walletpair-sdk 1.0.3 → 1.0.5

package/src/__tests__/adversarial/malicious-wallet.test.ts

@@ -9,18 +9,14 @@
  * correctly, protecting the dApp from a compromised or malicious wallet.
  */
 
-import { describe, it, expect, vi } from 'vitest';
-import { DAppSession } from '../../dapp-session.js';
-import { MockTransport, makeJoinBody } from '../../test-helpers.js';
-import {
-  generateX25519KeyPair,
-  sealPayload,
-  b64urlEncode,
-} from '../../crypto.js';
-import type { ProtocolMessage } from '../../types.js';
+import { describe, expect, it, vi } from 'vitest'
+import { generateX25519KeyPair, sealPayload } from '../../crypto.js'
+import { DAppSession } from '../../dapp-session.js'
+import { MockTransport, makeJoinBody } from '../../test-helpers.js'
+import type { ProtocolMessage } from '../../types.js'
 
 function wait(ms = 50): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
+  return new Promise((r) => setTimeout(r, ms))
 }
 
 // ---------------------------------------------------------------------------
@@ -28,34 +24,45 @@ function wait(ms = 50): Promise<void> {
 // ---------------------------------------------------------------------------
 
 function setupDAppManual() {
-  const transport = new MockTransport();
+  const transport = new MockTransport()
   const session = new DAppSession({
     transport,
-    meta: { name: 'Test', description: 'Test dApp', url: 'https://test.com', icon: 'https://test.com/icon.png' },
-  });
-  const walletKp = generateX25519KeyPair();
-  return { transport, session, walletKp };
+    meta: {
+      name: 'Test',
+      description: 'Test dApp',
+      url: 'https://test.com',
+      icon: 'https://test.com/icon.png',
+    },
+  })
+  const walletKp = generateX25519KeyPair()
+  return { transport, session, walletKp }
 }
 
 async function connectDAppManual(ctx: ReturnType<typeof setupDAppManual>) {
-  const { transport, session, walletKp } = ctx;
-  await session.createPairing();
+  const { transport, session, walletKp } = ctx
+  await session.createPairing()
 
   transport.receive({
-    v: 1, t: 'join', ch: session.channelId,
-    ts: Date.now(), from: walletKp.publicKeyB64,
-    body: makeJoinBody(session.channelId, transport.sent[0]!.from!, walletKp),
-  } as ProtocolMessage);
+    v: 1,
+    t: 'join',
+    ch: session.channelId,
+    ts: Date.now(),
+    from: walletKp.publicKeyB64,
+    body: makeJoinBody(session.channelId, transport.sent[0]?.from ?? '', walletKp),
+  } as ProtocolMessage)
 
   transport.receive({
-    v: 1, t: 'ready', ch: session.channelId,
-    ts: Date.now(), from: '_adapter',
+    v: 1,
+    t: 'ready',
+    ch: session.channelId,
+    ts: Date.now(),
+    from: '_adapter',
     body: { state: 'connected', reconnect: false, remote: walletKp.publicKeyB64 },
-  } as ProtocolMessage);
+  } as ProtocolMessage)
 
-  const recvKey = (session as any).recvKey as Uint8Array;
-  const dappPubB64 = transport.sent[0]!.from!;
-  return { recvKey, dappPubB64 };
+  const recvKey = (session as unknown as Record<string, unknown>).recvKey as Uint8Array
+  const dappPubB64 = transport.sent[0]?.from ?? ''
+  return { recvKey, dappPubB64 }
 }
 
 // ---------------------------------------------------------------------------
