Sécurité Spring du serveur d'autorisation Spring avec service de détails utilisateur personnalisé pour une authentification flexible basée sur les données-javaDidacticiel-php.cn

Serveur d'autorisation Spring

Le Spring Authorization Server est un framework conçu pour implémenter les spécifications OAuth 2.1 et OpenID Connect 1.0, ainsi que d'autres normes connexes. Construit sur Spring Security, il offre une base sécurisée, légère et personnalisable pour créer des fournisseurs d'identité compatibles avec les solutions OpenID Connect 1.0 et OAuth2 Authorization Server.

Liste des fonctionnalités

Qu’est-ce que Spring Security et comment ça marche ?

réponse courte
Spring Security est un cadre d'authentification et de contrôle d'accès puissant et hautement personnalisable. Il s'agit de la norme de facto pour sécuriser les applications basées sur Spring.

En son cœur, Spring Security est essentiellement un ensemble de filtres de servlets conçus pour améliorer votre application Web avec des fonctionnalités d'authentification et d'autorisation robustes.

Spring Security s'intègre également bien avec des frameworks comme Spring Web MVC ou Spring Boot, prenant en charge des normes telles que OAuth2 et SAML. Il génère automatiquement des interfaces de connexion et de déconnexion et protège votre application contre les vulnérabilités de sécurité courantes telles que CSRF.

Eh bien, ce n'est pas très utile, n'est-ce pas ?

Plongeons-nous dans la sécurité Web pour comprendre l'essentiel de son flux de travail de sécurité.

Pour devenir un expert Spring Security, vous devez d'abord maîtriser ces trois concepts fondamentaux :

Authentification
Autorisation
Filtres de servlets

Remarque - Ne contournez pas cette section ; il jette les bases de toutes les fonctionnalités de Spring Security.

Authentification

Vous devez accéder à votre compte bancaire en ligne pour vérifier votre solde ou effectuer une transaction. Cela se fait généralement en utilisant le nom d'utilisateur et le mot de passe

Utilisateur : "Je m'appelle John Doe. Mon nom d'utilisateur est : johndoe1985."
Système de la banque : "Veuillez vérifier votre identité. Quel est votre mot de passe ?"
Utilisateur : "Mon mot de passe est : secureB@nk2023."
Système de la banque : "Bienvenue, John Doe. Voici l'aperçu de votre compte."

Autorisation

Pour les applications de base, l'authentification seule peut suffire : une fois qu'un utilisateur se connecte, il a accès à toutes les zones de l'application.

Cependant, dans la plupart des applications, des autorisations ou des rôles sont en jeu.

Utilisateur : "Laissez-moi jouer avec cette transaction…."
Système de la banque : "Une seconde, je dois d'abord vérifier vos autorisations…..oui M. John Doe, vous avez le bon niveau d'autorisation. Profitez-en."
Utilisateur : "Je vais transférer 1M ha ha ha … Je plaisante, je plaisante"

Filtres de servlets

Maintenant, explorons les filtres de servlet. Quel est leur rapport avec l'authentification et l'autorisation ?

Pourquoi utiliser les filtres servlet ?
Chaque application Web Spring s'articule autour d'un seul servlet : le fidèle DispatcherServlet. Son rôle principal est d'acheminer les requêtes HTTP entrantes (telles que celles provenant d'un navigateur) vers le @Controller ou @RestController approprié pour leur traitement.

Voici le problème : le DispatcherServlet lui-même n'a aucune fonctionnalité de sécurité intégrée, et vous ne souhaitez probablement pas gérer les en-têtes HTTP Basic Auth bruts directement dans vos @Controllers. Idéalement, l'authentification et l'autorisation devraient être prises en charge avant même qu'une demande n'atteigne vos @Controllers

Heureusement, dans l'environnement Web Java, vous pouvez y parvenir en plaçant des filtres avant les servlets. Cela signifie que vous pouvez envisager de créer un SecurityFilter et de le configurer dans votre Tomcat (conteneur de servlet/serveur d'applications) pour intercepter et traiter chaque requête HTTP entrante avant qu'elle n'atteigne votre servlet.

