Naprawianie nieautoryzowanych błędów zabezpieczeń Spring 401 w aplikacji React-Spring z uwierzytelnianiem niestandardowym

Rozwiązanie 1: Aktualizacja konfiguracji zabezpieczeń Spring na potrzeby zarządzania sesjami bezstanowymi

To podejście wykorzystuje bezstanową politykę sesji Spring Security w celu rozwiązania zarządzania sesjami w kontekście interfejsu API REST, który jest zoptymalizowany pod kątem aplikacji jednostronicowych (SPA), takich jak React. W tym miejscu dostosowujemy konfigurację SecurityFilterChain, aby pasowała do modelu bezstanowego interfejsu API REST.

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

Rozwiązanie 2: Niestandardowy filtr uwierzytelniający dla uwierzytelniania opartego na tokenie

W tym rozwiązaniu niestandardowy filtr uwierzytelnia użytkownika i dołącza token w nagłówku odpowiedzi. Filtr ten korzysta z uwierzytelniania opartego na tokenach, co jest idealne dla aplikacji RESTful i może bezproblemowo współpracować z 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);
    }
}

Rozwiązanie 3: Korekty klasy usług i odpowiedź na token

Ta implementacja usługi wysyła token JWT po pomyślnym zalogowaniu, wykorzystując konstrukcję modułową, aby zapewnić, że każdą funkcję można przetestować i ponownie wykorzystać w aplikacji.

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

Test jednostkowy pod kątem generowania tokenów i uwierzytelniania

Ten test JUnit zapewnia, że ​​uwierzytelnianie i generowanie tokenów działają poprawnie oraz sprawdza uwierzytelnianie w celu uzyskania dostępu do bezpiecznych zasobów.

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

Często zadawane pytania dotyczące problemów z niestandardowym uwierzytelnianiem Spring Security

1. Dlaczego nadal otrzymuję błąd 401 Nieautoryzowany, nawet po ustawieniu SecurityContextHolder?
2. Błąd 401 często występuje, jeśli kontekst uwierzytelniania nie utrzymuje się. Jeśli aplikacja jest bezstanowa, upewnij się, że używasz uwierzytelniania opartego na tokenach.
3. Jak włączyć zarządzanie sesjami bezstanowymi w Spring Security?
4. Ustawić SessionCreationPolicy.STATELESS w twoim SecurityFilterChain aby zapewnić niezależne uwierzytelnienie każdego żądania.
5. Jaka jest rola DaoAuthenticationProvider w niestandardowym uwierzytelnianiu?
6. The DaoAuthenticationProvider weryfikuje poświadczenia użytkownika w oparciu o bazę danych i koduje hasła w celu bezpiecznego uwierzytelnienia.
7. Czy mogę używać tokenów JWT do zarządzania sesjami w Spring Security?
8. Tak, tokeny JWT są idealne do zastosowań bezstanowych. Wygeneruj token po uwierzytelnieniu i umieść go w nagłówku dla kolejnych żądań.
9. W jaki sposób ochrona CSRF wpływa na bezstanowe interfejsy API?
10. Ochrona CSRF jest zwykle wyłączona w przypadku używania bezstanowych interfejsów API csrf().disable() ponieważ nie jest to konieczne w przypadku interfejsów API bez sesji.
11. Co się stanie, jeśli chcę zezwolić na publiczny dostęp do niektórych punktów końcowych, na przykład logowanie lub rejestracja?
12. Używać authorizeHttpRequests i określ punkty końcowe, które powinny być dostępne bez użycia uwierzytelniania permitAll().
13. Jak przechowywać tokeny po stronie klienta za pomocą React?
14. Przechowuj tokeny w localStorage Lub sessionStorage, a następnie umieść je w nagłówku każdego żądania, aby mieć pewność, że backend może uwierzytelnić każde żądanie.
15. Czy wyłączenie CSRF dla interfejsów API jest bezpieczne?
16. Wyłączenie CSRF dla interfejsów API jest bezpieczne, jeśli Twoja aplikacja opiera się na tokenach lub nie korzysta z plików cookie, ponieważ CSRF chroni głównie przed atakami opartymi na plikach cookie.
17. Jaka jest funkcja OncePerRequestFilter w niestandardowym uwierzytelnianiu?
18. Ten filtr jest wykonywany tylko raz na żądanie, zapewniając spójne zastosowanie logiki uwierzytelniania bez zbędnych kontroli w cyklu żądania.
19. Dlaczego mój token uwierzytelniający może nie zostać rozpoznany na różnych punktach końcowych?
20. Upewnij się, że ustawiłeś token w nagłówku każdego żądania i potwierdź, że jest on poprawnie zweryfikowany na serwerze, stosując spójny proces weryfikacji tokena.
21. Jak mogę przetestować moją konfigurację Spring Security?
22. Używać MockMvc w testach, aby symulować żądania, sprawdzić odpowiedzi uwierzytelniające i sprawdzić, czy chronione punkty końcowe są dostępne tylko po zalogowaniu.

Ostatnie przemyślenia na temat rozwiązywania błędów 401 w niestandardowym uwierzytelnianiu Spring Security

Pomyślne zabezpieczenie aplikacji opartej na Springu za pomocą niestandardowej strony logowania wymaga starannej konfiguracji, szczególnie w przypadku korzystania z sesji bezstanowych lub podejść opartych na tokenach. Podczas integracji z frontendem React upewnienie się, że konfiguracja zabezpieczeń jest zgodna z zasadami RESTful i bezstanowymi, może pomóc uniknąć problemów z sesją.

Od modyfikowania Łańcuch filtrów bezpieczeństwa ustawienia implementacji przepływów opartych na tokenach, każde podejście odgrywa rolę w tworzeniu niezawodnej konfiguracji uwierzytelniania. Rozumiejąc zarządzanie sesjami, obsługę tokenów i SecurityContext, będziesz dobrze przygotowany do rozwiązywania nieautoryzowanych błędów 401 w aplikacjach Spring Security. 🔒