@livedesk/hub 0.1.31 → 0.1.33

package/src/transport/udp-hub-transport.js

@@ -441,12 +441,23 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             udpSessionId = crypto.randomUUID();
             routeKey = udpSessionRouteKey(udpSessionId);
         } while (sessionsByRouteKey.has(routeKey));
-        const proof = typeof rendezvousProofIssuer === 'function'
-            ? rendezvousProofIssuer({ roomId: udpSessionId, deviceId: id, ttlMs: 60_000 })
+        const hubProof = typeof rendezvousProofIssuer === 'function'
+            ? rendezvousProofIssuer({ roomId: udpSessionId, deviceId: id, role: 'hub', ttlMs: 60_000 })
             : null;
-        const signedRendezvousProof = safeText(proof?.proof, 2048);
+        const clientProof = typeof rendezvousProofIssuer === 'function'
+            ? rendezvousProofIssuer({ roomId: udpSessionId, deviceId: id, role: 'client', ttlMs: 60_000 })
+            : null;
+        const signedHubRendezvousProof = safeText(hubProof?.proof, 2048);
+        const signedClientRendezvousProof = safeText(clientProof?.proof, 2048);
         const allowLegacyUnsignedProofForTests = env.LIVEDESK_TEST_MODE === '1'
             || env.LIVEDESK_TEST_ALLOW_LEGACY_UDP_RENDEZVOUS === '1';
+        const legacyRendezvousToken = allowLegacyUnsignedProofForTests
+            && (!signedHubRendezvousProof || !signedClientRendezvousProof)
+            ? crypto.randomBytes(16).toString('hex')
+            : '';
+        const proofExpiries = [hubProof?.payload?.expiresAt, clientProof?.payload?.expiresAt]
+            .map(Number)
+            .filter(Number.isSafeInteger);
         const session = {
             deviceId: id,
             tcpSessionId: safeText(tcpSessionId, 160),
@@ -455,9 +466,9 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             routeKey,
             key,
             keyBase64: key.toString('base64'),
-            rendezvousToken: signedRendezvousProof
-                || (allowLegacyUnsignedProofForTests ? crypto.randomBytes(16).toString('hex') : ''),
-            rendezvousProofExpiresAt: Number(proof?.payload?.expiresAt || 0),
+            rendezvousToken: signedHubRendezvousProof || legacyRendezvousToken,
+            clientRendezvousToken: signedClientRendezvousProof || legacyRendezvousToken,
+            rendezvousProofExpiresAt: proofExpiries.length === 2 ? Math.min(...proofExpiries) : 0,
             sendControl,
             clientEndpoint: null,
             peerEndpoint: null,
@@ -493,8 +504,8 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             frameChunkHeader: UDP_FRAME_CHUNK_PROTOCOL,
             frameTimeoutMs,
             maxPendingFrames,
-            rendezvous: rendezvousHost && session.rendezvousToken
-                ? { host: rendezvousHost, port: rendezvousPort, roomId: session.sessionId, token: session.rendezvousToken }
+            rendezvous: rendezvousHost && session.clientRendezvousToken
+                ? { host: rendezvousHost, port: rendezvousPort, roomId: session.sessionId, token: session.clientRendezvousToken }
                 : null
         });
         sendRendezvousRegister(session);

package/src/transport/udp-rendezvous.js

@@ -62,20 +62,52 @@ function decodeCanonicalBase64Url(value, minimum, maximum = minimum) {
         : null;
 }
 
