Question Comment Linux sait-il que le nouveau mot de passe est similaire au précédent?


Quelques fois j'ai essayé de changer un mot de passe d'utilisateur sur différentes machines Linux et quand le nouveau mot de passe était similaire à l'ancien, le système d'exploitation s'est plaint d'être trop similaire.

Je me suis toujours demandé comment le système le sait? Je pensais que le mot de passe est enregistré en tant que hachage. Est-ce que cela signifie que lorsque le système est en mesure de comparer le nouveau mot de passe pour la similarité, l'ancien est réellement enregistré en texte brut?


140
2017-12-27 17:22


origine


1er off: texte en clair? non. Si (!) Sauvegardé, sauvegardez le hachage et comparez les hachages. Sous Linux, il vérifie le mot de passe actuel avec un nouveau mot de passe. Les deux sont fournis par l'utilisateur lors de la modification des mots de passe. - Rinzwind
@Rinzwind Mais la comparaison des hachages ne fonctionnera pas car une différence d'un caractère devrait se traduire par un hachage complètement différent - slhck
Voir également Est-ce que Facebook stocke des mots de passe en texte clair? sur Sécurité de l'information pour d'autres moyens de détecter la similitude, uniquement le hachage de l'ancien mot de passe et le texte en clair du nouveau mot de passe (pas de texte en clair pour l'ancien). - Bob
Vous pouvez réellement tester la similarité entre un ancien mot de passe haché et un nouveau mot de passe en texte brut. Il suffit de générer une liste de mots de passe similaire à la nouvelle, de les hacher tous et de comparer les hachages obtenus à l’ancien hachage de mot de passe. S'il y a une correspondance, alors c'est similaire. - BWG
@BWG: Il s’agit là d’une légère simplification excessive - les schémas de hachage actuels salissent le hachage, donc vous devez d’abord extraire le sel de l’ancien hachage de mot de passe et vous assurer que vous utilisez ce sel pour vos nouveaux mots de passe. (Je le souligne car il est possible que l’API n’expose pas un moyen de forcer un sel spécifique.) - Ulrich Schwarz


Réponses:


Puisque vous devez fournir à la fois l'ancien et le nouveau mot de passe lors de l'utilisation passwd, ils peuvent être facilement comparés en texte clair, en mémoire, sans les écrire quelque part sur le lecteur.

En effet, votre mot de passe est haché lorsqu'il est finalement stocké, mais jusqu'à ce que cela arrive, l'outil où vous entrez votre mot de passe peut bien sûr y accéder directement, comme n'importe quel autre programme peut accéder aux choses que vous avez saisies sur STDIN.

Ceci est une caractéristique du Système PAM qui est utilisé en arrière-plan du passwd outil. PAM est utilisé par les distributions Linux modernes.

Plus précisement, pam_cracklib est un module pour PAM qui permet de rejeter les mots de passe en fonction de plusieurs faiblesses qui les rendraient très vulnérables.

Ce ne sont pas seulement des mots de passe trop similaires qui peuvent être considérés comme peu sûrs. le code source  a divers exemples de ce qui peut être vérifié, par ex. si un mot de passe est un palindrome ou quelle est la distance de montage entre deux mots. L'idée est de rendre les mots de passe plus résistants aux attaques par dictionnaire.

Voir également la pam_cracklib page de manuel.


154
2017-12-27 19:27



Avez-vous des idées sur "comment" votre explication correspond aux arguments rapportés dans ma réponse? Y at-il deux approches différentes, prises par l'application "passwd", lorsque l'hôte est ne pas Conscient de PAM? P.S .: Pas de critique du tout. Je me demande juste (car PAM, BTW, était ma première supposition ... juste avant de taper le code source). - Damiano Verzulli
Plus dérangeantes sont les règles de mot de passe de l’entreprise qui vous avertissent si vous avez utilisé le même mot de passe ou un mot de passe similaire parmi les quatre derniers. - Nick T
@NickT Comment cela (nécessairement) dérangeant - ne pourraient-ils pas simplement sauvegarder vos 4 derniers hachages, puis comparer chacun de ceux-ci au nouveau proposé de la même manière que cette question? - neminem
@neminem "... ou similaire" - Nick T
@NickT Ah, assez bien, car dans ce cas particulier, vous comparez à "l'ancien mot de passe" entré par l'utilisateur pour changer le mot de passe, plutôt qu'à un hachage enregistré. Encore vous pourrait utiliser hypothétiquement la méthode BWG affichée dans un commentaire, au moins pour vérifier des modifications très simples (une substitution de caractère, un caractère ajouté / supprimé, etc.). - neminem


