chore: wip

Author: chrisbbreuer

packages/sha/src/index.ts

@@ -1,4 +1,4 @@
 export * from './sha1'
 export * from './sha256'
 export * from './sha384'
-export * from './sha512'
+// export * from './sha512'

packages/sha/src/sha1.ts

@@ -1,5 +1,7 @@
 /**
  * Secure Hash Algorithm with 160-bit digest (SHA-1) implementation.
+ * This implementation follows the FIPS 180-2 specification and is based on the
+ * node-forge implementation.
  *
  * @author Chris Breuer
  */
@@ -41,8 +43,8 @@ export function create(): MessageDigest {
   // input buffer
   let _input = createBuffer()
 
-  // Fix array initialization with proper typing
-  const _w: number[] = Array.from({ length: 80 }).fill(0)
+  // used for word storage
+  const _w: number[] = new Array(80).fill(0)
 
   // message digest object
   const md: MessageDigest = {
@@ -84,31 +86,31 @@ export function create(): MessageDigest {
     },
 
     /**
-     * Updates the digest with the given message input. The given input can
-     * treated as raw input (no encoding will be applied) or an encoding of
-     * 'utf8' maybe given to encode the input using UTF-8.
+     * Updates the digest with the given message input.
      *
      * @param msg the message input to update with.
      * @param encoding the encoding to use (default: 'raw', other: 'utf8').
      *
      * @return this digest object.
      */
     update(msg: string | ByteStringBuffer, encoding?: string) {
+      if (!msg) {
+        return md
+      }
+
       if (encoding === 'utf8') {
         msg = encodeUtf8(msg as string)
       }
 
       // update message length
       const len = msg instanceof ByteStringBuffer ? msg.length() : msg.length
       md.messageLength += len
-      const lenArr = [Math.floor(len / 0x100000000), len >>> 0]
+      const lenArr = [(len / 0x100000000) >>> 0, len >>> 0]
       for (let i = md.fullMessageLength.length - 1; i >= 0; --i) {
         md.fullMessageLength[i] += lenArr[1]
-        const carry = Math.floor(md.fullMessageLength[i] / 0x100000000)
+        lenArr[1] = lenArr[0] + ((md.fullMessageLength[i] / 0x100000000) >>> 0)
         md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0
-        if (carry > 0 && i > 0) {
-          md.fullMessageLength[i - 1] += carry
-        }
+        lenArr[0] = ((lenArr[1] / 0x100000000) >>> 0)
       }
 
       // add bytes to input buffer
@@ -117,9 +119,9 @@ export function create(): MessageDigest {
       // process bytes
       _update(_state!, _w, _input)
 
-      // compact input buffer every 2K or if empty
-      if (_input.read > 2048 || _input.length() === 0) {
-        _input.compact()
+      // compact input buffer every 2K bytes
+      if (_input.length() > 2048) {
+        _input = createBuffer(_input.bytes())
       }
 
       return md
@@ -131,70 +133,65 @@ export function create(): MessageDigest {
      * @return a byte buffer containing the digest value.
      */
     digest() {
-      /* Note: Here we copy the remaining bytes in the input buffer and
-      add the appropriate SHA-1 padding. Then we do the final update
-      on a copy of the state so that if the user wants to get
-      intermediate digests they can do so. */
-
-      /* Determine the number of bytes that must be added to the message
-      to ensure its length is congruent to 448 mod 512. In other words,
-      the data to be digested must be a multiple of 512 bits (or 128 bytes).
-      This data includes the message, some padding, and the length of the
-      message. Since the length of the message will be encoded as 8 bytes (64
-      bits), that means that the last segment of the data must have 56 bytes
-      (448 bits) of message and padding. Therefore, the length of the message
-      plus the padding must be congruent to 448 mod 512 because
-      512 - 128 = 448.
-
-      In order to fill up the message length it must be filled with
-      padding that begins with 1 bit followed by all 0 bits. Padding
-      must *always* be present, so if the message length is already
-      congruent to 448 mod 512, then 512 padding bits must be added. */
-
       const finalBlock = createBuffer()
       finalBlock.putBytes(_input.bytes())
 
       // compute remaining size to be digested (include message length size)
       const remaining = (
-        md.fullMessageLength[md.fullMessageLength.length - 1]
-        + md.messageLengthSize)
+        md.fullMessageLength[md.fullMessageLength.length - 1] +
+        md.messageLengthSize
+      )
 
       // add padding for overflow blockSize - overflow
-      // _padding starts with 1 byte with first bit is set (byte value 128), then
-      // there may be up to (blockSize - 1) other pad bytes
       const overflow = remaining & (md.blockLength - 1)
       if (_padding === null) {
         throw new Error('SHA-1 padding not initialized')
       }
-      finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow))
 
-      // serialize message length in bits in big-endian order; since length
-      // is stored in bytes we multiply by 8 and add carry from next int
-      let next: number, carry: number
+      // add padding
+      const padLength = overflow < 56 ? 56 - overflow : 120 - overflow
+      finalBlock.putBytes(_padding.substr(0, padLength))
+
+      // serialize message length in bits in big-endian order
       let bits = md.fullMessageLength[0] * 8
+      const finalState = {
+        h0: _state!.h0,
+        h1: _state!.h1,
+        h2: _state!.h2,
+        h3: _state!.h3,
+        h4: _state!.h4,
+      }
+
       for (let i = 0; i < md.fullMessageLength.length - 1; ++i) {
-        next = md.fullMessageLength[i + 1] * 8
-        carry = (next / 0x100000000) >>> 0
+        const next = md.fullMessageLength[i + 1] * 8
+        const carry = (next / 0x100000000) >>> 0
         bits += carry
         finalBlock.putInt32(bits >>> 0)
         bits = next >>> 0
       }
       finalBlock.putInt32(bits)
 
-      const s2 = {
-        h0: _state!.h0,
-        h1: _state!.h1,
-        h2: _state!.h2,
-        h3: _state!.h3,
-        h4: _state!.h4,
-      }
-      _update(s2, _w, finalBlock)
+      // update state one last time
+      _update(finalState, _w, finalBlock)
+
+      // build final hash value
       const rval = createBuffer()
-      rval.putInt32(s2.h0)
-      rval.putInt32(s2.h1)
-      rval.putInt32(s2.h2)
-      rval.putInt32(s2.h3)
-      rval.putInt32(s2.h4)
+      rval.putInt32(finalState.h0)
+      rval.putInt32(finalState.h1)
+      rval.putInt32(finalState.h2)
+      rval.putInt32(finalState.h3)
+      rval.putInt32(finalState.h4)
+
+      // reset state for next use
+      _input = createBuffer()
+      _state = {
+        h0: 0x67452301,
+        h1: 0xEFCDAB89,
+        h2: 0x98BADCFE,
+        h3: 0x10325476,
+        h4: 0xC3D2E1F0,
+      }
+
       return rval
     },
   }
@@ -237,108 +234,56 @@ function _update(s: {
 }, w: number[], bytes: ByteStringBuffer) {
   // consume 512 bit (64 byte) chunks
   let t: number, a: number, b: number, c: number, d: number, e: number, f: number
-  let i: number
   let len = bytes.length()
   while (len >= 64) {
-    // the w array will be populated with sixteen 32-bit big-endian words
-    // and then extended into 80 32-bit words according to SHA-1 algorithm
-    // and for 32-79 using Max Locktyukhin's optimization
-
     // initialize hash value for this chunk
     a = s.h0
     b = s.h1
     c = s.h2
     d = s.h3
     e = s.h4
 
-    // round 1
-    for (i = 0; i < 16; ++i) {
-      t = bytes.getInt32()
-      w[i] = t
-      f = d ^ (b & (c ^ d))
-      t = ((a << 5) | (a >>> 27)) + f + e + 0x5A827999 + t
-      e = d
-      d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
-      c = ((b << 30) | (b >>> 2)) >>> 0
-      b = a
-      a = t
-    }
-    for (; i < 20; ++i) {
-      t = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])
-      t = (t << 1) | (t >>> 31)
-      w[i] = t
-      f = d ^ (b & (c ^ d))
-      t = ((a << 5) | (a >>> 27)) + f + e + 0x5A827999 + t
-      e = d
-      d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
-      c = ((b << 30) | (b >>> 2)) >>> 0
-      b = a
-      a = t
-    }
-    // round 2
-    for (; i < 32; ++i) {
-      t = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])
-      t = (t << 1) | (t >>> 31)
-      w[i] = t
-      f = b ^ c ^ d
-      t = ((a << 5) | (a >>> 27)) + f + e + 0x6ED9EBA1 + t
-      e = d
-      d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
-      c = ((b << 30) | (b >>> 2)) >>> 0
-      b = a
-      a = t
+    // The w array will be populated with sixteen 32-bit big-endian words
+    for (let i = 0; i < 16; ++i) {
+      w[i] = bytes.getInt32()
     }
-    for (; i < 40; ++i) {
-      t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32])
-      t = (t << 2) | (t >>> 30)
-      w[i] = t
-      f = b ^ c ^ d
-      t = ((a << 5) | (a >>> 27)) + f + e + 0x6ED9EBA1 + t
-      e = d
-      d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
-      c = ((b << 30) | (b >>> 2)) >>> 0
-      b = a
-      a = t
-    }
-    // round 3
-    for (; i < 60; ++i) {
-      t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32])
-      t = (t << 2) | (t >>> 30)
-      w[i] = t
-      f = (b & c) | (d & (b ^ c))
-      t = ((a << 5) | (a >>> 27)) + f + e + 0x8F1BBCDC + t
-      e = d
-      d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
-      c = ((b << 30) | (b >>> 2)) >>> 0
-      b = a
-      a = t
+
+    // Extend into 80 32-bit words
+    for (let i = 16; i < 80; ++i) {
+      t = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]
+      w[i] = ((t << 1) | (t >>> 31)) >>> 0
     }