@@ -71,34 +78,39 @@ describe('Malicious Wallet: Wrong response ID', () => {
     // PREVENTS: Response injection for non-existent requests.
     // The dApp should silently ignore responses with unknown IDs.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
-    const responseHandler = vi.fn();
-    session.on('response', responseHandler);
+    const responseHandler = vi.fn()
+    session.on('response', responseHandler)
 
     // Wallet sends a response with a fabricated request ID
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: 'fabricated-req-id',
         sealed: sealPayload(
-          recvKey, session.channelId, 0,
+          recvKey,
+          session.channelId,
+          0,
           { _ok: true, _result: 'injected-data' },
           { type: 'res', from: walletKp.publicKeyB64, id: 'fabricated-req-id' },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait();
+    await wait()
 
     // Response handler should NOT have been called (no matching pending request)
-    expect(responseHandler).not.toHaveBeenCalled();
+    expect(responseHandler).not.toHaveBeenCalled()
     // Session should remain healthy
-    expect(session.phase).toBe('connected');
-  });
+    expect(session.phase).toBe('connected')
+  })
 
   it('response to wrong req.id does not resolve a different pending request', async () => {
     // ATTACK: Wallet sends a response with a different request's ID,
@@ -106,56 +118,66 @@ describe('Malicious Wallet: Wrong response ID', () => {
     //
     // PREVENTS: Cross-request response substitution.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
     // Send two requests
-    const p1 = session.request('wallet_getAccounts');
-    const p2 = session.request('wallet_signMessage', { message: 'test' });
-    await wait(20);
+    const p1 = session.request('wallet_getAccounts')
+    const p2 = session.request('wallet_signMessage', { message: 'test' })
+    await wait(20)
 
-    const reqs = transport.sent.filter(m => m.t === 'req') as any[];
-    const req1Id = reqs[0]!.body.id;
-    const req2Id = reqs[1]!.body.id;
+    const reqs = transport.sent.filter((m) => m.t === 'req')
+    const req1Id = (reqs[0]?.body as Record<string, unknown>)?.id as string
+    const req2Id = (reqs[1]?.body as Record<string, unknown>)?.id as string
 
     // Wallet responds to req2 with req1's ID (cross-wired)
     // The AAD includes the id field, so if the id doesn't match,
     // AEAD decryption will fail (or the wrong request will be resolved
     // with potentially confusing data).
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: req1Id,
         sealed: sealPayload(
-          recvKey, session.channelId, 0,
+          recvKey,
+          session.channelId,
+          0,
           { _ok: true, _result: 'correct-for-req1' },
           { type: 'res', from: walletKp.publicKeyB64, id: req1Id },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
     // req1 should resolve correctly
-    expect(await p1).toBe('correct-for-req1');
+    expect(await p1).toBe('correct-for-req1')
 
     // Now respond to req2 normally
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: req2Id,
         sealed: sealPayload(
-          recvKey, session.channelId, 1,
+          recvKey,
+          session.channelId,
+          1,
           { _ok: true, _result: 'correct-for-req2' },
           { type: 'res', from: walletKp.publicKeyB64, id: req2Id },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    expect(await p2).toBe('correct-for-req2');
-  });
-});
+    expect(await p2).toBe('correct-for-req2')
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Attack 2: Wallet sends req (role violation)
@@ -169,37 +191,42 @@ describe('Malicious Wallet: Sends req (role violation)', () => {
     //
     // PREVENTS: Role reversal attack where wallet tries to command the dApp.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
-    const errorHandler = vi.fn();
-    session.on('error', errorHandler);
+    const errorHandler = vi.fn()
+    session.on('error', errorHandler)
 
     // Wallet sends a req (which it should never do)
     transport.receive({
-      v: 1, t: 'req', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'req',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: 'evil-req-1',
         sealed: sealPayload(
-          recvKey, session.channelId, 0,
+          recvKey,
+          session.channelId,
+          0,
           { _method: 'dapp_executeTransaction' },
           { type: 'req', from: walletKp.publicKeyB64, id: 'evil-req-1' },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait();
+    await wait()
 
     // DApp does not have a request handler (it only sends requests).
     // The message should be silently ignored or cause no state change.
     // Key insight: DAppSession.handleMessage() has no case for 'req'
     // messages from the wallet, so it falls through to the default
     // case (no-op).
-    expect(session.phase).toBe('connected');
-  });
-});
+    expect(session.phase).toBe('connected')
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Attack 3: Wallet manipulates sequence numbers
@@ -210,31 +237,36 @@ describe('Malicious Wallet: Sequence number manipulation', () => {
     // Per Section 6.6.1: "Gaps are valid (expected after reconnect)."
     // This is NOT an attack — verifying correct behavior.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
-    const p = session.request('wallet_getAccounts');
-    await wait(20);
-    const req = transport.sent.find(m => m.t === 'req') as any;
-    const reqId = req.body.id;
+    const p = session.request('wallet_getAccounts')
+    await wait(20)
+    const req = transport.sent.find((m) => m.t === 'req')
+    const reqId = (req?.body as Record<string, unknown>)?.id as string
 
     // Wallet responds with seq=5 (skipping 0-4) — should be accepted
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: reqId,
         sealed: sealPayload(
-          recvKey, session.channelId, 5,
+          recvKey,
+          session.channelId,
+          5,
           { _ok: true, _result: 'gap-ok' },
           { type: 'res', from: walletKp.publicKeyB64, id: reqId },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    expect(await p).toBe('gap-ok');
-  });
+    expect(await p).toBe('gap-ok')
+  })
 
   it('reset sequence to 0 after receiving higher seq is rejected', async () => {
     // ATTACK: Wallet sends seq=10, then tries to reset to seq=0.
@@ -244,97 +276,117 @@ describe('Malicious Wallet: Sequence number manipulation', () => {
     //
     // PREVENTS: Sequence counter reset allowing message replay.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
     // First response at seq=10 (accepted)
-    const p0 = session.request('wallet_getAccounts');
-    await wait(20);
-    const req0 = transport.sent.find(m => m.t === 'req') as any;
-    const r0id = req0.body.id;
+    const p0 = session.request('wallet_getAccounts')
+    await wait(20)
+    const req0 = transport.sent.find((m) => m.t === 'req')
+    const r0id = (req0?.body as Record<string, unknown>)?.id as string
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: r0id,
         sealed: sealPayload(
-          recvKey, session.channelId, 10,
+          recvKey,
+          session.channelId,
+          10,
           { _ok: true, _result: 'first' },
           { type: 'res', from: walletKp.publicKeyB64, id: r0id },
         ),
       },
-    } as ProtocolMessage);
-    expect(await p0).toBe('first');
+    } as ProtocolMessage)
+    expect(await p0).toBe('first')
 
     // Second response at seq=0 (reset attempt — MUST be rejected)
-    const p1 = session.request('wallet_getAccounts');
-    await wait(20);
-    const req1 = transport.sent.filter(m => m.t === 'req')[1] as any;
-    const r1id = req1.body.id;
+    const p1 = session.request('wallet_getAccounts')
+    await wait(20)
+    const req1 = transport.sent.filter((m) => m.t === 'req')[1]
+    const r1id = (req1?.body as Record<string, unknown>)?.id as string
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: r1id,
         sealed: sealPayload(
-          recvKey, session.channelId, 0, // reset to 0!
+          recvKey,
+          session.channelId,
+          0, // reset to 0!
           { _ok: true, _result: 'replayed' },
           { type: 'res', from: walletKp.publicKeyB64, id: r1id },
         ),
       },
