simple_ldap_user.password.inc in Simple LDAP 7.2

Secure password hashing functions for user authentication.

Based on the Portable PHP password hashing framework.

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.

See also

http://www.openwall.com/phpass/

File

simple_ldap_user/simple_ldap_user.password.inc

<?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.
 */
define('DRUPAL_HASH_COUNT', 15);

/**
 * The minimum allowed log2 number of iterations for password stretching.
 */
define('DRUPAL_MIN_HASH_COUNT', 7);

/**
 * The maximum allowed log2 number of iterations for password stretching.
 */
define('DRUPAL_MAX_HASH_COUNT', 30);

/**
 * The expected (and maximum) number of characters in a hashed password.
 */
define('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 string $input
 *   The string containing bytes to encode.
 * @param integer $count
 *   The number of characters (bytes) to encode.
 *
 * @return string
 *   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 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 string
 *   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 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.
 */
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 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 _password_generate_salt().  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 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 string $password
 *   A plain-text password.
 * @param integer $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 string
 *   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);
  }
  $hash = _password_crypt('sha512', $password, _password_generate_salt($count_log2));
  SimpleLdapUser::hash($hash, $password);
  return $hash;
}

/**
 * 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 object $account
 *   A user object with at least the fields from the {users} table.
 *
 * @return boolean
 *   TRUE or FALSE.
 */
function user_check_password($password, $account) {

  // Use normal authentication for User1.
  if ($account->uid == 1) {
    return simple_ldap_user_check_drupal_password($password, $account);
  }
  $fallback = simple_ldap_user_variable_get('simple_ldap_user_auth_fallback');
  $fallback_writeback = simple_ldap_user_variable_get('simple_ldap_user_auth_fallback_writeback');
  $password_attribute_name = simple_ldap_user_variable_get('simple_ldap_user_attribute_pass');

  // Use LDAP authentication for everyone else.
  $ldap_user = SimpleLdapUser::singleton($account->name);
  if (!empty($password_attribute_name)) {
    $password_attribute = $ldap_user->{$password_attribute_name};
  }
  if (!empty($password_attribute) && $password_attribute['count'] != 0) {
    $ldap_password = $password_attribute[0];
  }
  if ($ldap_user->exists && !empty($ldap_password)) {
    return $ldap_user
      ->authenticate($password);
  }
  $valid_password = FALSE;

  // If the user is in LDAP, but has no password set AND we are set to fallback to Drupal, check Drupal.
  if ($ldap_user->exists && empty($ldap_password) && in_array('nopass', $fallback, TRUE)) {
    $valid_password = simple_ldap_user_check_drupal_password($password, $account);
    if ($valid_password && in_array('nopass', $fallback_writeback, TRUE)) {
      $account->writeback_password = TRUE;
    }
  }
  elseif (!$ldap_user->exists && in_array('norecord', $fallback, TRUE)) {
    $valid_password = simple_ldap_user_check_drupal_password($password, $account);
    if ($valid_password && in_array('norecord', $fallback_writeback, TRUE)) {
      $account->pass = $password;
      simple_ldap_user_sync_user_to_ldap($account);
    }
  }

  // Could not authenticate, return FALSE
  return $valid_password;
}

/**
 * A copy of the original user_check_password() function so we can fallback
 * to Drupal's authentication for UID1 and certain other cases.
 *
 * @param string $password
 *    The password to be checked.
 *
 * @param object $account
 *    The account to be authenticated.
 *
 * @return boolean
 *    Returns TRUE if the password matches.
 */
function simple_ldap_user_check_drupal_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().
    $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().
 *
 * Alternative implementations of this function might use other criteria based
 * on the fields in $account.
 *
 * @param object $account
 *   A user object with at least the fields from the {users} table.
 *
 * @return boolean
 *   TRUE or FALSE.
 */
function user_needs_new_hash($account) {

  // Check whether this was an updated password.
  if (!empty($account->writeback_password) || 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;
}

/**
 * Add a fall-back option when authenticating against LDAP.
 */
function simple_ldap_user_form_simple_ldap_user_admin_alter(&$form, &$form_state, $form_id) {
  $form['advanced']['simple_ldap_user_auth_fallback'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Fallback Authentication'),
    '#options' => array(
      'nopass' => t('fallback to Drupal if LDAP password is empty'),
      'norecord' => t('fallback to Drupal if no LDAP record exists'),
    ),
    '#description' => t('Simple LDAP can fallback to using the password saved in the Drupal database.  Select when (if ever) this should be done.  Requires a password attribute to be selected above.'),
    '#default_value' => simple_ldap_user_variable_get('simple_ldap_user_auth_fallback'),
  );
  $form['advanced']['simple_ldap_user_auth_fallback_writeback'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Writeback on Fallback'),
    '#options' => array(
      'nopass' => t('Writeback the user\'s password when their LDAP password is empty.'),
      'norecord' => t('Writeback full LDAP record when the user\'s LDAP record does not exist.'),
    ),
    '#description' => t('When using Fallback Authentication, should LDAP be updated on successful authentication?  Requires write-access to the LDAP server and a user password field to be selected above.'),
    '#default_value' => simple_ldap_user_variable_get('simple_ldap_user_auth_fallback_writeback'),
  );
}

Functions

Name	Description
simple_ldap_user_check_drupal_password	A copy of the original user_check_password() function so we can fallback to Drupal's authentication for UID1 and certain other cases.
simple_ldap_user_form_simple_ldap_user_admin_alter	Add a fall-back option when authenticating against LDAP.
user_check_password	Check whether a plain text password matches a stored hashed password.
user_hash_password	Hash a password using a secure hash.
user_needs_new_hash	Check whether a user's hashed password needs to be replaced with a new hash.
_password_base64_encode	Encode bytes into printable base 64 using the *nix standard from crypt().
_password_crypt	Hash a password using a secure stretched hash.
_password_enforce_log2_boundaries	Ensures that $count_log2 is within set bounds.
_password_generate_salt	Generates a random base 64-encoded salt prefixed with settings for the hash.
_password_get_count_log2	Parse the log2 iteration count from a stored hash or setting string.
_password_itoa64	Returns a string for mapping an int to the corresponding base 64 character.

Constants

Name	Description
DRUPAL_HASH_COUNT	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.
DRUPAL_HASH_LENGTH	The expected (and maximum) number of characters in a hashed password.
DRUPAL_MAX_HASH_COUNT	The maximum allowed log2 number of iterations for password stretching.
DRUPAL_MIN_HASH_COUNT	The minimum allowed log2 number of iterations for password stretching.