Bonjour,

Ayant des projets sous symfony depuis quelques année, j'ai gardé le même mode de hachage pour stocker les mots de passe dans ma base de données.

Cela se traduit dans le fichier security.yaml de la façon suivante:

security:
    encoders:
        App\Entity\User: sha512

Or je viens de remarquer qu'en remplaçant sha512 par auto, la connexion reste fonctionnelle et que les membres peuvent se connecter sans problème.

Du coup j'en viens à me demander comment se comporte ma base de données:

A l'enregistrement d''un nouvel, quel mode de hachage est utilisé?

A la connexion d'un user, comment sait-il le mode de hachage à utiliser?

En tout cas, je constate qu'un user créé alors que l'encoder est en auto ne peut pas se connecter quand on rebascule l'encoder sous sha512, alors qu'un user créé en mode sha512 peut se connecter quand l'encoder est sous 'auto'.

J'en conclus que le mode de hachage utilisé est contenu dans le mot de passe lui même. Est-ce bien cela?

A vous

Salut

Ce n'est pas impossible que je mélange deux sujets, mais est-ce que tu tentes aussi une migration de la gestion des mots de passe ? Genre sha512 de la vieille installation et passer à BCrypt automatiquement ?

Par rapport à un projet que je manipule, j'ai ce qui suit :

security:
    enable_authenticator_manager: true
    # https://symfony.com/doc/current/security.html#registering-the-user-hashing-passwords
    password_hashers:
        legacy:
            algorithm: sha512
            encode_as_base64: false
            iterations: 1
        App\Entity\User:
            algorithm: 'auto'
            migrate_from:
                - legacy

Avec le UserRepository qui implémente \Symfony\Component\Security\Core\User\PasswordUpgraderInterface. Quand je me connecte avec un utilisateur dont j'ai mis le mot de passe haché avec SHA-512 en base, ça fonctionne, et j'ai la version "mise à jour" qui remplace dans la base de données. Je me déconnecte et me reconnecte, ça fonctionne toujours, et ce qui est enregistré ne change plus.

De ce que j'ai pu voir quand j'ai voulu creuser le système (on m'avait donné le mauvais algorithme de hachage, avant que je n'y pense j'ai cru qu'il me fallait passer de binaire à ASCII), il semble qu'il y ait plusieurs tentatives de comparaison du mot de passe selon ce qu'il y a dans l'agrégat stocké en base. En imaginant qu'on ait à migrer de BCrypt à Sodium par exemple, ça pose peu de problème vu que c'est tout password_hash() qui gère et qu'il reconnaît de lui-même l'algorithme à utiliser selon ce à quoi il doit comparer, soient les quelques premiers caractères de l'agrégat en base. Il se base aussi là-dessus pour savoir s'il doit en re-générer un ou non, j'imagine.
Pour ce qui est d'algorithmes "plus anciens", on testera toujours la comparaison avant de passer au système plus récent. Avec ce que je donne, il teste d'abord avec le hasher legacy avant de tester avec le suivant. Et les nouveaux utilisateurs ont un mot de passe traité avec BCrypt, donc le hasher spécifié pour l'entité.

Après, je ne sais plus exactement si password_hash() ne gère pas aussi certains de ces "vieux algorithmes" en se basant notamment sur la longueur et la structure de l'agrégat fourni (qui me semblent être les seuls éléments qui puissent distinguer ceux-ci par leurs résultats respectifs) pour comparaison, ça me rappelle quelque chose.

-
Edité par Ymox 15 décembre 2021 à 18:28:57

Ma demande était plus simple et fonctionne. Avec mes paramètres, les users se connectent bien, les plus anciens restent au sha512 que j'avais à l'origine, les plus récents, j'imagine au cryptage le plus récent défini par Symfony.

security:
    enable_authenticator_manager: true

    password_hashers:
        Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface: 'auto'
        App\Entity\User:
            algorithm: auto

Tu m'apportes en plus une méthode si j'ai bien compris qui permet de migrer ceux qui sont en sha512 vers le plus récent.

Je vais étudier cela.

1. Est-ce que cela fait d'un coup tous les users, ou faut-il qu'ils se connectent pour voir leur cryptage se modifier. (J'imagine que c'est la deuxième option).

2. Y a -t-il un moyen de connaître le mode de cryptage avec le password crypté?

-
Edité par CarréDas1 15 décembre 2021 à 18:55:15

1. Il faut qu'ils se connectent, ce qui dans mon cas me permettra de voir qui utilise l'application et qui ne l'utilise pas
   Cela a aussi l'avantage de ne pas demander des ressources serveur quand on fait la mise à jour des paramètres, mais de répartir lors des connexions des utilisateurs. Il me semble que les moteurs de base de données n'ont rien pour gérer de la même manière, donc c'est forcément le langage qui s'interface avec le SGBD qui doit faire la conversion.
2. En se basant sur la longueur, on peut déterminer l'une ou l'autre famille parmi les "anciens bruts".
   Pour ce qui utilise password_hash()/password_verify()/password_needs_rehash(), les quelques caractères entre les deux premiers $ indiquent un type :
   • 2y pour Blowfish (2a et 2x sont aussi pour cet algorithme, mais des implémentations qui ne sont plus considérées comme sûres) ;
   • argon2i pour Argon2i ;
   • argon2id pour Argon2id ;
   • 1 pour MD5 (utilisable uniquement avec password_verify()) ;
   • 5 pour SHA-256 (utilisable uniquement avec password_verify()) ;
   • 6 pour SHA-512 (utilisable uniquement avec password_verify()).

-
Edité par Ymox 15 décembre 2021 à 22:48:22

Merci pour toutes ces explications.

J'en retire que symfony sait trouver quel mode de hachage utiliser rien qu'en lisant le mot de passe crypté.

J'ai fait les manipulations suivantes:

cryptage du mot 'openclassroom' en sha512 =>

BK4oreFNBFwEt4BKHYYiU4Vha0hZG+Utc8L7Ut69A/L04L5nGBMYqRCkqboOzKlGaOJ8OYElbiHJNOwWXJ2Img==

cryptage du mot 'openclassroom' en 'auto' =>

$2y$13$RDzPqBgUqeAGpBOWsCr7ZOLXwOTGKcO/kkMzhw9W6vSt4q0/Pea7e

Symfony sait lire les 2 mots de passe quand le hasher est sur auto et ne sait lire que le premier quand il est réglé sur sha512.

Je retiens aussi de la discussion qu'il y a un moyen de régler symfony pour qu'il transforme au fur et à mesure des connexions les cryptages des mots de passe en mode ancien désigné (par exemple sha512) vers un mode nouveau.