@lakutata/webrtc 0.0.0-stage → 3.1.1

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

@@ -0,0 +1,132 @@
+"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 });
+const node_crypto_1 = require("node:crypto");
+const helper_js_1 = require("../../helper.js");
+const common_js_1 = require("../../imports/common.js");
+const prf_js_1 = require("../prf.js");
+const abstract_js_1 = __importStar(require("./abstract.js"));
+const err = (0, common_js_1.debug)('webrtc/dtls/cipher/suites/aead:err');
+/**
+ * This class implements AEAD cipher family.
+ */
+class AEADCipher extends abstract_js_1.default {
+    constructor() {
+        super();
+        this.keyLength = 0;
+        this.nonceLength = 0;
+        this.ivLength = 0;
+        this.authTagLength = 0;
+        this.nonceImplicitLength = 0;
+        this.nonceExplicitLength = 0;
+    }
+    get summary() {
+        return (0, helper_js_1.getObjectSummary)(this);
+    }
+    init(masterSecret, serverRandom, clientRandom) {
+        const keys = (0, prf_js_1.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 === abstract_js_1.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 = (0, node_crypto_1.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 === abstract_js_1.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 = (0, node_crypto_1.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, (0, helper_js_1.dumpBuffer)(data), header, this.summary);
+            throw error;
+        }
+    }
+}
+exports.default = AEADCipher;

package/dist/cjs/lib/dtls/cipher/suites/null.d.ts

@@ -0,0 +1,24 @@
+import Cipher from './abstract.js';
+/**
+ * Default passthrough cipher.
+ */
+export default class NullCipher extends Cipher {
+    /**
+   * @class NullCipher
+   */
+    constructor();
+    /**
+   * Encrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    encrypt(session: any, data: Buffer): Buffer<ArrayBufferLike>;
+    /**
+   * Decrypts data.
+   * @param {AbstractSession} session
+   * @param {Buffer} data Content to encryption.
+   * @returns {Buffer}
+   */
+    decrypt(session: any, data: Buffer): Buffer<ArrayBufferLike>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const key_exchange_js_1 = require("../key-exchange.js");
+const abstract_js_1 = __importDefault(require("./abstract.js"));
+/**
+ * Default passthrough cipher.
+ */
+class NullCipher extends abstract_js_1.default {
+    /**
+   * @class NullCipher
+   */
+    constructor() {
+        super();
+        this.name = 'NULL_NULL_NULL'; // key, mac, hash
+        this.blockAlgorithm = undefined;
+        this.kx = (0, key_exchange_js_1.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;
+    }
+}
+exports.default = NullCipher;

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

@@ -0,0 +1,18 @@
+/**
+ * Culculates HMAC using provided hash.
+ * @param {string} algorithm - Hash algorithm.
+ * @param {Buffer} secret - Hmac seed.
+ * @param {Buffer} data - Input data.
+ * @returns {Buffer}
+ */
+declare function hmac(algorithm: string, secret: Buffer, data: Buffer): NonSharedBuffer;
+/**
+ * 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}
+ */
+declare function pHash(bytes: number, algorithm: string, secret: Buffer, seed: Buffer): Buffer<ArrayBuffer>;
+export { hmac, pHash };

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

@@ -0,0 +1,70 @@
+"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.hmac = hmac;
+exports.pHash = pHash;
+const crypto = __importStar(require("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);
+}

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

@@ -0,0 +1,33 @@
+import { type KeyObject } from 'node:crypto';
+/**
+ * The algorithm of the key of a self-signed certificate: ECDSA on P-256, or RSA (2048 bits)
+ */
+export type CertificateKeyType = 'ecdsa' | 'rsa';
+/**
+ * A certificate and its private key, both in PEM
+ */
+export interface CertificatePem {
+    certPem: string;
+    keyPem: string;
+}
+/**
+ * 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 declare function createDtlsCertificate(keyType?: CertificateKeyType, name?: string, days?: number): CertificatePem;
+/**
+ * Wraps DER in PEM, 64 characters of base64 per line
+ */
+export declare function toPem(derBytes: Buffer, label: string): string;
+/**
+ * The DER of the first certificate of a PEM text
+ */
+export declare function certificateDer(pem: string): Buffer;
+/**
+ * The private key of a PEM text (PKCS #8, PKCS #1 or SEC 1)
+ */
+export declare function privateKeyFromPem(pem: string): KeyObject;

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDtlsCertificate = createDtlsCertificate;
+exports.toPem = toPem;
+exports.certificateDer = certificateDer;
+exports.privateKeyFromPem = privateKeyFromPem;
+const node_crypto_1 = require("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
+ */
+function createDtlsCertificate(keyType = 'ecdsa', name = 'WebRTC', days = 30) {
+    const { privateKey, publicKey } = keyType === 'ecdsa'
+        ? (0, node_crypto_1.generateKeyPairSync)('ec', { namedCurve: 'prime256v1' })
+        : (0, node_crypto_1.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 = (0, node_crypto_1.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 = (0, node_crypto_1.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
+ */
+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
+ */
+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)
+ */
+function privateKeyFromPem(pem) {
+    return (0, node_crypto_1.createPrivateKey)(pem);
+}

package/dist/cjs/lib/dtls/client.d.ts

@@ -0,0 +1,7 @@
+import { DtlsSocket, type Options } from './socket.js';
+export declare class DtlsClient extends DtlsSocket {
+    constructor(options: Options);
+    connect(): Promise<void>;
+    private flight5?;
+    private handleHandshakes;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsClient = void 0;
+const abstract_js_1 = require("./cipher/suites/abstract.js");
+const flight1_js_1 = require("./flight/client/flight1.js");
+const flight3_js_1 = require("./flight/client/flight3.js");
+const flight5_js_1 = require("./flight/client/flight5.js");
+const const_js_1 = require("./handshake/const.js");
+const helloVerifyRequest_js_1 = require("./handshake/message/server/helloVerifyRequest.js");
+const common_js_1 = require("./imports/common.js");
+const socket_js_1 = require("./socket.js");
+const log = (0, common_js_1.debug)('webrtc/dtls/client:log');
+class DtlsClient extends socket_js_1.DtlsSocket {
+    constructor(options) {
+        super(options, abstract_js_1.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 const_js_1.HandshakeType.hello_verify_request_3:
+                        {
+                            const verifyReq = helloVerifyRequest_js_1.ServerHelloVerifyRequest.deSerialize(handshake.fragment);
+                            await new flight3_js_1.Flight3(this.transport, this.dtls).exec(verifyReq);
+                        }
+                        break;
+                    // flight 4
+                    case const_js_1.HandshakeType.server_hello_2:
+                        {
+                            if (this.connected)
+                                return;
+                            this.flight5 = new flight5_js_1.Flight5(this.transport, this.dtls, this.cipher, this.srtp);
+                            this.flight5.handleHandshake(handshake);
+                        }
+                        break;
+                    case const_js_1.HandshakeType.certificate_11:
+                    case const_js_1.HandshakeType.server_key_exchange_12:
+                    case const_js_1.HandshakeType.certificate_request_13:
+                        {
+                            await this.waitForReady(() => !!this.flight5);
+                            this.flight5?.handleHandshake(handshake);
+                        }
+                        break;
+                    case const_js_1.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 const_js_1.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_js_1.Flight1(this.transport, this.dtls, this.cipher).exec(this.extensions);
+    }
+}
+exports.DtlsClient = DtlsClient;

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

@@ -0,0 +1,42 @@
+import { type KeyObject } from 'node:crypto';
+import { type CipherSuites, type NamedCurveAlgorithms, type SignatureHash } from '../cipher/const.js';
+import type { NamedCurveKeyPair } from '../cipher/namedCurve.js';
+import { type SessionTypes } from '../cipher/suites/abstract.js';
+import type AEADCipher from '../cipher/suites/aead.js';
+import type { DtlsRandom } from '../handshake/random.js';
+import type { DtlsPlaintext } from '../record/message/plaintext.js';
+export declare class CipherContext {
+    sessionType: SessionTypes;
+    certPem?: string | undefined;
+    keyPem?: string | undefined;
+    localRandom: DtlsRandom;
+    remoteRandom: DtlsRandom;
+    cipherSuite: CipherSuites;
+    remoteCertificate?: Buffer;
+    remoteKeyPair: Partial<NamedCurveKeyPair>;
+    localKeyPair: NamedCurveKeyPair;
+    masterSecret: Buffer;
+    cipher: AEADCipher;
+    namedCurve: NamedCurveAlgorithms;
+    signatureHashAlgorithm?: SignatureHash;
+    localCert: Buffer;
+    localPrivateKey: KeyObject;
+    constructor(sessionType: SessionTypes, certPem?: string | undefined, keyPem?: string | undefined, signatureHashAlgorithm?: SignatureHash);
+    /**
+   *
+   * @param signatureHash
+   * @param namedCurveAlgorithm necessary when use ecdsa
+   */
+    static createSelfSignedCertificateWithKey: (signatureHash: SignatureHash, _namedCurveAlgorithm?: NamedCurveAlgorithms) => Promise<{
+        certPem: string;
+        keyPem: string;
+        signatureHash: SignatureHash;
+    }>;
+    encryptPacket(pkt: DtlsPlaintext): DtlsPlaintext;
+    decryptPacket(pkt: DtlsPlaintext): Buffer<ArrayBuffer>;
+    verifyData(buf: Buffer): Buffer<ArrayBuffer>;
+    signatureData(data: Buffer, hash: string): NonSharedBuffer;
+    generateKeySignature(hashAlgorithm: string): NonSharedBuffer;
+    parseX509(certPem: string, keyPem: string, signatureHash: SignatureHash): void;
+    private valueKeySignature;
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CipherContext = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("../cipher/const.js");
+const x509_js_1 = require("../cipher/x509.js");
+const prf_js_1 = require("../cipher/prf.js");
+const abstract_js_1 = require("../cipher/suites/abstract.js");
+const { encode, types } = common_js_1.binaryData;
+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 } = (0, x509_js_1.createDtlsCertificate)(signatureHash.signature === const_js_1.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 === abstract_js_1.SessionType.CLIENT)
+            return (0, prf_js_1.prfVerifyDataClient)(this.masterSecret, buf);
+        else
+            return (0, prf_js_1.prfVerifyDataServer)(this.masterSecret, buf);
+    }
+    signatureData(data, hash) {
+        return (0, node_crypto_1.sign)(hash, data, this.localPrivateKey);
+    }
+    generateKeySignature(hashAlgorithm) {
+        const clientRandom = this.sessionType === abstract_js_1.SessionType.CLIENT
+            ? this.localRandom
+            : this.remoteRandom;
+        const serverRandom = this.sessionType === abstract_js_1.SessionType.SERVER
+            ? this.localRandom
+            : this.remoteRandom;
+        const sig = this.valueKeySignature(clientRandom.serialize(), serverRandom.serialize(), this.localKeyPair.publicKey, this.namedCurve);
+        return (0, node_crypto_1.sign)(hashAlgorithm, sig, this.localPrivateKey);
+    }
+    parseX509(certPem, keyPem, signatureHash) {
+        this.localCert = (0, x509_js_1.certificateDer)(certPem);
+        this.localPrivateKey = (0, x509_js_1.privateKeyFromPem)(keyPem);
+        this.signatureHashAlgorithm = signatureHash;
+    }
+    valueKeySignature(clientRandom, serverRandom, publicKey, namedCurve) {
+        const serverParams = encode({
+            type: const_js_1.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]);
+    }
+}
+exports.CipherContext = CipherContext;

package/dist/cjs/lib/dtls/context/dtls.d.ts

@@ -0,0 +1,38 @@
+import type { HashAlgorithms, SignatureAlgorithms } from '../cipher/const.js';
+import type { SessionTypes } from '../cipher/suites/abstract.js';
+import type { FragmentedHandshake } from '../record/message/fragment.js';
+import type { Options } from '../socket.js';
+import type { Handshake } from '../typings/domain.js';
+export declare class DtlsContext {
+    options: Options;
+    sessionType: SessionTypes;
+    version: {
+        major: number;
+        minor: number;
+    };
+    lastFlight: Handshake[];
+    lastMessage: Buffer[];
+    recordSequenceNumber: number;
+    sequenceNumber: number;
+    epoch: number;
+    flight: number;
+    handshakeCache: {
+        [flight: number]: {
+            isLocal: boolean;
+            data: FragmentedHandshake[];
+            flight: number;
+        };
+    };
+    cookie?: Buffer;
+    requestedCertificateTypes: number[];
+    requestedSignatureAlgorithms: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[];
+    remoteExtendedMasterSecret: boolean;
+    constructor(options: Options, sessionType: SessionTypes);
+    get sessionId(): string;
+    get sortedHandshakeCache(): FragmentedHandshake[];
+    checkHandshakesExist: (handshakes: number[]) => boolean;
+    bufferHandshakeCache(handshakes: FragmentedHandshake[], isLocal: boolean, flight: number): void;
+}