@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/dtls/socket.js

@@ -0,0 +1,184 @@
+import { setTimeout } from 'node:timers/promises';
+import { Event, binaryData, debug, runDetached } from './imports/common.js';
+import { NamedCurveAlgorithmList, signatures } from './cipher/const.js';
+import { exportKeyingMaterial } from './cipher/prf.js';
+import { SessionType } from './cipher/suites/abstract.js';
+import { CipherContext } from './context/cipher.js';
+import { DtlsContext } from './context/dtls.js';
+import { SrtpContext } from './context/srtp.js';
+import { TransportContext } from './context/transport.js';
+import { EllipticCurves } from './handshake/extensions/ellipticCurves.js';
+import { ExtendedMasterSecret } from './handshake/extensions/extendedMasterSecret.js';
+import { RenegotiationIndication } from './handshake/extensions/renegotiationIndication.js';
+import { Signature } from './handshake/extensions/signature.js';
+import { UseSRTP } from './handshake/extensions/useSrtp.js';
+import { createPlaintext } from './record/builder.js';
+import { ContentType } from './record/const.js';
+import { FragmentedHandshake } from './record/message/fragment.js';
+import { parsePacket, parsePlainText } from './record/receive.js';
+const { decode, types } = binaryData;
+const log = debug('webrtc/dtls/socket:log');
+const err = debug('webrtc/dtls/socket:err');
+export class DtlsSocket {
+    constructor(options, sessionType) {
+        this.options = options;
+        this.sessionType = sessionType;
+        this.onConnect = new Event();
+        this.onData = new Event();
+        this.onError = new Event();
+        this.onClose = new Event();
+        this.srtp = new SrtpContext();
+        this.connected = false;
+        this.extensions = [];
+        this.bufferFragmentedHandshakes = [];
+        this.udpOnMessage = (data) => {
+            const packets = parsePacket(data);
+            for (const packet of packets) {
+                try {
+                    const messages = parsePlainText(this.dtls, this.cipher)(packet);
+                    for (const message of messages) {
+                        switch (message.type) {
+                            case ContentType.handshake:
+                                {
+                                    const handshake = message.data;
+                                    const handshakes = this.handleFragmentHandshake([handshake]);
+                                    const assembled = Object.values(handshakes.reduce((acc, cur) => {
+                                        if (!acc[cur.msg_type])
+                                            acc[cur.msg_type] = [];
+                                        acc[cur.msg_type].push(cur);
+                                        return acc;
+                                    }, {}))
+                                        .map((v) => FragmentedHandshake.assemble(v))
+                                        .sort((a, b) => a.msg_type - b.msg_type);
+                                    this.onHandleHandshakes(assembled).catch((error) => {
+                                        err(this.dtls.sessionId, 'onHandleHandshakes error', error);
+                                        this.onError.execute(error);
+                                    });
+                                }
+                                break;
+                            case ContentType.applicationData:
+                                {
+                                    this.onData.execute(message.data);
+                                }
+                                break;
+                            case ContentType.alert:
+                                this.onClose.execute();
+                                break;
+                        }
+                    }
+                }
+                catch (error) {
+                    err(this.dtls.sessionId, 'catch udpOnMessage error', error);
+                }
+            }
+        };
+        this.waitForReady = async (condition) => {
+            for (let i = 0; i < 10; i++) {
+                if (condition())
+                    return;
+                await setTimeout(100 * i);
+            }
+            throw new Error('waitForReady timeout');
+        };
+        /**send application data */
+        this.send = async (buf, addr) => {
+            const pkt = createPlaintext(this.dtls)([{ type: ContentType.applicationData, fragment: buf }], ++this.dtls.recordSequenceNumber)[0];
+            await this.transport.send(this.cipher.encryptPacket(pkt).serialize(), addr);
+        };
+        this.dtls = new DtlsContext(this.options, this.sessionType);
+        this.cipher = new CipherContext(this.sessionType, this.options.cert, this.options.key, this.options.signatureHash);
+        this.transport = new TransportContext(this.options.transport);
+        this.setupExtensions();
+        this.transport.socket.onData = this.udpOnMessage;
+    }
+    renegotiation() {
+        log('renegotiation', this.sessionType);
+        this.connected = false;
+        this.cipher = new CipherContext(this.sessionType, this.options.cert, this.options.key, this.options.signatureHash);
+        this.dtls = new DtlsContext(this.options, this.sessionType);
+        this.srtp = new SrtpContext();
+        this.extensions = [];
+        this.bufferFragmentedHandshakes = [];
+    }
+    setupExtensions() {
+        log(this.dtls.sessionId, 'support srtpProfiles', this.options.srtpProfiles);
+        if (this.options.srtpProfiles && this.options.srtpProfiles.length > 0) {
+            const useSrtp = UseSRTP.create(this.options.srtpProfiles, Buffer.from([0x00]));
+            this.extensions.push(useSrtp.extension);
+        }
+        {
+            const curve = EllipticCurves.createEmpty();
+            curve.data = NamedCurveAlgorithmList;
+            this.extensions.push(curve.extension);
+        }
+        {
+            const signature = Signature.createEmpty();
+            // libwebrtc/OpenSSL require 4=1 , 4=3 signatureHash
+            signature.data = signatures;
+            this.extensions.push(signature.extension);
+        }
+        if (this.options.extendedMasterSecret) {
+            this.extensions.push({
+                type: ExtendedMasterSecret.type,
+                data: Buffer.alloc(0)
+            });
+        }
+        {
+            const renegotiationIndication = RenegotiationIndication.createEmpty();
+            this.extensions.push(renegotiationIndication.extension);
+        }
+    }
+    handleFragmentHandshake(messages) {
+        let handshakes = messages.filter((v) => {
+            // find fragmented
+            if (v.fragment_length !== v.length) {
+                this.bufferFragmentedHandshakes.push(v);
+                return false;
+            }
+            return true;
+        });
+        if (this.bufferFragmentedHandshakes.length > 1) {
+            const [last] = this.bufferFragmentedHandshakes.slice(-1);
+            if (last.fragment_offset + last.fragment_length === last.length) {
+                handshakes = [...this.bufferFragmentedHandshakes, ...handshakes];
+                this.bufferFragmentedHandshakes = [];
+            }
+        }
+        return handshakes; // return un fragmented handshakes
+    }
+    close() {
+        this.transport.close();
+        runDetached(() => this.transport.socket.close(), (error) => log('close failed', error));
+    }
+    extractSessionKeys(keyLength, saltLength) {
+        const keyingMaterial = this.exportKeyingMaterial('EXTRACTOR-dtls_srtp', keyLength * 2 + saltLength * 2);
+        const { clientKey, serverKey, clientSalt, serverSalt } = decode(keyingMaterial, {
+            clientKey: types.buffer(keyLength),
+            serverKey: types.buffer(keyLength),
+            clientSalt: types.buffer(saltLength),
+            serverSalt: types.buffer(saltLength)
+        });
+        if (this.sessionType === SessionType.CLIENT) {
+            return {
+                localKey: clientKey,
+                localSalt: clientSalt,
+                remoteKey: serverKey,
+                remoteSalt: serverSalt
+            };
+        }
+        else {
+            return {
+                localKey: serverKey,
+                localSalt: serverSalt,
+                remoteKey: clientKey,
+                remoteSalt: clientSalt
+            };
+        }
+    }
+    exportKeyingMaterial(label, length) {
+        return exportKeyingMaterial(label, length, this.cipher.masterSecret, this.cipher.localRandom.serialize(), this.cipher.remoteRandom.serialize(), this.sessionType === SessionType.CLIENT);
+    }
+    get remoteCertificate() {
+        return this.cipher.remoteCertificate;
+    }
+}

