@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,79 @@
+import { createHash, createHmac } from 'node:crypto';
+import { binaryData } from '../imports/common.js';
+import { NamedCurveAlgorithm } from './const.js';
+import { p256PreMasterSecret, x25519PreMasterSecret } from './ec.js';
+export function prfPreMasterSecret(publicKey, privateKey, curve) {
+    switch (curve) {
+        case NamedCurveAlgorithm.secp256r1_23:
+            return p256PreMasterSecret({ publicKey, privateKey });
+        case NamedCurveAlgorithm.x25519_29:
+            return x25519PreMasterSecret({ publicKey, privateKey });
+        default:
+            throw new Error();
+    }
+}
+export function hmac(algorithm, secret, data) {
+    const hash = createHmac(algorithm, secret);
+    hash.update(data);
+    return hash.digest();
+}
+export function prfPHash(secret, seed, requestedLegth, algorithm = 'sha256') {
+    const totalLength = requestedLegth;
+    const bufs = [];
+    let Ai = seed; // A0
+    do {
+        Ai = hmac(algorithm, secret, Ai); // A(i) = HMAC(secret, A(i-1))
+        const output = hmac(algorithm, secret, Buffer.concat([Ai, seed]));
+        bufs.push(output);
+        requestedLegth -= output.length;
+    } while (requestedLegth > 0);
+    return Buffer.concat(bufs, totalLength);
+}
+export function prfMasterSecret(preMasterSecret, clientRandom, serverRandom) {
+    const seed = Buffer.concat([
+        Buffer.from('master secret'),
+        clientRandom,
+        serverRandom
+    ]);
+    return prfPHash(preMasterSecret, seed, 48);
+}
+export function prfExtendedMasterSecret(preMasterSecret, handshakes) {
+    const sessionHash = hash('sha256', handshakes);
+    const label = 'extended master secret';
+    return prfPHash(preMasterSecret, Buffer.concat([Buffer.from(label), sessionHash]), 48);
+}
+export function exportKeyingMaterial(label, length, masterSecret, localRandom, remoteRandom, isClient) {
+    const clientRandom = isClient ? localRandom : remoteRandom;
+    const serverRandom = isClient ? remoteRandom : localRandom;
+    const seed = Buffer.concat([Buffer.from(label), clientRandom, serverRandom]);
+    return prfPHash(masterSecret, seed, length);
+}
+export function hash(algorithm, data) {
+    return createHash(algorithm).update(data).digest();
+}
+export function prfVerifyData(masterSecret, handshakes, label, size = 12) {
+    const bytes = hash('sha256', handshakes);
+    return prfPHash(masterSecret, Buffer.concat([Buffer.from(label), bytes]), size);
+}
+export function prfVerifyDataClient(masterSecret, handshakes) {
+    return prfVerifyData(masterSecret, handshakes, 'client finished');
+}
+export function prfVerifyDataServer(masterSecret, handshakes) {
+    return prfVerifyData(masterSecret, handshakes, 'server finished');
+}
+export function prfEncryptionKeys(masterSecret, clientRandom, serverRandom, prfKeyLen, prfIvLen, prfNonceLen, algorithm = 'sha256') {
+    const size = prfKeyLen * 2 + prfIvLen * 2;
+    const secret = masterSecret;
+    const seed = Buffer.concat([serverRandom, clientRandom]);
+    const keyBlock = prfPHash(secret, Buffer.concat([Buffer.from('key expansion'), seed]), size, algorithm);
+    const stream = new binaryData.BinaryReader(keyBlock);
+    const clientWriteKey = stream.readBuffer(prfKeyLen);
+    const serverWriteKey = stream.readBuffer(prfKeyLen);
+    const clientNonceImplicit = stream.readBuffer(prfIvLen);
+    const serverNonceImplicit = stream.readBuffer(prfIvLen);
+    const clientNonce = Buffer.alloc(prfNonceLen, 0);
+    const serverNonce = Buffer.alloc(prfNonceLen, 0);
+    clientNonceImplicit.copy(clientNonce, 0);
+    serverNonceImplicit.copy(serverNonce, 0);
+    return { clientWriteKey, serverWriteKey, clientNonce, serverNonce };
+}

