如何使用 PHP 的 password_hash 来散列和验证密码

最近，我一直试图实现我自己的安全登录脚本，我偶然在互联网上。在努力学习如何创建自己的脚本来为每个用户生成一个 salt 之后，我偶然发现了 password_hash。

根据我的理解(基于对 这一页的读取) ，当您使用 password_hash时，在行中已经生成了 salt。这是真的吗？

我的另一个问题是，有两种盐不是很明智吗？一个直接在文件里，一个在数据库里？这样的话，如果有人在数据库中破坏了你的盐，你还能直接在文件中找到它吗？我在这里读到，储存盐从来不是一个明智的想法，但它总是让我困惑，人们是什么意思。

268728 次浏览
小开

是的，这是真的。你为什么怀疑这个函数的 php 常见问题? :)

运行 password_hash()的结果有四个方面:

  1. 使用的算法
  2. 参数
  3. 盐
  4. 实际的密码散列

如您所见，散列是其中的一部分。

当然，您可以添加一个额外的安全层，但是我真的认为在普通的 php 应用程序中这样做有些过头了。默认的 bcrypt 算法很好，可选的河豚算法甚至可以说更好。

小开

是的，您正确地理解了它，密码 _ hash ()函数将自己生成一个 salt，并将其包含在生成的 hash 值中。在数据库中存储 salt 是绝对正确的，即使知道它也会完成它的工作。

// Hash a new password for storing in the database.
// The function automatically generates a cryptographically safe salt.
$hashToStoreInDb = password_hash($_POST['password'], PASSWORD_DEFAULT);


// Check if the hash of the entered login password, matches the stored hash.
// The salt and the cost factor will be extracted from $existingHashFromDb.
$isPasswordCorrect = password_verify($_POST['password'], $existingHashFromDb);

您提到的第二个 salt (存储在文件中的那个)实际上是一个 Pepper 或服务器端键。如果你加入之前散列(如盐) ，然后你加入一个胡椒。不过还有一种更好的方法，您可以首先计算哈希，然后用服务器端密钥加密(双向)哈希。这使您有可能在必要时更改密钥。

与盐相比，这把钥匙应该保密。人们经常把它们混在一起，试图把盐藏起来，但是最好还是让盐来完成它的工作，然后用钥匙把秘密加进去。

小开
最佳答案

使用 password_hash是存储密码的推荐方法。不要将它们分离到数据库和文件中。

假设我们有以下输入:

$password = $_POST['password'];

您首先通过这样做来散列密码:

$hashed_password = password_hash($password, PASSWORD_DEFAULT);

然后查看输出:

var_dump($hashed_password);

如你所见，它是散列的。(我假设你已经完成了这些步骤)。

现在将这个散列密码存储在数据库 确保密码列足够大以容纳散列值(至少60个字符或更长)中。当用户要求登录时，您可以使用数据库中的散列值检查密码输入，方法是:

// Query the database for username and password
// ...


if(password_verify($password, $hashed_password)) {
// If the password inputs matched the hashed password in the database
// Do something, you know... log them in.
}


// Else, Redirect them back to the login page.

官方参考文件

小开

PHP 的密码函数中明显缺乏关于向前和向后兼容性的讨论。值得注意的是:

  1. 向后兼容性: 密码函数本质上是围绕 crypt()编写的一个良好的包装器，并且固有地向后兼容 crypt()格式的散列，即使它们使用过时和/或不安全的散列算法。
  2. 向前兼容性: 在认证工作流中插入 password_needs_rehash()和一点逻辑，可以让你的散列符号与当前和未来的算法保持最新，而且未来的工作流可能不会有任何变化。注意: 任何与指定算法不匹配的字符串将被标记为需要重新散列，包括不兼容密码的散列。

例如:

class FakeDB {
public function __call($name, $args) {
printf("%s::%s(%s)\n", __CLASS__, $name, json_encode($args));
return $this;
}
}