-    } as ProtocolMessage);
-    await expect(p1).rejects.toThrow('Replay detected');
-  });
+    } as ProtocolMessage)
+    await expect(p1).rejects.toThrow('Replay detected')
+  })
 
   it('reused sequence number is rejected', async () => {
     // ATTACK: Wallet sends the same sequence number twice.
     //
     // PREVENTS: Nonce reuse in AEAD encryption.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
     // First at seq=3 (accepted)
-    const p0 = session.request('wallet_getAccounts');
-    await wait(20);
-    const req0 = transport.sent.find(m => m.t === 'req') as any;
-    const r0id = req0.body.id;
+    const p0 = session.request('wallet_getAccounts')
+    await wait(20)
+    const req0 = transport.sent.find((m) => m.t === 'req')
+    const r0id = (req0?.body as Record<string, unknown>)?.id as string
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: r0id,
         sealed: sealPayload(
-          recvKey, session.channelId, 3,
+          recvKey,
+          session.channelId,
+          3,
           { _ok: true, _result: 'ok' },
           { type: 'res', from: walletKp.publicKeyB64, id: r0id },
         ),
       },
-    } as ProtocolMessage);
-    expect(await p0).toBe('ok');
+    } as ProtocolMessage)
+    expect(await p0).toBe('ok')
 
     // Second at seq=3 (reuse — MUST be rejected)
-    const p1 = session.request('wallet_getAccounts');
-    await wait(20);
-    const req1 = transport.sent.filter(m => m.t === 'req')[1] as any;
-    const r1id = req1.body.id;
+    const p1 = session.request('wallet_getAccounts')
+    await wait(20)
+    const req1 = transport.sent.filter((m) => m.t === 'req')[1]
+    const r1id = (req1?.body as Record<string, unknown>)?.id as string
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: {
         id: r1id,
         sealed: sealPayload(
-          recvKey, session.channelId, 3, // same seq!
+          recvKey,
+          session.channelId,
+          3, // same seq!
           { _ok: true, _result: 'reused' },
           { type: 'res', from: walletKp.publicKeyB64, id: r1id },
         ),
       },
-    } as ProtocolMessage);
-    await expect(p1).rejects.toThrow('Replay detected');
-  });
-});
+    } as ProtocolMessage)
+    await expect(p1).rejects.toThrow('Replay detected')
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Attack 4: Wallet sends evt before ready.connected
@@ -348,46 +400,52 @@ describe('Malicious Wallet: Event before connected', () => {
     //
     // PREVENTS: Pre-connection event injection.
 
-    const transport = new MockTransport();
+    const transport = new MockTransport()
     const session = new DAppSession({
       transport,
       meta: { name: 'T', description: 'T', url: 'https://t.test', icon: 'https://t.test/i.png' },
       autoAccept: false, // manual accept to control timing
-    });
+    })
 
