JavaScript/Hashes/MD5.js at patch-1 · MMABSOUT/JavaScript · GitHub

History

205 lines (179 loc) · 5.43 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

// 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,

]

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)) >>>

}

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 }

JavaScript/Hashes/MD5.js at patch-1 · MMABSOUT/JavaScript · GitHub

Expand file tree

Breadcrumbs

MD5.js

Latest commit

History

Breadcrumbs

MD5.js

File metadata and controls