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

Quelques fois, j'ai essayé de modifier le mot de passe d'un utilisateur sur différentes machines Linux. Lorsque le nouveau mot de passe était similaire à l'ancien, le système d'exploitation s'est plaint de leur similitude.

Je me suis toujours demandé comment le système le sait-il? Je pensais que le mot de passe est enregistré sous forme de hachage. Cela signifie-t-il que lorsque le système est capable de comparer le nouveau mot de passe pour la similarité, l'ancien est réellement enregistré en tant que texte brut?

Étant donné que vous devez fournir à la fois l'ancien et le nouveau mot de passe passwd, vous pouvez facilement les comparer 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 se produise, l’outil dans lequel vous entrez votre mot de passe peut bien sûr y accéder directement comme tout autre programme peut accéder aux éléments que vous avez entrés sur votre clavier alors qu’il lisait depuis STDIN.

Il s'agit d'une fonctionnalité du système PAM utilisée en arrière-plan de l' passwdoutil. PAM est utilisé par les distributions Linux modernes.

Plus spécifiquement, pam_cracklibest 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 les mots de passe trop similaires qui peuvent être considérés comme non sécurisés. Le code source contient divers exemples de ce qui peut être vérifié, par exemple si un mot de passe est un palindrome ou quelle est la distance d'édition entre deux mots. L'idée est de rendre les mots de passe plus résistants aux attaques par dictionnaire.

Voir aussi la pam_cracklibpage de manuel.

Au moins dans mon Ubuntu, les messages "trop ​​similaires" disparaissent when: "... 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 @slhck.

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

Pour vérifier davantage 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 package 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 de "obscure.c" donne ceci (je ne fais que copier-coller 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 existe une fonction "similaire" basée sur l'ancien et le nouveau chèque 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 revu 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" qui est 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 */

La réponse est beaucoup plus simple que vous ne le pensez. En fait, cela peut presque être qualifié de magie, 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 saisi l'ancien un instant auparavant.

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

En fait, il est possible de générer un groupe de mots de passe similaire au nouveau mot de passe que vous avez fourni, de les hacher, puis de 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! :)

Un aspect n'était pas couvert: l'historique des mots de passe. Certains systèmes supportent cela. Pour ce faire, il conserve un historique des mots de passe et les chiffre 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 enregistre la liste (à nouveau) cryptée avec une clé dérivée du nouveau mot de passe.

Voici comment cela remember=Nfonctionne dans PAM (stocké dans /etc/security/opasswd). Mais Windows et d'autres fournisseurs Unix offrent également des fonctions similaires.