@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/common/transport.d.ts

@@ -0,0 +1,104 @@
+import { type RemoteInfo, type Socket, type SocketType } from 'node:dgram';
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { type AddressInfo } from 'node:net';
+import { type Address, type InterfaceAddresses } from './network.js';
+export type TlsConnectionOptions = Omit<tls.ConnectionOptions, 'host' | 'port' | 'socket'>;
+export interface StreamTransportOptions {
+    /** Maximum time to wait for TCP/TLS connection establishment, in milliseconds. */
+    connectTimeoutMs?: number;
+}
+/**
+ * Grow the receive buffer of a bound UDP socket to 4 MiB, as far as the system allows (net.core.rmem_max on Linux); a
+ * buffer larger already is kept
+ * @param socket
+ */
+export declare function growReceiveBuffer(socket: Socket): void;
+export declare class UdpTransport implements Transport {
+    private socketType;
+    private options;
+    readonly type = "udp";
+    readonly socket: Socket;
+    rinfo?: Partial<Pick<RemoteInfo, 'address' | 'port'>>;
+    onData: (data: Buffer, addr: Address) => void;
+    closed: boolean;
+    private connected?;
+    private connectOnReceive?;
+    private connecting?;
+    private waiting?;
+    private constructor();
+    static init(type: SocketType, options?: {
+        portRange?: [number, number];
+        port?: number;
+        interfaceAddresses?: InterfaceAddresses;
+    }): Promise<UdpTransport>;
+    private init;
+    /**
+     * Send only to an address from now on (the other side of the pair ICE selected), once application data comes from
+     * it: the other side sends its data on the pair then (a reply to a check does not tell it). Connected, the socket
+     * sends without the lookup and the routing of the address of each packet, and drops what it is asked to send
+     * elsewhere; the system drops the packets of the other addresses
+     * @param addr An IP address
+     */
+    connectTo(addr: Address): void;
+    /**
+     * Send to any address again
+     */
+    disconnect(): void;
+    private connectNow;
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    get address(): net.AddressInfo;
+    /** IP family of the bound socket: 4 for udp4, 6 for udp6. */
+    get addressFamily(): IpAddressFamily;
+    get host(): string;
+    get port(): number;
+    close: () => Promise<void>;
+}
+export declare class TcpTransport implements Transport {
+    readonly type: "tcp";
+    private readonly stream;
+    private constructor();
+    static init(addr: Address, options?: StreamTransportOptions): Promise<TcpTransport>;
+    private init;
+    get address(): net.AddressInfo;
+    get remoteAddress(): readonly [string, number] | undefined;
+    get closed(): boolean;
+    get onData(): (data: Buffer, addr: Address) => void;
+    set onData(handler: (data: Buffer, addr: Address) => void);
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+}
+export declare class TlsTransport implements Transport {
+    readonly type: "tls";
+    private readonly stream;
+    private constructor();
+    static init(addr: Address, options?: TlsConnectionOptions, streamOptions?: StreamTransportOptions): Promise<TlsTransport>;
+    private init;
+    get address(): net.AddressInfo;
+    get remoteAddress(): readonly [string, number] | undefined;
+    get closed(): boolean;
+    get onData(): (data: Buffer, addr: Address) => void;
+    set onData(handler: (data: Buffer, addr: Address) => void);
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+}
+export type IpAddressFamily = 4 | 6;
+export interface Transport {
+    type: string;
+    address: AddressInfo;
+    closed: boolean;
+    onData: (data: Buffer, addr: Address) => void;
+    send: (data: Buffer, addr?: Address) => Promise<void>;
+    close: () => Promise<void>;
+    /**
+   * IP family of a datagram socket. A datagram transport can only reach
+   * addresses of this family. Built-in UDP transports always set it; a custom
+   * transport that leaves it unset gets no family preference.
+   */
+    addressFamily?: IpAddressFamily;
+    /**
+   * The peer a connected (stream) transport is talking to. Responses arrive
+   * from this address. Built-in TCP/TLS transports set it once connected.
+   */
+    remoteAddress?: Address;
+}

package/dist/cjs/lib/common/transport.js