package/dist/esm/lib/dtls/typings/domain.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/lib/dtls/util/binary.js

@@ -0,0 +1,5 @@
+import { binaryData } from '../imports/common.js';
+const { encode } = binaryData;
+export function encodeBuffer(obj, spec) {
+    return encode(obj, spec);
+}

package/dist/esm/lib/ice/candidate.js

@@ -0,0 +1,190 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { isIPv4 } from 'node:net';
+export class Candidate {
+    constructor(foundation, component, transport, priority, host, port, type, relatedAddress, relatedPort, tcptype, generation, ufrag) {
+        this.foundation = foundation;
+        this.component = component;
+        this.transport = transport;
+        this.priority = priority;
+        this.host = host;
+        this.port = port;
+        this.type = type;
+        this.relatedAddress = relatedAddress;
+        this.relatedPort = relatedPort;
+        this.tcptype = tcptype;
+        this.generation = generation;
+        this.ufrag = ufrag;
+        // An ICE candidate.
+        this.id = randomUUID().toString();
+    }
+    refreshId() {
+        this.id = randomUUID().toString();
+    }
+    static fromSdp(sdp) {
+        // Parse a :class:`Candidate` from SDP.
+        // .. code-block:: python
+        //    Candidate.from_sdp(
+        //     '6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0 ufrag b7l3')
+        const bits = sdp.split(' ');
+        if (bits.length < 8) {
+            throw new Error('SDP does not have enough properties');
+        }
+        // 固定ワード
+        const kwargs = {
+            foundation: bits[0],
+            component: Number(bits[1]),
+            transport: bits[2],
+            priority: Number(bits[3]),
+            host: bits[4],
+            port: Number(bits[5]),
+            type: bits[7]
+        };
+        for (let i = 8, il = bits.length - 1; i < il; i += 2) {
+            if (bits[i] === 'raddr') {
+                kwargs['related_address'] = bits[i + 1];
+            }
+            else if (bits[i] === 'rport') {
+                kwargs['related_port'] = Number(bits[i + 1]);
+            }
+            else if (bits[i] === 'tcptype') {
+                kwargs['tcptype'] = bits[i + 1];
+            }
+            else if (bits[i] === 'generation') {
+                kwargs['generation'] = Number(bits[i + 1]);
+            }
+            else if (bits[i] === 'ufrag') {
+                kwargs['ufrag'] = bits[i + 1];
+            }
+        }
+        const { foundation, component, transport, priority, host, port, type } = kwargs;
+        return new Candidate(foundation, component, transport, priority, host, port, type, kwargs['related_address'], kwargs['related_port'], kwargs['tcptype'], kwargs['generation'], kwargs['ufrag']);
+    }
+    canPairWith(other) {
+        // """
+        // A local candidate is paired with a remote candidate if and only if
+        // the two candidates have the same component ID and have the same IP
+        // address version.
+        // """
+        const a = isIPv4(this.host);
+        const b = isIPv4(other.host);
+        return (this.component === other.component &&
+            this.transport.toLowerCase() === other.transport.toLowerCase() &&
+            canPairTcpCandidates(this, other) &&
+            a === b);
+    }
+    toSdp() {
+        let sdp = `${this.foundation} ${this.component} ${this.transport} ${this.priority} ${this.host} ${this.port} typ ${this.type}`;
+        if (this.relatedAddress)
+            sdp += ` raddr ${this.relatedAddress}`;
+        if (this.relatedPort != undefined)
+            sdp += ` rport ${this.relatedPort}`;
+        if (this.tcptype)
+            sdp += ` tcptype ${this.tcptype}`;
+        if (this.generation != undefined)
+            sdp += ` generation ${this.generation}`;
+        if (this.ufrag != undefined)
+            sdp += ` ufrag ${this.ufrag}`;
+        return sdp;
+    }
+}
+const UDP_TYPE_PREFERENCE = {
+    host: 126,
+    prflx: 110,
+    srflx: 100,
+    relay: 0
+};
+const TCP_TYPE_PREFERENCE = {
+    host: 105,
+    prflx: 90,
+    srflx: 80,
+    relay: 0
+};
+const ACTIVE_PASSIVE_DIRECTION_PREFERENCE = {
+    active: 6,
+    passive: 4,
+    so: 2
+};
+const REFLEXIVE_DIRECTION_PREFERENCE = {
+    active: 4,
+    passive: 2,
+    so: 6
+};
+function normalizeTransport(transport) {
+    return transport?.toLowerCase() ?? 'udp';
+}
+function normalizeTcpType(tcptype) {
+    switch (tcptype) {
+        case 'active':
+        case 'passive':
+        case 'so':
+            return tcptype;
+        default:
+            return undefined;
+    }
+}
+function canPairTcpCandidates(local, remote) {
+    if (normalizeTransport(local.transport) !== 'tcp') {
+        return true;
+    }
+    const localType = normalizeTcpType(local.tcptype);
+    const remoteType = normalizeTcpType(remote.tcptype);
+    if (!localType || !remoteType) {
+        return false;
+    }
+    return ((localType === 'active' && remoteType === 'passive') ||
+        (localType === 'passive' && remoteType === 'active') ||
+        (localType === 'so' && remoteType === 'so'));
+}
+export function candidateLocalPreference({ candidateType, transport = 'udp', tcptype, otherPreference = 8191 }) {
+    if (normalizeTransport(transport) !== 'tcp') {
+        return otherPreference;
+    }
+    const tcpType = normalizeTcpType(tcptype) ?? 'active';
+    const directionPreference = candidateType === 'srflx' || candidateType === 'prflx'
+        ? REFLEXIVE_DIRECTION_PREFERENCE[tcpType]
+        : ACTIVE_PASSIVE_DIRECTION_PREFERENCE[tcpType];
+    return (1 << 13) * directionPreference + otherPreference;
+}
+function candidateTypePreference(candidateType, transport = 'udp') {
+    const table = normalizeTransport(transport) === 'tcp'
+        ? TCP_TYPE_PREFERENCE
+        : UDP_TYPE_PREFERENCE;
+    return table[candidateType] ?? 0;
+}
+export function candidateFoundation(candidateType, candidateTransport, baseAddress, server) {
+    // """
+    // See RFC 5245 - 4.1.1.3. Computing Foundations
+    // """
+    //The candidates from different STUN or TURN servers have different foundations (RFC 8445, section 5.1.1.3)
+    const key = server === undefined
+        ? `${candidateType}|${candidateTransport}|${baseAddress}`
+        : `${candidateType}|${candidateTransport}|${baseAddress}|${server}`;
+    return createHash('md5').update(key, 'ascii').digest('hex').slice(7);
+}
+// priorityを決める
+export function candidatePriority(candidateType, options = 65535) {
+    const candidateComponent = 1;
+    // See RFC 5245 - 4.1.2.1. Recommended Formula
+    const transport = typeof options === 'number' ? 'udp' : normalizeTransport(options.transport);
+    const localPref = typeof options === 'number'
+        ? options
+        : (options.localPreference ??
+            candidateLocalPreference({
+                candidateType,
+                transport,
+                tcptype: options.tcptype,
+                otherPreference: options.otherPreference
+            }));
+    const typePref = candidateTypePreference(candidateType, transport);
+    return ((1 << 24) * typePref + (1 << 8) * localPref + (256 - candidateComponent));
+}
+export function remoteTcpTypeForIncoming(localTcpType) {
+    switch (localTcpType) {
+        case 'passive':
+            return 'active';
+        case 'active':
+            return 'passive';
+        default:
+            return 'so';
+    }
+}