-    // round 4
-    for (; i < 80; ++i) {
-      t = (w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32])
-      t = (t << 2) | (t >>> 30)
-      w[i] = t
-      f = b ^ c ^ d
-      t = ((a << 5) | (a >>> 27)) + f + e + 0xCA62C1D6 + t
+
+    // Round function
+    for (let i = 0; i < 80; ++i) {
+      if (i < 20) {
+        f = (b & c) | ((~b) & d)
+        t = 0x5A827999
+      } else if (i < 40) {
+        f = b ^ c ^ d
+        t = 0x6ED9EBA1
+      } else if (i < 60) {
+        f = (b & c) | (b & d) | (c & d)
+        t = 0x8F1BBCDC
+      } else {
+        f = b ^ c ^ d
+        t = 0xCA62C1D6
+      }
+
+      t = (((a << 5) | (a >>> 27)) + f + e + t + w[i]) >>> 0
       e = d
       d = c
-      // `>>> 0` necessary to avoid iOS/Safari 10 optimization bug
       c = ((b << 30) | (b >>> 2)) >>> 0
       b = a
       a = t
     }
 
-    // update hash state
-    s.h0 = (s.h0 + a) | 0
-    s.h1 = (s.h1 + b) | 0
-    s.h2 = (s.h2 + c) | 0
-    s.h3 = (s.h3 + d) | 0
-    s.h4 = (s.h4 + e) | 0
+    // update state
+    s.h0 = (s.h0 + a) >>> 0
+    s.h1 = (s.h1 + b) >>> 0
+    s.h2 = (s.h2 + c) >>> 0
+    s.h3 = (s.h3 + d) >>> 0
+    s.h4 = (s.h4 + e) >>> 0
 
     len -= 64
   }
@@ -347,3 +292,5 @@ function _update(s: {
 export const sha1: { create: typeof create } = {
   create,
 }
+
+export default sha1