தனிப்பயன் அங்கீகாரத்துடன் ரியாக்ட்-ஸ்பிரிங் பயன்பாட்டில் 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);
    }
}

டோக்கன் உருவாக்கம் மற்றும் அங்கீகாரத்திற்கான அலகு சோதனை

இந்த ஜூனிட் சோதனையானது அங்கீகரிப்பு மற்றும் டோக்கன் உருவாக்கம் சரியாகச் செயல்படுவதையும், பாதுகாப்பான ஆதாரங்களை அணுகுவதற்கான அங்கீகாரத்தை உறுதிப்படுத்துவதையும் உறுதி செய்கிறது.

@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. CSRF முக்கியமாக குக்கீ அடிப்படையிலான தாக்குதல்களுக்கு எதிராகப் பாதுகாப்பதால், உங்கள் ஆப்ஸ் டோக்கன்களை நம்பியிருந்தாலோ அல்லது குக்கீகளைப் பயன்படுத்தாமலோ APIகளுக்கான CSRFஐ முடக்குவது பாதுகாப்பானது.
17. செயல்பாடு என்ன OncePerRequestFilter தனிப்பயன் அங்கீகாரத்தில்?
18. இந்த வடிப்பான் ஒரு கோரிக்கைக்கு ஒருமுறை மட்டுமே செயல்படுத்துகிறது, கோரிக்கை சுழற்சியில் தேவையற்ற சோதனைகள் இல்லாமல் அங்கீகார தர்க்கம் தொடர்ந்து பொருந்தும் என்பதை உறுதிப்படுத்துகிறது.
19. எனது அங்கீகார டோக்கன் வெவ்வேறு இறுதிப்புள்ளிகளில் ஏன் அங்கீகரிக்கப்படாமல் போகலாம்?
20. ஒவ்வொரு கோரிக்கையின் தலைப்பிலும் டோக்கனை அமைத்திருப்பதை உறுதிசெய்து, நிலையான டோக்கன் சரிபார்ப்பு செயல்முறையைப் பயன்படுத்தி சர்வரில் அது சரியாகச் சரிபார்க்கப்பட்டதா என்பதை உறுதிப்படுத்தவும்.
21. எனது ஸ்பிரிங் பாதுகாப்பு உள்ளமைவை நான் எவ்வாறு சோதிப்பது?
22. பயன்படுத்தவும் MockMvc உங்கள் சோதனைகளில் கோரிக்கைகளை உருவகப்படுத்தவும், அங்கீகார பதில்களைச் சரிபார்க்கவும் மற்றும் பாதுகாக்கப்பட்ட இறுதிப்புள்ளிகளை உள்நுழைந்த பிறகு மட்டுமே அணுக முடியும் என்பதை சரிபார்க்கவும்.

தனிப்பயன் வசந்த பாதுகாப்பு அங்கீகாரத்தில் 401 பிழைகளைத் தீர்ப்பதற்கான இறுதி எண்ணங்கள்

தனிப்பயன் உள்நுழைவுப் பக்கத்துடன் ஸ்பிரிங் அடிப்படையிலான பயன்பாட்டை வெற்றிகரமாகப் பாதுகாப்பதற்கு கவனமாக உள்ளமைவு தேவைப்படுகிறது, குறிப்பாக நிலையற்ற அமர்வுகள் அல்லது டோக்கன் அடிப்படையிலான அணுகுமுறைகளைப் பயன்படுத்தினால். ரியாக்ட் ஃபிரண்ட்டெண்டுடன் ஒருங்கிணைக்கும்போது, ​​உங்கள் பாதுகாப்பு உள்ளமைவு RESTful, நிலையற்ற கொள்கைகளுடன் சீரமைக்கப்படுவதை உறுதிசெய்தல் அமர்வு சிக்கல்களைத் தவிர்க்க உதவும்.

மாற்றியமைப்பதில் இருந்து பாதுகாப்பு வடிகட்டி சங்கிலி டோக்கன் அடிப்படையிலான ஓட்டங்களை செயல்படுத்துவதற்கான அமைப்புகள், ஒவ்வொரு அணுகுமுறையும் நம்பகமான அங்கீகார அமைப்பை உருவாக்குவதில் பங்கு வகிக்கிறது. அமர்வு மேலாண்மை, டோக்கன் கையாளுதல் மற்றும் பாதுகாப்புச் சூழல் ஆகியவற்றைப் புரிந்துகொள்வதன் மூலம், உங்கள் ஸ்பிரிங் செக்யூரிட்டி பயன்பாடுகளில் உள்ள 401 அங்கீகரிக்கப்படாத பிழைகளைத் தீர்க்க நீங்கள் நன்கு தயாராக இருப்பீர்கள். 🔒