Security context

Un SecurityFilter a environ 4 tâches

Tout d'abord, le filtre doit extraire un nom d'utilisateur/mot de passe de la requête. Cela peut être via un en-tête HTTP Basic Auth, ou des champs de formulaire, ou un cookie, etc.
Ensuite, le filtre doit valider cette combinaison nom d'utilisateur/mot de passe par rapport à quelque chose, comme une base de données.
Le filtre doit vérifier, après une authentification réussie, que l'utilisateur est autorisé à accéder à l'URI demandé.
Si la requête survit à toutes ces vérifications, alors le filtre peut et la requête passe par votre DispatcherServlet, c'est à dire vos @Controllers.

Chaînes de filtres

En pratique, nous décomposions un seul filtre en plusieurs, que vous relieriez ensuite entre eux.

Voici comment une requête HTTP entrante serait acheminée :

Tout d'abord, il passe par un LoginMethodFilter...
Ensuite, il passe par un AuthenticationFilter...
Ensuite, il passe à un AuthorizationFilter...
Et enfin, il atteint votre servlet.

Cette configuration est connue sous le nom de FilterChain.

En utilisant un filtre (ou une chaîne de filtres), vous pouvez gérer efficacement tous les défis d'authentification et d'autorisation dans votre application sans altérer l'implémentation de base de vos @RestControllers ou @Controllers.

DefaultSecurityFilterChain de Spring

Imaginez que vous avez correctement configuré Spring Security et démarré votre application Web. Vous remarquerez un message de journal qui ressemble à ceci :

2020-02-25 10:24:27.875  INFO 11116 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@46320c9a, org.springframework.security.web.context.SecurityContextPersistenceFilter@4d98e41b, org.springframework.security.web.header.HeaderWriterFilter@52bd9a27, org.springframework.security.web.csrf.CsrfFilter@51c65a43, org.springframework.security.web.authentication.logout.LogoutFilter@124d26ba, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@61e86192, org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@10980560, org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@32256e68, org.springframework.security.web.authentication.www.BasicAuthenticationFilter@52d0f583, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@5696c927, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@5f025000, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5e7abaf7, org.springframework.security.web.session.SessionManagementFilter@681c0ae6, org.springframework.security.web.access.ExceptionTranslationFilter@15639d09, org.springframework.security.web.access.intercept.FilterSecurityInterceptor@4f7be6c8]|

Copier après la connexion

L'expansion de cette seule ligne révèle que Spring Security n'ajoute pas seulement un filtre, il met en place une chaîne de filtres complète avec 15 (!) filtres différents.

Lorsqu'une requête HTTP arrive, elle passe par chacun de ces 15 filtres en séquence avant d'atteindre finalement vos @RestControllers. L'ordre de ces filtres est crucial, car la demande est traitée du haut de la chaîne vers le bas.

security chain

Analyse de la FilterChain de Spring

Plonger dans les détails de chaque filtre de la chaîne nous mènerait trop loin, mais voici des explications pour quelques filtres clés. Pour une compréhension plus approfondie des autres, vous pouvez explorer le code source de Spring Security.

BasicAuthenticationFilter : essaie de trouver un en-tête HTTP d'authentification de base sur la requête et, s'il est trouvé, essaie d'authentifier l'utilisateur avec le nom d'utilisateur et le mot de passe de l'en-tête.
UsernamePasswordAuthenticationFilter : essaie de trouver un paramètre de demande de nom d'utilisateur/mot de passe/corps POST et s'il est trouvé, essaie d'authentifier l'utilisateur avec ces valeurs.
DefaultLoginPageGeneratingFilter : génère une page de connexion pour vous, si vous ne désactivez pas explicitement cette fonctionnalité. CE filtre est la raison pour laquelle vous obtenez une page de connexion par défaut lors de l'activation de Spring Security.
DefaultLogoutPageGeneratingFilter : génère une page de déconnexion pour vous, si vous ne désactivez pas explicitement cette fonctionnalité.
FilterSecurityInterceptor : Effectue votre autorisation.