Au moins dans mon Ubuntu, les messages "trop ​​similaires" sortent quand: "... plus de la moitié des personnages sont différents ...." (voir ci-dessous pour plus de détails). grâce au support de PAM, comme expliqué clairement dans la réponse de @slhck.

Pour les autres plates-formes, où PAM n'est pas utilisé, les messages "trop ​​similaires" apparaissent lorsque: "... plus de la moitié des personnages sont différents ...." (voir ci-dessous pour plus de détails)

Pour vérifier cette déclaration par vous-même, il est possible de vérifier le code source. Voici comment.

Le programme "passwd" est inclus dans le paquet passwd:

verzulli@iMac:~$ which passwd
/usr/bin/passwd
verzulli@iMac:~$ dpkg -S /usr/bin/passwd
passwd: /usr/bin/passwd

En ce qui concerne les technologies Open Source, nous avons un accès illimité au code source. Le faire est aussi simple que:

verzulli@iMac:/usr/local/src/passwd$ apt-get source passwd

Ensuite, il est facile de trouver le fragment de code correspondant:

verzulli@iMac:/usr/local/src/passwd$ grep -i -r 'too similar' .
[...]
./shadow-4.1.5.1/NEWS:- new password is not "too similar" if it is long enough
./shadow-4.1.5.1/libmisc/obscure.c:     msg = _("too similar");

Une vérification rapide du fichier "obscure.c" donne ceci (je ne coupe que le morceau de code correspondant):

static const char *password_check (
    const char *old,
    const char *new,
    const struct passwd *pwdp)
{
    const char *msg = NULL;
    char *oldmono, *newmono, *wrapped;

    if (strcmp (new, old) == 0) {
            return _("no change");
    }
    [...]
    if (palindrome (oldmono, newmono)) {
            msg = _("a palindrome");
    } else if (strcmp (oldmono, newmono) == 0) {
            msg = _("case changes only");
    } else if (similar (oldmono, newmono)) {
            msg = _("too similar");
    } else if (simple (old, new)) {
            msg = _("too simple");
    } else if (strstr (wrapped, newmono) != NULL) {
            msg = _("rotated");
    } else {
    }
    [...]
    return msg;
}

Donc, maintenant, nous savons qu'il y a une fonction "similaire" basée sur l'ancien et le nouveau qui vérifie si les deux sont similaires. Voici l'extrait de code:

/*
 * more than half of the characters are different ones.
 */
static bool similar (const char *old, const char *new)
{
    int i, j;

    /*
     * XXX - sometimes this fails when changing from a simple password
     * to a really long one (MD5).  For now, I just return success if
     * the new password is long enough.  Please feel free to suggest
     * something better...  --marekm
     */
    if (strlen (new) >= 8) {
            return false;
    }

    for (i = j = 0; ('\0' != new[i]) && ('\0' != old[i]); i++) {
            if (strchr (new, old[i]) != NULL) {
                    j++;
            }
    }

    if (i >= j * 2) {
            return false;
    }

    return true;
}

Je n'ai pas examiné le code C. Je me suis limité à faire confiance au commentaire juste avant la définition de la fonction :-)


La différenciation entre les plates-formes compatibles PAM et NON-PAM est définie dans le fichier "obscure.c" structuré comme suit:

#include <config.h>
#ifndef USE_PAM
[...lots of things, including all the above...]
#else                           /* !USE_PAM */
extern int errno;               /* warning: ANSI C forbids an empty source file */
#endif                          /* !USE_PAM */

45
2017-12-28 18:14



C'est une longue réponse qui ne semble pas répondre directement à la question de savoir comment comparer les anciens mots de passe avec les mots de passe hachés. - jamesdlin
@jamesdlin: comme indiqué dans le commentaire de Rinzwind à la question originale, les hashes font NE PAS jouez n'importe quel rôle dans cette affaire: lorsque vous émettez la commande "passwd" pour changer le mot de passe, vous devez fournir à la fois "ancien" et "nouveau" mot de passe. Donc, le code "passwd" n'a aucun problème à comparer / vérifier les deux le mot de passe à la fois (dans des formes claires, pas du tout haché). - Damiano Verzulli
@DamianoVerzulli Néanmoins, cela ne règle pas vraiment la question. La question n'était pas "quel code C utilisez-vous pour dire si deux chaînes sont similaires?" c'est exactement la même chose pour les mots de passe que pour toute autre chose. La chose à propos de mots de passe ce qui les rend intéressants, c'est qu'ils ne sont jamais stockés en texte clair, et c'est ce que la question demande. Cela répond à "quels critères sont utilisés et comment est-il fait en C", mais il est beaucoup trop long pour "quels critères" et "comment ferais-je cela en C"? - cpast
@DamianoVerzulli Et le fait que passwd demande à la fois les anciens et les nouveaux mots de passe Est la réponse. Le reste de cette réponse est inutile. - jamesdlin
+1 pour une réponse extrêmement pertinente et intéressante! Il est intéressant de voir que le code comparant le mot de passe fonctionne réellement sur le texte en clair et, comme prévu, pas sur le hachage. - nico


