从PHP 5.5开始，PHP就有了简单安全的散列和验证密码的函数password_hash()和password_verify()

$password = 'anna';
$hash = password_hash($password, PASSWORD_DEFAULT);
$expensiveHash = password_hash($password, PASSWORD_DEFAULT, array('cost' => 20));

password_verify('anna', $hash); //Returns true
password_verify('anna', $expensiveHash); //Also returns true
password_verify('elsa', $hash); //Returns false

当使用password_hash()时，它生成一个随机的盐并将其包含在输出的哈希中(以及使用的代价和算法)。password_verify()然后读取该哈希并确定使用的盐和加密方法，并根据提供的明文密码验证它。

提供PASSWORD_DEFAULT指示PHP使用已安装的PHP版本的默认哈希算法。具体哪种算法在未来的版本中会随着时间的推移而改变，因此它将始终是可用的最强算法之一。

不断增加的成本(默认为10)使得哈希更难使用暴力，但也意味着生成哈希并根据它们验证密码将为服务器的CPU带来更多的工作。

请注意，即使默认的哈希算法可能会改变，旧的哈希将继续进行验证，因为所使用的算法存储在哈希中，password_verify()会捕获它。

我不会以两种不同的方式存储哈希密码，因为这样的话，系统至少和正在使用的最弱的哈希算法一样弱。

谷歌表示SHA256对PHP可用。

你一定要加盐。我建议使用随机字节(不要限制自己使用字符和数字)。通常情况下，你选择的时间越长，就越安全、越慢。64字节应该就可以了。

最后，在数学上，双重哈希没有任何好处。然而，在实践中，它对于防止基于彩虹表的攻击是有用的。换句话说，它并不比使用salt进行哈希更有好处，后者在应用程序或服务器上占用的处理器时间要少得多。

免责声明:这个答案写于2008年。 从那时起，PHP给了我们password_hash和password_verify，自从它们被引入以来，它们是推荐的密码哈希和检查方法。 尽管如此，答案的理论仍然是一本很好的读物。

博士TL;

不该做的事

Don't limit what characters users can enter for passwords. Only idiots do this. Don't limit the length of a password. If your users want a sentence with supercalifragilisticexpialidocious in it, don't prevent them from using it. Don't strip or escape HTML and special characters in the password. Never store your user's password in plain-text. Never email a password to your user except when they have lost theirs, and you sent a temporary one. Never, ever log passwords in any manner. Never hash passwords with SHA1 or MD5 or even SHA256! Modern crackers can exceed 60 and 180 billion hashes/second (respectively). Don't mix bcrypt and with the raw output of hash(), either use hex output or base64_encode it. (This applies to any input that may have a rogue \0 in it, which can seriously weaken security.)

Dos

尽可能使用scrypt;如果你不能Bcrypt。 如果不能使用bcrypt或scrypt，则使用PBKDF2和SHA2散列。 当数据库被入侵时，重置所有人的密码。 实现一个合理的8-10个字符的最小长度，加上要求至少一个大写字母，一个小写字母，一个数字和一个符号。这将提高密码的熵，从而使其更难被破解。(关于一些争论，请参阅“什么是好密码?”一节。)

为什么要对密码进行哈希?

哈希密码背后的目标很简单:通过破坏数据库防止恶意访问用户帐户。所以密码哈希的目标是阻止黑客或破解者花费太多的时间或金钱来计算纯文本密码。时间/成本是你武器库中最好的威慑。

希望对用户帐户进行良好、健壮的散列的另一个原因是给您足够的时间来更改系统中的所有密码。如果您的数据库被泄露，您至少需要足够的时间来锁定系统，如果不更改数据库中的每个密码的话。

Whitehat Security的CTO Jeremiah Grossman在最近一次密码恢复后，在White Hat Security的博客上表示，他需要暴力破解密码保护:

有趣的是，在这个噩梦中，我学到了很多我不知道的关于密码破解、存储和复杂性的知识。我开始理解为什么密码存储比密码复杂度重要得多。如果您不知道密码是如何存储的，那么您真正可以依赖的就是复杂性。对于密码和加密专家来说，这可能是常识，但对于一般的InfoSec或Web安全专家来说，我高度怀疑这一点。