@@ -0,0 +1,441 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlsTransport = exports.TcpTransport = exports.UdpTransport = void 0;
+exports.growReceiveBuffer = growReceiveBuffer;
+const node_dgram_1 = require("node:dgram");
+const net = __importStar(require("node:net"));
+const tls = __importStar(require("node:tls"));
+const node_net_1 = require("node:net");
+const log_js_1 = require("./log.js");
+const network_js_1 = require("./network.js");
+const log = (0, log_js_1.debug)('webrtc/common/transport');
+const DEFAULT_CONNECT_TIMEOUT_MS = 8000;
+/**
+ * The receive buffer of the UDP sockets of the connections and of the TURN server at least, in bytes. It holds what
+ * the receive window of SCTP (1 MiB) lets the other side send before the process reads it: about 900 packets, each
+ * taking 2 KiB of buffer or more in the system. With 1 MiB, a sender faster than the receiver overflowed it before the
+ * window stopped it (about 2% of the packets of a bulk transfer lost, and resent); the default of Linux (208 KiB) drops
+ * the packets of a burst too (15% of 50,000 packets a second). A size the system caps: net.core.rmem_max on Linux,
+ * 208 KiB by default, kern.ipc.maxsockbuf on macOS (8 MiB). The memory is taken only while packets wait in it
+ */
+const RECEIVE_BUFFER_SIZE = 4 * 1024 * 1024;
+/**
+ * Grow the receive buffer of a bound UDP socket to 4 MiB, as far as the system allows (net.core.rmem_max on Linux); a
+ * buffer larger already is kept
+ * @param socket
+ */
+function growReceiveBuffer(socket) {
+    try {
+        if (socket.getRecvBufferSize() < RECEIVE_BUFFER_SIZE)
+            socket.setRecvBufferSize(RECEIVE_BUFFER_SIZE);
+    }
+    catch (error) {
+        log('the receive buffer cannot grow', error);
+    }
+}
+/**
+ * Whether two addresses are the same
+ * @param a
+ * @param b
+ */
+function sameAddress(a, b) {
+    return a === b || (a[1] === b[1] && a[0] === b[0]);
+}
+class UdpTransport {
+    constructor(socketType, options = {}) {
+        this.socketType = socketType;
+        this.options = options;
+        this.type = 'udp';
+        this.onData = () => { };
+        this.closed = false;
+        this.send = async (data, addr) => {
+            const connected = this.connected;
+            if (connected) {
+                if (!addr || sameAddress(addr, connected)) {
+                    this.socket.send(data);
+                }
+                else {
+                    //Another pair: a check retransmitted after the selection, which the connected socket cannot send
+                    log('not sent to an address other than the connected one', addr);
+                }
+                return;
+            }
+            if (this.waiting) {
+                this.waiting.push([data, addr]);
+                return;
+            }
+            if (addr && !net.isIP(addr[0])) {
+                // if address is not resolved, need to use send callback to handle dns failure.
+                return new Promise((r, f) => {
+                    this.socket.send(data, addr[1], addr[0], (error) => {
+                        if (error) {
+                            log('send error', addr, data);
+                            f(error);
+                        }
+                        else {
+                            r();
+                        }
+                    });
+                });
+            }
+            else {
+                addr = addr ?? [this.rinfo.address, this.rinfo.port];
+                // a preestablished remote address does not need a callback to verify dns.
+                // this is faster because event loop is not used per packet.
+                this.socket.send(data, addr[1], addr[0]);
+            }
+        };
+        this.close = () => new Promise((r) => {
+            this.closed = true;
+            this.connectOnReceive = undefined;
+            this.connecting = undefined;
+            this.connected = undefined;
+            this.waiting = undefined;
+            this.socket.once('close', r);
+            try {
+                this.socket.close();
+            }
+            catch (error) {
+                r();
+            }
+        });
+        this.socket = (0, node_dgram_1.createSocket)(socketType);
+        this.socket.on('message', (data, info) => {
+            if ((0, network_js_1.normalizeFamilyNodeV18)(info.family) === 6) {
+                [info.address] = info.address.split('%'); // example fe80::1d3a:8751:4ffd:eb80%wlp82s0
+            }
+            this.rinfo = info;
+            //Application data (not STUN, whose first byte is 0 to 3) from the address: the other side sends on the pair
+            if (this.connectOnReceive && data[0] > 3 && info.port === this.connectOnReceive[1] && info.address === this.connectOnReceive[0])
+                this.connectNow(this.connectOnReceive);
+            try {
+                this.onData(data, [info.address, info.port]);
+            }
+            catch (error) {
+                log('onData error', error);
+            }
+        });
+    }
+    static async init(type, options = {}) {
+        const transport = new UdpTransport(type, options);
+        await transport.init();
+        return transport;
+    }
+    async init() {
+        const address = (0, network_js_1.interfaceAddress)(this.socketType, this.options.interfaceAddresses);
+        if (this.options.port) {
+            this.socket.bind({ port: this.options.port, address });
+        }
+        else if (this.options.portRange) {
+            const port = await (0, network_js_1.findPort)(this.options.portRange[0], this.options.portRange[1], this.socketType, this.options.interfaceAddresses);
+            this.socket.bind({ port, address });
+        }
+        else {
+            //A port the system chooses, given to bind: Linux frees a port it chose for a bind to port 0 when the socket
+            //disconnects (the socket of the pair ICE selected does, before an ICE restart), a port given to bind is kept
+            this.socket.bind({ port: await (0, network_js_1.randomPort)(this.socketType, this.options.interfaceAddresses), address });
+        }
+        await new Promise((resolve, reject) => {
+            const failed = (error) => reject(error);
+            this.socket.once('error', failed);
+            this.socket.once('listening', () => {
+                this.socket.off('error', failed);
+                resolve();
+            });
+        });
+        //A connected socket is told the errors of its address (ICMP port unreachable on Linux): they only end the
+        //packets sent there, which ICE notices
+        this.socket.on('error', (error) => log('socket error', error));
+        growReceiveBuffer(this.socket);
+    }
+    /**
+     * Send only to an address from now on (the other side of the pair ICE selected), once application data comes from
+     * it: the other side sends its data on the pair then (a reply to a check does not tell it). Connected, the socket
+     * sends without the lookup and the routing of the address of each packet, and drops what it is asked to send
+     * elsewhere; the system drops the packets of the other addresses
+     * @param addr An IP address
+     */
+    connectTo(addr) {
+        if (this.closed || this.connected || this.waiting || !net.isIP(addr[0]))
+            return;
+        this.connectOnReceive = addr;
+    }
+    /**
+     * Send to any address again
+     */
+    disconnect() {
+        this.connectOnReceive = undefined;
+        this.connecting = undefined;
+        if (!this.connected)
+            return;
+        this.connected = undefined;
+        try {
+            this.socket.disconnect();
+        }
+        catch (error) {
+            log('disconnect', error);
+        }
+    }
+    connectNow(addr) {
+        this.connectOnReceive = undefined;
+        this.connecting = addr;
+        const waiting = [];
+        this.waiting = waiting;
+        const done = (error) => {
+            if (this.waiting === waiting)
+                this.waiting = undefined;
+            //Disconnected meanwhile
+            const wanted = this.connecting === addr;
+            if (wanted)
+                this.connecting = undefined;
+            if (this.closed)
+                return;
+            if (error) {
+                log('connect', addr, error);
+            }
+            else if (wanted) {
+                this.connected = addr;
+            }
+            else {
+                this.socket.disconnect();
+            }
+            for (const [data, to] of waiting)
+                this.send(data, to).catch((error) => log('send', error));
+        };
+        try {
+            this.socket.connect(addr[1], addr[0], done);
+        }
+        catch (error) {
+            done(error);
+        }
+    }
+    get address() {
+        return this.socket.address();
+    }
+    /** IP family of the bound socket: 4 for udp4, 6 for udp6. */
+    get addressFamily() {
+        return this.socketType === 'udp6' ? 6 : 4;
+    }
+    get host() {
+        return this.socket.address().address;
+    }
+    get port() {
+        return this.socket.address().port;
+    }
+}
+exports.UdpTransport = UdpTransport;
+class TcpTransport {
+    constructor(addr, options = {}) {
+        this.type = 'tcp';
+        this.send = async (data, addr) => {
+            await this.stream.send(data, addr);
+        };
+        this.close = async () => {
+            await this.stream.close();
+        };
+        this.stream = new StreamTransport('tcp', () => (0, node_net_1.connect)({ port: addr[1], host: addr[0] }), undefined, options.connectTimeoutMs);
+    }
+    static async init(addr, options = {}) {
+        const transport = new TcpTransport(addr, options);
+        try {
+            await transport.init();
+            return transport;
+        }
+        catch (error) {
+            await transport.close();
+            throw error;
+        }
+    }
+    async init() {
+        await this.stream.waitForConnect();
+    }
+    get address() {
+        return this.stream.address;
+    }
+    get remoteAddress() {
+        return this.stream.remoteAddress;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    get onData() {
+        return this.stream.onData;
+    }
+    set onData(handler) {
+        this.stream.onData = handler;
+    }
+}
+exports.TcpTransport = TcpTransport;
+class TlsTransport {
+    constructor(addr, options = {}, streamOptions = {}) {
+        this.type = 'tls';
+        this.send = async (data, addr) => {
+            await this.stream.send(data, addr);
+        };
+        this.close = async () => {
+            await this.stream.close();
+        };
+        this.stream = new StreamTransport('tls', () => tls.connect({
+            ...options,
+            host: addr[0],
+            port: addr[1]
+        }), undefined, streamOptions.connectTimeoutMs);
+    }
+    static async init(addr, options = {}, streamOptions = {}) {
+        const transport = new TlsTransport(addr, options, streamOptions);
+        try {
+            await transport.init();
+            return transport;
+        }
+        catch (error) {
+            await transport.close();
+            throw error;
+        }
+    }
+    async init() {
+        await this.stream.waitForConnect();
+    }
+    get address() {
+        return this.stream.address;
+    }
+    get remoteAddress() {
+        return this.stream.remoteAddress;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    get onData() {
+        return this.stream.onData;
+    }
+    set onData(handler) {
+        this.stream.onData = handler;
+    }
+}
+exports.TlsTransport = TlsTransport;
+class StreamTransport {
+    constructor(type, createClient, connectEvent = type === 'tls'
+        ? 'secureConnect'
+        : 'connect', connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+        this.createClient = createClient;
+        this.connectEvent = connectEvent;
+        this.connectTimeoutMs = connectTimeoutMs;
+        this.onData = () => { };
+        this.closed = false;
+        this.send = async (data, addr) => {
+            void addr;
+            await this.connecting;
+            await new Promise((resolve, reject) => {
+                this.client.write(data, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        };
+        this.close = async () => {
+            this.closed = true;
+            this.rejectConnecting?.(new Error(`${this.type} transport closed`));
+            this.client?.destroy();
+        };
+        this.type = type;
+        this.connect();
+    }
+    connect() {
+        if (this.closed) {
+            return;
+        }
+        if (this.client) {
+            this.client.destroy();
+        }
+        const client = this.createClient();
+        this.client = client;
+        this.connecting = new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                client.off(this.connectEvent, onConnect);
+                client.off('error', onConnectError);
+                this.rejectConnecting = undefined;
+                error ? reject(error) : resolve();
+            };
+            const onConnect = () => {
+                settle();
+            };
+            const onConnectError = (error) => {
+                this.closed = true;
+                settle(error);
+                client.destroy();
+            };
+            const timer = setTimeout(() => {
+                this.closed = true;
+                settle(new Error(`${this.type} connect timed out after ${this.connectTimeoutMs}ms`));
+                client.destroy();
+            }, this.connectTimeoutMs);
+            this.rejectConnecting = (error) => settle(error);
+            client.once(this.connectEvent, onConnect);
+            client.once('error', onConnectError);
+        });
+        client.on('data', (data) => {
+            this.onData(data, this.remoteAddress);
+        });
+        client.on('error', (error) => {
+            log(`${this.type} transport error`, error);
+        });
+    }
+    async waitForConnect() {
+        await this.connecting;
+    }
+    get address() {
+        return {};
+    }
+    /** The peer the stream is connected to, once connected. */
+    get remoteAddress() {
+        const { remoteAddress, remotePort } = this.client;
+        if (!remoteAddress || !remotePort) {
+            return undefined;
+        }
+        return [stripZoneId(remoteAddress), remotePort];
+    }
+}
+/** Strip an IPv6 zone identifier, e.g. fe80::1%eth0 -> fe80::1. */
+function stripZoneId(address) {
+    return address.split('%')[0];
+}

package/dist/cjs/lib/common/type.d.ts

@@ -0,0 +1,3 @@
+export type RequireAtLeastOne<T> = {
+    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>;
+}[keyof T];

package/dist/cjs/lib/common/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/dtls/cipher/const.d.ts

@@ -0,0 +1,42 @@
+export declare const SignatureAlgorithm: {
+    readonly rsa_1: 1;
+    readonly ecdsa_3: 3;
+};
+export type SignatureAlgorithms = (typeof SignatureAlgorithm)[keyof typeof SignatureAlgorithm];
+export declare const HashAlgorithm: {
+    readonly sha256_4: 4;
+};
+export type HashAlgorithms = (typeof HashAlgorithm)[keyof typeof HashAlgorithm];
+export type SignatureHash = {
+    hash: HashAlgorithms;
+    signature: SignatureAlgorithms;
+};
+export declare const CipherSuite: {
+    readonly TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_49195: 49195;
+    readonly TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256_49199: 49199;
+};
+export type CipherSuites = (typeof CipherSuite)[keyof typeof CipherSuite];
+export declare const CipherSuiteList: CipherSuites[];
+export declare const NamedCurveAlgorithm: {
+    readonly x25519_29: 29;
+    readonly secp256r1_23: 23;
+};
+export type NamedCurveAlgorithms = (typeof NamedCurveAlgorithm)[keyof typeof NamedCurveAlgorithm];
+export declare const NamedCurveAlgorithmList: NamedCurveAlgorithms[];
+export declare const CurveType: {
+    readonly named_curve_3: 3;
+};
+export type CurveTypes = (typeof CurveType)[keyof typeof CurveType];
+export declare const SignatureScheme: {
+    readonly rsa_pkcs1_sha256: 1025;
+    readonly ecdsa_secp256r1_sha256: 1027;
+};
+export type SignatureSchemes = (typeof SignatureScheme)[keyof typeof SignatureScheme];
+export declare const certificateTypes: number[];
+export declare const signatures: ({
+    hash: 4;
+    signature: 1;
+} | {
+    hash: 4;
+    signature: 3;
+})[];

package/dist/cjs/lib/dtls/cipher/const.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatures = exports.certificateTypes = exports.SignatureScheme = exports.CurveType = exports.NamedCurveAlgorithmList = exports.NamedCurveAlgorithm = exports.CipherSuiteList = exports.CipherSuite = exports.HashAlgorithm = exports.SignatureAlgorithm = void 0;
+exports.SignatureAlgorithm = {
+    rsa_1: 1,
+    ecdsa_3: 3
+};
+exports.HashAlgorithm = {
+    sha256_4: 4
+};
+exports.CipherSuite = {
+    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_49195: 0xc02b, //49195,
+    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256_49199: 0xc02f //49199
+};
+exports.CipherSuiteList = Object.values(exports.CipherSuite);
+exports.NamedCurveAlgorithm = {
+    x25519_29: 29,
+    secp256r1_23: 23
+};
+exports.NamedCurveAlgorithmList = Object.values(exports.NamedCurveAlgorithm);
+exports.CurveType = { named_curve_3: 3 };
+exports.SignatureScheme = {
+    rsa_pkcs1_sha256: 0x0401,
+    ecdsa_secp256r1_sha256: 0x0403
+};
+exports.certificateTypes = [
+    1, // clientCertificateTypeRSASign
+    64 // clientCertificateTypeECDSASign
+];
+exports.signatures = [
+    { hash: exports.HashAlgorithm.sha256_4, signature: exports.SignatureAlgorithm.rsa_1 },
+    { hash: exports.HashAlgorithm.sha256_4, signature: exports.SignatureAlgorithm.ecdsa_3 }
+];

package/dist/cjs/lib/dtls/cipher/create.d.ts

@@ -0,0 +1,21 @@
+import type { CipherGCMTypes } from 'node:crypto';
+import { type KeyExchange } from './key-exchange.js';
+import AEADCipher from './suites/aead.js';
+/**
+ * Convert cipher value to cipher instance.
+ * @param {number} cipher
+ */
+export declare function createCipher(cipher: number): AEADCipher;
+/**
+ * @param {number} id An internal id of cipher suite.
+ * @param {string} name A valid cipher suite name.
+ * @param {string} block A valid nodejs cipher name.
+ * @param {KeyExchange} kx Key exchange type.
+ * @param {Object} constants Cipher specific constants.
+ * @param {string} hash
+ * @returns {AEADCipher}
+ */
+export declare function createAEADCipher(id: number, name: string, block: CipherGCMTypes, kx: KeyExchange, constants: {
+    K_LEN: number;
+    N_MAX: number;
+}, hash?: string): AEADCipher;