Sécurisation des mots de passe avec BCryptPasswordEncoder

1. Pourquoi ne jamais stocker un mot de passe en clair ?

Stocker les mots de passe des utilisateurs en texte brut dans votre base de données est une faute professionnelle majeure. En cas de fuite de données (et cela arrive même aux plus grandes entreprises), tous les mots de passe de vos utilisateurs seraient exposés. Pour éviter cette catastrophe, on utilise une technique appelée le hachage.

Le hachage est une fonction à sens unique : il est facile de calculer un hash à partir d'un mot de passe, mais quasiment impossible de retrouver le mot de passe original à partir du hash.

Il existe de nombreux algorithmes de hachage (MD5, SHA-256, etc.), mais pour les mots de passe, la norme est d'utiliser un algorithme adaptatif comme BCrypt. "Adaptatif" signifie que sa "lenteur" peut être ajustée. À mesure que la puissance de calcul des ordinateurs augmente, on peut augmenter le "coût" de calcul de BCrypt pour qu'il reste résistant aux attaques par force brute.

Spring Security fournit une implémentation prête à l'emploi : BCryptPasswordEncoder.

2. Étape 1 : Mettre le PasswordEncoder à disposition de Spring

Pour utiliser BCryptPasswordEncoder dans notre application, nous devons en déclarer une instance comme un Bean Spring. Cela permettra à Spring de l'injecter là où nous en avons besoin et, plus important encore, de l'intégrer dans son propre flux d'authentification.

Vous avez probablement déjà croisé ce Bean dans les leçons précédentes. Prenons le temps de bien comprendre son rôle dans la configuration de sécurité.

Voici à quoi ressemble ce Bean, généralement placé dans votre classe de configuration de sécurité :

@Configuration
public class ApplicationConfiguration {

    // ... autres beans (UserDetailsService, etc.)

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

    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService()); // Votre service qui charge l'utilisateur
        authProvider.setPasswordEncoder(passwordEncoder()); // On indique à Spring d'utiliser BCrypt
        return authProvider;
    }
    
    // ...
}

Une fois ce Bean déclaré, Spring Security l'utilisera automatiquement pour la vérification des mots de passe lors de l'authentification.

3. Étape 2 : Hacher le mot de passe lors de l'inscription

Maintenant que notre PasswordEncoder est disponible, nous devons l'utiliser activement chaque fois qu'un utilisateur est créé ou que son mot de passe est mis à jour. Le processus est simple :

1. Injectez le PasswordEncoder dans votre service (par exemple, UserService ou AuthenticationService).
2. Avant de sauvegarder l'entité User, appelez la méthode encode() sur le mot de passe fourni en clair.
3. Définissez ce nouveau mot de passe haché sur l'entité avant de la persister.

Note importante : Le tutoriel de Developpez.com mentionne que BCrypt utilise l'algorithme SHA-1. C'est une erreur factuelle. BCrypt est un algorithme distinct, spécifiquement conçu pour le hachage de mots de passe et bien plus robuste que SHA-1 à cet effet.

Pour une démonstration visuelle de ce processus, la vidéo suivante est très directe.

4. Étape 3 : Vérifier le mot de passe lors de la connexion

La vérification est la contrepartie du hachage. Quand un utilisateur tente de se connecter, il envoie son mot de passe en clair. Nous devons le comparer au hash stocké en base de données.

Attention : N'essayez PAS de hacher le mot de passe fourni et de comparer les deux hashs !
bcrypt.encode("password123") ne produira pas toujours la même sortie, car BCrypt intègre un "sel" (salt) aléatoire dans le hash pour le renforcer.

La bonne méthode est d'utiliser passwordEncoder.matches(motDePasseEnClair, hashStocké). Cette méthode est conçue pour extraire le sel du hash stocké, l'appliquer au mot de passe en clair, et ensuite comparer les résultats.

Heureusement, si vous avez correctement configuré l'AuthenticationProvider (comme vu à l'étape 2), Spring Security s'en occupe pour vous !

L'extrait vidéo suivant explique comment le AuthenticationManager est configuré pour utiliser notre PasswordEncoder et UserDetailsService afin d'effectuer cette vérification.

Conclusion

Vous venez de mettre en œuvre l'une des pratiques de sécurité les plus fondamentales. En hachant systématiquement les mots de passe, vous protégez vos utilisateurs même en cas de compromission de votre base de données.

Points clés à retenir :

• Ne jamais stocker de mots de passe en clair. Utilisez toujours une fonction de hachage forte et adaptative comme BCrypt.
• Configurez BCryptPasswordEncoder comme un @Bean dans votre configuration Spring Security et liez-le à votre AuthenticationProvider.
• Utilisez la méthode passwordEncoder.encode(plainTextPassword) pour hacher les mots de passe avant de les enregistrer lors de la création ou de la mise à jour d'un utilisateur.
• Laissez Spring Security gérer la vérification via la méthode matches() en arrière-plan lors du processus de connexion.

Dans la prochaine et dernière leçon de ce module sur la sécurité, nous aborderons la protection contre les attaques de type CSRF (Cross-Site Request Forgery). Nous analyserons son utilité dans le contexte d'une API REST stateless et verrons comment la configurer correctement.