404 lines
18 KiB
TypeScript
404 lines
18 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import { generateKeyPair, NoiseIkSession, createNoisePrologue } from '@dsh-remote/crypto'
|
|
import {
|
|
SequencedCiphertextReorderBuffer,
|
|
createRpcRequest,
|
|
createRpcResponse,
|
|
type RemoteMessage,
|
|
} from '@dsh-remote/protocol'
|
|
import { ClientLiveTransportUpgrader, RemoteClientCore, type UpgradeableSecureChannel } from '@dsh-remote/client-core'
|
|
import {
|
|
isSequencedOutboundTransport,
|
|
type RtcDataChannel,
|
|
type RtcPeerConnection,
|
|
type RtcPeerConnectionFactory,
|
|
type RtcStats,
|
|
type SequencedOutboundTransport,
|
|
} from '@dsh-remote/webrtc'
|
|
import { ServerNoiseChannel } from '../src/server-connection.js'
|
|
import { TransportUpgradeHost, wrapUpgradedTransportFrame, type TransportTier } from '../src/transport-upgrade.js'
|
|
|
|
function makeStats(tier: 'LAN' | 'P2P' | 'TURN' | 'unverified'): RtcStats {
|
|
if (tier === 'unverified') return new Map()
|
|
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' }],
|
|
])
|
|
}
|
|
|
|
function createPairedRtcFactories(hostTier: () => 'LAN' | 'P2P' | 'TURN' | 'unverified', clientTier?: () => 'LAN' | 'P2P' | 'TURN' | 'unverified') {
|
|
const pairs: Array<{ clientDc?: RtcDataChannel; hostDc?: RtcDataChannel; hostPcClosed: boolean; clientPcClosed: boolean; closeHostDc: () => void }> = []
|
|
let pendingPair: typeof pairs[number] | undefined
|
|
|
|
const clientFactory: RtcPeerConnectionFactory = {
|
|
create() {
|
|
const pair: typeof pairs[number] = { hostPcClosed: false, clientPcClosed: false, closeHostDc: () => undefined }
|
|
pairs.push(pair)
|
|
pendingPair = pair
|
|
const dc: RtcDataChannel = {
|
|
label: 'dsh', ordered: true, readyState: 'connecting', bufferedAmount: 0, binaryType: 'arraybuffer',
|
|
onopen: null, onmessage: null, onclose: null, onerror: null, onbufferedamountlow: null,
|
|
send: data => {
|
|
if (pair.hostDc && pair.hostDc.readyState === 'open') {
|
|
pair.hostDc.onmessage?.({ data })
|
|
}
|
|
},
|
|
close: () => { dc.readyState = 'closed'; dc.onclose?.() },
|
|
}
|
|
pair.clientDc = 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 () => {
|
|
pc.onicecandidate?.({ candidate: { candidate: 'candidate:1 1 udp 1 192.168.1.10 5000 typ host', sdpMid: '0' } })
|
|
},
|
|
setRemoteDescription: async () => {
|
|
queueMicrotask(() => {
|
|
if (pair.clientPcClosed || pair.hostPcClosed) return
|
|
dc.readyState = 'open'
|
|
dc.onopen?.()
|
|
if (pair.hostDc) {
|
|
pair.hostDc.readyState = 'open'
|
|
pair.hostDc.onopen?.()
|
|
}
|
|
})
|
|
},
|
|
addIceCandidate: async () => undefined,
|
|
getStats: async () => makeStats((clientTier ?? hostTier)()),
|
|
close: () => { pair.clientPcClosed = true; dc.readyState = 'closed' },
|
|
}
|
|
return pc
|
|
},
|
|
}
|
|
|
|
const hostFactory: RtcPeerConnectionFactory = {
|
|
create() {
|
|
const pair: typeof pairs[number] = pendingPair ?? { hostPcClosed: false, clientPcClosed: false, closeHostDc: () => undefined }
|
|
const dc: RtcDataChannel = {
|
|
label: 'dsh', ordered: true, readyState: 'connecting', bufferedAmount: 0, binaryType: 'arraybuffer',
|
|
onopen: null, onmessage: null, onclose: null, onerror: null, onbufferedamountlow: null,
|
|
send: data => {
|
|
if (pair.clientDc && pair.clientDc.readyState === 'open') {
|
|
pair.clientDc.onmessage?.({ data })
|
|
}
|
|
},
|
|
close: () => { dc.readyState = 'closed'; dc.onclose?.() },
|
|
}
|
|
pair.hostDc = dc
|
|
pair.closeHostDc = () => { dc.readyState = 'closed'; dc.onclose?.(); pair.clientDc?.onclose?.() }
|
|
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 () => {
|
|
pc.onicecandidate?.({ candidate: { candidate: 'candidate:2 1 udp 1 192.168.1.20 5000 typ host', sdpMid: '0' } })
|
|
pc.ondatachannel?.({ channel: dc })
|
|
},
|
|
setRemoteDescription: async () => undefined,
|
|
addIceCandidate: async () => undefined,
|
|
getStats: async () => makeStats(hostTier()),
|
|
close: () => { pair.hostPcClosed = true; dc.readyState = 'closed' },
|
|
}
|
|
return pc
|
|
},
|
|
}
|
|
|
|
return { clientFactory, hostFactory, pairs }
|
|
}
|
|
|
|
describe('In-band Transport Upgrade & Reorder / Drain Boundaries', () => {
|
|
it('strictly trusts Host ICE stats over inflated Client transport claims and rejects unverified paths', async () => {
|
|
let mode: TransportTier = 'Relay'
|
|
let hostObserved: 'LAN' | 'P2P' | 'TURN' | 'unverified' = 'TURN'
|
|
const { clientFactory, hostFactory } = createPairedRtcFactories(() => hostObserved, () => 'LAN')
|
|
|
|
const host = new TransportUpgradeHost({
|
|
connectionId: 'conn-strict',
|
|
peerDeviceId: 'peer-1',
|
|
currentMode: () => mode,
|
|
outboundCounter: () => 0,
|
|
loadRtcFactory: async () => hostFactory,
|
|
fetchIceServers: async () => [],
|
|
onReceiveSequencedCiphertext: () => undefined,
|
|
adoptRtc: async (_rtc, verified) => { mode = verified; return 0 },
|
|
publishEvent: async () => undefined,
|
|
})
|
|
|
|
// Client creates PC first (just like real initiator), claims 'lan', while Host ICE stats observe 'TURN'
|
|
const clientPc = clientFactory.create({})
|
|
clientPc.createDataChannel('dsh')
|
|
const ans = await host.offer({ attemptId: 'a1', sdp: 'v=0\r\noffer' })
|
|
await clientPc.setRemoteDescription({ type: 'answer', sdp: ans.sdp })
|
|
const res = await host.activate({ attemptId: 'a1', transport: 'lan', previousLegEndCounter: 0 })
|
|
expect(res.activated).toBe(true)
|
|
expect(res.mode).toBe('TURN')
|
|
expect(mode).toBe('TURN')
|
|
|
|
// Unverified stats on Host -> rejected cleanly without elevating tier
|
|
hostObserved = 'unverified'
|
|
const clientPc2 = clientFactory.create({})
|
|
clientPc2.createDataChannel('dsh')
|
|
const ans2 = await host.offer({ attemptId: 'a2', sdp: 'v=0\r\noffer2' })
|
|
await clientPc2.setRemoteDescription({ type: 'answer', sdp: ans2.sdp })
|
|
const res2 = await host.activate({ attemptId: 'a2', transport: 'lan' })
|
|
expect(res2.activated).toBe(false)
|
|
expect(mode).toBe('TURN')
|
|
|
|
await host.closeAll()
|
|
})
|
|
|
|
it('enforces reorder buffer frame limit, total byte budget, and gap timeout', async () => {
|
|
vi.useFakeTimers()
|
|
try {
|
|
let timedOutAt: number | undefined
|
|
const buf = new SequencedCiphertextReorderBuffer({
|
|
maxFrames: 3,
|
|
maxBytes: 100,
|
|
gapTimeoutMs: 500,
|
|
onGapTimeout: missing => { timedOutAt = missing },
|
|
})
|
|
|
|
buf.push(1, 0, new Uint8Array(40))
|
|
buf.push(2, 0, new Uint8Array(40))
|
|
// Exceeding maxBytes (40 + 40 + 30 > 100) throws immediately
|
|
expect(() => buf.push(3, 0, new Uint8Array(30))).toThrow(/exceeded its limit/)
|
|
// Duplicate buffered counter throws
|
|
expect(() => buf.push(1, 0, new Uint8Array(10))).toThrow(/Duplicate/)
|
|
|
|
// Gap timeout fires after 500ms if counter 0 never arrives
|
|
vi.advanceTimersByTime(499)
|
|
expect(timedOutAt).toBeUndefined()
|
|
vi.advanceTimersByTime(2)
|
|
expect(timedOutAt).toBe(0)
|
|
buf.clear()
|
|
} finally {
|
|
vi.useRealTimers()
|
|
}
|
|
})
|
|
|
|
it('reassembles out-of-order frames when fast upgraded WebRTC frames overtake trailing Relay frames and drains old WebRTC leg by counter watermark', async () => {
|
|
const hostKeys = generateKeyPair()
|
|
const clientKeys = generateKeyPair()
|
|
const connectionId = 'conn-reorder-1'
|
|
const prologue = createNoisePrologue(connectionId, 'host-1', 'client-1')
|
|
const clientNoise = new NoiseIkSession({
|
|
role: 'initiator',
|
|
localPrivateKey: clientKeys.privateKey,
|
|
localPublicKey: clientKeys.publicKey,
|
|
remotePublicKey: hostKeys.publicKey,
|
|
prologue,
|
|
})
|
|
const hostNoise = new NoiseIkSession({
|
|
role: 'responder',
|
|
localPrivateKey: hostKeys.privateKey,
|
|
localPublicKey: hostKeys.publicKey,
|
|
remotePublicKey: clientKeys.publicKey,
|
|
prologue,
|
|
})
|
|
hostNoise.readHandshake(clientNoise.writeHandshake())
|
|
clientNoise.readHandshake(hostNoise.writeHandshake())
|
|
|
|
const relaySentByHost: Uint8Array[] = []
|
|
const hostReceived: RemoteMessage[] = []
|
|
let channelClosed = false
|
|
const serverChannel = new ServerNoiseChannel(
|
|
{
|
|
connectionId,
|
|
membershipId: 'mem-1',
|
|
peer: { deviceId: 'client-1', name: 'Client', platform: 'android', publicKey: clientKeys.publicKey, membershipId: 'mem-1', trustedAt: '2026-01-01T00:00:00Z' },
|
|
preferredTransports: ['lan', 'p2p', 'relay'],
|
|
noise: hostNoise,
|
|
transport: 'relay',
|
|
} as never,
|
|
async cipher => { relaySentByHost.push(cipher) },
|
|
async () => { channelClosed = true },
|
|
'Relay',
|
|
)
|
|
serverChannel.onMessage(msg => hostReceived.push(msg))
|
|
|
|
// Client encrypts 3 messages: counter 0 (delayed on Relay), counter 1 & 2 (fast on upgraded P2P)
|
|
const encodeClientMsg = (id: string) => {
|
|
const req = createRpcRequest('harness.transport.describe', {})
|
|
req.id = id
|
|
return clientNoise.encrypt(new TextEncoder().encode(JSON.stringify(req)))
|
|
}
|
|
const c0 = encodeClientMsg('m0')
|
|
const c1 = encodeClientMsg('m1')
|
|
const c2 = encodeClientMsg('m2')
|
|
|
|
// Fast P2P frames c2 and c1 arrive BEFORE trailing Relay frame c0!
|
|
serverChannel.receive(2, c2)
|
|
serverChannel.receive(1, c1)
|
|
expect(hostReceived).toHaveLength(0)
|
|
|
|
// Trailing Relay frame c0 arrives -> all 3 decrypt strictly in order (m0, m1, m2)!
|
|
serverChannel.receive(0, c0)
|
|
expect(channelClosed).toBe(false)
|
|
expect(hostReceived.map(m => m.id)).toEqual(['m0', 'm1', 'm2'])
|
|
|
|
// Two-phase watermark draining of old WebRTC leg on P2P -> LAN switch:
|
|
let oldP2pDisposed = false
|
|
const fakeOldRtc = {} as never
|
|
const c3 = encodeClientMsg('m3') // counter 3 still in flight on old P2P leg
|
|
const c4 = encodeClientMsg('m4') // counter 4 sent on new LAN leg
|
|
await serverChannel.upgradeTransport('LAN', async () => undefined, fakeOldRtc, 'att-lan', () => { oldP2pDisposed = true })
|
|
// Never closed immediately during activate before Client switches outbound!
|
|
expect(oldP2pDisposed).toBe(false)
|
|
|
|
// Client confirms drain watermark = 4 over new LAN leg, and c4 arrives on LAN before trailing c3:
|
|
serverChannel.confirmPreviousLegDrain('att-lan', 4)
|
|
serverChannel.receive(4, c4)
|
|
expect(oldP2pDisposed).toBe(false)
|
|
|
|
// Trailing c3 arrives from old P2P leg -> receivingCounter reaches 5 >= 4, old P2P leg disposes immediately!
|
|
serverChannel.receive(3, c3)
|
|
expect(oldP2pDisposed).toBe(true)
|
|
expect(hostReceived.map(m => m.id)).toEqual(['m0', 'm1', 'm2', 'm3', 'm4'])
|
|
})
|
|
|
|
it('runs end-to-end ClientLiveTransportUpgrader + TransportUpgradeHost across Relay -> P2P -> LAN, concurrent supersede, abort race, and post-upgrade drop', async () => {
|
|
let currentNetTier: 'LAN' | 'P2P' | 'TURN' = 'P2P'
|
|
const { clientFactory, hostFactory, pairs } = createPairedRtcFactories(() => currentNetTier)
|
|
|
|
let hostMode: TransportTier = 'Relay'
|
|
let hostClosed = false
|
|
let clientClosed = false
|
|
let clientOutboundCounter = 0
|
|
let hostOutboundCounter = 0
|
|
let relaySentBytes = 120
|
|
let relayReceivedBytes = 340
|
|
let clientMsgHandler: ((data: Uint8Array) => void) | undefined
|
|
let hostUpgrade!: TransportUpgradeHost
|
|
|
|
const channel: UpgradeableSecureChannel = {
|
|
get outboundCounter() { return clientOutboundCounter },
|
|
attachIncomingLeg: () => undefined,
|
|
switchOutboundLeg: async () => clientOutboundCounter,
|
|
detachLeg: async leg => { await leg.close() },
|
|
relayTrafficBytes: () => ({ sent: relaySentBytes, received: relayReceivedBytes }),
|
|
}
|
|
|
|
// In-memory RPC bridge between RemoteClientCore and TransportUpgradeHost
|
|
const clientTransport = {
|
|
connect: async () => undefined,
|
|
send: async (bytes: Uint8Array) => {
|
|
clientOutboundCounter += 1
|
|
const msg = JSON.parse(new TextDecoder().decode(bytes)) as RemoteMessage<{ method: string; params: unknown }>
|
|
if (msg.type === 'rpc.request') {
|
|
let result: unknown
|
|
switch (msg.payload.method) {
|
|
case 'remote.transport.upgrade.offer': result = await hostUpgrade.offer(msg.payload.params); break
|
|
case 'remote.transport.upgrade.ice': result = await hostUpgrade.addIce(msg.payload.params); break
|
|
case 'remote.transport.upgrade.activate': result = await hostUpgrade.activate(msg.payload.params); break
|
|
case 'remote.transport.upgrade.drain': result = await hostUpgrade.drain(msg.payload.params); break
|
|
case 'remote.transport.upgrade.abort': result = await hostUpgrade.abort(msg.payload.params); break
|
|
}
|
|
const resp = createRpcResponse(msg.id, result)
|
|
hostOutboundCounter += 1
|
|
clientMsgHandler?.(new TextEncoder().encode(JSON.stringify(resp)))
|
|
}
|
|
},
|
|
onMessage: (cb: (data: Uint8Array) => void) => { clientMsgHandler = cb; return () => { clientMsgHandler = undefined } },
|
|
onClose: () => () => undefined,
|
|
close: async () => { clientClosed = true },
|
|
getStats: () => ({ mode: hostMode, connected: !clientClosed, bytesSent: 0, bytesReceived: 0 }),
|
|
}
|
|
|
|
const clientCore = new RemoteClientCore(clientTransport)
|
|
await clientCore.connect()
|
|
|
|
hostUpgrade = new TransportUpgradeHost({
|
|
connectionId: 'conn-e2e',
|
|
peerDeviceId: 'client-1',
|
|
currentMode: () => hostMode,
|
|
outboundCounter: () => hostOutboundCounter,
|
|
loadRtcFactory: async () => hostFactory,
|
|
fetchIceServers: async () => [],
|
|
onReceiveSequencedCiphertext: () => undefined,
|
|
adoptRtc: async (rtc, nextMode) => {
|
|
hostMode = nextMode
|
|
rtc.onClose(() => { hostClosed = true })
|
|
return hostOutboundCounter
|
|
},
|
|
publishEvent: async evt => {
|
|
clientMsgHandler?.(new TextEncoder().encode(JSON.stringify(evt)))
|
|
},
|
|
})
|
|
|
|
const telemetries: unknown[] = []
|
|
const upgrader = new ClientLiveTransportUpgrader({
|
|
connectionId: 'conn-e2e',
|
|
rpc: clientCore,
|
|
channel,
|
|
rtcFactory: clientFactory,
|
|
onTelemetry: t => telemetries.push(t),
|
|
})
|
|
|
|
// 1. Climb Relay -> P2P via waitForInitialWindow
|
|
const fastReady = await upgrader.waitForInitialWindow(500)
|
|
expect(fastReady).toBe(true)
|
|
expect(upgrader.currentMode).toBe('P2P')
|
|
expect(hostMode).toBe('P2P')
|
|
|
|
// 2. Same-tier P2P attempt is skipped cleanly without interrupting active P2P
|
|
const skipped = await upgrader.promote()
|
|
expect(skipped).toBe(false)
|
|
expect(upgrader.currentMode).toBe('P2P')
|
|
expect(hostClosed).toBe(false)
|
|
|
|
// 3. Climb P2P -> LAN when moving onto Wi-Fi
|
|
currentNetTier = 'LAN'
|
|
const climbedLan = await upgrader.promote({ preferLan: true })
|
|
expect(climbedLan).toBe(true)
|
|
expect(upgrader.currentMode).toBe('LAN')
|
|
expect(hostMode).toBe('LAN')
|
|
expect(telemetries.length).toBe(3)
|
|
|
|
// 4. Post-upgrade DataChannel drop triggers tunnel close (never silently pretends to fall back to Relay)
|
|
pairs[pairs.length - 1]!.closeHostDc()
|
|
expect(hostClosed).toBe(true)
|
|
|
|
await upgrader.close()
|
|
await hostUpgrade.closeAll()
|
|
await clientCore.close()
|
|
})
|
|
|
|
it('keeps existing Relay channel intact when pre-activation offer/abort/close fails or races', async () => {
|
|
let mode: TransportTier = 'Relay'
|
|
const { hostFactory } = createPairedRtcFactories(() => 'P2P')
|
|
const host = new TransportUpgradeHost({
|
|
connectionId: 'conn-race',
|
|
peerDeviceId: 'peer-1',
|
|
currentMode: () => mode,
|
|
outboundCounter: () => 0,
|
|
loadRtcFactory: async () => hostFactory,
|
|
fetchIceServers: async () => [],
|
|
onReceiveSequencedCiphertext: () => undefined,
|
|
adoptRtc: async (_rtc, next) => { mode = next; return 0 },
|
|
publishEvent: async () => undefined,
|
|
})
|
|
|
|
// Duplicate / concurrent offer supersedes the older attempt cleanly
|
|
await host.offer({ attemptId: 'old', sdp: 'v=0\r\noffer1' })
|
|
await host.offer({ attemptId: 'new', sdp: 'v=0\r\noffer2' })
|
|
await expect(host.activate({ attemptId: 'old' })).rejects.toThrow(/no longer active/)
|
|
|
|
// Abort before activate rejects subsequent activate while keeping Relay intact
|
|
await host.abort({ attemptId: 'new' })
|
|
await expect(host.activate({ attemptId: 'new' })).rejects.toThrow(/no longer active/)
|
|
expect(mode).toBe('Relay')
|
|
|
|
await host.closeAll()
|
|
})
|
|
})
|