@smartledger/bsv 5.5.0 → 5.5.2

package/test/crypto/bn.js

@@ -0,0 +1,168 @@
+'use strict'
+
+var should = require('chai').should()
+var bsv = require('../..')
+var BN = bsv.crypto.BN
+
+describe('BN', function () {
+  it('should create a bn', function () {
+    var bn = new BN(50)
+    should.exist(bn)
+    bn.toString().should.equal('50')
+  })
+
+  it('should parse this number', function () {
+    var bn = new BN(999970000)
+    bn.toString().should.equal('999970000')
+  })
+
+  it('should parse numbers below and at bn.js internal word size', function () {
+    var bn = new BN(Math.pow(2, 26) - 1)
+    bn.toString().should.equal((Math.pow(2, 26) - 1).toString())
+    bn = new BN(Math.pow(2, 26))
+    bn.toString().should.equal((Math.pow(2, 26)).toString())
+  })
+
+  describe('#add', function () {
+    it('should add two small numbers together', function () {
+      var bn1 = new BN(50)
+      var bn2 = new BN(75)
+      var bn3 = bn1.add(bn2)
+      bn3.toString().should.equal('125')
+    })
+  })
+
+  describe('#sub', function () {
+    it('should subtract a small number', function () {
+      var bn1 = new BN(50)
+      var bn2 = new BN(25)
+      var bn3 = bn1.sub(bn2)
+      bn3.toString().should.equal('25')
+    })
+  })
+
+  describe('#gt', function () {
+    it('should say 1 is greater than 0', function () {
+      var bn1 = new BN(1)
+      var bn0 = new BN(0)
+      bn1.gt(bn0).should.equal(true)
+    })
+
+    it('should say a big number is greater than a small big number', function () {
+      var bn1 = new BN('24023452345398529485723980457')
+      var bn0 = new BN('34098234283412341234049357')
+      bn1.gt(bn0).should.equal(true)
+    })
+
+    it('should say a big number is great than a standard number', function () {
+      var bn1 = new BN('24023452345398529485723980457')
+      var bn0 = new BN(5)
+      bn1.gt(bn0).should.equal(true)
+    })
+  })
+
+  describe('to/from ScriptNumBuffer', function () {
+    [0, 1, 10, 256, 1000, 65536, 65537, -1, -1000, -65536, -65537].forEach(function (n) {
+      it('rountrips correctly for ' + n, function () {
+        BN.fromScriptNumBuffer(new BN(n).toScriptNumBuffer()).toNumber().should.equal(n)
+      })
+    })
+  })
+
+  describe('#fromString', function () {
+    it('should make BN from a string', function () {
+      BN.fromString('5').toString().should.equal('5')
+    })
+    it('should work with hex string', function () {
+      BN.fromString('7fffff0000000000000000000000000000000000000000000000000000000000', 16)
+        .toString(16).should.equal('7fffff0000000000000000000000000000000000000000000000000000000000')
+    })
+  })
+
+  describe('#toString', function () {
+    it('should make a string', function () {
+      new BN(5).toString().should.equal('5')
+    })
+  })
+
+  describe('@fromBuffer', function () {
+    it('should work with big endian', function () {
+      var bn = BN.fromBuffer(Buffer.from('0001', 'hex'), {
+        endian: 'big'
+      })
+      bn.toString().should.equal('1')
+    })
+
+    it('should work with big endian 256', function () {
+      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
+        endian: 'big'
+      })
+      bn.toString().should.equal('256')
+    })
+
+    it('should work with little endian if we specify the size', function () {
+      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
+        size: 2,
+        endian: 'little'
+      })
+      bn.toString().should.equal('1')
+    })
+  })
+
+  describe('#toBuffer', function () {
+    it('should create a 4 byte buffer', function () {
+      var bn = new BN(1)
+      bn.toBuffer({
+        size: 4
+      }).toString('hex').should.equal('00000001')
+    })
+
+    it('should create a 4 byte buffer in little endian', function () {
+      var bn = new BN(1)
+      bn.toBuffer({
+        size: 4,
+        endian: 'little'
+      }).toString('hex').should.equal('01000000')
+    })
+
+    it('should create a 2 byte buffer even if you ask for a 1 byte', function () {
+      var bn = new BN('ff00', 16)
+      bn.toBuffer({
+        size: 1
+      }).toString('hex').should.equal('ff00')
+    })
+
+    it('should create a 4 byte buffer even if you ask for a 1 byte', function () {
+      var bn = new BN('ffffff00', 16)
+      bn.toBuffer({
+        size: 4
+      }).toString('hex').should.equal('ffffff00')
+    })
+  })
+
+  describe('@fromHex', function () {
+    it('should work with big endian', function () {
+      var bn = BN.fromHex('0001', {
+        endian: 'big'
+      })
+      bn.toString().should.equal('1')
+    })
+
+    it('should work with little endian if we specify the size', function () {
+      var bn = BN.fromHex('0100', {
+        size: 2,
+        endian: 'little'
+      })
+      bn.toString().should.equal('1')
+    })
+  })
+
+  describe('#toHex', function () {
+    it('should create a 4 byte he string', function () {
+      var bn = new BN(1)
+      bn.toHex({
+        size: 4
+      }).should.equal('00000001')
+    })
+  })
+})

