@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,97 @@
+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';
+/* 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/esm/lib/dtls/record/antiReplayWindow.js

@@ -0,0 +1,98 @@
+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
+ */
+export 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;
+    }
+}

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

@@ -0,0 +1,22 @@
+import { DtlsPlaintext } from './message/plaintext.js';
+export 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;
+    });
+};
+export const createPlaintext = (dtls) => (fragments, recordSequenceNumber) => {
+    return fragments.map((msg) => {
+        const plaintext = new DtlsPlaintext({
+            contentType: msg.type,
+            protocolVersion: dtls.version,
+            epoch: dtls.epoch,
+            sequenceNumber: recordSequenceNumber,
+            contentLen: msg.fragment.length
+        }, msg.fragment);
+        return plaintext;
+    });
+};

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

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

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

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

package/dist/esm/lib/dtls/record/message/header.js

@@ -0,0 +1,30 @@
+import { binaryData } from '../../imports/common.js';
+import { ProtocolVersion } from '../../handshake/binary.js';
+const { decode, encode, types } = binaryData;
+export class MACHeader {
+    static { this.spec = {
+        epoch: types.uint16be,
+        sequenceNumber: types.uint48be,
+        contentType: types.uint8,
+        protocolVersion: ProtocolVersion,
+        contentLen: types.uint16be
+    }; }
+    constructor(epoch, sequenceNumber, contentType, protocolVersion, contentLen) {
+        this.epoch = epoch;
+        this.sequenceNumber = sequenceNumber;
+        this.contentType = contentType;
+        this.protocolVersion = protocolVersion;
+        this.contentLen = contentLen;
+    }
+    static createEmpty() {
+        return new MACHeader(undefined, undefined, undefined, undefined, undefined);
+    }
+    static deSerialize(buf) {
+        return new MACHeader(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, MACHeader.spec)));
+    }
+    serialize() {
+        return encode(this, MACHeader.spec);
+    }
+}

package/dist/esm/lib/dtls/record/message/plaintext.js

@@ -0,0 +1,59 @@
+import { dumpBuffer } from '../../helper.js';
+import { MACHeader } from './header.js';
+export class DtlsPlaintext {
+    constructor(recordLayerHeader, fragment) {
+        this.recordLayerHeader = recordLayerHeader;
+        this.fragment = fragment;
+    }
+    get summary() {
+        return {
+            header: this.recordLayerHeader,
+            fragment: dumpBuffer(this.fragment)
+        };
+    }
+    static createEmpty() {
+        return new DtlsPlaintext(undefined, undefined);
+    }
+    static deSerialize(buf) {
+        if (buf.length < 13) {
+            throw new Error('Invalid DTLS record: buffer is too short');
+        }
+        const contentType = buf.readUInt8(0);
+        const majorVersion = buf.readUInt8(1);
+        const minorVersion = buf.readUInt8(2);
+        const epoch = buf.readUInt16BE(3);
+        // Read the 6-byte sequence number as a 48-bit integer
+        const sequenceNumber = buf.slice(5, 11).readUIntBE(0, 6);
+        const contentLen = buf.readUInt16BE(11);
+        // Ensure the buffer has enough data for the fragment
+        if (buf.length < 13 + contentLen) {
+            throw new Error('Invalid DTLS record: fragment length exceeds buffer');
+        }
+        const fragment = buf.slice(13, 13 + contentLen);
+        const r = new DtlsPlaintext({
+            contentType,
+            protocolVersion: { major: majorVersion, minor: minorVersion },
+            epoch,
+            sequenceNumber,
+            contentLen
+        }, fragment);
+        return r;
+    }
+    serialize() {
+        const fragmentLength = this.fragment.length;
+        // 13 bytes for headers + fragment length
+        const totalLength = 13 + fragmentLength;
+        const buffer = Buffer.alloc(totalLength);
+        buffer.writeUInt8(this.recordLayerHeader.contentType, 0);
+        buffer.writeUInt8(this.recordLayerHeader.protocolVersion.major, 1);
+        buffer.writeUInt8(this.recordLayerHeader.protocolVersion.minor, 2);
+        buffer.writeUInt16BE(this.recordLayerHeader.epoch, 3);
+        buffer.writeUIntBE(this.recordLayerHeader.sequenceNumber, 5, 6);
+        buffer.writeUInt16BE(fragmentLength, 11);
+        this.fragment.copy(buffer, 13);
+        return buffer;
+    }
+    computeMACHeader() {
+        return new MACHeader(this.recordLayerHeader.epoch, this.recordLayerHeader.sequenceNumber, this.recordLayerHeader.contentType, this.recordLayerHeader.protocolVersion, this.recordLayerHeader.contentLen).serialize();
+    }
+}

package/dist/esm/lib/dtls/record/receive.js

