Merge pull request #45 from crypto-browserify/dcousens-patch-2

calvinmetcalf · web-flow · commit b3e2423c9598 · 2017-05-23T08:02:18.000-04:00
hash: _update never returns anything
diff --git a/.npmignore b/.npmignore
@@ -0,0 +1 @@
+tests/
diff --git a/bin.js b/bin.js
@@ -28,11 +28,9 @@ function usage () {
 
 if (!process.stdin.isTTY) {
   pipe(argv[0], process.stdin)
-
 } else if (argv.length) {
   if (/--help|-h/.test(argv[0])) {
     usage()
-
   } else {
     var filename = argv.pop()
     var algorithm = argv.pop()
diff --git a/hash.js b/hash.js
@@ -1,12 +1,11 @@
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 // prototype class for hash functions
 function Hash (blockSize, finalSize) {
   this._block = new Buffer(blockSize)
   this._finalSize = finalSize
   this._blockSize = blockSize
   this._len = 0
-  this._s = 0
 }
 
 Hash.prototype.update = function (data, enc) {
@@ -15,56 +14,62 @@ Hash.prototype.update = function (data, enc) {
     data = new Buffer(data, enc)
   }
 
-  var l = this._len += data.length
-  var s = this._s || 0
-  var f = 0
-  var buffer = this._block
+  var block = this._block
+  var blockSize = this._blockSize
+  var length = data.length
+  var accum = this._len
 
-  while (s < l) {
-    var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize))
-    var ch = (t - f)
+  for (var offset = 0; offset < length;) {
+    var assigned = accum % blockSize
+    var remainder = Math.min(length - offset, blockSize - assigned)
 
-    for (var i = 0; i < ch; i++) {
-      buffer[(s % this._blockSize) + i] = data[i + f]
+    for (var i = 0; i < remainder; i++) {
+      block[assigned + i] = data[offset + i]
     }
 
-    s += ch
-    f += ch
+    accum += remainder
+    offset += remainder
 
-    if ((s % this._blockSize) === 0) {
-      this._update(buffer)
+    if ((accum % blockSize) === 0) {
+      this._update(block)
     }
   }
-  this._s = s
 
+  this._len += length
   return this
 }
 
 Hash.prototype.digest = function (enc) {
-  // Suppose the length of the message M, in bits, is l
-  var l = this._len * 8
+  var rem = this._len % this._blockSize
 
-  // Append the bit 1 to the end of the message
-  this._block[this._len % this._blockSize] = 0x80
+  this._block[rem] = 0x80
 
-  // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
-  this._block.fill(0, this._len % this._blockSize + 1)
+  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
+  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
+  this._block.fill(0, rem + 1)
 
-  if (l % (this._blockSize * 8) >= this._finalSize * 8) {
+  if (rem >= this._finalSize) {
     this._update(this._block)
     this._block.fill(0)
   }
 
-  // to this append the block which is equal to the number l written in binary
-  if (l <= 0xffffffff) {
-    this._block.writeUInt32BE(l, this._blockSize - 4)
+  var bits = this._len * 8
+
+  // uint32
+  if (bits <= 0xffffffff) {
+    this._block.writeUInt32BE(bits, this._blockSize - 4)
+
+  // uint64
   } else {
-    var ll = l & 0xffffffff
-    this._block.writeUInt32BE((l - ll) / 0x100000000, this._blockSize - 8)
-    this._block.writeUInt32BE(ll, this._blockSize - 4)
+    var lowBits = bits & 0xffffffff
+    var highBits = (bits - lowBits) / 0x100000000
+
+    this._block.writeUInt32BE(highBits, this._blockSize - 8)
+    this._block.writeUInt32BE(lowBits, this._blockSize - 4)
   }
 
-  var hash = this._update(this._block) || this._hash()
+  this._update(this._block)
+  var hash = this._hash()
 
   return enc ? hash.toString(enc) : hash
 }
diff --git a/hexpp.js b/hexpp.js
diff --git a/package.json b/package.json
@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "inherits": "^2.0.1",
-    "buffer": "^2.3.4"
+    "safe-buffer": "^5.0.1"
   },
   "devDependencies": {
     "buffer": "~2.3.2",
diff --git a/sha.js b/sha.js
@@ -8,7 +8,7 @@
 
 var inherits = require('inherits')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var K = [
   0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
diff --git a/sha1.js b/sha1.js
@@ -9,7 +9,7 @@
 
 var inherits = require('inherits')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var K = [
   0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
diff --git a/sha224.js b/sha224.js
@@ -9,7 +9,7 @@
 var inherits = require('inherits')
 var Sha256 = require('./sha256')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var W = new Array(64)
 
diff --git a/sha256.js b/sha256.js
@@ -8,7 +8,7 @@
 
 var inherits = require('inherits')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var K = [
   0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
diff --git a/sha384.js b/sha384.js
@@ -1,7 +1,7 @@
 var inherits = require('inherits')
 var SHA512 = require('./sha512')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var W = new Array(160)
 
diff --git a/sha512.js b/sha512.js
@@ -1,6 +1,6 @@
 var inherits = require('inherits')
 var Hash = require('./hash')
-var Buffer = require('buffer/').Buffer
+var Buffer = require('safe-buffer').Buffer
 
 var K = [
   0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
diff --git a/test/hash.js b/test/hash.js
@@ -1,53 +1,48 @@
-var hexpp = require('../hexpp').defaults({ bigendian: false })
 var tape = require('tape')
 var Hash = require('../hash')
 
 var hex = '0A1B2C3D4E5F6G7H'
 
 function equal (t, a, b) {
   t.equal(a.length, b.length)
-
-  for (var i = 0; i < a.length; i++) {
-    t.equal(a[i], b[i])
-  }
+  t.equal(a.toString('hex'), b.toString('hex'))
 }
 
-var hexBuf = new Buffer([48, 65, 49, 66, 50, 67, 51, 68, 52, 69, 53, 70, 54, 71, 55, 72])
+var hexBuf = new Buffer('0A1B2C3D4E5F6G7H', 'utf8')
 var count16 = {
   strings: ['0A1B2C3D4E5F6G7H'],
   buffers: [
     hexBuf,
-    new Buffer([ 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128])
+    new Buffer('80000000000000000000000000000080', 'hex')
   ]
 }
 
 var empty = {
   strings: [''],
   buffers: [
-    new Buffer([ 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ])
+    new Buffer('80000000000000000000000000000000', 'hex')
   ]
 }
 
 var multi = {
-      strings: ['abcd', 'efhijk', 'lmnopq'],
-      buffers: [
-        new Buffer('abcdefhijklmnopq', 'ascii'),
-        new Buffer([128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128])
-      ]
-    }
+  strings: ['abcd', 'efhijk', 'lmnopq'],
+  buffers: [
+    new Buffer('abcdefhijklmnopq', 'ascii'),
+    new Buffer('80000000000000000000000000000080', 'hex')
+  ]
+}
 
 var long = {
   strings: [hex + hex],
   buffers: [
     hexBuf,
     hexBuf,
-    new Buffer([128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0])
+    new Buffer('80000000000000000000000000000100', 'hex')
   ]
 }
 
 function makeTest (name, data) {
   tape(name, function (t) {
-
     var h = new Hash(16, 8)
     var hash = new Buffer(20)
     var n = 2
@@ -56,18 +51,13 @@ function makeTest (name, data) {
 
     h._update = function (block) {
       var e = expected.shift()
-
-      console.log('---block---')
-      console.log(hexpp(block), block.length)
-      console.log('---e---')
-      console.log(hexpp(e), block.length)
-      console.log(block)
       equal(t, block, e)
 
       if (n < 0) {
         throw new Error('expecting only 2 calls to _update')
       }
-
+    }
+    h._hash = function () {
       return hash
     }
 
diff --git a/test/vectors.js b/test/vectors.js
@@ -1,8 +1,7 @@
 var tape = require('tape')
 var vectors = require('hash-test-vectors')
 // var from = require('bops/typedarray/from')
-var Buffer = require('buffer').Buffer
-var hexpp = require('../hexpp')
+var Buffer = require('safe-buffer').Buffer
 
 var createHash = require('../')
 
@@ -14,7 +13,6 @@ function makeTest (alg, i, verbose) {
       console.log(v)
       console.log('VECTOR', i)
       console.log('INPUT', v.input)
-      console.log(hexpp(new Buffer(v.input, 'base64')))
       console.log(new Buffer(v.input, 'base64').toString('hex'))
     }
 
