@smartledger/bsv 7.12.0 → 7.13.0

package/test/crypto/random.js

@@ -28,5 +28,78 @@ describe('Random', function () {
         }
       }
     })
+
+    // 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/didweb/relationships.js

@@ -0,0 +1,144 @@
+'use strict'
+
+/* global describe, it */
+
+// DID Core defines the verification relationships to be DISTINCT. `authentication`
+// proves who you are right now; `assertionMethod` makes a claim that outlives the
+// session. Keeping them apart is what stops a low-friction login signature from being
+// redeemed as a signed statement.
+//
+// This module used to cross-list every key into both, and `rotateIssuerKey` rewrote both
+// regardless of which one was being rotated — so replacing a compromised authentication
+// key invalidated every statement the issuer had ever signed.
+
+require('chai').should()
+var didweb = require('../../lib/didweb')
+
+var DOMAIN = 'example.com'
+var DID = 'did:web:example.com'
+var P256 = { kid: 'auth-1', jwk: { kty: 'EC', crv: 'P-256', x: 'a', y: 'b' } }
+var K1 = { kid: 'sign-1', jwk: { kty: 'EC', crv: 'secp256k1', x: 'c', y: 'd' } }
+
+function scoped (key, rels) {
+  return { kid: key.kid, jwk: key.jwk, relationships: rels }
+}
+
+describe('did:web verification relationships', function () {
+  describe('buildDidWebDocuments', function () {
+    // The compatibility guarantee: callers that never heard of `relationships` must get
+    // byte-identical documents, including key order.
+    it('keeps the previous output when no relationships are given', function () {
+      var doc = didweb.buildDidWebDocuments({ domain: DOMAIN, p256: P256, k1: K1 }).didDocument
+      doc.authentication.should.deep.equal([DID + '#auth-1', DID + '#sign-1'])
+      doc.assertionMethod.should.deep.equal([DID + '#auth-1', DID + '#sign-1'])
+      Object.keys(doc).should.deep.equal([
+        '@context', 'id', 'verificationMethod', 'authentication', 'assertionMethod'
+      ])
+    })
+
+    it('scopes each key to the relationships it was given', function () {
+      var doc = didweb.buildDidWebDocuments({
+        domain: DOMAIN,
+        p256: scoped(P256, ['authentication']),
+        k1: scoped(K1, ['assertionMethod'])
+      }).didDocument
+      doc.authentication.should.deep.equal([DID + '#auth-1'])
+      doc.assertionMethod.should.deep.equal([DID + '#sign-1'])
+    })
+
+    it('supports the other three relationships and omits empty ones', function () {
+      var doc = didweb.buildDidWebDocuments({
+        domain: DOMAIN,
+        p256: scoped(P256, ['keyAgreement', 'capabilityInvocation', 'capabilityDelegation'])
+      }).didDocument
+      doc.keyAgreement.should.deep.equal([DID + '#auth-1'])
+      doc.capabilityInvocation.should.deep.equal([DID + '#auth-1'])
+      doc.capabilityDelegation.should.deep.equal([DID + '#auth-1'])
+      ;(doc.authentication === undefined).should.equal(true)
+      ;(doc.assertionMethod === undefined).should.equal(true)
+    })
+
+    it('rejects an unknown relationship rather than silently dropping it', function () {
+      ;(function () {
+        didweb.buildDidWebDocuments({ domain: DOMAIN, p256: scoped(P256, ['notARelationship']) })
+      }).should.throw(/unknown verification relationship/)
+    })
+
+    it('rejects an empty relationship list', function () {
+      ;(function () {
+        didweb.buildDidWebDocuments({ domain: DOMAIN, p256: scoped(P256, []) })
+      }).should.throw(/non-empty array/)
+    })
+  })
+
+  describe('rotateIssuerKey', function () {
+    function currentDoc () {
+      return didweb.buildDidWebDocuments({
+        domain: DOMAIN,
+        p256: scoped(P256, ['authentication']),
+        k1: scoped(K1, ['assertionMethod'])
+      }).didDocument
+    }
+
+    // The reported failure. Rotating a compromised auth key must not touch
+    // assertionMethod, or every seal the issuer ever made stops verifying.
+    it('leaves assertionMethod intact when only authentication is rotated', function () {
+      var before = currentDoc()
+      var after = didweb.rotateIssuerKey({
+        domain: DOMAIN,
+        newKey: { kid: 'auth-2', jwk: { kty: 'EC', crv: 'P-256', x: 'e', y: 'f' }, relationships: ['authentication'] },
+        currentDocument: before
+      }).didDocument
+
+      after.authentication.should.deep.equal([DID + '#auth-2'])
+      after.assertionMethod.should.deep.equal(before.assertionMethod)
+    })
+
+    it('still defines the key that the carried-over relationship points at', function () {
+      var after = didweb.rotateIssuerKey({
+        domain: DOMAIN,
+        newKey: { kid: 'auth-2', jwk: { kty: 'EC' }, relationships: ['authentication'] },
+        currentDocument: currentDoc()
+      }).didDocument
+
+      var defined = after.verificationMethod.map(function (vm) { return vm.id })
+      // Every referenced id resolves — no dangling references.
+      Object.keys(after).forEach(function (k) {
+        if (Array.isArray(after[k]) && k !== 'verificationMethod' && k !== '@context') {
+          after[k].forEach(function (id) { defined.indexOf(id).should.be.above(-1, k + ' references undefined ' + id) })
+        }
+      })
+    })
+
+    it('drops the rotated-out key, which nothing references any more', function () {
+      var after = didweb.rotateIssuerKey({
+        domain: DOMAIN,
+        newKey: { kid: 'auth-2', jwk: { kty: 'EC' }, relationships: ['authentication'] },
+        currentDocument: currentDoc()
+      }).didDocument
+      after.verificationMethod.some(function (vm) {
+        return vm.id === DID + '#auth-1'
+      }).should.equal(false)
+    })
+
+    it('keeps the previous behaviour with no currentDocument', function () {
+      var doc = didweb.rotateIssuerKey({
+        domain: DOMAIN, newKey: { kid: 'k9', jwk: { kty: 'EC' } }
+      }).didDocument
+      doc.authentication.should.deep.equal([DID + '#k9'])
+      doc.assertionMethod.should.deep.equal([DID + '#k9'])
+      doc.verificationMethod.length.should.equal(1)
+      Object.keys(doc).should.deep.equal([
+        '@context', 'id', 'verificationMethod', 'authentication', 'assertionMethod', 'rotationInfo'
+      ])
+    })
+
+    it('still reports rotationInfo', function () {
+      var doc = didweb.rotateIssuerKey({
+        domain: DOMAIN, newKey: { kid: 'k9', jwk: { kty: 'EC' } }, keepOldForDays: 7
+      }).didDocument
+      doc.rotationInfo.gracePeriodDays.should.equal(7)
+      doc.rotationInfo.rotatedAt.should.be.a('string')
+    })
+  })
+})

package/test/transaction/unspentoutput.js

@@ -2,7 +2,12 @@
 
 var chai = require('chai')
 var expect = chai.expect
-var cloneDeep = require('clone-deep')
+/* global structuredClone */
+// structuredClone, not the former clone-deep dependency: the fixture below is plain
+// JSON (strings and numbers), where the two are equivalent. The interpreter's stack
+// clone is NOT — it holds Buffers, which structuredClone would return as Uint8Array.
+// The global comment is for standard@12's eslint, which predates the API.
+var cloneDeep = structuredClone
 
 var bsv = require('../..')
 var UnspentOutput = bsv.Transaction.UnspentOutput

package/version.js

@@ -1,3 +1,3 @@
 'use strict'
 // GENERATED by scripts/sync-version.js on `npm version` — do not edit.
-module.exports = '7.12.0'
+module.exports = '7.13.0'