GeezerVison is showing github.com — JavaScript/Hashes/SHA1.js at master · Algorithms-Learn/JavaScript

Expand file tree

SHA1.js

Copy path

More file actions

Latest commit

History

176 lines (157 loc) · 4.41 KB

SHA1.js

Copy path

File metadata and controls

176 lines (157 loc) · 4.41 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

//= ===============================================================

// SHA1.js

// Module that replicates the SHA-1 Cryptographic Hash

// function in Javascript.

//= ===============================================================

// main variables

const CHAR_SIZE = 8

/**

* Adds padding to binary/hex string representation

* @param {string} str - string representation (binary/hex)

* @param {int} bits - total number of bits wanted

* @return {string} - string representation padding with empty (0) bits

* @example

* pad("10011", 8); // "00010011"

function pad(str, bits) {

let res = str

while (res.length % bits !== 0) {

res = '0' + res

}

return res

}

/**

* Separates string into chunks of the same size

* @param {string} str - string to separate into chunks

* @param {int} size - number of characters wanted in each chunk

* @return {array} - array of original string split into chunks

* @example

* chunkify("this is a test", 2)

function chunkify(str, size) {

const chunks = []

for (let i = 0; i < str.length; i += size) {

chunks.push(str.slice(i, i + size))

}

return chunks

}

/**

* Rotates string representation of bits to the left

* @param {string} bits - string representation of bits

* @param {int} turns - number of rotations to make

* @return {string} - string representation of bits after rotation

* @example

* rotateLeft("1011", 3); // "1101"

function rotateLeft(bits, turns) {

return bits.substr(turns) + bits.substr(0, turns)

}

/**

* Pre-processes message to feed the algorithm loop

* @param {string} message - message to pre-process

* @return {string} - processed message

function preProcess(message) {

// convert message to binary representation padded to

// 8 bits, and add 1

let m =

message

.split('')

.map((e) => e.charCodeAt(0))

.map((e) => e.toString(2))

.map((e) => pad(e, 8))

.join('') + '1'

// extend message by adding empty bits (0)

while (m.length % 512 !== 448) {

m += '0'

}

// length of message in binary, padded, and extended

// to a 64 bit representation

let ml = (message.length * CHAR_SIZE).toString(2)

ml = pad(ml, 8)

ml = '0'.repeat(64 - ml.length) + ml

return m + ml

}

/**

* Hashes message using SHA-1 Cryptographic Hash Function

* @param {string} message - message to hash

* @return {string} - message digest (hash value)

function SHA1(message) {

// main variables

let H0 = 0x67452301

let H1 = 0xefcdab89

let H2 = 0x98badcfe

let H3 = 0x10325476

let H4 = 0xc3d2e1f0

// pre-process message and split into 512 bit chunks

const bits = preProcess(message)

const chunks = chunkify(bits, 512)

chunks.forEach(function (chunk, i) {

// break each chunk into 16 32-bit words

const words = chunkify(chunk, 32)

// extend 16 32-bit words to 80 32-bit words

for (let i = 16; i < 80; i++) {

const val = [words[i - 3], words[i - 8], words[i - 14], words[i - 16]]

.map((e) => parseInt(e, 2))

.reduce((acc, curr) => curr ^ acc, 0)

const bin = (val >>> 0).toString(2)

const paddedBin = pad(bin, 32)

const word = rotateLeft(paddedBin, 1)

words.push(word)

}

// initialize variables for this chunk

let [a, b, c, d, e] = [H0, H1, H2, H3, H4]

for (let i = 0; i < 80; i++) {

let f, k

if (i < 20) {

f = (b & c) | (~b & d)

k = 0x5a827999

} else if (i < 40) {

f = b ^ c ^ d

k = 0x6ed9eba1

} else if (i < 60) {

f = (b & c) | (b & d) | (c & d)

k = 0x8f1bbcdc

} else {

f = b ^ c ^ d

k = 0xca62c1d6

}

// make sure f is unsigned

f >>>= 0

const aRot = rotateLeft(pad(a.toString(2), 32), 5)

const aInt = parseInt(aRot, 2) >>> 0

const wordInt = parseInt(words[i], 2) >>> 0

const t = aInt + f + e + k + wordInt

e = d >>> 0

d = c >>> 0

const bRot = rotateLeft(pad(b.toString(2), 32), 30)

c = parseInt(bRot, 2) >>> 0

b = a >>> 0

a = t >>> 0

}

// add values for this chunk to main hash variables (unsigned)

H0 = (H0 + a) >>> 0

H1 = (H1 + b) >>> 0

H2 = (H2 + c) >>> 0

H3 = (H3 + d) >>> 0

H4 = (H4 + e) >>> 0

})

// combine hash values of main hash variables and return

const HH = [H0, H1, H2, H3, H4]

.map((e) => e.toString(16))

.map((e) => pad(e, 8))

.join('')

return HH

}

// export SHA1 function

export { SHA1 }