ਕਸਟਮ ਪ੍ਰਮਾਣੀਕਰਣ ਦੇ ਨਾਲ ਇੱਕ ਰੀਐਕਟ-ਸਪਰਿੰਗ ਐਪ ਵਿੱਚ 401 ਅਣਅਧਿਕਾਰਤ ਸਪਰਿੰਗ ਸੁਰੱਖਿਆ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ

ਹੱਲ 1: ਸਟੇਟਲੈਸ ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ ਲਈ ਬਸੰਤ ਸੁਰੱਖਿਆ ਸੰਰਚਨਾ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨਾ

ਇਹ ਪਹੁੰਚ ਇੱਕ REST API ਸੰਦਰਭ ਵਿੱਚ ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਬਸੰਤ ਸੁਰੱਖਿਆ ਦੀ ਰਾਜ ਰਹਿਤ ਸੈਸ਼ਨ ਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜੋ ਕਿ ਪ੍ਰਤੀਕਿਰਿਆ ਵਰਗੇ ਸਿੰਗਲ-ਪੇਜ ਐਪਲੀਕੇਸ਼ਨਾਂ (SPAs) ਲਈ ਅਨੁਕੂਲਿਤ ਹੈ। ਇੱਥੇ, ਅਸੀਂ ਇੱਕ REST API ਸਟੇਟਲੈੱਸ ਮਾਡਲ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ SecurityFilterChain ਸੰਰਚਨਾ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਦੇ ਹਾਂ।

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())  // Disable CSRF for REST APIs
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/user/register", "/user/login").permitAll()
            .anyRequest().authenticated()
        )
        .httpBasic(Customizer.withDefaults())
        .sessionManagement(session ->
            session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        )
        .build();
}

ਹੱਲ 2: ਟੋਕਨ-ਅਧਾਰਿਤ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਕਸਟਮ ਪ੍ਰਮਾਣਿਕਤਾ ਫਿਲਟਰ

ਇਸ ਹੱਲ ਵਿੱਚ, ਇੱਕ ਕਸਟਮ ਫਿਲਟਰ ਉਪਭੋਗਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਜਵਾਬ ਸਿਰਲੇਖ ਵਿੱਚ ਇੱਕ ਟੋਕਨ ਨੱਥੀ ਕਰਦਾ ਹੈ। ਇਹ ਫਿਲਟਰ ਟੋਕਨ-ਅਧਾਰਿਤ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ RESTful ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਆਦਰਸ਼ ਹੈ ਅਤੇ React ਨਾਲ ਸਹਿਜੇ ਹੀ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।

@Component
public class CustomAuthFilter extends OncePerRequestFilter {
    private final AuthenticationManager authenticationManager;
    public CustomAuthFilter(AuthenticationManager authManager) {
        this.authenticationManager = authManager;
    }
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain)
                                    throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            Authentication authentication = new UsernamePasswordAuthenticationToken(token, null);
            Authentication authResult = authenticationManager.authenticate(authentication);
            SecurityContextHolder.getContext().setAuthentication(authResult);
        }
        filterChain.doFilter(request, response);
    }
}

ਹੱਲ 3: ਸਰਵਿਸ ਕਲਾਸ ਐਡਜਸਟਮੈਂਟਸ ਅਤੇ ਟੋਕਨ ਰਿਸਪਾਂਸ

ਇਹ ਸੇਵਾ ਲਾਗੂਕਰਨ ਸਫਲਤਾਪੂਰਵਕ ਲੌਗਇਨ ਕਰਨ 'ਤੇ JWT ਟੋਕਨ ਭੇਜਦਾ ਹੈ, ਮਾਡਿਊਲਰ ਡਿਜ਼ਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਹਰੇਕ ਫੰਕਸ਼ਨ ਟੈਸਟਯੋਗ ਹੈ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਹੈ।

