@bsv/sdk 1.0.0

package/src/primitives/__tests/Curve.unit.test.ts

@@ -0,0 +1,192 @@
+/* eslint-env jest */
+import Curve from '../../../dist/cjs/src/primitives/Curve.js'
+import Point from '../../../dist/cjs/src/primitives/Point'
+import JPoint from '../../../dist/cjs/src/primitives/JacobianPoint'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+
+describe('Curve', () => {
+  it('should work with secp256k1', () => {
+    const curve = new Curve()
+
+    const p = new Point(
+      '79be667e f9dcbbac 55a06295 ce870b07 029bfcdb 2dce28d9 59f2815b 16f81798',
+      '483ada77 26a3c465 5da4fbfc 0e1108a8 fd17b448 a6855419 9c47d08f fb10d4b8'
+    )
+
+    expect(p.validate()).toBe(true)
+    expect(p.dbl().validate()).toBe(true)
+    expect(p.toJ().dbl().toP().validate()).toBe(true)
+    expect(p.mul(new BigNumber('79be667e f9dcbbac 55a06295 ce870b07', 16)).validate()).toBe(true)
+
+    // Endomorphism test
+    expect(curve.endo).toBeDefined()
+    expect(
+      curve.endo.beta.fromRed().toString(16)
+    ).toEqual('7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee')
+    expect(
+      curve.endo.lambda.toString(16)
+    ).toEqual('5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72')
+
+    const k = new BigNumber('1234567890123456789012345678901234', 16)
+    const split = curve._endoSplit(k)
+    const testK = split.k1.add(split.k2.mul(curve.endo.lambda)).umod(curve.n)
+
+    expect(testK.toString(16)).toEqual(k.toString(16))
+  })
+
+  it('should compute this problematic secp256k1 multiplication', () => {
+    const curve = new Curve()
+    const g1 = curve.g // precomputed g
+    expect(g1.precomputed).toBeDefined()
+    const g2 = new Point(g1.getX(), g1.getY()) // not precomputed g
+    expect(g2.precomputed).toBeNull()
+
+    const a = new BigNumber('6d1229a6b24c2e775c062870ad26bc261051e0198c67203167273c7c62538846', 16)
+    const p1 = g1.mul(a)
+    const p2 = g2.mul(a)
+
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  it('should not use fixed NAF when k is too large', () => {
+    const curve = new Curve()
+    const g1 = curve.g // precomputed g
+    expect(g1.precomputed).toBeDefined()
+    const g2 = new Point(g1.getX(), g1.getY()) // not precomputed g
+    expect(g2.precomputed).toBeNull()
+
+    const a = new BigNumber(
+      '6d1229a6b24c2e775c062870ad26bc26' +
+            '1051e0198c67203167273c7c6253884612345678',
+      16)
+    const p1 = g1.mul(a)
+    const p2 = g2.mul(a)
+
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  it('should not fail on secp256k1 regression', () => {
+    const curve = new Curve()
+    const k1 = new BigNumber('32efeba414cd0c830aed727749e816a01c471831536fd2fce28c56b54f5a3bb1', 16)
+    const k2 = new BigNumber('5f2e49b5d64e53f9811545434706cde4de528af97bfd49fde1f6cf792ee37a8c', 16)
+
+    let p1 = curve.g.mul(k1)
+    let p2 = curve.g.mul(k2)
+
+    // 2 + 2 + 1 = 2 + 1 + 2
+    const two = p2.dbl()
+    const five = two.dbl().add(p2)
+    const three = two.add(p2)
+    const maybeFive = three.add(two)
+
+    expect(maybeFive.eq(five)).toBe(true)
+
+    p1 = p1.mul(k2)
+    p2 = p2.mul(k1)
+
+    expect(p1.validate()).toBe(true)
+    expect(p2.validate()).toBe(true)
+    expect(p1.eq(p2)).toBe(true)
+  })
+
+  test('should correctly double the affine point on secp256k1', () => {
+    let bad: any = {
+      x: '026a2073b1ef6fab47ace18e60e728a05180a82755bbcec9a0abc08ad9f7a3d4',
+      y: '9cd8cb48c3281596139f147c1364a3ede88d3f310fdb0eb98c924e599ca1b3c9',
+      z: 'd78587ad45e4102f48b54b5d85598296e069ce6085002e169c6bad78ddc6d9bd'
+    }
+
+    let good: any = {
+      x: 'e7789226739ac2eb3c7ccb2a9a910066beeed86cdb4e0f8a7fee8eeb29dc7016',
+      y: '4b76b191fd6d47d07828ea965e275b76d0e3e0196cd5056d38384fbb819f9fcb',
+      z: 'cbf8d99056618ba132d6145b904eee1ce566e0feedb9595139c45f84e90cfa7d'
+    }
+
+    // const curve = new Curve()
+    bad = new JPoint(bad.x, bad.y, bad.z)
+    good = new JPoint(good.x, good.y, good.z)
+
+    // They are the same points
+    expect(bad.add(good.neg()).isInfinity()).toBe(true)
+
+    // But doubling borks them out
+    expect(bad.dbl().add(good.dbl().neg()).isInfinity()).toBe(true)
+  })
+
+  test('should correctly handle scalar multiplication of zero', () => {
+    const curve = new Curve()
+    const p1 = curve.g.mul('0')
+    const p2 = p1.mul('2')
+    expect(p1.eq(p2)).toBe(true)
+  })
+})
+
+describe('Point codec', () => {
+  const makeShortTest = (definition: any): any => {
+    const curve = new Curve()
+
+    return () => {
+      const co = definition.coordinates
+      const p = new Point(co.x, co.y)
+
+      // Encodes as expected
+      expect(p.encode(false, 'hex')).toBe(definition.encoded)
+      expect(p.encode(true, 'hex')).toBe(definition.compactEncoded)
+
+      // Decodes as expected
+      expect(Point.fromString(definition.encoded).eq(p)).toBe(true)
+      expect(Point.fromString(definition.compactEncoded).eq(p)).toBe(true)
+      expect(Point.fromString(definition.hybrid).eq(p)).toBe(true)
+    }
+  }
+
+  const shortPointEvenY = {
+    coordinates: {
+      x: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+      y: '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
+    },
+    compactEncoded:
+        '02' +
+        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    encoded:
+        '04' +
+        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+        '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+    hybrid:
+        '06' +
+        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+        '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
+  }
+
+  const shortPointOddY = {
+    coordinates: {
+      x: 'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
+      y: 'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
+    },
+    compactEncoded:
+        '03' +
+        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
+    encoded:
+        '04' +
+        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+        'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297',
+    hybrid:
+        '07' +
+        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+        'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
+  }
+
+  it('should throw when trying to decode random bytes', () => {
+    expect(() => {
+      Point.fromString(
+        '05' +
+        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
+    }).toThrow()
+  })
+
+  it('should be able to encode/decode a short curve point with even Y',
+    makeShortTest(shortPointEvenY))
+
+  it('should be able to encode/decode a short curve point with odd Y',
+    makeShortTest(shortPointOddY))
+})

package/src/primitives/__tests/DRBG.test.ts

@@ -0,0 +1,18 @@
+import DRBG from '../../../dist/cjs/src/primitives/DRBG'
+import DRBGVectors from './DRBG.vectors'
+
+describe('Hmac_DRBG', () => {
+  describe('NIST vector', function () {
+    DRBGVectors.forEach(function (opt) {
+      it('should not fail at ' + opt.name, function () {
+        const drbg = new DRBG(opt.entropy, opt.nonce)
+
+        let last
+        for (let i = 0; i < opt.add.length; i++) {
+          last = drbg.generate(opt.expected.length / 2)
+        }
+        expect(last).toEqual(opt.expected)
+      })
+    })
+  })
+})

package/src/primitives/__tests/DRBG.vectors.ts

@@ -0,0 +1,167 @@
+export default [
+  {
+    name: '0',
+    entropy: 'ca851911349384bffe89de1cbdc46e6831e44d34a4fb935ee285dd14b71a7488',
+    nonce: '659ba96c601dc69fc902940805ec0ca8',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'e528e9abf2dece54d47c7e75e5fe302149f817ea9fb4bee6f4199697d04d5b89d54fbb978a15b5c443c9ec21036d2460b6f73ebad0dc2aba6e624abf07745bc107694bb7547bb0995f70de25d6b29e2d3011bb19d27676c07162c8b5ccde0668961df86803482cb37ed6d5c0bb8d50cf1f50d476aa0458bdaba806f48be9dcb8'
+  },
+  {
+    name: '1',
+    entropy: '79737479ba4e7642a221fcfd1b820b134e9e3540a35bb48ffae29c20f5418ea3',
+    nonce: '3593259c092bef4129bc2c6c9e19f343',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655b924159413e2293b17610f211e09f770f172b8fb693a35b85d3b9e5e63b1dc252ac0e115002e9bedfb4b5b6fd43f33b8e0eafb2d072e1a6fee1f159df9b51e6c8da737e60d5032dd30544ec51558c6f080bdbdab1de8a939e961e06b5f1aca37'
+  },
+  {
+    name: '2',
+    entropy: 'b340907445b97a8b589264de4a17c0bea11bb53ad72f9f33297f05d2879d898d',
+    nonce: '65cb27735d83c0708f72684ea58f7ee5',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '75183aaaf3574bc68003352ad655d0e9ce9dd17552723b47fab0e84ef903694a32987eeddbdc48efd24195dbdac8a46ba2d972f5808f23a869e71343140361f58b243e62722088fe10a98e43372d252b144e00c89c215a76a121734bdc485486f65c0b16b8963524a3a70e6f38f169c12f6cbdd169dd48fe4421a235847a23ff'
+  },
+  {
+    name: '3',
+    entropy: '8e159f60060a7d6a7e6fe7c9f769c30b98acb1240b25e7ee33f1da834c0858e7',
+    nonce: 'c39d35052201bdcce4e127a04f04d644',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '62910a77213967ea93d6457e255af51fc79d49629af2fccd81840cdfbb4910991f50a477cbd29edd8a47c4fec9d141f50dfde7c4d8fcab473eff3cc2ee9e7cc90871f180777a97841597b0dd7e779eff9784b9cc33689fd7d48c0dcd341515ac8fecf5c55a6327aea8d58f97220b7462373e84e3b7417a57e80ce946d6120db5'
+  },
+  {
+    name: '4',
+    entropy: '74755f196305f7fb6689b2fe6835dc1d81484fc481a6b8087f649a1952f4df6a',
+    nonce: 'c36387a544a5f2b78007651a7b74b749',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'b2896f3af4375dab67e8062d82c1a005ef4ed119d13a9f18371b1b873774418684805fd659bfd69964f83a5cfe08667ddad672cafd16befffa9faed49865214f703951b443e6dca22edb636f3308380144b9333de4bcb0735710e4d9266786342fc53babe7bdbe3c01a3addb7f23c63ce2834729fabbd419b47beceb4a460236'
+  },
+  {
+    name: '5',
+    entropy: '4b222718f56a3260b3c2625a4cf80950b7d6c1250f170bd5c28b118abdf23b2f',
+    nonce: '7aed52d0016fcaef0b6492bc40bbe0e9',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'a6da029b3665cd39fd50a54c553f99fed3626f4902ffe322dc51f0670dfe8742ed48415cf04bbad5ed3b23b18b7892d170a7dcf3ef8052d5717cb0c1a8b3010d9a9ea5de70ae5356249c0e098946030c46d9d3d209864539444374d8fbcae068e1d6548fa59e6562e6b2d1acbda8da0318c23752ebc9be0c1c1c5b3cf66dd967'
+  },
+  {
+    name: '6',
+    entropy: 'b512633f27fb182a076917e39888ba3ff35d23c3742eb8f3c635a044163768e0',
+    nonce: 'e2c39b84629a3de5c301db5643af1c21',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'fb931d0d0194a97b48d5d4c231fdad5c61aedf1c3a55ac24983ecbf38487b1c93396c6b86ff3920cfa8c77e0146de835ea5809676e702dee6a78100da9aa43d8ec0bf5720befa71f82193205ac2ea403e8d7e0e6270b366dc4200be26afd9f63b7e79286a35c688c57cbff55ac747d4c28bb80a2b2097b3b62ea439950d75dff'
+  },
+  {
+    name: '7',
+    entropy: 'aae3ffc8605a975befefcea0a7a286642bc3b95fb37bd0eb0585a4cabf8b3d1e',
+    nonce: '9504c3c0c4310c1c0746a036c91d9034',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '2819bd3b0d216dad59ddd6c354c4518153a2b04374b07c49e64a8e4d055575dfbc9a8fcde68bd257ff1ba5c6000564b46d6dd7ecd9c5d684fd757df62d85211575d3562d7814008ab5c8bc00e7b5a649eae2318665b55d762de36eba00c2906c0e0ec8706edb493e51ca5eb4b9f015dc932f262f52a86b11c41e9a6d5b3bd431'
+  },
+  {
+    name: '8',
+    entropy: 'b9475210b79b87180e746df704b3cbc7bf8424750e416a7fbb5ce3ef25a82cc6',
+    nonce: '24baf03599c10df6ef44065d715a93f7',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'ae12d784f796183c50db5a1a283aa35ed9a2b685dacea97c596ff8c294906d1b1305ba1f80254eb062b874a8dfffa3378c809ab2869aa51a4e6a489692284a25038908a347342175c38401193b8afc498077e10522bec5c70882b7f760ea5946870bd9fc72961eedbe8bff4fd58c7cc1589bb4f369ed0d3bf26c5bbc62e0b2b2'
+  },
+  {
+    name: '9',
+    entropy: '27838eb44ceccb4e36210703ebf38f659bc39dd3277cd76b7a9bcd6bc964b628',
+    nonce: '39cfe0210db2e7b0eb52a387476e7ea1',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'e5e72a53605d2aaa67832f97536445ab774dd9bff7f13a0d11fd27bf6593bfb52309f2d4f09d147192199ea584503181de87002f4ee085c7dc18bf32ce5315647a3708e6f404d6588c92b2dda599c131aa350d18c747b33dc8eda15cf40e95263d1231e1b4b68f8d829f86054d49cfdb1b8d96ab0465110569c8583a424a099a'
+  },
+  {
+    name: '10',
+    entropy: 'd7129e4f47008ad60c9b5d081ff4ca8eb821a6e4deb91608bf4e2647835373a5',
+    nonce: 'a72882773f78c2fc4878295840a53012',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '0cbf48585c5de9183b7ff76557f8fc9ebcfdfde07e588a8641156f61b7952725bbee954f87e9b937513b16bba0f2e523d095114658e00f0f3772175acfcb3240a01de631c19c5a834c94cc58d04a6837f0d2782fa53d2f9f65178ee9c837222494c799e64c60406069bd319549b889fa00a0032dd7ba5b1cc9edbf58de82bfcd'
+  },
+  {
+    name: '11',
+    entropy: '67fe5e300c513371976c80de4b20d4473889c9f1214bce718bc32d1da3ab7532',
+    nonce: 'e256d88497738a33923aa003a8d7845c',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: 'b44660d64ef7bcebc7a1ab71f8407a02285c7592d755ae6766059e894f694373ed9c776c0cfc8594413eefb400ed427e158d687e28da3ecc205e0f7370fb089676bbb0fa591ec8d916c3d5f18a3eb4a417120705f3e2198154cd60648dbfcfc901242e15711cacd501b2c2826abe870ba32da785ed6f1fdc68f203d1ab43a64f'
+  },
+  {
+    name: '12',
+    entropy: 'de8142541255c46d66efc6173b0fe3ffaf5936c897a3ce2e9d5835616aafa2cb',
+    nonce: 'd01f9002c407127bc3297a561d89b81d',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '64d1020929d74716446d8a4e17205d0756b5264867811aa24d0d0da8644db25d5cde474143c57d12482f6bf0f31d10af9d1da4eb6d701bdd605a8db74fb4e77f79aaa9e450afda50b18d19fae68f03db1d7b5f1738d2fdce9ad3ee9461b58ee242daf7a1d72c45c9213eca34e14810a9fca5208d5c56d8066bab1586f1513de7'
+  },
+  {
+    name: '13',
+    entropy: '4a8e0bd90bdb12f7748ad5f147b115d7385bb1b06aee7d8b76136a25d779bcb7',
+    nonce: '7f3cce4af8c8ce3c45bdf23c6b181a00',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '320c7ca4bbeb7af977bc054f604b5086a3f237aa5501658112f3e7a33d2231f5536d2c85c1dad9d9b0bf7f619c81be4854661626839c8c10ae7fdc0c0b571be34b58d66da553676167b00e7d8e49f416aacb2926c6eb2c66ec98bffae20864cf92496db15e3b09e530b7b9648be8d3916b3c20a3a779bec7d66da63396849aaf'
+  },
+  {
+    name: '14',
+    entropy: '451ed024bc4b95f1025b14ec3616f5e42e80824541dc795a2f07500f92adc665',
+    nonce: '2f28e6ee8de5879db1eccd58c994e5f0',
+    pers: null,
+    add: [
+      null,
+      null
+    ],
+    expected: '3fb637085ab75f4e95655faae95885166a5fbb423bb03dbf0543be063bcd48799c4f05d4e522634d9275fe02e1edd920e26d9accd43709cb0d8f6e50aa54a5f3bdd618be23cf73ef736ed0ef7524b0d14d5bef8c8aec1cf1ed3e1c38a808b35e61a44078127c7cb3a8fd7addfa50fcf3ff3bc6d6bc355d5436fe9b71eb44f7fd'
+  }
+]

package/src/primitives/__tests/ECDH.test.ts

@@ -0,0 +1,31 @@
+/* eslint-env jest */
+import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+
+describe('ECDH', function () {
+  it('should work with secp256k1', function () {
+    const s1 = PrivateKey.fromRandom()
+    const s2 = PrivateKey.fromRandom()
+    let sh1 = s1.deriveSharedSecret(s2.toPublicKey())
+    let sh2 = s2.deriveSharedSecret(s1.toPublicKey())
+    expect(sh1.toString()).toEqual(sh2.toString())
+    sh1 = s1.deriveSharedSecret(PublicKey.fromString(s2.toPublicKey().toDER()))
+    sh2 = s2.deriveSharedSecret(PublicKey.fromString(s1.toPublicKey().toDER()))
+    expect(sh1.toString()).toEqual(sh2.toString())
+    sh1 = s1.deriveSharedSecret(PublicKey.fromPrivateKey(s2))
+    sh2 = s2.deriveSharedSecret(PublicKey.fromPrivateKey(s1))
+    expect(sh1.toString()).toEqual(sh2.toString())
+  })
+  it('should be able to prevent a twist attack for secp256k1', () => {
+    const bob = PrivateKey.fromRandom()
+    // This is a bad point that shouldn't be able to be passed to derive.
+    // If a bad point can be passed it's possible to perform a twist attack.
+    const mallory = new PublicKey(new BigNumber(14), new BigNumber(16))
+    expect(() => {
+      bob.deriveSharedSecret(mallory)
+    }).toThrow(new Error(
+      'Public key not valid for ECDH secret derivation'
+    ))
+  })
+})

package/src/primitives/__tests/ECDSA.test.ts

@@ -0,0 +1,58 @@
+import * as ECDSA from '../../../dist/cjs/src/primitives/ECDSA'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import Curve from '../../../dist/cjs/src/primitives/Curve'
+import Signature from '../../../dist/cjs/src/primitives/Signature'
+
+const msg = new BigNumber('deadbeef', 16)
+const key = new BigNumber('1e5edd45de6d22deebef4596b80444ffcc29143839c1dce18db470e25b4be7b5', 16)
+const curve = new Curve()
+const pub = curve.g.mul(key)
+const wrongPub = curve.g.mul(new BigNumber(33))
+
+describe('ECDSA', () => {
+  it('should sign and verify', () => {
+    const signature = ECDSA.sign(msg, key)
+    expect(ECDSA.verify(msg, signature, pub)).toBeTruthy()
+  })
+
+  it('should encode and decode with DER', () => {
+    const signature = ECDSA.sign(msg, key)
+    const encoded = signature.toDER()
+    expect(encoded.length).toBe(71)
+    const decoded = Signature.fromDER(encoded)
+    expect(decoded.r.toString(16)).toEqual(signature.r.toString(16))
+    expect(decoded.s.toString(16)).toEqual(signature.s.toString(16))
+  })
+
+  it('should encode and decode with hex DER', () => {
+    const signature = ECDSA.sign(msg, key)
+    const encoded = signature.toDER('hex')
+    expect(encoded.length).toBe(142)
+    const decoded = Signature.fromDER(encoded, 'hex')
+    expect(decoded.r.toString(16)).toEqual(signature.r.toString(16))
+    expect(decoded.s.toString(16)).toEqual(signature.s.toString(16))
+  })
+
+  it('should have `signature.s <= keys.ec.nh`', () => {
+    // key.sign(msg, options)
+    const sign = ECDSA.sign(msg, key, true)
+    expect(sign.s.cmp(curve.n.ushrn(1)) <= 0).toBeTruthy()
+  })
+
+  it('should support `options.k`', () => {
+    const sign = ECDSA.sign(msg, key, undefined, new BigNumber(1358))
+    expect(ECDSA.verify(msg, sign, pub)).toBeTruthy()
+  })
+
+  it('should not verify an incorrectly signed message', () => {
+    const wrongMessage = new BigNumber('BA5AABBE1AA9B6EC1E2ADB2DF99699344345678901234567890ABCDEFABCDEF02', 16)
+    const signature = ECDSA.sign(msg, key)
+    const result = ECDSA.verify(wrongMessage, signature, pub)
+    expect(result).toBe(false)
+  })
+
+  it('should not verify signature with wrong public key', () => {
+    const signature = ECDSA.sign(msg, key)
+    expect(ECDSA.verify(msg, signature, wrongPub)).toBeFalsy()
+  })
+})

package/src/primitives/__tests/HMAC.test.ts

@@ -0,0 +1,59 @@
+/* eslint-env jest */
+import { SHA256HMAC } from '../../../dist/cjs/src/primitives/Hash'
+
+describe('HMAC', function () {
+  describe('mixed test vector', function () {
+    test({
+      name: 'nist 1',
+      key: '00010203 04050607 08090A0B 0C0D0E0F' +
+           '10111213 14151617 18191A1B 1C1D1E1F 20212223 24252627' +
+           '28292A2B 2C2D2E2F 30313233 34353637 38393A3B 3C3D3E3F',
+      msg: 'Sample message for keylen=blocklen',
+      res: '8bb9a1db9806f20df7f77b82138c7914d174d59e13dc4d0169c9057b133e1d62'
+    })
+    test({
+      name: 'nist 2',
+      key: '00010203 04050607' +
+           '08090A0B 0C0D0E0F 10111213 14151617 18191A1B 1C1D1E1F',
+      msg: 'Sample message for keylen<blocklen',
+      res: 'a28cf43130ee696a98f14a37678b56bcfcbdd9e5cf69717fecf5480f0ebdf790'
+    })
+    test({
+      name: 'nist 3',
+      key: '00010203' +
+           '04050607 08090A0B 0C0D0E0F 10111213 14151617 18191A1B' +
+           '1C1D1E1F 20212223 24252627 28292A2B 2C2D2E2F 30313233' +
+           '34353637 38393A3B 3C3D3E3F 40414243 44454647 48494A4B' +
+           '4C4D4E4F 50515253 54555657 58595A5B 5C5D5E5F 60616263',
+      msg: 'Sample message for keylen=blocklen',
+      res: 'bdccb6c72ddeadb500ae768386cb38cc41c63dbb0878ddb9c7a38a431b78378d'
+    })
+    test({
+      name: 'nist 4',
+      key: '00' +
+           '01020304 05060708 090A0B0C 0D0E0F10 11121314 15161718' +
+           '191A1B1C 1D1E1F20 21222324 25262728 292A2B2C 2D2E2F30',
+      msg: 'Sample message for keylen<blocklen, with truncated tag',
+      res: '27a8b157839efeac98df070b331d593618ddb985d403c0c786d23b5d132e57c7'
+    })
+    test({
+      name: 'regression 1',
+      key: '48f38d0c6a344959cc94502b7b5e8dffb6a5f41795d9066fc9a649557167ee2f',
+      msg: '1d495eef7761b65dccd0a983d2d7204fea28b5c81f1758046e062eb043755ea1',
+      msgEnc: 'hex',
+      res: 'cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655'
+    })
+
+    function test (opt): void {
+      it(`should not fail at ${opt.name as string}`, function (): void {
+        let h = new SHA256HMAC(opt.key)
+        expect(h.update(opt.msg, opt.msgEnc).digest('hex')).toEqual(opt.res)
+        h = h = new SHA256HMAC(opt.key)
+        expect(h
+          .update(opt.msg.slice(0, 10), opt.msgEnc)
+          .update(opt.msg.slice(10), opt.msgEnc)
+          .digest('hex')).toEqual(opt.res)
+      })
+    }
+  })
+})

package/src/primitives/__tests/Hash.test.ts

@@ -0,0 +1,121 @@
+/* eslint-env jest */
+import * as hash from '../../../dist/cjs/src/primitives/Hash'
+import * as crypto from 'crypto'
+import PBKDF2Vectors from './PBKDF2.vectors'
+import { toArray, toHex } from '../../../dist/cjs/src/primitives/utils'
+
+describe('Hash', function () {
+  function test(Hash, cases): void {
+    for (let i = 0; i < cases.length; i++) {
+      const msg = cases[i][0]
+      const res = cases[i][1]
+      const enc = cases[i][2]
+
+      let dgst = new Hash().update(msg, enc).digest('hex')
+      expect(dgst).toEqual(res)
+
+      // Split message
+      dgst = new Hash().update(msg.slice(0, 2), enc)
+        .update(msg.slice(2), enc)
+        .digest('hex')
+      expect(dgst).toEqual(res)
+    }
+  }
+
+  it('should support sha256', function () {
+    test(hash.SHA256, [
+      ['abc',
+        'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'],
+      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1'],
+      ['deadbeef',
+        '5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953',
+        'hex']
+    ])
+  })
+
+  it('should support ripemd160', function () {
+    test(hash.RIPEMD160, [
+      ['', '9c1185a5c5e9fc54612808977ee8f548b2258d31'],
+      ['abc',
+        '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'],
+      ['message digest',
+        '5d0689ef49d2fae572b881b123a85ffa21595f36'],
+      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '12a053384a9c0c88e405a06c27dcf49ada62eb2b'],
+      ['ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+        'b0e20b6e3116640286ed3a87a5713079b21f5189']
+    ])
+  })
+
+  it('should support sha1', function () {
+    test(hash.SHA1, [
+      ['',
+        'da39a3ee5e6b4b0d3255bfef95601890afd80709'],
+      ['abc',
+        'a9993e364706816aba3e25717850c26c9cd0d89d'],
+      ['abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '84983e441c3bd26ebaae4aa1f95129e5e54670f1'],
+      ['deadbeef',
+        'd78f8bb992a56a597f6c7a1fb918bb78271367eb',
+        'hex']
+    ])
+  })
+
+  it('should support sha512', function () {
+    test(hash.SHA512, [
+      ['abc',
+        'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a' +
+        '2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f'
+      ],
+      [
+        'abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn' +
+        'hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',
+        '8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018' +
+        '501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909'
+      ]
+    ])
+  })
+
+  it('handles utf8 in strings just like crypto', function () {
+    test(hash.SHA256, [
+      'hello', // one byte per character
+      'привет', // two bytes per character
+      '您好', // three bytes per character
+      '👋', // four bytes per character
+      'hello привет 您好 👋!!!' // mixed character lengths
+    ].map(str => [str, crypto
+      .createHash('sha256')
+      .update(str)
+      .digest('hex')]))
+  })
+
+  describe('PBKDF2 vectors', () => {
+    for (let i = 0; i < PBKDF2Vectors.length; i++) {
+      let v = PBKDF2Vectors[i]
+      let key, salt
+      if (v.keyUint8Array) {
+        key = v.keyUint8Array
+      }
+      if (v.key) {
+        key = toArray(v.key, 'utf8')
+      }
+      if (v.keyHex) {
+        key = toArray(v.keyHex, 'hex')
+      }
+      if (v.saltUint8Array) {
+        salt = v.saltUint8Array
+      }
+      if (v.salt) {
+        salt = toArray(v.salt, 'utf8')
+      }
+      if (v.saltHex) {
+        salt = toArray(v.saltHex, 'hex')
+      }
+      it(`Passes PBKDF2 vector ${i}`, () => {
+        const output = hash.pbkdf2(key, salt, v.iterations, v.dkLen)
+        expect(toHex(output)).toEqual(v.results.sha512)
+      })
+    }
+  })
+})