@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,202 @@
+import { SignatureAlgorithm, SignatureScheme } from '../../cipher/const.js';
+import { createCipher } from '../../cipher/create.js';
+import { generateKeyPair } from '../../cipher/namedCurve.js';
+import { prfExtendedMasterSecret, prfMasterSecret, prfPreMasterSecret } from '../../cipher/prf.js';
+import { SrtpContext } from '../../context/srtp.js';
+import { HandshakeType } from '../../handshake/const.js';
+import { ExtendedMasterSecret } from '../../handshake/extensions/extendedMasterSecret.js';
+import { RenegotiationIndication } from '../../handshake/extensions/renegotiationIndication.js';
+import { UseSRTP } from '../../handshake/extensions/useSrtp.js';
+import { Certificate } from '../../handshake/message/certificate.js';
+import { ChangeCipherSpec } from '../../handshake/message/changeCipherSpec.js';
+import { CertificateVerify } from '../../handshake/message/client/certificateVerify.js';
+import { ClientKeyExchange } from '../../handshake/message/client/keyExchange.js';
+import { Finished } from '../../handshake/message/finished.js';
+import { ServerCertificateRequest } from '../../handshake/message/server/certificateRequest.js';
+import { ServerHello } from '../../handshake/message/server/hello.js';
+import { ServerHelloDone } from '../../handshake/message/server/helloDone.js';
+import { ServerKeyExchange } from '../../handshake/message/server/keyExchange.js';
+import { DtlsRandom } from '../../handshake/random.js';
+import { debug } from '../../imports/rtp.js';
+import { createPlaintext } from '../../record/builder.js';
+import { ContentType } from '../../record/const.js';
+import { Flight } from '../flight.js';
+const log = debug('webrtc/dtls/flight/client/flight5:log');
+export class Flight5 extends 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 HandshakeType.server_hello_2:
+                    return ServerHello.deSerialize(handshake.fragment);
+                case HandshakeType.certificate_11:
+                    return Certificate.deSerialize(handshake.fragment);
+                case HandshakeType.server_key_exchange_12:
+                    return ServerKeyExchange.deSerialize(handshake.fragment);
+                case HandshakeType.certificate_request_13:
+                    return ServerCertificateRequest.deSerialize(handshake.fragment);
+                case HandshakeType.server_hello_done_14:
+                    return 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([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 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 = 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
+                ? prfExtendedMasterSecret(preMasterSecret, handshakes)
+                : prfMasterSecret(preMasterSecret, this.cipher.localRandom.serialize(), this.cipher.remoteRandom.serialize());
+        this.cipher.cipher = 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 SignatureAlgorithm.ecdsa_3:
+                    return SignatureScheme.ecdsa_secp256r1_sha256;
+                case SignatureAlgorithm.rsa_1:
+                    return SignatureScheme.rsa_pkcs1_sha256;
+            }
+        })();
+        if (!signatureScheme)
+            throw new Error();
+        log(this.dtls.sessionId, 'signatureScheme', this.cipher.signatureHashAlgorithm?.signature, signatureScheme);
+        const certificateVerify = new CertificateVerify(signatureScheme, signed);
+        const packets = this.createPacket([certificateVerify]);
+        const buf = Buffer.concat(packets.map((v) => v.serialize()));
+        return buf;
+    }
+    sendChangeCipherSpec() {
+        const changeCipherSpec = ChangeCipherSpec.createEmpty().serialize();
+        const packets = createPlaintext(this.dtls)([{ type: 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(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;
+    }
+}
+const handlers = {};
+handlers[HandshakeType.server_hello_2] =
+    ({ cipher, srtp, dtls }) => (message) => {
+        log(dtls.sessionId, 'serverHello', message.cipherSuite);
+        cipher.remoteRandom = 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.type:
+                        {
+                            const useSrtp = UseSRTP.fromData(extension.data);
+                            const profile = SrtpContext.findMatchingSRTPProfile(useSrtp.profiles, dtls.options.srtpProfiles || []);
+                            log(dtls.sessionId, 'selected srtp profile', profile);
+                            if (profile == undefined)
+                                return;
+                            srtp.srtpProfile = profile;
+                        }
+                        break;
+                    case ExtendedMasterSecret.type:
+                        dtls.remoteExtendedMasterSecret = true;
+                        break;
+                    case RenegotiationIndication.type:
+                        log(dtls.sessionId, 'RenegotiationIndication');
+                        break;
+                }
+            });
+        }
+    };
+handlers[HandshakeType.certificate_11] =
+    ({ cipher, dtls }) => (message) => {
+        log(dtls.sessionId, 'handshake certificate', message);
+        cipher.remoteCertificate = message.certificateList[0];
+    };
+handlers[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 = generateKeyPair(message.namedCurve);
+    };
+handlers[HandshakeType.certificate_request_13] =
+    ({ dtls }) => (message) => {
+        log(dtls.sessionId, 'certificate_request', message);
+        dtls.requestedCertificateTypes = message.certificateTypes;
+        dtls.requestedSignatureAlgorithms = message.signatures;
+    };
+handlers[HandshakeType.server_hello_done_14] =
+    ({ dtls }) => (msg) => {
+        log(dtls.sessionId, 'server_hello_done', msg);
+    };

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

