php - 什么密码强度被认为足以与 password_hash 函数一起使用？

Question

据我了解，新 PHP password hashing extension 最重要的功能之一(或一般的 bcrypt)是算法的速度，它大大减慢了暴力攻击方法。

但它仍然以一定的速度运行，这对于字典攻击和暴力破解弱密码来说肯定足够了，[据说] 短于六个字母数字字符。

所以我想知道，它为什么这么慢，尤其是 - 哪种密码强度被认为可以安全使用。“你能想象的那么强大”不是答案，因为密码强度始终是安全性和可用性之间的权衡——所以，我正在寻找可以被认为是安全的，甚至是面向 future 的最小强度。

请注意，我是一个实践者 - 因此，基于具体数字的确定答案比冗长而空洞的理论推理和不确定的结论更可取。

进一步澄清，假设最坏的情况:用户数据库被盗，有人会尝试破译密码。由于盐含量高，彩虹 table 不是一种选择。因此，剩下的唯一向量是字典攻击和暴力破解。假设我们为用户提供预生成的密码，消除字典攻击。这就是为什么密码强度是我唯一关心的问题。

更新:
看来我没有被很好地理解。对我来说，这个问题非常实用，而且相当可以回答。并且非常重要。

如果无法确定足够的密码强度，可能会质疑这种新算法的使用。 如果密码仍然不安全，为什么还要使用好的算法呢？所以——我坚信——除了推荐使用新的散列算法外，应该始终推荐最小密码强度。我想知道。

换句话说，如果对一个部分存在特定的确定性——算法(“使用这个，而不是其他!”)——显然应该对另一部分有确定性——密码强度，可以用相同级别的权限说出来.否则，最弱的部分会破坏最强的部分。

Answer 1

我不确定我是否清楚地理解您的问题，但我只关注密码强度及其如何影响暴力攻击。

But still it runs at some speed, surely enough for the dictionary attack and to brute-force weak passwords, [supposedly] shorter than six alphanumeric characters.

简介

暂时忘掉散列算法(md5、sha、pbkdf2 bcrypt、scrypt 等)，以免专注于 Password Strength第一

密码强度 Wiki

这是衡量密码抵抗猜测和暴力攻击的有效性的指标。在通常的形式下，它会估计无法直接访问密码的攻击者平均需要进行多少次尝试才能正确猜出密码。

可以简单地计算为:

熵由 H=Llog2N 给出，其中 L 是密码的长度，N 是字母表的大小，并且通常以位为单位。

哈希函数

password_hash 默认使用 [bcrypt][4] 作为密码就足够了，但还有更好的选择，例如 PBKDF2或 scrypt有关我的意思的更多信息，请参阅 How To Safely Store A Password

使用 oclHashcat , 让我们估计以下

+--------+-----------+----------------+
|  HASH  | ESTIMATE  |     BITS/S     |
+--------+-----------+----------------+
| MD5    | 10742M    | 90110427136    |
| BCRYPT | 31M       | 260046848      |
+--------+-----------+----------------+

请注意，这是一个估计值，可能会因硬件容量而异

有了这些信息，我们可以安全地计算出暴力破解不同密码需要多长时间

用 PHP 计算熵

$passwords = array(
        "1234",
        "F2A1CC",
        "password",
        "PaSSworD",
        "P4ssw0Rd97",
        "p#aSS*Word14",
        "Dance With Me Tonight" 
);

print("PASSWORD\tLENGTH\tENTROPY\tTIME MD5\tTIME BCRYPT\n");

foreach($passwords as $password ){

    printf("%s\t%s\t%s\t%s\t%s\n", 
        $password, 
        strlen($password), 
        $entropy = calculateEntropy($password), 
        totalTime($entropy, "90110427136"),     // Check with MD5
        totalTime($entropy, "260046848")        // Check with BCrypt
    );
}

输出

+-----------------------+--------+---------+------------+----------------+
|       PASSWORD        | LENGTH | ENTROPY |  TIME MD5  |  TIME BCRYPT   |
+-----------------------+--------+---------+------------+----------------+
| 1234                  |      4 |  13.29  | 1min       | 1min           |
| F2A1CC                |      6 |  24.00  | 1min       | 1min           |
| password              |      8 |  37.60  | 1min       | 1min           |
| PaSSworD              |      8 |  45.60  | 1min       | 1day+          |
| P4ssw0Rd97            |     10 |  59.54  | 2mo+       | 71yr+          |
| p#aSS*Word14          |     12 |  75.86  | 13,479yr+  | 4yr+           |
| Dance With Me Tonight |     21 |  120.29 | 474,250yr+ | 164,335,595yr+ |
+-----------------------+--------+---------+------------+----------------+

Output Converted using csv2table

密码破解器的 CUDA/OpenCL 实现可以利用 GPU 中可用的大量并行性，峰值为 billions of candidate passwords a second。 .

让我们估计我们可以在非常快的系统上并行执行 921600M c/s

T = 966367641600 * 8   
T = 7,730,941,132,800  // bits/sec

使用

foreach($passwords as $password ){  
    printf("%s\t%s\t%s\t%s\n", 
        $password, 
        strlen($password), 
        $entropy = calculateEntropy($password), 
        totalTime($entropy, "7730941132800")        // Check with Hash
    );
}

