@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/dtls/flight/server/flight4.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight4 = void 0;
+const const_js_1 = require("../../cipher/const.js");
+const extendedMasterSecret_js_1 = require("../../handshake/extensions/extendedMasterSecret.js");
+const renegotiationIndication_js_1 = require("../../handshake/extensions/renegotiationIndication.js");
+const useSrtp_js_1 = require("../../handshake/extensions/useSrtp.js");
+const certificate_js_1 = require("../../handshake/message/certificate.js");
+const certificateRequest_js_1 = require("../../handshake/message/server/certificateRequest.js");
+const hello_js_1 = require("../../handshake/message/server/hello.js");
+const helloDone_js_1 = require("../../handshake/message/server/helloDone.js");
+const keyExchange_js_1 = require("../../handshake/message/server/keyExchange.js");
+const common_js_1 = require("../../imports/common.js");
+const flight_js_1 = require("../flight.js");
+const log = (0, common_js_1.debug)('webrtc/dtls/flight/server/flight4:log');
+class Flight4 extends flight_js_1.Flight {
+    constructor(udp, dtls, cipher, srtp) {
+        super(udp, dtls, 4, 6);
+        this.cipher = cipher;
+        this.srtp = srtp;
+    }
+    async exec(clientHello, certificateRequest = false) {
+        if (this.dtls.flight === 4) {
+            log(this.dtls.sessionId, 'flight4 twice');
+            this.send(this.dtls.lastMessage).catch((error) => log('send failed', error));
+            return;
+        }
+        this.dtls.flight = 4;
+        this.dtls.sequenceNumber = 1;
+        this.dtls.bufferHandshakeCache([clientHello], false, 4);
+        const messages = [
+            this.sendServerHello(),
+            this.sendCertificate(),
+            this.sendServerKeyExchange(),
+            certificateRequest && this.sendCertificateRequest(),
+            this.sendServerHelloDone()
+        ].filter((v) => v);
+        this.dtls.lastMessage = messages;
+        await this.transmit(messages);
+    }
+    sendServerHello() {
+        // todo fix; should use socket.extensions
+        const extensions = [];
+        if (this.srtp.srtpProfile) {
+            extensions.push(useSrtp_js_1.UseSRTP.create([this.srtp.srtpProfile], Buffer.from([0x00])).extension);
+        }
+        if (this.dtls.options.extendedMasterSecret) {
+            extensions.push({
+                type: extendedMasterSecret_js_1.ExtendedMasterSecret.type,
+                data: Buffer.alloc(0)
+            });
+        }
+        const renegotiationIndication = renegotiationIndication_js_1.RenegotiationIndication.createEmpty();
+        extensions.push(renegotiationIndication.extension);
+        const serverHello = new hello_js_1.ServerHello(this.dtls.version, this.cipher.localRandom, Buffer.from([0x00]), this.cipher.cipherSuite, 0, // do not compression
+        extensions);
+        const packets = this.createPacket([serverHello]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+    // 7.4.2 Server Certificate
+    sendCertificate() {
+        const certificate = new certificate_js_1.Certificate([Buffer.from(this.cipher.localCert)]);
+        const packets = this.createPacket([certificate]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+    sendServerKeyExchange() {
+        const signature = this.cipher.generateKeySignature('sha256');
+        if (!this.cipher.signatureHashAlgorithm)
+            throw new Error('not exist');
+        const keyExchange = new keyExchange_js_1.ServerKeyExchange(const_js_1.CurveType.named_curve_3, this.cipher.namedCurve, this.cipher.localKeyPair.publicKey.length, this.cipher.localKeyPair.publicKey, this.cipher.signatureHashAlgorithm.hash, this.cipher.signatureHashAlgorithm.signature, signature.length, signature);
+        const packets = this.createPacket([keyExchange]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+    // 7.4.4.  Certificate Request
+    sendCertificateRequest() {
+        const handshake = new certificateRequest_js_1.ServerCertificateRequest(const_js_1.certificateTypes, const_js_1.signatures, []);
+        log(this.dtls.sessionId, 'sendCertificateRequest', handshake);
+        const packets = this.createPacket([handshake]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+    sendServerHelloDone() {
+        const handshake = new helloDone_js_1.ServerHelloDone();
+        const packets = this.createPacket([handshake]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+}
+exports.Flight4 = Flight4;

package/dist/cjs/lib/dtls/flight/server/flight6.d.ts

@@ -0,0 +1,13 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { FragmentedHandshake } from '../../record/message/fragment.js';
+import { Flight } from '../flight.js';
+export declare class Flight6 extends Flight {
+    private cipher;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext);
+    handleHandshake(handshake: FragmentedHandshake): void;
+    exec(): Promise<void>;
+    private sendChangeCipherSpec;
+    private sendFinished;
+}

package/dist/cjs/lib/dtls/flight/server/flight6.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight6 = void 0;
+const create_js_1 = require("../../cipher/create.js");
+const prf_js_1 = require("../../cipher/prf.js");
+const const_js_1 = require("../../handshake/const.js");
+const certificate_js_1 = require("../../handshake/message/certificate.js");
+const changeCipherSpec_js_1 = require("../../handshake/message/changeCipherSpec.js");
+const certificateVerify_js_1 = require("../../handshake/message/client/certificateVerify.js");
+const keyExchange_js_1 = require("../../handshake/message/client/keyExchange.js");
+const finished_js_1 = require("../../handshake/message/finished.js");
+const common_js_1 = require("../../imports/common.js");
+const builder_js_1 = require("../../record/builder.js");
+const const_js_2 = require("../../record/const.js");
+const flight_js_1 = require("../flight.js");
+const log = (0, common_js_1.debug)('webrtc/dtls/flight/server/flight6');
+class Flight6 extends flight_js_1.Flight {
+    constructor(udp, dtls, cipher) {
+        super(udp, dtls, 6);
+        this.cipher = cipher;
+    }
+    handleHandshake(handshake) {
+        this.dtls.bufferHandshakeCache([handshake], false, 5);
+        const message = (() => {
+            switch (handshake.msg_type) {
+                case const_js_1.HandshakeType.certificate_11:
+                    return certificate_js_1.Certificate.deSerialize(handshake.fragment);
+                case const_js_1.HandshakeType.certificate_verify_15:
+                    return certificateVerify_js_1.CertificateVerify.deSerialize(handshake.fragment);
+                case const_js_1.HandshakeType.client_key_exchange_16:
+                    return keyExchange_js_1.ClientKeyExchange.deSerialize(handshake.fragment);
+                case const_js_1.HandshakeType.finished_20:
+                    return finished_js_1.Finished.deSerialize(handshake.fragment);
+            }
+        })();
+        if (message) {
+            const handler = handlers[message.msgType];
+            if (!handler) {
+                return;
+            }
+            handler({ dtls: this.dtls, cipher: this.cipher })(message);
+        }
+    }
+    async exec() {
+        if (this.dtls.flight === 6) {
+            log(this.dtls.sessionId, 'flight6 twice');
+            this.send(this.dtls.lastMessage).catch((error) => log('send failed', error));
+            return;
+        }
+        this.dtls.flight = 6;
+        const messages = [this.sendChangeCipherSpec(), this.sendFinished()];
+        this.dtls.lastMessage = messages;
+        await this.transmit(messages);
+    }
+    sendChangeCipherSpec() {
+        const changeCipherSpec = changeCipherSpec_js_1.ChangeCipherSpec.createEmpty().serialize();
+        const packets = (0, builder_js_1.createPlaintext)(this.dtls)([{ type: const_js_2.ContentType.changeCipherSpec, fragment: changeCipherSpec }], ++this.dtls.recordSequenceNumber);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        return buf;
+    }
+    sendFinished() {
+        const cache = Buffer.concat(this.dtls.sortedHandshakeCache.map((v) => v.serialize()));
+        const localVerifyData = this.cipher.verifyData(cache);
+        const finish = new finished_js_1.Finished(localVerifyData);
+        this.dtls.epoch = 1;
+        const [packet] = this.createPacket([finish]);
+        this.dtls.recordSequenceNumber = 0;
+        const buf = this.cipher.encryptPacket(packet).serialize();
+        return buf;
+    }
+}
+exports.Flight6 = Flight6;
+const handlers = {};
+handlers[const_js_1.HandshakeType.client_key_exchange_16] =
+    ({ cipher, dtls }) => (message) => {
+        cipher.remoteKeyPair = {
+            curve: cipher.namedCurve,
+            publicKey: message.publicKey
+        };
+        if (!cipher.remoteKeyPair.publicKey ||
+            !cipher.localKeyPair ||
+            !cipher.remoteRandom ||
+            !cipher.localRandom)
+            throw new Error('not exist');
+        const preMasterSecret = (0, prf_js_1.prfPreMasterSecret)(cipher.remoteKeyPair.publicKey, cipher.localKeyPair.privateKey, cipher.localKeyPair.curve);
+        log(dtls.sessionId, 'extendedMasterSecret', dtls.options.extendedMasterSecret, dtls.remoteExtendedMasterSecret);
+        const handshakes = Buffer.concat(dtls.sortedHandshakeCache.map((v) => v.serialize()));
+        cipher.masterSecret =
+            dtls.options.extendedMasterSecret && dtls.remoteExtendedMasterSecret
+                ? (0, prf_js_1.prfExtendedMasterSecret)(preMasterSecret, handshakes)
+                : (0, prf_js_1.prfMasterSecret)(preMasterSecret, cipher.remoteRandom.serialize(), cipher.localRandom.serialize());
+        cipher.cipher = (0, create_js_1.createCipher)(cipher.cipherSuite);
+        cipher.cipher.init(cipher.masterSecret, cipher.localRandom.serialize(), cipher.remoteRandom.serialize());
+        log(dtls.sessionId, 'setup cipher', cipher.cipher.summary);
+    };
+handlers[const_js_1.HandshakeType.certificate_11] =
+    ({ cipher, dtls }) => (message) => {
+        log(dtls.sessionId, 'handshake certificate', message);
+        cipher.remoteCertificate = message.certificateList[0];
+    };
+handlers[const_js_1.HandshakeType.certificate_verify_15] =
+    ({ cipher, dtls }) => (message) => {
+        if (!cipher.remoteCertificate) {
+            throw new Error('client certificate missing before certificate verify');
+        }
+        log(dtls.sessionId, 'certificate_verify', message.algorithm);
+    };
+handlers[const_js_1.HandshakeType.finished_20] =
+    ({ dtls }) => (message) => {
+        log(dtls.sessionId, 'finished', message);
+    };

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

@@ -0,0 +1,16 @@
+import { binaryData } from '../imports/common.js';
+export declare const ExtensionList: binaryData.DataType<{
+    type: number;
+    data: Buffer<ArrayBufferLike>;
+}[]>;
+export declare const ASN11Cert: binaryData.DataType<Buffer<ArrayBufferLike>>;
+export declare const ClientCertificateType: binaryData.NumberType;
+export declare const DistinguishedName: binaryData.DataType<string>;
+export declare const SignatureHashAlgorithm: {
+    hash: binaryData.NumberType;
+    signature: binaryData.NumberType;
+};
+export declare const ProtocolVersion: {
+    major: binaryData.NumberType;
+    minor: binaryData.NumberType;
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolVersion = exports.SignatureHashAlgorithm = exports.DistinguishedName = exports.ClientCertificateType = exports.ASN11Cert = exports.ExtensionList = void 0;
+const common_js_1 = require("../imports/common.js");
+const { types } = common_js_1.binaryData;
+const { uint16be, uint24be, buffer, array, uint8, string } = types;
+// export const Random = {
+//   gmt_unix_time: uint32be,
+//   random_bytes: buffer(28),
+// };
+const Extension = {
+    type: uint16be,
+    data: buffer(uint16be)
+};
+exports.ExtensionList = array(Extension, uint16be, 'bytes');
+exports.ASN11Cert = buffer(uint24be);
+exports.ClientCertificateType = uint8;
+exports.DistinguishedName = string(uint16be);
+exports.SignatureHashAlgorithm = { hash: uint8, signature: uint8 };
+exports.ProtocolVersion = { major: uint8, minor: uint8 };

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

@@ -0,0 +1,13 @@
+export declare enum HandshakeType {
+    hello_request_0 = 0,
+    client_hello_1 = 1,
+    server_hello_2 = 2,
+    hello_verify_request_3 = 3,
+    certificate_11 = 11,
+    server_key_exchange_12 = 12,
+    certificate_request_13 = 13,
+    server_hello_done_14 = 14,
+    certificate_verify_15 = 15,
+    client_key_exchange_16 = 16,
+    finished_20 = 20
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandshakeType = void 0;
+var HandshakeType;
+(function (HandshakeType) {
+    HandshakeType[HandshakeType["hello_request_0"] = 0] = "hello_request_0";
+    HandshakeType[HandshakeType["client_hello_1"] = 1] = "client_hello_1";
+    HandshakeType[HandshakeType["server_hello_2"] = 2] = "server_hello_2";
+    HandshakeType[HandshakeType["hello_verify_request_3"] = 3] = "hello_verify_request_3";
+    HandshakeType[HandshakeType["certificate_11"] = 11] = "certificate_11";
+    HandshakeType[HandshakeType["server_key_exchange_12"] = 12] = "server_key_exchange_12";
+    HandshakeType[HandshakeType["certificate_request_13"] = 13] = "certificate_request_13";
+    HandshakeType[HandshakeType["server_hello_done_14"] = 14] = "server_hello_done_14";
+    HandshakeType[HandshakeType["certificate_verify_15"] = 15] = "certificate_verify_15";
+    HandshakeType[HandshakeType["client_key_exchange_16"] = 16] = "client_key_exchange_16";
+    HandshakeType[HandshakeType["finished_20"] = 20] = "finished_20";
+})(HandshakeType || (exports.HandshakeType = HandshakeType = {}));

package/dist/cjs/lib/dtls/handshake/extensions/ellipticCurves.d.ts

@@ -0,0 +1,17 @@
+import { binaryData } from '../../imports/common.js';
+import type { Extension } from '../../typings/domain.js';
+export declare class EllipticCurves {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<number[]>;
+    };
+    type: number;
+    data: number[];
+    constructor(props?: Partial<EllipticCurves>);
+    static createEmpty(): EllipticCurves;
+    static fromData(buf: Buffer): EllipticCurves;
+    static deSerialize(buf: Buffer): EllipticCurves;
+    serialize(): Buffer<ArrayBufferLike>;
+    get extension(): Extension;
+}

package/dist/cjs/lib/dtls/handshake/extensions/ellipticCurves.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EllipticCurves = void 0;
+const common_js_1 = require("../../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+// rfc4492
+class EllipticCurves {
+    static { this.type = 10; }
+    static { this.spec = {
+        type: types.uint16be,
+        data: types.array(types.uint16be, types.uint16be, 'bytes')
+    }; }
+    constructor(props = {}) {
+        this.type = EllipticCurves.type;
+        this.data = [];
+        Object.assign(this, props);
+    }
+    static createEmpty() {
+        return new EllipticCurves();
+    }
+    static fromData(buf) {
+        return new EllipticCurves({
+            type: EllipticCurves.type,
+            data: decode(buf, EllipticCurves.spec.data)
+        });
+    }
+    static deSerialize(buf) {
+        return new EllipticCurves(decode(buf, EllipticCurves.spec));
+    }
+    serialize() {
+        return encode(this, EllipticCurves.spec);
+    }
+    get extension() {
+        return {
+            type: this.type,
+            data: this.serialize().slice(2)
+        };
+    }
+}
+exports.EllipticCurves = EllipticCurves;

package/dist/cjs/lib/dtls/handshake/extensions/extendedMasterSecret.d.ts

@@ -0,0 +1,3 @@
+export declare class ExtendedMasterSecret {
+    static type: number;
+}

package/dist/cjs/lib/dtls/handshake/extensions/extendedMasterSecret.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedMasterSecret = void 0;
+class ExtendedMasterSecret {
+    static { this.type = 23; }
+}
+exports.ExtendedMasterSecret = ExtendedMasterSecret;

package/dist/cjs/lib/dtls/handshake/extensions/renegotiationIndication.d.ts

@@ -0,0 +1,18 @@
+import { binaryData } from '../../imports/common.js';
+export declare class RenegotiationIndication {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.NumberType;
+    };
+    type: number;
+    data: number;
+    constructor(props?: Partial<RenegotiationIndication>);
+    static createEmpty(): RenegotiationIndication;
+    static deSerialize(buf: Buffer): RenegotiationIndication;
+    serialize(): Buffer<ArrayBufferLike>;
+    get extension(): {
+        type: number;
+        data: Buffer<ArrayBuffer>;
+    };
+}

package/dist/cjs/lib/dtls/handshake/extensions/renegotiationIndication.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenegotiationIndication = void 0;
+const common_js_1 = require("../../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class RenegotiationIndication {
+    static { this.type = 65281; }
+    static { this.spec = {
+        type: types.uint16be,
+        data: types.uint8
+    }; }
+    constructor(props = {}) {
+        this.type = RenegotiationIndication.type;
+        this.data = 0;
+        Object.assign(this, props);
+    }
+    static createEmpty() {
+        const v = new RenegotiationIndication();
+        return v;
+    }
+    static deSerialize(buf) {
+        return new RenegotiationIndication(decode(buf, RenegotiationIndication.spec));
+    }
+    serialize() {
+        return encode(this, RenegotiationIndication.spec);
+    }
+    get extension() {
+        return {
+            type: this.type,
+            data: this.serialize().slice(2)
+        };
+    }
+}
+exports.RenegotiationIndication = RenegotiationIndication;

package/dist/cjs/lib/dtls/handshake/extensions/signature.d.ts

@@ -0,0 +1,26 @@
+import { binaryData } from '../../imports/common.js';
+import type { HashAlgorithms, SignatureAlgorithms } from '../../cipher/const.js';
+export declare class Signature {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<{
+            hash: number;
+            signature: number;
+        }[]>;
+    };
+    type: number;
+    data: {
+        hash: HashAlgorithms;
+        signature: SignatureAlgorithms;
+    }[];
+    constructor(props?: Partial<Signature>);
+    static createEmpty(): Signature;
+    static deSerialize(buf: Buffer): Signature;
+    serialize(): Buffer<ArrayBufferLike>;
+    static fromData(buf: Buffer): Signature;
+    get extension(): {
+        type: number;
+        data: Buffer<ArrayBuffer>;
+    };
+}

package/dist/cjs/lib/dtls/handshake/extensions/signature.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Signature = void 0;
+const common_js_1 = require("../../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class Signature {
+    static { this.type = 13; }
+    static { this.spec = {
+        type: types.uint16be,
+        data: types.array({ hash: types.uint8, signature: types.uint8 }, types.uint16be, 'bytes')
+    }; }
+    constructor(props = {}) {
+        this.type = Signature.type;
+        this.data = [];
+        Object.assign(this, props);
+    }
+    static createEmpty() {
+        const v = new Signature();
+        return v;
+    }
+    static deSerialize(buf) {
+        return new Signature(decode(buf, Signature.spec));
+    }
+    serialize() {
+        return encode(this, Signature.spec);
+    }
+    static fromData(buf) {
+        const type = Buffer.alloc(2);
+        type.writeUInt16BE(Signature.type);
+        return Signature.deSerialize(Buffer.concat([type, buf]));
+    }
+    get extension() {
+        return {
+            type: this.type,
+            data: this.serialize().slice(2)
+        };
+    }
+}
+exports.Signature = Signature;

package/dist/cjs/lib/dtls/handshake/extensions/useSrtp.d.ts

@@ -0,0 +1,19 @@
+import { binaryData } from '../../imports/common.js';
+import type { Extension } from '../../typings/domain.js';
+export declare class UseSRTP {
+    static type: number;
+    static readonly spec: {
+        type: binaryData.NumberType;
+        data: binaryData.DataType<Buffer<ArrayBufferLike>>;
+    };
+    type: number;
+    data: Buffer;
+    profiles: number[];
+    mki: Buffer;
+    constructor(props?: Partial<UseSRTP>);
+    static create(profiles: number[], mki: Buffer): UseSRTP;
+    static deSerialize(buf: Buffer): UseSRTP;
+    serialize(): Buffer<ArrayBufferLike>;
+    static fromData(buf: Buffer): UseSRTP;
+    get extension(): Extension;
+}

package/dist/cjs/lib/dtls/handshake/extensions/useSrtp.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseSRTP = void 0;
+const common_js_1 = require("../../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class UseSRTP {
+    static { this.type = 14; } // 9.  IANA Considerations
+    static { this.spec = {
+        type: types.uint16be,
+        data: types.buffer(types.uint16be)
+    }; }
+    constructor(props = {}) {
+        this.type = UseSRTP.type;
+        this.data = Buffer.from([]);
+        this.profiles = [];
+        this.mki = Buffer.from([0x00]);
+        Object.assign(this, props);
+    }
+    static create(profiles, mki) {
+        const v = new UseSRTP({
+            profiles,
+            mki
+        });
+        return v;
+    }
+    static deSerialize(buf) {
+        const useSrtp = new UseSRTP(decode(buf, UseSRTP.spec));
+        const profileLength = useSrtp.data.readUInt16BE();
+        const profiles = new Array(profileLength / 2);
+        for (let i = 0; i < profiles.length; i++) {
+            profiles[i] = useSrtp.data.readUInt16BE(i * 2 + 2);
+        }
+        useSrtp.profiles = profiles;
+        useSrtp.mki = useSrtp.data.slice(profileLength + 2);
+        return useSrtp;
+    }
+    serialize() {
+        const profileLength = Buffer.alloc(2);
+        profileLength.writeUInt16BE(this.profiles.length * 2);
+        const data = Buffer.concat([
+            profileLength,
+            ...this.profiles.map((profile) => {
+                const buf = Buffer.alloc(2);
+                buf.writeUInt16BE(profile);
+                return buf;
+            }),
+            this.mki
+        ]);
+        this.data = data;
+        return encode(this, UseSRTP.spec);
+    }
+    static fromData(buf) {
+        const head = Buffer.alloc(4);
+        head.writeUInt16BE(UseSRTP.type);
+        head.writeUInt16BE(buf.length, 2);
+        return UseSRTP.deSerialize(Buffer.concat([head, buf]));
+    }
+    get extension() {
+        return {
+            type: this.type,
+            data: this.serialize().slice(4)
+        };
+    }
+}
+exports.UseSRTP = UseSRTP;

package/dist/cjs/lib/dtls/handshake/message/alert.d.ts

@@ -0,0 +1,12 @@
+import { binaryData } from '../../imports/common.js';
+export declare class Alert {
+    level: number;
+    description: number;
+    static readonly spec: {
+        level: binaryData.NumberType;
+        description: binaryData.NumberType;
+    };
+    constructor(level: number, description: number);
+    static deSerialize(buf: Buffer): Alert;
+    serialize(): Buffer<ArrayBufferLike>;
+}

package/dist/cjs/lib/dtls/handshake/message/alert.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alert = void 0;
+const common_js_1 = require("../../imports/common.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class Alert {
+    static { this.spec = {
+        level: types.uint8,
+        description: types.uint8
+    }; }
+    constructor(level, description) {
+        this.level = level;
+        this.description = description;
+    }
+    static deSerialize(buf) {
+        return new Alert(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, Alert.spec)));
+    }
+    serialize() {
+        return encode(this, Alert.spec);
+    }
+}
+exports.Alert = Alert;

package/dist/cjs/lib/dtls/handshake/message/certificate.d.ts

@@ -0,0 +1,17 @@
+import { binaryData } from '../../imports/common.js';
+import { FragmentedHandshake } from '../../record/message/fragment.js';
+import type { Handshake } from '../../typings/domain.js';
+import { HandshakeType } from '../const.js';
+export declare class Certificate implements Handshake {
+    certificateList: Buffer[];
+    msgType: HandshakeType;
+    messageSeq?: number;
+    static readonly spec: {
+        certificateList: binaryData.DataType<Buffer<ArrayBufferLike>[]>;
+    };
+    constructor(certificateList: Buffer[]);
+    static createEmpty(): Certificate;
+    static deSerialize(buf: Buffer): Certificate;
+    serialize(): Buffer<ArrayBufferLike>;
+    toFragment(): FragmentedHandshake;
+}

package/dist/cjs/lib/dtls/handshake/message/certificate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Certificate = void 0;
+const common_js_1 = require("../../imports/common.js");
+const fragment_js_1 = require("../../record/message/fragment.js");
+const binary_js_1 = require("../binary.js");
+const const_js_1 = require("../const.js");
+const { decode, encode, types } = common_js_1.binaryData;
+// 7.4.2.  Server Certificate
+// 7.4.6.  Client Certificate
+class Certificate {
+    static { this.spec = {
+        certificateList: types.array(binary_js_1.ASN11Cert, types.uint24be, 'bytes')
+    }; }
+    constructor(certificateList) {
+        this.certificateList = certificateList;
+        this.msgType = const_js_1.HandshakeType.certificate_11;
+    }
+    static createEmpty() {
+        return new Certificate(undefined);
+    }
+    static deSerialize(buf) {
+        return new Certificate(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, Certificate.spec)));
+    }
+    serialize() {
+        return encode(this, Certificate.spec);
+    }
+    toFragment() {
+        const body = this.serialize();
+        return new fragment_js_1.FragmentedHandshake(this.msgType, body.length, this.messageSeq, 0, body.length, body);
+    }
+}
+exports.Certificate = Certificate;