¿Cómo sabe Linux que la nueva contraseña es similar a la anterior?

Algunas veces intenté cambiar una contraseña de usuario en varias máquinas Linux y cuando la nueva contraseña era similar a la anterior, el sistema operativo se quejó de que eran demasiado similares.

Siempre me pregunté, ¿cómo sabe esto el sistema? Pensé que la contraseña se guarda como un hash. ¿Significa esto que cuando el sistema puede comparar la nueva contraseña por similitud, la antigua realmente se guarda como texto sin formato?

Dado que debe proporcionar tanto la contraseña antigua como la nueva cuando se usa passwd, se pueden comparar fácilmente en texto sin formato, en memoria, sin escribirlas en algún lugar de la unidad.

De hecho, su contraseña se codifica cuando finalmente se almacena, pero hasta que eso suceda, la herramienta donde está ingresando su contraseña puede, por supuesto, acceder directamente como cualquier otro programa puede acceder a las cosas que ingresó en su teclado mientras leía desde STDIN.

Esta es una característica del sistema PAM que se utiliza en el fondo de la passwdherramienta. PAM es utilizado por las distribuciones modernas de Linux.

Más específicamente, pam_cracklibes un módulo para PAM que permite rechazar contraseñas basadas en varias debilidades que las harían muy vulnerables.

No solo las contraseñas que son demasiado similares pueden considerarse inseguras. El código fuente tiene varios ejemplos de lo que se puede verificar, por ejemplo, si una contraseña es un palíndromo o cuál es la distancia de edición entre dos palabras. La idea es hacer que las contraseñas sean más resistentes a los ataques de diccionario.

Ver también la página de pam_cracklibmanual.

Al menos en mi Ubuntu, los mensajes "demasiado similares" aparecen cuando: "... más de la mitad de los personajes son diferentes ..." (ver más abajo para más detalles). gracias al soporte de PAM, como se explica claramente en la respuesta @slhck.

Para otra plataforma, donde no se utiliza PAM, los mensajes "demasiado similares" aparecen cuando: "... más de la mitad de los caracteres son diferentes ..." (ver más abajo para más detalles)

Para verificar esta declaración por su cuenta, es posible verificar el código fuente. Aquí es cómo.

El programa "passwd" está incluido en el paquete passwd:

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

Como estamos tratando con tecnologías de código abierto, tenemos acceso ilimitado al código fuente. Conseguirlo es tan simple como:

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

Después es fácil encontrar el fragmento de código relevante:

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

Una comprobación rápida de "obscure.c" muestra esto (estoy cortando y pegando solo el fragmento de código relevante):

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

Entonces, ahora, sabemos que hay una función "similar" que se basa en el antiguo y el nuevo para verificar si ambos son similares. Aquí está el fragmento:

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

No he revisado el código C. Me limité a confiar en el comentario justo antes de la definición de la función :-)

La diferenciación entre las plataformas con reconocimiento PAM y NO PAM se define en el archivo "obscure.c" que está estructurado de la siguiente manera:

#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 respuesta es mucho más simple de lo que piensas. De hecho, casi califica como magia, porque una vez que explicas el truco, desaparece:

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

Password changed successfully

Sabe que tu nueva contraseña es similar ... Porque escribiste la anterior solo un momento antes.

Aunque las otras respuestas son correctas, vale la pena mencionar que no necesita proporcionar la contraseña anterior para que esto funcione.

De hecho, uno puede generar un montón de contraseñas similares a la nueva contraseña que proporcionó, aplicarles un hash y luego verificar si alguno de estos hashes coincide con el anterior. Si este es el caso, ¡la nueva contraseña se considera similar a la anterior! :)

Un aspecto no estaba cubierto: el historial de contraseñas. Algunos sistemas lo admiten. Para hacerlo, mantiene un historial de contraseñas y las cifra con la contraseña actual. Cuando cambia su contraseña, utiliza la contraseña "antigua" para descifrar la lista y verificar. Y cuando establece una nueva contraseña, guarda la lista (nuevamente) encriptada con una clave derivada de la nueva contraseña.

Así es como remember=Nfunciona en PAM (almacenado en /etc/security/opasswd). Pero también Windows y otros proveedores de Unix ofrecen funciones similares.