MD5.js

// Module that replicates the MD5 Cryptographic Hash
// function in Javascript.

// main variables
const S = [
 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5,
 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11,
 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15,
 21
]

const K = [
 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a,
 0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340,
 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8,
 0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa,
 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92,
 0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
]

/**
 * Separates an array into equal sized chunks
 *
 * @param {Array|string} array - array or string to separate into chunks
 * @param {number} size - number of elements wanted in each chunk
 * @return {Array} - array of original array split into chunks
 *
 * @example
 * chunkify("this is a test", 2)
 */
function chunkify(array, size) {
 const chunks = []
 for (let i = 0; i < array.length; i += size) {
 chunks.push(array.slice(i, i + size))
 }
 return chunks
}

/**
 * Rotates the bits to the left
 *
 * @param {number} bits - 32 bit number
 * @param {number} turns - number of rotations to make
 * @return {number} - number after bits rotation
 *
 * @example
 * rotateLeft(0b1011, 3); // 0b1011000
 */
function rotateLeft(bits, turns) {
 return (bits << turns) | (bits >>> (32 - turns))
}

/**
 * Converts Uint8Array to Uint32Array
 *
 * @param {Uint8Array} u8Array Uint8Array to convert
 * @returns {Uint32Array} - Required Uint32Array
 */
function u8ToU32(u8Array) {
 const uint32Array = new Uint32Array(u8Array.length / 4)

 for (let i = 0; i < u8Array.length; i += 4) {
 uint32Array[i / 4] =
 (u8Array[i] |
 (u8Array[i + 1] << 8) |
 (u8Array[i + 2] << 16) |
 (u8Array[i + 3] << 24)) >>>
 0
 }

 return uint32Array
}

/**
 * Converts Uint32Array to Uint8Array
 *
 * @param {Uint32Array} u32Array Uint32Array to convert
 * @returns {Uint8Array} - Required Uint8Array
 */
function u32ToU8(u32Array) {
 const uint8Array = new Uint8Array(u32Array.length * 4)

 for (let i = 0; i < u32Array.length; i++) {
 uint8Array[i * 4] = u32Array[i] & 0xff
 uint8Array[i * 4 + 1] = (u32Array[i] >> 8) & 0xff
 uint8Array[i * 4 + 2] = (u32Array[i] >> 16) & 0xff
 uint8Array[i * 4 + 3] = (u32Array[i] >> 24) & 0xff
 }

 return uint8Array
}

/**
 * Adds padding to the end of the given array
 *
 * @param {Uint8Array} u8Array Array to pad
 * @param {number} size Resulting size of the array
 */
function padEnd(u8Array, size) {
 const result = new Uint8Array(size)
 result.set(u8Array)
 result.fill(0, u8Array.length)

 return result
}

/**
 * Pre-processes message to feed the algorithm loop
 *
 * @param {Uint8Array} message - message to pre-process
 * @return {Uint32Array} - processed message
 */
function preProcess(message) {
 // Extend message by adding '0'
 //
 // message.length + 1 is for adding '1' bit
 // 56 - (length % 64) is for padding with '0's
 // 8 is for appending 64 bit message length
 let m = padEnd(
 message,
 message.length + 1 + (56 - ((message.length + 1) % 64)) + 8
 )

 // Add '1' bit at the end of the message
 m[message.length] = 1 << 7

 // convert message to 32 bit uint array
 m = u8ToU32(m)

 // Append the length of the message to the end
 // (ml / 0x100000000) | 0 is equivalent to (ml >> 32) & 0xffffffff) in other languages
 let ml = message.length * 8
 m[m.length - 2] = ml & 0xffffffff
 m[m.length - 1] = (ml / 0x100000000) | 0

 return m
}

/**
 * Hashes message using MD5 Cryptographic Hash Function
 *
 * @see
 * For more info: https://en.wikipedia.org/wiki/MD5
 *
 * @param {Uint8Array} message - message to hash
 * @return {Uint8Array} - message digest (hash value)
 */
function MD5(message) {
 // Initialize variables:
 let [a0, b0, c0, d0] = [
 0x67452301 >>> 0,
 0xefcdab89 >>> 0,
 0x98badcfe >>> 0,
 0x10325476 >>> 0
 ]

 // pre-process message and split into 512 bit chunks
 const words = Array.from(preProcess(message))
 const chunks = chunkify(words, 16)

 chunks.forEach(function (chunk, _) {
 // initialize variables for this chunk
 let [A, B, C, D] = [a0, b0, c0, d0]

 for (let i = 0; i < 64; i++) {
 let [F, g] = [0, 0]

 if (i <= 15) {
 F = (B & C) | (~B & D)
 g = i
 } else if (i <= 31) {
 F = (D & B) | (~D & C)
 g = (5 * i + 1) % 16
 } else if (i <= 47) {
 F = B ^ C ^ D
 g = (3 * i + 5) % 16
 } else {
 F = C ^ (B | ~D)
 g = (7 * i) % 16
 }

 F = (F + A + K[i] + chunk[g]) >>> 0
 A = D
 D = C
 C = B
 B = ((B + rotateLeft(F, S[i])) & 0xffffffff) >>> 0
 }

 // add values for this chunk to main hash variables (unsigned)
 a0 = (a0 + A) >>> 0
 b0 = (b0 + B) >>> 0
 c0 = (c0 + C) >>> 0
 d0 = (d0 + D) >>> 0
 })

 return u32ToU8([a0, b0, c0, d0])
}

// export MD5 function
export { MD5 }