package/dist/esm/lib/ice/dns/lookup.js

@@ -0,0 +1,95 @@
+import * as worker_thread from 'node:worker_threads';
+import { MulticastDns } from './mdns.js';
+export class MdnsLookup {
+    constructor() {
+        this.cache = new Map();
+        this.mdnsInstance = new MulticastDns();
+        this.mdnsInstance.setMaxListeners(50);
+    }
+    lookup(host) {
+        return new Promise((r, f) => {
+            const cleanup = () => {
+                this.mdnsInstance.removeListener('response', l);
+                clearTimeout(timeout);
+            };
+            const timeout = setTimeout(() => {
+                cleanup();
+                f(new Error('No mDNS response'));
+            }, 10000);
+            const l = (answers) => {
+                const a = answers.find((answer) => answer.type === 'A' &&
+                    answer.name.toLowerCase() === host.toLowerCase());
+                if (!a) {
+                    return;
+                }
+                cleanup();
+                r(a.data);
+            };
+            this.mdnsInstance.on('response', l);
+            this.mdnsInstance.query(host, 'A').catch((error) => {
+                cleanup();
+                f(error);
+            });
+        });
+    }
+    close() {
+        this.mdnsInstance.destroy();
+    }
+}
+export class DnsLookup {
+    constructor() {
+        this.cache = new Map();
+        const lookupWorkerFunction = () => {
+            const worker_thread = global.require('worker_threads');
+            const { lookup } = global.require('dns');
+            const dnsLookup = (host) => lookup(host, (err, address, family) => {
+                const res = {
+                    err: err?.message,
+                    address,
+                    family,
+                    host
+                };
+                worker_thread.parentPort?.postMessage(res);
+                process.exit();
+            });
+            worker_thread.parentPort?.on('message', (message) => {
+                const { host } = message;
+                dnsLookup(host);
+            });
+        };
+        const lookupEval = `(${lookupWorkerFunction})()`;
+        this.thread = new worker_thread.Worker(lookupEval, {
+            eval: true
+        });
+        this.thread.setMaxListeners(100);
+    }
+    async lookup(host) {
+        let cached = this.cache.get(host);
+        if (cached) {
+            return cached;
+        }
+        cached = new Promise((r, f) => {
+            const exitListener = (exitCode) => f(new Error(`dns.lookup thread exited unexpectedly: ${exitCode}`));
+            const threadMessageListener = (result) => {
+                if (result.host !== host) {
+                    return;
+                }
+                this.thread.removeListener('message', threadMessageListener);
+                this.thread.removeListener('exit', exitListener);
+                if (!result.address)
+                    return f(new Error(result.err || 'dns.lookup thread unknown error'));
+                r(result.address);
+            };
+            this.thread.on('message', threadMessageListener);
+            this.thread.on('exit', exitListener);
+            this.thread.postMessage({
+                host
+            });
+        });
+        this.cache.set(host, cached);
+        return cached;
+    }
+    close() {
+        return this.thread.terminate();
+    }
+}

