@lakutata/webrtc 0.0.0-stage → 3.1.1

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

@@ -0,0 +1,401 @@
+import { createSocket } from 'node:dgram';
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+import { connect } from 'node:net';
+import { debug } from './log.js';
+import { findPort, interfaceAddress, randomPort, normalizeFamilyNodeV18 } from './network.js';
+const log = 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
+ */
+export 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]);
+}
+export 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 = createSocket(socketType);
+        this.socket.on('message', (data, info) => {
+            if (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 = 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 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 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;
+    }
+}
+export 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', () => 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;
+    }
+}
+export 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;
+    }
+}
+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/esm/lib/common/type.js

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

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

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

package/dist/esm/lib/dtls/cipher/create.js

@@ -0,0 +1,98 @@
+import { createECDHEECDSAKeyExchange, createECDHEPSKKeyExchange, createECDHERSAKeyExchange, createPSKKeyExchange, createRSAKeyExchange } from './key-exchange.js';
+import AEADCipher from './suites/aead.js';
+const cipherSuites = {
+    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: 0xc02b,
+    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: 0xc02c,
+    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256: 0xc02f,
+    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384: 0xc030,
+    TLS_RSA_WITH_AES_128_GCM_SHA256: 0x009c,
+    TLS_RSA_WITH_AES_256_GCM_SHA384: 0x009d,
+    TLS_PSK_WITH_AES_128_GCM_SHA256: 0x00a8,
+    TLS_PSK_WITH_AES_256_GCM_SHA384: 0x00a9,
+    TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256: 0xd001,
+    TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384: 0xd002,
+    TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256: 0xccac,
+    TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256: 0xcca9,
+    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256: 0xcca8,
+    TLS_PSK_WITH_CHACHA20_POLY1305_SHA256: 0xccab
+};
+const AEAD_AES_128_GCM = {
+    K_LEN: 16, // Length of a key.
+    N_MIN: 12, // Min nonce length.
+    N_MAX: 12, // Max nonce length.
+    P_MAX: 2 ** 36 - 31, // Max length of a plaintext.
+    // Max safe int in js is 2 ** 53. So, use this value
+    // instead of 2 ** 61 as described in rfc5116.
+    A_MAX: 2 ** 53 - 1, // Max length of an additional data.
+    C_MAX: 2 ** 36 - 15 // Cipher text length.
+};
+const AEAD_AES_256_GCM = {
+    K_LEN: 32, // Length of a key.
+    N_MIN: 12, // Min nonce length.
+    N_MAX: 12, // Max nonce length.
+    P_MAX: 2 ** 36 - 31, // Max length of a plaintext.
+    // Note: see above.
+    A_MAX: 2 ** 53 - 1, // Max length of an additional data.
+    C_MAX: 2 ** 36 - 15 // Cipher text length.
+};
+const RSA_KEY_EXCHANGE = createRSAKeyExchange();
+const ECDHE_RSA_KEY_EXCHANGE = createECDHERSAKeyExchange();
+const ECDHE_ECDSA_KEY_EXCHANGE = createECDHEECDSAKeyExchange();
+const PSK_KEY_EXCHANGE = createPSKKeyExchange();
+const ECDHE_PSK_KEY_EXCHANGE = createECDHEPSKKeyExchange();
+/**
+ * Convert cipher value to cipher instance.
+ * @param {number} cipher
+ */
+export function createCipher(cipher) {
+    switch (cipher) {
+        case cipherSuites.TLS_RSA_WITH_AES_128_GCM_SHA256:
+            return createAEADCipher(cipherSuites.TLS_RSA_WITH_AES_128_GCM_SHA256, 'TLS_RSA_WITH_AES_128_GCM_SHA256', 'aes-128-gcm', RSA_KEY_EXCHANGE, AEAD_AES_128_GCM);
+        case cipherSuites.TLS_RSA_WITH_AES_256_GCM_SHA384:
+            return createAEADCipher(cipherSuites.TLS_RSA_WITH_AES_256_GCM_SHA384, 'TLS_RSA_WITH_AES_256_GCM_SHA384', 'aes-256-gcm', RSA_KEY_EXCHANGE, AEAD_AES_256_GCM, 'sha384');
+        case cipherSuites.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 'TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256', 'aes-128-gcm', ECDHE_RSA_KEY_EXCHANGE, AEAD_AES_128_GCM);
+        case cipherSuites.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 'TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384', 'aes-256-gcm', ECDHE_RSA_KEY_EXCHANGE, AEAD_AES_256_GCM, 'sha384');
+        case cipherSuites.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 'TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256', 'aes-128-gcm', ECDHE_ECDSA_KEY_EXCHANGE, AEAD_AES_128_GCM);
+        case cipherSuites.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384', 'aes-256-gcm', ECDHE_ECDSA_KEY_EXCHANGE, AEAD_AES_256_GCM, 'sha384');
+        case cipherSuites.TLS_PSK_WITH_AES_128_GCM_SHA256:
+            return createAEADCipher(cipherSuites.TLS_PSK_WITH_AES_128_GCM_SHA256, 'TLS_PSK_WITH_AES_128_GCM_SHA256', 'aes-128-gcm', PSK_KEY_EXCHANGE, AEAD_AES_128_GCM, 'sha256');
+        case cipherSuites.TLS_PSK_WITH_AES_256_GCM_SHA384:
+            return createAEADCipher(cipherSuites.TLS_PSK_WITH_AES_256_GCM_SHA384, 'TLS_PSK_WITH_AES_256_GCM_SHA384', 'aes-256-gcm', PSK_KEY_EXCHANGE, AEAD_AES_256_GCM, 'sha384');
+        case cipherSuites.TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256, 'TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256', 'aes-128-gcm', ECDHE_PSK_KEY_EXCHANGE, AEAD_AES_128_GCM, 'sha256');
+        case cipherSuites.TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384:
+            return createAEADCipher(cipherSuites.TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384, 'TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384', 'aes-256-gcm', ECDHE_PSK_KEY_EXCHANGE, AEAD_AES_256_GCM, 'sha384');
+        default:
+            break;
+    }
+    return null;
+}
+/**
+ * @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 function createAEADCipher(id, name, block, kx, constants, hash = 'sha256') {
+    const cipher = new AEADCipher();
+    cipher.id = id;
+    cipher.name = name;
+    cipher.blockAlgorithm = block;
+    cipher.kx = kx;
+    cipher.hashAlgorithm = hash;
+    cipher.keyLength = constants.K_LEN;
+    cipher.nonceLength = constants.N_MAX;
+    // RFC5288, sec. 3
+    cipher.nonceImplicitLength = 4;
+    cipher.nonceExplicitLength = 8;
+    cipher.ivLength = cipher.nonceImplicitLength;
+    cipher.authTagLength = 16;
+    return cipher;
+}

package/dist/esm/lib/dtls/cipher/ec.js

@@ -0,0 +1,37 @@
+import { createECDH, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync } from 'node:crypto';
+/**
+ * A key pair of P-256 for ECDHE: the private scalar (32 bytes) and the uncompressed public point (65 bytes)
+ */
+export const p256Keypair = () => {
+    const ecdh = createECDH('prime256v1');
+    const publicKey = ecdh.generateKeys();
+    return { privateKey: ecdh.getPrivateKey(), publicKey };
+};
+/**
+ * The premaster secret of ECDHE on P-256: the x coordinate of the shared point
+ */
+export const p256PreMasterSecret = ({ publicKey, privateKey }) => {
+    const ecdh = createECDH('prime256v1');
+    ecdh.setPrivateKey(privateKey);
+    return ecdh.computeSecret(publicKey);
+};
+//The fixed DER prefixes of the X25519 keys (RFC 8410): the raw 32 bytes follow them
+const x25519Pkcs8Prefix = Buffer.from('302e020100300506032b656e04220420', 'hex');
+const x25519SpkiPrefix = Buffer.from('302a300506032b656e032100', 'hex');
+/**
+ * A key pair of X25519: both keys as their raw 32 bytes
+ */
+export const x25519Keypair = () => {
+    const { privateKey, publicKey } = generateKeyPairSync('x25519');
+    return {
+        privateKey: privateKey.export({ type: 'pkcs8', format: 'der' }).subarray(x25519Pkcs8Prefix.length),
+        publicKey: publicKey.export({ type: 'spki', format: 'der' }).subarray(x25519SpkiPrefix.length)
+    };
+};
+/**
+ * The premaster secret of X25519 from the raw keys
+ */
+export const x25519PreMasterSecret = ({ publicKey, privateKey }) => diffieHellman({
+    privateKey: createPrivateKey({ key: Buffer.concat([x25519Pkcs8Prefix, privateKey]), format: 'der', type: 'pkcs8' }),
+    publicKey: createPublicKey({ key: Buffer.concat([x25519SpkiPrefix, publicKey]), format: 'der', type: 'spki' })
+});