@Service
public class AuthenticationService {
    private final AuthenticationManager authenticationManager;
    private final TokenProvider tokenProvider; // Custom class for generating JWTs
    public AuthenticationService(AuthenticationManager authenticationManager,
                                 TokenProvider tokenProvider) {
        this.authenticationManager = authenticationManager;
        this.tokenProvider = tokenProvider;
    }
    public String authenticateAndGenerateToken(LoginDTO loginDTO) {
        Authentication authentication = authenticationManager
            .authenticate(new UsernamePasswordAuthenticationToken(loginDTO.getUserName(),
                                                                loginDTO.getPassword()));
        SecurityContextHolder.getContext().setAuthentication(authentication);
        return tokenProvider.createToken(authentication);
    }
}

ਟੋਕਨ ਜਨਰੇਸ਼ਨ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

ਇਹ JUnit ਟੈਸਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਟੋਕਨ ਜਨਰੇਸ਼ਨ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ ਅਤੇ ਸੁਰੱਖਿਅਤ ਸਰੋਤਾਂ ਤੱਕ ਪਹੁੰਚਣ ਲਈ ਪ੍ਰਮਾਣਿਕਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦੇ ਹਨ।

@SpringBootTest
@AutoConfigureMockMvc
public class AuthenticationServiceTest {
    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private AuthenticationService authenticationService;
    @Test
    public void testAuthenticateAndGenerateToken() throws Exception {
        LoginDTO loginDTO = new LoginDTO("user", "password");
        String token = authenticationService.authenticateAndGenerateToken(loginDTO);
        mockMvc.perform(MockMvcRequestBuilders.post("/login")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\\"userName\\":\\"user\\", \\"password\\":\\"password\\"}"))
                .andExpect(status().isOk())
                .andExpect(header().exists("Authorization"))
                .andExpect(content().string("Successfully Authenticated"));
    }
}