输出

+-----------------------+---------+---------+----------+
|       PASSWORD        | LENGTH  | ENTROPY |   TIME   |
+-----------------------+---------+---------+----------+
| 1234                  |       4 | 13.29   | 1min     |
| F2A1CC                |       6 | 24.00   | 1min     |
| password              |       8 | 37.60   | 1min     |
| PaSSworD              |       8 | 45.60   | 1min     |
| P4ssw0Rd97            |      10 | 59.54   | 20hr+    |
| p#aSS*Word14          |      12 | 75.86   | 157yr+   |
| Dance With Me Tonight |      21 | 120.29  | 5,527yr+ |
+-----------------------+---------+---------+----------+

如您所见，要破解像样的 12 位数字还需要一段时间。

使用的函数

// Calculate Password entropy
// Uses H = L Log2 N
// where L is the length of the password and
// N is the size of the alphabet, and it is usually measured in bits
function calculateEntropy($password) {

    // See http://en.wikipedia.org/wiki/Password_strength
    // Entropy per symbol for different symbol sets
    // Missing All extended ASCII printable characters
    // Missing Diceware word list

    // TODO
    // Larger Character Set
    // '/[\!"#$%&\'\(\)\*\+,\-.\/:;<\=>\?\@\[\]^_`\{|\}~]+/' => 32,
    $cases = array(
            "/\s+/" => 1, // Arabic numerals (0–9) (e.g. PIN)
            "/[0-9]+/" => 10, // Arabic numerals (0–9) (e.g. PIN)
            "/[a-z]+/" => 26, // Case insensitive Latin alphabet (a-z)
            "/[A-Z]+/" => 26, // Case insensitive Latin alphabet (A-Z)
            '/[\!\@#$%\?\&\*\(\)_\-\+=~:;.]+/i' => 18  // Other Character
        );

    $L = strlen($password); // Length of password
    $N = 0; // Character Set

    foreach($cases as $regex => $value ){
        if (preg_match($regex, $password)){
            $N += $value;
        }
    }

    // Don't confuse hexadecimal for alpha numeric characters
    // hexadecimal numerals (0–9, A-F) (e.g. WEP keys)
    if (ctype_xdigit($password)){
        $N = 16;
    }

    // Fix pure number cases that might have been changed by hexadecimal
    // Arabic numerals (0–9) (e.g. PIN)
    if (ctype_digit($password)){
        $N = 10;
    }

    // Using H = L Log2N
    // See http://en.wikipedia.org/wiki/Password_strength
    // Random passwords entropy
    $H = $L * log($N, 2);
    return number_format($H, 2);
}

// Claculate Total time it would take
// Using Entropy & froce / s
function totalTime($entropy, $force) {
    bcscale(0);

    // Total Base on entorpy 2^H
    $total = bcpow(2, $entropy);

    // Time Taken per sec on Force
    $ss = bcdiv($total, $force);

    $time = "";
    $parts = [];

    $parts['yr'] = bcdiv($ss, "31104000");
    $parts['mo'] = bcdiv(bcmod($ss, 31104000), 2592000);
    $parts['day'] = bcdiv(bcmod($ss, 2592000), 86400);
    $parts['hr'] = bcdiv(bcmod($ss, 86400), 3600);

    // Clean Year
    // Can really generate large numbers

    $suffix = "";
    $yr = $parts['yr'];
    if (!empty($yr)){
        if (bccomp($yr, "1000000") > 0){
            $parts['yr'] = bcdiv($yr, "1000000"); // Million
            $year = " million ";
        }

        if (bccomp($yr, "1000000000") > 0){
            $parts['yr'] = bcdiv($yr, "1000000000"); // Billion
            $year = " billion ";
        }

        if (bccomp($yr, "1000000000000") > 0){
            $parts['yr'] = bcdiv($yr, "1000000000000"); // Trillion
            $year = " trillion ";
        }
    }

    foreach($parts as $t => $v ){
        if (empty($v)){
            continue;
        }
        $time .= number_format($v, 0) . $suffix . $t . "+";
        break;
    }

    return empty($time) ? "1min" : $time;
}

误会

你是对的密码长度很重要，就像密码的熵一样。大多数建议建议用户使用 use bcrypt 、密码复杂度等不了解密码强度

但事实是，最简单的密码往往也是最强大的。

Source | Related blog post

So I want to know, how it's certainly slow, and, particularly - which password strength considered safe to be used with.

Source

绝对不是 6 个字母 :)

• < 28 位 = 非常弱；可能会将家庭成员拒之门外
• 28 - 35 位 = 弱；应将大多数人拒之门外，通常适用于桌面登录密码
• 36 - 59 位 = 合理；相当安全的网络密码和公司密码
• 60 - 127 位 = 强；可以很好地保护财务信息
• 128+ 位 = 非常强；经常矫枉过正

结论

这里有一些很好的引用资料，你可能会看什么

• The Rainbow Table Is Dead
• oclHashcat
• How To Safely Store A Password
• Don't use bcrypt
• Password Entropy
• Password Strength/Entropy: Characters vs. Words
• HOW MUCH ENTROPY IN THAT PASSWORD?
• Kolmogorov complexity