නව මුරපදය පෙර පැවති වචනයට සමාන බව ලිනක්ස් දැන ගන්නේ කෙසේද?

විවිධ ලිනක්ස් යන්ත්‍රවල පරිශීලක මුරපදයක් වෙනස් කිරීමට මම කිහිප වතාවක් උත්සාහ කළ අතර නව මුරපදය පැරණි එකට සමාන වූ විට, මෙහෙයුම් පද්ධතිය පැමිණිලි කළේ ඒවා බොහෝ සමාන බවයි.

මම නිතරම කල්පනා කළා, පද්ධතිය මෙය දන්නේ කෙසේද? මුරපදය හැෂ් ලෙස සුරකින බව මම සිතුවෙමි. මෙයින් අදහස් කරන්නේ පද්ධතියට නව මුරපදය සමානකම් සඳහා සංසන්දනය කිරීමට හැකි වූ විට පැරණි එක සත්‍ය පෙළ ලෙස සුරකින බවයි?

භාවිතා කරන විට පැරණි හා නව මුරපදය සැපයීමට ඔබට අවශ්‍ය බැවින් passwdඒවා ධාවකයේ කොතැනක හෝ ලිවීමකින් තොරව සරල පෙළ, මතකයේ පහසුවෙන් සැසඳිය හැකිය.

ඇත්ත වශයෙන්ම ඔබගේ මුරපදය ගබඩා කර ඇති විට එය හෑෂ් කර ඇත, නමුත් එය සිදු වන තුරු, ඔබ ඔබේ මුරපදය ඇතුළත් කරන මෙවලම වෙනත් ඕනෑම වැඩසටහනකට STDIN වෙතින් කියවන අතරතුර ඔබේ යතුරුපුවරුවේ ඇතුළත් කළ දේට ප්‍රවේශ විය හැකිය.

මෙය PAM පද්ධතියේ අංගයක් වන අතර එය passwdමෙවලමෙහි පසුබිමෙහි භාවිතා වේ . නවීන ලිනක්ස් බෙදාහැරීම් මගින් PAM භාවිතා කරයි.

වඩාත් නිශ්චිතවම, pam_cracklibPAM සඳහා වන මොඩියුලයක් වන අතර එය දුර්වලතා කිහිපයක් මත පදනම්ව මුරපද ප්‍රතික්ෂේප කිරීමට ඉඩ සලසයි.

එය අනාරක්ෂිත යැයි සැලකිය හැකි මුරපද පමණක් නොවේ. මෙම මූල කේතය මුරපදයක් ඇති palindrome හෝ කුමක් සංස්කරණය දුර වචන දෙක අතර වේ ද යන්න උදා, පරීක්ෂා කළ හැක දේ විවිධ උදාහරණ ඇත. මුරපද ශබ්ද කෝෂ ප්‍රහාරයන්ට වඩා ප්‍රතිරෝධී කිරීම මෙහි අදහසයි.

මෙයද බලන්න ද pam_cracklibmanpage.

අවම වශයෙන් මගේ උබුන්ටු වල, “බොහෝ සමාන” පණිවිඩ එළියට එයි විට: "... අක්ෂරවලින් අඩකට වඩා වෙනස් ඒවා ...." (විස්තර සඳහා පහත බලන්න). @slhck පිළිතුරෙහි පැහැදිලිව විස්තර කර ඇති පරිදි PAM සහාය සඳහා ස්තූතියි.

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

මම සී කේතය සමාලෝචනය කර නැත. ශ්‍රිත අර්ථ දැක්වීමට මොහොතකට පෙර අදහස් දැක්වීම විශ්වාස කිරීමට මා සීමා විය :-)

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=NPAM හි ක්‍රියා කරන ආකාරය මෙයයි (ගබඩා කර ඇත /etc/security/opasswd). නමුත් වින්ඩෝස් සහ අනෙකුත් යුනික්ස් වෙළෙන්දෝ ද ඒ හා සමාන කාර්යයන් ඉදිරිපත් කරති.