Woher weiß Linux, dass das neue Passwort dem vorherigen ähnlich ist?

Einige Male habe ich versucht, ein Benutzerkennwort auf verschiedenen Linux-Rechnern zu ändern, und als das neue Kennwort dem alten ähnlich war, beklagte sich das Betriebssystem, dass sie zu ähnlich waren.

Ich habe mich immer gefragt, woher das System das weiß. Ich dachte, dass das Passwort als Hash gespeichert wird. Bedeutet dies, dass das alte Passwort tatsächlich als Klartext gespeichert wird, wenn das System das neue Passwort auf Ähnlichkeit vergleichen kann?

Da Sie bei der Verwendung sowohl das alte als auch das neue Kennwort eingeben müssen passwd, können diese problemlos im Klartext und im Speicher verglichen werden, ohne dass sie irgendwo auf das Laufwerk geschrieben werden müssen.

Ihr Passwort wird zwar gehasht, wenn es endgültig gespeichert ist, aber bis dahin kann das Tool, in das Sie Ihr Passwort eingeben, natürlich genauso direkt darauf zugreifen wie jedes andere Programm auf Dinge, die Sie beim Lesen von STDIN über Ihre Tastatur eingegeben haben.

Dies ist eine Funktion des PAM-Systems, die im Hintergrund des passwdTools verwendet wird. PAM wird von modernen Linux-Distributionen verwendet.

Genauer gesagt pam_cracklibhandelt es sich um ein Modul für PAM, mit dem Kennwörter abgelehnt werden können, die auf mehreren Schwachstellen beruhen, die sie sehr anfällig machen würden.

Nicht nur zu ähnliche Passwörter können als unsicher eingestuft werden. Der Quellcode enthält verschiedene Beispiele dafür, was überprüft werden kann, z. B. ob ein Passwort ein Palindrom ist oder wie groß der Bearbeitungsabstand zwischen zwei Wörtern ist. Die Idee ist, Passwörter widerstandsfähiger gegen Wörterbuchangriffe zu machen.

Siehe auch die pam_cracklibManpage.

Zumindest in meinem Ubuntu kommt die "zu ähnliche" Nachricht raus wenn: "... mehr als die Hälfte der Zeichen sind verschiedene ..." (Einzelheiten siehe unten). Dank der PAM-Unterstützung, wie in der @ slhck-Antwort deutlich erklärt.

Für andere Plattformen, auf denen PAM nicht verwendet wird, werden die "zu ähnlichen" Meldungen ausgegeben, wenn: "... mehr als die Hälfte der Zeichen unterschiedliche sind ...." (Einzelheiten siehe unten)

Um diese Aussage selbst weiter zu überprüfen, können Sie den Quellcode überprüfen. Hier ist, wie.

Das "passwd" -Programm ist im passwd-Paket enthalten:

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

Da es sich um Open Source-Technologien handelt, haben wir uneingeschränkten Zugriff auf Quellcode. Es zu bekommen ist so einfach wie:

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

Danach ist es einfach, das entsprechende Codefragment zu finden:

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

Eine schnelle Überprüfung der "obscure.c" ergibt dies (ich schneide nur den relevanten Teil des Codes aus und füge ihn ein):

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

Jetzt wissen wir also, dass es eine "ähnliche" Funktion gibt, die auf der alten und der neuen basiert und prüft, ob beide ähnlich sind. Hier ist der Ausschnitt:

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

Ich habe den C-Code nicht überprüft. Ich habe mich darauf beschränkt, dem Kommentar kurz vor der Funktionsdefinition zu vertrauen :-)

Die Unterscheidung zwischen PAM- und NON-PAM-fähigen Plattformen wird in der Datei "obscure.c" definiert, die wie folgt aufgebaut ist:

#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 */

Die Antwort ist viel einfacher als Sie denken. Tatsächlich ist es fast wie Zauberei, denn sobald Sie den Trick erklärt haben, ist er weg:

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

Password changed successfully

Es weiß, dass Ihr neues Passwort ähnlich ist ... Weil Sie das alte in einem Moment zuvor eingegeben haben.

Obwohl die anderen Antworten richtig sind, kann es erwähnenswert sein, dass Sie nicht das alte Passwort eingeben müssen, damit dies funktioniert!

Tatsächlich kann man eine Reihe von Passwörtern erstellen, die dem von Ihnen eingegebenen neuen Passwort ähneln, sie hacken und dann prüfen, ob einer dieser Hashes mit dem alten übereinstimmt. Ist dies der Fall, wird das neue Passwort ähnlich wie das alte beurteilt! :)

Ein Aspekt wurde nicht behandelt: Kennwortverlauf. Einige Systeme unterstützen dies. Zu diesem Zweck werden Kennwörter im Verlauf gespeichert und mit dem aktuellen Kennwort verschlüsselt. Wenn Sie Ihr Passwort ändern, wird das "alte" Passwort verwendet, um die Liste zu entschlüsseln und zu überprüfen. Wenn ein neues Passwort festgelegt wird, wird die Liste (erneut) mit einem vom neuen Passwort abgeleiteten Schlüssel verschlüsselt gespeichert.

So remember=Nfunktioniert das in PAM (gespeichert in /etc/security/opasswd). Aber auch Windows und andere Unix-Anbieter bieten ähnliche Funktionen.