Linux รู้ได้อย่างไรว่ารหัสผ่านใหม่คล้ายกับรหัสผ่านก่อนหน้า

สองสามครั้งที่ฉันพยายามเปลี่ยนรหัสผ่านผู้ใช้บนเครื่อง Linux ต่างๆและเมื่อรหัสผ่านใหม่คล้ายกับรหัสเก่าระบบปฏิบัติการบ่นว่าพวกเขาคล้ายกันเกินไป

ฉันสงสัยอยู่เสมอว่าระบบรู้ได้อย่างไร ฉันคิดว่ารหัสผ่านถูกบันทึกเป็นแฮช นี่หมายความว่าเมื่อระบบสามารถเปรียบเทียบรหัสผ่านใหม่เพื่อความคล้ายคลึงกันรหัสเดิมจะถูกบันทึกเป็นข้อความธรรมดาหรือไม่

เนื่องจากคุณต้องระบุทั้งรหัสผ่านเก่าและรหัสผ่านใหม่เมื่อใช้passwdงานจึงสามารถเปรียบเทียบได้อย่างง่ายดายในข้อความธรรมดาในหน่วยความจำโดยไม่ต้องเขียนลงในไดรฟ์

แน่นอนรหัสผ่านของคุณจะถูกแฮชเมื่อมันถูกเก็บไว้ในที่สุด แต่จนกระทั่งเกิดขึ้นเครื่องมือที่คุณป้อนรหัสผ่านของคุณสามารถเข้าถึงได้โดยตรงเช่นโปรแกรมอื่น ๆ สามารถเข้าถึงสิ่งที่คุณป้อนบนแป้นพิมพ์ในขณะที่อ่านจาก STDIN

นี่คือคุณสมบัติของระบบ PAMที่ใช้ในพื้นหลังของpasswdเครื่องมือ PAM ถูกใช้โดยลีนุกซ์รุ่นใหม่

โดยเฉพาะอย่างยิ่งpam_cracklibเป็นโมดูลสำหรับ PAM ที่อนุญาตให้ปฏิเสธรหัสผ่านตามจุดอ่อนต่าง ๆ ที่จะทำให้พวกเขามีความเสี่ยงมาก

ไม่ใช่แค่รหัสผ่านที่คล้ายกันมากเกินไปที่อาจถือว่าไม่ปลอดภัย รหัสที่มา มีตัวอย่างต่าง ๆ ของสิ่งที่สามารถตรวจสอบได้เช่นว่ารหัสผ่านเป็น palindrome หรือสิ่งที่แก้ไขระยะทางที่อยู่ระหว่างคำสองคำ แนวคิดคือการทำให้รหัสผ่านทนต่อการโจมตีด้วยพจนานุกรมได้มากขึ้น

ดูเพิ่มเติมที่pam_cracklibmanpage

อย่างน้อยใน Ubuntu ของฉันข้อความ "คล้ายกันมาก" ก็หมดลง เมื่อ: "... มากกว่าครึ่งหนึ่งของตัวละครต่างกัน .... " (ดูรายละเอียดด้านล่าง) ขอบคุณที่รองรับ PAM ดังที่อธิบายไว้ในคำตอบ @slhck อย่างชัดเจน

สำหรับแพลตฟอร์มอื่น ๆ ที่ไม่ได้ใช้ PAM ข้อความ "คล้ายกันมากเกินไป" จะเกิดขึ้นเมื่อ: "... มากกว่าครึ่งหนึ่งของตัวละครต่างกัน ... " (ดูรายละเอียดด้านล่าง)

หากต้องการตรวจสอบคำแถลงนี้เพิ่มเติมด้วยตนเองคุณสามารถตรวจสอบซอร์สโค้ดได้ นี่คือวิธี

โปรแกรม "passwd" รวมอยู่ในแพ็คเกจ passwd:

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

ขณะที่เราจัดการกับเทคโนโลยีโอเพ่นซอร์สเรามีการเข้าถึงซอร์สโค้ดแบบไม่ จำกัด รับมันง่ายเหมือน:

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

หลังจากนั้นง่ายต่อการค้นหาส่วนที่เกี่ยวข้องของรหัส:

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

ตรวจสอบอย่างรวดเร็วเพื่อ "obscure.c" ให้สิ่งนี้ (ฉันตัดและวางเฉพาะส่วนที่เกี่ยวข้องของรหัส):

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

ดังนั้นตอนนี้เรารู้ว่ามีฟังก์ชั่น "ที่คล้ายกัน" ซึ่งขึ้นอยู่กับการตรวจสอบเก่าและการตรวจสอบใหม่หากทั้งสองมีความคล้ายคลึงกัน นี่คือตัวอย่าง:

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

ฉันยังไม่ได้ตรวจสอบรหัส C ฉัน จำกัด ตัวเองในการไว้วางใจความคิดเห็นก่อนหน้านิยามฟังก์ชัน :-)

ความแตกต่างระหว่างแพลตฟอร์มการรับรู้ของ PAM และ NON-PAM นั้นกำหนดไว้ในไฟล์ "obscure.c" ที่มีโครงสร้างเช่น:

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

คำตอบนั้นง่ายกว่าที่คุณคิด ในความเป็นจริงมันเกือบจะมีคุณสมบัติเหมือนเวทมนตร์เพราะเมื่อคุณอธิบายเคล็ดลับมันหายไป:

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

Password changed successfully

มันรู้รหัสผ่านใหม่ของคุณคล้ายกัน ... เพราะคุณพิมพ์รหัสเก่าในเวลาก่อน

แม้ว่าคำตอบอื่น ๆ นั้นถูกต้อง แต่ก็อาจคุ้มค่าที่จะพูดถึงว่าคุณไม่จำเป็นต้องใส่รหัสผ่านเก่าเพื่อให้มันใช้งานได้!

ในความเป็นจริงเราสามารถสร้างรหัสผ่านได้หลายแบบคล้ายกับรหัสผ่านใหม่ที่คุณให้ไว้แฮชรหัสผ่านแล้วตรวจสอบว่าแฮชเหล่านี้ตรงกับรหัสเดิมหรือไม่ หากเป็นกรณีนี้รหัสผ่านใหม่จะถูกตัดสินเช่นเดียวกับรหัสผ่านเก่า! :)

ไม่ได้ครอบคลุมด้านหนึ่ง: ประวัติรหัสผ่าน บางระบบรองรับสิ่งนี้ ในการดำเนินการดังกล่าวจะเก็บประวัติรหัสผ่านและเข้ารหัสด้วยรหัสผ่านปัจจุบัน เมื่อคุณเปลี่ยนรหัสผ่านจะใช้รหัสผ่าน "เก่า" เพื่อถอดรหัสรายการและตรวจสอบ และเมื่อมันตั้งรหัสผ่านใหม่มันจะบันทึกรายการ (อีกครั้ง) เข้ารหัสด้วยคีย์ที่ได้รับจากรหัสผ่านใหม่

นี่คือวิธีการremember=Nทำงานใน PAM (เก็บไว้ใน/etc/security/opasswd) แต่ผู้ค้า Windows และ Unix รายอื่น ๆ ก็มีฟังก์ชั่นที่คล้ายกัน