[Framework] Problème avec Spring Security : Redirection vers la page de connexion lors de l'inscription

Bonjour à tous,

Je travaille actuellement sur une application Spring Boot en utilisant Spring Security pour l'authentification avec JWT. J'ai configuré des endpoints pour l'inscription et la connexion des utilisateurs. Cependant, je rencontre un problème où, lorsque j'essaie d'enregistrer un nouvel utilisateur, je suis automatiquement redirigé vers la page de connexion au lieu de rester sur la page d'inscription ou de recevoir une confirmation d'inscription.

Voici un aperçu de ma configuration :
Configuration de la sécurité :
J'ai autorisé l'accès aux endpoints /api/auth/register et /api/auth/login sans authentification.
J'utilise des sessions sans état (stateless) et j'ai désactivé la protection CSRF.
CORS est configuré pour autoriser les requêtes provenant de http://localhost:4200.
Contrôleur d'authentification :
Le contrôleur gère l'inscription et la connexion des utilisateurs en vérifiant les informations d'identification et en générant un token JWT lors de la connexion réussie.
Problème rencontré :
Malgré la configuration, toute tentative d'accéder à l'endpoint d'inscription me redirige automatiquement vers la page de connexion, comme si l'endpoint nécessitait une authentification, ce qui n'est pas le cas d'après ma configuration.
Code de configuration de la sécurité :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
package com.cognitiex.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import java.util.Collections;
import java.util.Arrays;
import org.springframework.http.HttpMethod;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import jakarta.servlet.http.HttpServletResponse;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth
                .requestMatchers(HttpMethod.POST, "/api/auth/register", "/api/auth/login").permitAll() // Autoriser register et login
                .anyRequest().authenticated() // Les autres requêtes nécessitent une authentification
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS) // Utiliser des sessions stateless
            )
            .cors(corsCustomizer -> corsCustomizer
                .configurationSource(request -> {
                    CorsConfiguration cors = new CorsConfiguration();
                    cors.setAllowedOrigins(Collections.singletonList("http://localhost:4200"));
                    cors.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
                    cors.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type"));
                    cors.setAllowCredentials(true);
                    return cors;
                })
            )
            .exceptionHandling(exceptionHandling -> exceptionHandling
                .authenticationEntryPoint((request, response, authException) -> {
                    System.out.println("Unauthenticated request - redirecting to login");
                    response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
                })
            );
 
        return http.build();
    }
}
Code du contrôleur:
 
package com.cognitiex.controllers;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import com.cognitiex.repositories.UserRepository;
import com.cognitiex.config.JwtUtil;
import com.cognitiex.models.User;
import com.cognitiex.models.AuthRequest;
import com.cognitiex.models.AuthResponse;
 
@RestController
@RequestMapping("/api/auth")
public class AuthController {
 
    @Autowired
    private UserRepository userRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @PostMapping("/register")
    public ResponseEntity<?> registerUser(@RequestBody User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        userRepository.save(user);
        return ResponseEntity.ok("User registered successfully");
    }
 
    @PostMapping("/login")
    public ResponseEntity<?> loginUser(@RequestBody AuthRequest authRequest) {
        User user = userRepository.findByUsername(authRequest.getUsername());
        if (user != null && passwordEncoder.matches(authRequest.getPassword(), user.getPassword())) {
            String token = jwtUtil.generateToken(user.getUsername());
            return ResponseEntity.ok(new AuthResponse(token));
        } else {
            return ResponseEntity.status(401).body("Invalid credentials");
        }
    }
}

Questions :
Ai-je manqué quelque chose dans ma configuration de sécurité ?
Y a-t-il une raison pour laquelle l'endpoint /api/auth/register pourrait toujours nécessiter une authentification malgré la configuration permitAll() ?
Merci d'avance pour votre aide !