Sécuriser les API REST en Java avec Spring Security et JWT

Utilisez Spring Security et JWT pour implémenter l'authentification sécurisée et l'autorisation de l'API REST en Java, adapté aux architectures apatrides et évolutives telles que les microservices, les applications mobiles et les applications à une page; 2. Ajoutez d'abord des dépendances Spring Boot, Spring Security et JJW dans pom.xml; 3. Créez des classes de modèles utilisateur et LoginRequest pour les informations utilisateur et les demandes de connexion; 4. Écrivez la classe d'outils JWTutil pour générer, analyser et vérifier JWT, notez que la clé doit être configurée via des variables d'environnement plutôt qu'en codé en dur; 5. Configurer la classe SecurityConfig pour désactiver CSRF, définir les politiques de session sans état, libérer l'interface d'authentification et enregistrer les filtres JWT; 6. Implémentez le filtre JWTREQUESTFILTER pour extraire et vérifier JWT de l'en-tête d'autorisation, et définir le contexte d'authentification s'il est valide; 7. Créez un AuthController pour fournir une interface de connexion / authentification et renvoyez le jeton JWT après la vérification des informations d'identification; 8. Définir des points de terminaison API protégés tels que / sécurisé, qui ne peuvent être accessibles que si la demande transporte un jeton de support valide; 9. Les meilleures pratiques incluent l'utilisation de HTTPS, les jetons de stockage sécurisés, la définition d'un court temps d'expiration et la coordination avec des jetons de rafraîchissement, la priorisation de l'utilisation de l'algorithme RS256, la vérification des déclarations de jetons et la limitation de la fréquence des interfaces de connexion pour éviter la fissure de brute. En plaçant correctement l'API et en suivant les spécifications de sécurité, cette solution garantit l'apatride, la sécurité et l'évolutivité élevée de l'API.

La sécurisation des API REST en Java à l'aide de Spring Security et JWT est une exigence commune pour les applications Web modernes, en particulier lors de la création de backends apatrides et évolutifs. Voici un guide pratique de la mise en œuvre d'authentification et d'autorisation sécurisées avec Spring Security et JSON Web Tokens (JWT).

Pourquoi utiliser Spring Security JWT?

Spring Security fournit un cadre puissant et personnalisé pour gérer l'authentification et l'autorisation dans les applications Java. Lorsqu'il est combiné avec JWT, il permet l'authentification sans état , ce qui signifie que le serveur n'a pas besoin de stocker les données de session. Au lieu de cela, chaque demande comprend un jeton signé qui prouve l'identité de l'utilisateur.

Ceci est idéal pour:

• Architectures de microservices
• Applications mobiles et une seule page (spas)
• API qui doivent mettre à l'échelle horizontalement

Étape 1: Configurer les dépendances

Ajoutez les dépendances requises dans votre pom.xml (pour maven):

 <dépendances>
    <dépendance>
        <GroupId> org.springFramework.boot </romp grouped>
        <ArtefactId> Spring-Boot-Starter-Web </refactive>
    </Dependance>
    <dépendance>
        <GroupId> org.springFramework.boot </romp grouped>
        <ArtefactId> Spring-Boot-Starter-Security </refactive>
    </Dependance>
    <dépendance>
        <pouprid> io.jsonwebtoken </rombandid>
        <ArtefactId> JJWT-API </ Arfactive>
        <version> 0.11.5 </ version>
    </Dependance>
    <dépendance>
        <pouprid> io.jsonwebtoken </rombandid>
        <ArtefactId> JJWT-IMPL </ ARTIFACTID>
        <version> 0.11.5 </ version>
        <ccope> Runtime </ccope>
    </Dependance>
    <dépendance>
        <pouprid> io.jsonwebtoken </rombandid>
        <ArtefactId> JJWT-JACKSON </ Arfactive>
        <version> 0.11.5 </ version>
        <ccope> Runtime </ccope>
    </Dependance>
</DENDENDENCES>

Étape 2: Créer un modèle utilisateur et une demande d'authentification

Définissez un modèle utilisateur simple et connexion DTO:

 classe publique User {
    Nom d'utilisateur de chaîne privée;
    mot de passe de chaîne privé;
    // constructeurs, getters, setters
}

 classe publique LoginRequest {
    Nom d'utilisateur de chaîne privée;
    mot de passe de chaîne privé;
    // Getters et Setters
}

Étape 3: générer et valider JWT

Créez une classe d'utilité pour générer et analyser les jetons:

 @Composant
classe publique jwtutil {

    String privé secret_key = "votre secret-key"; // Utiliser une variable d'environnement ou un stage de clé en production

    public String generateToken (userDetails userDetails) {
        return jwts.builder ()
                .SetSubject (userDetails.getUserName ())
                .setShedat (new Date ())
                .SetExpiration (nouvelle date (System.CurrentTimemillis () 1000 * 60 * 60 * 10)) // 10 heures
                .signWith (Signaturealgorithm.hs256, Secret_key)
                .compact();
    }

    public boolean validateToken (token string, userDetails userDetails) {
        Final String Username = ExtractUserName (token);
        return (username.equals (userdetails.getUserName ()) &&! istoKenexpired (token));
    }

    public String ExtractUserName (String Token) {
        return jwts.parser (). setSigningKey (secret_key) .parseclaimsjws (token) .getBody (). getSubject ();
    }

    booléen privé istokenexpired (token de chaîne) {
        return jwts.parser (). setSigningKey (secret_key) .parseclaimsjws (token) .getBody (). getExpiration (). AVANT (new Date ());
    }
}

? Conseil de sécurité : ne jamais cocoter la clé secrète. Utilisez @Value("${jwt.secret}") avec des variables d'environnement ou un système de gestion de clés sécurisé.

