263 lines
12 KiB
TypeScript
263 lines
12 KiB
TypeScript
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<string, unknown> }>
|
|
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<string, unknown> }>
|
|
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()
|
|
})
|
|
})
|