package/test/crypto/ecdsa.js

@@ -0,0 +1,328 @@
+'use strict'
+
+var ECDSA = require('../../lib/crypto/ecdsa')
+var Hash = require('../../lib/crypto/hash')
+var Privkey = require('../../lib/privatekey')
+var Pubkey = require('../../lib/publickey')
+var Signature = require('../../lib/crypto/signature')
+var BN = require('../../lib/crypto/bn')
+var point = require('../../lib/crypto/point')
+var should = require('chai').should()
+var vectors = require('../data/ecdsa')
+
+describe('ECDSA', function () {
+  it('instantiation', function () {
+    var ecdsa = new ECDSA()
+    should.exist(ecdsa)
+  })
+
+  var ecdsa = new ECDSA()
+  ecdsa.hashbuf = Hash.sha256(Buffer.from('test data'))
+  ecdsa.privkey = new Privkey(BN.fromBuffer(
+    Buffer.from('fee0a1f7afebf9d2a5a80c0c98a31c709681cce195cbcd06342b517970c0be1e', 'hex')
+  ))
+  ecdsa.privkey2pubkey()
+
+  describe('#set', function () {
+    it('sets hashbuf', function () {
+      should.exist(ECDSA().set({
+        hashbuf: ecdsa.hashbuf
+      }).hashbuf)
+    })
+  })
+
+  describe('#calci', function () {
+    it('calculates i correctly', function () {
+      ecdsa.randomK()
+      ecdsa.sign()
+      ecdsa.calci()
+      should.exist(ecdsa.sig.i)
+    })
+
+    it('calulates this known i', function () {
+      var hashbuf = Hash.sha256(Buffer.from('some data'))
+      var r = new BN('71706645040721865894779025947914615666559616020894583599959600180037551395766', 10)
+      var s = new BN('109412465507152403114191008482955798903072313614214706891149785278625167723646', 10)
+      var ecdsa = new ECDSA({
+        privkey: new Privkey(BN.fromBuffer(Hash.sha256(Buffer.from('test')))),
+        hashbuf: hashbuf,
+        sig: new Signature({
+          r: r,
+          s: s
+        })
+      })
+
+      ecdsa.calci()
+      ecdsa.sig.i.should.equal(1)
+    })
+  })
+
+  describe('#fromString', function () {
+    it('round trip with fromString', function () {
+      var str = ecdsa.toString()
+      var ecdsa2 = ECDSA.fromString(str)
+      should.exist(ecdsa2.hashbuf)
+      should.exist(ecdsa2.privkey)
+    })
+  })
+
+  describe('#randomK', function () {
+    it('should generate a new random k when called twice in a row', function () {
+      ecdsa.randomK()
+      var k1 = ecdsa.k
+      ecdsa.randomK()
+      var k2 = ecdsa.k;
+      (k1.cmp(k2) === 0).should.equal(false)
+    })
+
+    it('should generate a random k that is (almost always) greater than this relatively small number', function () {
+      ecdsa.randomK()
+      var k1 = ecdsa.k
+      var k2 = new BN(Math.pow(2, 32)).mul(new BN(Math.pow(2, 32))).mul(new BN(Math.pow(2, 32)))
+      k2.gt(k1).should.equal(false)
+    })
+  })
+
+  describe('#deterministicK', function () {
+    it('should generate the same deterministic k', function () {
+      ecdsa.deterministicK()
+      ecdsa.k.toBuffer().toString('hex')
+        .should.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
+    })
+    it('should generate the same deterministic k if badrs is set', function () {
+      ecdsa.deterministicK(0)
+      ecdsa.k.toBuffer().toString('hex')
+        .should.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
+      ecdsa.deterministicK(1)
+      ecdsa.k.toBuffer().toString('hex')
+        .should.not.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
+      ecdsa.k.toBuffer().toString('hex')
+        .should.equal('727fbcb59eb48b1d7d46f95a04991fc512eb9dbf9105628e3aec87428df28fd8')
+    })
+    it('should compute this test vector correctly', function () {
+      // test fixture from bitcoinjs
+      // https://github.com/bitcoinjs/bitcoinjs-lib/blob/10630873ebaa42381c5871e20336fbfb46564ac8/test/fixtures/ecdsa.json#L6
+      var ecdsa = new ECDSA()
+      ecdsa.hashbuf = Hash.sha256(Buffer.from('Everything should be made as simple as possible, but not simpler.'))
+      ecdsa.privkey = new Privkey(new BN(1))
+      ecdsa.privkey2pubkey()
+      ecdsa.deterministicK()
+      ecdsa.k.toBuffer().toString('hex')
+        .should.equal('ec633bd56a5774a0940cb97e27a9e4e51dc94af737596a0c5cbb3d30332d92a5')
+      ecdsa.sign()
+      ecdsa.sig.r.toString()
+        .should.equal('23362334225185207751494092901091441011938859014081160902781146257181456271561')
+      ecdsa.sig.s.toString()
+        .should.equal('50433721247292933944369538617440297985091596895097604618403996029256432099938')
+    })
+  })
+
+  describe('#toPublicKey', function () {
+    it('should calculate the correct public key', function () {
+      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
+      ecdsa.sign()
+      ecdsa.sig.i = 0
+      var pubkey = ecdsa.toPublicKey()
+      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
+    })
+
+    it('should calculate the correct public key for this signature with low s', function () {
+      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
+      ecdsa.sig = Signature.fromString('3045022100ec3cfe0e335791ad278b4ec8eac93d0347' +
+        'a97877bb1d54d35d189e225c15f6650220278cf15b05ce47fb37d2233802899d94c774d5480bba9f0f2d996baa13370c43')
+      ecdsa.sig.i = 0
+      var pubkey = ecdsa.toPublicKey()
+      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
+    })
+
+    it('should calculate the correct public key for this signature with high s', function () {
+      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
+      ecdsa.sign()
+      ecdsa.sig = Signature.fromString('3046022100ec3cfe0e335791ad278b4ec8eac93d0347' +
+        'a97877bb1d54d35d189e225c15f665022100d8730ea4fa31b804c82ddcc7fd766269f33a079ea38e012c9238f2e2bcff34fe')
+      ecdsa.sig.i = 1
+      var pubkey = ecdsa.toPublicKey()
+      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
+    })
+  })
+
+  describe('#sigError', function () {
+    it('should return an error if the hash is invalid', function () {
+      var ecdsa = new ECDSA()
+      ecdsa.sigError().should.equal('hashbuf must be a 32 byte buffer')
+    })
+
+    it('should return an error if r, s are invalid', function () {
+      var ecdsa = new ECDSA()
+      ecdsa.hashbuf = Hash.sha256(Buffer.from('test'))
+      var pk = Pubkey.fromDER(Buffer.from('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49' +
+        '710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341', 'hex'))
+      ecdsa.pubkey = pk
+      ecdsa.sig = new Signature()
+      ecdsa.sig.r = new BN(0)
+      ecdsa.sig.s = new BN(0)
+      ecdsa.sigError().should.equal('r and s not in range')
+    })
+
+    it('should return an error if the signature is incorrect', function () {
+      ecdsa.sig = Signature.fromString('3046022100e9915e6236695f093a4128ac2a956c40' +
+        'ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827')
+      ecdsa.sig.r = ecdsa.sig.r.add(new BN(1))
+      ecdsa.sigError().should.equal('Invalid signature')
+    })
+  })
+
+  describe('#sign', function () {
+    it('should create a valid signature', function () {
+      ecdsa.randomK()
+      ecdsa.sign()
+      ecdsa.verify().verified.should.equal(true)
+    })
+
+    it('should should throw an error if hashbuf is not 32 bytes', function () {
+      var ecdsa2 = ECDSA().set({
+        hashbuf: ecdsa.hashbuf.slice(0, 31),
+        privkey: ecdsa.privkey
+      })
+      ecdsa2.randomK()
+      ecdsa2.sign.bind(ecdsa2).should.throw('hashbuf must be a 32 byte buffer')
+    })
+
+    it('should default to deterministicK', function () {
+      var ecdsa2 = new ECDSA(ecdsa)
+      ecdsa2.k = undefined
+      var called = 0
+      var deterministicK = ecdsa2.deterministicK.bind(ecdsa2)
+      ecdsa2.deterministicK = function () {
+        deterministicK()
+        called++
+      }
+      ecdsa2.sign()
+      called.should.equal(1)
+    })
+
+    it('should generate right K', function () {
+      var msg1 = Buffer.from('52204d20fd0131ae1afd173fd80a3a746d2dcc0cddced8c9dc3d61cc7ab6e966', 'hex')
+      var msg2 = [].reverse.call(Buffer.from(msg1))
+      var pk = Buffer.from('16f243e962c59e71e54189e67e66cf2440a1334514c09c00ddcc21632bac9808', 'hex')
+      var signature1 = ECDSA.sign(msg1, Privkey.fromBuffer(pk)).toBuffer().toString('hex')
+      var signature2 = ECDSA.sign(msg2, Privkey.fromBuffer(pk), 'little').toBuffer().toString('hex')
+      signature1.should.equal(signature2)
+    })
+  })
+
+  describe('#toString', function () {
+    it('should convert this to a string', function () {
+      var str = ecdsa.toString();
+      (typeof str === 'string').should.equal(true)
+    })
+  })
+
+  describe('signing and verification', function () {
+    describe('@sign', function () {
+      it('should produce a signature', function () {
+        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey)
+        ;(sig instanceof Signature).should.equal(true)
+      })
+
+      it('should produce a signaturei', function () {
+        var sig = ECDSA.signWithCalcI(ecdsa.hashbuf, ecdsa.privkey)
+        ;(sig instanceof Signature).should.equal(true)
+        should.exist(sig.i)
+        sig.toCompact().toString('base64').should.equal('IF7ucRrxMczOWYg28NkA+krY4aXx9XgT7KVglwpLEqqyIUtqBrrU5mSDQqOm0ETZ47KdQEMv121aWkxO7P1hbGk=')
+      })
+
+      it('should produce a signature', function () {
+        var sig = ECDSA.signRandomK(ecdsa.hashbuf, ecdsa.privkey)
+        ;(sig instanceof Signature).should.equal(true)
+        var sig2 = ECDSA.signRandomK(ecdsa.hashbuf, ecdsa.privkey)
+        ;(sig2 instanceof Signature).should.equal(true)
+        sig.toString().should.not.equal(sig2.toString())
+      })
+
+      it('should produce a signature, and be different when called twice', function () {
+        ecdsa.signRandomK()
+        should.exist(ecdsa.sig)
+        var ecdsa2 = ECDSA(ecdsa)
+        ecdsa2.signRandomK()
+        ecdsa.sig.toString().should.not.equal(ecdsa2.sig.toString())
+      })
+    })
+
+    describe('#verify', function () {
+      it('should verify a signature that was just signed', function () {
+        ecdsa.sig = Signature.fromString('3046022100e9915e6236695f093a4128ac2a956c' +
+          '40ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827')
+        ecdsa.verify().verified.should.equal(true)
+      })
+      it('should verify this known good signature', function () {
+        ecdsa.signRandomK()
+        ecdsa.verify().verified.should.equal(true)
+      })
+      it('should verify a valid signature, and unverify an invalid signature', function () {
+        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey)
+        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey).should.equal(true)
+        var fakesig = new Signature(sig.r.add(new BN(1)), sig.s)
+        ECDSA.verify(ecdsa.hashbuf, fakesig, ecdsa.pubkey).should.equal(false)
+      })
+      it('should work with big and little endian', function () {
+        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey, 'big')
+        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'big').should.equal(true)
+        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'little').should.equal(false)
+        sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey, 'little')
+        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'big').should.equal(false)
+        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'little').should.equal(true)
+      })
+    })
+
+    describe('vectors', function () {
+      vectors.valid.forEach(function (obj, i) {
+        it('should validate valid vector ' + i, function () {
+          var ecdsa = ECDSA().set({
+            privkey: new Privkey(BN.fromBuffer(Buffer.from(obj.d, 'hex'))),
+            k: BN.fromBuffer(Buffer.from(obj.k, 'hex')),
+            hashbuf: Hash.sha256(Buffer.from(obj.message)),
+            sig: new Signature().set({
+              r: new BN(obj.signature.r),
+              s: new BN(obj.signature.s),
+              i: obj.i
+            })
+          })
+          var ecdsa2 = ECDSA(ecdsa)
+          ecdsa2.k = undefined
+          ecdsa2.sign()
+          ecdsa2.calci()
+          ecdsa2.k.toString().should.equal(ecdsa.k.toString())
+          ecdsa2.sig.toString().should.equal(ecdsa.sig.toString())
+          ecdsa2.sig.i.should.equal(ecdsa.sig.i)
+          ecdsa.verify().verified.should.equal(true)
+        })
+      })
+
+      vectors.invalid.sigError.forEach(function (obj, i) {
+        it('should validate invalid.sigError vector ' + i + ': ' + obj.description, function () {
+          var ecdsa = ECDSA().set({
+            pubkey: Pubkey.fromPoint(point.fromX(true, 1)),
+            sig: new Signature(new BN(obj.signature.r), new BN(obj.signature.s)),
+            hashbuf: Hash.sha256(Buffer.from(obj.message))
+          })
+          ecdsa.sigError().should.equal(obj.exception)
+        })
+      })
+
+      vectors.deterministicK.forEach(function (obj, i) {
+        it('should validate deterministicK vector ' + i, function () {
+          var hashbuf = Hash.sha256(Buffer.from(obj.message))
+          var privkey = Privkey(BN.fromBuffer(Buffer.from(obj.privkey, 'hex')), 'mainnet')
+          var ecdsa = ECDSA({
+            privkey: privkey,
+            hashbuf: hashbuf
+          })
+          ecdsa.deterministicK(0).k.toString('hex').should.equal(obj.k_bad00)
+          ecdsa.deterministicK(1).k.toString('hex').should.equal(obj.k_bad01)
+          ecdsa.deterministicK(15).k.toString('hex').should.equal(obj.k_bad15)
+        })
+      })
+    })
+  })
+})