Étape 4: Configurer la sécurité du printemps

Créer une classe de configuration de sécurité:

 @Configuration
@Enablewebsecurity
classe publique SecurityConfig {

    @Autowired
    UserDetailSService privé UserDetailSService;

    @Autowired
    JWTReQuestFilter privé JWTReQuestFilter;

    @Haricot
    Public MotwordEncoder MotwordEncoder () {
        Renvoie un nouveau BCryptPasswordEncoder ();
    }

    @Haricot
    public AuthenticationManager AuthenticationManager (AuthenticationConfiguration Config) lève l'exception {
        return config.getAuthenticationManager ();
    }

    @Haricot
    Sécurité protégé FilterChain FilterChain (httpsecurity http) lève une exception {
        http.csrf (). Disable ()
            .AuthorizeHttpRequests (Auth -> Auth
                .Requestmatchers ("/ authentifier"). permutall ()
                .anyRequest (). Authenticated ()
            )
            .SessionManagement (Sess -> Sess.SessionCreationPolicy (SessionCreationPolicy.Stateless));

        http.addfilterBefore (jwtRequestFilter, usernamepasswordAuthenticationFilter.class);

        return http.build ();
    }
}

Étape 5: Implémentez le filtre JWT

Créez un filtre pour intercepter les demandes entrantes et valider le JWT:

 @Composant
La classe publique JWTREQUESTFILTER étend une fois PEperRequestFilter {

    @Autowired
    UserDetailSService privé UserDetailSService;

    @Autowired
    JWTUTIL JWTUTIL;

    @Outrepasser
    VOID DOFILTERINNERNAL (demande HttpServletRequest, réponse httpservletResponse, chaîne FilterChain)
            lance ServletException, ioException {

        Final String AuthorizationHeader = request.GetHeader ("Authorization");

        String username = null;
        String jwt = null;

        if (AuthorizationHeader! = null && AuthorizationHeader.startswith ("Bearer")) {
            JWT = AuthorizationHeader.SubString (7);
            username = jwtutil.ExtractUsername (jwt);
        }

        if (username! = null && securityContexTholder.getContext (). getAuthentication () == null) {
            UserDetails userDetails = this.userDetailsService.LoadUserByUserName (nom d'utilisateur);

            if (jwtutil.validateToken (jwt, userDetails)) {
                UserNamepasswordAuthenticationToken authtoken = new userNamepasswordAuthenticationToken (
                        userDetails, null, userDetails.getAuthorities ());
                authtoken.setDetails (new webAuthenticationDetailsSource (). buildDetails (demande));
                SecurityContexTholder.getContext (). SetAuthentication (AuthToken);
            }
        }
        chain.dofilter (demande, réponse);
    }
}

Étape 6: Créer un point de terminaison d'authentification

Exposez un point de terminaison pour générer un jeton lors de la connexion:

 @RestController
classe publique AuthController {

    @Autowired
    Authentication PrivateManager AuthenticationManager;

    @Autowired
    UserDetailSService privé UserDetailSService;

    @Autowired
    JWTUTIL JWTUTIL;

    @Postmapping ("/ authentifier")
    Public Responsentity <?> CreateAuthenticationToken (@Requestbody LoginRequest LoginRequest) lève une exception {
        essayer {
            authenticationManager.Authenticate (
                Nouveau userNamepasswordAuthenticationToken (LoginRequest.GetUserName (), LoginRequest.GetPassword ())
            ));
        } catch (badCredentialSexception e) {
            lancer une nouvelle exception ("nom d&#39;utilisateur ou mot de passe incorrect", e);
        }

        userDetails final userDetails = userDetailsService.LoadUserByUserName (LoginRequest.GetUserName ());
        chaîne finale jwt = jwtutil.generateToken (userDetails);

        return réponsentity.ok (new JWTResponse (JWT));
    }
}

Et la réponse DTO:

 classe publique JWTResponse {
    jeton de chaîne privé;

    public jwtResponse (token de chaîne) {
        this.token = token;
    }

    // Getter
}

Étape 7: Testez l'API sécurisée

Maintenant, tout point final autre que /authenticate nécessite un JWT valide:

 @RestController
classe publique Democontroller {

    @Getmapping ("/ sécurisé")
    String public SecuredEndpoint () {
        Retour "Bonjour, vous êtes authentifié!";
    }
}

Pour accéder /secured , incluez l'en-tête:

 Autorisation: Bearer <your-jwt-token>

Meilleures pratiques et conseils de sécurité

• ✅ Utilisez HTTPS en production
• ✅ Stockez les JWT en toute sécurité sur le client (évitez localStorage si possible; préférez les cookies httpOnly pour les applications Web)
• ✅ Réglez les temps d'expiration courts et implémentez les jetons de rafraîchissement
• ✅ Utilisez des secrets forts ou des clés RSA (RS256 au lieu de HS256 pour une meilleure séparation des clés)
• ✅ Valider l'émetteur, le public et les réclamations en production
• ✅ Points de terminaison d'authentification à limite de taux pour éviter les attaques de force brute

Conclusion

Spring Security with JWT vous donne une base solide pour sécuriser les API REST en Java. Bien que la configuration implique plusieurs composants - filtres, génération de jetons et configuration - le modèle est réutilisable et correspond bien aux architectures d'application modernes.

Avec une gestion des clés et une gestion des jetons appropriés, cette approche maintient vos API sécurisées, apatrides et évolutives.

Fondamentalement, il suffit de câbler le filtre, de protéger vos points de terminaison et de valider les jetons sur chaque demande - et vous êtes prêt à partir.

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!