package/dist/esm/lib/ice/dns/mdns.js

@@ -0,0 +1,139 @@
+import { createSocket } from 'node:dgram';
+import { EventEmitter } from 'node:events';
+const multicastAddress = '224.0.0.251';
+const multicastPort = 5353;
+const typeCodes = { A: 1, AAAA: 28 };
+//A name as DNS labels: each label prefixed with its length, then a zero
+function encodeName(name) {
+    const parts = name.replace(/\.$/, '').split('.').map((label) => {
+        const bytes = Buffer.from(label, 'utf8');
+        return Buffer.concat([Buffer.from([bytes.length]), bytes]);
+    });
+    return Buffer.concat([...parts, Buffer.from([0])]);
+}
+//A name at an offset, following the compression pointers (RFC 1035 section 4.1.4); the offset after it
+function decodeName(packet, start) {
+    const labels = [];
+    let offset = start;
+    let end = -1;
+    for (let jumps = 0; jumps < 64; jumps++) {
+        const length = packet[offset];
+        if (length === undefined)
+            throw new Error('truncated name');
+        if (length === 0) {
+            offset++;
+            break;
+        }
+        if ((length & 0xc0) === 0xc0) {
+            if (end < 0)
+                end = offset + 2;
+            offset = ((length & 0x3f) << 8) | packet[offset + 1];
+            continue;
+        }
+        labels.push(packet.toString('utf8', offset + 1, offset + 1 + length));
+        offset += 1 + length;
+    }
+    return [labels.join('.'), end < 0 ? offset : end];
+}
+function formatAddress(type, data) {
+    if (type === typeCodes.A && data.length === 4)
+        return Array.from(data).join('.');
+    if (type === typeCodes.AAAA && data.length === 16) {
+        const groups = [];
+        for (let i = 0; i < 16; i += 2)
+            groups.push(data.readUInt16BE(i).toString(16));
+        return groups.join(':');
+    }
+    return data;
+}
+/**
+ * The answers (and additional records) of an mDNS response; undefined when the packet is a query or malformed
+ */
+export function parseMdnsResponse(packet) {
+    try {
+        if (packet.length < 12 || !(packet[2] & 0x80))
+            return undefined;
+        const questions = packet.readUInt16BE(4);
+        const records = packet.readUInt16BE(6) + packet.readUInt16BE(8) + packet.readUInt16BE(10);
+        let offset = 12;
+        for (let i = 0; i < questions; i++)
+            offset = decodeName(packet, offset)[1] + 4;
+        const answers = [];
+        for (let i = 0; i < records; i++) {
+            const [name, next] = decodeName(packet, offset);
+            const type = packet.readUInt16BE(next);
+            const ttl = packet.readUInt32BE(next + 4);
+            const length = packet.readUInt16BE(next + 8);
+            const data = packet.subarray(next + 10, next + 10 + length);
+            offset = next + 10 + length;
+            const known = type === typeCodes.A ? 'A' : type === typeCodes.AAAA ? 'AAAA' : undefined;
+            answers.push({ name, type: known ?? type, ttl, data: formatAddress(type, data) });
+        }
+        return answers;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A query of one name: no id, no flags, one question of class IN
+ */
+export function encodeMdnsQuery(name, type) {
+    const header = Buffer.alloc(12);
+    header.writeUInt16BE(1, 4);
+    const question = Buffer.alloc(4);
+    question.writeUInt16BE(typeCodes[type], 0);
+    question.writeUInt16BE(1, 2);
+    return Buffer.concat([header, encodeName(name), question]);
+}
+/**
+ * A client of multicast DNS (RFC 6762) that only queries: it joins the group on port 5353 (shared with the other
+ * responders of the host) and emits the answers of every response it hears
+ */
+export class MulticastDns extends EventEmitter {
+    #socket;
+    #ready;
+    constructor() {
+        super();
+        this.#socket = createSocket({ type: 'udp4', reuseAddr: true });
+        this.#socket.on('error', (error) => void this.emit('error', error));
+        this.#socket.on('message', (message, remote) => {
+            const answers = parseMdnsResponse(message);
+            if (answers?.length)
+                this.emit('response', answers, remote);
+        });
+        this.#ready = new Promise((resolve) => {
+            this.#socket.bind(multicastPort, () => {
+                try {
+                    this.#socket.addMembership(multicastAddress);
+                    this.#socket.setMulticastTTL(255);
+                    this.#socket.setMulticastLoopback(true);
+                }
+                catch (error) {
+                    this.emit('error', error);
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Sends a query of a name to the group
+     */
+    async query(name, type = 'A') {
+        await this.#ready;
+        await new Promise((resolve, reject) => {
+            this.#socket.send(encodeMdnsQuery(name, type), multicastPort, multicastAddress, (error) => error ? reject(error) : resolve());
+        });
+    }
+    /**
+     * Leaves the group and closes the socket
+     */
+    destroy() {
+        try {
+            this.#socket.close();
+        }
+        catch {
+            //Already closed
+        }
+    }
+}

package/dist/esm/lib/ice/exceptions.js

@@ -0,0 +1,34 @@
+export class TransactionError extends Error {
+}
+export class TransactionFailed extends TransactionError {
+    constructor(response, addr) {
+        super();
+        this.response = response;
+        this.addr = addr;
+    }
+    get str() {
+        let out = 'STUN transaction failed';
+        const attribute = this.response.getAttributeValue('ERROR-CODE');
+        if (attribute) {
+            const [code, msg] = attribute;
+            out += ` (${code} - ${msg})`;
+        }
+        return out;
+    }
+}
+export class TransactionTimeout extends TransactionError {
+    get str() {
+        return 'STUN transaction timed out';
+    }
+}
+/**
+ * The request target is an IP literal of a different family than the socket
+ * that would carry it, so it can never be delivered.
+ */
+export class AddressFamilyMismatch extends Error {
+    constructor(addr, socketFamily) {
+        super(`cannot reach ${addr[0]}:${addr[1]} from an IPv${socketFamily} socket`);
+        this.addr = addr;
+        this.socketFamily = socketFamily;
+    }
+}