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

Au moins dans mon Ubuntu, le message "trop similaire" apparaît. quand : "...plus de la moitié des personnages sont différents...." (voir ci-dessous pour plus de détails). grâce au support PAM, comme expliqué clairement dans la réponse de @slhck.

Pour les autres plates-formes, où PAM n'est pas utilisé, le message "trop similaire" apparaît lorsque : "...plus de la moitié des personnages sont différents...." (voir ci-dessous pour plus de détails)

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

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

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

Comme nous avons affaire à des technologies Open Source, nous avons un accès illimité au code source. Pour l'obtenir, rien de plus simple :

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 et colle que le morceau de code concerné) :

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" qui, en se basant sur l'ancien et le nouveau, vérifie si les deux sont similaires. Voici l'extrait :

/*
 * 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 plateformes conscientes de PAM et celles qui ne le sont pas est définie dans le fichier "obscure.c" qui est structuré de la manière suivante :

#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 bien plus simple que vous ne le pensez. En fait, c'est presque de la magie, car une fois que vous avez expliqué le tour, il disparaît :

$ 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 juste un instant avant.

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, on peut 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 c'est le cas, alors le nouveau mot de passe est jugé similaire à l'ancien ! :)

Un aspect n'a pas été couvert : l'historique des mots de passe. Certains systèmes le permettent. Pour ce faire, il conserve un historique des mots de passe et les crypte avec le mot de passe actuel. Lorsque vous changez de mot de passe, il utilise l'"ancien" mot de passe pour décrypter la liste et la vérifier. Et lorsqu'il définit un nouveau mot de passe, il enregistre la liste (à nouveau) chiffrée avec une clé dérivée du nouveau mot de passe.

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