Blague

Question - Pourquoi la requête HTTP a-t-elle été interrompue avec le filtre Spring Security ?
Réponse - Parce qu'à chaque fois qu'il essayait de se rapprocher, le filtre disait : "Attends ! Laisse-moi d'abord te vérifier !" ?

Ouais, pause ........ Whoa, attends... c'était beaucoup trop de discours de sécurité pour une seule fois !

Configurer le serveur d'autorisation Spring

Le moyen le plus simple de commencer à utiliser Spring Authorization Server consiste à créer une application basée sur Spring Boot. Vous pouvez utiliser start.spring.io pour générer un projet de base.

La seule dépendance requise est l'implémentation("org.springframework.boot:spring-boot-starter-oauth2-authorization-server")

Nous en ajouterons deux autres pour faire plus d'action

2020-02-25 10:24:27.875  INFO 11116 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@46320c9a, org.springframework.security.web.context.SecurityContextPersistenceFilter@4d98e41b, org.springframework.security.web.header.HeaderWriterFilter@52bd9a27, org.springframework.security.web.csrf.CsrfFilter@51c65a43, org.springframework.security.web.authentication.logout.LogoutFilter@124d26ba, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@61e86192, org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@10980560, org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@32256e68, org.springframework.security.web.authentication.www.BasicAuthenticationFilter@52d0f583, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@5696c927, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@5f025000, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5e7abaf7, org.springframework.security.web.session.SessionManagementFilter@681c0ae6, org.springframework.security.web.access.ExceptionTranslationFilter@15639d09, org.springframework.security.web.access.intercept.FilterSecurityInterceptor@4f7be6c8]|

Copier après la connexion

Comment configurer Spring Security

Avec les dernières versions de Spring Security et/ou Spring Boot, la façon de configurer Spring Security consiste à avoir une classe qui : Est annotée avec @EnableWebSecurity.

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-oauth2-authorization-server")
    implementation("org.springframework.boot:spring-boot-starter-webflux")
    implementation("org.springframework.boot:spring-boot-starter-validation")
}

Copier après la connexion

(1) : Une chaîne de filtres Spring Security pour les points de terminaison du protocole.
(2) : Une chaîne de filtres Spring Security pour l'authentification.
(3) : Une instance de com.nimbusds.jose.jwk.source.JWKSource pour signer les jetons d'accès.
(4) : Une instance de JwtDecoder pour décoder les jetons d'accès signés.
(5) : Une instance de AuthorizationServerSettings pour configurer Spring Authorization Server.

Configurons CORS pour autoriser certaines URL vers notre application

2020-02-25 10:24:27.875  INFO 11116 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@46320c9a, org.springframework.security.web.context.SecurityContextPersistenceFilter@4d98e41b, org.springframework.security.web.header.HeaderWriterFilter@52bd9a27, org.springframework.security.web.csrf.CsrfFilter@51c65a43, org.springframework.security.web.authentication.logout.LogoutFilter@124d26ba, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@61e86192, org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@10980560, org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@32256e68, org.springframework.security.web.authentication.www.BasicAuthenticationFilter@52d0f583, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@5696c927, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@5f025000, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5e7abaf7, org.springframework.security.web.session.SessionManagementFilter@681c0ae6, org.springframework.security.web.access.ExceptionTranslationFilter@15639d09, org.springframework.security.web.access.intercept.FilterSecurityInterceptor@4f7be6c8]|

Copier après la connexion

CorsConfiguration
Cette classe est utilisée pour définir les règles CORS. Dans ce cas :

addAllowedOrigin("http://localhost:3000/") : autorise les requêtes de http://localhost:3000. Ceci est utile pour le développement local lorsque votre interface s'exécute sur un port différent. En production, remplacez-le par vos domaines réels.
addAllowedMethod("*") : autorise toutes les méthodes HTTP (par exemple, GET, POST, PUT, DELETE, etc.).
addAllowedHeader("*") : autorise tous les en-têtes HTTP dans les requêtes.

