@bsv/sdk 1.1.29 → 1.1.32

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

@@ -0,0 +1,272 @@
+import Schnorr from '../../../dist/cjs/src/primitives/Schnorr.js'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber.js'
+import Curve from '../../../dist/cjs/src/primitives/Curve.js'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey.js'
+
+describe('Schnorr Zero-Knowledge Proof', () => {
+    let schnorr: Schnorr
+    let curve: Curve
+
+    beforeAll(() => {
+        schnorr = new Schnorr()
+        curve = new Curve()
+    })
+
+    it('should verify a valid proof', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, proof)
+        expect(result).toBe(true)
+    })
+
+    it('should fail verification if proof is tampered (R modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with R
+        const tamperedR = proof.R.add(curve.g)
+        const tamperedProof = { ...proof, R: tamperedR }
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, tamperedProof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if proof is tampered (z modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with z
+        const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n)
+        const tamperedProof = { ...proof, z: tamperedZ }
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, tamperedProof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if proof is tampered (S\' modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with S'
+        const tamperedSPrime = proof.SPrime.add(curve.g)
+        const tamperedProof = { ...proof, SPrime: tamperedSPrime }
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, tamperedProof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if inputs are tampered (A modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with A
+        const tamperedA = A.add(curve.g)
+
+        // Verify proof
+        const result = schnorr.verifyProof(tamperedA, B, S, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if inputs are tampered (B modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with B
+        const tamperedB = B.add(curve.g)
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, tamperedB, S, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if inputs are tampered (S modified)', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Tamper with S
+        const tamperedS = S.add(curve.g)
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, tamperedS, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if using wrong private key', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const wrongA = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof using wrong private key
+        const proof = schnorr.generateProof(wrongA, A, B, S)
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if using wrong public key', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+        const wrongB = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+        const wrongBPublic = wrongB.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Verify proof with wrong B
+        const result = schnorr.verifyProof(A, wrongBPublic, S, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should fail verification if shared secret S is incorrect', () => {
+        // Generate private keys
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Intentionally compute incorrect shared secret
+        const S = B.mul(a).add(curve.g)
+
+        // Generate proof with correct S
+        const proof = schnorr.generateProof(a, A, B, B.mul(a))
+
+        // Verify proof with incorrect S
+        const result = schnorr.verifyProof(A, B, S, proof)
+        expect(result).toBe(false)
+    })
+
+    it('should verify a valid proof with fixed keys', () => {
+        // Use fixed private keys for determinism
+        const a = new PrivateKey(new BigNumber('123456789abcdef123456789abcdef123456789abcdef123456789abcdef', 16))
+        const b = new PrivateKey(new BigNumber('abcdef123456789abcdef123456789abcdef123456789abcdef123456789', 16))
+
+        // Compute public keys
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+
+        // Compute shared secret S = B * a
+        const S = B.mul(a)
+
+        // Generate proof
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        // Verify proof
+        const result = schnorr.verifyProof(A, B, S, proof)
+        expect(result).toBe(true)
+    })
+
+    it('should throw an error if inputs are invalid', () => {
+        const a = PrivateKey.fromRandom()
+        const b = PrivateKey.fromRandom()
+        const A = a.toPublicKey()
+        const B = b.toPublicKey()
+        const S = B.mul(a)
+        const proof = schnorr.generateProof(a, A, B, S)
+
+        expect(() => schnorr.verifyProof(null as any, B, S, proof)).toThrow()
+        expect(() => schnorr.verifyProof(A, null as any, S, proof)).toThrow()
+        expect(() => schnorr.verifyProof(A, B, null as any, proof)).toThrow()
+        expect(() => schnorr.verifyProof(A, B, S, null as any)).toThrow()
+    })
+})

package/src/primitives/index.ts

@@ -11,3 +11,4 @@ export * as Hash from './Hash.js'
 export { default as Random } from './Random.js'
 export { default as TransactionSignature } from './TransactionSignature.js'
 export { default as Polynomial, PointInFiniteField } from './Polynomial.js'
+export { default as Schnorr } from './Schnorr.js'

package/src/totp/totp.ts

@@ -106,7 +106,7 @@ function generateHOTP (
   options: Required<TOTPOptions>
 ): string {
   const timePad = new BigNumber(counter).toArray('be', 8)
-  //console.log({ timePad })
+  // console.log({ timePad })
   const hmac = calcHMAC(secret, timePad, options.algorithm)
   const signature = hmac.digest()