package/dist/esm/lib/dtls/cipher/key-exchange.js

@@ -0,0 +1,103 @@
+const signTypes = {
+    NULL: 0,
+    ECDHE: 1
+};
+const keyTypes = {
+    NULL: 0,
+    RSA: 1,
+    ECDSA: 2,
+    PSK: 3
+};
+const kxTypes = {
+    NULL: 0,
+    RSA: 1,
+    ECDHE_RSA: 2,
+    ECDHE_ECDSA: 3,
+    PSK: 4,
+    ECDHE_PSK: 5
+};
+/**
+ * This class represent type of key exchange mechanism.
+ */
+export class KeyExchange {
+    constructor() {
+        this.id = 0;
+    }
+    /**
+   * @returns {string}
+   */
+    toString() {
+        return this.name;
+    }
+}
+/**
+ * Creates `RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createRSAKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.RSA;
+    exchange.name = 'RSA';
+    exchange.keyType = keyTypes.RSA;
+    return exchange;
+}
+/**
+ * Creates `ECDHE_RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createECDHERSAKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.ECDHE_RSA;
+    exchange.name = 'ECDHE_RSA';
+    exchange.signType = signTypes.ECDHE;
+    exchange.keyType = keyTypes.RSA;
+    return exchange;
+}
+/**
+ * Creates `ECDHE_ECDSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createECDHEECDSAKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.ECDHE_ECDSA;
+    exchange.name = 'ECDHE_ECDSA';
+    exchange.signType = signTypes.ECDHE;
+    exchange.keyType = keyTypes.ECDSA;
+    return exchange;
+}
+/**
+ * Creates `NULL` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createNULLKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.NULL;
+    exchange.name = 'NULL';
+    exchange.signType = signTypes.NULL;
+    exchange.keyType = keyTypes.NULL;
+    return exchange;
+}
+/**
+ * Creates `PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createPSKKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.PSK;
+    exchange.name = 'PSK';
+    exchange.signType = signTypes.NULL;
+    exchange.keyType = keyTypes.PSK;
+    return exchange;
+}
+/**
+ * Creates `ECDHE_PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export function createECDHEPSKKeyExchange() {
+    const exchange = new KeyExchange();
+    exchange.id = kxTypes.ECDHE_PSK;
+    exchange.name = 'ECDHE_PSK';
+    exchange.signType = signTypes.ECDHE;
+    exchange.keyType = keyTypes.PSK;
+    return exchange;
+}

package/dist/esm/lib/dtls/cipher/namedCurve.js

@@ -0,0 +1,24 @@
+import { NamedCurveAlgorithm } from './const.js';
+import { p256Keypair, x25519Keypair } from './ec.js';
+export function generateKeyPair(namedCurve) {
+    switch (namedCurve) {
+        case NamedCurveAlgorithm.secp256r1_23: {
+            const { privateKey, publicKey } = p256Keypair();
+            return {
+                curve: namedCurve,
+                privateKey,
+                publicKey
+            };
+        }
+        case NamedCurveAlgorithm.x25519_29: {
+            const { privateKey, publicKey } = x25519Keypair();
+            return {
+                curve: namedCurve,
+                privateKey,
+                publicKey
+            };
+        }
+        default:
+            throw new Error();
+    }
+}