Désactiver les sessions et CSRF, utilisez SessionCreationPolicy.Stateless et CSRF (). Disable () pour atteindre la sécurité conviviale; 2. Utilisez JWT pour l'authentification sans état, générez et vérifiez les jetons contenant des r?les utilisateur et le temps d'expiration via JWTUtil; 3. Créez JWTAuthenticationFilter pour intercepter les demandes, analyser les jetons de support dans l'en-tête d'autorisation et stocker les informations d'authentification dans SecurityContextholder après vérification; 4. Utiliser @preAuthorize ("Hasrole ('admin')") et d'autres annotations pour implémenter le contr?le d'accès basé sur les r?les et activer la sécurité au niveau de la méthode via @enableglobalMethodSecurity (PreposseNabled = true); 5. Fournissez une interface / connexion de connexion et renvoyez le jeton JWT après une authentification réussie par AuthenticationManager; Assurez-vous d'utiliser HTTPS, de stockage sécurisé des clés, d'éviter les jetons de stockage localstorage, de vérifier strictement les signatures et de définir des politiques d'expiration raisonnables pour assurer la sécurité de l'API.

La sécurisation des API REST avec la sécurité du printemps en Java n'est pas seulement une meilleure pratique - c'est une nécessité. Contrairement aux applications Web traditionnelles qui reposent sur les cookies de session, les API REST sont apatrides, de sorte que la sécurité doit être gérée différemment. Voici comment faire les choses correctement en utilisant Spring Security et Java (sans Spring Boot si vous allez la route XML ou Pure Java Config, bien que nous nous concentrerons sur la configuration Java moderne).

1. Activer la sécurité du printemps d'une manière conviviale

Commencez par configurer Spring Security avec la configuration Java. Vous devrez désactiver la création de session et la protection CSRF car les API REST utilisent généralement l'authentification basée sur les jetons (comme JWT), pas les sessions.

 @Configuration
@Enablewebsecurity
classe publique SecurityConfig {

    @Haricot
    Sécurité publiqueFilterChain FilterChain (httpSecurity http) lève une exception {
        http
            .csrf (). Disable () // Pas de CSRF pour les API sans état
            .SessionManagement ()
                .SessionCreationPolicy (SessionCreationPolicy.Stateless) // Toujours sans état
            .et()
            .AuthorizeHttpRequests (Authz -> Authz
                .requestmatchers ("/ api / public / **"). permutall ()
                .requestmatchers ("/ api / admin / **"). Hasrole ("admin")
                .anyRequest (). Authenticated ()
            )
            .httpbasic (). Disable () // pas idéal pour le repos; utiliser des jetons
            .AddFilterBefore (jwtFilter (), usernamePasswordAuthenticationFilter.class);

        return http.build ();
    }

    @Haricot
    public jwtAuthenticationFilter jwtfilter () {
        retourner new jwtAuthenticationFilter ();
    }
}

? Points clés:

• Les séances STATELESS empêchent le printemps de créer des cookies JSESSIONID .
• Désactiver CSRF car il repose sur l'état de session.
• Utilisez requestMatchers() pour définir le public vs des points de terminaison sécurisés.

2. Utilisez JWT pour l'authentification sans état

JWT (jeton Web JSON) est parfait pour les API REST. Le client se connecte une fois, obtient un jeton et l'envoie dans l'en-tête Authorization: Bearer <token> sur les demandes suivantes.