package/test/crypto/elliptic-fixed.js

@@ -0,0 +1,61 @@
+'use strict'
+
+/* global describe, it */
+
+var assert = require('assert')
+var ec = require('../../lib/crypto/elliptic-fixed')
+
+describe('elliptic-fixed (hardened secp256k1)', function () {
+  var key = ec.keyFromPrivate(
+    '0101010101010101010101010101010101010101010101010101010101010101', 'hex'
+  )
+  var msg = 'deadbeef'.repeat(8) // 32-byte hash, hex
+
+  it('produces low-S canonical signatures', function () {
+    for (var i = 0; i < 20; i++) {
+      var m = (i.toString(16).padStart(2, '0')).repeat(32)
+      var sig = ec.sign(m, key)
+      var halfN = ec.curve.n.ushrn(1)
+      assert.ok(sig.s.cmp(halfN) <= 0, 's must be <= n/2 (low-S)')
+    }
+  })
+
+  it('keeps recoveryParam consistent so the pubkey recovers correctly', function () {
+    // Regression guard: a manual s-flip without flipping recoveryParam (the
+    // pre-fix behaviour) recovers the WRONG public key whenever s was high —
+    // which is ~50% of signatures. Use buffer messages for both sign and
+    // recover so the encoding is identical on each side.
+    var pub = key.getPublic()
+    for (var i = 1; i <= 40; i++) {
+      var m = Buffer.from(i.toString(16).padStart(2, '0').repeat(32), 'hex')
+      var sig = ec.sign(m, key)
+      assert.notStrictEqual(sig.recoveryParam, null)
+      var recovered = ec.recoverPubKey(m, sig, sig.recoveryParam)
+      assert.ok(recovered.eq(pub), 'recovered pubkey must match signer (iter ' + i + ')')
+    }
+  })
+
+  it('still verifies its own canonical signatures', function () {
+    var sig = ec.sign(msg, key)
+    assert.strictEqual(ec.verify(msg, sig, key), true)
+  })
+
+  it('rejects zero r or s', function () {
+    var sig = ec.sign(msg, key)
+    var BN = sig.r.constructor // bn.js
+    assert.strictEqual(ec.verify(msg, { r: new BN(0), s: sig.s }, key), false)
+    assert.strictEqual(ec.verify(msg, { r: sig.r, s: new BN(0) }, key), false)
+  })
+
+  it('rejects out-of-range r or s (>= n)', function () {
+    var sig = ec.sign(msg, key)
+    assert.strictEqual(ec.verify(msg, { r: ec.curve.n, s: sig.s }, key), false)
+    assert.strictEqual(ec.verify(msg, { r: sig.r, s: ec.curve.n }, key), false)
+  })
+
+  it('returns false (never throws) on malformed signatures', function () {
+    assert.strictEqual(ec.verify(msg, null, key), false)
+    assert.strictEqual(ec.verify(msg, {}, key), false)
+    assert.strictEqual(ec.verify(msg, { r: 'x', s: 'y' }, key), false)
+  })
+})