class MyAuth {
protected $dbh;
protected $fakeUsers = [
// old crypt-md5 format
1 => ['password' => '$1$AVbfJOzY$oIHHCHlD76Aw1xmjfTpm5.'],
// old salted md5 format
2 => ['password' => '3858f62230ac3c915f300c664312c63f', 'salt' => 'bar'],
// current bcrypt format
3 => ['password' => '$2y$10$3eUn9Rnf04DR.aj8R3WbHuBO9EdoceH9uKf6vMiD7tz766rMNOyTO']
];


public function __construct($dbh) {
$this->dbh = $dbh;
}


protected function getuser($id) {
// just pretend these are coming from the DB
return $this->fakeUsers[$id];
}


public function authUser($id, $password) {
$userInfo = $this->getUser($id);


// Do you have old, turbo-legacy, non-crypt hashes?
if( strpos( $userInfo['password'], '$' ) !== 0 ) {
printf("%s::legacy_hash\n", __METHOD__);
$res = $userInfo['password'] === md5($password . $userInfo['salt']);
} else {
printf("%s::password_verify\n", __METHOD__);
$res = password_verify($password, $userInfo['password']);
}


// once we've passed validation we can check if the hash needs updating.
if( $res && password_needs_rehash($userInfo['password'], PASSWORD_DEFAULT) ) {
printf("%s::rehash\n", __METHOD__);
$stmt = $this->dbh->prepare('UPDATE users SET pass = ? WHERE user_id = ?');
$stmt->execute([password_hash($password, PASSWORD_DEFAULT), $id]);
}


return $res;
}
}


$auth = new MyAuth(new FakeDB());


for( $i=1; $i<=3; $i++) {
var_dump($auth->authuser($i, 'foo'));
echo PHP_EOL;
}

产出:

MyAuth::authUser::password_verify
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$zNjPwqQX\/RxjHiwkeUEzwOpkucNw49yN4jjiRY70viZpAx5x69kv.",1]])
bool(true)


MyAuth::authUser::legacy_hash
MyAuth::authUser::rehash
FakeDB::prepare(["UPDATE users SET pass = ? WHERE user_id = ?"])
FakeDB::execute([["$2y$10$VRTu4pgIkGUvilTDRTXYeOQSEYqe2GjsPoWvDUeYdV2x\/\/StjZYHu",2]])
bool(true)


MyAuth::authUser::password_verify
bool(true)

最后要说明的是，鉴于您只能在登录时重新散列用户的密码，您应该考虑“日落”不安全的遗留散列，以保护您的用户。我的意思是，在一定的宽限期之后，删除所有不安全的散列(例如: 裸 MD5/SHA/其他弱散列) ，并让用户依赖应用程序的密码重置机制。

小开

类密码完整代码:

