@smartledger/bsv 8.3.1 → 9.1.0

package/test/crypto/hash.js

@@ -1,122 +0,0 @@
-'use strict'
-
-require('chai').should()
-var bsv = require('../..')
-var Hash = bsv.crypto.Hash
-
-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)
-    })
-  })
-})

package/test/crypto/point.js

@@ -1,193 +0,0 @@
-'use strict'
-
-var should = require('chai').should()
-var bsv = require('../..')
-var Point = bsv.crypto.Point
-var BN = bsv.crypto.BN
-
-describe('Point', function () {
-  var valid = {
-    x: 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2',
-    y: '4836ab292c105a711ed10fcfd30999c31ff7c02456147747e03e739ad527c380'
-  }
-
-  it('should create a point', function () {
-    var p = Point(valid.x, valid.y)
-    should.exist(p)
-  })
-
-  it('should create a point when called with "new"', function () {
-    var p = new Point(valid.x, valid.y)
-    should.exist(p)
-  })
-
-  describe('#getX', function () {
-    it('should return x', function () {
-      var p = Point(valid.x, valid.y)
-      var x = p.getX()
-      x.toString('hex', 64).should.equal(valid.x)
-    })
-
-    it('should be convertable to a buffer', function () {
-      var p = Point(valid.x, valid.y)
-      var a = p.getX().toBuffer({ size: 32 })
-      a.length.should.equal(32)
-      a.should.deep.equal(Buffer.from(valid.x, 'hex'))
-    })
-  })
-
-  describe('#getY', function () {
-    it('should return y', function () {
-      var p = Point(valid.x, valid.y)
-      p.getY().toString('hex', 64).should.equal(valid.y)
-    })
-
-    it('should be convertable to a buffer', function () {
-      var p = Point(valid.x, valid.y)
-      var a = p.getY().toBuffer({ size: 32 })
-      a.length.should.equal(32)
-      a.should.deep.equal(Buffer.from(valid.y, 'hex'))
-    })
-  })
-
-  describe('#add', function () {
-    it('should accurately add g to itself', function () {
-      var p1 = Point.getG()
-      var p2 = Point.getG()
-      var p3 = p1.add(p2)
-      p3.getX().toString().should.equal('89565891926547004231252920425935692360644145829622209' +
-                                        '833684329913297188986597')
-      p3.getY().toString().should.equal('12158399299693830322967808612713398636155367887041628' +
-                                        '176798871954788371653930')
-    })
-  })
-
-  describe('#mul', function () {
-    it('should accurately multiply g by 2', function () {
-      var g = Point.getG()
-      var b = g.mul(new BN(2))
-      b.getX().toString().should.equal('8956589192654700423125292042593569236064414582962220983' +
-                                       '3684329913297188986597')
-      b.getY().toString().should.equal('1215839929969383032296780861271339863615536788704162817' +
-                                       '6798871954788371653930')
-    })
-
-    it('should accurately multiply g by n-1', function () {
-      var g = Point.getG()
-      var n = Point.getN()
-      var b = g.mul(n.sub(new BN(1)))
-      b.getX().toString().should.equal('55066263022277343669578718895168534326250603453777594175' +
-                                       '500187360389116729240')
-      b.getY().toString().should.equal('83121579216557378445487899878180864668798711284981320763' +
-                                       '518679672151497189239')
-    })
-
-    // not sure if this is technically accurate or not...
-    // normally, you should always multiply g by something less than n
-    // but it is the same result in OpenSSL
-    it('should accurately multiply g by n+1', function () {
-      var g = Point.getG()
-      var n = Point.getN()
-      var b = g.mul(n.add(new BN(1)))
-      b.getX().toString().should.equal('550662630222773436695787188951685343262506034537775941755' +
-                                       '00187360389116729240')
-      b.getY().toString().should.equal('326705100207588169780830851305070431844712733806592432759' +
-                                       '38904335757337482424')
-    })
-  })
-
-  describe('@fromX', function () {
-    it('should return g', function () {
-      var g = Point.getG()
-      var p = Point.fromX(false, g.getX())
-      g.eq(p).should.equal(true)
-    })
-  })
-
-  describe('@pointToCompressed', function () {
-    it('should return g', function () {
-      let g = Point.getG()
-      let pbuf = Point.pointToCompressed(g)
-      pbuf.length.should.equal(33)
-      pbuf.toString('hex').should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
-    })
-  })
-
-  describe('#toBuffer', function () {
-    it('should return g', function () {
-      let g = Point.getG()
-      let pbuf = g.toBuffer()
-      pbuf.length.should.equal(33)
-      pbuf.toString('hex').should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
-    })
-  })
-
-  describe('@fromBuffer', function () {
-    it('should return g', function () {
-      let buf = Buffer.from('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', 'hex')
-      let p = Point.fromBuffer(buf)
-      p.toBuffer().toString('hex').should.equal(buf.toString('hex'))
-    })
-  })
-
-  describe('#toHex', function () {
-    it('should return g', function () {
-      let g = Point.getG()
-      let phex = g.toHex()
-      phex.length.should.equal(33 * 2)
-      phex.should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
-    })
-  })
-
-  describe('@fromHex', function () {
-    it('should return g', function () {
-      let hex = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
-      let p = Point.fromHex(hex)
-      p.toHex().should.equal(hex)
-    })
-  })
-
-  describe('#validate', function () {
-    it('should describe this point as valid', function () {
-      var p = Point(valid.x, valid.y)
-      should.exist(p.validate())
-    })
-
-    it('should describe this point as invalid because of zero y', function () {
-      var x = 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2'
-      var y = '0000000000000000000000000000000000000000000000000000000000000000';
-      (function () {
-        Point(x, y)
-      }).should.throw('Invalid y value for curve.')
-    })
-
-    it('should describe this point as invalid because of invalid y', function () {
-      var x = 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2'
-      var y = '00000000000000000000000000000000000000000000000000000000000000FF';
-      (function () {
-        Point(x, y)
-      }).should.throw('Invalid y value for curve.')
-    })
-
-    it('should describe this point as invalid because out of curve bounds', function () {
-      // point larger than max
-      var x = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDCE6AF48A03BBFD25E8CD0364141'
-      // calculated y of x
-      var y = 'ed3970f129bc2ca7c7c6cf92fa7da4de6a1dfc9c14da4bf056aa868d3dd74034';
-
-      (function () {
-        // set the point
-        Point(x, y)
-      }).should.throw('Point does not lie on the curve')
-    })
-
-    it('should describe this point as invalid because out of curve bounds', function () {
-      var x = '0000000000000000000000000000000000000000000000000000000000000000';
-
-      (function () {
-        // set the point
-        Point.fromX(false, x)
-      }).should.throw('Invalid X')
-    })
-  })
-})

