Import apps/android/tests/transport-upgrade-android.test.ts
This commit is contained in:
parent
35aa9799cb
commit
158245f3bc
|
|
@ -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<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()
|
||||
})
|
||||
})
|
||||
Loading…
Reference in New Issue