From 6482b15ec844fd6058cc0697ddc948ebeedcd894 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:00:18 +0800 Subject: [PATCH] Import packages/plugin/tests/client-secure-transport.test.ts --- .../tests/client-secure-transport.test.ts | 214 ++++++++++++++++++ 1 file changed, 214 insertions(+) create mode 100644 packages/plugin/tests/client-secure-transport.test.ts diff --git a/packages/plugin/tests/client-secure-transport.test.ts b/packages/plugin/tests/client-secure-transport.test.ts new file mode 100644 index 0000000..47e861a --- /dev/null +++ b/packages/plugin/tests/client-secure-transport.test.ts @@ -0,0 +1,214 @@ +import { NoiseIkSession, createNoisePrologue, generateKeyPair } from '@dsh-remote/crypto' +import { MAX_SECURE_MESSAGE_BYTES, SECURE_FRAGMENT_CHUNK_BYTES, SecureMessageCodec } from '@dsh-remote/protocol' +import type { SecureHandshakeTransport } from '@dsh-remote/webrtc' +import { describe, expect, it, vi } from 'vitest' +import { ClientSecureTransport } from '../src/client-secure-transport.js' +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import type { HostIdentity, TrustedPeer } from '../src/identity-store.js' + +class HostLoopbackTransport implements SecureHandshakeTransport { + private messageHandler?: (data: Uint8Array) => void + private handshakeHandler?: (step: number, data: Uint8Array) => void + private readonly closeHandlers = new Set<() => void>() + private readonly incoming = new SecureMessageCodec() + private readonly outgoing = new SecureMessageCodec() + plaintext?: Uint8Array + closed = false + sendError?: Error + + constructor(private readonly hostNoise: NoiseIkSession) {} + + async connect(): Promise {} + + async send(data: Uint8Array): Promise { + if (this.sendError !== undefined) throw this.sendError + const message = this.incoming.decode(this.hostNoise.decrypt(data)) + if (message !== undefined) this.plaintext = message + } + + async sendHandshake(step: number, data: Uint8Array): Promise { + expect(step).toBe(1) + this.hostNoise.readHandshake(data) + this.handshakeHandler?.(2, this.hostNoise.writeHandshake()) + } + + connectionInfo() { return { connectionId: 'connection-1', localDeviceId: 'client-1', remoteDeviceId: 'host-1' } } + + onHandshake(handler: (step: number, data: Uint8Array) => void): () => void { + this.handshakeHandler = handler + return () => { this.handshakeHandler = undefined } + } + + onMessage(handler: (data: Uint8Array) => void): () => void { + this.messageHandler = handler + return () => { this.messageHandler = undefined } + } + + onClose(handler: () => void): () => void { + this.closeHandlers.add(handler) + return () => { this.closeHandlers.delete(handler) } + } + + async close(): Promise { + if (this.closed) return + this.closed = true + this.disconnect() + } + + getStats() { return { mode: 'Relay' as const, connected: !this.closed } } + + sendFromHost(data: Uint8Array): void { + for (const frame of this.outgoing.encode(data)) this.messageHandler?.(this.hostNoise.encrypt(frame)) + } + + disconnect(): void { for (const handler of this.closeHandlers) handler() } + corruptFrame(): void { this.messageHandler?.(new Uint8Array(32)) } +} + +describe('ClientSecureTransport', () => { + it('reports rejected ciphertext as a terminal security failure for reconnect policy', async () => { + const { secure, wire } = secureTransportFixture() + const closed = vi.fn() + const received = vi.fn() + secure.onClose(closed) + secure.onMessage(received) + await secure.connect() + wire.corruptFrame() + expect(closed).toHaveBeenCalledWith(expect.objectContaining({ code: 'SECURE_CHANNEL_FAILED' })) + expect(received).not.toHaveBeenCalled() + expect(wire.closed).toBe(true) + }) + it('starts the Noise deadline after transport selection and settles timeout, cancellation and disconnect', async () => { + await runScenarios(['success', 'timeout', 'close', 'disconnect'].map(action => ({ name: action, run: async () => { + vi.useFakeTimers() + try { + const { secure, wire } = secureTransportFixture() + vi.spyOn(wire, 'connect').mockImplementation(() => new Promise(resolve => setTimeout(resolve, 20000))) + const sendHandshake = wire.sendHandshake.bind(wire) + const send = vi.spyOn(wire, 'sendHandshake').mockImplementation(async () => {}) + const outcome = secure.connect().then(() => 'ready', error => error.message as string) + await vi.advanceTimersByTimeAsync(19999) + expect(send).not.toHaveBeenCalled() + await vi.advanceTimersByTimeAsync(1) + expect(send).toHaveBeenCalledOnce() + if (action === 'success') await sendHandshake(...send.mock.calls[0]!) + else if (action === 'timeout') await vi.advanceTimersByTimeAsync(10000) + else if (action === 'close') await secure.close() + else wire.disconnect() + const result = await outcome + expect(result).toEqual(action === 'success' ? 'ready' : expect.stringMatching(/handshake/i)) + if (action !== 'success') { + await sendHandshake(...send.mock.calls[0]!) + await expect(secure.send(new Uint8Array([1]))).rejects.toThrow('not connected') + expect(wire.closed).toBe(true) + } + await secure.close() + expect(vi.getTimerCount()).toBe(0) + } finally { vi.useRealTimers(); vi.restoreAllMocks() } + } }))) + }) + + it('authenticates the Host, protects both directions, and forwards disconnects', async () => { + const clientKeys = generateKeyPair(new Uint8Array(32).fill(21)) + const hostKeys = generateKeyPair(new Uint8Array(32).fill(22)) + const client: HostIdentity = { + schemaVersion: 1, + deviceId: 'client-1', + name: 'Local Client', + fingerprint: 'CLIENT', + ...clientKeys, + } + const host: TrustedPeer = { + deviceId: 'host-1', + name: 'Remote Host', + platform: 'linux', + publicKey: hostKeys.publicKey, + fingerprint: 'HOST', + trustedAt: 1, + membershipId: 'membership-1', + } + const hostNoise = new NoiseIkSession({ + role: 'responder', + localPrivateKey: hostKeys.privateKey, + localPublicKey: hostKeys.publicKey, + remotePublicKey: clientKeys.publicKey, + prologue: createNoisePrologue('connection-1', 'host-1', 'client-1'), + }) + const wire = new HostLoopbackTransport(hostNoise) + const secure = new ClientSecureTransport(wire, client, host) + const closed = vi.fn() + secure.onClose(closed) + let received = new Uint8Array() + secure.onMessage(data => { received = Uint8Array.from(data) }) + + await secure.connect() + await secure.send(new TextEncoder().encode('private request')) + expect(new TextDecoder().decode(wire.plaintext)).toBe('private request') + wire.sendFromHost(new TextEncoder().encode('private response')) + expect(new TextDecoder().decode(received)).toBe('private response') + + const large = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2 + 19).fill(7) + await secure.send(large) + expect(wire.plaintext).toEqual(large) + wire.sendFromHost(large) + expect(received).toEqual(large) + + wire.disconnect() + expect(closed).toHaveBeenCalledOnce() + }) + + it('closes the Noise session when the encrypted transport send fails', async () => { + const { secure, wire } = secureTransportFixture() + await secure.connect() + wire.sendError = new Error('Relay frame exceeds its limit.') + + await expect(secure.send(new Uint8Array(64 * 1024))).rejects.toThrow('Relay frame exceeds its limit.') + expect(wire.closed).toBe(true) + expect(secure.getStats().connected).toBe(false) + await expect(secure.send(new Uint8Array([1]))).rejects.toThrow( + 'The authenticated Noise channel is not connected.', + ) + }) + + it('keeps the Noise session open when local message validation fails', async () => { + const { secure, wire } = secureTransportFixture() + await secure.connect() + + await expect(secure.send(new Uint8Array(MAX_SECURE_MESSAGE_BYTES + 1))).rejects.toThrow( + 'Secure message exceeds the reassembly limit.', + ) + expect(wire.closed).toBe(false) + await secure.send(new TextEncoder().encode('valid request')) + expect(new TextDecoder().decode(wire.plaintext)).toBe('valid request') + }) +}) + +function secureTransportFixture(): { secure: ClientSecureTransport; wire: HostLoopbackTransport } { + const clientKeys = generateKeyPair(new Uint8Array(32).fill(21)) + const hostKeys = generateKeyPair(new Uint8Array(32).fill(22)) + const client: HostIdentity = { + schemaVersion: 1, + deviceId: 'client-1', + name: 'Local Client', + fingerprint: 'CLIENT', + ...clientKeys, + } + const host: TrustedPeer = { + deviceId: 'host-1', + name: 'Remote Host', + platform: 'linux', + publicKey: hostKeys.publicKey, + fingerprint: 'HOST', + trustedAt: 1, + membershipId: 'membership-1', + } + const hostNoise = new NoiseIkSession({ + role: 'responder', + localPrivateKey: hostKeys.privateKey, + localPublicKey: hostKeys.publicKey, + remotePublicKey: clientKeys.publicKey, + prologue: createNoisePrologue('connection-1', 'host-1', 'client-1'), + }) + const wire = new HostLoopbackTransport(hostNoise) + return { secure: new ClientSecureTransport(wire, client, host), wire } +}