UrlBasedCorsConfigurationSource

Une classe qui mappe les modèles d'URL (comme /**) à des configurations CORS spécifiques.
registerCorsConfiguration("/", configuration) : applique les règles CORS définies (configuration) à tous les points de terminaison (/) de l'application.

Wow, ça fait beaucoup de configuration ! Mais c’est la magie du Spring Framework : il gère tout le gros du travail en coulisses.

Il est temps de configurer les clients

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-oauth2-authorization-server")
    implementation("org.springframework.boot:spring-boot-starter-webflux")
    implementation("org.springframework.boot:spring-boot-starter-validation")
}

Copier après la connexion

Peu de choses que nous avons faites ci-dessus

clientId : Un identifiant unique pour autoriser l'accès
clientAuthenticationMethod : Définition de la méthode d'authentification
redirectUris Autoriser uniquement les URL définies
authorizationGrantTypes authorisation_code

ServiceDétailsUtilisateur

UserDetailsService est utilisé par DaoAuthenticationProvider pour récupérer un nom d'utilisateur, un mot de passe et d'autres attributs pour s'authentifier avec un nom d'utilisateur et un mot de passe. Spring Security fournit des implémentations en mémoire, JDBC et en cache de UserDetailsService.

Vous pouvez définir une authentification personnalisée en exposant un UserDetailsService personnalisé en tant que bean.

InMemoryUserDetailsManager

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    private static final String[] ALLOW_LIST = {"/oauth2/token", "/userinfo"};
    //This is primarily configured to handle OAuth2 and OpenID Connect specific endpoints. It sets up the security for the authorization server, handling token endpoints, client authentication, etc.
    @Bean (1)
    @Order(1)
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
        OAuth2AuthorizationServerConfigurer authorizationServerConfigurer = OAuth2AuthorizationServerConfigurer.authorizationServer();
        http
                .cors(Customizer.withDefaults())
                .authorizeHttpRequests(authz -> authz
                        .requestMatchers(ALLOW_LIST).permitAll()
                        .requestMatchers("/**", "/oauth2/jwks/").hasAuthority("SCOPE_keys.write")
                        .anyRequest()
                        .authenticated())
                .securityMatchers(matchers ->
                        matchers.requestMatchers(antMatcher("/oauth2/**"), authorizationServerConfigurer.getEndpointsMatcher()))
                .with(authorizationServerConfigurer, (authorizationServer) ->
                        authorizationServer
                        .oidc(Customizer.withDefaults()))    // Enable OpenID Connect 1.0

                // Redirect to the login page when not authenticated from the
                // authorization endpoint
                .exceptionHandling((exceptions) -> exceptions
                        .defaultAuthenticationEntryPointFor(
                                new LoginUrlAuthenticationEntryPoint("/login"),
                                new MediaTypeRequestMatcher(MediaType.TEXT_HTML)
                        ))
                // Accept access tokens for User Info and/or Client Registration
                .oauth2ResourceServer((oauth2) -> oauth2.jwt(Customizer.withDefaults()));
        return http.build();
    }

    // This configuration is set up for general application security, handling standard web security features like form login for paths not specifically managed by the OAuth2 configuration.
    @Bean (2)
    @Order(2)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http)
            throws Exception {
        http
                .authorizeHttpRequests((authorize) -> authorize
                        .requestMatchers("/login", "/error", "/main.css")
                        .permitAll()
                        .anyRequest()
                        .authenticated()
                )
                // Form login handles the redirect to the login page from the
                // authorization server filter chain
                .formLogin((login) -> login.loginPage("/login"));

        return http.build();
    }

    @Bean (3)
    public JWKSource<SecurityContext> jwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                .privateKey(privateKey)
                .keyID(UUID.randomUUID().toString())
                .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

    private static KeyPair generateRsaKey() {
        KeyPair keyPair;
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            keyPair = keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
        return keyPair;
    }


    @Bean (4)
    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
    }

    @Bean (5)
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings
                .builder()
                .build();
    }

}

Copier après la connexion