Générer JWT (exemple utilitaire)

 classe publique jwtutil {
    String privé secret = "YOTSUPERSECRETKEYTHATISATLEAST256BITSLONG";

    Public String generateToken (nom d&#39;utilisateur de cha?ne, collection <? étend l&#39;autorité accorde> les autorités) {
        return jwts.builder ()
            .SetSubject (nom d&#39;utilisateur)
            .Claim ("Autorités", autorités.stream ()
                .map (AccordedAuthority :: GetAuthority)
                .Collect (collectionners.tolist ()))
            .setShedat (new Date ())
            .SetExpiration (nouvelle date (System.CurrentTimemillis () 86400000)) // 24h
            .signWith (Signaturealgorithm.hs256, secret)
            .compact();
    }

    public boolean istokenvalid (token de cha?ne, nom d&#39;utilisateur de cha?ne) {
        return getUserNameFromToken (token) .equals (nom d&#39;utilisateur) &&! istoKenexpired (token);
    }

    String public getUserNameFromToken (token de cha?ne) {
        return getClaims (token) .getSubject ();
    }

    Réclations privées getClaims (jeton de cha?ne) {
        return jwts.parser ()
            .SetsigningKey (secret)
            .Parseclaidsjws (jeton)
            .getBody ();
    }

    booléen privé istokenexpired (token de cha?ne) {
        return getClaims (token) .getExpiration (). avant (new Date ());
    }
}

?? Gardez le secret en sécurité - jamais le code dur dans la production. Utilisez des variables d'environnement ou des serveurs de configuration.

3. Filtre d'authentification JWT personnalisé

Vous avez besoin d'un filtre pour intercepter les demandes entrantes, extraire le JWT de l'en-tête Authorization , le valider et définir l'authentification dans le contexte de Spring Security.

 La classe publique JWTAUTHENTICTIONSFILTER étend une foisPerRequestFilter {

    @Autowired
    JWTUTIL JWTUTIL;

    @Autowired
    UserDetailSService privé UserDetailSService;

    @Outrepasser
    VOID DOFILTERINTERNAL (demande httpServleRequest,
                                    Réponse httpservletResponse,
                                    FilterChain FilterChain) lève ServletException, ioException {

        String token = extractToken (demande);

        if (token! = null && jwtutil.validateToken (token)) {
            String username = jwtutil.getUserNameFromToken (token);
            UserDetails userDetails = userDetailsService.LoadUserByUserName (nom d'utilisateur);

            UserNamepasswordAuthenticationToken Authentication =
                Nouveau userNamepasswordAuthenticationToken (UserDetails, NULL, UserDetails.GetAuthorities ());
            authentication.setDetails (new webAuthenticationDetailsSource (). buildDetails (demande));

            SecurityContexTholder.getContext (). SetAuthentication (authentification);
        }

        FilterChain.Dofilter (demande, réponse);
    }

    ExtractToken de cha?ne privée (requête httpservletRequest) {
        String BearertElk = request.GetHeader ("Autorisation");
        if (Bearertoken! = null && bearertoken.startswith ("Bearer")) {
            RETOUR BEARERERTKENK.SUBSTRING (7);
        }
        retourner null;
    }
}

? Ce filtre s'exécute avant que Spring vérifie l'authentification. Si le jeton est valide, il définit l'objet Authentication ainsi @PreAuthorize , hasRole() , etc., fonctionnez comme prévu.

4. Secure de terminaison avec un accès basé sur les r?les

Une fois l'authentification en place, protégez vos points de terminaison en utilisant la sécurité au niveau de la méthode:

 @RestController
@RequestMapping ("/ api / admin")
@PreAuthorize ("Hasrole ('admin')")
Classe publique AdminController {

    @Getmapping ("/ data")
    Public Responsentity <string> getSensivedata () {
        return réponsentity.ok ("Top Secret Data!");
    }
}

N'oubliez pas d'activer la sécurité au niveau de la méthode:

 @Configuration
@Enableglobalthodsecurity (prepossenabled = true)
classe publique MethodsEcurityConfig {
    // Pas de haricots supplémentaires nécessaires si vous utilisez la sécurité de la méthode globale
}

5. Ajouter un point de terminaison de connexion pour émettre des jetons

Créez un contr?leur de connexion simple pour authentifier et renvoyer un JWT:

 @Postmapping ("/ login")
Public Responsentity <?> Login (@Requestbody LoginRequest Request) {
    essayer {
        Authentification Authentication = AuthenticationManager.Authenticiate (
            Nouveau userNamePasswordAuthenticationToken (request.getUserName (), request.getPassword ())
        ));
        SecurityContexTholder.getContext (). SetAuthentication (authentification);

        Token de cha?ne = jwtutil.generatetoken (
            authentication.getName (),
            (Collection <? étend l&#39;autorité accordé>) Authentication.getAuthorities ()
        ));

        return réponsentity.ok (new JWTResponse (jeton));
    } catch (AuthenticationException e) {
        return réponsentity.status (httpstatus.unauthorized) .build ();
    }
}

? Vous devrez exposer le bean AuthenticationManager si vous n'utilisez pas la configuration automatique de Spring Boot.

Notes finales

• Ne stockez jamais JWTS dans LocalStorage (Risque XSS). Préférez les cookies httpOnly si possible, ou utilisez un stockage sécurisé en mémoire.
• Utilisez toujours HTTPS en production.
• Faites tourner les secrets et considérez l'expiration des jetons courts avec des jetons de rafra?chissement.
• Valider strictement les signatures de jeton - n'utilisez pas none algorithme.

Fondamentalement, sécuriser les API REST avec la sécurité du printemps se résume à:

• Séances de désactivation et CSRF.
• Utilisation de JWT (ou OAuth2) pour Autant sans état.
• écriture d'un filtre pour valider les jetons.
• Tirer parti des mécanismes d'autorisation de Spring.

Ce n'est pas complexe, mais facile de se tromper. Faites-le une fois bien et votre API reste en sécurité.

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!