Skip to content

Instantly share code, notes, and snippets.

@jcable jcable/password.js

Last active May 8, 2020
Embed
What would you like to do?
Drupal 7 password.inc translation to javascript
const crypto = require('crypto');
var md5 = require('md5');
/**
* @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 = 15;
/**
* 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';
}
/**
* Encodes bytes into printable base 64 using the *nix standard from crypt().
*
* @param input
* The Buffer 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 = input[i++];
output += itoa64[value & 0x3f];
if (i < count) {
value = value | input[i] << 8;
}
output += itoa64[value >> 6 & 0x3f];
if (i++ >= count) {
break;
}
if (i < count) {
value = value | 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(crypto.randomBytes(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;
}
else if (count_log2 > DRUPAL_MAX_HASH_COUNT) {
return DRUPAL_MAX_HASH_COUNT;
}
return 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
* Plain-text password up to 512 bytes (128 to 512 UTF-8 characters) 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) {
// Prevent DoS attacks by refusing to hash large passwords.
if (password.length > 512) {
return false;
}
// The first 12 characters of an existing hash are its setting string.
setting = setting.substr(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 = setting.substr(4, 8);
// Hashes must have an 8 character salt.
if (salt.length !== 8) {
return false;
}
// Convert the base 2 logarithm into an integer.
let hash = crypto.createHash(algo);
hash.update(salt + password);
let buffer = hash.digest();
count = 1 << count_log2;
const pb = Buffer.from(password);
do {
hash = crypto.createHash(algo);
hash.update(Buffer.concat([buffer, pb]));
buffer = hash.digest();
} while (--count);
len = buffer.length;
output = setting + _password_base64_encode(buffer, 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 + Math.ceil(8 * len / 6);
return output.length === expected ? output.substr(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 itoa64.indexOf(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 (account.pass.startsWith('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 = account.pass.substr(1);
password = md5(password);
}
else {
stored_hash = account.pass;
}
type = stored_hash.substr(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 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 (account.pass.substr(0, 3) != '$S$' || account.pass.length != DRUPAL_HASH_LENGTH) {
return true;
}
// Ensure that count_log2 is within set bounds.
count_log2 = _password_enforce_log2_boundaries(DRUPAL_HASH_COUNT);
// Check whether the iteration count used differs from the standard number.
return _password_get_count_log2(account.pass) !== count_log2;
}
/* base64_charIndex
* Internal helper to translate a base64 character to its integer index.
*/
function base64_charIndex(c) {
return _password_itoa64().indexOf(c)
}
function charToBinary(c) {
const d = base64_charIndex(c);
const b = d.toString(2).padStart(6, '0');
const r = b.split('').reverse().join('');
return r;
}
function toBinaryString(data) {
let r = '';
for(i=0; i<data.length; i++) {
r += charToBinary(data[i]);
}
return r;
}
function _password_base64_decode(data) {
let r = Buffer.alloc(data.length);
let b = toBinaryString(data);
let count = 0;
while(b.length > 0) {
n = parseInt(b.slice(0,8).split('').reverse().join(''), 2);
b = b.slice(8);
r[count++] = n;
}
return r.slice(0, count);
}
module.exports = {
_password_base64_encode,
_password_base64_decode,
_password_crypt,
user_check_password,
user_needs_new_hash,
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.