(强调我的。)

到底什么才是好的密码呢?

熵。(并不是说我完全赞同兰德尔的观点。)

简而言之，熵就是密码内部的变化量。当密码只有小写罗马字母时，也就是26个字符。变化不大。字母数字组合的密码更好，最多36个字符。但是允许大写和小写，加上符号，大约是96个字符。这比只写信好多了。一个问题是，为了让我们的密码更容易记住，我们插入了模式——这减少了熵。哦!

密码熵很容易逼近。使用全范围的ascii字符(大约96个可输入字符)产生每个字符6.6的熵，对于未来的安全性来说，8个字符的密码仍然太低(52.679位熵)。但好消息是:较长的密码和使用unicode字符的密码确实会增加密码的熵，使其更难破解。

在Crypto StackExchange网站上有一个关于密码熵的更长的讨论。一个好的谷歌搜索也会出现很多结果。

在我与@popnoodles交谈的评论中，他指出，强制执行X长度的密码策略，包含X个字母、数字、符号等，实际上可以通过使密码方案更可预测来减少熵。我同意。随机性总是最安全但最不容易记住的解决方案。

据我所知，制定世界上最好的密码是一个两难的选择。要么是不容易记住，太可预测，太短，太多unicode字符(很难在Windows/移动设备上输入)，要么是太长，等等。任何密码都不能真正满足我们的目的，所以我们必须像保护诺克斯堡一样保护它们。

最佳实践

Bcrypt and scrypt are the current best practices. Scrypt will be better than bcrypt in time, but it hasn't seen adoption as a standard by Linux/Unix or by webservers, and hasn't had in-depth reviews of its algorithm posted yet. But still, the future of the algorithm does look promising. If you are working with Ruby there is an scrypt gem that will help you out, and Node.js now has its own scrypt package. You can use Scrypt in PHP either via the Scrypt extension or the Libsodium extension (both are available in PECL).

如果您想了解如何使用bcrypt，或者找到一个好的包装器，或者使用PHPASS之类的东西来实现更传统的实现，我强烈建议您阅读crypt函数的文档。我建议至少进行12轮bcrypt，如果不是15到18轮的话。

当我了解到bcrypt只使用blowfish的密钥调度时，我改变了使用bcrypt的想法，并具有可变成本机制。后者可以通过增加blowfish本已昂贵的密钥调度来增加暴力破解密码的成本。

一般的做法

我几乎无法想象这种情况了。PHPASS支持PHP 3.0.18到5.3，因此它几乎适用于所有可以想象到的安装——如果您不确定您的环境是否支持bcrypt，则应该使用它。

但是假设您根本不能使用bcrypt或PHPASS。然后什么?

尝试使用环境/应用程序/用户感知所能容忍的最大轮数的PDKBF2实现。我建议最低数量是2500发。此外，如果hash_hmac()可用，请确保使用hash_hmac()，以使操作更难再现。

未来的实践

PHP 5.5中提供了一个完整的密码保护库，可以抽象出使用bcrypt的任何痛苦。当我们大多数人在最常见的环境(尤其是共享主机)中使用PHP 5.2和5.3时，@ircmaxell已经为即将到来的API构建了向后兼容PHP 5.3.7的兼容层。

密码学概述和免责声明

真正破解散列密码所需的计算能力并不存在。计算机“破解”密码的唯一方法是重新创建密码，并模拟用于保护密码的哈希算法。散列的速度与它的野蛮强制能力线性相关。更糟糕的是，大多数哈希算法可以很容易地并行化，从而执行得更快。这就是为什么像bcrypt和scrypt这样昂贵的方案如此重要。

You cannot possibly foresee all threats or avenues of attack, and so you must make your best effort to protect your users up front. If you do not, then you might even miss the fact that you were attacked until it's too late... and you're liable. To avoid that situation, act paranoid to begin with. Attack your own software (internally) and attempt to steal user credentials, or modify other user's accounts or access their data. If you don't test the security of your system, then you cannot blame anyone but yourself.

