first

node_modules/crypto-es/lib/sha256.js

@@ -0,0 +1,171 @@
+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);