ਬਸੰਤ ਸੁਰੱਖਿਆ ਕਸਟਮ ਪ੍ਰਮਾਣੀਕਰਨ ਮੁੱਦਿਆਂ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. ਸੈੱਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਵੀ ਮੈਨੂੰ 401 ਅਣਅਧਿਕਾਰਤ ਗਲਤੀ ਕਿਉਂ ਮਿਲਦੀ ਹੈ SecurityContextHolder?
2. 401 ਗਲਤੀ ਅਕਸਰ ਵਾਪਰਦੀ ਹੈ ਜੇਕਰ ਪ੍ਰਮਾਣੀਕਰਨ ਸੰਦਰਭ ਜਾਰੀ ਨਹੀਂ ਰਹਿੰਦਾ ਹੈ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਟੋਕਨ-ਅਧਾਰਿਤ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ ਜੇਕਰ ਤੁਹਾਡੀ ਅਰਜ਼ੀ ਸਟੇਟਲੈੱਸ ਹੈ।
3. ਮੈਂ ਬਸੰਤ ਸੁਰੱਖਿਆ ਵਿੱਚ ਰਾਜ ਰਹਿਤ ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ ਨੂੰ ਕਿਵੇਂ ਸਮਰੱਥ ਕਰਾਂ?
4. ਸੈੱਟ ਕਰੋ SessionCreationPolicy.STATELESS ਤੁਹਾਡੇ ਵਿੱਚ SecurityFilterChain ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਹਰੇਕ ਬੇਨਤੀ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਪ੍ਰਮਾਣਿਤ ਹੈ।
5. ਦੀ ਭੂਮਿਕਾ ਕੀ ਹੈ DaoAuthenticationProvider ਕਸਟਮ ਪ੍ਰਮਾਣਿਕਤਾ ਵਿੱਚ?
6. ਦ DaoAuthenticationProvider ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਦੇ ਵਿਰੁੱਧ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਅਤ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਪਾਸਵਰਡਾਂ ਨੂੰ ਏਨਕੋਡ ਕਰਦਾ ਹੈ।
7. ਕੀ ਮੈਂ ਬਸੰਤ ਸੁਰੱਖਿਆ ਵਿੱਚ ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ ਲਈ JWT ਟੋਕਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?
8. ਹਾਂ, JWT ਟੋਕਨ ਸਟੇਟਲੈੱਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਆਦਰਸ਼ ਹਨ। ਪ੍ਰਮਾਣਿਕਤਾ ਤੋਂ ਬਾਅਦ ਇੱਕ ਟੋਕਨ ਤਿਆਰ ਕਰੋ ਅਤੇ ਇਸ ਨੂੰ ਅਗਲੀਆਂ ਬੇਨਤੀਆਂ ਲਈ ਸਿਰਲੇਖ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ।
9. CSRF ਸੁਰੱਖਿਆ ਸਟੇਟਲੈੱਸ API ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ?
10. CSRF ਸੁਰੱਖਿਆ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤਦੇ ਹੋਏ ਸਟੇਟਲੈੱਸ API ਵਿੱਚ ਅਸਮਰੱਥ ਹੁੰਦੀ ਹੈ csrf().disable() ਕਿਉਂਕਿ ਸੈਸ਼ਨਾਂ ਤੋਂ ਬਿਨਾਂ API ਲਈ ਇਹ ਬੇਲੋੜੀ ਹੈ।
11. ਜੇ ਮੈਂ ਲੌਗਇਨ ਜਾਂ ਰਜਿਸਟਰ ਵਰਗੇ ਕੁਝ ਅੰਤਮ ਬਿੰਦੂਆਂ ਤੱਕ ਜਨਤਕ ਪਹੁੰਚ ਦੀ ਇਜਾਜ਼ਤ ਦੇਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਤਾਂ ਕੀ ਹੋਵੇਗਾ?
12. ਵਰਤੋ authorizeHttpRequests ਅਤੇ ਅੰਤਮ ਬਿੰਦੂ ਨਿਰਧਾਰਤ ਕਰੋ ਜੋ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਪਹੁੰਚਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ permitAll().
13. ਮੈਂ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਨਾਲ ਕਲਾਇੰਟ ਸਾਈਡ 'ਤੇ ਟੋਕਨਾਂ ਨੂੰ ਕਿਵੇਂ ਸਟੋਰ ਕਰਾਂ?
14. ਵਿੱਚ ਟੋਕਨ ਸਟੋਰ ਕਰੋ localStorage ਜਾਂ sessionStorage, ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਹਰੇਕ ਬੇਨਤੀ ਦੇ ਸਿਰਲੇਖ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ ਕਿ ਬੈਕਐਂਡ ਹਰੇਕ ਬੇਨਤੀ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰ ਸਕਦਾ ਹੈ।
15. ਕੀ APIs ਲਈ CSRF ਨੂੰ ਅਯੋਗ ਕਰਨਾ ਸੁਰੱਖਿਅਤ ਹੈ?
16. API ਲਈ CSRF ਨੂੰ ਅਸਮਰੱਥ ਕਰਨਾ ਸੁਰੱਖਿਅਤ ਹੈ ਜੇਕਰ ਤੁਹਾਡੀ ਐਪ ਟੋਕਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਜਾਂ ਕੂਕੀਜ਼ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੀ ਹੈ, ਕਿਉਂਕਿ CSRF ਮੁੱਖ ਤੌਰ 'ਤੇ ਕੂਕੀ-ਆਧਾਰਿਤ ਹਮਲਿਆਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ।
17. ਦਾ ਕੰਮ ਕੀ ਹੈ OncePerRequestFilter ਕਸਟਮ ਪ੍ਰਮਾਣਿਕਤਾ ਵਿੱਚ?
18. ਇਹ ਫਿਲਟਰ ਪ੍ਰਤੀ ਬੇਨਤੀ ਸਿਰਫ ਇੱਕ ਵਾਰ ਚਲਾਉਂਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਬੇਨਤੀ ਚੱਕਰ ਵਿੱਚ ਬੇਲੋੜੀਆਂ ਜਾਂਚਾਂ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰਮਾਣੀਕਰਨ ਤਰਕ ਲਗਾਤਾਰ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।
19. ਮੇਰੇ ਪ੍ਰਮਾਣਿਕਤਾ ਟੋਕਨ ਨੂੰ ਵੱਖ-ਵੱਖ ਅੰਤਮ ਬਿੰਦੂਆਂ ਵਿੱਚ ਕਿਉਂ ਨਹੀਂ ਪਛਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ?
20. ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਤੁਸੀਂ ਹਰੇਕ ਬੇਨਤੀ ਦੇ ਸਿਰਲੇਖ ਵਿੱਚ ਟੋਕਨ ਸੈਟ ਕੀਤਾ ਹੈ ਅਤੇ ਇੱਕ ਨਿਰੰਤਰ ਟੋਕਨ ਤਸਦੀਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਰਵਰ 'ਤੇ ਇਹ ਸਹੀ ਤਰ੍ਹਾਂ ਪ੍ਰਮਾਣਿਤ ਹੋਣ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
21. ਮੈਂ ਆਪਣੀ ਬਸੰਤ ਸੁਰੱਖਿਆ ਸੰਰਚਨਾ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
22. ਵਰਤੋ MockMvc ਬੇਨਤੀਆਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਟੈਸਟਾਂ ਵਿੱਚ, ਪ੍ਰਮਾਣੀਕਰਨ ਜਵਾਬਾਂ ਦੀ ਜਾਂਚ ਕਰੋ, ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰੋ ਕਿ ਸੁਰੱਖਿਅਤ ਅੰਤਮ ਬਿੰਦੂ ਸਿਰਫ਼ ਲੌਗਇਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਹੀ ਪਹੁੰਚਯੋਗ ਹਨ।