最后，我不是密码学家。无论我说什么都是我的观点，但我碰巧认为这是基于良好的常识……还有大量的阅读。记住，要尽可能地多疑，让事情尽可能地难以侵入，然后，如果你仍然担心，联系一个白帽黑客或密码学家，看看他们对你的代码/系统有什么看法。

我在这里找到了关于这个问题的完美主题:https://crackstation.net/hashing-security.htm，我希望你能从中受益，这里还有源代码，可以防止基于时间的攻击。

<?php
/*
 * Password hashing with PBKDF2.
 * Author: havoc AT defuse.ca
 * www: https://defuse.ca/php-pbkdf2.htm
 */

// These constants may be changed without breaking existing hashes.
define("PBKDF2_HASH_ALGORITHM", "sha256");
define("PBKDF2_ITERATIONS", 1000);
define("PBKDF2_SALT_BYTES", 24);
define("PBKDF2_HASH_BYTES", 24);

define("HASH_SECTIONS", 4);
define("HASH_ALGORITHM_INDEX", 0);
define("HASH_ITERATION_INDEX", 1);
define("HASH_SALT_INDEX", 2);
define("HASH_PBKDF2_INDEX", 3);

function create_hash($password)
{
    // format: algorithm:iterations:salt:hash
    $salt = base64_encode(mcrypt_create_iv(PBKDF2_SALT_BYTES, MCRYPT_DEV_URANDOM));
    return PBKDF2_HASH_ALGORITHM . ":" . PBKDF2_ITERATIONS . ":" .  $salt . ":" . 
        base64_encode(pbkdf2(
            PBKDF2_HASH_ALGORITHM,
            $password,
            $salt,
            PBKDF2_ITERATIONS,
            PBKDF2_HASH_BYTES,
            true
        ));
}

function validate_password($password, $good_hash)
{
    $params = explode(":", $good_hash);
    if(count($params) < HASH_SECTIONS)
       return false; 
    $pbkdf2 = base64_decode($params[HASH_PBKDF2_INDEX]);
    return slow_equals(
        $pbkdf2,
        pbkdf2(
            $params[HASH_ALGORITHM_INDEX],
            $password,
            $params[HASH_SALT_INDEX],
            (int)$params[HASH_ITERATION_INDEX],
            strlen($pbkdf2),
            true
        )
    );
}

// Compares two strings $a and $b in length-constant time.
function slow_equals($a, $b)
{
    $diff = strlen($a) ^ strlen($b);
    for($i = 0; $i < strlen($a) && $i < strlen($b); $i++)
    {
        $diff |= ord($a[$i]) ^ ord($b[$i]);
    }
    return $diff === 0; 
}

/*
 * PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt
 * $algorithm - The hash algorithm to use. Recommended: SHA256
 * $password - The password.
 * $salt - A salt that is unique to the password.
 * $count - Iteration count. Higher is better, but slower. Recommended: At least 1000.
 * $key_length - The length of the derived key in bytes.
 * $raw_output - If true, the key is returned in raw binary format. Hex encoded otherwise.
 * Returns: A $key_length-byte key derived from the password and salt.
 *
 * Test vectors can be found here: https://www.ietf.org/rfc/rfc6070.txt
 *
 * This implementation of PBKDF2 was originally created by https://defuse.ca
 * With improvements by http://www.variations-of-shadow.com
 */
function pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
{
    $algorithm = strtolower($algorithm);
    if(!in_array($algorithm, hash_algos(), true))
        die('PBKDF2 ERROR: Invalid hash algorithm.');
    if($count <= 0 || $key_length <= 0)
        die('PBKDF2 ERROR: Invalid parameters.');

    $hash_length = strlen(hash($algorithm, "", true));
    $block_count = ceil($key_length / $hash_length);

    $output = "";
    for($i = 1; $i <= $block_count; $i++) {
        // $i encoded as 4 bytes, big endian.
        $last = $salt . pack("N", $i);
        // first iteration
        $last = $xorsum = hash_hmac($algorithm, $last, $password, true);
        // perform the other $count - 1 iterations
        for ($j = 1; $j < $count; $j++) {
            $xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true));
        }
        $output .= $xorsum;
    }

    if($raw_output)
        return substr($output, 0, $key_length);
    else
        return bin2hex(substr($output, 0, $key_length));
}
?>