@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/dtls/handshake/random.d.ts

@@ -0,0 +1,13 @@
+import { binaryData } from '../imports/common.js';
+export declare class DtlsRandom {
+    gmt_unix_time: number;
+    random_bytes: NonSharedBuffer;
+    static readonly spec: {
+        gmt_unix_time: binaryData.NumberType;
+        random_bytes: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(gmt_unix_time?: number, random_bytes?: NonSharedBuffer);
+    static deSerialize(buf: Buffer): DtlsRandom;
+    static from(spec: binaryData.Decoded<typeof DtlsRandom.spec>): DtlsRandom;
+    serialize(): Buffer<ArrayBufferLike>;
+}

package/dist/cjs/lib/dtls/handshake/random.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsRandom = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class DtlsRandom {
+    static { this.spec = {
+        gmt_unix_time: types.uint32be,
+        random_bytes: types.buffer(28)
+    }; }
+    constructor(gmt_unix_time = Math.floor(Date.now() / 1000), random_bytes = (0, node_crypto_1.randomBytes)(28)) {
+        this.gmt_unix_time = gmt_unix_time;
+        this.random_bytes = random_bytes;
+    }
+    static deSerialize(buf) {
+        return new DtlsRandom(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, DtlsRandom.spec)));
+    }
+    static from(spec) {
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        return new DtlsRandom(...Object.values(spec));
+    }
+    serialize() {
+        return encode(this, DtlsRandom.spec);
+    }
+}
+exports.DtlsRandom = DtlsRandom;

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

@@ -0,0 +1,4 @@
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function divide(from: string, split: string): [string, string];
+export declare const dumpBuffer: (data: Buffer) => string;
+export declare const getObjectSummary: (obj: any) => any;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectSummary = exports.dumpBuffer = void 0;
+exports.enumerate = enumerate;
+exports.divide = divide;
+function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+function divide(from, split) {
+    const arr = from.split(split);
+    return [arr[0], arr.slice(1).join(split)];
+}
+const dumpBuffer = (data) => '0x' +
+    data
+        .toString('hex')
+        .replace(/(.)(.)/g, '$1$2 ')
+        .split(' ')
+        .filter((s) => s != undefined && s.length > 0)
+        .join(',0x');
+exports.dumpBuffer = dumpBuffer;
+const getObjectSummary = (obj) => Object.entries({ ...obj }).reduce((acc, [key, value]) => {
+    if (typeof value === 'number' || typeof value === 'string') {
+        acc[key] = value;
+    }
+    if (Buffer.isBuffer(value)) {
+        acc[key] = (0, exports.dumpBuffer)(value);
+    }
+    return acc;
+}, {});
+exports.getObjectSummary = getObjectSummary;

package/dist/cjs/lib/dtls/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/cjs/lib/dtls/imports/common.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../common/index.js"), exports);

package/dist/cjs/lib/dtls/imports/rtp.d.ts

@@ -0,0 +1 @@
+export * from '../../rtp/index.js';

package/dist/cjs/lib/dtls/imports/rtp.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../rtp/index.js"), exports);

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

@@ -0,0 +1,7 @@
+export * from './context/cipher.js';
+export * from './context/srtp.js';
+export * from './cipher/const.js';
+export * from './cipher/x509.js';
+export { DtlsClient } from './client.js';
+export { DtlsServer } from './server.js';
+export { DtlsSocket } from './socket.js';

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

