Come fa Linux a sapere che la nuova password è simile alla precedente?

Alcune volte ho provato a cambiare una password utente su varie macchine Linux e quando la nuova password era simile a quella precedente, il sistema operativo si è lamentato del fatto che erano troppo simili.

Mi sono sempre chiesto, come fa il sistema a saperlo? Ho pensato che la password fosse salvata come hash. Ciò significa che quando il sistema è in grado di confrontare la nuova password per somiglianza, quella vecchia viene effettivamente salvata come testo normale?

Dato che è necessario fornire sia la vecchia che la nuova password durante l'utilizzo passwd, possono essere facilmente confrontati in testo normale, in memoria, senza scriverli da qualche parte sul disco.

In effetti la tua password viene cancellata quando viene finalmente memorizzata, ma fino a quando ciò accade, lo strumento in cui stai inserendo la tua password può ovviamente accedervi direttamente come qualsiasi altro programma può accedere alle cose che hai inserito sulla tastiera mentre stava leggendo da STDIN.

Questa è una caratteristica del sistema PAM che viene utilizzato in background sullo passwdstrumento. PAM è utilizzato dalle moderne distribuzioni Linux.

Più specificamente, pam_cracklibè un modulo per PAM che consente di rifiutare le password in base a diversi punti deboli che le renderebbero molto vulnerabili.

Non sono solo le password troppo simili che possono essere considerate non sicure. Il codice sorgente contiene vari esempi di cosa può essere verificato, ad esempio se una password è un palindromo o quale sia la distanza di modifica tra due parole. L'idea è di rendere le password più resistenti agli attacchi del dizionario.

Vedi anche la pam_cracklibmanpage.

Almeno nel mio Ubuntu, i messaggi "troppo simili" vengono fuori quando: "... più della metà dei personaggi sono diversi ...." (vedi sotto per i dettagli). grazie al supporto PAM, come spiegato chiaramente nella risposta @slhck.

Per altre piattaforme, in cui PAM non viene utilizzato, i messaggi "troppo simili" vengono visualizzati quando: "... più della metà dei personaggi sono diversi ...." (vedi sotto per i dettagli)

Per controllare ulteriormente questa affermazione da solo, è possibile controllare il codice sorgente. Ecco come.

Il programma "passwd" è incluso nel pacchetto passwd:

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

Dato che abbiamo a che fare con le tecnologie Open Source, abbiamo accesso illimitato al codice sorgente. Ottenere è semplice come:

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

Successivamente è facile trovare il frammento di codice rilevante:

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");

Un rapido controllo su "obscure.c" dà questo (sto solo incollando il pezzo di codice pertinente):

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;
}

Quindi, ora sappiamo che esiste una funzione "simile" che si basa sul vecchio e sul nuovo controllo se entrambi sono simili. Ecco il frammento:

/*
 * 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;
}

Non ho rivisto il codice C. Mi sono limitato a fidarmi del commento appena prima della definizione della funzione :-)

La differenziazione tra piattaforme compatibili con PAM e NON-PAM è definita nel file "obscure.c" strutturato come:

#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 risposta è molto più semplice di quanto pensi. In effetti, quasi si qualifica come magia, perché una volta spiegato il trucco, è andato:

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

Password changed successfully

Sa che la tua nuova password è simile ... Perché hai digitato la vecchia solo un momento prima.

Anche se le altre risposte sono giuste, potrebbe valere la pena ricordare che non è necessario fornire la vecchia password per farlo funzionare!

In effetti, è possibile generare un gruppo di password simile alla nuova password fornita, l'hash e quindi verificare se uno di questi hash corrisponde a quello precedente. In questo caso, la nuova password viene giudicata simile a quella precedente! :)

Un aspetto non è stato trattato: la cronologia delle password. Alcuni sistemi supportano questo. Per fare ciò, mantiene una cronologia delle password e le crittografa con la password corrente. Quando si modifica la password, utilizza la "vecchia" password per decrittografare l'elenco e verificarlo. E quando imposta una nuova password, salva l'elenco (di nuovo) crittografato con una chiave derivata dalla nuova password.

Ecco come remember=Nfunziona in PAM (memorizzato in /etc/security/opasswd). Ma anche Windows e altri fornitori Unix offrono funzioni simili.