Une fois l'application lancée, notre configuration OIDC et OAuth2 avec Spring Authorization Server devrait fonctionner correctement. Cependant, vous remarquerez que nous avons utilisé InMemoryUserDetailsManager, ce qui convient parfaitement aux démos ou au prototypage. Mais pour un environnement de production, ce n'est pas conseillé car toutes les données disparaissent au redémarrage de l'application.

JdbcUserDetailsManager dans Spring Security

JdbcUserDetailsManager est une fonctionnalité de Spring Security qui utilise JDBC pour gérer les informations d'identification et les rôles des utilisateurs en se connectant à une base de données relationnelle. C'est idéal lorsque votre application peut fonctionner avec le schéma standard pour les tables utilisateur attendu par Spring Security.

Le schéma disponible sur Spring security org/springframework/security/core/userdetails/jdbc/users.ddl

@Configuration
public class CorsConfig {

    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.addAllowedOrigin("http://localhost:3000/"); // Change to specific domains in production
        configuration.addAllowedMethod("*");
        configuration.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Copier après la connexion

Le seul ajustement nécessaire pour passer de InMemoryUserDetailsManager à JdbcUserDetailsManager

2020-02-25 10:24:27.875  INFO 11116 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@46320c9a, org.springframework.security.web.context.SecurityContextPersistenceFilter@4d98e41b, org.springframework.security.web.header.HeaderWriterFilter@52bd9a27, org.springframework.security.web.csrf.CsrfFilter@51c65a43, org.springframework.security.web.authentication.logout.LogoutFilter@124d26ba, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@61e86192, org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@10980560, org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@32256e68, org.springframework.security.web.authentication.www.BasicAuthenticationFilter@52d0f583, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@5696c927, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@5f025000, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5e7abaf7, org.springframework.security.web.session.SessionManagementFilter@681c0ae6, org.springframework.security.web.access.ExceptionTranslationFilter@15639d09, org.springframework.security.web.access.intercept.FilterSecurityInterceptor@4f7be6c8]|

Copier après la connexion

Cette configuration est efficace pour les applications qui respectent le schéma de table standard de Spring Security. Mais, si vous avez besoin de personnaliser (comme utiliser un e-mail pour vous connecter au lieu d'un nom d'utilisateur), la mise en œuvre d'un UserDetailsService personnalisé offre l'adaptabilité nécessaire.

UserDetailsService personnalisé avec une entité client

Ajoutons un CustomUserDetailsService personnalisé au fournisseur. Dans AuthenticationProvider, définissez le service personnalisé en utilisant setUserDetailsService

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-oauth2-authorization-server")
    implementation("org.springframework.boot:spring-boot-starter-webflux")
    implementation("org.springframework.boot:spring-boot-starter-validation")
}

Copier après la connexion