@@ -0,0 +1,117 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsSocket = exports.DtlsServer = exports.DtlsClient = void 0;
+__exportStar(require("./context/cipher.js"), exports);
+__exportStar(require("./context/srtp.js"), exports);
+__exportStar(require("./cipher/const.js"), exports);
+__exportStar(require("./cipher/x509.js"), exports);
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "DtlsClient", { enumerable: true, get: function () { return client_js_1.DtlsClient; } });
+var server_js_1 = require("./server.js");
+Object.defineProperty(exports, "DtlsServer", { enumerable: true, get: function () { return server_js_1.DtlsServer; } });
+var socket_js_1 = require("./socket.js");
+Object.defineProperty(exports, "DtlsSocket", { enumerable: true, get: function () { return socket_js_1.DtlsSocket; } });
+/* Client                                          Server
+   ------                                          ------
+
+   ClientHello             -------->                           Flight 1
+
+                           <-------    HelloVerifyRequest      Flight 2
+
+   ClientHello             -------->                           Flight 3
+
+                                              ServerHello    \
+                                             Certificate*     \
+                                       ServerKeyExchange*      Flight 4
+                                      CertificateRequest*     /
+                           <--------      ServerHelloDone    /
+
+   Certificate*                                              \
+   ClientKeyExchange                                          \
+   CertificateVerify*                                          Flight 5
+   [ChangeCipherSpec]                                         /
+   Finished                -------->                         /
+
+                                       [ChangeCipherSpec]    \ Flight 6
+                           <--------             Finished    /
+
+               Figure 1. Message Flights for Full Handshake
+
+=======================================================================
+
+   Client                                           Server
+   ------                                           ------
+
+   ClientHello             -------->                          Flight 1
+
+                                              ServerHello    \
+                                       [ChangeCipherSpec]     Flight 2
+                            <--------             Finished    /
+
+   [ChangeCipherSpec]                                         \Flight 3
+   Finished                 -------->                         /
+
+         Figure 2. Message Flights for Session-Resuming Handshake
+                           (No Cookie Exchange)
+*/
+// enum HandshakeType {
+//   hello_request = 0,
+//   client_hello = 1,
+//   server_hello = 2,
+//   hello_verify_request = 3,
+//   certificate = 11,
+//   server_key_exchange = 12,
+//   certificate_request = 13,
+//   server_hello_done = 14,
+//   certificate_verify = 15,
+//   client_key_exchange = 16,
+//   finished = 20,
+// }
+// enum ContentType {
+//   changeCipherSpec = 20,
+//   alert = 21,
+//   handshake = 22,
+//   applicationData = 23,
+// }
+// enum {
+//   close_notify(0),
+//   unexpected_message(10),
+//   bad_record_mac(20),
+//   decryption_failed_RESERVED(21),
+//   record_overflow(22),
+//   decompression_failure(30),
+//   handshake_failure(40),
+//   no_certificate_RESERVED(41),
+//   bad_certificate(42),
+//   unsupported_certificate(43),
+//   certificate_revoked(44),
+//   certificate_expired(45),
+//   certificate_unknown(46),
+//   illegal_parameter(47),
+//   unknown_ca(48),
+//   access_denied(49),
+//   decode_error(50),
+//   decrypt_error(51),
+//   export_restriction_RESERVED(60),
+//   protocol_version(70),
+//   insufficient_security(71),
+//   internal_error(80),
+//   user_canceled(90),
+//   no_renegotiation(100),
+//   unsupported_extension(110),
+//   (255)
+// } AlertDescription;

package/dist/cjs/lib/dtls/record/antiReplayWindow.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Provides protection against replay attacks by remembering received packets in a sliding window
+ */
+export declare class AntiReplayWindow {
+    private window;
+    private ceiling;
+    constructor();
+    /**
+   * Initializes the anti replay window to its default state
+   */
+    reset(): void;
+    /**
+   * Checks if the packet with the given sequence number may be received or has to be discarded
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    mayReceive(seq_num: number): boolean;
+    /**
+   * Checks if the packet with the given sequence number is marked as received
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    hasReceived(seq_num: number): boolean;
+    /**
+   * Marks the packet with the given sequence number as received
+   * @param seq_num - The sequence number of the packet
+   */
+    markAsReceived(seq_num: number): void;
+}

