@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCipher = createCipher;
+exports.createAEADCipher = createAEADCipher;
+const key_exchange_js_1 = require("./key-exchange.js");
+const aead_js_1 = __importDefault(require("./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 = (0, key_exchange_js_1.createRSAKeyExchange)();
+const ECDHE_RSA_KEY_EXCHANGE = (0, key_exchange_js_1.createECDHERSAKeyExchange)();
+const ECDHE_ECDSA_KEY_EXCHANGE = (0, key_exchange_js_1.createECDHEECDSAKeyExchange)();
+const PSK_KEY_EXCHANGE = (0, key_exchange_js_1.createPSKKeyExchange)();
+const ECDHE_PSK_KEY_EXCHANGE = (0, key_exchange_js_1.createECDHEPSKKeyExchange)();
+/**
+ * Convert cipher value to cipher instance.
+ * @param {number} cipher
+ */
+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}
+ */
+function createAEADCipher(id, name, block, kx, constants, hash = 'sha256') {
+    const cipher = new aead_js_1.default();
+    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/cjs/lib/dtls/cipher/ec.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A key pair of P-256 for ECDHE: the private scalar (32 bytes) and the uncompressed public point (65 bytes)
+ */
+export declare const p256Keypair: () => {
+    privateKey: Buffer;
+    publicKey: Buffer;
+};
+/**
+ * The premaster secret of ECDHE on P-256: the x coordinate of the shared point
+ */
+export declare const p256PreMasterSecret: ({ publicKey, privateKey }: {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}) => Buffer;
+/**
+ * A key pair of X25519: both keys as their raw 32 bytes
+ */
+export declare const x25519Keypair: () => {
+    privateKey: Buffer;
+    publicKey: Buffer;
+};
+/**
+ * The premaster secret of X25519 from the raw keys
+ */
+export declare const x25519PreMasterSecret: ({ publicKey, privateKey }: {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}) => Buffer;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.x25519PreMasterSecret = exports.x25519Keypair = exports.p256PreMasterSecret = exports.p256Keypair = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * A key pair of P-256 for ECDHE: the private scalar (32 bytes) and the uncompressed public point (65 bytes)
+ */
+const p256Keypair = () => {
+    const ecdh = (0, node_crypto_1.createECDH)('prime256v1');
+    const publicKey = ecdh.generateKeys();
+    return { privateKey: ecdh.getPrivateKey(), publicKey };
+};
+exports.p256Keypair = p256Keypair;
+/**
+ * The premaster secret of ECDHE on P-256: the x coordinate of the shared point
+ */
+const p256PreMasterSecret = ({ publicKey, privateKey }) => {
+    const ecdh = (0, node_crypto_1.createECDH)('prime256v1');
+    ecdh.setPrivateKey(privateKey);
+    return ecdh.computeSecret(publicKey);
+};
+exports.p256PreMasterSecret = p256PreMasterSecret;
+//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
+ */
+const x25519Keypair = () => {
+    const { privateKey, publicKey } = (0, node_crypto_1.generateKeyPairSync)('x25519');
+    return {
+        privateKey: privateKey.export({ type: 'pkcs8', format: 'der' }).subarray(x25519Pkcs8Prefix.length),
+        publicKey: publicKey.export({ type: 'spki', format: 'der' }).subarray(x25519SpkiPrefix.length)
+    };
+};
+exports.x25519Keypair = x25519Keypair;
+/**
+ * The premaster secret of X25519 from the raw keys
+ */
+const x25519PreMasterSecret = ({ publicKey, privateKey }) => (0, node_crypto_1.diffieHellman)({
+    privateKey: (0, node_crypto_1.createPrivateKey)({ key: Buffer.concat([x25519Pkcs8Prefix, privateKey]), format: 'der', type: 'pkcs8' }),
+    publicKey: (0, node_crypto_1.createPublicKey)({ key: Buffer.concat([x25519SpkiPrefix, publicKey]), format: 'der', type: 'spki' })
+});
+exports.x25519PreMasterSecret = x25519PreMasterSecret;

package/dist/cjs/lib/dtls/cipher/key-exchange.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This class represent type of key exchange mechanism.
+ */
+export declare class KeyExchange {
+    id: number;
+    name?: string;
+    signType?: number;
+    keyType?: number;
+    /**
+   * @returns {string}
+   */
+    toString(): string | undefined;
+}
+/**
+ * Creates `RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createRSAKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHERSAKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_ECDSA` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHEECDSAKeyExchange(): KeyExchange;
+/**
+ * Creates `NULL` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createNULLKeyExchange(): KeyExchange;
+/**
+ * Creates `PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createPSKKeyExchange(): KeyExchange;
+/**
+ * Creates `ECDHE_PSK` key exchange.
+ * @returns {KeyExchange}
+ */
+export declare function createECDHEPSKKeyExchange(): KeyExchange;

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyExchange = void 0;
+exports.createRSAKeyExchange = createRSAKeyExchange;
+exports.createECDHERSAKeyExchange = createECDHERSAKeyExchange;
+exports.createECDHEECDSAKeyExchange = createECDHEECDSAKeyExchange;
+exports.createNULLKeyExchange = createNULLKeyExchange;
+exports.createPSKKeyExchange = createPSKKeyExchange;
+exports.createECDHEPSKKeyExchange = createECDHEPSKKeyExchange;
+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.
+ */
+class KeyExchange {
+    constructor() {
+        this.id = 0;
+    }
+    /**
+   * @returns {string}
+   */
+    toString() {
+        return this.name;
+    }
+}
+exports.KeyExchange = KeyExchange;
+/**
+ * Creates `RSA` key exchange.
+ * @returns {KeyExchange}
+ */
+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}
+ */
+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}
+ */
+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}
+ */
+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}
+ */
+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}
+ */
+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/cjs/lib/dtls/cipher/namedCurve.d.ts