Service personnalisé

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    private static final String[] ALLOW_LIST = {"/oauth2/token", "/userinfo"};
    //This is primarily configured to handle OAuth2 and OpenID Connect specific endpoints. It sets up the security for the authorization server, handling token endpoints, client authentication, etc.
    @Bean (1)
    @Order(1)
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
        OAuth2AuthorizationServerConfigurer authorizationServerConfigurer = OAuth2AuthorizationServerConfigurer.authorizationServer();
        http
                .cors(Customizer.withDefaults())
                .authorizeHttpRequests(authz -> authz
                        .requestMatchers(ALLOW_LIST).permitAll()
                        .requestMatchers("/**", "/oauth2/jwks/").hasAuthority("SCOPE_keys.write")
                        .anyRequest()
                        .authenticated())
                .securityMatchers(matchers ->
                        matchers.requestMatchers(antMatcher("/oauth2/**"), authorizationServerConfigurer.getEndpointsMatcher()))
                .with(authorizationServerConfigurer, (authorizationServer) ->
                        authorizationServer
                        .oidc(Customizer.withDefaults()))    // Enable OpenID Connect 1.0

                // Redirect to the login page when not authenticated from the
                // authorization endpoint
                .exceptionHandling((exceptions) -> exceptions
                        .defaultAuthenticationEntryPointFor(
                                new LoginUrlAuthenticationEntryPoint("/login"),
                                new MediaTypeRequestMatcher(MediaType.TEXT_HTML)
                        ))
                // Accept access tokens for User Info and/or Client Registration
                .oauth2ResourceServer((oauth2) -> oauth2.jwt(Customizer.withDefaults()));
        return http.build();
    }

    // This configuration is set up for general application security, handling standard web security features like form login for paths not specifically managed by the OAuth2 configuration.
    @Bean (2)
    @Order(2)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http)
            throws Exception {
        http
                .authorizeHttpRequests((authorize) -> authorize
                        .requestMatchers("/login", "/error", "/main.css")
                        .permitAll()
                        .anyRequest()
                        .authenticated()
                )
                // Form login handles the redirect to the login page from the
                // authorization server filter chain
                .formLogin((login) -> login.loginPage("/login"));

        return http.build();
    }

    @Bean (3)
    public JWKSource<SecurityContext> jwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                .privateKey(privateKey)
                .keyID(UUID.randomUUID().toString())
                .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

    private static KeyPair generateRsaKey() {
        KeyPair keyPair;
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            keyPair = keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
        return keyPair;
    }


    @Bean (4)
    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
    }

    @Bean (5)
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings
                .builder()
                .build();
    }

}

Copier après la connexion

Référentiel

@Configuration
public class CorsConfig {

    @Bean
    public UrlBasedCorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.addAllowedOrigin("http://localhost:3000/"); // Change to specific domains in production
        configuration.addAllowedMethod("*");
        configuration.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Copier après la connexion

Entité

@Configuration
public class Clients {
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient oidcClient = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("stomble")
                .clientAuthenticationMethod(ClientAuthenticationMethod.NONE)
                .authorizationGrantTypes(types -> {
                    types.add(AuthorizationGrantType.AUTHORIZATION_CODE);
                    types.add(AuthorizationGrantType.REFRESH_TOKEN);
                })
                .redirectUris(redirectUri -> {
                    redirectUri.add("http://localhost:3000");
                    redirectUri.add("https://oauth.pstmn.io/v1/callback");
                    redirectUri.add("http://localhost:3000/signin-callback");
                })
                .postLogoutRedirectUri("http://localhost:3000")
                .scopes(score -> {
                    score.add(OidcScopes.OPENID);
                    score.add(OidcScopes.PROFILE);
                    score.add(OidcScopes.EMAIL);
                })
                .clientSettings(ClientSettings.builder()
                        .requireAuthorizationConsent(false)
                        .requireProofKey(true)
                        .build())
                .build();
        return new InMemoryRegisteredClientRepository(oidcClient);
    }
}

Copier après la connexion

Dans le filtre de sécurité, nous devons dire à Spring Security d'utiliser ce service

.clientAuthentication(clientAuth -> clientAuth.authenticationProvider(authenticationProvider))

@Configuration
public class UserConfig {

    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
        UserDetails userDetailFirst = User.builder()
                .username("user1")
                .password(passwordEncoder.encode("password"))
                .roles("USER")
                .build();
        UserDetails userDetailSecond = User.builder()
                .username("user2")
                .password(passwordEncoder.encode("password"))
                .roles("USER")
                .build();
        return new InMemoryUserDetailsManager(List.of(userDetailFirst, userDetailSecond));
    }
}

@Bean
public PasswordEncoder passwordEncoder() {
   return new BCryptPasswordEncoder();
}

Copier après la connexion

Conclusion

Ici, vous disposez de deux choix robustes pour gérer l'authentification :

JdbcUserDetailsManager : une option simple si votre application s'aligne sur le schéma par défaut de Spring.
Custom UserDetailsService : offre la flexibilité nécessaire pour gérer les champs et les rôles spéciaux.

Peu importe si vous choisissez JdbcUserDetailsManager ou décidez d'implémenter un UserDetailsService personnalisé, les deux équiperont votre application d'un système d'authentification évolutif pris en charge par une base de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!