-    const eventHandler = vi.fn();
-    session.on('event', eventHandler);
+    const eventHandler = vi.fn()
+    session.on('event', eventHandler)
 
-    await session.createPairing();
-    const dappPubB64 = transport.sent[0]!.from!;
+    await session.createPairing()
+    const dappPubB64 = transport.sent[0]?.from ?? ''
 
-    const walletKp = generateX25519KeyPair();
+    const walletKp = generateX25519KeyPair()
 
     // Wallet joins
     transport.receive({
-      v: 1, t: 'join', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'join',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: makeJoinBody(session.channelId, dappPubB64, walletKp),
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait();
+    await wait()
     // Session is now in pending_accept, NOT connected
 
     // Wallet tries to send an event before connected
     transport.receive({
-      v: 1, t: 'evt', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 1,
+      t: 'evt',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: { id: 'premature-evt', sealed: 'fake-sealed' },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait();
+    await wait()
 
     // Event should NOT have been processed (recvKey exists but
     // the sealed data is invalid, or the event is silently dropped
     // due to decryption failure)
-    expect(eventHandler).not.toHaveBeenCalled();
-  });
-});
+    expect(eventHandler).not.toHaveBeenCalled()
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Attack 5: Wallet sends response from a different key
@@ -401,39 +459,44 @@ describe('Malicious Wallet: Response from wrong peer', () => {
     //
     // PREVENTS: Third-party response injection.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    const { recvKey } = await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session } = ctx
+    const { recvKey } = await connectDAppManual(ctx)
 
-    const p = session.request('wallet_getAccounts');
-    await wait(20);
-    const req = transport.sent.find(m => m.t === 'req') as any;
-    const reqId = req.body.id;
+    const p = session.request('wallet_getAccounts')
+    await wait(20)
+    const req = transport.sent.find((m) => m.t === 'req')
+    const reqId = (req?.body as Record<string, unknown>)?.id as string
 
     // Impersonator uses a different key
-    const impersonatorKp = generateX25519KeyPair();
+    const impersonatorKp = generateX25519KeyPair()
     transport.receive({
-      v: 1, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: impersonatorKp.publicKeyB64, // wrong key!
+      v: 1,
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: impersonatorKp.publicKeyB64, // wrong key!
       body: {
         id: reqId,
         sealed: sealPayload(
-          recvKey, session.channelId, 0,
+          recvKey,
+          session.channelId,
+          0,
           { _ok: true, _result: 'evil' },
           { type: 'res', from: impersonatorKp.publicKeyB64, id: reqId },
         ),
       },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait(20);
+    await wait(20)
 
     // The response should have been silently dropped (from mismatch)
     // The request should still be pending (not resolved)
     // Clean up by closing
-    session.close();
-    await expect(p).rejects.toThrow('Session closed');
-  });
-});
+    session.close()
+    await expect(p).rejects.toThrow('Session closed')
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Attack 6: Wallet sends unsupported protocol version
@@ -446,22 +509,25 @@ describe('Malicious Wallet: Unsupported protocol version', () => {
     //
     // PREVENTS: Version confusion attacks. Section 15 rule 12.
 
-    const ctx = setupDAppManual();
-    const { transport, session, walletKp } = ctx;
-    await connectDAppManual(ctx);
+    const ctx = setupDAppManual()
+    const { transport, session, walletKp } = ctx
+    await connectDAppManual(ctx)
 
     transport.receive({
-      v: 99 as any, t: 'res', ch: session.channelId,
-      ts: Date.now(), from: walletKp.publicKeyB64,
+      v: 99 as ProtocolMessage['v'],
+      t: 'res',
+      ch: session.channelId,
+      ts: Date.now(),
+      from: walletKp.publicKeyB64,
       body: { id: 'req-1', sealed: 'whatever' },
-    } as ProtocolMessage);
+    } as ProtocolMessage)
 
-    await wait();
+    await wait()
 
     // DApp should close with unsupported_version
-    expect(session.phase).toBe('closed');
-    const closeMsg = transport.sent.find(m => m.t === 'close') as any;
-    expect(closeMsg).toBeTruthy();
-    expect(closeMsg.body.reason).toBe('unsupported_version');
-  });
-});
+    expect(session.phase).toBe('closed')
+    const closeMsg = transport.sent.find((m) => m.t === 'close')
+    expect(closeMsg).toBeTruthy()
+    expect((closeMsg?.body as Record<string, unknown>)?.reason).toBe('unsupported_version')
+  })
+})