package/test/crypto/random.js

@@ -1,105 +0,0 @@
-'use strict'
-
-var bsv = require('../..')
-var Random = bsv.crypto.Random
-
-describe('Random', function () {
-  describe('@getRandomBuffer', function () {
-    it('should return a buffer', function () {
-      var bytes = Random.getRandomBuffer(8)
-      bytes.length.should.equal(8)
-      Buffer.isBuffer(bytes).should.equal(true)
-    })
-
-    it('should not equate two 256 bit random buffers', function () {
-      var bytes1 = Random.getRandomBuffer(32)
-      var bytes2 = Random.getRandomBuffer(32)
-      bytes1.toString('hex').should.not.equal(bytes2.toString('hex'))
-    })
-
-    it('should generate 100 8 byte buffers in a row that are not equal', function () {
-      var hexs = []
-      for (var i = 0; i < 100; i++) {
-        hexs[i] = Random.getRandomBuffer(8).toString('hex')
-      }
-      for (i = 0; i < 100; i++) {
-        for (var j = i + 1; j < 100; j++) {
-          hexs[i].should.not.equal(hexs[j])
-        }
-      }
-    })
-
-    // WebCrypto refuses more than 65,536 bytes per call. Before chunking, a request
-    // above that limit threw; a naive implementation that ignored the return size
-    // instead would hand back a zero-filled tail, which is far worse than throwing.
-    it('fills requests larger than the 65536-byte getRandomValues limit', function () {
-      var buf = Random.getRandomBuffer(70000)
-      buf.length.should.equal(70000)
-      // The tail comes from a second call — assert it is real entropy, not zero padding.
-      var tail = buf.subarray(65536)
-      tail.some(function (b) { return b !== 0 }).should.equal(true)
-      buf.subarray(0, 32).toString('hex').should.not.equal(tail.subarray(0, 32).toString('hex'))
-    })
-
-    it('handles the exact limit and one past it', function () {
-      Random.getRandomBuffer(65536).length.should.equal(65536)
-      Random.getRandomBuffer(65537).length.should.equal(65537)
-    })
-
-    // The backend is chosen by feature detection. This used to branch on
-    // `process.browser`, which is undefined in React Native, Deno, Workers and Bun —
-    // all of which then fell through to require('crypto').randomBytes. Where a partial
-    // crypto shim supplies a weak randomBytes, that produced guessable keys silently.
-    it('does not depend on process.browser', function () {
-      var saved = process.browser
-      try {
-        process.browser = undefined
-        Random.getRandomBuffer(16).length.should.equal(16)
-        process.browser = true
-        Random.getRandomBuffer(16).length.should.equal(16)
-      } finally {
-        process.browser = saved
-      }
-    })
-
-    it('prefers globalThis.crypto.getRandomValues when present', function () {
-      var calls = 0
-      var real = Object.getOwnPropertyDescriptor(globalThis, 'crypto')
-      try {
-        Object.defineProperty(globalThis, 'crypto', {
-          configurable: true,
-          value: {
-            getRandomValues: function (arr) {
-              calls++
-              for (var i = 0; i < arr.length; i++) arr[i] = (i * 7 + 3) & 0xff
-              return arr
-            }
-          }
-        })
-        var buf = Random.getRandomBuffer(4)
-        calls.should.equal(1)
-        buf.toString('hex').should.equal('030a1118')
-      } finally {
-        if (real) Object.defineProperty(globalThis, 'crypto', real)
-      }
-    })
-
-    // The throw matters as much as the detection: a key library must never return bytes
-    // it cannot vouch for. Verified in a child process because it has to remove both
-    // backends, which cannot be undone safely in-process.
-    it('throws rather than returning bytes when no CSPRNG exists', function () {
-      var out = require('child_process').spawnSync(process.execPath, ['-e', [
-        'var Module = require("module"), orig = Module._load',
-        'delete globalThis.crypto',
-        'Module._load = function (r) {',
-        '  if (r === "crypto") { var e = new Error("no crypto"); e.code = "MODULE_NOT_FOUND"; throw e }',
-        '  return orig.apply(this, arguments)',
-        '}',
-        'var R = require(' + JSON.stringify(require.resolve('../../lib/crypto/random.js')) + ')',
-        'try { R.getRandomBuffer(32); console.log("RETURNED") }',
-        'catch (e) { console.log("THREW") }'
-      ].join('\n')], { encoding: 'utf8' })
-      out.stdout.trim().should.equal('THREW')
-    })
-  })
-})

