import {
|
WordArray,
|
Hasher,
|
} from './core.js';
|
|
// Initialization and round constants tables
|
const H = [];
|
const K = [];
|
|
// Compute constants
|
const isPrime = (n) => {
|
const sqrtN = Math.sqrt(n);
|
for (let factor = 2; factor <= sqrtN; factor += 1) {
|
if (!(n % factor)) {
|
return false;
|
}
|
}
|
|
return true;
|
};
|
|
const getFractionalBits = n => ((n - (n | 0)) * 0x100000000) | 0;
|
|
let n = 2;
|
let nPrime = 0;
|
while (nPrime < 64) {
|
if (isPrime(n)) {
|
if (nPrime < 8) {
|
H[nPrime] = getFractionalBits(n ** (1 / 2));
|
}
|
K[nPrime] = getFractionalBits(n ** (1 / 3));
|
|
nPrime += 1;
|
}
|
|
n += 1;
|
}
|
|
// Reusable object
|
const W = [];
|
|
/**
|
* SHA-256 hash algorithm.
|
*/
|
export class SHA256Algo extends Hasher {
|
_doReset() {
|
this._hash = new WordArray(H.slice(0));
|
}
|
|
_doProcessBlock(M, offset) {
|
// Shortcut
|
const _H = this._hash.words;
|
|
// Working variables
|
let a = _H[0];
|
let b = _H[1];
|
let c = _H[2];
|
let d = _H[3];
|
let e = _H[4];
|
let f = _H[5];
|
let g = _H[6];
|
let h = _H[7];
|
|
// Computation
|
for (let i = 0; i < 64; i += 1) {
|
if (i < 16) {
|
W[i] = M[offset + i] | 0;
|
} else {
|
const gamma0x = W[i - 15];
|
const gamma0 = ((gamma0x << 25) | (gamma0x >>> 7))
|
^ ((gamma0x << 14) | (gamma0x >>> 18))
|
^ (gamma0x >>> 3);
|
|
const gamma1x = W[i - 2];
|
const gamma1 = ((gamma1x << 15) | (gamma1x >>> 17))
|
^ ((gamma1x << 13) | (gamma1x >>> 19))
|
^ (gamma1x >>> 10);
|
|
W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
|
}
|
|
const ch = (e & f) ^ (~e & g);
|
const maj = (a & b) ^ (a & c) ^ (b & c);
|
|
const sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
|
const sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));
|
|
const t1 = h + sigma1 + ch + K[i] + W[i];
|
const t2 = sigma0 + maj;
|
|
h = g;
|
g = f;
|
f = e;
|
e = (d + t1) | 0;
|
d = c;
|
c = b;
|
b = a;
|
a = (t1 + t2) | 0;
|
}
|
|
// Intermediate hash value
|
_H[0] = (_H[0] + a) | 0;
|
_H[1] = (_H[1] + b) | 0;
|
_H[2] = (_H[2] + c) | 0;
|
_H[3] = (_H[3] + d) | 0;
|
_H[4] = (_H[4] + e) | 0;
|
_H[5] = (_H[5] + f) | 0;
|
_H[6] = (_H[6] + g) | 0;
|
_H[7] = (_H[7] + h) | 0;
|
}
|
|
_doFinalize() {
|
// Shortcuts
|
const data = this._data;
|
const dataWords = data.words;
|
|
const nBitsTotal = this._nDataBytes * 8;
|
const nBitsLeft = data.sigBytes * 8;
|
|
// Add padding
|
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));
|
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
|
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
|
data.sigBytes = dataWords.length * 4;
|
|
// Hash final blocks
|
this._process();
|
|
// Return final computed hash
|
return this._hash;
|
}
|
|
clone() {
|
const clone = super.clone.call(this);
|
clone._hash = this._hash.clone();
|
|
return clone;
|
}
|
}
|
|
/**
|
* Shortcut function to the hasher's object interface.
|
*
|
* @param {WordArray|string} message The message to hash.
|
*
|
* @return {WordArray} The hash.
|
*
|
* @static
|
*
|
* @example
|
*
|
* var hash = CryptoJS.SHA256('message');
|
* var hash = CryptoJS.SHA256(wordArray);
|
*/
|
export const SHA256 = Hasher._createHelper(SHA256Algo);
|
|
/**
|
* Shortcut function to the HMAC's object interface.
|
*
|
* @param {WordArray|string} message The message to hash.
|
* @param {WordArray|string} key The secret key.
|
*
|
* @return {WordArray} The HMAC.
|
*
|
* @static
|
*
|
* @example
|
*
|
* var hmac = CryptoJS.HmacSHA256(message, key);
|
*/
|
export const HmacSHA256 = Hasher._createHmacHelper(SHA256Algo);
|