package/test/crypto/hash.browser.js

@@ -0,0 +1,121 @@
+'use strict'
+
+require('chai').should()
+var Hash = require('../../lib/crypto/hash.browser')
+
+describe('Hash', function () {
+  var buf = Buffer.from([0, 1, 2, 3, 253, 254, 255])
+  var str = 'test string'
+
+  describe('@sha1', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.sha1(buf)
+      hash.toString('hex').should.equal('de69b8a4a5604d0486e6420db81e39eb464a17b2')
+      hash = Hash.sha1(Buffer.alloc(0))
+      hash.toString('hex').should.equal('da39a3ee5e6b4b0d3255bfef95601890afd80709')
+    })
+
+    it('throws an error when the input is not a buffer', function () {
+      Hash.sha1.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#sha256', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.sha256(buf)
+      hash.toString('hex').should.equal('6f2c7b22fd1626998287b3636089087961091de80311b9279c4033ec678a83e8')
+    })
+
+    it('fails when the input is not a buffer', function () {
+      Hash.sha256.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#sha256hmac', function () {
+    it('computes this known big key correctly', function () {
+      var key = Buffer.from('b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
+        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
+        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
+        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad')
+      var data = Buffer.from('')
+      Hash.sha256hmac(data, key).toString('hex')
+        .should.equal('fb1f87218671f1c0c4593a88498e02b6dfe8afd814c1729e89a1f1f6600faa23')
+    })
+
+    it('computes this known empty test vector correctly', function () {
+      var key = Buffer.from('')
+      var data = Buffer.from('')
+      Hash.sha256hmac(data, key).toString('hex')
+        .should.equal('b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad')
+    })
+
+    it('computes this known non-empty test vector correctly', function () {
+      var key = Buffer.from('key')
+      var data = Buffer.from('The quick brown fox jumps over the lazy dog')
+      Hash.sha256hmac(data, key).toString('hex')
+        .should.equal('f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8')
+    })
+  })
+
+  describe('#sha256sha256', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.sha256sha256(buf)
+      hash.toString('hex').should.equal('be586c8b20dee549bdd66018c7a79e2b67bb88b7c7d428fa4c970976d2bec5ba')
+    })
+
+    it('fails when the input is not a buffer', function () {
+      Hash.sha256sha256.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#sha256ripemd160', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.sha256ripemd160(buf)
+      hash.toString('hex').should.equal('7322e2bd8535e476c092934e16a6169ca9b707ec')
+    })
+
+    it('fails when the input is not a buffer', function () {
+      Hash.sha256ripemd160.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#ripemd160', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.ripemd160(buf)
+      hash.toString('hex').should.equal('fa0f4565ff776fee0034c713cbf48b5ec06b7f5c')
+    })
+
+    it('fails when the input is not a buffer', function () {
+      Hash.ripemd160.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#sha512', function () {
+    it('calculates the hash of this buffer correctly', function () {
+      var hash = Hash.sha512(buf)
+      hash.toString('hex')
+        .should.equal('c0530aa32048f4904ae162bc14b9eb535eab6c465e960130005fedd' +
+          'b71613e7d62aea75f7d3333ba06e805fc8e45681454524e3f8050969fe5a5f7f2392e31d0')
+    })
+
+    it('fails when the input is not a buffer', function () {
+      Hash.sha512.bind(Hash, str).should.throw('Invalid Argument')
+    })
+  })
+
+  describe('#sha512hmac', function () {
+    it('calculates this known empty test vector correctly', function () {
+      var hex = 'b936cee86c9f87aa5d3c6f2e84cb5a4239a5fe50480a6ec66b70ab5b1f4a' +
+        'c6730c6c515421b327ec1d69402e53dfb49ad7381eb067b338fd7b0cb22247225d47'
+      Hash.sha512hmac(Buffer.from([]), Buffer.from([])).toString('hex').should.equal(hex)
+    })
+
+    it('calculates this known non-empty test vector correctly', function () {
+      var hex = 'c40bd7c15aa493b309c940e08a73ffbd28b2e4cb729eb94480d727e4df577' +
+        'b13cc403a78e6150d83595f3b17c4cc331f12ca5952691de3735a63c1d4c69a2bac'
+      var data = Buffer.from('test1')
+      var key = Buffer.from('test2')
+      Hash.sha512hmac(data, key).toString('hex').should.equal(hex)
+    })
+  })
+})