1478 lines
76 KiB
TypeScript
1478 lines
76 KiB
TypeScript
import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs'
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { randomUUID, createHmac } from 'node:crypto'
|
|
import { once } from 'node:events'
|
|
import { createConnection } from 'node:net'
|
|
import { request as httpRequest } from 'node:http'
|
|
import { WebSocket } from 'ws'
|
|
import { MAX_CONTROL_FRAME_BYTES, createControlFrame } from '@dsh-remote/protocol'
|
|
import { NoiseIkSession, createNoisePrologue, generateKeyPair, toBase64Url, fromBase64Url } from '../../../packages/crypto/src/index.js'
|
|
import { AdaptiveTransport, RelayTransport, stunOnlyIceServers } from '../../../packages/webrtc/src/index.js'
|
|
import { ClientSecureTransport } from '../../../packages/plugin/src/client-secure-transport.js'
|
|
import { ClientServerApi } from '../../../packages/plugin/src/server-api.js'
|
|
import { IdentityStore } from '../../../packages/plugin/src/identity-store.js'
|
|
import { ServerCredentialStore } from '../../../packages/plugin/src/server-credentials.js'
|
|
import {
|
|
createRemoteServer,
|
|
normalizeGatewayOptions,
|
|
normalizeMaxFramesPerSec,
|
|
normalizeIp,
|
|
normalizeTrustedProxyIps,
|
|
parseHelloTimeout,
|
|
parseHeartbeatInterval,
|
|
parseHeartbeatDisconnect,
|
|
parseMaxFramesPerSec,
|
|
type Config,
|
|
} from '../src/server.js'
|
|
import {
|
|
Logger,
|
|
redactSensitive,
|
|
parseLogLevel,
|
|
type LogEntry,
|
|
} from '../src/logger.js'
|
|
import { MAX_ICE_CANDIDATES_PER_CONNECTION } from '../src/gateway.js'
|
|
import { parseIceConfig } from '../src/ice.js'
|
|
|
|
const account = 'owner@example.com', password = 'local-test-password'
|
|
let app: ReturnType<typeof createRemoteServer>, dir: string, base: string, accountToken: string
|
|
const sockets: WebSocket[] = []
|
|
const secureClients: ClientSecureTransport[] = []
|
|
const noiseSessions: NoiseIkSession[] = []
|
|
async function request(path: string, method = 'GET', body?: unknown, token?: string, headers = {}) {
|
|
const response = await fetch(`${base}/api/v1${path}`, { method, headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}), ...headers }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) })
|
|
return { status: response.status, data: await response.json(), headers: response.headers }
|
|
}
|
|
async function rawJsonRequest(path: string, body: string | Uint8Array, token?: string) {
|
|
const response = await fetch(`${base}/api/v1${path}`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
|
|
body,
|
|
})
|
|
return { status: response.status, data: await response.json() }
|
|
}
|
|
async function start(pass = password, trustedProxyIps: readonly string[] = [], configOverrides: Partial<Config> = {}) {
|
|
app = createRemoteServer({ account, password: pass, dataFile: join(dir, 'state.json'), publicUrl: 'http://localhost:8080', trustedProxyIps, ...configOverrides })
|
|
app.server.listen(0, '127.0.0.1'); await once(app.server, 'listening')
|
|
base = `http://127.0.0.1:${(app.server.address() as { port: number }).port}`
|
|
}
|
|
/** Send a raw HTTP/1.1 request so duplicate header lines stay separate (fetch merges them). */
|
|
async function rawStatus(headerLines: string[]): Promise<number> {
|
|
const port = (app.server.address() as { port: number }).port
|
|
const crlf = String.fromCharCode(13, 10)
|
|
const lines = [
|
|
'GET /api/v1/auth/me HTTP/1.1',
|
|
`Host: 127.0.0.1:${port}`,
|
|
...headerLines,
|
|
'Connection: close',
|
|
'',
|
|
'',
|
|
]
|
|
return await new Promise<number>((resolve, reject) => {
|
|
const socket = createConnection(port, '127.0.0.1')
|
|
const timer = setTimeout(() => { socket.destroy(); reject(new Error('raw request timed out')) }, 5000)
|
|
let buffer = ''
|
|
socket.on('connect', () => socket.write(lines.join(crlf)))
|
|
socket.on('data', chunk => {
|
|
buffer += chunk.toString('utf8')
|
|
const match = /^HTTP[/]1[.][01] ([0-9]{3})/.exec(buffer)
|
|
if (!match) return
|
|
clearTimeout(timer); socket.destroy(); resolve(Number(match[1]))
|
|
})
|
|
socket.on('error', error => { clearTimeout(timer); reject(error) })
|
|
})
|
|
}
|
|
async function device(role: 'host' | 'client' = 'client') {
|
|
const keys = generateKeyPair()
|
|
const descriptor = { deviceId: randomUUID(), identityKey: keys.publicKey, name: 'test-device', role, platform: 'linux', clientVersion: '0.4.15' }
|
|
const result = await request('/devices/register', 'POST', { v: 1, device: descriptor }, accountToken)
|
|
expect(result.status).toBe(200)
|
|
return { ...descriptor, keys, ...result.data }
|
|
}
|
|
class Wire {
|
|
messages: any[] = []
|
|
waiters: (() => void)[] = []
|
|
constructor(readonly ws: WebSocket) { ws.on('message', raw => { this.messages.push(JSON.parse(raw.toString())); for (const notify of this.waiters.splice(0)) notify() }) }
|
|
send(type: Parameters<typeof createControlFrame>[0], payload: unknown) { this.ws.send(JSON.stringify(createControlFrame(type, payload))) }
|
|
async next(type: string): Promise<any> {
|
|
const until = Date.now() + 3000
|
|
while (Date.now() < until) {
|
|
const idx = this.messages.findIndex(m => m.type === type)
|
|
if (idx >= 0) return this.messages.splice(idx, 1)[0].payload
|
|
await new Promise<void>(resolve => { const timer = setTimeout(resolve, 50); this.waiters.push(() => { clearTimeout(timer); resolve() }) })
|
|
}
|
|
throw new Error(`Missing frame ${type}`)
|
|
}
|
|
}
|
|
const fullCapabilities = ['transport.lan', 'transport.p2p', 'transport.turn', 'transport.relay']
|
|
const fullPreferredTransports = ['lan', 'p2p', 'turn', 'relay']
|
|
async function socket(d: Awaited<ReturnType<typeof device>>, overrides = {}) {
|
|
const ws = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect'); sockets.push(ws)
|
|
const wire = new Wire(ws); await once(ws, 'open')
|
|
wire.send('hello', { role: d.role, deviceId: d.deviceId, accessToken: d.accessToken, protocols: [1], capabilities: fullCapabilities, clientVersion: d.clientVersion, ...overrides })
|
|
return wire
|
|
}
|
|
async function connection(options: { hostCapabilities?: string[]; clientCapabilities?: string[]; preferredTransports?: string[] } = {}) {
|
|
const h = await device('host'), c = await device()
|
|
const host = await socket(h, options.hostCapabilities === undefined ? {} : { capabilities: options.hostCapabilities })
|
|
const client = await socket(c, options.clientCapabilities === undefined ? {} : { capabilities: options.clientCapabilities })
|
|
const ack = await host.next('hello.ack')
|
|
expect(ack).toMatchObject({ webrtcEnabled: true })
|
|
expect(ack.capabilities).toEqual(expect.arrayContaining(['transport.relay']))
|
|
await client.next('hello.ack')
|
|
client.send('connect.request', { hostDeviceId: h.deviceId, preferredTransports: options.preferredTransports ?? ['relay'] })
|
|
const incoming = await host.next('connect.incoming')
|
|
expect(incoming.clientIdentityKey).toBe(c.identityKey)
|
|
host.send('connect.accepted', { connectionId: incoming.connectionId })
|
|
const { connectionId } = await client.next('connect.accepted')
|
|
return { h, c, host, client, connectionId, incoming }
|
|
}
|
|
async function handshake(ctx: Awaited<ReturnType<typeof connection>>) {
|
|
const { h, c, host, client, connectionId } = ctx
|
|
const prologue = createNoisePrologue(connectionId, h.deviceId, c.deviceId)
|
|
const initiator = new NoiseIkSession({ role: 'initiator', localPrivateKey: c.keys.privateKey, localPublicKey: c.identityKey, remotePublicKey: h.identityKey, prologue })
|
|
const responder = new NoiseIkSession({ role: 'responder', localPrivateKey: h.keys.privateKey, localPublicKey: h.identityKey, remotePublicKey: c.identityKey, prologue })
|
|
noiseSessions.push(initiator, responder)
|
|
client.send('secure.handshake', { connectionId, targetDeviceId: h.deviceId, step: 1, data: toBase64Url(initiator.writeHandshake()) })
|
|
responder.readHandshake(fromBase64Url((await host.next('secure.handshake')).data))
|
|
host.send('secure.handshake', { connectionId, targetDeviceId: c.deviceId, step: 2, data: toBase64Url(responder.writeHandshake()) })
|
|
initiator.readHandshake(fromBase64Url((await client.next('secure.handshake')).data))
|
|
return { initiator, responder }
|
|
}
|
|
async function secureConnection() {
|
|
const h = await device('host'), c = await device(), host = await socket(h)
|
|
await host.next('hello.ack')
|
|
const relay = new RelayTransport(base.replace('http:', 'ws:') + '/ws/v1/connect', {
|
|
role: 'client', deviceId: c.deviceId, accessToken: c.accessToken, targetDeviceId: h.deviceId,
|
|
})
|
|
const secure = new ClientSecureTransport(relay, {
|
|
schemaVersion: 1, deviceId: c.deviceId, name: c.name, ...c.keys, fingerprint: 'test-client',
|
|
}, {
|
|
deviceId: h.deviceId, name: h.name, platform: h.platform, publicKey: h.identityKey,
|
|
fingerprint: 'test-host', trustedAt: Date.now(),
|
|
})
|
|
secureClients.push(secure)
|
|
const received: string[] = []
|
|
secure.onMessage(data => received.push(new TextDecoder().decode(data)))
|
|
const connecting = secure.connect().then(() => undefined, error => error as Error)
|
|
const incoming = await host.next('connect.incoming')
|
|
const connectionId: string = incoming.connectionId
|
|
host.send('connect.accepted', { connectionId })
|
|
const responder = new NoiseIkSession({
|
|
role: 'responder', localPrivateKey: h.keys.privateKey, localPublicKey: h.identityKey,
|
|
remotePublicKey: c.identityKey, prologue: createNoisePrologue(connectionId, h.deviceId, c.deviceId),
|
|
})
|
|
noiseSessions.push(responder)
|
|
const first = await host.next('secure.handshake')
|
|
expect(first).toMatchObject({ connectionId, targetDeviceId: h.deviceId, step: 1 })
|
|
responder.readHandshake(fromBase64Url(first.data))
|
|
host.send('secure.handshake', { connectionId, targetDeviceId: c.deviceId, step: 2, data: toBase64Url(responder.writeHandshake()) })
|
|
const error = await connecting
|
|
if (error) throw error
|
|
return { h, c, host, secure, responder, connectionId, received }
|
|
}
|
|
const prepareScenario1 = async () => {
|
|
dir = mkdtempSync(join(tmpdir(), 'dsh-server-'))
|
|
await start()
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
}
|
|
beforeEach(prepareScenario1)
|
|
const cleanupScenario2 = async () => {
|
|
for (const secure of secureClients.splice(0)) await secure.close()
|
|
for (const noise of noiseSessions.splice(0)) noise.destroy()
|
|
for (const ws of sockets.splice(0)) ws.terminate()
|
|
await app.close()
|
|
rmSync(dir, { recursive: true, force: true })
|
|
}
|
|
afterEach(cleanupScenario2)
|
|
|
|
describe('account and device authorization', () => {
|
|
it('rejects duplicate REST fields before authentication or state changes', async () => {
|
|
const d = await device()
|
|
const registration = JSON.stringify({ v: 1, device: {
|
|
deviceId: randomUUID(), identityKey: generateKeyPair().publicKey,
|
|
name: 'new-device', role: 'client', platform: 'linux', clientVersion: '0.6.4',
|
|
} })
|
|
const cases = [
|
|
{ path: '/auth/login', body: JSON.stringify({ email: account, password }).replace('"password":', '"password":"wrong","password":') },
|
|
{ path: '/auth/login', body: JSON.stringify({ email: account, password }).replace('"password":', '"pass\\u0077ord":"wrong","password":') },
|
|
{ path: '/devices/register', body: registration.replace('"identityKey":', '"identityKey":"wrong","identityKey":'), token: accountToken },
|
|
{ path: '/auth/refresh', body: JSON.stringify({ deviceId: d.deviceId, refreshToken: d.refreshToken }).replace('"refreshToken":', '"refreshToken":"wrong","refreshToken":') },
|
|
{ path: `/devices/${d.deviceId}/name`, body: '{"name":"first","name":"second"}', token: accountToken },
|
|
{ path: '/auth/login', body: Uint8Array.from([0xc0, 0xaf]) },
|
|
]
|
|
for (const entry of cases) {
|
|
const result = await rawJsonRequest(entry.path, entry.body, entry.token)
|
|
expect(result.status).toBe(400)
|
|
expect(result.data.error.code).toBe('INVALID_MESSAGE')
|
|
}
|
|
const devices = await request('/account/devices', 'GET', undefined, accountToken)
|
|
expect(devices.data.items).toHaveLength(1)
|
|
expect(devices.data.items[0].name).toBe('test-device')
|
|
})
|
|
it('rejects a noncanonical registered X25519 public key', async () => {
|
|
const keys = generateKeyPair()
|
|
const descriptor = {
|
|
deviceId: randomUUID(), identityKey: `${keys.publicKey.slice(0, -1)}B`,
|
|
name: 'invalid-key', role: 'client', platform: 'linux', clientVersion: '0.6.4',
|
|
}
|
|
const result = await request('/devices/register', 'POST', { v: 1, device: descriptor }, accountToken)
|
|
expect(result.status).toBe(400)
|
|
expect(result.data.error.code).toBe('INVALID_MESSAGE')
|
|
})
|
|
it('separates account, cookie and device credentials; rejects cross-origin requests', async () => {
|
|
expect((await request('/auth/login', 'POST', { email: account, password: 'wrong' })).status).toBe(401)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, { Origin: 'https://attacker.example' })).status).toBe(403)
|
|
const d = await device()
|
|
expect((await request('/auth/me', 'GET', undefined, d.accessToken)).status).toBe(401)
|
|
expect((await request('/devices', 'GET', undefined, accountToken)).status).toBe(401)
|
|
expect((await request('/devices/register', 'POST', { v: 1, device: d })).status).toBe(401)
|
|
const login = await request('/auth/login', 'POST', { email: account, password })
|
|
const cookie = login.headers.get('set-cookie')!.split(';')[0]!
|
|
expect(login.headers.get('set-cookie')).toContain('HttpOnly')
|
|
expect((await request('/account/devices', 'GET', undefined, undefined, { Cookie: cookie })).status).toBe(200)
|
|
await request('/auth/logout', 'POST', {}, undefined, { Cookie: cookie })
|
|
expect((await request('/auth/me', 'GET', undefined, login.data.token)).status).toBe(401)
|
|
})
|
|
it('pins identity and requires distinct opposite-role registration', async () => {
|
|
const h = await device('host'), c = await device()
|
|
const changed = { deviceId: h.deviceId, name: h.name, role: h.role, platform: h.platform, clientVersion: h.clientVersion, identityKey: c.identityKey }
|
|
expect((await request('/devices/register', 'POST', { v: 1, device: changed }, accountToken)).data.error.code).toBe('PEER_IDENTITY_MISMATCH')
|
|
expect((await request(`/devices/${h.deviceId}`, 'GET', undefined, c.accessToken)).data.identityKey).toBe(h.identityKey)
|
|
expect((await request(`/devices/${c.deviceId}`, 'GET', undefined, c.accessToken)).status).toBe(403)
|
|
const descriptor = { ...changed, deviceId: randomUUID() }
|
|
expect((await request('/devices/register-owned-role', 'POST', { v: 1, device: descriptor }, h.accessToken)).status).toBe(409)
|
|
expect((await request('/devices/register-owned-role', 'POST', { v: 1, device: descriptor }, c.accessToken)).status).toBe(200)
|
|
})
|
|
it('recovers a lost refresh response across restart without invalidating the successor', async () => {
|
|
const d = await device()
|
|
const saved = readFileSync(join(dir, 'state.json'), 'utf8')
|
|
expect(saved).not.toContain(d.refreshToken); expect(saved).not.toContain(d.accessToken); expect(saved).not.toContain(password)
|
|
await app.close(); await start()
|
|
expect((await request('/devices', 'GET', undefined, d.accessToken)).status).toBe(200)
|
|
// Discard the successful response body, as when the link drops after commit.
|
|
await new Promise<void>((resolve, reject) => {
|
|
const req = httpRequest(base + '/api/v1/auth/refresh', { method: 'POST', headers: { 'Content-Type': 'application/json' } }, res => {
|
|
const status = res.statusCode
|
|
res.destroy()
|
|
if (status === 200) resolve()
|
|
else reject(new Error('Expected successful rotation before response loss'))
|
|
})
|
|
req.on('error', reject)
|
|
req.end(JSON.stringify({ deviceId: d.deviceId, refreshToken: d.refreshToken }))
|
|
})
|
|
await app.close(); await start()
|
|
const rotated = await request('/auth/refresh', 'POST', { deviceId: d.deviceId, refreshToken: d.refreshToken })
|
|
expect(rotated.status).toBe(200)
|
|
expect(rotated.data.refreshTokenExpiresAt).toBe(d.refreshTokenExpiresAt)
|
|
const retries = await Promise.all(Array.from({ length: 3 }, () => request('/auth/refresh', 'POST', { deviceId: d.deviceId, refreshToken: d.refreshToken })))
|
|
for (const retry of retries) { expect(retry.status).toBe(200); expect(retry.data).toEqual(rotated.data) }
|
|
expect((await request('/devices', 'GET', undefined, rotated.data.accessToken)).status).toBe(200)
|
|
const next = await request('/auth/refresh', 'POST', { deviceId: d.deviceId, refreshToken: rotated.data.refreshToken })
|
|
expect(next.status).toBe(200)
|
|
expect((await request('/auth/refresh', 'POST', { deviceId: d.deviceId, refreshToken: d.refreshToken })).status).toBe(401)
|
|
expect((await request('/devices', 'GET', undefined, next.data.accessToken)).status).toBe(200)
|
|
const persisted = readFileSync(join(dir, 'state.json'), 'utf8')
|
|
for (const value of [d.accessToken, d.refreshToken, rotated.data.accessToken, rotated.data.refreshToken, next.data.refreshToken]) {
|
|
expect(persisted).not.toContain(value)
|
|
}
|
|
})
|
|
it('lets the Plugin recover a dropped refresh response without signing in again, even after access expiry', async () => {
|
|
await runScenarios([0, 2 * 60 * 60_000].map(delay => ({
|
|
name: delay === 0 ? 'immediate retry' : 'two hours offline', run: async () => {
|
|
const identity = await new IdentityStore({ directory: join(dir, `identity-${delay}`) }).loadOrCreate('test')
|
|
const credentials = new ServerCredentialStore(join(dir, `client-${delay}`))
|
|
let loseResponse = true, logins = 0, registrations = 0
|
|
const api = new ClientServerApi(base, credentials, async (url, init) => {
|
|
if (url.endsWith('/auth/login')) logins++
|
|
if (url.endsWith('/devices/register')) registrations++
|
|
const response = await fetch(url, init)
|
|
if (loseResponse && url.endsWith('/auth/refresh')) {
|
|
loseResponse = false
|
|
expect(response.status).toBe(200)
|
|
await response.arrayBuffer()
|
|
throw new TypeError('Simulated response loss after Server commit')
|
|
}
|
|
return response
|
|
})
|
|
await api.authorizeWithAccount(identity, account, password)
|
|
const before = await credentials.load(base, identity.deviceId)
|
|
await expect(api.refreshCredentials()).rejects.toMatchObject({ code: 'CONNECTION_FAILED', phase: 'credential_refresh' })
|
|
expect(await credentials.load(base, identity.deviceId)).toEqual(before)
|
|
const now = Date.now() + delay
|
|
const clock = vi.spyOn(Date, 'now').mockReturnValue(now)
|
|
try {
|
|
if (delay === 0) await api.refreshCredentials()
|
|
else expect((await api.authenticate(identity)).accessTokenExpiresAt).toBeGreaterThan(now)
|
|
await expect(api.listDevices()).resolves.toEqual([])
|
|
const recovered = await credentials.load(base, identity.deviceId)
|
|
expect(recovered?.refreshToken).not.toBe(before?.refreshToken)
|
|
expect(recovered?.accessTokenExpiresAt).toBeGreaterThan(now)
|
|
expect(recovered?.refreshTokenExpiresAt).toBe(before?.refreshTokenExpiresAt)
|
|
expect(logins).toBe(1); expect(registrations).toBe(1)
|
|
} finally { clock.mockRestore() }
|
|
},
|
|
})))
|
|
})
|
|
it('invalidates credentials when the configured password changes', async () => {
|
|
const d = await device(); await app.close(); await start('a-different-password')
|
|
expect((await request('/devices', 'GET', undefined, d.accessToken)).status).toBe(401)
|
|
expect((await request('/auth/refresh', 'POST', { deviceId: d.deviceId, refreshToken: d.refreshToken })).status).toBe(401)
|
|
})
|
|
})
|
|
describe('control authorization and encrypted relay', () => {
|
|
it('rejects invalid Control messages at the WebSocket boundary', async () => {
|
|
await runScenarios(['unsupported-version', 'binary-control', 'oversized-control', 'unknown-frame-type', 'duplicate-payload-field', 'noncanonical-handshake'].map(reason => ({
|
|
name: reason,
|
|
run: async () => {
|
|
const wire = await socket(await device())
|
|
await wire.next('hello.ack')
|
|
const closed = once(wire.ws, 'close')
|
|
const frame = {
|
|
...createControlFrame(reason === 'noncanonical-handshake' ? 'secure.handshake' : 'ping',
|
|
reason === 'noncanonical-handshake'
|
|
? { connectionId: randomUUID(), targetDeviceId: randomUUID(), step: 1, data: 'AQIDBB' }
|
|
: { nonce: reason === 'oversized-control' ? 'a'.repeat(MAX_CONTROL_FRAME_BYTES) : 'test' }),
|
|
...(reason === 'unsupported-version' ? { v: 2 } : {}),
|
|
...(reason === 'unknown-frame-type' ? { type: 'unknown' } : {}),
|
|
}
|
|
const encoded = JSON.stringify(frame)
|
|
wire.ws.send(reason === 'duplicate-payload-field'
|
|
? encoded.replace('"nonce":', '"nonce":"other","nonce":')
|
|
: encoded, { binary: reason === 'binary-control' })
|
|
expect((await wire.next('error')).code).toBe(reason === 'unsupported-version' ? 'UNSUPPORTED_VERSION' : 'INVALID_MESSAGE')
|
|
expect((await closed)[0]).toBe(4001)
|
|
},
|
|
})), async () => {
|
|
await cleanupScenario2()
|
|
await prepareScenario1()
|
|
})
|
|
})
|
|
it('relays real Noise IK ciphertext and rejects replay', async () => {
|
|
const ctx = await connection(), { initiator, responder } = await handshake(ctx)
|
|
const ciphertext = toBase64Url(initiator.encrypt(new TextEncoder().encode('private prompt')))
|
|
const payload = { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, counter: 0, ciphertext }
|
|
ctx.client.send('relay', payload)
|
|
const received = await ctx.host.next('relay')
|
|
expect(received.ciphertext).not.toContain('private prompt')
|
|
expect(new TextDecoder().decode(responder.decrypt(fromBase64Url(received.ciphertext)))).toBe('private prompt')
|
|
ctx.client.send('relay', payload)
|
|
expect((await ctx.client.next('error')).code).toBe('INVALID_MESSAGE')
|
|
})
|
|
it('rejects unauthorized relay routes', async () => {
|
|
const rows = ['wrong-target', 'third-device', 'unknown-connection', 'before-handshake'] as const
|
|
await runScenarios(
|
|
rows.map((row, index) => {
|
|
const reason = row
|
|
return {
|
|
name: scenarioName('rejects unauthorized relay: %s', row, index),
|
|
run: async () => {
|
|
const ctx = await connection()
|
|
if (reason !== 'before-handshake') await handshake(ctx)
|
|
const attacker = reason === 'third-device' ? await socket(await device()) : ctx.client
|
|
if (reason === 'third-device') await attacker.next('hello.ack')
|
|
attacker.send('relay', {
|
|
connectionId: reason === 'unknown-connection' ? randomUUID() : ctx.connectionId,
|
|
targetDeviceId: reason === 'wrong-target' ? randomUUID() : ctx.h.deviceId,
|
|
counter: 0,
|
|
ciphertext: 'AQIDBA',
|
|
})
|
|
expect((await attacker.next('error')).code).toBe(reason === 'before-handshake' ? 'INVALID_MESSAGE' : 'CONNECTION_NOT_FOUND')
|
|
ctx.host.send('ping', { nonce: 'route-check' })
|
|
await ctx.host.next('pong')
|
|
expect(ctx.host.messages.filter((m) => m.type === 'relay')).toHaveLength(0)
|
|
},
|
|
}
|
|
}),
|
|
async () => {
|
|
await cleanupScenario2()
|
|
await prepareScenario1()
|
|
},
|
|
)
|
|
})
|
|
it('closes the production Client secure channel after relayed tampering or ciphertext replay', async () => {
|
|
await runScenarios(['tamper', 'replay-with-new-counter'].map(reason => ({
|
|
name: reason,
|
|
run: async () => {
|
|
const ctx = await secureConnection()
|
|
await ctx.secure.send(new TextEncoder().encode('synthetic request'))
|
|
const request = await ctx.host.next('relay')
|
|
expect(new TextDecoder().decode(ctx.responder.decrypt(fromBase64Url(request.ciphertext)))).toBe('synthetic request')
|
|
const ciphertext = ctx.responder.encrypt(new TextEncoder().encode('synthetic response'))
|
|
const payload = { connectionId: ctx.connectionId, targetDeviceId: ctx.c.deviceId, counter: 0, ciphertext: toBase64Url(ciphertext) }
|
|
if (reason === 'replay-with-new-counter') {
|
|
ctx.host.send('relay', payload)
|
|
await expect.poll(() => ctx.received, { timeout: 3000, interval: 50 }).toEqual(['synthetic response'])
|
|
payload.counter = 1
|
|
} else {
|
|
ciphertext[ciphertext.length - 1]! ^= 1
|
|
payload.ciphertext = toBase64Url(ciphertext)
|
|
}
|
|
const before = ctx.secure.getStats().bytesReceived ?? 0
|
|
ctx.host.send('relay', payload)
|
|
await expect.poll(() => ctx.secure.getStats().bytesReceived, { timeout: 3000, interval: 50 })
|
|
.toBe(before + fromBase64Url(payload.ciphertext).byteLength)
|
|
await expect.poll(() => ctx.secure.getStats().connected, { timeout: 3000, interval: 50 }).toBe(false)
|
|
expect(ctx.received).toEqual(reason === 'tamper' ? [] : ['synthetic response'])
|
|
await expect(ctx.secure.send(new Uint8Array([1]))).rejects.toThrow('The authenticated Noise channel is not connected.')
|
|
// The Host keeps its Control socket after one Client channel fails.
|
|
ctx.host.send('ping', { nonce: 'host-still-online' })
|
|
expect(await ctx.host.next('pong')).toEqual({ nonce: 'host-still-online' })
|
|
},
|
|
})), async () => {
|
|
await cleanupScenario2()
|
|
await prepareScenario1()
|
|
})
|
|
}, 15000)
|
|
it('rejects a relayed initiator whose static identity or connection prologue differs from local trust', async () => {
|
|
await runScenarios(['wrong-static-key', 'wrong-prologue'].map(reason => ({
|
|
name: reason,
|
|
run: async () => {
|
|
const ctx = await connection()
|
|
const prologue = createNoisePrologue(ctx.connectionId, ctx.h.deviceId, ctx.c.deviceId)
|
|
const initiator = new NoiseIkSession({
|
|
role: 'initiator', localPrivateKey: ctx.c.keys.privateKey, localPublicKey: ctx.c.identityKey,
|
|
remotePublicKey: ctx.h.identityKey, prologue,
|
|
})
|
|
const responder = new NoiseIkSession({
|
|
role: 'responder', localPrivateKey: ctx.h.keys.privateKey, localPublicKey: ctx.h.identityKey,
|
|
remotePublicKey: reason === 'wrong-static-key' ? generateKeyPair().publicKey : ctx.c.identityKey,
|
|
prologue: reason === 'wrong-prologue' ? createNoisePrologue(randomUUID(), ctx.h.deviceId, ctx.c.deviceId) : prologue,
|
|
})
|
|
noiseSessions.push(initiator, responder)
|
|
ctx.client.send('secure.handshake', {
|
|
connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, step: 1, data: toBase64Url(initiator.writeHandshake()),
|
|
})
|
|
const received = await ctx.host.next('secure.handshake')
|
|
const read = () => responder.readHandshake(fromBase64Url(received.data))
|
|
if (reason === 'wrong-static-key') expect(read).toThrow(/static key/)
|
|
else expect(read).toThrow()
|
|
expect(responder.complete).toBe(false)
|
|
expect(() => responder.encrypt(new Uint8Array([1]))).toThrow()
|
|
ctx.client.send('relay', {
|
|
connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, counter: 0, ciphertext: 'AQIDBA',
|
|
})
|
|
expect((await ctx.client.next('error')).code).toBe('INVALID_MESSAGE')
|
|
ctx.host.send('ping', { nonce: 'handshake-check' })
|
|
await ctx.host.next('pong')
|
|
expect(ctx.host.messages.filter(m => m.type === 'relay')).toHaveLength(0)
|
|
},
|
|
})), async () => {
|
|
await cleanupScenario2()
|
|
await prepareScenario1()
|
|
})
|
|
})
|
|
it('rejects account tokens and mismatched device roles in hello', async () => {
|
|
const d = await device()
|
|
expect((await (await socket(d, { accessToken: accountToken })).next('error')).code).toBe('AUTH_INVALID')
|
|
expect((await (await socket(d, { role: 'host' })).next('error')).code).toBe('AUTH_INVALID')
|
|
})
|
|
it('replaces a device socket without removing the new connection', async () => {
|
|
const d = await device(), old = await socket(d); await old.next('hello.ack')
|
|
const closed = once(old.ws, 'close'), current = await socket(d)
|
|
await current.next('hello.ack'); expect((await closed)[0]).toBe(4003)
|
|
current.send('ping', { nonce: 'new-socket' }); expect(await current.next('pong')).toEqual({ nonce: 'new-socket' })
|
|
})
|
|
it('keeps concurrent clients isolated and tears down revoked connections', async () => {
|
|
const ctx = await connection(), second = await device(), wire = await socket(second); await wire.next('hello.ack')
|
|
wire.send('connect.request', { hostDeviceId: ctx.h.deviceId, preferredTransports: ['relay'] })
|
|
const incoming = await ctx.host.next('connect.incoming')
|
|
ctx.host.send('connect.accepted', { connectionId: incoming.connectionId }); await wire.next('connect.accepted')
|
|
expect(ctx.client.messages.filter(m => m.type === 'error')).toHaveLength(0)
|
|
await handshake(ctx)
|
|
const closed = once(wire.ws, 'close')
|
|
expect((await request('/devices/self', 'DELETE', undefined, second.accessToken)).status).toBe(200)
|
|
await closed
|
|
expect(await ctx.host.next('error')).toMatchObject({ connectionId: incoming.connectionId })
|
|
expect((await request('/devices', 'GET', undefined, second.accessToken)).status).toBe(401)
|
|
})
|
|
})
|
|
|
|
|
|
describe('webrtc signaling and TURN credentials', () => {
|
|
const candidate = (index: number) => ({
|
|
candidate: `candidate:${index} 1 udp 2122260223 192.0.2.1 ${50000 + index} typ host`,
|
|
sdpMid: '0',
|
|
sdpMLineIndex: 0,
|
|
})
|
|
|
|
it('advertises the negotiated WebRTC transports and only enables TURN when configured', async () => {
|
|
const partial = await socket(await device(), { capabilities: ['transport.p2p', 'transport.relay'] })
|
|
expect(await partial.next('hello.ack')).toMatchObject({
|
|
capabilities: ['transport.p2p', 'transport.relay'],
|
|
webrtcEnabled: true,
|
|
webrtcFallbackTimeoutMs: 12_000,
|
|
})
|
|
const withoutTurn = await socket(await device(), { capabilities: fullCapabilities })
|
|
expect(await withoutTurn.next('hello.ack')).toMatchObject({
|
|
capabilities: ['transport.lan', 'transport.p2p', 'transport.relay'],
|
|
})
|
|
await app.close()
|
|
await start(password, [], {
|
|
ice: {
|
|
stunUrls: ['stun:stun.example.test:3478'],
|
|
turnUrls: ['turn:turn.example.test:3478?transport=udp'],
|
|
turnSecret: 'test-turn-secret',
|
|
turnTtlSeconds: 120,
|
|
},
|
|
})
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const withTurn = await socket(await device(), { capabilities: fullCapabilities })
|
|
expect(await withTurn.next('hello.ack')).toMatchObject({ capabilities: fullCapabilities })
|
|
})
|
|
|
|
it('forwards ordered WebRTC signaling and transport selection', async () => {
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
ctx.client.send('signal.offer', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, sdp: 'v=0 offer' })
|
|
expect(await ctx.host.next('signal.offer')).toMatchObject({ connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId })
|
|
ctx.host.send('signal.answer', { connectionId: ctx.connectionId, targetDeviceId: ctx.c.deviceId, sdp: 'v=0 answer' })
|
|
expect(await ctx.client.next('signal.answer')).toMatchObject({ sdp: 'v=0 answer' })
|
|
for (let index = 0; index < 3; index++) {
|
|
ctx.client.send('signal.ice', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, candidate: candidate(index) })
|
|
}
|
|
for (let index = 0; index < 3; index++) {
|
|
expect((await ctx.host.next('signal.ice')).candidate).toEqual(candidate(index))
|
|
}
|
|
ctx.client.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, transport: 'lan' })
|
|
expect(await ctx.host.next('transport.selected')).toMatchObject({ transport: 'lan' })
|
|
})
|
|
|
|
it('downgrades LAN to P2P for a host that did not negotiate transport.lan', async () => {
|
|
const ctx = await connection({ hostCapabilities: ['transport.p2p', 'transport.relay'], clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
ctx.client.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, transport: 'lan' })
|
|
expect(await ctx.host.next('transport.selected')).toMatchObject({ transport: 'p2p' })
|
|
})
|
|
|
|
it('tolerates a responder transport selection without dropping the link', async () => {
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
ctx.client.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, transport: 'lan' })
|
|
expect(await ctx.host.next('transport.selected')).toMatchObject({ transport: 'lan' })
|
|
// The Host (responder) also announces its own selection; it must be
|
|
// ignored rather than treated as an invalid frame that drops the link.
|
|
ctx.host.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.c.deviceId, transport: 'p2p' })
|
|
ctx.client.send('ping', { nonce: 'responder-selection' })
|
|
expect(await ctx.client.next('pong')).toEqual({ nonce: 'responder-selection' })
|
|
expect(ctx.client.messages.filter(message => message.type === 'error')).toHaveLength(0)
|
|
})
|
|
|
|
it('does not forward signaling to a host that cannot use WebRTC', async () => {
|
|
const ctx = await connection({ hostCapabilities: ['transport.relay'], clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
ctx.client.send('signal.offer', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, sdp: 'v=0 offer' })
|
|
ctx.client.send('signal.ice', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, candidate: candidate(0) })
|
|
await new Promise(resolve => setTimeout(resolve, 100))
|
|
expect(ctx.host.messages.filter(message => message.type === 'signal.offer' || message.type === 'signal.ice')).toHaveLength(0)
|
|
await handshake(ctx)
|
|
ctx.client.send('relay', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, counter: 0, ciphertext: 'AQIDBA' })
|
|
expect(await ctx.host.next('relay')).toMatchObject({ connectionId: ctx.connectionId })
|
|
})
|
|
|
|
it('drops signaling on a relay-only link without closing the connection', async () => {
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities, preferredTransports: ['relay'] })
|
|
// Both peers support WebRTC, but this link only negotiated Relay (e.g. a
|
|
// force-relay Client). Signaling must be dropped instead of forwarded: the
|
|
// Host treats unsolicited signaling as a protocol violation that would
|
|
// close its whole Control connection.
|
|
ctx.client.send('signal.offer', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, sdp: 'v=0 offer' })
|
|
ctx.client.send('signal.ice', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, candidate: candidate(0) })
|
|
await new Promise(resolve => setTimeout(resolve, 100))
|
|
expect(ctx.host.messages.filter(message => message.type === 'signal.offer' || message.type === 'signal.ice')).toHaveLength(0)
|
|
expect(ctx.client.messages.filter(message => message.type === 'error')).toHaveLength(0)
|
|
await handshake(ctx)
|
|
ctx.client.send('relay', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, counter: 0, ciphertext: 'AQIDBA' })
|
|
expect(await ctx.host.next('relay')).toMatchObject({ connectionId: ctx.connectionId })
|
|
})
|
|
|
|
it('narrows connect.incoming to the transports both peers support', async () => {
|
|
const ctx = await connection({ hostCapabilities: ['transport.lan', 'transport.p2p', 'transport.relay'], clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
// The TURN transport is also absent because this test Server has no TURN
|
|
// deployment configured, so the intersection cannot include it.
|
|
expect(ctx.incoming.preferredTransports).toEqual(['lan', 'p2p', 'relay'])
|
|
ctx.client.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, transport: 'turn' })
|
|
expect((await ctx.client.next('error')).code).toBe('CAPABILITY_NOT_SUPPORTED')
|
|
})
|
|
|
|
it('enforces the per-connection ICE candidate limit', async () => {
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
for (let index = 0; index < MAX_ICE_CANDIDATES_PER_CONNECTION; index++) {
|
|
ctx.client.send('signal.ice', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, candidate: candidate(index) })
|
|
}
|
|
ctx.client.send('signal.ice', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, candidate: candidate(MAX_ICE_CANDIDATES_PER_CONNECTION) })
|
|
expect((await ctx.client.next('error')).code).toBe('INVALID_MESSAGE')
|
|
})
|
|
|
|
it('issues short-lived STUN/TURN credentials only to connection participants', async () => {
|
|
await app.close()
|
|
await start(password, [], {
|
|
ice: {
|
|
stunUrls: ['stun:stun.example.test:3478'],
|
|
turnUrls: ['turn:turn.example.test:3478?transport=udp'],
|
|
turnSecret: 'test-turn-secret',
|
|
turnTtlSeconds: 120,
|
|
},
|
|
})
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities, preferredTransports: fullPreferredTransports })
|
|
// Negotiate TURN before selecting it; the diagnostic must survive forwarding.
|
|
ctx.client.send('transport.selected', { connectionId: ctx.connectionId, targetDeviceId: ctx.h.deviceId, transport: 'turn', turnNode: 'turn.example.test:3478' })
|
|
expect(await ctx.host.next('transport.selected')).toMatchObject({ transport: 'turn', turnNode: 'turn.example.test:3478' })
|
|
const before = Date.now()
|
|
const result = await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, ctx.c.accessToken)
|
|
expect(result.status).toBe(200)
|
|
const [stun, turn] = result.data.iceServers as Array<{ urls: string; username?: string; credential?: string }>
|
|
expect(stun).toEqual({ urls: 'stun:stun.example.test:3478' })
|
|
const expiresAt = Number(String(turn!.username).split(':')[0])
|
|
expect(expiresAt).toBeGreaterThanOrEqual(Math.floor(before / 1000) + 120)
|
|
expect(expiresAt).toBeLessThanOrEqual(Math.ceil(Date.now() / 1000) + 120)
|
|
expect(turn!.credential).toBe(createHmac('sha1', 'test-turn-secret').update(turn!.username!).digest('base64'))
|
|
expect((await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, ctx.h.accessToken)).status).toBe(200)
|
|
|
|
const stranger = await device()
|
|
expect((await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, stranger.accessToken)).status).toBe(404)
|
|
expect((await request(`/turn/credentials?connection_id=${randomUUID()}`, 'GET', undefined, ctx.c.accessToken)).status).toBe(404)
|
|
expect((await request('/turn/credentials', 'GET', undefined, ctx.c.accessToken)).status).toBe(400)
|
|
|
|
await handshake(ctx)
|
|
// WebRTC-capable ready links remain eligible for post-authentication in-band upgrades (`remote.transport.upgrade.v1`),
|
|
// while strangers and strictly relay-only ready links are still rejected.
|
|
expect((await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, ctx.c.accessToken)).status).toBe(200)
|
|
expect((await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, ctx.h.accessToken)).status).toBe(200)
|
|
expect((await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, stranger.accessToken)).status).toBe(404)
|
|
|
|
const relayOnlyCtx = await connection({ hostCapabilities: ['transport.relay'], clientCapabilities: ['transport.relay'], preferredTransports: ['relay'] })
|
|
await handshake(relayOnlyCtx)
|
|
expect((await request(`/turn/credentials?connection_id=${relayOnlyCtx.connectionId}`, 'GET', undefined, relayOnlyCtx.c.accessToken)).status).toBe(404)
|
|
})
|
|
|
|
it('issues configured static TURN credentials', async () => {
|
|
await app.close()
|
|
await start(password, [], {
|
|
ice: {
|
|
stunUrls: [],
|
|
turnUrls: ['turn:turn.example.test:3478'],
|
|
turnSecret: undefined,
|
|
turnUsername: 'remote',
|
|
turnPassword: 'static-turn-password',
|
|
turnTtlSeconds: 120,
|
|
},
|
|
})
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const ctx = await connection({ hostCapabilities: fullCapabilities, clientCapabilities: fullCapabilities })
|
|
const result = await request(`/turn/credentials?connection_id=${ctx.connectionId}`, 'GET', undefined, ctx.c.accessToken)
|
|
expect(result.status).toBe(200)
|
|
expect(result.data.iceServers).toEqual([{ urls: 'turn:turn.example.test:3478', username: 'remote', credential: 'static-turn-password' }])
|
|
})
|
|
|
|
it('rejects partial TURN credential configuration at startup', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'urls without any credential source',
|
|
run: () => {
|
|
expect(() => parseIceConfig({ DSH_SERVER_TURN_URLS: 'turn:turn.example.test:3478' })).toThrow(/DSH_SERVER_TURN_URLS requires/)
|
|
},
|
|
},
|
|
{
|
|
name: 'secret together with static credentials',
|
|
run: () => {
|
|
expect(() => parseIceConfig({
|
|
DSH_SERVER_TURN_URLS: 'turn:turn.example.test:3478',
|
|
DSH_SERVER_TURN_SECRET: 'secret',
|
|
DSH_SERVER_TURN_USERNAME: 'remote',
|
|
DSH_SERVER_TURN_PASSWORD: 'password',
|
|
})).toThrow(/not both/)
|
|
},
|
|
},
|
|
{
|
|
name: 'static username without password',
|
|
run: () => {
|
|
expect(() => parseIceConfig({
|
|
DSH_SERVER_TURN_URLS: 'turn:turn.example.test:3478',
|
|
DSH_SERVER_TURN_USERNAME: 'remote',
|
|
})).toThrow(/together/)
|
|
},
|
|
},
|
|
{
|
|
name: 'static credentials without urls',
|
|
run: () => {
|
|
expect(() => parseIceConfig({
|
|
DSH_SERVER_TURN_USERNAME: 'remote',
|
|
DSH_SERVER_TURN_PASSWORD: 'password',
|
|
})).toThrow(/DSH_SERVER_TURN_URLS is required/)
|
|
},
|
|
},
|
|
{
|
|
name: 'secret without urls',
|
|
run: () => {
|
|
expect(() => parseIceConfig({ DSH_SERVER_TURN_SECRET: 'secret' })).toThrow(/DSH_SERVER_TURN_URLS is required/)
|
|
},
|
|
},
|
|
{
|
|
name: 'accepts a complete static pair',
|
|
run: () => {
|
|
expect(parseIceConfig({
|
|
DSH_SERVER_TURN_URLS: 'turn:turn.example.test:3478',
|
|
DSH_SERVER_TURN_USERNAME: 'remote',
|
|
DSH_SERVER_TURN_PASSWORD: 'password',
|
|
})).toMatchObject({ turnUsername: 'remote', turnPassword: 'password', turnSecret: undefined })
|
|
},
|
|
},
|
|
])
|
|
})
|
|
|
|
it('does not issue TURN credentials before the host accepts the connection', async () => {
|
|
await app.close()
|
|
await start(password, [], {
|
|
ice: {
|
|
stunUrls: [],
|
|
turnUrls: ['turn:turn.example.test:3478'],
|
|
turnSecret: 'test-turn-secret',
|
|
turnTtlSeconds: 120,
|
|
},
|
|
})
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const h = await device('host'), c = await device(), host = await socket(h), client = await socket(c)
|
|
await host.next('hello.ack'); await client.next('hello.ack')
|
|
client.send('connect.request', { hostDeviceId: h.deviceId, preferredTransports: ['relay'] })
|
|
const incoming = await host.next('connect.incoming')
|
|
expect((await request(`/turn/credentials?connection_id=${incoming.connectionId}`, 'GET', undefined, c.accessToken)).status).toBe(404)
|
|
})
|
|
})
|
|
|
|
describe('reverse-proxy client IP rate limiting', () => {
|
|
const trusted = ['127.0.0.1', '::ffff:127.0.0.1']
|
|
const forwarded = (ip: string) => ({ 'x-forwarded-for': ip })
|
|
const restart = async (ips: readonly string[] = trusted) => { await app.close(); await start(password, ips) }
|
|
|
|
it('normalizes IPv4, IPv6 and IPv4-mapped IPv6 to one canonical form', () => {
|
|
expect(normalizeIp('127.0.0.1')).toBe('127.0.0.1')
|
|
expect(normalizeIp('::ffff:127.0.0.1')).toBe('127.0.0.1')
|
|
expect(normalizeIp('::ffff:7f00:1')).toBe('127.0.0.1')
|
|
expect(normalizeIp('0:0:0:0:0:ffff:127.0.0.1')).toBe('127.0.0.1')
|
|
expect(normalizeIp('2001:0DB8:0000:0000:0000:0000:0000:0001')).toBe('2001:db8::1')
|
|
expect([...normalizeTrustedProxyIps(['127.0.0.1', '::ffff:127.0.0.1', '2001:db8::2'])]).toEqual(['127.0.0.1', '2001:db8::2'])
|
|
for (const invalid of ['', '10.0.0.0/8', '10.0.0.1:8080', '[::1]:8080', 'client.example.com', '1.2.3.4, 5.6.7.8', 'fe80::1%eth0']) {
|
|
expect(normalizeIp(invalid)).toBeNull()
|
|
}
|
|
})
|
|
|
|
it('rejects invalid trusted proxy IP lists at startup', () => {
|
|
for (const invalid of ['10.0.0.0/8', 'proxy.example.com', '127.0.0.1:8080', '999.1.1.1', '::1/128', '']) {
|
|
expect(() => createRemoteServer({ account, password, dataFile: join(dir, 'invalid.json'), publicUrl: 'http://localhost:8080', trustedProxyIps: [invalid] })).toThrow(/DSH_SERVER_TRUSTED_PROXY_IPS/)
|
|
}
|
|
})
|
|
|
|
it('keeps client B working after client A exhausts the 20/min login limit', async () => {
|
|
await restart()
|
|
const A = forwarded('10.20.0.1'), B = forwarded('10.20.0.2')
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, B)).status).toBe(200)
|
|
for (let i = 0; i < 20; i++) expect((await request('/auth/login', 'POST', { email: account, password: 'wrong' }, undefined, A)).status).toBe(401)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, A)).status).toBe(429)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, B)).status).toBe(200)
|
|
}, 15000)
|
|
|
|
it('keeps client B working after client A exhausts the 240/min API limit', async () => {
|
|
await restart()
|
|
const A = forwarded('10.30.0.1'), B = forwarded('10.30.0.2')
|
|
for (let i = 0; i < 240; i++) expect((await request('/auth/me', 'GET', undefined, undefined, A)).status).toBe(401)
|
|
expect((await request('/auth/me', 'GET', undefined, undefined, A)).status).toBe(429)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, B)).status).toBe(200)
|
|
}, 30000)
|
|
|
|
it('ignores spoofed X-Forwarded-For from an untrusted peer and limits by socket IP', async () => {
|
|
await restart([])
|
|
for (let i = 0; i < 20; i++) expect((await request('/auth/login', 'POST', { email: account, password: 'wrong' }, undefined, forwarded('10.40.0.1'))).status).toBe(401)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, forwarded('10.40.0.2'))).status).toBe(429)
|
|
expect(await rawStatus(['X-Forwarded-For: 10.40.0.1', 'x-forwarded-for: 10.40.0.2'])).toBe(401)
|
|
}, 15000)
|
|
|
|
it('rejects missing, duplicate and malformed X-Forwarded-For from a trusted peer', async () => {
|
|
await restart()
|
|
const missing = await request('/auth/me')
|
|
expect(missing.status).toBe(400)
|
|
expect(missing.data.error.code).toBe('INVALID_MESSAGE')
|
|
for (const value of ['10.0.0.1, 10.0.0.2', '10.0.0.1:8080', 'client.example.com', '10.0.0.0/8', '[::1]']) {
|
|
const result = await request('/auth/me', 'GET', undefined, undefined, forwarded(value))
|
|
expect(result.status).toBe(400)
|
|
expect(result.data.error.code).toBe('INVALID_MESSAGE')
|
|
}
|
|
expect(await rawStatus(['X-Forwarded-For: 10.0.0.1', 'x-forwarded-for: 10.0.0.2'])).toBe(400)
|
|
expect((await request('/auth/me', 'GET', undefined, undefined, forwarded('10.0.0.9'))).status).toBe(401)
|
|
}, 15000)
|
|
|
|
it('shares a rate bucket between IPv4 and IPv4-mapped IPv6 forwarded addresses', async () => {
|
|
await restart(['127.0.0.1'])
|
|
const mapped = forwarded('::ffff:10.50.0.1'), plain = forwarded('10.50.0.1'), other = forwarded('10.50.0.2')
|
|
for (let i = 0; i < 20; i++) expect((await request('/auth/login', 'POST', { email: account, password: 'wrong' }, undefined, mapped)).status).toBe(401)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, plain)).status).toBe(429)
|
|
expect((await request('/auth/login', 'POST', { email: account, password }, undefined, other)).status).toBe(200)
|
|
}, 15000)
|
|
})
|
|
|
|
describe('gateway hello timeout and diagnostics', () => {
|
|
it('terminates unresponsive client with HELLO_TIMEOUT error frame and 4001 CONNECTION_FAILED close', async () => {
|
|
await app.close()
|
|
await start(password, [], { helloTimeoutMs: 1000 })
|
|
const ws = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect')
|
|
sockets.push(ws)
|
|
const wire = new Wire(ws)
|
|
await once(ws, 'open')
|
|
const closePromise = once(ws, 'close')
|
|
|
|
const errorPayload = await wire.next('error')
|
|
expect(errorPayload).toMatchObject({
|
|
code: 'HELLO_TIMEOUT',
|
|
retryable: true,
|
|
})
|
|
expect(errorPayload.message).toContain('1000ms')
|
|
|
|
const [closeCode, closeReason] = await closePromise
|
|
expect(closeCode).toBe(4001)
|
|
expect(closeReason.toString()).toBe('CONNECTION_FAILED')
|
|
})
|
|
|
|
it('succeeds handshake when hello arrives within extended hello timeout', async () => {
|
|
await app.close()
|
|
await start(password, [], { helloTimeoutMs: 1000 })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const d = await device()
|
|
const ws = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect')
|
|
sockets.push(ws)
|
|
const wire = new Wire(ws)
|
|
await once(ws, 'open')
|
|
|
|
// Delay 200ms before sending hello: well inside the 1000ms deadline.
|
|
await new Promise(r => setTimeout(r, 200))
|
|
wire.send('hello', {
|
|
role: d.role,
|
|
deviceId: d.deviceId,
|
|
accessToken: d.accessToken,
|
|
protocols: [1],
|
|
capabilities: ['transport.relay'],
|
|
clientVersion: d.clientVersion,
|
|
})
|
|
|
|
const ack = await wire.next('hello.ack')
|
|
expect(ack.protocol).toBe(1)
|
|
expect(ack.heartbeatIntervalMs).toBe(25000)
|
|
})
|
|
})
|
|
|
|
describe('structured logger and sensitive data redaction', () => {
|
|
it('redacts sensitive fields in nested objects and arrays', () => {
|
|
const raw = {
|
|
deviceId: 'dev-1',
|
|
role: 'client',
|
|
accessToken: 'token-secret-123',
|
|
password: 'mypassword',
|
|
refreshToken: 'refresh-secret-456',
|
|
ciphertext: 'opaque-ciphertext-abc',
|
|
sdp: 'v=0\r\no=...',
|
|
headers: {
|
|
authorization: 'Bearer token-secret-789',
|
|
cookie: 'dsh_session=abc123xyz',
|
|
host: 'example.com',
|
|
},
|
|
tokens: [
|
|
{ id: 1, token: 'token-in-array' },
|
|
{ id: 2, access_token: 'access-token-in-array' },
|
|
],
|
|
}
|
|
|
|
const redacted = redactSensitive(raw) as any
|
|
expect(redacted.deviceId).toBe('dev-1')
|
|
expect(redacted.role).toBe('client')
|
|
expect(redacted.accessToken).toBe('[REDACTED]')
|
|
expect(redacted.password).toBe('[REDACTED]')
|
|
expect(redacted.refreshToken).toBe('[REDACTED]')
|
|
expect(redacted.ciphertext).toBe('[REDACTED]')
|
|
expect(redacted.sdp).toBe('[REDACTED]')
|
|
expect(redacted.headers.host).toBe('example.com')
|
|
expect(redacted.headers.authorization).toBe('[REDACTED]')
|
|
expect(redacted.headers.cookie).toBe('[REDACTED]')
|
|
expect(redacted.tokens[0].token).toBe('[REDACTED]')
|
|
expect(redacted.tokens[1].access_token).toBe('[REDACTED]')
|
|
})
|
|
|
|
it('redacts sensitive parameters in URLs and bearer strings', () => {
|
|
const url = 'https://server.example.com/ws/v1/connect?accessToken=secret123&other=safe'
|
|
expect(redactSensitive(url)).toBe('https://server.example.com/ws/v1/connect?accessToken=[REDACTED]&other=safe')
|
|
|
|
const bearer = 'Bearer super_secret_token_val== other'
|
|
expect(redactSensitive(bearer)).toBe('Bearer [REDACTED] other')
|
|
})
|
|
|
|
it('handles circular references and errors safely', () => {
|
|
const circular: Record<string, unknown> = { key: 'safe' }
|
|
circular.self = circular
|
|
const clean = redactSensitive(circular) as any
|
|
expect(clean.key).toBe('safe')
|
|
expect(clean.self).toBe('[CIRCULAR]')
|
|
|
|
const err = new Error('Failed to parse accessToken=secret123')
|
|
const cleanErr = redactSensitive(err) as any
|
|
expect(cleanErr.name).toBe('Error')
|
|
expect(cleanErr.message).toContain('accessToken=[REDACTED]')
|
|
})
|
|
|
|
it('emits single-line JSON log entries filtered by log level', () => {
|
|
const entries: LogEntry[] = []
|
|
const lines: string[] = []
|
|
const logger = new Logger('test-scope', 'warn', (line, entry) => {
|
|
lines.push(line)
|
|
entries.push(entry)
|
|
})
|
|
|
|
logger.debug('debug_ignored', { info: 'hidden' })
|
|
logger.info('info_ignored', { info: 'hidden' })
|
|
expect(entries).toHaveLength(0)
|
|
|
|
logger.warn('warning_logged', {
|
|
user: 'alice',
|
|
accessToken: 'my-token',
|
|
})
|
|
logger.error('error_logged', {
|
|
password: 'pass',
|
|
reason: 'failed',
|
|
})
|
|
|
|
expect(entries).toHaveLength(2)
|
|
expect(entries[0].level).toBe('warn')
|
|
expect(entries[0].scope).toBe('test-scope')
|
|
expect(entries[0].event).toBe('warning_logged')
|
|
expect(entries[0].meta.user).toBe('alice')
|
|
expect(entries[0].meta.accessToken).toBe('[REDACTED]')
|
|
|
|
expect(entries[1].level).toBe('error')
|
|
expect(entries[1].event).toBe('error_logged')
|
|
expect(entries[1].meta.password).toBe('[REDACTED]')
|
|
expect(entries[1].meta.reason).toBe('failed')
|
|
|
|
expect(lines).toHaveLength(2)
|
|
expect(lines[0]).not.toContain('\n')
|
|
const parsed = JSON.parse(lines[0])
|
|
expect(parsed.event).toBe('warning_logged')
|
|
expect(parsed.meta.accessToken).toBe('[REDACTED]')
|
|
})
|
|
|
|
it('parses and validates environment configuration with fallback warnings', () => {
|
|
// Hello timeout
|
|
expect(parseHelloTimeout(undefined)).toBe(5000)
|
|
expect(parseHelloTimeout('10000')).toBe(10000)
|
|
expect(parseHelloTimeout('500')).toBe(5000)
|
|
expect(parseHelloTimeout('70000')).toBe(5000)
|
|
expect(parseHelloTimeout('invalid')).toBe(5000)
|
|
|
|
// Heartbeat interval
|
|
expect(parseHeartbeatInterval(undefined)).toBe(25000)
|
|
expect(parseHeartbeatInterval('30000')).toBe(30000)
|
|
expect(parseHeartbeatInterval('1000')).toBe(25000)
|
|
expect(parseHeartbeatInterval('150000')).toBe(25000)
|
|
|
|
// Heartbeat disconnect
|
|
expect(parseHeartbeatDisconnect(undefined, 25000)).toBe(75000)
|
|
expect(parseHeartbeatDisconnect('80000', 25000)).toBe(80000)
|
|
expect(parseHeartbeatDisconnect('40000', 25000)).toBe(75000)
|
|
expect(parseHeartbeatDisconnect('50000', 30000)).toBe(90000)
|
|
|
|
// Log level
|
|
expect(parseLogLevel(undefined)).toBe('info')
|
|
expect(parseLogLevel('debug')).toBe('debug')
|
|
expect(parseLogLevel('WARN')).toBe('warn')
|
|
expect(parseLogLevel('silent')).toBe('silent')
|
|
expect(parseLogLevel('invalid_level')).toBe('info')
|
|
|
|
// Max frames per second
|
|
expect(parseMaxFramesPerSec(undefined)).toBe(512)
|
|
expect(parseMaxFramesPerSec('4096')).toBe(4096)
|
|
expect(parseMaxFramesPerSec('32')).toBe(512)
|
|
expect(parseMaxFramesPerSec('100000')).toBe(512)
|
|
expect(normalizeMaxFramesPerSec(Number.NaN)).toBe(512)
|
|
})
|
|
})
|
|
|
|
describe('gateway handshake state machine', () => {
|
|
it('discards a hello that arrives after the deadline without authenticating', async () => {
|
|
await app.close()
|
|
await start(password, [], { helloTimeoutMs: 1000, forceTerminateGraceMs: 200 })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const d = await device()
|
|
const ws = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect')
|
|
sockets.push(ws)
|
|
const wire = new Wire(ws)
|
|
await once(ws, 'open')
|
|
const closed = once(ws, 'close')
|
|
|
|
expect((await wire.next('error')).code).toBe('HELLO_TIMEOUT')
|
|
|
|
// The deadline already fired: this late hello must not authenticate, must
|
|
// not register a peer and must not touch the store.
|
|
await new Promise<void>(resolve => ws.send(JSON.stringify(createControlFrame('hello', {
|
|
role: d.role,
|
|
deviceId: d.deviceId,
|
|
accessToken: d.accessToken,
|
|
protocols: [1],
|
|
capabilities: ['transport.relay'],
|
|
clientVersion: d.clientVersion,
|
|
})), () => resolve()))
|
|
|
|
const [closeCode] = await closed
|
|
expect(closeCode).toBe(4001)
|
|
expect(wire.messages.filter(message => message.type === 'hello.ack')).toHaveLength(0)
|
|
expect(app.gateway.peers.has(d.deviceId)).toBe(false)
|
|
expect(app.store.get(d.deviceId).lastSeenAt).toBe(0)
|
|
}, 15000)
|
|
|
|
it('keeps a fresh connection authenticated after a timed-out sibling', async () => {
|
|
await app.close()
|
|
await start(password, [], { helloTimeoutMs: 1000 })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const d = await device()
|
|
const stalled = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect')
|
|
sockets.push(stalled)
|
|
await once(stalled, 'open')
|
|
const closed = once(stalled, 'close')
|
|
|
|
const live = await socket(d)
|
|
expect((await live.next('hello.ack')).protocol).toBe(1)
|
|
await closed
|
|
expect(app.gateway.peers.get(d.deviceId)).toBeDefined()
|
|
live.send('ping', { nonce: 'still-authenticated' })
|
|
expect(await live.next('pong')).toEqual({ nonce: 'still-authenticated' })
|
|
}, 15000)
|
|
})
|
|
|
|
describe('gateway timing configuration normalization', () => {
|
|
it('maps NaN, Infinity and out-of-range programmatic values to safe defaults', () => {
|
|
expect(normalizeGatewayOptions({})).toEqual({
|
|
helloTimeoutMs: 5000, heartbeatIntervalMs: 25000, heartbeatDisconnectMs: 75000, forceTerminateGraceMs: 1000,
|
|
})
|
|
expect(normalizeGatewayOptions({
|
|
helloTimeoutMs: Number.NaN,
|
|
heartbeatIntervalMs: Number.POSITIVE_INFINITY,
|
|
heartbeatDisconnectMs: -1,
|
|
forceTerminateGraceMs: 0,
|
|
})).toEqual({
|
|
helloTimeoutMs: 5000, heartbeatIntervalMs: 25000, heartbeatDisconnectMs: 75000, forceTerminateGraceMs: 1000,
|
|
})
|
|
expect(normalizeGatewayOptions({ helloTimeoutMs: 59 }).helloTimeoutMs).toBe(5000)
|
|
expect(normalizeGatewayOptions({ helloTimeoutMs: 60001 }).helloTimeoutMs).toBe(5000)
|
|
expect(normalizeGatewayOptions({ helloTimeoutMs: '2500' as unknown as number }).helloTimeoutMs).toBe(2500)
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 300_000 }).heartbeatIntervalMs).toBe(25000)
|
|
expect(normalizeGatewayOptions({ forceTerminateGraceMs: 50 }).forceTerminateGraceMs).toBe(1000)
|
|
expect(normalizeGatewayOptions({ forceTerminateGraceMs: 10001 }).forceTerminateGraceMs).toBe(1000)
|
|
})
|
|
|
|
it('keeps the disconnect threshold at twice the interval and inside its ceiling', () => {
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 30000 }).heartbeatDisconnectMs).toBe(90000)
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 30000, heartbeatDisconnectMs: 59000 }).heartbeatDisconnectMs).toBe(90000)
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 30000, heartbeatDisconnectMs: 60001 }).heartbeatDisconnectMs).toBe(60001)
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 30000, heartbeatDisconnectMs: 600_001 }).heartbeatDisconnectMs).toBe(90000)
|
|
expect(normalizeGatewayOptions({ heartbeatIntervalMs: 120_000 }).heartbeatDisconnectMs).toBe(360_000)
|
|
})
|
|
|
|
it('normalizes unsafe values handed to createRemoteServer', () => {
|
|
const unsafe = createRemoteServer({
|
|
account, password, dataFile: join(dir, 'unsafe.json'), publicUrl: 'http://localhost:8080',
|
|
helloTimeoutMs: Number.NaN, heartbeatIntervalMs: Number.POSITIVE_INFINITY,
|
|
heartbeatDisconnectMs: -1, forceTerminateGraceMs: Number.NaN,
|
|
})
|
|
try {
|
|
expect(unsafe.gateway.helloTimeoutMs).toBe(5000)
|
|
expect(unsafe.gateway.heartbeatIntervalMs).toBe(25000)
|
|
expect(unsafe.gateway.heartbeatDisconnectMs).toBe(75000)
|
|
expect(unsafe.gateway.forceTerminateGraceMs).toBe(1000)
|
|
} finally {
|
|
unsafe.gateway.close()
|
|
}
|
|
})
|
|
|
|
it('never echoes the rejected value in a configuration warning', () => {
|
|
const warnings: string[] = []
|
|
const spy = vi.spyOn(console, 'warn').mockImplementation((message: unknown) => { warnings.push(String(message)) })
|
|
try {
|
|
expect(parseHelloTimeout('not-a-number-CANARY7')).toBe(5000)
|
|
expect(parseHeartbeatInterval('CANARY7')).toBe(25000)
|
|
expect(parseHeartbeatDisconnect('CANARY7', 25000)).toBe(75000)
|
|
expect(parseLogLevel('CANARY7')).toBe('info')
|
|
} finally {
|
|
spy.mockRestore()
|
|
}
|
|
expect(warnings).toHaveLength(4)
|
|
for (const warning of warnings) expect(warning).not.toContain('CANARY7')
|
|
expect(warnings[0]).toContain('1000 and 60000')
|
|
})
|
|
})
|
|
|
|
describe('defensive logger hardening', () => {
|
|
it('redacts secrets inside serialized JSON documents and URLs', () => {
|
|
const document = JSON.stringify({
|
|
access_token: 'CANARY-A', sdp: 'v=0 o=alice 1234', nested: { refreshToken: 'CANARY-B' }, keep: 'visible',
|
|
})
|
|
const redacted = redactSensitive(document) as string
|
|
expect(redacted).not.toContain('CANARY-A')
|
|
expect(redacted).not.toContain('CANARY-B')
|
|
expect(redacted).not.toContain('v=0')
|
|
expect(redacted).toContain('visible')
|
|
expect(redacted).toContain('[REDACTED]')
|
|
expect(redactSensitive('wss://host/ws?token=CANARY-C&sdp=CANARY-D&keep=1'))
|
|
.toBe('wss://host/ws?token=[REDACTED]&sdp=[REDACTED]&keep=1')
|
|
// Scheme prefixes must be handled before the generic key/value rule.
|
|
expect(redactSensitive('Authorization: Bearer CANARY-TOKEN')).not.toContain('CANARY-TOKEN')
|
|
expect(redactSensitive('basic CANARY-BASIC')).not.toContain('CANARY-BASIC')
|
|
})
|
|
|
|
it('redacts ciphertext, cookie and authorization keys in every spelling', () => {
|
|
const clean = redactSensitive({
|
|
'x-ciphertext': 'CANARY-E',
|
|
cipher_text: 'CANARY-F',
|
|
cookie: 'CANARY-G',
|
|
authorization: 'CANARY-H',
|
|
'refresh-token': 'CANARY-I',
|
|
secret: 'CANARY-J',
|
|
sibling: 'kept',
|
|
}) as Record<string, string>
|
|
for (const key of Object.keys(clean)) {
|
|
if (key === 'sibling') expect(clean[key]).toBe('kept')
|
|
else expect(clean[key]).toBe('[REDACTED]')
|
|
}
|
|
})
|
|
|
|
it('never throws on BigInt, NaN, throwing getters or hostile proxies', () => {
|
|
const entries: LogEntry[] = []
|
|
const logger = new Logger('test-scope', 'debug', (_line, entry) => entries.push(entry))
|
|
const withGetter = { ok: 'fine', get boom(): string { throw new Error('getter exploded') } }
|
|
const hostile = new Proxy({}, {
|
|
ownKeys() { throw new Error('blocked') },
|
|
getOwnPropertyDescriptor() { throw new Error('blocked') },
|
|
get() { throw new Error('blocked') },
|
|
})
|
|
|
|
expect(() => logger.info('bigint_logged', { size: 9007199254740993n, ratio: Number.NaN, list: [1n, 2n] })).not.toThrow()
|
|
expect(() => logger.warn('getter_logged', withGetter as unknown as Record<string, unknown>)).not.toThrow()
|
|
expect(() => logger.error('hostile_logged', hostile as Record<string, unknown>)).not.toThrow()
|
|
|
|
expect(entries[0].meta.size).toBe('9007199254740993')
|
|
expect(entries[0].meta.ratio).toBe('NaN')
|
|
expect(entries[0].meta.list).toEqual(['1', '2'])
|
|
expect(entries[1].meta.ok).toBe('fine')
|
|
expect(entries[1].meta.boom).toBe('[UNSERIALIZABLE]')
|
|
expect(entries[2].meta).toEqual({ value: '[UNSERIALIZABLE]' })
|
|
for (const entry of entries) expect(() => JSON.stringify(entry)).not.toThrow()
|
|
})
|
|
|
|
it('replaces unsanitized event and scope labels', () => {
|
|
const entries: LogEntry[] = []
|
|
const logger = new Logger('bad scope {"injected":true}', 'info', (_line, entry) => entries.push(entry))
|
|
logger.info('event with spaces {"leak":1}', { ok: 1 })
|
|
expect(entries[0].scope).toBe('server')
|
|
expect(entries[0].event).toBe('invalid_event')
|
|
expect(entries[0].meta).toEqual({ ok: 1 })
|
|
})
|
|
|
|
it('rejects prototype members when parsing log levels', () => {
|
|
const warnings: string[] = []
|
|
const spy = vi.spyOn(console, 'warn').mockImplementation((message: unknown) => { warnings.push(String(message)) })
|
|
try {
|
|
for (const candidate of ['constructor', '__proto__', 'toString', 'hasOwnProperty', 'valueOf']) {
|
|
expect(parseLogLevel(candidate)).toBe('info')
|
|
}
|
|
expect(parseLogLevel('constructor', 'warn')).toBe('warn')
|
|
} finally {
|
|
spy.mockRestore()
|
|
}
|
|
expect(warnings.join('\n')).not.toContain('__proto__')
|
|
})
|
|
})
|
|
|
|
describe('gateway diagnostics redaction', () => {
|
|
it('never logs query parameters from a rejected upgrade', async () => {
|
|
const lines: string[] = []
|
|
const spy = vi.spyOn(console, 'warn').mockImplementation((message: unknown) => { lines.push(String(message)) })
|
|
try {
|
|
const port = (app.server.address() as { port: number }).port
|
|
const crlf = String.fromCharCode(13, 10)
|
|
await new Promise<void>(resolve => {
|
|
const socket = createConnection(port, '127.0.0.1')
|
|
socket.on('connect', () => socket.write([
|
|
'GET /ws/v1/connect?access_token=CANARY-URL HTTP/1.1',
|
|
`Host: 127.0.0.1:${port}`,
|
|
'Upgrade: websocket',
|
|
'Connection: Upgrade',
|
|
'Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==',
|
|
'Sec-WebSocket-Version: 13',
|
|
'',
|
|
'',
|
|
].join(crlf)))
|
|
socket.on('data', () => {})
|
|
socket.on('close', () => resolve())
|
|
socket.on('error', () => resolve())
|
|
})
|
|
} finally {
|
|
spy.mockRestore()
|
|
}
|
|
const log = lines.join('\n')
|
|
expect(log).toContain('ws_upgrade_rejected')
|
|
expect(log).toContain('invalid_url')
|
|
expect(log).not.toContain('CANARY-URL')
|
|
expect(log).not.toContain('access_token')
|
|
})
|
|
|
|
it('never logs credentials from a rejected hello', async () => {
|
|
const lines: string[] = []
|
|
const spy = vi.spyOn(console, 'warn').mockImplementation((message: unknown) => { lines.push(String(message)) })
|
|
try {
|
|
const wire = await socket(await device(), { accessToken: 'CANARY-HELLO' })
|
|
expect((await wire.next('error')).code).toBe('AUTH_INVALID')
|
|
} finally {
|
|
spy.mockRestore()
|
|
}
|
|
expect(lines.join('\n')).toContain('ws_message_error')
|
|
expect(lines.join('\n')).not.toContain('CANARY-HELLO')
|
|
})
|
|
|
|
it('never logs a client-supplied close reason', async () => {
|
|
await app.close()
|
|
await start(password, [], { logLevel: 'debug' })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const d = await device()
|
|
const ws = new WebSocket(base.replace('http:', 'ws:') + '/ws/v1/connect')
|
|
sockets.push(ws)
|
|
const wire = new Wire(ws)
|
|
await once(ws, 'open')
|
|
wire.send('hello', {
|
|
role: d.role, deviceId: d.deviceId, accessToken: d.accessToken,
|
|
protocols: [1], capabilities: ['transport.relay'], clientVersion: d.clientVersion,
|
|
})
|
|
await wire.next('hello.ack')
|
|
|
|
const lines: string[] = []
|
|
const spy = vi.spyOn(console, 'info').mockImplementation((message: unknown) => { lines.push(String(message)) })
|
|
try {
|
|
const closed = once(ws, 'close')
|
|
ws.close(4000, 'CANARY-REASON')
|
|
await closed
|
|
await new Promise(resolve => setTimeout(resolve, 50))
|
|
} finally {
|
|
spy.mockRestore()
|
|
}
|
|
const log = lines.join('\n')
|
|
expect(log).toContain('ws_connection_closed')
|
|
expect(log).toContain('"hasReason":true')
|
|
expect(log).not.toContain('CANARY-REASON')
|
|
})
|
|
})
|
|
|
|
describe('stale link frame dropping and configurable rate limit', () => {
|
|
it('silently drops late frames for a closed link even after the active frame quota is full, while bounding sustained stale byte floods', async () => {
|
|
await app.close()
|
|
await start(password, [], { maxFramesPerSec: 64 })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
|
|
const ctx = await connection()
|
|
await handshake(ctx)
|
|
const closedClient = once(ctx.client.ws, 'close')
|
|
ctx.client.ws.close(1000, 'client closed')
|
|
await closedClient
|
|
expect(await ctx.host.next('error')).toMatchObject({
|
|
code: 'CONNECTION_FAILED',
|
|
connectionId: ctx.connectionId,
|
|
retryable: true,
|
|
})
|
|
|
|
// Churn 1,100 dropped links on an unrelated Host: per-Host tombstone isolation must prevent
|
|
// unrelated churn from evicting ctx.connectionId's tombstone.
|
|
const churnHost = await device('host')
|
|
const churnClient = await device('client')
|
|
const churnHostWire = await socket(churnHost)
|
|
const churnClientWire = await socket(churnClient)
|
|
await churnHostWire.next('hello.ack')
|
|
await churnClientWire.next('hello.ack')
|
|
const gatewayInternals = app.gateway as unknown as {
|
|
recordDroppedLink(link: { id: string; host: string; client: string }): void
|
|
}
|
|
for (let i = 0; i < 1100; i++) {
|
|
gatewayInternals.recordDroppedLink({
|
|
id: `churn-link-${i}`,
|
|
host: churnHost.deviceId,
|
|
client: churnClient.deviceId,
|
|
})
|
|
}
|
|
|
|
// Fill the normal 64-frame quota first with active traffic in the current window.
|
|
for (let i = 0; i < 60; i++) {
|
|
ctx.host.send('ping', { nonce: `fill-${i}` })
|
|
expect(await ctx.host.next('pong')).toEqual({ nonce: `fill-${i}` })
|
|
}
|
|
|
|
// Now burst 200 late relay frames (exceeding the 64 frames/sec active cap) on the dropped link:
|
|
// they are absorbed by the dedicated dropped-link drain budget without touching the active quota.
|
|
const lateCiphertext = 'A'.repeat(16 * 1024)
|
|
for (let i = 0; i < 200; i++) {
|
|
ctx.host.send('relay', {
|
|
connectionId: ctx.connectionId,
|
|
targetDeviceId: ctx.c.deviceId,
|
|
counter: i,
|
|
ciphertext: lateCiphertext,
|
|
})
|
|
}
|
|
|
|
// Wait for the 1s rate window to roll over and confirm the Host control connection
|
|
// was not closed with RATE_LIMITED and received zero error frames.
|
|
await new Promise(resolve => setTimeout(resolve, 1050))
|
|
ctx.host.send('ping', { nonce: 'host-survives-stale-burst' })
|
|
expect(await ctx.host.next('pong')).toEqual({ nonce: 'host-survives-stale-burst' })
|
|
expect(ctx.host.messages.filter(m => m.type === 'error')).toHaveLength(0)
|
|
expect(app.gateway.droppedLinkFrameCount(ctx.connectionId)).toBe(200)
|
|
|
|
// Even if the same Host subsequently drops >64 links (evicting ctx.connectionId's tombstone),
|
|
// evictedTombstoneUntil on the Peer still protects late frames for ctx.connectionId.
|
|
for (let i = 0; i < 70; i++) {
|
|
gatewayInternals.recordDroppedLink({
|
|
id: `same-host-churn-${i}`,
|
|
host: ctx.h.deviceId,
|
|
client: ctx.c.deviceId,
|
|
})
|
|
}
|
|
expect(app.gateway.droppedLinkFrameCount(ctx.connectionId)).toBe(0)
|
|
for (let i = 0; i < 100; i++) {
|
|
ctx.host.send('relay', {
|
|
connectionId: ctx.connectionId,
|
|
targetDeviceId: ctx.c.deviceId,
|
|
counter: 500 + i,
|
|
ciphertext: lateCiphertext,
|
|
})
|
|
}
|
|
await new Promise(resolve => setTimeout(resolve, 1050))
|
|
ctx.host.send('ping', { nonce: 'host-survives-post-eviction-burst' })
|
|
expect(await ctx.host.next('pong')).toEqual({ nonce: 'host-survives-post-eviction-burst' })
|
|
expect(ctx.host.messages.filter(m => m.type === 'error')).toHaveLength(0)
|
|
|
|
// Sustained stale traffic exceeding the 8 MiB/sec dropped-link byte ceiling is still bounded.
|
|
const hostClosed = once(ctx.host.ws, 'close')
|
|
const hugeCiphertext = 'B'.repeat(128 * 1024)
|
|
for (let i = 0; i < 70; i++) {
|
|
ctx.host.send('relay', {
|
|
connectionId: ctx.connectionId,
|
|
targetDeviceId: ctx.c.deviceId,
|
|
counter: 1000 + i,
|
|
ciphertext: hugeCiphertext,
|
|
})
|
|
}
|
|
expect(await ctx.host.next('error')).toMatchObject({
|
|
code: 'RATE_LIMITED',
|
|
retryable: false,
|
|
})
|
|
const [hostCloseCode] = await hostClosed
|
|
expect(hostCloseCode).toBe(4001)
|
|
})
|
|
|
|
it('enforces configured maxFramesPerSec on active frames and immediately reaps a heartbeat-expired host on connect.request', async () => {
|
|
await app.close()
|
|
await start(password, [], { maxFramesPerSec: 64 })
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
expect(app.gateway.maxFramesPerSec).toBe(64)
|
|
|
|
const h = await device('host')
|
|
const c = await device('client')
|
|
const rateLimitedClient = await device('client')
|
|
const hostWire = await socket(h)
|
|
const clientWire = await socket(c)
|
|
const noisyWire = await socket(rateLimitedClient)
|
|
await hostWire.next('hello.ack')
|
|
await clientWire.next('hello.ack')
|
|
await noisyWire.next('hello.ack')
|
|
|
|
// Simulate a Host whose last pong is older than heartbeatDisconnectMs before
|
|
// the next periodic interval tick runs.
|
|
const hostPeer = app.gateway.peers.get(h.deviceId)!
|
|
hostPeer.lastPong = Date.now() - (app.gateway.heartbeatDisconnectMs + 1000)
|
|
|
|
clientWire.send('connect.request', { hostDeviceId: h.deviceId, preferredTransports: ['relay'] })
|
|
expect(await clientWire.next('error')).toMatchObject({
|
|
code: 'HOST_OFFLINE',
|
|
retryable: true,
|
|
})
|
|
expect(app.gateway.peers.has(h.deviceId)).toBe(false)
|
|
|
|
// Active frames exceeding the configured 64 frames/sec threshold trigger RATE_LIMITED (4001).
|
|
const noisyClosed = once(noisyWire.ws, 'close')
|
|
for (let i = 0; i < 70; i++) {
|
|
noisyWire.send('ping', { nonce: `active-${i}` })
|
|
}
|
|
expect(await noisyWire.next('error')).toMatchObject({
|
|
code: 'RATE_LIMITED',
|
|
retryable: false,
|
|
})
|
|
const [closeCode] = await noisyClosed
|
|
expect(closeCode).toBe(4001)
|
|
})
|
|
|
|
it('preserves TURN in preferredTransports under relayFirst and authorizes post-handshake TURN credentials to both peers of the live connection', async () => {
|
|
await app.close()
|
|
await start(password, [], {
|
|
ice: {
|
|
stunUrls: ['stun:stun.example.test:3478'],
|
|
turnUrls: ['turn:turn.example.test:3478'],
|
|
turnSecret: 'test-turn-secret',
|
|
turnUsername: undefined,
|
|
turnPassword: undefined,
|
|
turnTtlSeconds: 120,
|
|
},
|
|
})
|
|
accountToken = (await request('/auth/login', 'POST', { email: account, password })).data.token
|
|
const h = await device('host')
|
|
const c = await device('client')
|
|
const stranger = await device('client')
|
|
const hostWire = await socket(h)
|
|
await hostWire.next('hello.ack')
|
|
|
|
const prevWs = (globalThis as Record<string, unknown>).WebSocket
|
|
;(globalThis as Record<string, unknown>).WebSocket = WebSocket
|
|
try {
|
|
const adaptive = new AdaptiveTransport(`${base.replace('http', 'ws')}/ws/v1/connect`, {
|
|
role: 'client',
|
|
deviceId: c.deviceId,
|
|
accessToken: c.accessToken,
|
|
targetDeviceId: h.deviceId,
|
|
relayFirst: true,
|
|
preferredTransports: ['p2p', 'turn', 'relay'],
|
|
})
|
|
const connectPromise = adaptive.connect()
|
|
const incoming = await hostWire.next('connect.incoming')
|
|
// Relay-first still forwards 'turn' in preferredTransports to the Host!
|
|
expect(incoming.preferredTransports).toEqual(['p2p', 'turn', 'relay'])
|
|
hostWire.send('connect.accepted', { connectionId: incoming.connectionId })
|
|
const selected = await hostWire.next('transport.selected')
|
|
expect(selected.transport).toBe('relay')
|
|
await connectPromise
|
|
|
|
// Complete full Noise IK handshake -> link enters 'ready' stage on Server
|
|
const clientNoise = new NoiseIkSession({ role: 'initiator', localPrivateKey: c.keys.privateKey, localPublicKey: c.keys.publicKey, remotePublicKey: h.keys.publicKey, prologue: createNoisePrologue(incoming.connectionId, h.deviceId, c.deviceId) })
|
|
const hostNoise = new NoiseIkSession({ role: 'responder', localPrivateKey: h.keys.privateKey, localPublicKey: h.keys.publicKey, remotePublicKey: c.keys.publicKey, prologue: createNoisePrologue(incoming.connectionId, h.deviceId, c.deviceId) })
|
|
noiseSessions.push(clientNoise, hostNoise)
|
|
const hsDone = new Promise<void>(resolve => {
|
|
adaptive.onHandshake((step, data) => { if (step === 2) { clientNoise.readHandshake(data); resolve() } })
|
|
})
|
|
await adaptive.sendHandshake(1, clientNoise.writeHandshake())
|
|
const hs1 = await hostWire.next('secure.handshake')
|
|
hostNoise.readHandshake(fromBase64Url(hs1.data))
|
|
hostWire.send('secure.handshake', { connectionId: incoming.connectionId, targetDeviceId: c.deviceId, step: 2, data: toBase64Url(hostNoise.writeHandshake()) })
|
|
await hsDone
|
|
|
|
// Post-handshake ICE credentials succeed for both Client and Host, keep TURN servers (not stripped to stunOnly), and reject strangers!
|
|
const clientTurn = await request(`/turn/credentials?connection_id=${incoming.connectionId}`, 'GET', undefined, c.accessToken)
|
|
const hostTurn = await request(`/turn/credentials?connection_id=${incoming.connectionId}`, 'GET', undefined, h.accessToken)
|
|
expect(clientTurn.status).toBe(200)
|
|
expect(hostTurn.status).toBe(200)
|
|
const hostFiltered = incoming.preferredTransports.includes('turn') ? hostTurn.data.iceServers : stunOnlyIceServers(hostTurn.data.iceServers)
|
|
expect(hostFiltered.some((s: { urls: string }) => s.urls.startsWith('turn:'))).toBe(true)
|
|
expect((await request(`/turn/credentials?connection_id=${incoming.connectionId}`, 'GET', undefined, stranger.accessToken)).status).toBe(404)
|
|
|
|
await adaptive.close()
|
|
} finally {
|
|
;(globalThis as Record<string, unknown>).WebSocket = prevWs
|
|
}
|
|
})
|
|
})
|