convert: use Buffers and add more tests

src/convert.js

@@ -2,11 +2,11 @@ var assert = require('assert')
 var Crypto = require('crypto-js')
 var WordArray = Crypto.lib.WordArray
 
-function bytesToWords(bytes) {
+function bufferToWords(buffer) {
-  assert(Array.isArray(bytes) || Buffer.isBuffer(bytes), 'Input must be a byte array')
+  assert(Buffer.isBuffer(buffer), 'Expected Buffer, got' + buffer)
   var words = []
-  for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
+  for (var i = 0, b = 0; i < buffer.length; i++, b += 8) {
-    words[b >>> 5] |= bytes[i] << (24 - b % 32)
+    words[b >>> 5] |= buffer[i] << (24 - b % 32)
   }
   return words
 }
@@ -19,12 +19,12 @@ function wordsToBytes(words) {
   return bytes
 }
 
-function bytesToWordArray(bytes) {
+function bufferToWordArray(buffer) {
-  return new WordArray.init(bytesToWords(bytes), bytes.length)
+  return new WordArray.init(bufferToWords(buffer), buffer.length)
 }
 
-function wordArrayToBytes(wordArray) {
+function wordArrayToBuffer(wordArray) {
-  return wordsToBytes(wordArray.words)
+  return new Buffer(wordsToBytes(wordArray.words))
 }
 
 function reverseEndian(hex) {
@@ -35,9 +35,9 @@ function reverseEndian(hex) {
 }
 
 module.exports = {
-  bytesToWords: bytesToWords,
+  bufferToWords: bufferToWords,
   wordsToBytes: wordsToBytes,
-  bytesToWordArray: bytesToWordArray,
+  bufferToWordArray: bufferToWordArray,
-  wordArrayToBytes: wordArrayToBytes,
+  wordArrayToBuffer: wordArrayToBuffer,
   reverseEndian: reverseEndian
 }

src/crypto.js

@@ -5,13 +5,12 @@ var crypto = require('crypto')
 var convert = require('./convert')
 
 function hash160(buffer) {
-
   var step1 = sha256(buffer)
 
-  var step2a = convert.bytesToWordArray(step1)
+  var step2a = convert.bufferToWordArray(step1)
   var step2b = CryptoJS.RIPEMD160(step2a)
 
-  return new Buffer(convert.wordArrayToBytes(step2b))
+  return convert.wordArrayToBuffer(step2b)
 }
 
 function hash256(buffer) {
@@ -35,12 +34,12 @@ function HmacSHA512(data, secret) {
   assert(Buffer.isBuffer(data), 'Expected Buffer for data, got ' + data)
   assert(Buffer.isBuffer(secret), 'Expected Buffer for secret, got ' + secret)
 
-  var dataWords = convert.bytesToWordArray(data)
+  var dataWords = convert.bufferToWordArray(data)
-  var secretWords = convert.bytesToWordArray(secret)
+  var secretWords = convert.bufferToWordArray(secret)
 
   var hash = CryptoJS.HmacSHA512(dataWords, secretWords)
 
-  return new Buffer(convert.wordArrayToBytes(hash))
+  return convert.wordArrayToBuffer(hash)
 }
 
 module.exports = {

test/convert.js

@@ -1,30 +1,26 @@
 var assert = require('assert')
 var convert = require('../src/convert')
 
+var fixtures = require('./fixtures/convert')
+
 describe('convert', function() {
-  describe('byte array and word array conversions', function(){
+  describe('bufferToWordArray', function() {
-    var bytes, wordArray
+    fixtures.valid.forEach(function(f) {
+      it('converts ' + f.hex + ' correctly', function() {
+        var buffer = new Buffer(f.hex, 'hex')
+        var result = convert.bufferToWordArray(buffer)
 
-    beforeEach(function(){
+        assert.deepEqual(result, f.wordArray)
-      bytes = [
-        98, 233, 7, 177, 92, 191, 39, 213, 66, 83,
-        153, 235, 246, 240, 251, 80, 235, 184, 143, 24
-      ]
-      wordArray = {
-        words: [1659439025, 1556031445, 1112775147, -151979184, -340226280],
-        sigBytes: 20
-      }
       })
-
-    describe('bytesToWords', function() {
-      it('works', function() {
-        assert.deepEqual(convert.bytesToWordArray(bytes), wordArray)
     })
   })
 
-    describe('bytesToWords', function() {
+  describe('wordArrayToBuffer', function() {
-      it('works', function() {
+    fixtures.valid.forEach(function(f) {
-        assert.deepEqual(convert.wordArrayToBytes(wordArray), bytes)
+      it('converts to ' + f.hex + ' correctly', function() {
+        var resultHex = convert.wordArrayToBuffer(f.wordArray).toString('hex')
+
+        assert.deepEqual(resultHex, f.hex)
       })
     })
   })

test/fixtures/convert.json

@@ -0,0 +1,25 @@
+{
+  "valid": [
+    {
+      "hex": "0000000000000000000000000000000000000000",
+      "wordArray": {
+        "words": [0, 0, 0, 0, 0],
+        "sigBytes": 20
+      }
+    },
+    {
+      "hex": "62e907b15cbf27d5425399ebf6f0fb50ebb88f18",
+      "wordArray": {
+        "words": [1659439025, 1556031445, 1112775147, -151979184, -340226280],
+        "sigBytes": 20
+      }
+    },
+    {
+      "hex": "ffffffffffffffffffffffffffffffffffffffff",
+      "wordArray": {
+        "words": [-1, -1, -1, -1, -1],
+        "sigBytes": 20
+      }
+    }
+  ]
+}