package/dist/esm/lib/dtls/cipher/suites/abstract.js

@@ -0,0 +1,37 @@
+export const SessionType = {
+    CLIENT: 1,
+    SERVER: 2
+};
+export default class AbstractCipher {
+    constructor() {
+        this.id = 0;
+        this.verifyDataLength = 12;
+    }
+    /**
+   * Init cipher.
+   * @abstract
+   */
+    init(..._args) {
+        throw new Error('not implemented');
+    }
+    /**
+   * Encrypts data.
+   * @abstract
+   */
+    encrypt(..._args) {
+        throw new Error('not implemented');
+    }
+    /**
+   * Decrypts data.
+   * @abstract
+   */
+    decrypt(..._args) {
+        throw new Error('not implemented');
+    }
+    /**
+   * @returns {string}
+   */
+    toString() {
+        return this.name;
+    }
+}

package/dist/esm/lib/dtls/cipher/suites/aead.js

@@ -0,0 +1,96 @@
+import { createCipheriv, createDecipheriv } from 'node:crypto';
+import { dumpBuffer, getObjectSummary } from '../../helper.js';
+import { debug } from '../../imports/common.js';
+import { prfEncryptionKeys } from '../prf.js';
+import Cipher, { SessionType } from './abstract.js';
+const err = debug('webrtc/dtls/cipher/suites/aead:err');
+/**
+ * This class implements AEAD cipher family.
+ */
+export default class AEADCipher extends Cipher {
+    constructor() {
+        super();
+        this.keyLength = 0;
+        this.nonceLength = 0;
+        this.ivLength = 0;
+        this.authTagLength = 0;
+        this.nonceImplicitLength = 0;
+        this.nonceExplicitLength = 0;
+    }
+    get summary() {
+        return getObjectSummary(this);
+    }
+    init(masterSecret, serverRandom, clientRandom) {
+        const keys = prfEncryptionKeys(masterSecret, clientRandom, serverRandom, this.keyLength, this.ivLength, this.nonceLength, this.hashAlgorithm);
+        this.clientWriteKey = keys.clientWriteKey;
+        this.serverWriteKey = keys.serverWriteKey;
+        this.clientNonce = keys.clientNonce;
+        this.serverNonce = keys.serverNonce;
+    }
+    /**
+   * Encrypt message.
+   */
+    encrypt(type, data, header) {
+        const isClient = type === SessionType.CLIENT;
+        const iv = isClient ? this.clientNonce : this.serverNonce;
+        const writeKey = isClient ? this.clientWriteKey : this.serverWriteKey;
+        if (!iv || !writeKey)
+            throw new Error();
+        iv.writeUInt16BE(header.epoch, this.nonceImplicitLength);
+        iv.writeUIntBE(header.sequenceNumber, this.nonceImplicitLength + 2, 6);
+        const explicitNonce = iv.slice(this.nonceImplicitLength);
+        const additionalBuffer = this.encodeAdditionalBuffer(header, data.length);
+        const cipher = createCipheriv(this.blockAlgorithm, writeKey, iv, {
+            authTagLength: this.authTagLength
+        });
+        cipher.setAAD(additionalBuffer, {
+            plaintextLength: data.length
+        });
+        const headPart = cipher.update(data);
+        const finalPart = cipher.final();
+        const authTag = cipher.getAuthTag();
+        return Buffer.concat([explicitNonce, headPart, finalPart, authTag]);
+    }
+    encodeAdditionalBuffer(header, dataLength) {
+        const additionalBuffer = Buffer.alloc(13);
+        additionalBuffer.writeUInt16BE(header.epoch, 0);
+        additionalBuffer.writeUintBE(header.sequenceNumber, 2, 6);
+        additionalBuffer.writeUInt8(header.type, 8);
+        additionalBuffer.writeUInt16BE(header.version, 9);
+        additionalBuffer.writeUInt16BE(dataLength, 11);
+        return additionalBuffer;
+    }
+    /**
+   * Decrypt message.
+   */
+    decrypt(type, data, header) {
+        const isClient = type === SessionType.CLIENT;
+        const iv = isClient ? this.serverNonce : this.clientNonce;
+        const writeKey = isClient ? this.serverWriteKey : this.clientWriteKey;
+        if (!iv || !writeKey)
+            throw new Error();
+        const explicitNonce = data.subarray(0, this.nonceExplicitLength);
+        explicitNonce.copy(iv, this.nonceImplicitLength);
+        const encrypted = data.subarray(this.nonceExplicitLength, data.length - this.authTagLength);
+        const authTag = data.subarray(data.length - this.authTagLength);
+        const additionalBuffer = this.encodeAdditionalBuffer(header, encrypted.length);
+        const decipher = createDecipheriv(this.blockAlgorithm, writeKey, iv, {
+            authTagLength: this.authTagLength
+        });
+        decipher.setAuthTag(authTag);
+        decipher.setAAD(additionalBuffer, {
+            plaintextLength: encrypted.length
+        });
+        const headPart = decipher.update(encrypted);
+        try {
+            const finalPart = decipher.final();
+            return finalPart.length > 0
+                ? Buffer.concat([headPart, finalPart])
+                : headPart;
+        }
+        catch (error) {
+            err('decrypt failed', error, type, dumpBuffer(data), header, this.summary);
+            throw error;
+        }
+    }
+}

