fcad-core-dragon 2.0.0-beta.1 → 2.0.0-beta.3

package/src/module/xapi/Crypto/algorithms/C_algo.js

@@ -1,319 +1,315 @@
-import { WordArray } from '../WordArray'
-import { Hasher } from '../Hasher'
-import { Base } from '../encoders/Base'
-import { Utf8 } from '../encoders/Utf8'
-/**
- * Algorithm namespace.
- */
-export const C_algo = function() {
-  // Reusable Variables
-  let W = [],
-    K = [],
-    H = []
-
-  return {
-    /**
-     * SHA-1 hash algorithm.
-     */
-    SHA1: Hasher.extend({
-      _doReset: function() {
-        this._hash = new WordArray.init([
-          0x67452301,
-          0xefcdab89,
-          0x98badcfe,
-          0x10325476,
-          0xc3d2e1f0
-        ])
-      },
-
-      _doProcessBlock: function(M, offset) {
-        // Shortcut
-        let H = this._hash.words
-
-        // Working let iables
-        let a = H[0]
-        let b = H[1]
-        let c = H[2]
-        let d = H[3]
-        let e = H[4]
-
-        // Computation
-        for (let i = 0; i < 80; i++) {
-          if (i < 16) {
-            W[i] = M[offset + i] | 0
-          } else {
-            let n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
-            W[i] = (n << 1) | (n >>> 31)
-          }
-
-          let t = ((a << 5) | (a >>> 27)) + e + W[i]
-          if (i < 20) {
-            t += ((b & c) | (~b & d)) + 0x5a827999
-          } else if (i < 40) {
-            t += (b ^ c ^ d) + 0x6ed9eba1
-          } else if (i < 60) {
-            t += ((b & c) | (b & d) | (c & d)) - 0x70e44324
-          } /* if (i < 80) */ else {
-            t += (b ^ c ^ d) - 0x359d3e2a
-          }
-
-          e = d
-          d = c
-          c = (b << 30) | (b >>> 2)
-          b = a
-          a = t
-        }
-
-        // 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
-      },
-
-      _doFinalize: function() {
-        // Shortcuts
-        let data = this._data
-        let dataWords = data.words
-
-        let nBitsTotal = this._nDataBytes * 8
-        let 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: function() {
-        let clone = Hasher.clone.call(this)
-        clone._hash = this._hash.clone()
-
-        return clone
-      }
-    }),
-    /**
-     * HMAC algorithm.
-     */
-    HMAC: Base.extend({
-      /**
-       * Initializes a newly created HMAC.
-       *
-       * @param {Hasher} hasher The hash algorithm to use.
-       * @param {WordArray|string} key The secret key.
-       * @example
-       *     let hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
-       */
-      init: function(hasher, key) {
-        // Init hasher
-        hasher = this._hasher = new hasher.init()
-
-        // Convert string to WordArray, else assume WordArray already
-        if (typeof key == 'string') {
-          key = Utf8.parse(key)
-        }
-
-        // Shortcuts
-        let hasherBlockSize = hasher.blockSize
-        let hasherBlockSizeBytes = hasherBlockSize * 4
-
-        // Allow arbitrary length keys
-        if (key.sigBytes > hasherBlockSizeBytes) {
-          key = hasher.finalize(key)
-        }
-
-        // Clamp excess bits
-        key.clamp()
-
-        // Clone key for inner and outer pads
-        let oKey = (this._oKey = key.clone())
-        let iKey = (this._iKey = key.clone())
-
-        // Shortcuts
-        let oKeyWords = oKey.words
-        let iKeyWords = iKey.words
-
-        // XOR keys with pad constants
-        for (let i = 0; i < hasherBlockSize; i++) {
-          oKeyWords[i] ^= 0x5c5c5c5c
-          iKeyWords[i] ^= 0x36363636
-        }
-        oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes
-
-        // Set initial values
-        this.reset()
-      },
-
-      /**
-       * Resets this HMAC to its initial state.
-       * @example
-       *     hmacHasher.reset();
-       */
-      reset: function() {
-        // Shortcut
-        let hasher = this._hasher
-
-        // Reset
-        hasher.reset()
-        hasher.update(this._iKey)
-      },
-
-      /**
-       * Updates this HMAC with a message.
-       * @param {WordArray|string} messageUpdate The message to append.
-       * @return {HMAC} This HMAC instance.
-       * @example
-       *     hmacHasher.update('message');
-       *     hmacHasher.update(wordArray);
-       */
-      update: function(messageUpdate) {
-        this._hasher.update(messageUpdate)
-
-        // Chainable
-        return this
-      },
-
-      /**
-       * Finalizes the HMAC computation.
-       * Note that the finalize operation is effectively a destructive, read-once operation.
-       *
-       * @param {WordArray|string} messageUpdate (Optional) A final message update.
-       * @return {WordArray} The HMAC.
-       * @example
-       *     let hmac = hmacHasher.finalize();
-       *     let hmac = hmacHasher.finalize('message');
-       *     let hmac = hmacHasher.finalize(wordArray);
-       */
-      finalize: function(messageUpdate) {
-        // Shortcut
-        let hasher = this._hasher
-
-        // Compute HMAC
-        let innerHash = hasher.finalize(messageUpdate)
-        hasher.reset()
-        let hmac = hasher.finalize(this._oKey.clone().concat(innerHash))
-
-        return hmac
-      }
-    }),
-
-    /**
-     * SHA-256 hash algorithm.
-     */
-    SHA256: Hasher.extend({
-      _doReset: function() {
-        this._hash = new WordArray.init(H.slice(0))
-      },
-
-      _doProcessBlock: function(M, offset) {
-        // Shortcut
-        let 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++) {
-          if (i < 16) {
-            W[i] = M[offset + i] | 0
-          } else {
-            let gamma0x = W[i - 15]
-            let gamma0 =
-              ((gamma0x << 25) | (gamma0x >>> 7)) ^
-              ((gamma0x << 14) | (gamma0x >>> 18)) ^
-              (gamma0x >>> 3)
-
-            let gamma1x = W[i - 2]
-            let gamma1 =
-              ((gamma1x << 15) | (gamma1x >>> 17)) ^
-              ((gamma1x << 13) | (gamma1x >>> 19)) ^
-              (gamma1x >>> 10)
-
-            W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
-          }
-
-          let ch = (e & f) ^ (~e & g)
-          let maj = (a & b) ^ (a & c) ^ (b & c)
-
-          let sigma0 =
-            ((a << 30) | (a >>> 2)) ^
-            ((a << 19) | (a >>> 13)) ^
-            ((a << 10) | (a >>> 22))
-          let sigma1 =
-            ((e << 26) | (e >>> 6)) ^
-            ((e << 21) | (e >>> 11)) ^
-            ((e << 7) | (e >>> 25))
-
-          let t1 = h + sigma1 + ch + K[i] + W[i]
-          let 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: function() {
-        // Shortcuts
-        let data = this._data
-        let dataWords = data.words
-
-        let nBitsTotal = this._nDataBytes * 8
-        let 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: function() {
-        let clone = Hasher.clone.call(this)
-        clone._hash = this._hash.clone()
-
-        return clone
-      }
-    })
-  }
-}
+import { WordArray } from '../WordArray'
+import { Hasher } from '../Hasher'
+import { Base } from '../encoders/Base'
+import { Utf8 } from '../encoders/Utf8'
+/**
+ * Algorithm namespace.
+ */
+export const C_algo = function () {
+  // Reusable Variables
+  let W = [],
+    K = [],
+    H = []
+
+  return {
+    /**
+     * SHA-1 hash algorithm.
+     */
+    SHA1: Hasher.extend({
+      _doReset: function () {
+        this._hash = new WordArray.init([
+          0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
+        ])
+      },
+
+      _doProcessBlock: function (M, offset) {
+        // Shortcut
+        let H = this._hash.words
+
+        // Working let iables
+        let a = H[0]
+        let b = H[1]
+        let c = H[2]
+        let d = H[3]
+        let e = H[4]
+
+        // Computation
+        for (let i = 0; i < 80; i++) {
+          if (i < 16) {
+            W[i] = M[offset + i] | 0
+          } else {
+            let n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
+            W[i] = (n << 1) | (n >>> 31)
+          }
+
+          let t = ((a << 5) | (a >>> 27)) + e + W[i]
+          if (i < 20) {
+            t += ((b & c) | (~b & d)) + 0x5a827999
+          } else if (i < 40) {
+            t += (b ^ c ^ d) + 0x6ed9eba1
+          } else if (i < 60) {
+            t += ((b & c) | (b & d) | (c & d)) - 0x70e44324
+          } /* if (i < 80) */ else {
+            t += (b ^ c ^ d) - 0x359d3e2a
+          }
+
+          e = d
+          d = c
+          c = (b << 30) | (b >>> 2)
+          b = a
+          a = t
+        }
+
+        // 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
+      },
+
+      _doFinalize: function () {
+        // Shortcuts
+        let data = this._data
+        let dataWords = data.words
+
+        let nBitsTotal = this._nDataBytes * 8
+        let 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: function () {
+        let clone = Hasher.clone.call(this)
+        clone._hash = this._hash.clone()
+
+        return clone
+      }
+    }),
+    /**
+     * HMAC algorithm.
+     */
+    HMAC: Base.extend({
+      /**
+       * Initializes a newly created HMAC.
+       *
+       * @param {Hasher} hasher The hash algorithm to use.
+       * @param {WordArray|string} key The secret key.
+       * @example
+       *     let hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+       */
+      init: function (hasher, key) {
+        // Init hasher
+        hasher = this._hasher = new hasher.init()
+
+        // Convert string to WordArray, else assume WordArray already
+        if (typeof key == 'string') {
+          key = Utf8.parse(key)
+        }
+
+        // Shortcuts
+        let hasherBlockSize = hasher.blockSize
+        let hasherBlockSizeBytes = hasherBlockSize * 4
+
+        // Allow arbitrary length keys
+        if (key.sigBytes > hasherBlockSizeBytes) {
+          key = hasher.finalize(key)
+        }
+
+        // Clamp excess bits
+        key.clamp()
+
+        // Clone key for inner and outer pads
+        let oKey = (this._oKey = key.clone())
+        let iKey = (this._iKey = key.clone())
+
+        // Shortcuts
+        let oKeyWords = oKey.words
+        let iKeyWords = iKey.words
+
+        // XOR keys with pad constants
+        for (let i = 0; i < hasherBlockSize; i++) {
+          oKeyWords[i] ^= 0x5c5c5c5c
+          iKeyWords[i] ^= 0x36363636
+        }
+        oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes
+
+        // Set initial values
+        this.reset()
+      },
+
+      /**
+       * Resets this HMAC to its initial state.
+       * @example
+       *     hmacHasher.reset();
+       */
+      reset: function () {
+        // Shortcut
+        let hasher = this._hasher
+
+        // Reset
+        hasher.reset()
+        hasher.update(this._iKey)
+      },
+
+      /**
+       * Updates this HMAC with a message.
+       * @param {WordArray|string} messageUpdate The message to append.
+       * @return {HMAC} This HMAC instance.
+       * @example
+       *     hmacHasher.update('message');
+       *     hmacHasher.update(wordArray);
+       */
+      update: function (messageUpdate) {
+        this._hasher.update(messageUpdate)
+
+        // Chainable
+        return this
+      },
+
+      /**
+       * Finalizes the HMAC computation.
+       * Note that the finalize operation is effectively a destructive, read-once operation.
+       *
+       * @param {WordArray|string} messageUpdate (Optional) A final message update.
+       * @return {WordArray} The HMAC.
+       * @example
+       *     let hmac = hmacHasher.finalize();
+       *     let hmac = hmacHasher.finalize('message');
+       *     let hmac = hmacHasher.finalize(wordArray);
+       */
+      finalize: function (messageUpdate) {
+        // Shortcut
+        let hasher = this._hasher
+
+        // Compute HMAC
+        let innerHash = hasher.finalize(messageUpdate)
+        hasher.reset()
+        let hmac = hasher.finalize(this._oKey.clone().concat(innerHash))
+
+        return hmac
+      }
+    }),
+
+    /**
+     * SHA-256 hash algorithm.
+     */
+    SHA256: Hasher.extend({
+      _doReset: function () {
+        this._hash = new WordArray.init(H.slice(0))
+      },
+
+      _doProcessBlock: function (M, offset) {
+        // Shortcut
+        let 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++) {
+          if (i < 16) {
+            W[i] = M[offset + i] | 0
+          } else {
+            let gamma0x = W[i - 15]
+            let gamma0 =
+              ((gamma0x << 25) | (gamma0x >>> 7)) ^
+              ((gamma0x << 14) | (gamma0x >>> 18)) ^
+              (gamma0x >>> 3)
+
+            let gamma1x = W[i - 2]
+            let gamma1 =
+              ((gamma1x << 15) | (gamma1x >>> 17)) ^
+              ((gamma1x << 13) | (gamma1x >>> 19)) ^
+              (gamma1x >>> 10)
+
+            W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
+          }
+
+          let ch = (e & f) ^ (~e & g)
+          let maj = (a & b) ^ (a & c) ^ (b & c)
+
+          let sigma0 =
+            ((a << 30) | (a >>> 2)) ^
+            ((a << 19) | (a >>> 13)) ^
+            ((a << 10) | (a >>> 22))
+          let sigma1 =
+            ((e << 26) | (e >>> 6)) ^
+            ((e << 21) | (e >>> 11)) ^
+            ((e << 7) | (e >>> 25))
+
+          let t1 = h + sigma1 + ch + K[i] + W[i]
+          let 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: function () {
+        // Shortcuts
+        let data = this._data
+        let dataWords = data.words
+
+        let nBitsTotal = this._nDataBytes * 8
+        let 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: function () {
+        let clone = Hasher.clone.call(this)
+        clone._hash = this._hash.clone()
+
+        return clone
+      }
+    })
+  }
+}

package/src/module/xapi/Crypto/algorithms/HMAC.js

@@ -1,9 +1,9 @@
-//import { WordArray } from './WordArray'
-import { C_algo } from './C_algo'
-/**
- * SHA-1 hash algorithm.
- */
-export const SHA1 = function() {
-  let sha1 = C_algo().SHA1
-  return sha1
-}
+//import { WordArray } from './WordArray'
+import { C_algo } from './C_algo'
+/**
+ * SHA-1 hash algorithm.
+ */
+export const SHA1 = function () {
+  let sha1 = C_algo().SHA1
+  return sha1
+}