@@ -0,0 +1,86 @@
+import { Alert } from '../handshake/message/alert.js';
+import { debug } from '../imports/common.js';
+import { AlertDesc, ContentType } from './const.js';
+import { FragmentedHandshake } from './message/fragment.js';
+import { DtlsPlaintext } from './message/plaintext.js';
+const log = debug('webrtc/dtls/record/receive:log');
+const err = debug('webrtc/dtls/record/receive:err');
+export const parsePacket = (data) => {
+    let start = 0;
+    const packets = [];
+    while (data.length > start) {
+        const fragmentLength = data.readUInt16BE(start + 11);
+        if (data.length < start + (12 + fragmentLength)) {
+            break;
+        }
+        const packet = DtlsPlaintext.deSerialize(data.subarray(start));
+        packets.push(packet);
+        start += 13 + fragmentLength;
+    }
+    return packets;
+};
+export const parsePlainText = (dtls, cipher) => (plain) => {
+    const contentType = plain.recordLayerHeader.contentType;
+    switch (contentType) {
+        case ContentType.changeCipherSpec: {
+            log(dtls.sessionId, 'change cipher spec');
+            return [
+                {
+                    type: ContentType.changeCipherSpec,
+                    data: undefined
+                }
+            ];
+        }
+        case ContentType.handshake: {
+            let raw = plain.fragment;
+            try {
+                if (plain.recordLayerHeader.epoch > 0) {
+                    log(dtls.sessionId, 'decrypt handshake');
+                    raw = cipher.decryptPacket(plain);
+                }
+            }
+            catch (error) {
+                err(dtls.sessionId, 'decrypt failed', error);
+                throw error;
+            }
+            try {
+                let start = 0;
+                const handshakes = [];
+                while (raw.length > start) {
+                    const handshake = FragmentedHandshake.deSerialize(raw.subarray(start));
+                    handshakes.push({ type: ContentType.handshake, data: handshake });
+                    start += handshake.fragment_length + 12;
+                }
+                return handshakes;
+            }
+            catch (error) {
+                err(dtls.sessionId, 'decSerialize failed', error, raw);
+                throw error;
+            }
+        }
+        case ContentType.applicationData: {
+            return [
+                {
+                    type: ContentType.applicationData,
+                    data: cipher.decryptPacket(plain)
+                }
+            ];
+        }
+        case ContentType.alert: {
+            let alert = Alert.deSerialize(plain.fragment);
+            // TODO impl more better about handle encrypted alert
+            if (AlertDesc[alert.description] == undefined) {
+                const dec = cipher.decryptPacket(plain);
+                alert = Alert.deSerialize(dec);
+            }
+            err(dtls.sessionId, 'ContentType.alert', alert, AlertDesc[alert.description], 'flight', dtls.flight, 'lastFlight', dtls.lastFlight);
+            if (alert.level > 1) {
+                throw new Error('alert fatal error');
+            }
+            return [{ type: ContentType.alert, data: undefined }];
+        }
+        default: {
+            return [{ type: ContentType.alert, data: undefined }];
+        }
+    }
+};

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

@@ -0,0 +1,74 @@
+import { SessionType } from './cipher/suites/abstract.js';
+import { flight2 } from './flight/server/flight2.js';
+import { Flight4 } from './flight/server/flight4.js';
+import { Flight6 } from './flight/server/flight6.js';
+import { HandshakeType } from './handshake/const.js';
+import { ClientHello } from './handshake/message/client/hello.js';
+import { debug } from './imports/common.js';
+import { DtlsSocket } from './socket.js';
+const log = debug('webrtc/dtls/server:log');
+export class DtlsServer extends DtlsSocket {
+    constructor(options) {
+        super(options, SessionType.SERVER);
+        this.handleHandshakes = async (assembled) => {
+            log(this.dtls.sessionId, 'handleHandshakes', assembled.map((a) => a.msg_type));
+            for (const handshake of assembled) {
+                switch (handshake.msg_type) {
+                    // flight1,3
+                    case HandshakeType.client_hello_1:
+                        {
+                            if (this.connected) {
+                                this.renegotiation();
+                            }
+                            const clientHello = ClientHello.deSerialize(handshake.fragment);
+                            if (clientHello.cookie.length === 0) {
+                                log(this.dtls.sessionId, 'send flight2');
+                                flight2(this.transport, this.dtls, this.cipher, this.srtp)(clientHello);
+                            }
+                            else if (this.dtls.cookie &&
+                                clientHello.cookie.equals(this.dtls.cookie)) {
+                                log(this.dtls.sessionId, 'send flight4');
+                                await new Flight4(this.transport, this.dtls, this.cipher, this.srtp).exec(handshake, this.options.certificateRequest);
+                            }
+                            else {
+                                log('wrong state', {
+                                    dtlsCookie: this.dtls.cookie?.toString('hex').slice(10),
+                                    helloCookie: clientHello.cookie.toString('hex').slice(10)
+                                });
+                            }
+                        }
+                        break;
+                    // flight 5
+                    case HandshakeType.certificate_11:
+                    case HandshakeType.certificate_verify_15:
+                    case HandshakeType.client_key_exchange_16:
+                        {
+                            if (this.connected)
+                                return;
+                            this.flight6 = new Flight6(this.transport, this.dtls, this.cipher);
+                            this.flight6.handleHandshake(handshake);
+                        }
+                        break;
+                    case HandshakeType.finished_20:
+                        {
+                            await this.waitForReady(() => !!this.flight6);
+                            this.flight6?.handleHandshake(handshake);
+                            const requiredHandshakes = [
+                                16,
+                                this.options.certificateRequest && 11,
+                                this.options.certificateRequest && 15
+                            ].filter((type) => typeof type === 'number');
+                            await this.waitForReady(() => this.dtls.checkHandshakesExist(requiredHandshakes));
+                            await this.flight6?.exec();
+                            this.connected = true;
+                            this.onConnect.execute();
+                            log(this.dtls.sessionId, 'dtls connected');
+                        }
+                        break;
+                }
+            }
+        };
+        this.onHandleHandshakes = this.handleHandshakes;
+        log(this.dtls.sessionId, 'start server');
+    }
+}