package/dist/cjs/lib/dtls/record/antiReplayWindow.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntiReplayWindow = void 0;
+const width = 64; // bits / entries, must be multiple of INT_SIZE
+const INT_SIZE = 32; // in JS, bitwise operators use 32bit ints
+/**
+ * Provides protection against replay attacks by remembering received packets in a sliding window
+ */
+class AntiReplayWindow {
+    constructor() {
+        // window bitmap looks as follows:
+        //  v- upper end                    lower end --v
+        // [111011 ... window_n]...[11111101 ... window_0]
+        this.window = [];
+        this.ceiling = 0; // upper end of the window bitmap / highest received seq_num
+        this.reset();
+    }
+    /**
+   * Initializes the anti replay window to its default state
+   */
+    reset() {
+        this.window = [];
+        for (let i = 0; i < width / INT_SIZE; i++) {
+            this.window[i] = 0;
+        }
+        this.ceiling = width - 1;
+    }
+    /**
+   * Checks if the packet with the given sequence number may be received or has to be discarded
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    mayReceive(seq_num) {
+        if (seq_num > this.ceiling + width) {
+            // we skipped a lot of packets... I don't think we should accept
+            return false;
+        }
+        else if (seq_num > this.ceiling) {
+            // always accept new packets
+            return true;
+        }
+        else if (seq_num >= this.ceiling - width + 1 && seq_num <= this.ceiling) {
+            // packet falls within the window, check if it was received already.
+            // if so, don't accept
+            return !this.hasReceived(seq_num);
+        } /* seq_num <= this.ceiling - width */
+        else {
+            // too old, don't accept
+            return false;
+        }
+    }
+    /**
+   * Checks if the packet with the given sequence number is marked as received
+   * @param seq_num - The sequence number of the packet to be checked
+   */
+    hasReceived(seq_num) {
+        // check if the packet was received already
+        const lowerBound = this.ceiling - width + 1;
+        // find out where the bit is located
+        const bitIndex = seq_num - lowerBound;
+        const windowIndex = Math.floor(bitIndex / INT_SIZE);
+        const windowBit = bitIndex % INT_SIZE;
+        const flag = 1 << windowBit;
+        // check if it is set;
+        return (this.window[windowIndex] & flag) === flag;
+    }
+    /**
+   * Marks the packet with the given sequence number as received
+   * @param seq_num - The sequence number of the packet
+   */
+    markAsReceived(seq_num) {
+        if (seq_num > this.ceiling) {
+            // shift the window
+            let amount = seq_num - this.ceiling;
+            // first shift whole blocks
+            while (amount > INT_SIZE) {
+                for (let i = 1; i < this.window.length; i++) {
+                    this.window[i - 1] = this.window[i];
+                }
+                this.window[this.window.length - 1] = 0;
+                amount -= INT_SIZE;
+            }
+            // now shift bitwise (to the right)
+            for (let i = 0; i < this.window.length; i++) {
+                const overflow = this.window[i] << (INT_SIZE - amount); // BBBBBBAA => AA000000
+                this.window[i] = this.window[i] >>> amount; // BBBBBBAA ==> 00BBBBBB
+                if (i > 0)
+                    this.window[i - 1] |= overflow;
+            }
+            // and remember the new ceiling
+            this.ceiling = seq_num;
+        }
+        const lowerBound = this.ceiling - width + 1;
+        // find out where the bit is located
+        const bitIndex = seq_num - lowerBound;
+        const windowIndex = Math.floor(bitIndex / INT_SIZE);
+        const windowBit = bitIndex % INT_SIZE;
+        const flag = 1 << windowBit;
+        // and set it
+        this.window[windowIndex] |= flag;
+    }
+}
+exports.AntiReplayWindow = AntiReplayWindow;

package/dist/cjs/lib/dtls/record/builder.d.ts

@@ -0,0 +1,9 @@
+import type { DtlsContext } from '../context/dtls.js';
+import type { Handshake } from '../typings/domain.js';
+import { DtlsPlaintext } from './message/plaintext.js';
+export type Message = {
+    type: number;
+    fragment: Buffer;
+};
+export declare const createFragments: (dtls: DtlsContext) => (handshakes: Handshake[]) => import("./message/fragment.js").FragmentedHandshake[];
+export declare const createPlaintext: (dtls: DtlsContext) => (fragments: Message[], recordSequenceNumber: number) => DtlsPlaintext[];

