@lakutata/webrtc 0.0.0-stage → 3.1.4

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

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

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

@@ -0,0 +1,5 @@
+import type { SrtpProfile } from '../imports/rtp.js';
+export declare class SrtpContext {
+    srtpProfile?: SrtpProfile;
+    static findMatchingSRTPProfile(remote: SrtpProfile[], local: SrtpProfile[]): 1 | 7 | undefined;
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtpContext = void 0;
+class SrtpContext {
+    static findMatchingSRTPProfile(remote, local) {
+        for (const v of local) {
+            if (remote.includes(v))
+                return v;
+        }
+    }
+}
+exports.SrtpContext = SrtpContext;

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

@@ -0,0 +1,8 @@
+import type { Address, Transport } from '../imports/common.js';
+export declare class TransportContext {
+    socket: Transport;
+    readonly closing: AbortController;
+    constructor(socket: Transport);
+    readonly send: (buf: Buffer, addr?: Address) => Promise<void>;
+    close(): void;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportContext = void 0;
+class TransportContext {
+    constructor(socket) {
+        this.socket = socket;
+        //Aborted when the DTLS socket closes: the flights being sent again stop
+        this.closing = new AbortController();
+        this.send = (buf, addr) => {
+            return this.socket.send(buf, addr);
+        };
+    }
+    close() {
+        this.closing.abort();
+    }
+}
+exports.TransportContext = TransportContext;

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

@@ -0,0 +1,10 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { Extension } from '../../typings/domain.js';
+import { Flight } from '../flight.js';
+export declare class Flight1 extends Flight {
+    private cipher;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext);
+    exec(extensions: Extension[]): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight1 = void 0;
+const const_js_1 = require("../../cipher/const.js");
+const hello_js_1 = require("../../handshake/message/client/hello.js");
+const random_js_1 = require("../../handshake/random.js");
+const flight_js_1 = require("../flight.js");
+class Flight1 extends flight_js_1.Flight {
+    constructor(udp, dtls, cipher) {
+        super(udp, dtls, 1, 3);
+        this.cipher = cipher;
+    }
+    async exec(extensions) {
+        if (this.dtls.flight === 1)
+            throw new Error();
+        this.dtls.flight = 1;
+        const hello = new hello_js_1.ClientHello({ major: 255 - 1, minor: 255 - 2 }, new random_js_1.DtlsRandom(), Buffer.from([]), Buffer.from([]), const_js_1.CipherSuiteList, [0], // don't compress
+        extensions);
+        this.dtls.version = hello.clientVersion;
+        this.cipher.localRandom = random_js_1.DtlsRandom.from(hello.random);
+        const packets = this.createPacket([hello]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        await this.transmit([buf]);
+    }
+}
+exports.Flight1 = Flight1;

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

@@ -0,0 +1,8 @@
+import type { DtlsContext } from '../../context/dtls.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { ServerHelloVerifyRequest } from '../../handshake/message/server/helloVerifyRequest.js';
+import { Flight } from '../flight.js';
+export declare class Flight3 extends Flight {
+    constructor(udp: TransportContext, dtls: DtlsContext);
+    exec(verifyReq: ServerHelloVerifyRequest): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight3 = void 0;
+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/client/flight3:log');
+class Flight3 extends flight_js_1.Flight {
+    constructor(udp, dtls) {
+        super(udp, dtls, 3, 5);
+    }
+    async exec(verifyReq) {
+        if (this.dtls.flight === 3)
+            throw new Error();
+        this.dtls.flight = 3;
+        this.dtls.handshakeCache = [];
+        const [clientHello] = this.dtls.lastFlight;
+        log('dtls version', clientHello.clientVersion);
+        clientHello.cookie = verifyReq.cookie;
+        this.dtls.cookie = verifyReq.cookie;
+        const packets = this.createPacket([clientHello]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        await this.transmit([buf]);
+    }
+}
+exports.Flight3 = Flight3;

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

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

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight5 = void 0;
+const const_js_1 = require("../../cipher/const.js");
+const create_js_1 = require("../../cipher/create.js");
+const namedCurve_js_1 = require("../../cipher/namedCurve.js");
+const prf_js_1 = require("../../cipher/prf.js");
+const srtp_js_1 = require("../../context/srtp.js");
+const const_js_2 = require("../../handshake/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 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 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_2 = require("../../handshake/message/server/keyExchange.js");
+const random_js_1 = require("../../handshake/random.js");
+const rtp_js_1 = require("../../imports/rtp.js");
+const builder_js_1 = require("../../record/builder.js");
+const const_js_3 = require("../../record/const.js");
+const flight_js_1 = require("../flight.js");
+const log = (0, rtp_js_1.debug)('webrtc/dtls/flight/client/flight5:log');
+class Flight5 extends flight_js_1.Flight {
+    constructor(udp, dtls, cipher, srtp) {
+        super(udp, dtls, 5, 7);
+        this.cipher = cipher;
+        this.srtp = srtp;
+    }
+    handleHandshake(handshake) {
+        this.dtls.bufferHandshakeCache([handshake], false, 4);
+        const message = (() => {
+            switch (handshake.msg_type) {
+                case const_js_2.HandshakeType.server_hello_2:
+                    return hello_js_1.ServerHello.deSerialize(handshake.fragment);
+                case const_js_2.HandshakeType.certificate_11:
+                    return certificate_js_1.Certificate.deSerialize(handshake.fragment);
+                case const_js_2.HandshakeType.server_key_exchange_12:
+                    return keyExchange_js_2.ServerKeyExchange.deSerialize(handshake.fragment);
+                case const_js_2.HandshakeType.certificate_request_13:
+                    return certificateRequest_js_1.ServerCertificateRequest.deSerialize(handshake.fragment);
+                case const_js_2.HandshakeType.server_hello_done_14:
+                    return helloDone_js_1.ServerHelloDone.deSerialize(handshake.fragment);
+            }
+        })();
+        if (message) {
+            handlers[message.msgType]({
+                dtls: this.dtls,
+                cipher: this.cipher,
+                srtp: this.srtp
+            })(message);
+        }
+    }
+    async exec() {
+        if (this.dtls.flight === 5) {
+            log(this.dtls.sessionId, 'flight5 twice');
+            this.send(this.dtls.lastMessage).catch((error) => log('send failed', error));
+            return;
+        }
+        this.dtls.flight = 5;
+        const needCertificate = this.dtls.requestedCertificateTypes.length > 0;
+        log(this.dtls.sessionId, 'send flight5', needCertificate);
+        const messages = [
+            needCertificate && this.sendCertificate(),
+            this.sendClientKeyExchange(),
+            needCertificate && this.sendCertificateVerify(),
+            this.sendChangeCipherSpec(),
+            this.sendFinished()
+        ].filter((v) => v);
+        this.dtls.lastMessage = messages;
+        await this.transmit(messages);
+    }
+    sendCertificate() {
+        const certificate = new certificate_js_1.Certificate([Buffer.from(this.cipher.localCert)]);
+        const packets = this.createPacket([certificate]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        return buf;
+    }
+    sendClientKeyExchange() {
+        if (!this.cipher.localKeyPair)
+            throw new Error();
+        const clientKeyExchange = new keyExchange_js_1.ClientKeyExchange(this.cipher.localKeyPair.publicKey);
+        const packets = this.createPacket([clientKeyExchange]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        const localKeyPair = this.cipher.localKeyPair;
+        const remoteKeyPair = this.cipher.remoteKeyPair;
+        if (!remoteKeyPair.publicKey)
+            throw new Error('not exist');
+        const preMasterSecret = (0, prf_js_1.prfPreMasterSecret)(remoteKeyPair.publicKey, localKeyPair.privateKey, localKeyPair.curve);
+        log(this.dtls.sessionId, 'extendedMasterSecret', this.dtls.options.extendedMasterSecret, this.dtls.remoteExtendedMasterSecret);
+        const handshakes = Buffer.concat(this.dtls.sortedHandshakeCache.map((v) => v.serialize()));
+        this.cipher.masterSecret =
+            this.dtls.options.extendedMasterSecret &&
+                this.dtls.remoteExtendedMasterSecret
+                ? (0, prf_js_1.prfExtendedMasterSecret)(preMasterSecret, handshakes)
+                : (0, prf_js_1.prfMasterSecret)(preMasterSecret, this.cipher.localRandom.serialize(), this.cipher.remoteRandom.serialize());
+        this.cipher.cipher = (0, create_js_1.createCipher)(this.cipher.cipherSuite);
+        this.cipher.cipher.init(this.cipher.masterSecret, this.cipher.remoteRandom.serialize(), this.cipher.localRandom.serialize());
+        log(this.dtls.sessionId, 'cipher', this.cipher.cipher.summary);
+        return buf;
+    }
+    sendCertificateVerify() {
+        const cache = Buffer.concat(this.dtls.sortedHandshakeCache.map((v) => v.serialize()));
+        const signed = this.cipher.signatureData(cache, 'sha256');
+        const signatureScheme = (() => {
+            switch (this.cipher.signatureHashAlgorithm?.signature) {
+                case const_js_1.SignatureAlgorithm.ecdsa_3:
+                    return const_js_1.SignatureScheme.ecdsa_secp256r1_sha256;
+                case const_js_1.SignatureAlgorithm.rsa_1:
+                    return const_js_1.SignatureScheme.rsa_pkcs1_sha256;
+            }
+        })();
+        if (!signatureScheme)
+            throw new Error();
+        log(this.dtls.sessionId, 'signatureScheme', this.cipher.signatureHashAlgorithm?.signature, signatureScheme);
+        const certificateVerify = new certificateVerify_js_1.CertificateVerify(signatureScheme, signed);
+        const packets = this.createPacket([certificateVerify]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        return buf;
+    }
+    sendChangeCipherSpec() {
+        const changeCipherSpec = changeCipherSpec_js_1.ChangeCipherSpec.createEmpty().serialize();
+        const packets = (0, builder_js_1.createPlaintext)(this.dtls)([{ type: const_js_3.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]);
+        // log(
+        //   this.dtls.sessionId,
+        //   "raw finish packet",
+        //   packet.summary,
+        //   this.dtls.sortedHandshakeCache.map((h) => h.summary),
+        // );
+        this.dtls.recordSequenceNumber = 0;
+        const buf = this.cipher.encryptPacket(packet).serialize();
+        log(this.dtls.sessionId, 'finished', this.cipher.cipher.summary);
+        return buf;
+    }
+}
+exports.Flight5 = Flight5;
+const handlers = {};
+handlers[const_js_2.HandshakeType.server_hello_2] =
+    ({ cipher, srtp, dtls }) => (message) => {
+        log(dtls.sessionId, 'serverHello', message.cipherSuite);
+        cipher.remoteRandom = random_js_1.DtlsRandom.from(message.random);
+        cipher.cipherSuite = message.cipherSuite;
+        log(dtls.sessionId, 'selected cipherSuite', cipher.cipherSuite);
+        if (message.extensions) {
+            message.extensions.forEach((extension) => {
+                switch (extension.type) {
+                    case useSrtp_js_1.UseSRTP.type:
+                        {
+                            const useSrtp = useSrtp_js_1.UseSRTP.fromData(extension.data);
+                            const profile = srtp_js_1.SrtpContext.findMatchingSRTPProfile(useSrtp.profiles, dtls.options.srtpProfiles || []);
+                            log(dtls.sessionId, 'selected srtp profile', profile);
+                            if (profile == undefined)
+                                return;
+                            srtp.srtpProfile = profile;
+                        }
+                        break;
+                    case extendedMasterSecret_js_1.ExtendedMasterSecret.type:
+                        dtls.remoteExtendedMasterSecret = true;
+                        break;
+                    case renegotiationIndication_js_1.RenegotiationIndication.type:
+                        log(dtls.sessionId, 'RenegotiationIndication');
+                        break;
+                }
+            });
+        }
+    };
+handlers[const_js_2.HandshakeType.certificate_11] =
+    ({ cipher, dtls }) => (message) => {
+        log(dtls.sessionId, 'handshake certificate', message);
+        cipher.remoteCertificate = message.certificateList[0];
+    };
+handlers[const_js_2.HandshakeType.server_key_exchange_12] =
+    ({ cipher, dtls }) => (message) => {
+        if (!cipher.localRandom || !cipher.remoteRandom)
+            throw new Error();
+        log(dtls.sessionId, 'ServerKeyExchange', message);
+        log(dtls.sessionId, 'selected curve', message.namedCurve);
+        cipher.remoteKeyPair = {
+            curve: message.namedCurve,
+            publicKey: message.publicKey
+        };
+        cipher.localKeyPair = (0, namedCurve_js_1.generateKeyPair)(message.namedCurve);
+    };
+handlers[const_js_2.HandshakeType.certificate_request_13] =
+    ({ dtls }) => (message) => {
+        log(dtls.sessionId, 'certificate_request', message);
+        dtls.requestedCertificateTypes = message.certificateTypes;
+        dtls.requestedSignatureAlgorithms = message.signatures;
+    };
+handlers[const_js_2.HandshakeType.server_hello_done_14] =
+    ({ dtls }) => (msg) => {
+        log(dtls.sessionId, 'server_hello_done', msg);
+    };

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

@@ -0,0 +1,18 @@
+import type { DtlsContext } from '../context/dtls.js';
+import type { TransportContext } from '../context/transport.js';
+import type { Handshake } from '../typings/domain.js';
+type FlightType = 'PREPARING' | 'SENDING' | 'WAITING' | 'FINISHED';
+export declare abstract class Flight {
+    private transport;
+    dtls: DtlsContext;
+    private flight;
+    private nextFlight?;
+    state: FlightType;
+    static RetransmitCount: number;
+    constructor(transport: TransportContext, dtls: DtlsContext, flight: number, nextFlight?: number | undefined);
+    protected createPacket(handshakes: Handshake[]): import("../record/message/plaintext.js").DtlsPlaintext[];
+    protected transmit(buffers: Buffer[]): Promise<void>;
+    protected send: (buf: Buffer[]) => Promise<void[]>;
+    private setState;
+}
+export {};

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flight = void 0;
+const promises_1 = require("node:timers/promises");
+const common_js_1 = require("../imports/common.js");
+const builder_js_1 = require("../record/builder.js");
+const const_js_1 = require("../record/const.js");
+const warn = (0, common_js_1.debug)('webrtc/dtls/flight/flight:warn');
+const err = (0, common_js_1.debug)('webrtc/dtls/flight/flight:err');
+class Flight {
+    static { this.RetransmitCount = 10; }
+    constructor(transport, dtls, flight, nextFlight) {
+        this.transport = transport;
+        this.dtls = dtls;
+        this.flight = flight;
+        this.nextFlight = nextFlight;
+        this.state = 'PREPARING';
+        this.send = (buf) => Promise.all(buf.map((v) => this.transport.send(v)));
+    }
+    createPacket(handshakes) {
+        const fragments = (0, builder_js_1.createFragments)(this.dtls)(handshakes);
+        this.dtls.bufferHandshakeCache(fragments, true, this.flight);
+        const packets = (0, builder_js_1.createPlaintext)(this.dtls)(fragments.map((fragment) => ({
+            type: const_js_1.ContentType.handshake,
+            fragment: fragment.serialize()
+        })), ++this.dtls.recordSequenceNumber);
+        return packets;
+    }
+    async transmit(buffers) {
+        //The socket closed during the handshake: the flight is not sent again
+        const closing = this.transport.closing.signal;
+        let retransmitCount = 0;
+        for (; retransmitCount <= Flight.RetransmitCount; retransmitCount++) {
+            if (closing.aborted)
+                return;
+            this.setState('SENDING');
+            this.send(buffers).catch((error) => {
+                err('fail to send', error);
+            });
+            this.setState('WAITING');
+            if (this.nextFlight === undefined) {
+                this.setState('FINISHED');
+                break;
+            }
+            try {
+                await (0, promises_1.setTimeout)(1000 * ((retransmitCount + 1) / 2), undefined, { signal: closing });
+            }
+            catch {
+                return;
+            }
+            if (this.dtls.flight >= this.nextFlight) {
+                this.setState('FINISHED');
+                break;
+            }
+            else {
+                warn(this.dtls.sessionId, 'retransmit', retransmitCount, this.dtls.flight);
+            }
+        }
+        if (retransmitCount > Flight.RetransmitCount) {
+            err(this.dtls.sessionId, 'retransmit failed', retransmitCount);
+            throw new Error(`over retransmitCount : ${this.flight} ${this.nextFlight}`);
+        }
+    }
+    setState(state) {
+        this.state = state;
+    }
+}
+exports.Flight = Flight;

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

@@ -0,0 +1,6 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import { SrtpContext } from '../../context/srtp.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { ClientHello } from '../../handshake/message/client/hello.js';
+export declare const flight2: (udp: TransportContext, dtls: DtlsContext, cipher: CipherContext, srtp: SrtpContext) => (clientHello: ClientHello) => void;

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flight2 = void 0;
+const node_crypto_1 = require("node:crypto");
+const const_js_1 = require("../../cipher/const.js");
+const namedCurve_js_1 = require("../../cipher/namedCurve.js");
+const srtp_js_1 = require("../../context/srtp.js");
+const ellipticCurves_js_1 = require("../../handshake/extensions/ellipticCurves.js");
+const extendedMasterSecret_js_1 = require("../../handshake/extensions/extendedMasterSecret.js");
+const renegotiationIndication_js_1 = require("../../handshake/extensions/renegotiationIndication.js");
+const signature_js_1 = require("../../handshake/extensions/signature.js");
+const useSrtp_js_1 = require("../../handshake/extensions/useSrtp.js");
+const helloVerifyRequest_js_1 = require("../../handshake/message/server/helloVerifyRequest.js");
+const random_js_1 = require("../../handshake/random.js");
+const rtp_js_1 = require("../../imports/rtp.js");
+const builder_js_1 = require("../../record/builder.js");
+const const_js_2 = require("../../record/const.js");
+const log = (0, rtp_js_1.debug)('webrtc/dtls/flight/server/flight2:log');
+// HelloVerifyRequest do not retransmit
+const flight2 = (udp, dtls, cipher, srtp) => (clientHello) => {
+    log('dtls version', clientHello.clientVersion);
+    dtls.flight = 2;
+    // if flight 2 restarts due to packet loss, sequence numbers are reused from the top:
+    // https://datatracker.ietf.org/doc/html/rfc6347#section-4.2.2
+    // The first message each side transmits in each handshake always has
+    // message_seq = 0.  Whenever each new message is generated, the
+    // message_seq value is incremented by one.  Note that in the case of a
+    // rehandshake, this implies that the HelloRequest will have message_seq = 0
+    // and the ServerHello will have message_seq = 1.  When a message is
+    // retransmitted, the same message_seq value is used.
+    dtls.recordSequenceNumber = 0;
+    dtls.sequenceNumber = 0;
+    clientHello.extensions.forEach((extension) => {
+        switch (extension.type) {
+            case ellipticCurves_js_1.EllipticCurves.type:
+                {
+                    const curves = ellipticCurves_js_1.EllipticCurves.fromData(extension.data).data;
+                    log(dtls.sessionId, 'curves', curves);
+                    const curve = curves.filter((curve) => const_js_1.NamedCurveAlgorithmList.includes(curve))[0];
+                    cipher.namedCurve = curve;
+                    log(dtls.sessionId, 'curve selected', cipher.namedCurve);
+                }
+                break;
+            case signature_js_1.Signature.type:
+                {
+                    if (!cipher.signatureHashAlgorithm)
+                        throw new Error('need to set certificate');
+                    const signatureHash = signature_js_1.Signature.fromData(extension.data).data;
+                    log(dtls.sessionId, 'hash,signature', signatureHash);
+                    const signature = signatureHash.find((v) => v.signature === cipher.signatureHashAlgorithm?.signature)?.signature;
+                    const hash = signatureHash.find((v) => v.hash === cipher.signatureHashAlgorithm?.hash)?.hash;
+                    if (signature == undefined || hash == undefined) {
+                        throw new Error('invalid signatureHash');
+                    }
+                }
+                break;
+            case useSrtp_js_1.UseSRTP.type:
+                {
+                    if (!dtls.options?.srtpProfiles)
+                        return;
+                    if (dtls.options.srtpProfiles.length === 0)
+                        return;
+                    const useSrtp = useSrtp_js_1.UseSRTP.fromData(extension.data);
+                    log(dtls.sessionId, 'srtp profiles', useSrtp.profiles);
+                    const profile = srtp_js_1.SrtpContext.findMatchingSRTPProfile(useSrtp.profiles, dtls.options?.srtpProfiles);
+                    if (!profile) {
+                        throw new Error();
+                    }
+                    srtp.srtpProfile = profile;
+                    log(dtls.sessionId, 'srtp profile selected', srtp.srtpProfile);
+                }
+                break;
+            case extendedMasterSecret_js_1.ExtendedMasterSecret.type:
+                {
+                    dtls.remoteExtendedMasterSecret = true;
+                }
+                break;
+            case renegotiationIndication_js_1.RenegotiationIndication.type:
+                {
+                    log(dtls.sessionId, 'RenegotiationIndication', extension.data);
+                }
+                break;
+            case 43:
+                {
+                    // todo dtls1.3
+                    const data = extension.data.subarray(1);
+                    const versions = [...data].map((v) => v.toString(10));
+                    log('dtls supported version', versions);
+                }
+                break;
+        }
+    });
+    cipher.localRandom = new random_js_1.DtlsRandom();
+    cipher.remoteRandom = random_js_1.DtlsRandom.from(clientHello.random);
+    const suites = clientHello.cipherSuites;
+    log(dtls.sessionId, 'cipher suites', suites);
+    const suite = (() => {
+        switch (cipher.signatureHashAlgorithm?.signature) {
+            case const_js_1.SignatureAlgorithm.ecdsa_3:
+                return const_js_1.CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_49195;
+            case const_js_1.SignatureAlgorithm.rsa_1:
+                return const_js_1.CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256_49199;
+        }
+    })();
+    if (suite === undefined || !suites.includes(suite)) {
+        throw new Error('dtls cipher suite negotiation failed');
+    }
+    cipher.cipherSuite = suite;
+    log(dtls.sessionId, 'selected cipherSuite', cipher.cipherSuite);
+    cipher.localKeyPair = (0, namedCurve_js_1.generateKeyPair)(cipher.namedCurve);
+    dtls.cookie ||= (0, node_crypto_1.randomBytes)(20);
+    const helloVerifyReq = new helloVerifyRequest_js_1.ServerHelloVerifyRequest({
+        major: 255 - 1,
+        minor: 255 - 2
+    }, dtls.cookie);
+    const fragments = (0, builder_js_1.createFragments)(dtls)([helloVerifyReq]);
+    const packets = (0, builder_js_1.createPlaintext)(dtls)(fragments.map((fragment) => ({
+        type: const_js_2.ContentType.handshake,
+        fragment: fragment.serialize()
+    })), ++dtls.recordSequenceNumber);
+    const chunk = packets.map((v) => v.serialize());
+    for (const buf of chunk) {
+        udp.send(buf).catch((error) => log('send failed', error));
+    }
+};
+exports.flight2 = flight2;

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

@@ -0,0 +1,17 @@
+import type { CipherContext } from '../../context/cipher.js';
+import type { DtlsContext } from '../../context/dtls.js';
+import type { SrtpContext } from '../../context/srtp.js';
+import type { TransportContext } from '../../context/transport.js';
+import type { FragmentedHandshake } from '../../record/message/fragment.js';
+import { Flight } from '../flight.js';
+export declare class Flight4 extends Flight {
+    private cipher;
+    private srtp;
+    constructor(udp: TransportContext, dtls: DtlsContext, cipher: CipherContext, srtp: SrtpContext);
+    exec(clientHello: FragmentedHandshake, certificateRequest?: boolean): Promise<void>;
+    private sendServerHello;
+    private sendCertificate;
+    private sendServerKeyExchange;
+    private sendCertificateRequest;
+    private sendServerHelloDone;
+}