@@ -0,0 +1,64 @@
+import { setTimeout } from 'node:timers/promises';
+import { debug } from '../imports/common.js';
+import { createFragments, createPlaintext } from '../record/builder.js';
+import { ContentType } from '../record/const.js';
+const warn = debug('webrtc/dtls/flight/flight:warn');
+const err = debug('webrtc/dtls/flight/flight:err');
+export 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 = createFragments(this.dtls)(handshakes);
+        this.dtls.bufferHandshakeCache(fragments, true, this.flight);
+        const packets = createPlaintext(this.dtls)(fragments.map((fragment) => ({
+            type: 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 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;
+    }
+}

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

@@ -0,0 +1,122 @@
+import { randomBytes } from 'node:crypto';
+import { CipherSuite, NamedCurveAlgorithmList, SignatureAlgorithm } from '../../cipher/const.js';
+import { generateKeyPair } from '../../cipher/namedCurve.js';
+import { SrtpContext } from '../../context/srtp.js';
+import { EllipticCurves } from '../../handshake/extensions/ellipticCurves.js';
+import { ExtendedMasterSecret } from '../../handshake/extensions/extendedMasterSecret.js';
+import { RenegotiationIndication } from '../../handshake/extensions/renegotiationIndication.js';
+import { Signature } from '../../handshake/extensions/signature.js';
+import { UseSRTP } from '../../handshake/extensions/useSrtp.js';
+import { ServerHelloVerifyRequest } from '../../handshake/message/server/helloVerifyRequest.js';
+import { DtlsRandom } from '../../handshake/random.js';
+import { debug } from '../../imports/rtp.js';
+import { createFragments, createPlaintext } from '../../record/builder.js';
+import { ContentType } from '../../record/const.js';
+const log = debug('webrtc/dtls/flight/server/flight2:log');
+// HelloVerifyRequest do not retransmit
+export 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.type:
+                {
+                    const curves = EllipticCurves.fromData(extension.data).data;
+                    log(dtls.sessionId, 'curves', curves);
+                    const curve = curves.filter((curve) => NamedCurveAlgorithmList.includes(curve))[0];
+                    cipher.namedCurve = curve;
+                    log(dtls.sessionId, 'curve selected', cipher.namedCurve);
+                }
+                break;
+            case Signature.type:
+                {
+                    if (!cipher.signatureHashAlgorithm)
+                        throw new Error('need to set certificate');
+                    const signatureHash = 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.type:
+                {
+                    if (!dtls.options?.srtpProfiles)
+                        return;
+                    if (dtls.options.srtpProfiles.length === 0)
+                        return;
+                    const useSrtp = UseSRTP.fromData(extension.data);
+                    log(dtls.sessionId, 'srtp profiles', useSrtp.profiles);
+                    const profile = 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.type:
+                {
+                    dtls.remoteExtendedMasterSecret = true;
+                }
+                break;
+            case 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 DtlsRandom();
+    cipher.remoteRandom = DtlsRandom.from(clientHello.random);
+    const suites = clientHello.cipherSuites;
+    log(dtls.sessionId, 'cipher suites', suites);
+    const suite = (() => {
+        switch (cipher.signatureHashAlgorithm?.signature) {
+            case SignatureAlgorithm.ecdsa_3:
+                return CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_49195;
+            case SignatureAlgorithm.rsa_1:
+                return 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 = generateKeyPair(cipher.namedCurve);
+    dtls.cookie ||= randomBytes(20);
+    const helloVerifyReq = new ServerHelloVerifyRequest({
+        major: 255 - 1,
+        minor: 255 - 2
+    }, dtls.cookie);
+    const fragments = createFragments(dtls)([helloVerifyReq]);
+    const packets = createPlaintext(dtls)(fragments.map((fragment) => ({
+        type: 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));
+    }
+};

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

@@ -0,0 +1,83 @@
+import { CurveType, certificateTypes, signatures } from '../../cipher/const.js';
+import { ExtendedMasterSecret } from '../../handshake/extensions/extendedMasterSecret.js';
+import { RenegotiationIndication } from '../../handshake/extensions/renegotiationIndication.js';
+import { UseSRTP } from '../../handshake/extensions/useSrtp.js';
+import { Certificate } from '../../handshake/message/certificate.js';
+import { ServerCertificateRequest } from '../../handshake/message/server/certificateRequest.js';
+import { ServerHello } from '../../handshake/message/server/hello.js';
+import { ServerHelloDone } from '../../handshake/message/server/helloDone.js';
+import { ServerKeyExchange } from '../../handshake/message/server/keyExchange.js';
+import { debug } from '../../imports/common.js';
+import { Flight } from '../flight.js';
+const log = debug('webrtc/dtls/flight/server/flight4:log');
+export class Flight4 extends 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.create([this.srtp.srtpProfile], Buffer.from([0x00])).extension);
+        }
+        if (this.dtls.options.extendedMasterSecret) {
+            extensions.push({
+                type: ExtendedMasterSecret.type,
+                data: Buffer.alloc(0)
+            });
+        }
+        const renegotiationIndication = RenegotiationIndication.createEmpty();
+        extensions.push(renegotiationIndication.extension);
+        const serverHello = new 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([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 ServerKeyExchange(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 ServerCertificateRequest(certificateTypes, signatures, []);
+        log(this.dtls.sessionId, 'sendCertificateRequest', handshake);
+        const packets = this.createPacket([handshake]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+    sendServerHelloDone() {
+        const handshake = new ServerHelloDone();
+        const packets = this.createPacket([handshake]);
+        return Buffer.concat(packets.map((v) => v.serialize()));
+    }
+}

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

@@ -0,0 +1,107 @@
+import { createCipher } from '../../cipher/create.js';
+import { prfExtendedMasterSecret, prfMasterSecret, prfPreMasterSecret } from '../../cipher/prf.js';
+import { HandshakeType } from '../../handshake/const.js';
+import { Certificate } from '../../handshake/message/certificate.js';
+import { ChangeCipherSpec } from '../../handshake/message/changeCipherSpec.js';
+import { CertificateVerify } from '../../handshake/message/client/certificateVerify.js';
+import { ClientKeyExchange } from '../../handshake/message/client/keyExchange.js';
+import { Finished } from '../../handshake/message/finished.js';
+import { debug } from '../../imports/common.js';
+import { createPlaintext } from '../../record/builder.js';
+import { ContentType } from '../../record/const.js';
+import { Flight } from '../flight.js';
+const log = debug('webrtc/dtls/flight/server/flight6');
+export class Flight6 extends 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 HandshakeType.certificate_11:
+                    return Certificate.deSerialize(handshake.fragment);
+                case HandshakeType.certificate_verify_15:
+                    return CertificateVerify.deSerialize(handshake.fragment);
+                case HandshakeType.client_key_exchange_16:
+                    return ClientKeyExchange.deSerialize(handshake.fragment);
+                case HandshakeType.finished_20:
+                    return 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.createEmpty().serialize();
+        const packets = createPlaintext(this.dtls)([{ type: 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(localVerifyData);
+        this.dtls.epoch = 1;
+        const [packet] = this.createPacket([finish]);
+        this.dtls.recordSequenceNumber = 0;
+        const buf = this.cipher.encryptPacket(packet).serialize();
+        return buf;
+    }
+}
+const handlers = {};
+handlers[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 = 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
+                ? prfExtendedMasterSecret(preMasterSecret, handshakes)
+                : prfMasterSecret(preMasterSecret, cipher.remoteRandom.serialize(), cipher.localRandom.serialize());
+        cipher.cipher = createCipher(cipher.cipherSuite);
+        cipher.cipher.init(cipher.masterSecret, cipher.localRandom.serialize(), cipher.remoteRandom.serialize());
+        log(dtls.sessionId, 'setup cipher', cipher.cipher.summary);
+    };
+handlers[HandshakeType.certificate_11] =
+    ({ cipher, dtls }) => (message) => {
+        log(dtls.sessionId, 'handshake certificate', message);
+        cipher.remoteCertificate = message.certificateList[0];
+    };
+handlers[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[HandshakeType.finished_20] =
+    ({ dtls }) => (message) => {
+        log(dtls.sessionId, 'finished', message);
+    };

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

@@ -0,0 +1,17 @@
+import { binaryData } from '../imports/common.js';
+const { types } = 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)
+};
+export const ExtensionList = array(Extension, uint16be, 'bytes');
+export const ASN11Cert = buffer(uint24be);
+export const ClientCertificateType = uint8;
+export const DistinguishedName = string(uint16be);
+export const SignatureHashAlgorithm = { hash: uint8, signature: uint8 };
+export const ProtocolVersion = { major: uint8, minor: uint8 };

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

@@ -0,0 +1,14 @@
+export 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 || (HandshakeType = {}));

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

@@ -0,0 +1,36 @@
+import { binaryData } from '../../imports/common.js';
+const { decode, encode, types } = binaryData;
+// rfc4492
+export 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)
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+export class ExtendedMasterSecret {
+    static { this.type = 23; }
+}