package/dist/cjs/lib/dtls/record/builder.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlaintext = exports.createFragments = void 0;
+const plaintext_js_1 = require("./message/plaintext.js");
+const createFragments = (dtls) => (handshakes) => {
+    dtls.lastFlight = handshakes;
+    return handshakes.flatMap((handshake) => {
+        handshake.messageSeq = dtls.sequenceNumber++;
+        const fragment = handshake.toFragment();
+        const fragments = fragment.chunk();
+        return fragments;
+    });
+};
+exports.createFragments = createFragments;
+const createPlaintext = (dtls) => (fragments, recordSequenceNumber) => {
+    return fragments.map((msg) => {
+        const plaintext = new plaintext_js_1.DtlsPlaintext({
+            contentType: msg.type,
+            protocolVersion: dtls.version,
+            epoch: dtls.epoch,
+            sequenceNumber: recordSequenceNumber,
+            contentLen: msg.fragment.length
+        }, msg.fragment);
+        return plaintext;
+    });
+};
+exports.createPlaintext = createPlaintext;

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

@@ -0,0 +1,33 @@
+export declare enum ContentType {
+    changeCipherSpec = 20,
+    alert = 21,
+    handshake = 22,
+    applicationData = 23
+}
+export declare enum AlertDesc {
+    CloseNotify = 0,
+    UnexpectedMessage = 10,
+    BadRecordMac = 20,
+    DecryptionFailed = 21,
+    RecordOverflow = 22,
+    DecompressionFailure = 30,
+    HandshakeFailure = 40,
+    NoCertificate = 41,
+    BadCertificate = 42,
+    UnsupportedCertificate = 43,
+    CertificateRevoked = 44,
+    CertificateExpired = 45,
+    CertificateUnknown = 46,
+    IllegalParameter = 47,
+    UnknownCa = 48,
+    AccessDenied = 49,
+    DecodeError = 50,
+    DecryptError = 51,
+    ExportRestriction = 60,
+    ProtocolVersion = 70,
+    InsufficientSecurity = 71,
+    InternalError = 80,
+    UserCanceled = 90,
+    NoRenegotiation = 100,
+    UnsupportedExtension = 110
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertDesc = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType[ContentType["changeCipherSpec"] = 20] = "changeCipherSpec";
+    ContentType[ContentType["alert"] = 21] = "alert";
+    ContentType[ContentType["handshake"] = 22] = "handshake";
+    ContentType[ContentType["applicationData"] = 23] = "applicationData";
+})(ContentType || (exports.ContentType = ContentType = {}));
+var AlertDesc;
+(function (AlertDesc) {
+    AlertDesc[AlertDesc["CloseNotify"] = 0] = "CloseNotify";
+    AlertDesc[AlertDesc["UnexpectedMessage"] = 10] = "UnexpectedMessage";
+    AlertDesc[AlertDesc["BadRecordMac"] = 20] = "BadRecordMac";
+    AlertDesc[AlertDesc["DecryptionFailed"] = 21] = "DecryptionFailed";
+    AlertDesc[AlertDesc["RecordOverflow"] = 22] = "RecordOverflow";
+    AlertDesc[AlertDesc["DecompressionFailure"] = 30] = "DecompressionFailure";
+    AlertDesc[AlertDesc["HandshakeFailure"] = 40] = "HandshakeFailure";
+    AlertDesc[AlertDesc["NoCertificate"] = 41] = "NoCertificate";
+    AlertDesc[AlertDesc["BadCertificate"] = 42] = "BadCertificate";
+    AlertDesc[AlertDesc["UnsupportedCertificate"] = 43] = "UnsupportedCertificate";
+    AlertDesc[AlertDesc["CertificateRevoked"] = 44] = "CertificateRevoked";
+    AlertDesc[AlertDesc["CertificateExpired"] = 45] = "CertificateExpired";
+    AlertDesc[AlertDesc["CertificateUnknown"] = 46] = "CertificateUnknown";
+    AlertDesc[AlertDesc["IllegalParameter"] = 47] = "IllegalParameter";
+    AlertDesc[AlertDesc["UnknownCa"] = 48] = "UnknownCa";
+    AlertDesc[AlertDesc["AccessDenied"] = 49] = "AccessDenied";
+    AlertDesc[AlertDesc["DecodeError"] = 50] = "DecodeError";
+    AlertDesc[AlertDesc["DecryptError"] = 51] = "DecryptError";
+    AlertDesc[AlertDesc["ExportRestriction"] = 60] = "ExportRestriction";
+    AlertDesc[AlertDesc["ProtocolVersion"] = 70] = "ProtocolVersion";
+    AlertDesc[AlertDesc["InsufficientSecurity"] = 71] = "InsufficientSecurity";
+    AlertDesc[AlertDesc["InternalError"] = 80] = "InternalError";
+    AlertDesc[AlertDesc["UserCanceled"] = 90] = "UserCanceled";
+    AlertDesc[AlertDesc["NoRenegotiation"] = 100] = "NoRenegotiation";
+    AlertDesc[AlertDesc["UnsupportedExtension"] = 110] = "UnsupportedExtension";
+})(AlertDesc || (exports.AlertDesc = AlertDesc = {}));

