it-swarm.com.de

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?

141
Arkonix

Da Sie bei Verwendung von passwd sowohl das alte als auch das neue Kennwort angeben müssen, können Sie diese problemlos im Klartext und im Speicher vergleichen, ohne sie irgendwo auf das Laufwerk schreiben zu 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 Tools passwd verwendet wird. PAM wird von modernen Linux-Distributionen verwendet.

Insbesondere ist pam_cracklib 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. 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 Manpage pam_cracklib.

156
slhck

Zumindest in meinem Ubuntu kommt die "zu ähnliche" Nachricht raus when: "... 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.

Auf anderen Plattformen, auf denen PAM nicht verwendet wird, werden die "zu ähnlichen" Meldungen ausgegeben, wenn: "... mehr als die Hälfte der Zeichen unterschiedlich sind ...." (Einzelheiten siehe unten)

Um diese Aussage selbst weiter zu überprüfen, ist es möglich, den Quellcode zu überprüfen. Hier ist, wie.

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

[email protected]:~$ which passwd
/usr/bin/passwd
[email protected]:~$ 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:

[email protected]:/usr/local/src/passwd$ apt-get source passwd

Danach ist es einfach, das entsprechende Codefragment zu finden:

[email protected]:/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 kurze Ü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 folgendermaßen 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 */
46

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.

37
Cort Ammon

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 erzeugen, die dem von Ihnen eingegebenen neuen Passwort ähneln, sie hashen 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! :)

8
Ant

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 funktioniert remember=N in PAM (gespeichert in /etc/security/opasswd). Aber auch Windows und andere Unix-Anbieter bieten ähnliche Funktionen.

4
eckes