ಕಸ್ಟಮ್ ದೃಢೀಕರಣದೊಂದಿಗೆ ರಿಯಾಕ್ಟ್-ಸ್ಪ್ರಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ 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 ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ ಮತ್ತು ರಿಯಾಕ್ಟ್‌ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕೆಲಸ ಮಾಡಬಹುದು.

@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);
    }
}

ಟೋಕನ್ ಜನರೇಷನ್ ಮತ್ತು ದೃಢೀಕರಣಕ್ಕಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆ

ಈ ಜುನಿಟ್ ಪರೀಕ್ಷೆಯು ದೃಢೀಕರಣ ಮತ್ತು ಟೋಕನ್ ಉತ್ಪಾದನೆಯು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಸುರಕ್ಷಿತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ದೃಢೀಕರಣವನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

@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. API ಗಳಿಗಾಗಿ CSRF ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದು ಸುರಕ್ಷಿತವೇ?
16. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಟೋಕನ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ ಅಥವಾ ಕುಕೀಗಳನ್ನು ಬಳಸದಿದ್ದರೆ API ಗಳಿಗಾಗಿ CSRF ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದು ಸುರಕ್ಷಿತವಾಗಿದೆ, ಏಕೆಂದರೆ CSRF ಮುಖ್ಯವಾಗಿ ಕುಕೀ-ಆಧಾರಿತ ದಾಳಿಯಿಂದ ರಕ್ಷಿಸುತ್ತದೆ.
17. ಕಾರ್ಯವೇನು OncePerRequestFilter ಕಸ್ಟಮ್ ದೃಢೀಕರಣದಲ್ಲಿ?
18. ಈ ಫಿಲ್ಟರ್ ಪ್ರತಿ ವಿನಂತಿಯನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ವಿನಂತಿಯ ಚಕ್ರದಲ್ಲಿ ಅನಗತ್ಯ ಪರಿಶೀಲನೆಗಳಿಲ್ಲದೆ ದೃಢೀಕರಣ ತರ್ಕವು ಸ್ಥಿರವಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
19. ವಿವಿಧ ಅಂತಿಮ ಬಿಂದುಗಳಲ್ಲಿ ನನ್ನ ದೃಢೀಕರಣ ಟೋಕನ್ ಅನ್ನು ಏಕೆ ಗುರುತಿಸಲಾಗುವುದಿಲ್ಲ?
20. ಪ್ರತಿ ವಿನಂತಿಯ ಶಿರೋಲೇಖದಲ್ಲಿ ನೀವು ಟೋಕನ್ ಅನ್ನು ಹೊಂದಿಸಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಸ್ಥಿರವಾದ ಟೋಕನ್ ಪರಿಶೀಲನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸರ್ವರ್‌ನಲ್ಲಿ ಅದನ್ನು ಸರಿಯಾಗಿ ಮೌಲ್ಯೀಕರಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
21. ನನ್ನ ಸ್ಪ್ರಿಂಗ್ ಸೆಕ್ಯುರಿಟಿ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಾನು ಹೇಗೆ ಪರೀಕ್ಷಿಸಬಹುದು?
22. ಬಳಸಿ MockMvc ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ವಿನಂತಿಗಳನ್ನು ಅನುಕರಿಸಲು, ದೃಢೀಕರಣದ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಸಂರಕ್ಷಿತ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಲಾಗಿನ್ ಮಾಡಿದ ನಂತರ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು ಎಂದು ಮೌಲ್ಯೀಕರಿಸಿ.

ಕಸ್ಟಮ್ ಸ್ಪ್ರಿಂಗ್ ಭದ್ರತಾ ದೃಢೀಕರಣದಲ್ಲಿ 401 ದೋಷಗಳನ್ನು ಪರಿಹರಿಸುವ ಅಂತಿಮ ಆಲೋಚನೆಗಳು

ಕಸ್ಟಮ್ ಲಾಗಿನ್ ಪುಟದೊಂದಿಗೆ ಸ್ಪ್ರಿಂಗ್-ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸುರಕ್ಷಿತವಾಗಿರಿಸಲು ಎಚ್ಚರಿಕೆಯಿಂದ ಕಾನ್ಫಿಗರೇಶನ್ ಅಗತ್ಯವಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಸ್ಥಿತಿಯಿಲ್ಲದ ಅವಧಿಗಳು ಅಥವಾ ಟೋಕನ್-ಆಧಾರಿತ ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ. ರಿಯಾಕ್ಟ್ ಮುಂಭಾಗದೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಾಗ, ನಿಮ್ಮ ಭದ್ರತಾ ಸಂರಚನೆಯು RESTful, ಸ್ಥಿತಿಯಿಲ್ಲದ ತತ್ವಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅಧಿವೇಶನ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಮಾರ್ಪಡಿಸುವಿಕೆಯಿಂದ ಸೆಕ್ಯುರಿಟಿಫಿಲ್ಟರ್‌ಚೈನ್ ಟೋಕನ್-ಆಧಾರಿತ ಹರಿವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸೆಟ್ಟಿಂಗ್‌ಗಳು, ಪ್ರತಿ ವಿಧಾನವು ವಿಶ್ವಾಸಾರ್ಹ ದೃಢೀಕರಣ ಸೆಟಪ್ ಅನ್ನು ರಚಿಸುವಲ್ಲಿ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ. ಅಧಿವೇಶನ ನಿರ್ವಹಣೆ, ಟೋಕನ್ ನಿರ್ವಹಣೆ ಮತ್ತು ಭದ್ರತಾ ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಸ್ಪ್ರಿಂಗ್ ಸೆಕ್ಯುರಿಟಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ 401 ಅನಧಿಕೃತ ದೋಷಗಳನ್ನು ಪರಿಹರಿಸಲು ನೀವು ಸುಸಜ್ಜಿತರಾಗಿರುತ್ತೀರಿ. 🔒