@livedesk/hub 0.1.3 → 0.1.5

package/src/transport/udp-protocol.js

@@ -0,0 +1,216 @@
+import crypto from 'node:crypto';
+
+export const UDP_P2P_PROTOCOL = 'livedesk.udp.p2p.v1';
+export const UDP_P2P_VERSION = 1;
+export const UDP_MAX_DATAGRAM_BYTES = 1200;
+export const UDP_PACKET_TYPES = Object.freeze({
+    probe: 1,
+    'probe-ack': 2,
+    ready: 3,
+    ping: 4,
+    pong: 5,
+    frame: 6,
+    close: 7
+});
+const UDP_PACKET_TYPE_NAMES = new Map(Object.entries(UDP_PACKET_TYPES).map(([name, value]) => [value, name]));
+const UDP_FIXED_HEADER_BYTES = 15;
+const UDP_NONCE_BYTES = 12;
+const UDP_TAG_BYTES = 16;
+const UDP_MAX_SESSION_ID_BYTES = 96;
+const UDP_MAX_HEADER_BYTES = 4096;
+const UDP_MAX_PAYLOAD_BYTES = UDP_MAX_DATAGRAM_BYTES - UDP_FIXED_HEADER_BYTES - UDP_NONCE_BYTES - UDP_TAG_BYTES - 1;
+
+function asBuffer(value) {
+    if (Buffer.isBuffer(value)) return value;
+    if (value instanceof Uint8Array) return Buffer.from(value);
+    if (typeof value === 'string') return Buffer.from(value, 'utf8');
+    return Buffer.alloc(0);
+}
+
+function normalizeKey(key) {
+    const value = asBuffer(key);
+    return value.length === 32 ? value : crypto.createHash('sha256').update(value).digest();
+}
+
+function normalizeSessionId(value) {
+    const sessionId = String(value || '').trim();
+    if (!sessionId || Buffer.byteLength(sessionId, 'utf8') > UDP_MAX_SESSION_ID_BYTES) {
+        throw new Error('invalid-udp-session-id');
+    }
+    return sessionId;
+}
+
+function packetTypeCode(type) {
+    const code = typeof type === 'number' ? type : UDP_PACKET_TYPES[String(type || '').toLowerCase()];
+    if (!code || !UDP_PACKET_TYPE_NAMES.has(code)) throw new Error('invalid-udp-packet-type');
+    return code;
+}
+
+function encodeHeader(header) {
+    const bytes = Buffer.from(JSON.stringify(header && typeof header === 'object' ? header : {}), 'utf8');
+    if (bytes.length > UDP_MAX_HEADER_BYTES) throw new Error('udp-packet-header-too-large');
+    return bytes;
+}
+
+export function deriveUdpSessionKey(keyMaterial) {
+    return normalizeKey(keyMaterial);
+}
+
+export function createUdpSessionKey() {
+    return crypto.randomBytes(32);
+}
+
+export function encodeUdpPacket({ type, sessionId, key, sequence = 0, header = {}, payload = Buffer.alloc(0) }) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    const sessionBytes = Buffer.from(normalizedSessionId, 'utf8');
+    const headerBytes = encodeHeader(header);
+    const payloadBytes = asBuffer(payload);
+    if (payloadBytes.length > UDP_MAX_PAYLOAD_BYTES) throw new Error('udp-packet-payload-too-large');
+
+    const preamble = Buffer.allocUnsafe(UDP_FIXED_HEADER_BYTES);
+    UDP_P2P_PROTOCOL.startsWith('livedesk') && Buffer.from('LDU1', 'ascii').copy(preamble, 0);
+    preamble[4] = UDP_P2P_VERSION;
+    preamble[5] = packetTypeCode(type);
+    preamble[6] = sessionBytes.length;
+    preamble.writeUInt16BE(headerBytes.length, 7);
+    preamble.writeUInt16BE(payloadBytes.length, 9);
+    preamble.writeUInt32BE((Number(sequence) >>> 0), 11);
+    const nonce = crypto.randomBytes(UDP_NONCE_BYTES);
+    const associatedData = Buffer.concat([preamble, nonce, sessionBytes, headerBytes]);
+    const cipher = crypto.createCipheriv('aes-256-gcm', normalizeKey(key), nonce);
+    cipher.setAAD(associatedData);
+    const encrypted = Buffer.concat([cipher.update(payloadBytes), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const packet = Buffer.concat([associatedData, encrypted, tag]);
+    if (packet.length > UDP_MAX_DATAGRAM_BYTES) throw new Error('udp-datagram-too-large');
+    return packet;
+}
+
+export function decodeUdpPacket(packet, key) {
+    const bytes = asBuffer(packet);
+    if (bytes.length < UDP_FIXED_HEADER_BYTES + UDP_NONCE_BYTES + UDP_TAG_BYTES) return null;
+    if (!bytes.subarray(0, 4).equals(Buffer.from('LDU1', 'ascii')) || bytes[4] !== UDP_P2P_VERSION) return null;
+    const type = UDP_PACKET_TYPE_NAMES.get(bytes[5]);
+    const sessionLength = bytes[6];
+    const headerLength = bytes.readUInt16BE(7);
+    const payloadLength = bytes.readUInt16BE(9);
+    const sequence = bytes.readUInt32BE(11);
+    const associatedLength = UDP_FIXED_HEADER_BYTES + UDP_NONCE_BYTES + sessionLength + headerLength;
+    const expectedLength = associatedLength + payloadLength + UDP_TAG_BYTES;
+    if (!type || sessionLength < 1 || sessionLength > UDP_MAX_SESSION_ID_BYTES
+        || headerLength > UDP_MAX_HEADER_BYTES || payloadLength > UDP_MAX_PAYLOAD_BYTES
+        || expectedLength !== bytes.length) return null;
+
+    const associatedData = bytes.subarray(0, associatedLength);
+    const sessionStart = UDP_FIXED_HEADER_BYTES + UDP_NONCE_BYTES;
+    const sessionId = bytes.subarray(sessionStart, sessionStart + sessionLength).toString('utf8');
+    const headerStart = sessionStart + sessionLength;
+    let header;
+    try {
+        header = JSON.parse(bytes.subarray(headerStart, headerStart + headerLength).toString('utf8'));
+    } catch {
+        return null;
+    }
+    const nonce = bytes.subarray(UDP_FIXED_HEADER_BYTES, UDP_FIXED_HEADER_BYTES + UDP_NONCE_BYTES);
+    const ciphertextStart = associatedLength;
+    const ciphertext = bytes.subarray(ciphertextStart, ciphertextStart + payloadLength);
+    const tag = bytes.subarray(ciphertextStart + payloadLength);
+    try {
+        const decipher = crypto.createDecipheriv('aes-256-gcm', normalizeKey(key), nonce);
+        decipher.setAAD(associatedData);
+        decipher.setAuthTag(tag);
+        const payload = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        return { type, sessionId, sequence, header, payload };
+    } catch {
+        return null;
+    }
+}
+
+export class UdpReplayWindow {
+    constructor(size = 512) {
+        this.size = Math.max(32, Math.min(4096, Math.floor(Number(size) || 512)));
+        this.highest = -1;
+        this.seen = new Set();
+    }
+
+    accept(sequence) {
+        const value = Number(sequence) >>> 0;
+        if (this.highest >= 0 && value + this.size < this.highest) return false;
+        if (this.seen.has(value)) return false;
+        this.seen.add(value);
+        if (this.highest < 0 || value > this.highest) this.highest = value;
+        const minimum = Math.max(0, this.highest - this.size);
+        for (const item of this.seen) {
+            if (item < minimum) this.seen.delete(item);
+        }
+        return true;
+    }
+}
+
+export class UdpFrameReassembler {
+    constructor({ maxPending = 2, timeoutMs = 80, maxFrameBytes = 8 * 1024 * 1024 } = {}) {
+        this.maxPending = Math.max(1, Math.min(16, Math.floor(Number(maxPending) || 2)));
+        this.timeoutMs = Math.max(20, Math.min(2000, Math.floor(Number(timeoutMs) || 80)));
+        this.maxFrameBytes = Math.max(64 * 1024, Math.min(16 * 1024 * 1024, Math.floor(Number(maxFrameBytes) || 8 * 1024 * 1024)));
+        this.pending = new Map();
+    }
+
+    ingest(packet, now = Date.now()) {
+        if (!packet || packet.type !== 'frame') return null;
+        this.expire(now);
+        const header = packet.header && typeof packet.header === 'object' ? packet.header : {};
+        const frameId = String(header.frameId || '').slice(0, 160);
+        const chunkIndex = Number(header.chunkIndex);
+        const chunkCount = Number(header.chunkCount);
+        if (!frameId || !Number.isInteger(chunkIndex) || !Number.isInteger(chunkCount)
+            || chunkIndex < 0 || chunkCount < 1 || chunkCount > 4096 || chunkIndex >= chunkCount) return null;
+        let state = this.pending.get(frameId);
+        if (!state) {
+            while (this.pending.size >= this.maxPending) {
+                const oldest = this.pending.keys().next().value;
+                if (oldest === undefined) break;
+                this.pending.delete(oldest);
+            }
+            state = { createdAt: now, chunkCount, chunks: new Array(chunkCount), received: 0, totalBytes: 0, frameHeader: null };
+            this.pending.set(frameId, state);
+        }
+        if (state.chunkCount !== chunkCount || state.chunks[chunkIndex]) return null;
+        const payload = asBuffer(packet.payload);
+        state.chunks[chunkIndex] = payload;
+        state.received += 1;
+        state.totalBytes += payload.length;
+        if (header.frameHeader && typeof header.frameHeader === 'object') state.frameHeader = header.frameHeader;
+        if (state.totalBytes > this.maxFrameBytes) {
+            this.pending.delete(frameId);
+            return null;
+        }
+        if (state.received !== state.chunkCount) return null;
+        this.pending.delete(frameId);
+        return {
+            frameId,
+            header: state.frameHeader || header.frameHeader || {},
+            payload: Buffer.concat(state.chunks, state.totalBytes)
+        };
+    }
+
+    expire(now = Date.now()) {
+        for (const [frameId, state] of this.pending) {
+            if (now - state.createdAt > this.timeoutMs) this.pending.delete(frameId);
+        }
+    }
+}
+
+export function encodeRendezvousMessage(message) {
+    const payload = Buffer.from(JSON.stringify(message && typeof message === 'object' ? message : {}), 'utf8');
+    if (payload.length > UDP_MAX_DATAGRAM_BYTES) throw new Error('rendezvous-message-too-large');
+    return payload;
+}
+
+export function decodeRendezvousMessage(payload) {
+    try {
+        const value = JSON.parse(asBuffer(payload).toString('utf8'));
+        return value && typeof value === 'object' ? value : null;
+    } catch {
+        return null;
+    }
+}

package/src/transport/udp-rendezvous.js

@@ -0,0 +1,78 @@
+import dgram from 'node:dgram';
+import { decodeRendezvousMessage, encodeRendezvousMessage, UDP_MAX_DATAGRAM_BYTES } from './udp-protocol.js';
+
+function safeText(value, max = 160) {
+    return String(value || '').replace(/[\r\n\t]/g, ' ').trim().slice(0, max);
+}
+
+function normalizePort(value, fallback) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 0 && port <= 65535 ? port : fallback;
+}
+
+export function createUdpRendezvousServer({ host = '0.0.0.0', port = 5199, log = () => {} } = {}) {
+    const socket = dgram.createSocket('udp4');
+    const rooms = new Map();
+    let started = false;
+    let boundPort = normalizePort(port, 5199);
+
+    function send(message, address, targetPort) {
+        const payload = encodeRendezvousMessage(message);
+        socket.send(payload, targetPort, address);
+    }
+
+    function onMessage(payload, rinfo) {
+        if (!Buffer.isBuffer(payload) || payload.length > UDP_MAX_DATAGRAM_BYTES) return;
+        const message = decodeRendezvousMessage(payload);
+        if (message?.type !== 'rendezvous.register') return;
+        const roomId = safeText(message.roomId, 160);
+        const role = safeText(message.role, 16).toLowerCase();
+        const token = safeText(message.token, 256);
+        if (!roomId || !token || !['hub', 'client'].includes(role)) return;
+        let room = rooms.get(roomId);
+        if (!room || room.token !== token || Date.now() - room.updatedAt > 60_000) {
+            room = { token, peers: new Map(), updatedAt: Date.now() };
+            rooms.set(roomId, room);
+        }
+        room.updatedAt = Date.now();
+        room.peers.set(role, { address: rinfo.address, port: rinfo.port });
+        const peers = [...room.peers.entries()];
+        if (peers.length < 2) return;
+        for (const [peerRole, peer] of peers) {
+            const other = peers.find(([candidateRole]) => candidateRole !== peerRole)?.[1];
+            if (!other) continue;
+            send({ type: 'rendezvous.peer', roomId, role: peerRole === 'hub' ? 'client' : 'hub', host: other.address, port: other.port }, peer.address, peer.port);
+        }
+    }
+
+    socket.on('message', onMessage);
+    socket.on('error', error => log(`UDP rendezvous error: ${error?.message || error}`));
+
+    async function start() {
+        if (started) return { host, port: boundPort };
+        await new Promise((resolve, reject) => {
+            const onError = error => { socket.off('listening', onListening); reject(error); };
+            const onListening = () => { socket.off('error', onError); resolve(); };
+            socket.once('error', onError);
+            socket.once('listening', onListening);
+            socket.bind(boundPort, host);
+        });
+        started = true;
+        boundPort = socket.address().port;
+        log(`UDP rendezvous listening on udp://${host}:${boundPort}`);
+        return { host, port: boundPort };
+    }
+
+    async function close() {
+        rooms.clear();
+        if (!started) return;
+        await new Promise(resolve => socket.close(() => resolve()));
+        started = false;
+    }
+
+    return {
+        start,
+        close,
+        getStatus: () => ({ started, host, port: boundPort, rooms: rooms.size })
+    };
+}