Oprava 401 neautorizovaných chýb zabezpečenia Spring v aplikácii React-Spring s vlastnou autentizáciou

Riešenie 1: Aktualizácia jarnej bezpečnostnej konfigurácie pre správu bezstavových relácií

Tento prístup využíva bezstavovú politiku relácií Spring Security na riešenie správy relácií v kontexte REST API, ktoré je optimalizované pre jednostránkové aplikácie (SPA) ako React. Tu upravíme konfiguráciu SecurityFilterChain tak, aby zodpovedala bezstavovému modelu REST API.

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

Riešenie 2: Vlastný overovací filter pre autentizáciu na základe tokenov

V tomto riešení vlastný filter autentifikuje používateľa a pripojí token do hlavičky odpovede. Tento filter využíva autentifikáciu založenú na tokenoch, ktorá je ideálna pre aplikácie RESTful a môže bezproblémovo fungovať s Reactom.

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

Riešenie 3: Úpravy servisnej triedy a odozva tokenu

Táto implementácia služby odošle token JWT pri úspešnom prihlásení pomocou modulárneho dizajnu, aby sa zabezpečilo, že každá funkcia bude testovateľná a opakovane použiteľná v celej aplikácii.

@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 jednotky na generovanie tokenov a autentifikáciu

Tento test JUnit zaisťuje, že overovanie a generovanie tokenov funguje správne a overuje overenie pre prístup k zabezpečeným zdrojom.

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

Bežné otázky o problémoch s vlastnou autentifikáciou Spring Security

1. Prečo sa mi stále zobrazuje chyba 401 Neoprávnené aj po nastavení SecurityContextHolder?
2. Chyba 401 sa často vyskytuje, ak kontext overovania nepretrvá. Uistite sa, že používate autentifikáciu na základe tokenov, ak je vaša aplikácia bez stavu.
3. Ako povolím správu relácií bez stavu v Spring Security?
4. Set SessionCreationPolicy.STATELESS v tvojom SecurityFilterChain zabezpečiť, aby bola každá požiadavka nezávisle overená.
5. Aká je úloha DaoAuthenticationProvider vo vlastnej autentifikácii?
6. The DaoAuthenticationProvider overí používateľské poverenia oproti vašej databáze a zakóduje heslá pre bezpečnú autentifikáciu.
7. Môžem použiť tokeny JWT na správu relácií v Spring Security?
8. Áno, tokeny JWT sú ideálne pre aplikácie bez štátnej príslušnosti. Po overení vygenerujte token a zahrňte ho do hlavičky pre následné požiadavky.
9. Ako ochrana CSRF ovplyvňuje bezstavové API?
10. Ochrana CSRF je zvyčajne zakázaná pri používaní bezstavových rozhraní API csrf().disable() pretože je to zbytočné pre API bez relácií.
11. Čo ak chcem povoliť verejný prístup k niektorým koncovým bodom, ako je prihlásenie alebo registrácia?
12. Použite authorizeHttpRequests a špecifikujte koncové body, ktoré by mali byť prístupné bez použitia autentifikácie permitAll().
13. Ako uložím tokeny na strane klienta pomocou React?
14. Uložte žetóny v localStorage alebo sessionStorage, potom ich zahrňte do hlavičky každej požiadavky, aby ste zabezpečili, že backend dokáže overiť každú požiadavku.
15. Je bezpečné zakázať CSRF pre API?
16. Zakázanie CSRF pre rozhrania API je bezpečné, ak sa vaša aplikácia spolieha na tokeny alebo nepoužíva súbory cookie, pretože CSRF chráni hlavne pred útokmi založenými na súboroch cookie.
17. Aká je funkcia OncePerRequestFilter vo vlastnej autentifikácii?
18. Tento filter sa vykoná iba raz na požiadavku, čím sa zabezpečí konzistentné uplatňovanie logiky autentifikácie bez nadbytočných kontrol v cykle požiadaviek.
19. Prečo nemusí byť môj autentifikačný token rozpoznaný v rôznych koncových bodoch?
20. Uistite sa, že ste token nastavili v hlavičke každej požiadavky a potvrdili, že je správne overený na serveri pomocou konzistentného procesu overovania tokenu.
21. Ako môžem otestovať svoju konfiguráciu Spring Security?
22. Použite MockMvc vo svojich testoch simulovať požiadavky, kontrolovať autentifikačné odpovede a overovať, že chránené koncové body sú prístupné len po prihlásení.

Záverečné myšlienky na vyriešenie 401 chýb vo vlastnej jarnej bezpečnostnej autentizácii

Úspešné zabezpečenie aplikácie založenej na pružine pomocou vlastnej prihlasovacej stránky si vyžaduje starostlivú konfiguráciu, najmä ak používate bezstavové relácie alebo prístupy založené na tokenoch. Pri integrácii s klientskym rozhraním React môže zaistenie, že vaša konfigurácia zabezpečenia je v súlade s princípmi RESTful, bez stavu, pomôcť vyhnúť sa problémom s reláciami.

Z úpravy SecurityFilterChain nastavenia na implementáciu tokov založených na tokenoch, každý prístup zohráva úlohu pri vytváraní spoľahlivého nastavenia autentifikácie. Po pochopení správy relácií, manipulácie s tokenmi a SecurityContext budete dobre vybavení na riešenie 401 neautorizovaných chýb vo vašich aplikáciách Spring Security. 🔒