La réponse est beaucoup plus simple que vous ne le pensez. En fait, il est presque qualifié de magique, car une fois que vous expliquez le truc, il est parti:

$ passwd
Current Password:
New Password:
Repeat New Password:

Password changed successfully

Il sait que votre nouveau mot de passe est similaire ... Parce que vous avez tapé l'ancien en un instant.


37
2017-12-29 13:41



"... ou des bonbons." - Nick T
Stupide lapin, trix sont pour les enfants! - iAdjunct
Qu'est-ce qu'il n'explique pas, c'est quand il connaît vos n mots de passe passés :) "Mot de passe a été utilisé trop récemment", ce qui empêche l'échange des mêmes mots de passe dans un environnement d'entreprise. - Juha Untinen
@Juha Untinen: C'est vrai, mais cela peut se faire en se rappelant simplement les N derniers hachages. Catching "identique à Nth password" est facile, c'est le "similaire à Nth password "c'est difficile. Autant que je sache, ces systèmes ne vérifient que la similarité avec le dernier mot de passe, et la même chose avec le dernier N. S'ils vérifient la similarité avec le dernier N ... c'est vraiment intéressant astuce maintenant, n'est-ce pas, je ne sais pas comment ils vont faire ça. - Cort Ammon


Bien que les autres réponses soient correctes, il peut être utile de mentionner que vous n'avez pas besoin de fournir l'ancien mot de passe pour que cela fonctionne!

En fait, vous pouvez générer un tas de mots de passe similaires au nouveau mot de passe que vous avez fourni, les hacher, puis vérifier si l'un de ces hachages correspond à l'ancien. Si tel est le cas, le nouveau mot de passe est jugé similaire à l'ancien! :)


8
2018-01-02 11:06



Bien que ce soit effectivement un moyen de réaliser cet exploit (et est utilisé par de nombreux sites Web), ce n'est pas ce qui se passe dans ce cas. - Brian S
C'est un bon tour! Un peu plus intensif en calcul, mais intelligent! - Cort Ammon
Vous devriez au moins donner une estimation du nombre de mots de passe similaires à générer pour effectuer une vérification significative ou un lien vers une ressource externe. Sinon, il ne s'agit que d'une idée d'une alternative possible, et non d'une réponse fondée. - hyde
@hyde qui dépend de critères auxquels on peut penser. Pour moi, les mots de passe sont similaires si 3 caractères maximum ont été ajoutés / supprimés / modifiés. Donc, il y a 62 hachages pour chaque caractère (et cela si nous n'utilisons que des caractères alphanumériques) fois la combinaison de 3 de la longueur du mot de passe (n), lequel est 62 * (n!)/(6 * (n - 3)!), ce qui équivaut à 13540 pour un mot de passe de 12 caractères. Mais si quelqu'un pense à quelque chose de différent, l'équation est inutile, alors pourquoi s'en préoccuper? - Killah
Réponse stupide, mais un aperçu néanmoins. Pourquoi stupide? 1. Vous devez générer un nombre inimaginable de hachages. 2. Une telle configuration affaiblirait la sécurité du mot de passe original. Si quelqu'un obtenait un hachage de tous les mots de passe similaires au lieu d'un simple hachage, il aurait beaucoup plus de facilité à le déchiffrer. - Rok Kralj


Un aspect n'était pas couvert: l'historique des mots de passe. Certains systèmes supportent cela. Pour ce faire, il conserve l'historique des mots de passe et les crypte avec le mot de passe actuel. Lorsque vous modifiez votre mot de passe, il utilise l'ancien mot de passe pour déchiffrer la liste et vérifier. Et quand il définit un nouveau mot de passe, il sauvegarde la liste (à nouveau) chiffrée avec une clé dérivée du nouveau mot de passe.

C'est ainsi remember=N fonctionne dans PAM (stocké dans /etc/security/opasswd). Mais Windows et d'autres fournisseurs Unix offrent également des fonctions similaires.


4