@@ -0,0 +1,7 @@
+import { type NamedCurveAlgorithms } from './const.js';
+export interface NamedCurveKeyPair {
+    curve: NamedCurveAlgorithms;
+    publicKey: Buffer;
+    privateKey: Buffer;
+}
+export declare function generateKeyPair(namedCurve: NamedCurveAlgorithms): NamedCurveKeyPair;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKeyPair = generateKeyPair;
+const const_js_1 = require("./const.js");
+const ec_js_1 = require("./ec.js");
+function generateKeyPair(namedCurve) {
+    switch (namedCurve) {
+        case const_js_1.NamedCurveAlgorithm.secp256r1_23: {
+            const { privateKey, publicKey } = (0, ec_js_1.p256Keypair)();
+            return {
+                curve: namedCurve,
+                privateKey,
+                publicKey
+            };
+        }
+        case const_js_1.NamedCurveAlgorithm.x25519_29: {
+            const { privateKey, publicKey } = (0, ec_js_1.x25519Keypair)();
+            return {
+                curve: namedCurve,
+                privateKey,
+                publicKey
+            };
+        }
+        default:
+            throw new Error();
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type NamedCurveAlgorithms } from './const.js';
+export declare function prfPreMasterSecret(publicKey: Buffer, privateKey: Buffer, curve: NamedCurveAlgorithms): Buffer<ArrayBufferLike>;
+export declare function hmac(algorithm: string, secret: Buffer, data: Buffer): NonSharedBuffer;
+export declare function prfPHash(secret: Buffer, seed: Buffer, requestedLegth: number, algorithm?: string): Buffer<ArrayBuffer>;
+export declare function prfMasterSecret(preMasterSecret: Buffer, clientRandom: Buffer, serverRandom: Buffer): Buffer<ArrayBuffer>;
+export declare function prfExtendedMasterSecret(preMasterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function exportKeyingMaterial(label: string, length: number, masterSecret: Buffer, localRandom: Buffer, remoteRandom: Buffer, isClient: boolean): Buffer<ArrayBuffer>;
+export declare function hash(algorithm: string, data: Buffer): NonSharedBuffer;
+export declare function prfVerifyData(masterSecret: Buffer, handshakes: Buffer, label: string, size?: number): Buffer<ArrayBuffer>;
+export declare function prfVerifyDataClient(masterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function prfVerifyDataServer(masterSecret: Buffer, handshakes: Buffer): Buffer<ArrayBuffer>;
+export declare function prfEncryptionKeys(masterSecret: Buffer, clientRandom: Buffer, serverRandom: Buffer, prfKeyLen: number, prfIvLen: number, prfNonceLen: number, algorithm?: string): {
+    clientWriteKey: Buffer<ArrayBufferLike>;
+    serverWriteKey: Buffer<ArrayBufferLike>;
+    clientNonce: Buffer<ArrayBuffer>;
+    serverNonce: Buffer<ArrayBuffer>;
+};

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prfPreMasterSecret = prfPreMasterSecret;
+exports.hmac = hmac;
+exports.prfPHash = prfPHash;
+exports.prfMasterSecret = prfMasterSecret;
+exports.prfExtendedMasterSecret = prfExtendedMasterSecret;
+exports.exportKeyingMaterial = exportKeyingMaterial;
+exports.hash = hash;
+exports.prfVerifyData = prfVerifyData;
+exports.prfVerifyDataClient = prfVerifyDataClient;
+exports.prfVerifyDataServer = prfVerifyDataServer;
+exports.prfEncryptionKeys = prfEncryptionKeys;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("./const.js");
+const ec_js_1 = require("./ec.js");
+function prfPreMasterSecret(publicKey, privateKey, curve) {
+    switch (curve) {
+        case const_js_1.NamedCurveAlgorithm.secp256r1_23:
+            return (0, ec_js_1.p256PreMasterSecret)({ publicKey, privateKey });
+        case const_js_1.NamedCurveAlgorithm.x25519_29:
+            return (0, ec_js_1.x25519PreMasterSecret)({ publicKey, privateKey });
+        default:
+            throw new Error();
+    }
+}
+function hmac(algorithm, secret, data) {
+    const hash = (0, node_crypto_1.createHmac)(algorithm, secret);
+    hash.update(data);
+    return hash.digest();
+}
+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);
+}
+function prfMasterSecret(preMasterSecret, clientRandom, serverRandom) {
+    const seed = Buffer.concat([
+        Buffer.from('master secret'),
+        clientRandom,
+        serverRandom
+    ]);
+    return prfPHash(preMasterSecret, seed, 48);
+}
+function prfExtendedMasterSecret(preMasterSecret, handshakes) {
+    const sessionHash = hash('sha256', handshakes);
+    const label = 'extended master secret';
+    return prfPHash(preMasterSecret, Buffer.concat([Buffer.from(label), sessionHash]), 48);
+}
+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);
+}
+function hash(algorithm, data) {
+    return (0, node_crypto_1.createHash)(algorithm).update(data).digest();
+}
+function prfVerifyData(masterSecret, handshakes, label, size = 12) {
+    const bytes = hash('sha256', handshakes);
+    return prfPHash(masterSecret, Buffer.concat([Buffer.from(label), bytes]), size);
+}
+function prfVerifyDataClient(masterSecret, handshakes) {
+    return prfVerifyData(masterSecret, handshakes, 'client finished');
+}
+function prfVerifyDataServer(masterSecret, handshakes) {
+    return prfVerifyData(masterSecret, handshakes, 'server finished');
+}
+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 common_js_1.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/cjs/lib/dtls/cipher/suites/abstract.d.ts

