From a6dbcf8ce8a4db0ce2ef3b9678bc1ea165e2d42f Mon Sep 17 00:00:00 2001 From: QQ Date: Tue, 17 Nov 2026 08:31:41 +0800 Subject: [PATCH] Import apps/android/src/services/secure-transport.ts --- apps/android/src/services/secure-transport.ts | 262 ++++++++++++++++-- 1 file changed, 232 insertions(+), 30 deletions(-) diff --git a/apps/android/src/services/secure-transport.ts b/apps/android/src/services/secure-transport.ts index 759e788..9c37a12 100644 --- a/apps/android/src/services/secure-transport.ts +++ b/apps/android/src/services/secure-transport.ts @@ -1,13 +1,46 @@ import { NoiseIkSession, createNoisePrologue } from '@dsh-remote/crypto' -import { SecureMessageCodec } from '@dsh-remote/protocol' -import type { RemoteTransport, SecureHandshakeTransport } from '@dsh-remote/webrtc' +import type { UpgradeableSecureChannel } from '@dsh-remote/client-core' +import { + DEFAULT_PREVIOUS_LEG_DRAIN_MS, + SecureMessageCodec, + SequencedCiphertextReorderBuffer, + type TransportStats, +} from '@dsh-remote/protocol' +import { + isSequencedOutboundTransport, + type RemoteTransport, + type SecureHandshakeTransport, + type SequencedOutboundTransport, +} from '@dsh-remote/webrtc' import { connectionLog } from './connection-log' import { strings } from '../locales/i18n' +import { nativeChaChaEncryptor } from './native-chacha-poly' import type { DeviceIdentity, RemoteDevice } from '../types' -export class SecureTransport implements RemoteTransport { +interface AttachedLeg { + readonly leg: SequencedOutboundTransport + readonly unsubscribeMsg: () => void + readonly unsubscribeClose: () => void +} + +interface DrainingLeg { + readonly leg: SequencedOutboundTransport + endCounter?: number + readonly timer: ReturnType +} + +export class SecureTransport implements RemoteTransport, UpgradeableSecureChannel { private noise?: NoiseIkSession + private activeOutbound?: RemoteTransport + private relayBytesSent = 0 + private relayBytesReceived = 0 private unsubscribeInner?: () => void + private unsubscribeInnerClose?: () => void + private messageCb?: (data: Uint8Array) => void + private readonly closeHandlers = new Set<(error?: Error) => void>() + private readonly attachedLegs = new Map() + private readonly drainingLegs = new Map() + private readonly reorderBuffer: SequencedCiphertextReorderBuffer private readonly incoming = new SecureMessageCodec() private readonly outgoing = new SecureMessageCodec() private closed = false @@ -19,12 +52,30 @@ export class SecureTransport implements RemoteTransport { private readonly identity: DeviceIdentity, private readonly host: RemoteDevice, private readonly onHandshakeStarting?: () => void, + reorderOptions?: { maxFrames?: number; maxBytes?: number; gapTimeoutMs?: number }, ) { if (host.identityKey.length === 0) throw new Error(strings.runtime.hostMissingKey) + this.reorderBuffer = new SequencedCiphertextReorderBuffer({ + ...reorderOptions, + onGapTimeout: () => { + connectionLog('secure-receive-failed', { stage: 'reorder-gap-timeout', errorName: 'TimeoutError' }) + void this.failAndClose(new Error('Secure channel reorder gap timed out.')) + }, + }) + } + + get outboundCounter(): number { return this.noise ? Number(this.noise.sendingCounter()) : 0 } + + relayTrafficBytes(): { sent: number; received: number } { + return { sent: this.relayBytesSent, received: this.relayBytesReceived } } async connect(): Promise { this.closed = false + this.relayBytesSent = 0 + this.relayBytesReceived = 0 + this.activeOutbound = this.inner + this.reorderBuffer.clear() this.incoming.reset() this.outgoing.reset() await this.inner.connect() @@ -37,6 +88,7 @@ export class SecureTransport implements RemoteTransport { this.onHandshakeStarting?.() const noise = new NoiseIkSession({ role: 'initiator', + encryptChaChaPoly: nativeChaChaEncryptor(), localPrivateKey: this.identity.privateKey, localPublicKey: this.identity.publicKey, remotePublicKey: this.host.identityKey, @@ -53,6 +105,75 @@ export class SecureTransport implements RemoteTransport { await this.inner.close() throw error } + this.unsubscribeInnerClose = this.inner.onClose?.(err => { + void this.failAndClose(err ?? new Error('Control transport closed.')) + }) + } + + markPreviousLegEndCounter(previousLegEndCounter: number): void { + for (const [draining, entry] of this.drainingLegs) { + entry.endCounter = previousLegEndCounter + if (this.noise !== undefined && Number(this.noise.receivingCounter()) >= previousLegEndCounter) { + clearTimeout(entry.timer) + this.drainingLegs.delete(draining) + void this.detachLeg(draining) + } + } + } + + attachIncomingLeg(leg: SequencedOutboundTransport): void { + if (this.closed || this.attachedLegs.has(leg)) return + const unsubscribeMsg = leg.onSequencedMessage((counter, ciphertext) => { + this.handleIncomingCiphertext(counter, ciphertext) + }) + const unsubscribeClose = leg.onClose?.(err => { + if (this.activeOutbound === leg && !this.closed) { + void this.failAndClose(err ?? new Error('Upgraded WebRTC DataChannel closed.')) + } + }) ?? (() => undefined) + this.attachedLegs.set(leg, { leg, unsubscribeMsg, unsubscribeClose }) + } + + async switchOutboundLeg( + leg: SequencedOutboundTransport, + options: { closePrevious?: boolean; drainMs?: number } = {}, + ): Promise { + const run = this.sendTail.then(async () => { + if (this.closed) { + await this.detachLeg(leg) + return this.outboundCounter + } + const prev = this.activeOutbound + this.activeOutbound = leg + const endCounter = this.outboundCounter + if (options.closePrevious && prev !== undefined && prev !== leg && prev !== this.inner && isSequencedOutboundTransport(prev)) { + const drainMs = options.drainMs ?? DEFAULT_PREVIOUS_LEG_DRAIN_MS + const timer = setTimeout(() => { + this.drainingLegs.delete(prev) + void this.detachLeg(prev) + }, drainMs) + ;(timer as { unref?: () => void }).unref?.() + this.drainingLegs.set(prev, { leg: prev, timer }) + } + return endCounter + }) + this.sendTail = run.then(() => undefined, () => undefined) + return run + } + + async detachLeg(leg: SequencedOutboundTransport): Promise { + const draining = this.drainingLegs.get(leg) + if (draining !== undefined) { + clearTimeout(draining.timer) + this.drainingLegs.delete(leg) + } + const attached = this.attachedLegs.get(leg) + if (attached !== undefined) { + this.attachedLegs.delete(leg) + attached.unsubscribeMsg() + attached.unsubscribeClose() + } + await leg.close().catch(() => undefined) } async send(data: Uint8Array): Promise { @@ -65,54 +186,125 @@ export class SecureTransport implements RemoteTransport { const plaintextFrames = this.outgoing.encode(data) try { for (const plaintext of plaintextFrames) { - await this.inner.send(this.requireNoise().encrypt(plaintext)) + const noise = this.requireNoise() + const ciphertext = noise.encrypt(plaintext) + const counter = Number(noise.sendingCounter() - 1n) + const target = this.activeOutbound ?? this.inner + if (isSequencedOutboundTransport(target)) { + await target.sendSequenced(counter, ciphertext) + } else { + this.relayBytesSent += ciphertext.byteLength + await target.send(ciphertext) + } } } catch (error) { connectionLog('secure-send-failed') - await this.close().catch(() => undefined) + await this.failAndClose(error instanceof Error ? error : new Error('Secure send failed.')).catch(() => undefined) throw error } } onMessage(cb: (data: Uint8Array) => void): () => void { + this.messageCb = cb this.unsubscribeInner?.() - this.unsubscribeInner = this.inner.onMessage(data => { - const noise = this.noise - if (noise === undefined || !noise.complete || this.closed) return - let stage = 'decrypt' - try { - const plaintext = noise.decrypt(data) - stage = 'reassembly' - const message = this.incoming.decode(plaintext) - if (message !== undefined) { - stage = 'message-handler' - cb(message) - } - } catch (error) { - // Only known error classes and numeric bundle positions. Error messages - // and arbitrary stack lines can contain decrypted application content. - const name = error instanceof Error - && ['Error', 'TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'ZodError'].includes(error.name) - ? error.name : 'unknown' - connectionLog('secure-receive-failed', { stage, errorName: name }) - void this.close() - } - }) + this.unsubscribeInner = this.inner.onSequencedMessage + ? this.inner.onSequencedMessage((counter, data) => { + this.relayBytesReceived += data.byteLength + this.handleIncomingCiphertext(counter, data) + }) + : this.inner.onMessage(data => { + this.relayBytesReceived += data.byteLength + this.handleIncomingCiphertext(undefined, data) + }) return () => { + if (this.messageCb === cb) this.messageCb = undefined this.unsubscribeInner?.() this.unsubscribeInner = undefined } } - onClose(handler: () => void): () => void { - return this.inner.onClose?.(handler) ?? (() => undefined) + private handleIncomingCiphertext(counter: number | undefined, ciphertext: Uint8Array): void { + const noise = this.noise + if (noise === undefined || !noise.complete || this.closed) return + let stage = 'decrypt' + try { + if (counter !== undefined) { + const expected = Number(noise.receivingCounter()) + if (!Number.isSafeInteger(counter) || counter < expected) { + throw new Error('Ciphertext counter is duplicated or out of order.') + } + if (counter > expected) { + this.reorderBuffer.push(counter, expected, ciphertext) + return + } + } + this.decryptAndDeliver(noise, ciphertext, s => { stage = s }) + while (!this.closed) { + const nextExpected = Number(noise.receivingCounter()) + const buffered = this.reorderBuffer.takeNext(nextExpected) + if (buffered === undefined) break + stage = 'decrypt' + this.decryptAndDeliver(noise, buffered, s => { stage = s }) + } + } catch (error) { + const name = error instanceof Error + && ['Error', 'TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'ZodError'].includes(error.name) + ? error.name : 'unknown' + connectionLog('secure-receive-failed', { stage, errorName: name }) + void this.failAndClose(error instanceof Error ? error : new Error('Secure receive failed.')) + } + } + + private decryptAndDeliver(noise: NoiseIkSession, ciphertext: Uint8Array, setStage: (s: string) => void): void { + const plaintext = noise.decrypt(ciphertext) + const currentReceiving = Number(noise.receivingCounter()) + this.reorderBuffer.onExpectedAdvanced(currentReceiving) + for (const [leg, draining] of this.drainingLegs) { + if (draining.endCounter !== undefined && currentReceiving >= draining.endCounter) { + clearTimeout(draining.timer) + this.drainingLegs.delete(leg) + void this.detachLeg(leg) + } + } + setStage('reassembly') + const message = this.incoming.decode(plaintext) + if (message !== undefined && this.messageCb !== undefined) { + setStage('message-handler') + this.messageCb(message) + } + } + + onClose(cb: (error?: Error) => void): () => void { + this.closeHandlers.add(cb) + return () => this.closeHandlers.delete(cb) + } + + private async failAndClose(error?: Error): Promise { + const wasClosed = this.closed + await this.close() + if (!wasClosed) { + for (const cb of this.closeHandlers) cb(error) + } } async close(): Promise { if (this.closed) return this.closed = true + this.reorderBuffer.clear() this.unsubscribeInner?.() this.unsubscribeInner = undefined + this.unsubscribeInnerClose?.() + this.unsubscribeInnerClose = undefined + for (const [, draining] of this.drainingLegs) clearTimeout(draining.timer) + this.drainingLegs.clear() + const legs = [...this.attachedLegs.values()] + this.attachedLegs.clear() + for (const entry of legs) { + entry.unsubscribeMsg() + entry.unsubscribeClose() + await entry.leg.close().catch(() => undefined) + } + this.activeOutbound = undefined this.incoming.reset() this.outgoing.reset() this.noise?.destroy() @@ -120,7 +312,13 @@ export class SecureTransport implements RemoteTransport { await this.inner.close() } - getStats() { return this.inner.getStats() } + getStats(): TransportStats { + const active = this.activeOutbound + if (active !== undefined && active !== this.inner) { + return active.getStats() + } + return this.inner.getStats() + } private requireNoise(): NoiseIkSession { if (this.noise === undefined || !this.noise.complete || this.closed) { @@ -145,11 +343,15 @@ async function waitForResponder(inner: SecureHandshakeTransport, noise: NoiseIkS finish(error instanceof Error ? error : new Error(strings.runtime.secureHandshakeFailed)) } }) + const unsubscribeClose = inner.onClose?.(error => { + finish(error ?? new Error(strings.runtime.secureHandshakeFailed)) + }) const finish = (error?: Error): void => { if (settled) return settled = true clearTimeout(timer) unsubscribe() + unsubscribeClose?.() if (error === undefined) resolve() else reject(error) }