package/test/crypto/security.js

@@ -1,176 +0,0 @@
-'use strict'
-
-/* global describe, it, before */
-
-require('chai').should()
-var expect = require('chai').expect
-
-var bsv = require('../../index.js')
-var BN = bsv.crypto.BN
-var ECDSA = bsv.crypto.ECDSA
-var Hash = bsv.crypto.Hash
-var Point = bsv.crypto.Point
-var Signature = bsv.crypto.Signature
-var SmartVerify = bsv.SmartVerify
-
-describe('SmartLedger Security Patches', function () {
-  var privateKey, publicKey, message, hash
-
-  before(function () {
-    privateKey = new bsv.PrivateKey()
-    publicKey = privateKey.toPublicKey()
-    message = 'SmartLedger security test message'
-    hash = Hash.sha256(Buffer.from(message))
-  })
-
-  describe('Zero Parameter Attack Protection', function () {
-    it('Signature.validate() throws when r = 0', function () {
-      var sig = new Signature({ r: new BN(0), s: new BN(1) })
-      expect(function () { sig.validate() }).to.throw(/r component is zero/)
-    })
-
-    it('Signature.validate() throws when s = 0', function () {
-      var sig = new Signature({ r: new BN(1), s: new BN(0) })
-      expect(function () { sig.validate() }).to.throw(/s component is zero/)
-    })
-
-    it('smartVerify rejects (without throwing) a zero-s signature', function () {
-      var sig = new Signature({ r: new BN(1), s: new BN(0) })
-      SmartVerify.smartVerify(hash, sig, publicKey).should.equal(false)
-    })
-  })
-
-  describe('Canonical Signature Enforcement', function () {
-    it('freshly produced signatures are canonical (low-S)', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      sig.isCanonical().should.equal(true)
-      SmartVerify.isCanonical(sig).should.equal(true)
-    })
-
-    it('detects a non-canonical (high-S) signature', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var n = Point.getN()
-      var lowS = sig.s.lte(n.shrn(1)) ? sig.s : n.sub(sig.s)
-      var highS = new Signature({ r: sig.r, s: n.sub(lowS) })
-
-      highS.isCanonical().should.equal(false)
-      SmartVerify.isCanonical(highS).should.equal(false)
-    })
-
-    it('toCanonical() converts a high-S signature to canonical form', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var n = Point.getN()
-      var lowS = sig.s.lte(n.shrn(1)) ? sig.s : n.sub(sig.s)
-      var highS = new Signature({ r: sig.r, s: n.sub(lowS) })
-
-      var canonical = highS.toCanonical()
-      canonical.isCanonical().should.equal(true)
-      // Both forms verify (ECDSA is malleable in s); canonicalization does not
-      // change which key/message the signature is valid for.
-      canonical.r.cmp(highS.r).should.equal(0)
-    })
-
-    it('toCanonical() returns a new signature and leaves the original alone', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var n = Point.getN()
-      var lowS = sig.s.lte(n.shrn(1)) ? sig.s : n.sub(sig.s)
-      var highS = new Signature({ r: sig.r, s: n.sub(lowS) })
-      var before = highS.s.toString()
-
-      var canonical = highS.toCanonical()
-      canonical.should.not.equal(highS)
-      highS.s.toString().should.equal(before)
-    })
-  })
-
-  describe('applySecurityPatches', function () {
-    var highSig = function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var n = Point.getN()
-      var lowS = sig.s.lte(n.shrn(1)) ? sig.s : n.sub(sig.s)
-      return new Signature({ r: sig.r, s: n.sub(lowS) })
-    }
-
-    it('accepts a canonical signature and returns it for chaining', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      sig.applySecurityPatches().should.equal(sig)
-    })
-
-    it('rejects a non-canonical (high-S) signature rather than rewriting it', function () {
-      // Rewriting s to n-s cannot protect against malleability: the rewritten
-      // signature verifies exactly as the original, so silently normalizing only
-      // hides from the caller that the signature was malleated.
-      var highS = highSig()
-      var before = highS.s.toString()
-
-      expect(function () { highS.applySecurityPatches() }).to.throw(/non-canonical/)
-      highS.s.toString().should.equal(before)
-    })
-
-    it('rejects zero and out-of-range components', function () {
-      expect(function () {
-        new Signature({ r: new BN(0), s: new BN(1) }).applySecurityPatches()
-      }).to.throw(/zero r or s/)
-      expect(function () {
-        new Signature({ r: new BN(1), s: Point.getN() }).applySecurityPatches()
-      }).to.throw(/out of range/)
-    })
-  })
-
-  describe('SmartVerify Enhanced Validation', function () {
-    it('accepts a valid signature', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      SmartVerify.smartVerify(hash, sig, publicKey).should.equal(true)
-    })
-
-    it('rejects a malleated (high-S) signature', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var n = Point.getN()
-      var lowS = sig.s.lte(n.shrn(1)) ? sig.s : n.sub(sig.s)
-      var highS = new Signature({ r: sig.r, s: n.sub(lowS) })
-      SmartVerify.isCanonical(highS).should.equal(false)
-      SmartVerify.smartVerify(hash, highS, publicKey).should.equal(false)
-      // ...while the canonical form of the same signature still verifies.
-      SmartVerify.smartVerify(hash, new Signature({ r: sig.r, s: lowS }), publicKey).should.equal(true)
-    })
-
-    it('throws on an invalid (non-32-byte) message hash', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var shortHash = Buffer.alloc(16)
-      expect(function () {
-        SmartVerify.smartVerify(shortHash, sig, publicKey)
-      }).to.throw(/32-byte/)
-    })
-
-    it('rejects a signature from the wrong key', function () {
-      var sig = ECDSA.sign(hash, privateKey)
-      var otherPub = new bsv.PrivateKey().toPublicKey()
-      SmartVerify.smartVerify(hash, sig, otherPub).should.equal(false)
-    })
-  })
-
-  describe('Integration with Original BSV', function () {
-    it('round-trips a Bitcoin message signature', function () {
-      var sig = new bsv.Message(message).sign(privateKey)
-      var verified = new bsv.Message(message).verify(publicKey.toAddress().toString(), sig)
-      verified.should.equal(true)
-    })
-
-    it('signs a transaction to completion', function () {
-      var utxo = {
-        txId: 'a'.repeat(64),
-        outputIndex: 0,
-        address: privateKey.toAddress().toString(),
-        script: bsv.Script.buildPublicKeyHashOut(privateKey.toAddress()).toHex(),
-        satoshis: 100000
-      }
-
-      var transaction = new bsv.Transaction()
-        .from(utxo)
-        .to(privateKey.toAddress(), 50000)
-        .sign(privateKey)
-
-      transaction.isFullySigned().should.equal(true)
-    })
-  })
-})