diff --git a/apps/android/tests/transport-upgrade-android.test.ts b/apps/android/tests/transport-upgrade-android.test.ts new file mode 100644 index 0000000..720c11f --- /dev/null +++ b/apps/android/tests/transport-upgrade-android.test.ts @@ -0,0 +1,262 @@ +vi.mock('expo', () => ({ requireOptionalNativeModule: () => undefined })) +import { describe, expect, it, vi } from 'vitest' +import { generateKeyPair, NoiseIkSession, createNoisePrologue } from '@dsh-remote/crypto' +import { ClientLiveTransportUpgrader, RemoteClientCore } from '@dsh-remote/client-core' +import { + SecureMessageCodec, + createRpcResponse, + decodeMessage, + encodeMessage, + unwrapUpgradedTransportFrame, + wrapUpgradedTransportFrame, + type RemoteMessage, +} from '@dsh-remote/protocol' +import { + RtcChunkCodec, + type RtcDataChannel, + type RtcPeerConnection, + type RtcPeerConnectionFactory, + type RtcStats, + type SecureHandshakeTransport, + type SequencedOutboundTransport, +} from '@dsh-remote/webrtc' +import { SecureTransport } from '../src/services/secure-transport' + +function createPairedHandshake() { + const clientKeys = generateKeyPair() + const hostKeys = generateKeyPair() + const connectionId = 'conn-android-upg' + const hostNoise = new NoiseIkSession({ + role: 'responder', + localPrivateKey: hostKeys.privateKey, + localPublicKey: hostKeys.publicKey, + remotePublicKey: clientKeys.publicKey, + prologue: createNoisePrologue(connectionId, 'host-1', 'client-1'), + }) + let onMsg: ((data: Uint8Array) => void) | undefined + let onHs: ((step: number, data: Uint8Array) => void) | undefined + const relayOutbound: Uint8Array[] = [] + const inner: SecureHandshakeTransport = { + connect: async () => undefined, + connectionInfo: () => ({ connectionId, localDeviceId: 'client-1', remoteDeviceId: 'host-1' }), + sendHandshake: async (_step, data) => { + hostNoise.readHandshake(data) + onHs?.(2, hostNoise.writeHandshake()) + }, + onHandshake: cb => { onHs = cb; return () => { onHs = undefined } }, + send: async data => { relayOutbound.push(data) }, + onMessage: cb => { onMsg = cb; return () => { onMsg = undefined } }, + onClose: () => () => undefined, + close: async () => undefined, + getStats: () => ({ mode: 'Relay', connected: true, bytesSent: 0, bytesReceived: 0 }), + } + return { clientKeys, hostKeys, hostNoise, inner, relayOutbound, deliverRelay: (cipher: Uint8Array) => onMsg?.(cipher) } +} + +function makeStats(tier: 'LAN' | 'P2P' | 'TURN'): RtcStats { + const localType = tier === 'TURN' ? 'relay' : tier === 'P2P' ? 'srflx' : 'host' + const localAddr = tier === 'LAN' ? '192.168.1.10' : '203.0.113.10' + const remoteAddr = tier === 'LAN' ? '192.168.1.20' : '198.51.100.20' + return new Map([ + ['L1', { id: 'L1', type: 'local-candidate', candidateType: localType, address: localAddr }], + ['R1', { id: 'R1', type: 'remote-candidate', candidateType: localType === 'relay' ? 'srflx' : localType, address: remoteAddr }], + ['P1', { id: 'P1', type: 'candidate-pair', localCandidateId: 'L1', remoteCandidateId: 'R1', state: 'succeeded', nominated: true }], + ['T1', { id: 'T1', type: 'transport', selectedCandidatePairId: 'P1' }], + ]) +} + +describe('Android SecureTransport live upgrade & cross-leg reorder', () => { + it('switches outbound leg without re-handshaking, tracks Relay byte cost separately, and reorders fast DataChannel frames overtaking Relay frames', async () => { + const { clientKeys, hostKeys, hostNoise, inner, relayOutbound, deliverRelay } = createPairedHandshake() + const secure = new SecureTransport( + inner, + { deviceId: 'client-1', name: 'Phone', platform: 'android', publicKey: clientKeys.publicKey, privateKey: clientKeys.privateKey }, + { deviceId: 'host-1', name: 'Mac', platform: 'darwin', identityKey: hostKeys.publicKey, membershipId: 'm1', online: true, trusted: true }, + ) + const received: string[] = [] + secure.onMessage(msg => received.push(new TextDecoder().decode(msg))) + await secure.connect() + + await secure.send(new TextEncoder().encode('hello-relay')) + expect(relayOutbound).toHaveLength(1) + const relaySentBeforeUpgrade = secure.relayTrafficBytes().sent + + let onSeq: ((counter: number, cipher: Uint8Array) => void) | undefined + const dcSent: Array<{ counter: number; cipher: Uint8Array }> = [] + const lanLeg: SequencedOutboundTransport = { + isSequencedUpgradeLeg: true, + mode: 'LAN', + selectedTransport: 'lan', + connect: async () => undefined, + send: async () => { throw new Error('unused') }, + sendSequenced: async (counter, cipher) => { dcSent.push({ counter, cipher }) }, + onSequencedMessage: cb => { onSeq = cb; return () => { onSeq = undefined } }, + onMessage: () => () => undefined, + onClose: () => () => undefined, + close: async () => undefined, + getStats: () => ({ mode: 'LAN', connected: true, bytesSent: 100, bytesReceived: 200 }), + connectionDetails: async () => ({ mode: 'LAN', transport: 'lan', connectionState: 'connected', iceConnectionState: 'connected', diagnostics: {} as never }), + } + + secure.attachIncomingLeg(lanLeg) + const endCounter = await secure.switchOutboundLeg(lanLeg, { closePrevious: true }) + expect(endCounter).toBe(1) + expect(secure.getStats().mode).toBe('LAN') + + await secure.send(new TextEncoder().encode('hello-lan')) + expect(dcSent).toHaveLength(1) + expect(dcSent[0]!.counter).toBe(1) + expect(secure.relayTrafficBytes().sent).toBe(relaySentBeforeUpgrade) + + const hostCodec = new SecureMessageCodec() + const c0 = hostNoise.encrypt(hostCodec.encode(new TextEncoder().encode('snap-0'))[0]!) + const c1 = hostNoise.encrypt(hostCodec.encode(new TextEncoder().encode('delta-1'))[0]!) + + onSeq?.(1, c1) + expect(received).toEqual([]) + deliverRelay(c0) + expect(received).toEqual(['snap-0', 'delta-1']) + + await secure.close() + }) + + it('survives old P2P DataChannel closing as soon as drain RPC arrives on second upgrade (P2P -> LAN)', async () => { + const { clientKeys, hostKeys, hostNoise, inner } = createPairedHandshake() + const hostIncoming = new SecureMessageCodec() + const hostOutgoing = new SecureMessageCodec() + let tier: 'P2P' | 'LAN' = 'P2P' + const clientDcs: RtcDataChannel[] = [] + const drainWatermarks: number[] = [] + + const hostRtcChunkOut = new RtcChunkCodec() + const hostRtcChunkIn = new RtcChunkCodec() + const sendFromHostOnDc = (dcIndex: number, msg: RemoteMessage, delayMs = 0) => { + const encoded = encodeMessage(msg) + for (const pt of hostOutgoing.encode(encoded)) { + const cipher = hostNoise.encrypt(pt) + const ctr = Number(hostNoise.sendingCounter() - 1n) + const framed = wrapUpgradedTransportFrame(ctr, cipher) + for (const rtch of hostRtcChunkOut.encode(framed)) { + const buf = rtch.buffer.slice(rtch.byteOffset, rtch.byteOffset + rtch.byteLength) as ArrayBuffer + const deliver = () => clientDcs[dcIndex]?.onmessage?.({ data: buf }) + if (delayMs > 0) setTimeout(deliver, delayMs) + else deliver() + } + } + } + + // Intercept Relay sends during first upgrade + inner.send = async cipher => { + const pt = hostIncoming.decode(hostNoise.decrypt(cipher)) + if (!pt) return + const req = decodeMessage(pt) as RemoteMessage<{ method: string; params: Record }> + if (req.payload.method === 'remote.transport.upgrade.offer') { + sendFromHostOnRelay(createRpcResponse(req.id, { attemptId: req.payload.params.attemptId, sdp: 'v=0\r\nans' })) + } else if (req.payload.method === 'remote.transport.upgrade.activate') { + sendFromHostOnDc(0, createRpcResponse(req.id, { activated: true, mode: 'P2P', previousLegEndCounter: Number(hostNoise.sendingCounter()) })) + } + } + let relaySeqCb: ((ctr: number | undefined, d: Uint8Array) => void) | undefined + inner.onSequencedMessage = cb => { relaySeqCb = cb; return () => { relaySeqCb = undefined } } + const sendFromHostOnRelay = (msg: RemoteMessage) => { + for (const pt of hostOutgoing.encode(encodeMessage(msg))) { + const cipher = hostNoise.encrypt(pt) + const ctr = Number(hostNoise.sendingCounter() - 1n) + relaySeqCb?.(ctr, cipher) + } + } + + const factory: RtcPeerConnectionFactory = { + create() { + const idx = clientDcs.length + const dc: RtcDataChannel = { + label: 'dsh', ordered: true, readyState: 'connecting', bufferedAmount: 0, binaryType: 'arraybuffer', + onopen: null, onmessage: null, onclose: null, onerror: null, onbufferedamountlow: null, + send: raw => { + if (dc.readyState !== 'open') throw new Error('DC already closed') + const assembled = hostRtcChunkIn.decode(new Uint8Array(raw as ArrayBuffer)) + if (!assembled) return + const { ciphertext } = unwrapUpgradedTransportFrame(assembled) + const pt = hostIncoming.decode(hostNoise.decrypt(ciphertext)) + if (!pt) return + const req = decodeMessage(pt) as RemoteMessage<{ method: string; params: Record }> + if (req.payload.method === 'remote.transport.upgrade.offer') { + sendFromHostOnDc(idx, createRpcResponse(req.id, { attemptId: req.payload.params.attemptId, sdp: 'v=0\r\nans2' })) + } else if (req.payload.method === 'remote.transport.upgrade.activate') { + // Host does NOT close dc[0] during activate; responds on new dc[1] after 25ms! + sendFromHostOnDc(1, createRpcResponse(req.id, { activated: true, mode: 'LAN', previousLegEndCounter: Number(hostNoise.sendingCounter()) }), 25) + } else if (req.payload.method === 'remote.transport.upgrade.drain') { + drainWatermarks.push(req.payload.params.previousLegEndCounter as number) + if (idx === 1) { + // On 2nd hop (P2P -> LAN), immediately close superseded P2P dc[0] firing real client dc.onclose()! + clientDcs[0]!.readyState = 'closed' + clientDcs[0]!.onclose?.() + } + sendFromHostOnDc(idx, createRpcResponse(req.id, { ok: true })) + } else { + sendFromHostOnDc(idx, createRpcResponse(req.id, { ok: true, echo: req.payload.params })) + } + }, + close: () => { if (dc.readyState !== 'closed') { dc.readyState = 'closed'; dc.onclose?.() } }, + } + clientDcs.push(dc) + const pc: RtcPeerConnection = { + connectionState: 'new', iceConnectionState: 'new', iceGatheringState: 'new', signalingState: 'stable', + onicecandidate: null, ondatachannel: null, onconnectionstatechange: null, oniceconnectionstatechange: null, onicegatheringstatechange: null, + createDataChannel: () => dc, + createOffer: async () => ({ type: 'offer', sdp: 'v=0\r\noffer' }), + createAnswer: async () => ({ type: 'answer', sdp: 'v=0\r\nanswer' }), + setLocalDescription: async () => undefined, + setRemoteDescription: async () => { + queueMicrotask(() => { + pc.connectionState = 'connected' + pc.iceConnectionState = 'connected' + dc.readyState = 'open' + dc.onopen?.() + }) + }, + addIceCandidate: async () => undefined, + getStats: async () => makeStats(tier), + close: () => dc.close(), + } + return pc + }, + } + + let closed = false + const secure = new SecureTransport( + inner, + { deviceId: 'client-1', name: 'Phone', platform: 'android', publicKey: clientKeys.publicKey, privateKey: clientKeys.privateKey }, + { deviceId: 'host-1', name: 'Mac', platform: 'darwin', identityKey: hostKeys.publicKey, membershipId: 'm1', online: true, trusted: true }, + ) + const core = new RemoteClientCore(secure) + core.onClose(() => { closed = true }) + await core.connect() + + const upgrader = new ClientLiveTransportUpgrader({ + connectionId: 'conn-android-upg', + rpc: core, + channel: secure, + rtcFactory: factory, + }) + + expect(await upgrader.promote()).toBe(true) + expect(secure.getStats().mode).toBe('P2P') + + tier = 'LAN' + const p = upgrader.promote({ preferLan: true }) + await new Promise(resolve => setTimeout(resolve, 5)) + const inFlightRpc = core.rpc('harness.transport.describe', { during: 'activate' }) + const [ok, res] = await Promise.all([p, inFlightRpc]) + expect(ok).toBe(true) + expect(res).toEqual({ ok: true, echo: { during: 'activate' } }) + await new Promise(resolve => setTimeout(resolve, 30)) + expect(drainWatermarks.length).toBe(2) + expect(clientDcs[0]!.readyState).toBe('closed') + expect(closed).toBe(false) + expect(secure.getStats().mode).toBe('LAN') + + await upgrader.close() + await core.close() + }) +})