package/dist/esm/lib/dtls/cipher/suites/null.js

@@ -0,0 +1,35 @@
+import { createNULLKeyExchange } from '../key-exchange.js';
+import Cipher from './abstract.js';
+/**
+ * Default passthrough cipher.
+ */
+export default class NullCipher extends Cipher {
+    /**
+   * @class NullCipher
+   */
+    constructor() {
+        super();
+        this.name = 'NULL_NULL_NULL'; // key, mac, hash
+        this.blockAlgorithm = undefined;
+        this.kx = createNULLKeyExchange();
+        this.hashAlgorithm = 'NULL';
+    }
+    /**
+   * Encrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    encrypt(session, data) {
+        return data;
+    }
+    /**
+   * Decrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    decrypt(session, data) {
+        return data;
+    }
+}

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

@@ -0,0 +1,34 @@
+import * as crypto from 'node:crypto';
+/**
+ * Culculates HMAC using provided hash.
+ * @param {string} algorithm - Hash algorithm.
+ * @param {Buffer} secret - Hmac seed.
+ * @param {Buffer} data - Input data.
+ * @returns {Buffer}
+ */
+function hmac(algorithm, secret, data) {
+    const hash = crypto.createHmac(algorithm, secret);
+    hash.update(data);
+    return hash.digest();
+}
+/**
+ * A data expansion function for PRF.
+ * @param {number} bytes - The number of bytes required by PRF.
+ * @param {string} algorithm - Hmac hash algorithm.
+ * @param {Buffer} secret - Hmac secret.
+ * @param {Buffer} seed - Input data.
+ * @returns {Buffer}
+ */
+function pHash(bytes, algorithm, secret, seed) {
+    const totalLength = bytes;
+    const bufs = [];
+    let Ai = seed; // A0
+    do {
+        Ai = hmac(algorithm, secret, Ai); // A(i) = HMAC(secret, A(i-1))
+        const output = hmac(algorithm, secret, Buffer.concat([Ai, seed]));
+        bufs.push(output);
+        bytes -= output.length;
+    } while (bytes > 0);
+    return Buffer.concat(bufs, totalLength);
+}
+export { hmac, pHash };

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

@@ -0,0 +1,94 @@
+import { createPrivateKey, generateKeyPairSync, randomBytes, sign } from 'node:crypto';
+//DER: a tag, the length (short form under 128 bytes, long form above), then the content
+function der(tag, content) {
+    const length = content.length;
+    if (length < 0x80)
+        return Buffer.concat([Buffer.from([tag, length]), content]);
+    const bytes = [];
+    for (let rest = length; rest > 0; rest = Math.floor(rest / 256))
+        bytes.unshift(rest & 0xff);
+    return Buffer.concat([Buffer.from([tag, 0x80 | bytes.length, ...bytes]), content]);
+}
+const sequence = (...items) => der(0x30, Buffer.concat(items));
+const set = (...items) => der(0x31, Buffer.concat(items));
+const nullValue = Buffer.from([0x05, 0x00]);
+const utf8String = (text) => der(0x0c, Buffer.from(text, 'utf8'));
+const bitString = (content) => der(0x03, Buffer.concat([Buffer.from([0]), content]));
+const explicit = (tag, content) => der(0xa0 | tag, content);
+//A positive INTEGER: a leading zero when the first bit is set, so it is not read as negative
+function integer(value) {
+    let start = 0;
+    while (start < value.length - 1 && value[start] === 0)
+        start++;
+    const trimmed = value.subarray(start);
+    return der(0x02, trimmed[0] & 0x80 ? Buffer.concat([Buffer.from([0]), trimmed]) : trimmed);
+}
+//An OBJECT IDENTIFIER from its dotted form: the first two arcs in one byte, the others in base 128
+function oid(dotted) {
+    const arcs = dotted.split('.').map(Number);
+    const bytes = [arcs[0] * 40 + arcs[1]];
+    for (const arc of arcs.slice(2)) {
+        const encoded = [arc & 0x7f];
+        for (let rest = Math.floor(arc / 128); rest > 0; rest = Math.floor(rest / 128))
+            encoded.unshift(0x80 | (rest & 0x7f));
+        bytes.push(...encoded);
+    }
+    return der(0x06, Buffer.from(bytes));
+}
+//UTCTime up to 2049, GeneralizedTime from 2050 (RFC 5280 section 4.1.2.5)
+function time(date) {
+    const iso = date.toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    return date.getUTCFullYear() < 2050 ? der(0x17, Buffer.from(`${iso.slice(2)}Z`)) : der(0x18, Buffer.from(`${iso}Z`));
+}
+const commonName = (name) => sequence(set(sequence(oid('2.5.4.3'), utf8String(name))));
+/**
+ * Creates a self-signed X.509 certificate for DTLS: the peers of WebRTC check it against the fingerprint in the SDP,
+ * not against a certificate authority, so it only has to be well formed
+ * @param keyType The algorithm of the key; ECDSA on P-256 by default, as the browsers use
+ * @param name The common name of the subject and the issuer
+ * @param days How long the certificate is valid, from a day before now
+ * @returns The certificate and its private key (PKCS #8), in PEM
+ */
+export function createDtlsCertificate(keyType = 'ecdsa', name = 'WebRTC', days = 30) {
+    const { privateKey, publicKey } = keyType === 'ecdsa'
+        ? generateKeyPairSync('ec', { namedCurve: 'prime256v1' })
+        : generateKeyPairSync('rsa', { modulusLength: 2048, publicExponent: 0x10001 });
+    //ecdsa-with-SHA256 has no parameters, sha256WithRSAEncryption a NULL one
+    const algorithm = keyType === 'ecdsa'
+        ? sequence(oid('1.2.840.10045.4.3.2'))
+        : sequence(oid('1.2.840.113549.1.1.11'), nullValue);
+    const notBefore = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const notAfter = new Date(notBefore.getTime() + (days + 1) * 24 * 60 * 60 * 1000);
+    const serial = randomBytes(8);
+    serial[0] &= 0x7f;
+    const subject = commonName(name);
+    const toBeSigned = sequence(explicit(0, integer(Buffer.from([2]))), integer(serial), algorithm, subject, sequence(time(notBefore), time(notAfter)), subject, publicKey.export({ type: 'spki', format: 'der' }));
+    const signature = sign('sha256', toBeSigned, privateKey);
+    const certificate = sequence(toBeSigned, algorithm, bitString(signature));
+    return {
+        certPem: toPem(certificate, 'CERTIFICATE'),
+        keyPem: privateKey.export({ type: 'pkcs8', format: 'pem' })
+    };
+}
+/**
+ * Wraps DER in PEM, 64 characters of base64 per line
+ */
+export function toPem(derBytes, label) {
+    const lines = derBytes.toString('base64').match(/.{1,64}/g) ?? [];
+    return `-----BEGIN ${label}-----\n${lines.join('\n')}\n-----END ${label}-----\n`;
+}
+/**
+ * The DER of the first certificate of a PEM text
+ */
+export function certificateDer(pem) {
+    const match = pem.match(/-----BEGIN CERTIFICATE-----([\s\S]+?)-----END CERTIFICATE-----/);
+    if (!match)
+        throw new Error('no certificate in the PEM text');
+    return Buffer.from(match[1].replace(/\s+/g, ''), 'base64');
+}
+/**
+ * The private key of a PEM text (PKCS #8, PKCS #1 or SEC 1)
+ */
+export function privateKeyFromPem(pem) {
+    return createPrivateKey(pem);
+}

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

@@ -0,0 +1,72 @@
+import { SessionType } from './cipher/suites/abstract.js';
+import { Flight1 } from './flight/client/flight1.js';
+import { Flight3 } from './flight/client/flight3.js';
+import { Flight5 } from './flight/client/flight5.js';
+import { HandshakeType } from './handshake/const.js';
+import { ServerHelloVerifyRequest } from './handshake/message/server/helloVerifyRequest.js';
+import { debug } from './imports/common.js';
+import { DtlsSocket } from './socket.js';
+const log = debug('webrtc/dtls/client:log');
+export class DtlsClient extends DtlsSocket {
+    constructor(options) {
+        super(options, SessionType.CLIENT);
+        this.handleHandshakes = async (assembled) => {
+            log(this.dtls.sessionId, 'handleHandshakes', assembled.map((a) => a.msg_type));
+            for (const handshake of assembled) {
+                switch (handshake.msg_type) {
+                    // flight2
+                    case HandshakeType.hello_verify_request_3:
+                        {
+                            const verifyReq = ServerHelloVerifyRequest.deSerialize(handshake.fragment);
+                            await new Flight3(this.transport, this.dtls).exec(verifyReq);
+                        }
+                        break;
+                    // flight 4
+                    case HandshakeType.server_hello_2:
+                        {
+                            if (this.connected)
+                                return;
+                            this.flight5 = new Flight5(this.transport, this.dtls, this.cipher, this.srtp);
+                            this.flight5.handleHandshake(handshake);
+                        }
+                        break;
+                    case HandshakeType.certificate_11:
+                    case HandshakeType.server_key_exchange_12:
+                    case HandshakeType.certificate_request_13:
+                        {
+                            await this.waitForReady(() => !!this.flight5);
+                            this.flight5?.handleHandshake(handshake);
+                        }
+                        break;
+                    case HandshakeType.server_hello_done_14:
+                        {
+                            await this.waitForReady(() => !!this.flight5);
+                            this.flight5?.handleHandshake(handshake);
+                            const targets = [
+                                11,
+                                12,
+                                this.options.certificateRequest && 13
+                            ].filter((n) => typeof n === 'number');
+                            await this.waitForReady(() => this.dtls.checkHandshakesExist(targets));
+                            await this.flight5?.exec();
+                        }
+                        break;
+                    // flight 6
+                    case HandshakeType.finished_20:
+                        {
+                            this.dtls.flight = 7;
+                            this.connected = true;
+                            this.onConnect.execute();
+                            log(this.dtls.sessionId, 'dtls connected');
+                        }
+                        break;
+                }
+            }
+        };
+        this.onHandleHandshakes = this.handleHandshakes;
+        log(this.dtls.sessionId, 'start client');
+    }
+    async connect() {
+        await new Flight1(this.transport, this.dtls, this.cipher).exec(this.extensions);
+    }
+}

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

@@ -0,0 +1,83 @@
+import { sign } from 'node:crypto';
+import { binaryData } from '../imports/common.js';
+import { CurveType, SignatureAlgorithm } from '../cipher/const.js';
+import { certificateDer, createDtlsCertificate, privateKeyFromPem } from '../cipher/x509.js';
+import { prfVerifyDataClient, prfVerifyDataServer } from '../cipher/prf.js';
+import { SessionType } from '../cipher/suites/abstract.js';
+const { encode, types } = binaryData;
+export class CipherContext {
+    constructor(sessionType, certPem, keyPem, signatureHashAlgorithm) {
+        this.sessionType = sessionType;
+        this.certPem = certPem;
+        this.keyPem = keyPem;
+        if (certPem && keyPem && signatureHashAlgorithm) {
+            this.parseX509(certPem, keyPem, signatureHashAlgorithm);
+        }
+    }
+    /**
+   *
+   * @param signatureHash
+   * @param namedCurveAlgorithm necessary when use ecdsa
+   */
+    static { this.createSelfSignedCertificateWithKey = async (signatureHash, _namedCurveAlgorithm) => {
+        //The key of the certificate signs with ECDSA on P-256 or with RSA; the curve of the key exchange is negotiated apart
+        const { certPem, keyPem } = createDtlsCertificate(signatureHash.signature === SignatureAlgorithm.rsa_1 ? 'rsa' : 'ecdsa');
+        return { certPem, keyPem, signatureHash };
+    }; }
+    encryptPacket(pkt) {
+        const header = pkt.recordLayerHeader;
+        const version = (header.protocolVersion.major << 8) | header.protocolVersion.minor;
+        const enc = this.cipher.encrypt(this.sessionType, pkt.fragment, {
+            type: header.contentType,
+            version,
+            epoch: header.epoch,
+            sequenceNumber: header.sequenceNumber
+        });
+        pkt.fragment = enc;
+        pkt.recordLayerHeader.contentLen = enc.length;
+        return pkt;
+    }
+    decryptPacket(pkt) {
+        const header = pkt.recordLayerHeader;
+        const version = (header.protocolVersion.major << 8) | header.protocolVersion.minor;
+        const dec = this.cipher.decrypt(this.sessionType, pkt.fragment, {
+            type: header.contentType,
+            version,
+            epoch: header.epoch,
+            sequenceNumber: header.sequenceNumber
+        });
+        return dec;
+    }
+    verifyData(buf) {
+        if (this.sessionType === SessionType.CLIENT)
+            return prfVerifyDataClient(this.masterSecret, buf);
+        else
+            return prfVerifyDataServer(this.masterSecret, buf);
+    }
+    signatureData(data, hash) {
+        return sign(hash, data, this.localPrivateKey);
+    }
+    generateKeySignature(hashAlgorithm) {
+        const clientRandom = this.sessionType === SessionType.CLIENT
+            ? this.localRandom
+            : this.remoteRandom;
+        const serverRandom = this.sessionType === SessionType.SERVER
+            ? this.localRandom
+            : this.remoteRandom;
+        const sig = this.valueKeySignature(clientRandom.serialize(), serverRandom.serialize(), this.localKeyPair.publicKey, this.namedCurve);
+        return sign(hashAlgorithm, sig, this.localPrivateKey);
+    }
+    parseX509(certPem, keyPem, signatureHash) {
+        this.localCert = certificateDer(certPem);
+        this.localPrivateKey = privateKeyFromPem(keyPem);
+        this.signatureHashAlgorithm = signatureHash;
+    }
+    valueKeySignature(clientRandom, serverRandom, publicKey, namedCurve) {
+        const serverParams = encode({
+            type: CurveType.named_curve_3,
+            curve: namedCurve,
+            len: publicKey.length
+        }, { type: types.uint8, curve: types.uint16be, len: types.uint8 });
+        return Buffer.concat([clientRandom, serverRandom, serverParams, publicKey]);
+    }
+}

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

@@ -0,0 +1,45 @@
+import { debug } from '../imports/common.js';
+const log = debug('webrtc/dtls/context/dtls:log');
+export class DtlsContext {
+    constructor(options, sessionType) {
+        this.options = options;
+        this.sessionType = sessionType;
+        this.version = { major: 255 - 1, minor: 255 - 2 };
+        this.lastFlight = [];
+        this.lastMessage = [];
+        this.recordSequenceNumber = 0;
+        this.sequenceNumber = 0;
+        this.epoch = 0;
+        this.flight = 0;
+        this.handshakeCache = {};
+        this.requestedCertificateTypes = [];
+        this.requestedSignatureAlgorithms = [];
+        this.remoteExtendedMasterSecret = false;
+        this.checkHandshakesExist = (handshakes) => !handshakes.find((type) => this.sortedHandshakeCache.find((h) => h.msg_type === type) == undefined);
+    }
+    get sessionId() {
+        return this.cookie ? this.cookie.toString('hex').slice(0, 10) : '';
+    }
+    get sortedHandshakeCache() {
+        return Object.entries(this.handshakeCache)
+            .sort(([a], [b]) => Number(a) - Number(b))
+            .flatMap(([, { data }]) => data.sort((a, b) => a.message_seq - b.message_seq));
+    }
+    bufferHandshakeCache(handshakes, isLocal, flight) {
+        if (!this.handshakeCache[flight]) {
+            this.handshakeCache[flight] = { data: [], isLocal, flight };
+        }
+        const filtered = handshakes.filter((h) => {
+            const exist = this.handshakeCache[flight].data.find((t) => t.msg_type === h.msg_type);
+            if (exist) {
+                log(this.sessionId, 'exist', exist.summary, isLocal, flight);
+                return false;
+            }
+            return true;
+        });
+        this.handshakeCache[flight].data = [
+            ...this.handshakeCache[flight].data,
+            ...filtered
+        ];
+    }
+}

package/dist/esm/lib/dtls/context/srtp.js

@@ -0,0 +1,8 @@
+export class SrtpContext {
+    static findMatchingSRTPProfile(remote, local) {
+        for (const v of local) {
+            if (remote.includes(v))
+                return v;
+        }
+    }
+}

package/dist/esm/lib/dtls/context/transport.js

@@ -0,0 +1,13 @@
+export class TransportContext {
+    constructor(socket) {
+        this.socket = socket;
+        //Aborted when the DTLS socket closes: the flights being sent again stop
+        this.closing = new AbortController();
+        this.send = (buf, addr) => {
+            return this.socket.send(buf, addr);
+        };
+    }
+    close() {
+        this.closing.abort();
+    }
+}

package/dist/esm/lib/dtls/flight/client/flight1.js

@@ -0,0 +1,22 @@
+import { CipherSuiteList } from '../../cipher/const.js';
+import { ClientHello } from '../../handshake/message/client/hello.js';
+import { DtlsRandom } from '../../handshake/random.js';
+import { Flight } from '../flight.js';
+export class Flight1 extends Flight {
+    constructor(udp, dtls, cipher) {
+        super(udp, dtls, 1, 3);
+        this.cipher = cipher;
+    }
+    async exec(extensions) {
+        if (this.dtls.flight === 1)
+            throw new Error();
+        this.dtls.flight = 1;
+        const hello = new ClientHello({ major: 255 - 1, minor: 255 - 2 }, new DtlsRandom(), Buffer.from([]), Buffer.from([]), CipherSuiteList, [0], // don't compress
+        extensions);
+        this.dtls.version = hello.clientVersion;
+        this.cipher.localRandom = DtlsRandom.from(hello.random);
+        const packets = this.createPacket([hello]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        await this.transmit([buf]);
+    }
+}

package/dist/esm/lib/dtls/flight/client/flight3.js

@@ -0,0 +1,21 @@
+import { debug } from '../../imports/common.js';
+import { Flight } from '../flight.js';
+const log = debug('webrtc/dtls/flight/client/flight3:log');
+export class Flight3 extends Flight {
+    constructor(udp, dtls) {
+        super(udp, dtls, 3, 5);
+    }
+    async exec(verifyReq) {
+        if (this.dtls.flight === 3)
+            throw new Error();
+        this.dtls.flight = 3;
+        this.dtls.handshakeCache = [];
+        const [clientHello] = this.dtls.lastFlight;
+        log('dtls version', clientHello.clientVersion);
+        clientHello.cookie = verifyReq.cookie;
+        this.dtls.cookie = verifyReq.cookie;
+        const packets = this.createPacket([clientHello]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        await this.transmit([buf]);
+    }
+}