package/dist/cjs/lib/dtls/record/message/fragment.d.ts

@@ -0,0 +1,26 @@
+import { binaryData } from '../../imports/common.js';
+import type { HandshakeType } from '../../handshake/const.js';
+export declare class FragmentedHandshake {
+    msg_type: number;
+    length: number;
+    message_seq: number;
+    fragment_offset: number;
+    fragment_length: number;
+    fragment: Buffer;
+    static readonly spec: {
+        msg_type: binaryData.NumberType;
+        length: binaryData.NumberType;
+        message_seq: binaryData.NumberType;
+        fragment_offset: binaryData.NumberType;
+        fragment_length: binaryData.NumberType;
+        fragment: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    constructor(msg_type: number, length: number, message_seq: number, fragment_offset: number, fragment_length: number, fragment: Buffer);
+    get summary(): any;
+    static createEmpty(): FragmentedHandshake;
+    static deSerialize(buf: Buffer): FragmentedHandshake;
+    serialize(): Buffer<ArrayBufferLike>;
+    chunk(maxFragmentLength?: number): FragmentedHandshake[];
+    static assemble(messages: FragmentedHandshake[]): FragmentedHandshake;
+    static findAllFragments(fragments: FragmentedHandshake[], type: HandshakeType): FragmentedHandshake[];
+}

package/dist/cjs/lib/dtls/record/message/fragment.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FragmentedHandshake = void 0;
+const common_js_1 = require("../../imports/common.js");
+const helper_js_1 = require("../../helper.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class FragmentedHandshake {
+    static { this.spec = {
+        msg_type: types.uint8,
+        length: types.uint24be,
+        message_seq: types.uint16be,
+        fragment_offset: types.uint24be,
+        fragment_length: types.uint24be,
+        fragment: types.buffer((context) => context.current.fragment_length)
+    }; }
+    constructor(msg_type, length, message_seq, fragment_offset, fragment_length, fragment) {
+        this.msg_type = msg_type;
+        this.length = length;
+        this.message_seq = message_seq;
+        this.fragment_offset = fragment_offset;
+        this.fragment_length = fragment_length;
+        this.fragment = fragment;
+    }
+    get summary() {
+        return (0, helper_js_1.getObjectSummary)(this);
+    }
+    static createEmpty() {
+        return new FragmentedHandshake(undefined, undefined, undefined, undefined, undefined, undefined);
+    }
+    static deSerialize(buf) {
+        return new FragmentedHandshake(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, FragmentedHandshake.spec)));
+    }
+    serialize() {
+        return encode(this, FragmentedHandshake.spec);
+    }
+    chunk(maxFragmentLength) {
+        let start = 0;
+        const totalLength = this.fragment.length;
+        if (totalLength === 0)
+            return [
+                new FragmentedHandshake(this.msg_type, totalLength, this.message_seq, start, 0, this.fragment)
+            ];
+        const fragments = [];
+        if (!maxFragmentLength) {
+            maxFragmentLength = 1280 - (20 + 8) - (1 + 3 + 2 + 3 + 3);
+        }
+        // loop through the message and fragment it
+        while (start < totalLength) {
+            // calculate maximum length, limited by MTU - IP/UDP headers - handshake overhead
+            const fragmentLength = Math.min(maxFragmentLength, totalLength - start);
+            // slice and dice
+            const data = Buffer.from(this.fragment.slice(start, start + fragmentLength));
+            if (data.length <= 0) {
+                // this shouldn't happen, but we don't want to introduce an infinite loop
+                throw new Error(`Zero or less bytes processed while fragmenting handshake message.`);
+            }
+            // create the message
+            fragments.push(new FragmentedHandshake(this.msg_type, totalLength, this.message_seq, start, data.length, data));
+            // step forward by the actual fragment length
+            start += data.length;
+        }
+        return fragments;
+    }
+    static assemble(messages) {
+        // cannot reassemble empty arrays
+        if (!messages?.length) {
+            throw new Error('cannot reassemble handshake from empty array');
+        }
+        // sort by fragment start
+        messages = messages.sort((a, b) => a.fragment_offset - b.fragment_offset);
+        // combine into a single buffer
+        const combined = Buffer.alloc(messages[0].length);
+        for (const msg of messages) {
+            msg.fragment.copy(combined, msg.fragment_offset);
+        }
+        // and return the complete message
+        return new FragmentedHandshake(messages[0].msg_type, messages[0].length, messages[0].message_seq, 0, combined.length, combined);
+    }
+    static findAllFragments(fragments, type) {
+        const reference = fragments.find((v) => v.msg_type === type);
+        if (!reference)
+            return [];
+        // ignore empty arrays
+        if (!fragments?.length)
+            return [];
+        // return all fragments with matching msg_type, message_seq and total length
+        return fragments.filter((f) => {
+            return (f.msg_type === reference.msg_type &&
+                f.message_seq === reference.message_seq &&
+                f.length === reference.length);
+        });
+    }
+}
+exports.FragmentedHandshake = FragmentedHandshake;

package/dist/cjs/lib/dtls/record/message/header.d.ts

@@ -0,0 +1,38 @@
+import { binaryData } from '../../imports/common.js';
+export interface DtlsPlaintextHeader {
+    contentType: number;
+    protocolVersion: {
+        major: number;
+        minor: number;
+    };
+    epoch: number;
+    sequenceNumber: number;
+    contentLen: number;
+}
+export declare class MACHeader {
+    epoch: number;
+    sequenceNumber: number;
+    contentType: number;
+    protocolVersion: {
+        major: number;
+        minor: number;
+    };
+    contentLen: number;
+    static readonly spec: {
+        epoch: binaryData.NumberType;
+        sequenceNumber: binaryData.NumberType;
+        contentType: binaryData.NumberType;
+        protocolVersion: {
+            major: binaryData.NumberType;
+            minor: binaryData.NumberType;
+        };
+        contentLen: binaryData.NumberType;
+    };
+    constructor(epoch: number, sequenceNumber: number, contentType: number, protocolVersion: {
+        major: number;
+        minor: number;
+    }, contentLen: number);
+    static createEmpty(): MACHeader;
+    static deSerialize(buf: Buffer): MACHeader;
+    serialize(): Buffer<ArrayBufferLike>;
+}