-function verifyRendezvousProof(proof, roomId, current) {
+function trustedIssuerMap(values) {
+    const entries = Array.isArray(values)
+        ? values
+        : String(values || '').split(/[\s,]+/u).filter(Boolean);
+    if (entries.length > 10_000) throw new Error('udp-rendezvous-trusted-issuer-capacity');
+    const issuers = new Map();
+    for (const entry of entries) {
+        const publicKeyBytes = decodeCanonicalBase64Url(entry, 80, 160);
+        if (!publicKeyBytes) throw new Error('udp-rendezvous-trusted-issuer-invalid');
+        let publicKey;
+        try {
+            publicKey = crypto.createPublicKey({ key: publicKeyBytes, format: 'der', type: 'spki' });
+        } catch {
+            throw new Error('udp-rendezvous-trusted-issuer-invalid');
+        }
+        if (publicKey.asymmetricKeyType !== 'ec'
+            || publicKey.asymmetricKeyDetails?.namedCurve !== 'prime256v1') {
+            throw new Error('udp-rendezvous-trusted-issuer-invalid');
+        }
+        const keyId = crypto.createHash('sha256').update(publicKeyBytes).digest('base64url');
+        issuers.set(keyId, publicKey);
+    }
+    return issuers;
+}
+
+function exactSafeText(value, maximum) {
+    return typeof value === 'string' && value.length > 0 && safeText(value, maximum) === value;
+}
+
+function verifyRendezvousProof(proof, roomId, role, current, trustedIssuers) {
     try {
         const parts = String(proof || '').split('.');
-        if (parts.length !== 2) return false;
+        if (parts.length !== 2) return { ok: false, reason: 'invalid-proof' };
         const payloadBytes = decodeCanonicalBase64Url(parts[0], 64, 1536);
         const signature = decodeCanonicalBase64Url(parts[1], 64, 64);
-        if (!payloadBytes || !signature) return false;
+        if (!payloadBytes || !signature) return { ok: false, reason: 'invalid-proof' };
         const payload = JSON.parse(payloadBytes.toString('utf8'));
-        if (!payload || payload.version !== 1
-            || payload.protocol !== 'livedesk.udp.rendezvous-proof.v1'
+        if (!payload || payload.version !== 2
+            || payload.protocol !== 'livedesk.udp.rendezvous-proof.v2'
             || payload.roomId !== roomId
-            || !safeText(payload.accountId, 128)
-            || !safeText(payload.hubId, 128)
-            || !safeText(payload.deviceId, 128)
+            || !exactSafeText(payload.issuerKeyId, 64)
+            || !exactSafeText(payload.roomId, 160)
+            || !exactSafeText(payload.role, 16)
+            || !exactSafeText(payload.accountId, 128)
+            || !exactSafeText(payload.hubId, 128)
+            || !exactSafeText(payload.deviceId, 128)
             || !Number.isSafeInteger(payload.issuedAt)
             || !Number.isSafeInteger(payload.expiresAt)
             || payload.issuedAt > current + 30_000
@@ -83,19 +115,26 @@ function verifyRendezvousProof(proof, roomId, current) {
             || payload.expiresAt <= payload.issuedAt
             || payload.expiresAt - payload.issuedAt > 120_000
             || !decodeCanonicalBase64Url(payload.nonce, 16, 32)) {
-            return false;
+            return { ok: false, reason: 'invalid-proof' };
         }
-        const hubPublicBytes = decodeCanonicalBase64Url(payload.hubPublicKey, 80, 160);
-        if (!hubPublicBytes) return false;
-        const hubKey = crypto.createPublicKey({ key: hubPublicBytes, format: 'der', type: 'spki' });
-        return hubKey.asymmetricKeyType === 'ec'
-            && hubKey.asymmetricKeyDetails?.namedCurve === 'prime256v1'
-            && crypto.verify('sha256', Buffer.from(parts[0], 'utf8'), {
-                key: hubKey,
+        if (payload.role !== role) return { ok: false, reason: 'role-mismatch' };
+        const issuerKeyIdBytes = decodeCanonicalBase64Url(payload.issuerKeyId, 32, 32);
+        if (!issuerKeyIdBytes) return { ok: false, reason: 'invalid-proof' };
+        const issuerKey = trustedIssuers.get(payload.issuerKeyId);
+        if (!issuerKey) return { ok: false, reason: 'untrusted-issuer' };
+        const valid = crypto.verify('sha256', Buffer.from(parts[0], 'utf8'), {
+                key: issuerKey,
                 dsaEncoding: 'ieee-p1363'
             }, signature);
+        if (!valid) return { ok: false, reason: 'invalid-signature' };
+        return {
+            ok: true,
+            payload,
+            proofKey: `${payload.issuerKeyId}:${payload.nonce}:${payload.roomId}:${payload.role}`,
+            proofHash: crypto.createHash('sha256').update(String(proof), 'utf8').digest('base64url')
+        };
     } catch {
-        return false;
+        return { ok: false, reason: 'invalid-proof' };
     }
 }
 
@@ -116,6 +155,7 @@ export function createUdpRendezvousServer({
     perSourceBurst = DEFAULT_LIMITS.perSourceBurst,
     globalRate = DEFAULT_LIMITS.globalRate,
     globalBurst = DEFAULT_LIMITS.globalBurst,
+    trustedIssuerPublicKeys = [],
     allowLegacyTokens = false
 } = {}) {
     const socket = dgram.createSocket('udp4');
@@ -123,12 +163,15 @@ export function createUdpRendezvousServer({
     const unpairedRooms = new Map();
     const sources = new Map();
     const evictableSources = new Map();
+    const consumedProofs = new Map();
+    const trustedIssuers = trustedIssuerMap(trustedIssuerPublicKeys);
     const limits = Object.freeze({
         roomTtlMs: normalizeInteger(roomTtlMs, DEFAULT_LIMITS.roomTtlMs),
         sourceTtlMs: normalizeInteger(sourceTtlMs, DEFAULT_LIMITS.sourceTtlMs),
         sweepIntervalMs: normalizeInteger(sweepIntervalMs, DEFAULT_LIMITS.sweepIntervalMs),
         statusIntervalMs: normalizeInteger(statusIntervalMs, DEFAULT_LIMITS.statusIntervalMs, 0),
         maxRooms: normalizeInteger(maxRooms, DEFAULT_LIMITS.maxRooms),
+        maxConsumedProofs: Math.min(200_000, normalizeInteger(maxRooms, DEFAULT_LIMITS.maxRooms) * 2),
         maxSources: normalizeInteger(maxSources, DEFAULT_LIMITS.maxSources),
         maxRoomsPerSource: normalizeInteger(maxRoomsPerSource, DEFAULT_LIMITS.maxRoomsPerSource),
         perSourceRate: normalizeRate(perSourceRate, DEFAULT_LIMITS.perSourceRate),
@@ -151,6 +194,13 @@ export function createUdpRendezvousServer({
         sourceRoomLimitDrops: 0,
         roomCapacityDrops: 0,
         tokenMismatchDrops: 0,
+        untrustedIssuerDrops: 0,
+        roleMismatchDrops: 0,
+        bindingMismatchDrops: 0,
+        proofReplayDrops: 0,
+        endpointOverwriteDrops: 0,
+        idempotentRefreshes: 0,
+        proofCapacityDrops: 0,
         expiredRooms: 0,
         evictedRooms: 0,
         expiredSources: 0,
@@ -194,6 +244,9 @@ export function createUdpRendezvousServer({
         for (const [roomId, room] of rooms) {
             if (at - room.updatedAt >= limits.roomTtlMs) deleteRoom(roomId, 'expired');
         }
+        for (const [proofKey, consumed] of consumedProofs) {
+            if (consumed.expiresAt <= at) consumedProofs.delete(proofKey);
+        }
         for (const [key, source] of sources) {
             if (source.activeRooms === 0 && at - source.lastSeenAt >= limits.sourceTtlMs) {
                 sources.delete(key);
@@ -259,7 +312,7 @@ export function createUdpRendezvousServer({
         });
     }
 
-    function createRoom(roomId, token, source, at) {
+    function createRoom(roomId, binding, source, at, legacyToken = '') {
         if (source.activeRooms >= limits.maxRoomsPerSource) {
             counters.sourceRoomLimitDrops += 1;
             return null;
@@ -274,7 +327,8 @@ export function createUdpRendezvousServer({
             }
         }
         const room = {
-            token,
+            legacyToken,
+            binding,
             ownerSource: source.key,
             peers: new Map(),
             createdAt: at,
@@ -317,8 +371,13 @@ export function createUdpRendezvousServer({
             counters.invalidDatagrams += 1;
             return;
         }
-        if (!allowLegacyTokens && !verifyRendezvousProof(token, roomId, at)) {
+        const verification = allowLegacyTokens
+            ? { ok: true, legacy: true, token }
+            : verifyRendezvousProof(token, roomId, role, at, trustedIssuers);
+        if (!verification.ok) {
             counters.invalidDatagrams += 1;
+            if (verification.reason === 'untrusted-issuer') counters.untrustedIssuerDrops += 1;
+            if (verification.reason === 'role-mismatch') counters.roleMismatchDrops += 1;
             return;
         }
         let room = rooms.get(roomId);
@@ -326,16 +385,64 @@ export function createUdpRendezvousServer({
             deleteRoom(roomId, 'expired');
             room = null;
         }
-        if (room && room.token !== token) {
-            counters.tokenMismatchDrops += 1;
-            return;
-        }
-        if (!room) {
-            room = createRoom(roomId, token, source, at);
-            if (!room) return;
+        if (verification.legacy) {
+            if (room && room.legacyToken !== token) {
+                counters.tokenMismatchDrops += 1;
+                return;
+            }
+            if (!room) {
+                room = createRoom(roomId, null, source, at, token);
+                if (!room) return;
+            }
+            room.updatedAt = at;
+            room.peers.set(role, { address: rinfo.address, port: rinfo.port });
+        } else {
+            const binding = {
+                issuerKeyId: verification.payload.issuerKeyId,
+                accountId: verification.payload.accountId,
+                hubId: verification.payload.hubId,
+                deviceId: verification.payload.deviceId
+            };
+            if (room && JSON.stringify(room.binding) !== JSON.stringify(binding)) {
+                counters.bindingMismatchDrops += 1;
+                return;
+            }
+            const endpoint = { address: rinfo.address, port: rinfo.port };
+            const consumed = consumedProofs.get(verification.proofKey);
+            const existingPeer = room?.peers.get(role);
+            if (consumed) {
+                const sameEndpoint = consumed.address === endpoint.address && consumed.port === endpoint.port;
+                const sameOwner = existingPeer?.proofKey === verification.proofKey
+                    && existingPeer.address === endpoint.address
+                    && existingPeer.port === endpoint.port;
+                if (sameEndpoint && sameOwner) {
+                    room.updatedAt = at;
+                    counters.idempotentRefreshes += 1;
+                    return;
+                }
+                counters.proofReplayDrops += 1;
+                if (existingPeer && !sameEndpoint) counters.endpointOverwriteDrops += 1;
+                return;
+            }
+            if (consumedProofs.size >= limits.maxConsumedProofs) {
+                counters.proofCapacityDrops += 1;
+                return;
+            }
+            if (existingPeer) {
+                counters.endpointOverwriteDrops += 1;
+                return;
+            }
+            if (!room) {
+                room = createRoom(roomId, binding, source, at);
+                if (!room) return;
+            }
+            room.updatedAt = at;
+            room.peers.set(role, { ...endpoint, proofKey: verification.proofKey, proofHash: verification.proofHash });
+            consumedProofs.set(verification.proofKey, {
+                ...endpoint,
+                expiresAt: verification.payload.expiresAt
+            });
         }
-        room.updatedAt = at;
-        room.peers.set(role, { address: rinfo.address, port: rinfo.port });
         counters.acceptedRegistrations += 1;
         if (room.peers.size < 2) {
             unpairedRooms.delete(roomId);
@@ -391,6 +498,9 @@ export function createUdpRendezvousServer({
             unpairedRooms: unpairedRooms.size,
             sources: sources.size,
             evictableSources: evictableSources.size,
+            consumedProofs: consumedProofs.size,
+            trustedIssuerCount: trustedIssuers.size,
+            securityReady: allowLegacyTokens || trustedIssuers.size > 0,
             limits: { ...limits },
             counters: { ...counters },
             lastError
@@ -419,6 +529,9 @@ export function createUdpRendezvousServer({
 
     async function start() {
         if (started) return { host, port: boundPort };
+        if (!allowLegacyTokens && trustedIssuers.size === 0) {
+            throw new Error('udp-rendezvous-trusted-issuer-required');
+        }
         await new Promise((resolve, reject) => {
             const onError = error => { socket.off('listening', onListening); reject(error); };
             const onListening = () => { socket.off('error', onError); resolve(); };
@@ -443,6 +556,7 @@ export function createUdpRendezvousServer({
         unpairedRooms.clear();
         sources.clear();
         evictableSources.clear();
+        consumedProofs.clear();
         if (started) {
             await new Promise(resolve => socket.close(() => resolve()));
             started = false;