ਕਸਟਮ ਸਪਰਿੰਗ ਸੁਰੱਖਿਆ ਪ੍ਰਮਾਣੀਕਰਨ ਵਿੱਚ 401 ਤਰੁੱਟੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਬਾਰੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਇੱਕ ਕਸਟਮ ਲੌਗਇਨ ਪੰਨੇ ਦੇ ਨਾਲ ਇੱਕ ਸਪਰਿੰਗ-ਅਧਾਰਿਤ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਧਿਆਨ ਨਾਲ ਸੰਰਚਨਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇ ਸਟੇਟਲੈਸ ਸੈਸ਼ਨਾਂ ਜਾਂ ਟੋਕਨ-ਅਧਾਰਿਤ ਪਹੁੰਚਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। ਰਿਐਕਟ ਫਰੰਟਐਂਡ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨਾ ਕਿ ਤੁਹਾਡੀ ਸੁਰੱਖਿਆ ਸੰਰਚਨਾ RESTful, ਸਟੇਟਲੈਸ ਸਿਧਾਂਤਾਂ ਨਾਲ ਇਕਸਾਰ ਹੈ ਸੈਸ਼ਨ ਦੇ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀ ਹੈ।

ਸੋਧਣ ਤੋਂ ਸੁਰੱਖਿਆ ਫਿਲਟਰਚੇਨ ਟੋਕਨ-ਆਧਾਰਿਤ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸੈਟਿੰਗਾਂ, ਹਰੇਕ ਪਹੁੰਚ ਇੱਕ ਭਰੋਸੇਯੋਗ ਪ੍ਰਮਾਣੀਕਰਨ ਸੈੱਟਅੱਪ ਬਣਾਉਣ ਵਿੱਚ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੀ ਹੈ। ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ, ਟੋਕਨ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਸੁਰੱਖਿਆ ਸੰਦਰਭ ਨੂੰ ਸਮਝ ਕੇ, ਤੁਸੀਂ ਆਪਣੀਆਂ ਸਪਰਿੰਗ ਸੁਰੱਖਿਆ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ 401 ਅਣਅਧਿਕਾਰਤ ਤਰੁੱਟੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਹੋਵੋਗੇ। 🔒