Commit bb3b4b99 authored by Dries's avatar Dries

Issue #1463624 by znerol, marcingy, Rob Loach, cosmicdreams: Move password.inc into DIC.

parent 3d2c548b
<?php
/**
* @file
* Secure password hashing functions for user authentication.
*
* Based on the Portable PHP password hashing framework.
* @see http://www.openwall.com/phpass/
*
* An alternative or custom version of this password hashing API may be
* used by setting the variable password_inc to the name of the PHP file
* containing replacement user_hash_password(), user_check_password(), and
* user_needs_new_hash() functions.
*/
/**
* The standard log2 number of iterations for password stretching. This should
* increase by 1 every Drupal version in order to counteract increases in the
* speed and power of computers available to crack the hashes.
*/
const DRUPAL_HASH_COUNT = 16;
/**
* The minimum allowed log2 number of iterations for password stretching.
*/
const DRUPAL_MIN_HASH_COUNT = 7;
/**
* The maximum allowed log2 number of iterations for password stretching.
*/
const DRUPAL_MAX_HASH_COUNT = 30;
/**
* The expected (and maximum) number of characters in a hashed password.
*/
const DRUPAL_HASH_LENGTH = 55;
/**
* Returns a string for mapping an int to the corresponding base 64 character.
*/
function _password_itoa64() {
return './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
}
/**
* Encode bytes into printable base 64 using the *nix standard from crypt().
*
* @param $input
* The string containing bytes to encode.
* @param $count
* The number of characters (bytes) to encode.
*
* @return
* Encoded string
*/
function _password_base64_encode($input, $count) {
$output = '';
$i = 0;
$itoa64 = _password_itoa64();
do {
$value = ord($input[$i++]);
$output .= $itoa64[$value & 0x3f];
if ($i < $count) {
$value |= ord($input[$i]) << 8;
}
$output .= $itoa64[($value >> 6) & 0x3f];
if ($i++ >= $count) {
break;
}
if ($i < $count) {
$value |= ord($input[$i]) << 16;
}
$output .= $itoa64[($value >> 12) & 0x3f];
if ($i++ >= $count) {
break;
}
$output .= $itoa64[($value >> 18) & 0x3f];
} while ($i < $count);
return $output;
}
/**
* Generates a random base 64-encoded salt prefixed with settings for the hash.
*
* Proper use of salts may defeat a number of attacks, including:
* - The ability to try candidate passwords against multiple hashes at once.
* - The ability to use pre-hashed lists of candidate passwords.
* - The ability to determine whether two users have the same (or different)
* password without actually having to guess one of the passwords.
*
* @param $count_log2
* Integer that determines the number of iterations used in the hashing
* process. A larger value is more secure, but takes more time to complete.
*
* @return
* A 12 character string containing the iteration count and a random salt.
*/
function _password_generate_salt($count_log2) {
$output = '$S$';
// Ensure that $count_log2 is within set bounds.
$count_log2 = _password_enforce_log2_boundaries($count_log2);
// We encode the final log2 iteration count in base 64.
$itoa64 = _password_itoa64();
$output .= $itoa64[$count_log2];
// 6 bytes is the standard salt for a portable phpass hash.
$output .= _password_base64_encode(drupal_random_bytes(6), 6);
return $output;
}
/**
* Ensures that $count_log2 is within set bounds.
*
* @param $count_log2
* Integer that determines the number of iterations used in the hashing
* process. A larger value is more secure, but takes more time to complete.
*
* @return
* Integer within set bounds that is closest to $count_log2.
*/
function _password_enforce_log2_boundaries($count_log2) {
if ($count_log2 < DRUPAL_MIN_HASH_COUNT) {
return DRUPAL_MIN_HASH_COUNT;
}
elseif ($count_log2 > DRUPAL_MAX_HASH_COUNT) {
return DRUPAL_MAX_HASH_COUNT;
}
return (int) $count_log2;
}
/**
* Hash a password using a secure stretched hash.
*
* By using a salt and repeated hashing the password is "stretched". Its
* security is increased because it becomes much more computationally costly
* for an attacker to try to break the hash by brute-force computation of the
* hashes of a large number of plain-text words or strings to find a match.
*
* @param $algo
* The string name of a hashing algorithm usable by hash(), like 'sha256'.
* @param $password
* The plain-text password to hash.
* @param $setting
* An existing hash or the output of _password_generate_salt(). Must be
* at least 12 characters (the settings and salt).
*
* @return
* A string containing the hashed password (and salt) or FALSE on failure.
* The return string will be truncated at DRUPAL_HASH_LENGTH characters max.
*/
function _password_crypt($algo, $password, $setting) {
// The first 12 characters of an existing hash are its setting string.
$setting = substr($setting, 0, 12);
if ($setting[0] != '$' || $setting[2] != '$') {
return FALSE;
}
$count_log2 = _password_get_count_log2($setting);
// Hashes may be imported from elsewhere, so we allow != DRUPAL_HASH_COUNT
if ($count_log2 < DRUPAL_MIN_HASH_COUNT || $count_log2 > DRUPAL_MAX_HASH_COUNT) {
return FALSE;
}
$salt = substr($setting, 4, 8);
// Hashes must have an 8 character salt.
if (strlen($salt) != 8) {
return FALSE;
}
// Convert the base 2 logarithm into an integer.
$count = 1 << $count_log2;
// We rely on the hash() function being available in PHP 5.2+.
$hash = hash($algo, $salt . $password, TRUE);
do {
$hash = hash($algo, $hash . $password, TRUE);
} while (--$count);
$len = strlen($hash);
$output = $setting . _password_base64_encode($hash, $len);
// _password_base64_encode() of a 16 byte MD5 will always be 22 characters.
// _password_base64_encode() of a 64 byte sha512 will always be 86 characters.
$expected = 12 + ceil((8 * $len) / 6);
return (strlen($output) == $expected) ? substr($output, 0, DRUPAL_HASH_LENGTH) : FALSE;
}
/**
* Parse the log2 iteration count from a stored hash or setting string.
*/
function _password_get_count_log2($setting) {
$itoa64 = _password_itoa64();
return strpos($itoa64, $setting[3]);
}
/**
* Hash a password using a secure hash.
*
* @param $password
* A plain-text password.
* @param $count_log2
* Optional integer to specify the iteration count. Generally used only during
* mass operations where a value less than the default is needed for speed.
*
* @return
* A string containing the hashed password (and a salt), or FALSE on failure.
*/
function user_hash_password($password, $count_log2 = 0) {
if (empty($count_log2)) {
// Use the standard iteration count.
$count_log2 = variable_get('password_count_log2', DRUPAL_HASH_COUNT);
}
return _password_crypt('sha512', $password, _password_generate_salt($count_log2));
}
/**
* Check whether a plain text password matches a stored hashed password.
*
* Alternative implementations of this function may use other data in the
* $account object, for example the uid to look up the hash in a custom table
* or remote database.
*
* @param $password
* A plain-text password
* @param $account
* A user object with at least the fields from the {users} table.
*
* @return
* TRUE or FALSE.
*/
function user_check_password($password, $account) {
if (substr($account->pass, 0, 2) == 'U$') {
// This may be an updated password from user_update_7000(). Such hashes
// have 'U' added as the first character and need an extra md5() (see the
// Drupal 7 documentation).
$stored_hash = substr($account->pass, 1);
$password = md5($password);
}
else {
$stored_hash = $account->pass;
}
$type = substr($stored_hash, 0, 3);
switch ($type) {
case '$S$':
// A normal Drupal 7 password using sha512.
$hash = _password_crypt('sha512', $password, $stored_hash);
break;
case '$H$':
// phpBB3 uses "$H$" for the same thing as "$P$".
case '$P$':
// A phpass password generated using md5. This is an
// imported password or from an earlier Drupal version.
$hash = _password_crypt('md5', $password, $stored_hash);
break;
default:
return FALSE;
}
return ($hash && $stored_hash == $hash);
}
/**
* Check whether a user's hashed password needs to be replaced with a new hash.
*
* This is typically called during the login process when the plain text
* password is available. A new hash is needed when the desired iteration count
* has changed through a change in the variable password_count_log2 or
* DRUPAL_HASH_COUNT or if the user's password hash was generated in an update
* like user_update_7000() (see the Drupal 7 documentation).
*
* Alternative implementations of this function might use other criteria based
* on the fields in $account.
*
* @param $account
* A user object with at least the fields from the {users} table.
*
* @return
* TRUE or FALSE.
*/
function user_needs_new_hash($account) {
// Check whether this was an updated password.
if ((substr($account->pass, 0, 3) != '$S$') || (strlen($account->pass) != DRUPAL_HASH_LENGTH)) {
return TRUE;
}
// Ensure that $count_log2 is within set bounds.
$count_log2 = _password_enforce_log2_boundaries(variable_get('password_count_log2', DRUPAL_HASH_COUNT));
// Check whether the iteration count used differs from the standard number.
return (_password_get_count_log2($account->pass) !== $count_log2);
}
......@@ -145,6 +145,15 @@ public function build(ContainerBuilder $container) {
->addArgument(new Reference('database'))
->addArgument(new Reference('path.alias_manager'));
// Add password hashing service. The argument to PhpassHashedPassword
// constructor is the log2 number of iterations for password stretching.
// This should increase by 1 every Drupal version in order to counteract
// increases in the speed and power of computers available to crack the
// hashes. The current password hashing method was introduced in Drupal 7
// with a log2 count of 15.
$container->register('password', 'Drupal\Core\Password\PhpassHashedPassword')
->addArgument(16);
// The following services are tagged as 'nested_matcher' services and are
// processed in the RegisterNestedMatchersPass compiler pass. Each one
// needs to be set on the matcher using a different method, so we use a
......
<?php
/**
* @file
* Definition of Drupal\Core\Password\PasswordInterface
*/
namespace Drupal\Core\Password;
/**
* Secure password hashing functions for user authentication.
*/
interface PasswordInterface {
/**
* Hash a password using a secure hash.
*
* @param string $password
* A plain-text password.
*
* @return string
* A string containing the hashed password (and a salt), or FALSE on failure.
*/
public function hash($password);
/**
* Check whether a plain text password matches a stored hashed password.
*
* Alternative implementations of this function may use other data in the
* $account object, for example the uid to look up the hash in a custom table
* or remote database.
*
* @param string $password
* A plain-text password
* @param Drupal\user\User
* A user object with at least the fields from the {users} table.
*
* @return bolean.
* TRUE or FALSE.
*/
public function check($password, $account);
/**
* Check whether a user's hashed password needs to be replaced with a new hash.
*
* This is typically called during the login process when the plain text
* password is available. A new hash is needed when the desired iteration
* count has changed by a modification of the password-service in the
* dependency injection container or if the user's password hash was
* generated in an update like user_update_7000() (see the Drupal 7
* documentation).
*
* Alternative implementations of this function might use other criteria based
* on the fields in $account.
*
* @param Drupal\user\User
* A user object with at least the fields from the {users} table.
*
* @return boolean
* TRUE or FALSE.
*/
public function userNeedsNewHash($account);
}
<?php
/**
* @file
* Definition of Drupal\Core\Password\PhpassHashedPassword
*/
namespace Drupal\Core\Password;
/**
* Secure password hashing functions based on the Portable PHP password
* hashing framework.
*
* @see http://www.openwall.com/phpass/
*/
class PhpassHashedPassword implements PasswordInterface {
/**
* The minimum allowed log2 number of iterations for password stretching.
*/
const MIN_HASH_COUNT = 7;
/**
* The maximum allowed log2 number of iterations for password stretching.
*/
const MAX_HASH_COUNT = 30;
/**
* The expected (and maximum) number of characters in a hashed password.
*/
const HASH_LENGTH = 55;
/**
* Returns a string for mapping an int to the corresponding base 64 character.
*/
static $ITOA64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
/**
* Specifies the number of times the hashing function will be applied when
* generating new password hashes. The number of times is calculated by
* raising 2 to the power of the given value.
*/
protected $countLog2;
/**
* Constructs a new phpass password hashing instance.
*
* @param int $countLog2
* Password stretching iteration count. Specifies the number of times the
* hashing function will be applied when generating new password hashes.
* The number of times is calculated by raising 2 to the power of the given
* value.
*/
function __construct($countLog2) {
// Ensure that $countLog2 is within set bounds.
$this->countLog2 = $this->enforceLog2Boundaries($countLog2);
}
/**
* Encode bytes into printable base 64 using the *nix standard from crypt().
*
* @param String $input
* The string containing bytes to encode.
* @param Integer $count
* The number of characters (bytes) to encode.
*
* @return String
* Encoded string
*/
protected function base64Encode($input, $count) {
$output = '';
$i = 0;
do {
$value = ord($input[$i++]);
$output .= static::$ITOA64[$value & 0x3f];
if ($i < $count) {
$value |= ord($input[$i]) << 8;
}
$output .= static::$ITOA64[($value >> 6) & 0x3f];
if ($i++ >= $count) {
break;
}
if ($i < $count) {
$value |= ord($input[$i]) << 16;
}
$output .= static::$ITOA64[($value >> 12) & 0x3f];
if ($i++ >= $count) {
break;
}
$output .= static::$ITOA64[($value >> 18) & 0x3f];
} while ($i < $count);
return $output;
}
/**
* Generates a random base 64-encoded salt prefixed with settings for the hash.
*
* Proper use of salts may defeat a number of attacks, including:
* - The ability to try candidate passwords against multiple hashes at once.
* - The ability to use pre-hashed lists of candidate passwords.
* - The ability to determine whether two users have the same (or different)
* password without actually having to guess one of the passwords.
*
* @return String
* A 12 character string containing the iteration count and a random salt.
*/
protected function generateSalt() {
$output = '$S$';
// We encode the final log2 iteration count in base 64.
$output .= static::$ITOA64[$this->countLog2];
// 6 bytes is the standard salt for a portable phpass hash.
$output .= $this->base64Encode(drupal_random_bytes(6), 6);
return $output;
}
/**
* Ensures that $count_log2 is within set bounds.
*
* @param Integer $count_log2
* Integer that determines the number of iterations used in the hashing
* process. A larger value is more secure, but takes more time to complete.
*
* @return Integer
* Integer within set bounds that is closest to $count_log2.
*/
protected function enforceLog2Boundaries($count_log2) {
if ($count_log2 < static::MIN_HASH_COUNT) {
return static::MIN_HASH_COUNT;
}
elseif ($count_log2 > static::MAX_HASH_COUNT) {
return static::MAX_HASH_COUNT;
}
return (int) $count_log2;
}
/**
* Hash a password using a secure stretched hash.
*
* By using a salt and repeated hashing the password is "stretched". Its
* security is increased because it becomes much more computationally costly
* for an attacker to try to break the hash by brute-force computation of the
* hashes of a large number of plain-text words or strings to find a match.
*
* @param String $algo
* The string name of a hashing algorithm usable by hash(), like 'sha256'.
* @param String $password
* The plain-text password to hash.
* @param String $setting
* An existing hash or the output of $this->generateSalt(). Must be
* at least 12 characters (the settings and salt).
*
* @return String
* A string containing the hashed password (and salt) or FALSE on failure.
* The return string will be truncated at HASH_LENGTH characters max.
*/
protected function crypt($algo, $password, $setting) {
// The first 12 characters of an existing hash are its setting string.
$setting = substr($setting, 0, 12);
if ($setting[0] != '$' || $setting[2] != '$') {
return FALSE;
}
$count_log2 = $this->getCountLog2($setting);
// Stored hashes may have been crypted with any iteration count. However we
// do not allow applying the algorithm for unreasonable low and heigh
// values respectively.
if ($count_log2 != $this->enforceLog2Boundaries($count_log2)) {
return FALSE;
}
$salt = substr($setting, 4, 8);
// Hashes must have an 8 character salt.
if (strlen($salt) != 8) {
return FALSE;
}
// Convert the base 2 logarithm into an integer.
$count = 1 << $count_log2;
// We rely on the hash() function being available in PHP 5.2+.
$hash = hash($algo, $salt . $password, TRUE);
do {
$hash = hash($algo, $hash . $password, TRUE);
} while (--$count);
$len = strlen($hash);
$output = $setting . $this->base64Encode($hash, $len);
// $this->base64Encode() of a 16 byte MD5 will always be 22 characters.
// $this->base64Encode() of a 64 byte sha512 will always be 86 characters.
$expected = 12 + ceil((8 * $len) / 6);
return (strlen($output) == $expected) ? substr($output, 0, static::HASH_LENGTH) : FALSE;
}
/**
* Parse the log2 iteration count from a stored hash or setting string.
*
* @param String $setting
* An existing hash or the output of $this->generateSalt(). Must be
* at least 12 characters (the settings and salt).
*/
public function getCountLog2($setting) {
return strpos(static::$ITOA64, $setting[3]);
}
/**
* Implements Drupal\Core\Password\PasswordInterface::hash().
*/
public function hash($password) {
return $this->crypt('sha512', $password, $this->generateSalt());
}
/**
* Implements Drupal\Core\Password\PasswordInterface::checkPassword().
*/
public function check($password, $account) {
if (substr($account->pass, 0, 2) == 'U$') {
// This may be an updated password from user_update_7000(). Such hashes
// have 'U' added as the first character and need an extra md5() (see the
// Drupal 7 documentation).
$stored_hash = substr($account->pass, 1);
$password = md5($password);
}
else {
$stored_hash = $account->pass;
}
$type = substr($stored_hash, 0, 3);
switch ($type) {
case '$S$':
// A normal Drupal 7 password using sha512.
$hash = $this->crypt('sha512', $password, $stored_hash);
break;
case '$H$':
// phpBB3 uses "$H$" for the same thing as "$P$".
case '$P$':
// A phpass password generated using md5. This is an
// imported password or from an earlier Drupal version.
$hash = $this->crypt('md5', $password, $stored_hash);
break;
default:
return FALSE;
}
return ($hash && $stored_hash == $hash);
}
/**
* Implements Drupal\Core\Password\PasswordInterface::userNeedsNewHash().
*/
public function userNeedsNewHash($account) {
// Check whether this was an updated password.
if ((substr($account->pass, 0, 3) != '$S$') || (strlen($account->pass) != static::HASH_LENGTH)) {
return TRUE;
}
// Ensure that $count_log2 is within set bounds.
$count_log2 = $this->enforceLog2Boundaries($this->countLog2);
// Check whether the iteration count used differs from the standard number.
return ($this->getCountLog2($account->pass) !== $count_log2);
}
}
......@@ -7,12 +7,13 @@
namespace Drupal\system\Tests\System;
use Drupal\simpletest\WebTestBase;
use Drupal\simpletest\UnitTestBase;
use Drupal\Core\Password\PhpassHashedPassword;
/**
* Unit tests for password hashing API.
*/
class PasswordHashingTest extends WebTestBase {
class PasswordHashingTest extends UnitTestBase {
public static function getInfo() {
return array(
'name' => 'Password hashing',
......@@ -21,42 +22,38 @@ public static function getInfo() {
);
}
function setUp() {
require_once DRUPAL_ROOT . '/' . variable_get('password_inc', 'core/includes/password.inc');
parent::setUp();
}
/**
* Test password hashing.
*/
function testPasswordHashing() {
// Set a log2 iteration count that is deliberately out of bounds to test
// that it is corrected to be within bounds.
variable_set('password_count_log2', 1);
$password_hasher = new PhpassHashedPassword(1);
// Set up a fake $account with a password 'baz', hashed with md5.
$password = 'baz';
$account = (object) array('name' => 'foo', 'pass' => md5($password));
// The md5 password should be flagged as needing an update.
$this->assertTrue(user_needs_new_hash($account), 'User with md5 password needs a new hash.');
$this->assertTrue($password_hasher->userNeedsNewHash($account), 'User with md5 password needs a new hash.');
// Re-hash the password.
$old_hash = $account->pass;
$account->pass = user_hash_password($password);
$this->assertIdentical(_password_get_count_log2($account->pass), DRUPAL_MIN_HASH_COUNT, 'Re-hashed password has the minimum number of log2 iterations.');
$account->pass = $password_hasher->hash($password);
$this->assertIdentical($password_hasher->getCountLog2($account->pass), $password_hasher::MIN_HASH_COUNT, 'Re-hashed password has the minimum number of log2 iterations.');
$this->assertTrue($account->pass != $old_hash, 'Password hash changed.');
$this->assertTrue(user_check_password($password, $account), 'Password check succeeds.');
$this->assertTrue($password_hasher->check($password, $account), 'Password check succeeds.');
// Since the log2 setting hasn't changed and the user has a valid password,
// user_needs_new_hash() should return FALSE.
$this->assertFalse(user_needs_new_hash($account), 'User does not need a new hash.');
// $password_hasher->userNeedsNewHash() should return FALSE.
$this->assertFalse($password_hasher->userNeedsNewHash($account), 'User does not need a new hash.');
// Increment the log2 iteration to MIN + 1.
variable_set('password_count_log2', DRUPAL_MIN_HASH_COUNT + 1);
$this->assertTrue(user_needs_new_hash($account), 'User needs a new hash after incrementing the log2 count.');
$password_hasher = new PhpassHashedPassword($password_hasher::MIN_HASH_COUNT + 1);
$this->assertTrue($password_hasher->userNeedsNewHash($account), 'User needs a new hash after incrementing the log2 count.');
// Re-hash the password.
$old_hash = $account->pass;
$account->pass = user_hash_password($password);
$this->assertIdentical(_password_get_count_log2($account->pass), DRUPAL_MIN_HASH_COUNT + 1, 'Re-hashed password has the correct number of log2 iterations.');
$account->pass = $password_hasher->hash($password);
$this->assertIdentical($password_hasher->getCountLog2($account->pass), $password_hasher::MIN_HASH_COUNT + 1, 'Re-hashed password has the correct number of log2 iterations.');
$this->assertTrue($account->pass != $old_hash, 'Password hash changed again.');
// Now the hash should be OK.
$this->assertFalse(user_needs_new_hash($account), 'Re-hashed password does not need a new hash.');
$this->assertTrue(user_check_password($password, $account), 'Password check succeeds with re-hashed password.');
$this->assertFalse($password_hasher->userNeedsNewHash($account), 'Re-hashed password does not need a new hash.');
$this->assertTrue($password_hasher->check($password, $account), 'Password check succeeds with re-hashed password.');
}
}
......@@ -61,8 +61,7 @@ function testUpdateAccess() {
// Access the update page as user 1.
$user1 = user_load(1);
$user1->pass_raw = user_password();
require_once DRUPAL_ROOT . '/' . variable_get('password_inc', 'core/includes/password.inc');
$user1->pass = user_hash_password(trim($user1->pass_raw));
$user1->pass = drupal_container()->get('password')->hash(trim($user1->pass_raw));
db_query("UPDATE {users} SET pass = :pass WHERE uid = :uid", array(':pass' => $user1->pass, ':uid' => $user1->uid));
$this->drupalLogin($user1);
$this->drupalGet($this->update_url, array('external' => TRUE));
......
......@@ -2231,6 +2231,15 @@ function system_update_8036() {
));
}
/**