Class Password {


public function __construct() {}




/**
* Hash the password using the specified algorithm
*
* @param string $password The password to hash
* @param int    $algo     The algorithm to use (Defined by PASSWORD_* constants)
* @param array  $options  The options for the algorithm to use
*
* @return string|false The hashed password, or false on error.
*/
function password_hash($password, $algo, array $options = array()) {
if (!function_exists('crypt')) {
trigger_error("Crypt must be loaded for password_hash to function", E_USER_WARNING);
return null;
}
if (!is_string($password)) {
trigger_error("password_hash(): Password must be a string", E_USER_WARNING);
return null;
}
if (!is_int($algo)) {
trigger_error("password_hash() expects parameter 2 to be long, " . gettype($algo) . " given", E_USER_WARNING);
return null;
}
switch ($algo) {
case PASSWORD_BCRYPT :
// Note that this is a C constant, but not exposed to PHP, so we don't define it here.
$cost = 10;
if (isset($options['cost'])) {
$cost = $options['cost'];
if ($cost < 4 || $cost > 31) {
trigger_error(sprintf("password_hash(): Invalid bcrypt cost parameter specified: %d", $cost), E_USER_WARNING);
return null;
}
}
// The length of salt to generate
$raw_salt_len = 16;
// The length required in the final serialization
$required_salt_len = 22;
$hash_format = sprintf("$2y$%02d$", $cost);
break;
default :
trigger_error(sprintf("password_hash(): Unknown password hashing algorithm: %s", $algo), E_USER_WARNING);
return null;
}
if (isset($options['salt'])) {
switch (gettype($options['salt'])) {
case 'NULL' :
case 'boolean' :
case 'integer' :
case 'double' :
case 'string' :
$salt = (string)$options['salt'];
break;
case 'object' :
if (method_exists($options['salt'], '__tostring')) {
$salt = (string)$options['salt'];
break;
}
case 'array' :
case 'resource' :
default :
trigger_error('password_hash(): Non-string salt parameter supplied', E_USER_WARNING);
return null;
}
if (strlen($salt) < $required_salt_len) {
trigger_error(sprintf("password_hash(): Provided salt is too short: %d expecting %d", strlen($salt), $required_salt_len), E_USER_WARNING);
return null;
} elseif (0 == preg_match('#^[a-zA-Z0-9./]+$#D', $salt)) {
$salt = str_replace('+', '.', base64_encode($salt));
}
} else {
$salt = str_replace('+', '.', base64_encode($this->generate_entropy($required_salt_len)));
}
$salt = substr($salt, 0, $required_salt_len);


$hash = $hash_format . $salt;


$ret = crypt($password, $hash);


if (!is_string($ret) || strlen($ret) <= 13) {
return false;
}


return $ret;
}




/**
* Generates Entropy using the safest available method, falling back to less preferred methods depending on support
*
* @param int $bytes
*
* @return string Returns raw bytes
*/
function generate_entropy($bytes){
$buffer = '';
$buffer_valid = false;
if (function_exists('mcrypt_create_iv') && !defined('PHALANGER')) {
$buffer = mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM);
if ($buffer) {
$buffer_valid = true;
}
}
if (!$buffer_valid && function_exists('openssl_random_pseudo_bytes')) {
$buffer = openssl_random_pseudo_bytes($bytes);
if ($buffer) {
$buffer_valid = true;
}
}
if (!$buffer_valid && is_readable('/dev/urandom')) {
$f = fopen('/dev/urandom', 'r');
$read = strlen($buffer);
while ($read < $bytes) {
$buffer .= fread($f, $bytes - $read);
$read = strlen($buffer);
}
fclose($f);
if ($read >= $bytes) {
$buffer_valid = true;
}
}
if (!$buffer_valid || strlen($buffer) < $bytes) {
$bl = strlen($buffer);
for ($i = 0; $i < $bytes; $i++) {
if ($i < $bl) {
$buffer[$i] = $buffer[$i] ^ chr(mt_rand(0, 255));
} else {
$buffer .= chr(mt_rand(0, 255));
}
}
}
return $buffer;
}


/**
* Get information about the password hash. Returns an array of the information
* that was used to generate the password hash.
*
* array(
*    'algo' => 1,
*    'algoName' => 'bcrypt',
*    'options' => array(
*        'cost' => 10,
*    ),
* )
*
* @param string $hash The password hash to extract info from
*
* @return array The array of information about the hash.
*/
function password_get_info($hash) {
$return = array('algo' => 0, 'algoName' => 'unknown', 'options' => array(), );
if (substr($hash, 0, 4) == '$2y$' && strlen($hash) == 60) {
$return['algo'] = PASSWORD_BCRYPT;
$return['algoName'] = 'bcrypt';
list($cost) = sscanf($hash, "$2y$%d$");
$return['options']['cost'] = $cost;
}
return $return;
}


/**
* Determine if the password hash needs to be rehashed according to the options provided
*
* If the answer is true, after validating the password using password_verify, rehash it.
*
* @param string $hash    The hash to test
* @param int    $algo    The algorithm used for new password hashes
* @param array  $options The options array passed to password_hash
*
* @return boolean True if the password needs to be rehashed.
*/
function password_needs_rehash($hash, $algo, array $options = array()) {
$info = password_get_info($hash);
if ($info['algo'] != $algo) {
return true;
}
switch ($algo) {
case PASSWORD_BCRYPT :
$cost = isset($options['cost']) ? $options['cost'] : 10;
if ($cost != $info['options']['cost']) {
return true;
}
break;
}
return false;
}


/**
* Verify a password against a hash using a timing attack resistant approach
*
* @param string $password The password to verify
* @param string $hash     The hash to verify against
*
* @return boolean If the password matches the hash
*/
public function password_verify($password, $hash) {
if (!function_exists('crypt')) {
trigger_error("Crypt must be loaded for password_verify to function", E_USER_WARNING);
return false;
}
$ret = crypt($password, $hash);
if (!is_string($ret) || strlen($ret) != strlen($hash) || strlen($ret) <= 13) {
return false;
}


$status = 0;
for ($i = 0; $i < strlen($ret); $i++) {
$status |= (ord($ret[$i]) ^ ord($hash[$i]));
}


return $status === 0;
}


}

提交答案