From 3b8d53805c90fcb85f1dc93b60a8a1ed3c8cd514 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:53:04 +0800 Subject: [PATCH] Import packages/plugin/src/client-secure-transport.ts --- .../plugin/src/client-secure-transport.ts | 155 ++++++++++++++++++ 1 file changed, 155 insertions(+) create mode 100644 packages/plugin/src/client-secure-transport.ts diff --git a/packages/plugin/src/client-secure-transport.ts b/packages/plugin/src/client-secure-transport.ts new file mode 100644 index 0000000..f42d41d --- /dev/null +++ b/packages/plugin/src/client-secure-transport.ts @@ -0,0 +1,155 @@ +import { SerialSend } from '@dsh-remote/webrtc' +import { NoiseIkSession, createNoisePrologue } from '@dsh-remote/crypto' +import { SecureMessageCodec, MAX_SECURE_MESSAGE_BYTES } from '@dsh-remote/protocol' +import type { RemoteTransport, SecureHandshakeTransport } from '@dsh-remote/webrtc' +import type { HostIdentity, TrustedPeer } from './identity-store.js' + +/** Client-side Noise IK wrapper used by the local Harness remote-mode runtime. */ +export class ClientSecureTransport implements RemoteTransport { + private noise?: NoiseIkSession + private unsubscribeInner?: () => void + private readonly incoming = new SecureMessageCodec() + private readonly outgoing = new SecureMessageCodec() + private closed = false + private lifetime?: AbortController + private readonly sends = new SerialSend() + private closeError?: Error + + constructor( + private readonly inner: SecureHandshakeTransport, + private readonly identity: HostIdentity, + private readonly host: TrustedPeer, + ) {} + + async connect(): Promise { + const lifetime = new AbortController() + this.lifetime = lifetime + this.closed = false + this.closeError = undefined + this.incoming.reset() + this.outgoing.reset() + await this.inner.connect() + lifetime.signal.throwIfAborted() + const info = this.inner.connectionInfo() + if (info.localDeviceId !== this.identity.deviceId || info.remoteDeviceId !== this.host.deviceId) { + await this.inner.close() + throw Object.assign(new Error('The relay connection is bound to an unexpected device.'), { code: 'PEER_IDENTITY_MISMATCH' }) + } + const noise = new NoiseIkSession({ + role: 'initiator', + localPrivateKey: this.identity.privateKey, + localPublicKey: this.identity.publicKey, + remotePublicKey: this.host.publicKey, + prologue: createNoisePrologue(info.connectionId, this.host.deviceId, this.identity.deviceId), + }) + this.noise = noise + try { + await waitForResponder(this.inner, noise, lifetime.signal) + this.inner.markSecureReady?.() + } catch (error) { + noise.destroy() + if (this.lifetime === lifetime) { + this.noise = undefined + await this.inner.close() + } + throw error + } + } + + async send(data: Uint8Array): Promise { + if (data.byteLength > MAX_SECURE_MESSAGE_BYTES) throw new Error('Secure message exceeds the reassembly limit.') + const noise = this.requireNoise() + try { + await this.sends.run(data.byteLength, async () => { + if (this.closed || this.noise !== noise) throw new Error('Secure transport replaced') + for (const plaintext of this.outgoing.encode(data)) await this.inner.send(noise.encrypt(plaintext)) + }) + } catch (error) { + await this.close().catch(() => undefined) + throw error + } + } + + onMessage(handler: (data: Uint8Array) => void): () => void { + this.unsubscribeInner?.() + this.unsubscribeInner = this.inner.onMessage(data => { + const noise = this.noise + if (noise === undefined || !noise.complete || this.closed) return + try { + const message = this.incoming.decode(noise.decrypt(data)) + if (message !== undefined) handler(message) + } catch { + this.closeError = Object.assign(new Error('The authenticated Remote channel rejected a frame.'), { code: 'SECURE_CHANNEL_FAILED' }) + void this.close() + } + }) + return () => { + this.unsubscribeInner?.() + this.unsubscribeInner = undefined + } + } + + onClose(handler: (error?: Error) => void): () => void { + return this.inner.onClose?.(error => handler(this.closeError ?? error)) ?? (() => undefined) + } + + async close(): Promise { + if (this.closed) return + this.closed = true + this.lifetime?.abort() + this.lifetime = undefined + this.unsubscribeInner?.() + this.unsubscribeInner = undefined + this.incoming.reset() + this.outgoing.reset() + this.noise?.destroy() + this.noise = undefined + await this.inner.close() + } + + getStats() { return this.inner.getStats() } + + private requireNoise(): NoiseIkSession { + if (this.noise === undefined || !this.noise.complete || this.closed) { + throw new Error('The authenticated Noise channel is not connected.') + } + return this.noise + } +} + +async function waitForResponder(inner: SecureHandshakeTransport, noise: NoiseIkSession, signal: AbortSignal): Promise { + await new Promise((resolve, reject) => { + let settled = false + let unsubscribe = () => {} + let unsubscribeClose = () => {} + const timer = setTimeout(() => finish(new Error('Noise IK handshake timed out.')), 10_000) + const onAbort = () => finish(new Error('Noise IK handshake was aborted.')) + const finish = (error?: Error): void => { + if (settled) return + settled = true + clearTimeout(timer) + unsubscribe() + unsubscribeClose() + signal.removeEventListener('abort', onAbort) + if (error === undefined) resolve() + else reject(error) + } + unsubscribe = inner.onHandshake((step, data) => { + if (settled) return + try { + if (step !== 2) throw new Error('Noise IK responder sent an out-of-order handshake message.') + noise.readHandshake(data) + if (!noise.complete) throw new Error('Noise IK handshake did not complete.') + finish() + } catch (error) { + finish(Object.assign(error instanceof Error ? error : new Error('Noise IK handshake failed.'), { code: 'SECURE_CHANNEL_FAILED' })) + } + }) + unsubscribeClose = inner.onClose?.(error => finish(error ?? new Error('Control channel closed during Noise IK handshake.'))) ?? (() => {}) + signal.addEventListener('abort', onAbort, { once: true }) + if (signal.aborted) { onAbort(); return } + void inner.sendHandshake(1, noise.writeHandshake()).catch(error => { + finish(error instanceof Error ? error : new Error('Noise IK handshake failed.')) + }) + }) +}