@@ -0,0 +1,40 @@
+import type { CipherGCMTypes } from 'node:crypto';
+import type { KeyExchange } from '../key-exchange.js';
+export type CipherHeader = {
+    type: number;
+    version: number;
+    epoch: number;
+    sequenceNumber: number;
+};
+export declare const SessionType: {
+    readonly CLIENT: 1;
+    readonly SERVER: 2;
+};
+export type SessionTypes = (typeof SessionType)[keyof typeof SessionType];
+export default abstract class AbstractCipher {
+    id: number;
+    name?: string;
+    hashAlgorithm?: string;
+    verifyDataLength: number;
+    blockAlgorithm?: CipherGCMTypes;
+    kx?: KeyExchange;
+    /**
+   * Init cipher.
+   * @abstract
+   */
+    init(..._args: any): void;
+    /**
+   * Encrypts data.
+   * @abstract
+   */
+    encrypt(..._args: any): Buffer;
+    /**
+   * Decrypts data.
+   * @abstract
+   */
+    decrypt(..._args: any): Buffer;
+    /**
+   * @returns {string}
+   */
+    toString(): string | undefined;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionType = void 0;
+exports.SessionType = {
+    CLIENT: 1,
+    SERVER: 2
+};
+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;
+    }
+}
+exports.default = AbstractCipher;

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

@@ -0,0 +1,28 @@
+import Cipher, { type CipherHeader, type SessionTypes } from './abstract.js';
+/**
+ * This class implements AEAD cipher family.
+ */
+export default class AEADCipher extends Cipher {
+    keyLength: number;
+    nonceLength: number;
+    ivLength: number;
+    authTagLength: number;
+    nonceImplicitLength: number;
+    nonceExplicitLength: number;
+    clientWriteKey?: Buffer;
+    serverWriteKey?: Buffer;
+    clientNonce?: Buffer;
+    serverNonce?: Buffer;
+    constructor();
+    get summary(): any;
+    init(masterSecret: Buffer, serverRandom: Buffer, clientRandom: Buffer): void;
+    /**
+   * Encrypt message.
+   */
+    encrypt(type: SessionTypes, data: Buffer, header: CipherHeader): Buffer<ArrayBuffer>;
+    encodeAdditionalBuffer(header: CipherHeader, dataLength: number): Buffer<ArrayBuffer>;
+    /**
+   * Decrypt message.
+   */
+    decrypt(type: SessionTypes, data: Buffer, header: CipherHeader): Buffer<ArrayBuffer>;
+}