werift 0.22.9 → 0.23.0

package/lib/index.mjs

@@ -4646,7 +4646,12 @@ import { createHmac as createHmac3 } from "crypto";
 import AES from "aes-js";
 
 // ../rtp/src/srtp/cipher/ctr.ts
-import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, createHmac as createHmac2 } from "crypto";
+import {
+  createCipheriv as createCipheriv2,
+  createDecipheriv as createDecipheriv2,
+  createHmac as createHmac2,
+  timingSafeEqual
+} from "crypto";
 
 // ../rtp/src/srtp/cipher/index.ts
 var CipherAesBase = class {
@@ -4659,7 +4664,7 @@ var CipherAesBase = class {
   encryptRtp(header, payload, rolloverCounter) {
     return Buffer.from([]);
   }
-  decryptRtp(cipherText, rolloverCounter) {
+  decryptRtp(cipherText, rolloverCounter, header) {
     return [];
   }
   encryptRTCP(rawRtcp, srtcpIndex) {
@@ -4670,6 +4675,74 @@ var CipherAesBase = class {
   }
 };
 
+// ../rtp/src/srtp/error.ts
+var SrtpAuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SrtpAuthenticationError";
+  }
+};
+
+// ../rtp/src/srtp/packet.ts
+var minRtpHeaderSize = 12;
+var minRtcpPacketSize = 8;
+function parseSrtpRtpHeader(packet, authTagLength, message = "Failed to authenticate SRTP packet") {
+  const authTagOffset = packet.length - authTagLength;
+  assertAuthenticatedPacketLength(
+    packet.length >= minRtpHeaderSize + authTagLength,
+    message
+  );
+  const header = wrapAuthenticationError(
+    () => RtpHeader.deSerialize(packet.subarray(0, authTagOffset)),
+    message
+  );
+  header.paddingSize = 0;
+  assertAuthenticatedPacketLength(
+    header.payloadOffset >= minRtpHeaderSize && header.payloadOffset <= authTagOffset,
+    message
+  );
+  return header;
+}
+function parseSrtcpHeader(packet, authTagLength, srtcpIndexSize3, message = "Failed to authenticate SRTCP packet") {
+  assertAuthenticatedPacketLength(
+    packet.length >= minRtcpPacketSize + authTagLength + srtcpIndexSize3,
+    message
+  );
+  return wrapAuthenticationError(
+    () => RtcpHeader.deSerialize(packet.subarray(0, RTCP_HEADER_SIZE)),
+    message
+  );
+}
+function assertAuthenticatedPacketLength(condition, message) {
+  if (!condition) {
+    throw new SrtpAuthenticationError(message);
+  }
+}
+function wrapAuthenticationError(parse, message) {
+  try {
+    return parse();
+  } catch {
+    throw new SrtpAuthenticationError(message);
+  }
+}
+function finalizeSrtpRtpHeader(header, packet, message = "Failed to authenticate SRTP packet") {
+  if (!header.padding) {
+    header.paddingSize = 0;
+    return header;
+  }
+  assertAuthenticatedPacketLength(
+    packet.length > header.payloadOffset,
+    message
+  );
+  const paddingSize = packet[packet.length - 1];
+  assertAuthenticatedPacketLength(
+    paddingSize > 0 && paddingSize <= packet.length - header.payloadOffset,
+    message
+  );
+  header.paddingSize = paddingSize;
+  return header;
+}
+
 // ../rtp/src/srtp/cipher/ctr.ts
 var CipherAesCtr = class extends CipherAesBase {
   constructor(srtpSessionKey, srtpSessionSalt, srtcpSessionKey, srtcpSessionSalt, srtpSessionAuthTag, srtcpSessionAuthTag) {
@@ -4695,10 +4768,20 @@ var CipherAesCtr = class extends CipherAesBase {
     );
     return Buffer.concat([headerBuffer, enc, authTag]);
   }
-  decryptRtp(cipherText, rolloverCounter) {
-    const header = RtpHeader.deSerialize(cipherText);
-    const size = cipherText.length - this.authTagLength;
-    cipherText = cipherText.subarray(0, cipherText.length - this.authTagLength);
+  decryptRtp(cipherText, rolloverCounter, header = parseSrtpRtpHeader(cipherText, this.authTagLength)) {
+    const authTagOffset = cipherText.length - this.authTagLength;
+    const encryptedPacket = cipherText.subarray(0, authTagOffset);
+    const actualAuthTag = cipherText.subarray(authTagOffset);
+    const expectedAuthTag = this.generateSrtpAuthTag(
+      rolloverCounter,
+      encryptedPacket.subarray(0, header.payloadOffset),
+      encryptedPacket.subarray(header.payloadOffset)
+    );
+    assertAuthTag(
+      actualAuthTag,
+      expectedAuthTag,
+      "Failed to authenticate SRTP packet"
+    );
     const counter = this.generateCounter(
       header.sequenceNumber,
       rolloverCounter,
@@ -4710,14 +4793,16 @@ var CipherAesCtr = class extends CipherAesBase {
       this.srtpSessionKey,
       counter
     );
-    const payload = cipherText.subarray(header.payloadOffset);
+    const payload = encryptedPacket.subarray(header.payloadOffset);
     const buf = cipher.update(payload);
     const dst = Buffer.concat([
-      cipherText.subarray(0, header.payloadOffset),
-      buf,
-      Buffer.alloc(size - header.payloadOffset - buf.length)
+      encryptedPacket.subarray(0, header.payloadOffset),
+      buf
     ]);
-    return [dst, header];
+    return [
+      dst,
+      finalizeSrtpRtpHeader(header, dst, "Failed to authenticate SRTP packet")
+    ];
   }
   encryptRTCP(rtcpPacket, srtcpIndex) {
     let out = Buffer.from(rtcpPacket);
@@ -4739,15 +4824,29 @@ var CipherAesCtr = class extends CipherAesBase {
     return out;
   }
   decryptRTCP(encrypted) {
-    const header = RtcpHeader.deSerialize(encrypted);
+    const header = parseSrtcpHeader(
+      encrypted,
+      this.authTagLength,
+      srtcpIndexSize
+    );
     const tailOffset = encrypted.length - (this.authTagLength + srtcpIndexSize);
+    const authenticatedPortion = encrypted.subarray(
+      0,
+      encrypted.length - this.authTagLength
+    );
+    const actualTag = encrypted.subarray(encrypted.length - this.authTagLength);
+    const expectedTag = this.generateSrtcpAuthTag(authenticatedPortion);
+    assertAuthTag(
+      actualTag,
+      expectedTag,
+      "Failed to authenticate SRTCP packet"
+    );
     const out = Buffer.from(encrypted).slice(0, tailOffset);
-    const isEncrypted = encrypted[tailOffset] >> 7;
+    const isEncrypted = encrypted[tailOffset] >>> 7;
     if (isEncrypted === 0) return [out, header];
     let srtcpIndex = encrypted.readUInt32BE(tailOffset);
     srtcpIndex &= ~(1 << 31);
     const ssrc = encrypted.readUInt32BE(4);
-    const actualTag = encrypted.subarray(encrypted.length - 10);
     const counter = this.generateCounter(
       srtcpIndex & 65535,
       srtcpIndex >> 16,
@@ -4788,6 +4887,11 @@ var CipherAesCtr = class extends CipherAesBase {
   }
 };
 var srtcpIndexSize = 4;
+function assertAuthTag(actual, expected, message) {
+  if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+    throw new SrtpAuthenticationError(message);
+  }
+}
 
 // ../rtp/src/srtp/cipher/gcm.ts
 import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3 } from "crypto";
@@ -4810,20 +4914,25 @@ var CipherAesGcm = class extends CipherAesBase {
     const dst = Buffer.concat([hdr, enc, authTag]);
     return dst;
   }
-  decryptRtp(cipherText, rolloverCounter) {
-    const header = RtpHeader.deSerialize(cipherText);
+  decryptRtp(cipherText, rolloverCounter, header = parseSrtpRtpHeader(cipherText, this.aeadAuthTagLen)) {
+    const headerBuffer = cipherText.subarray(0, header.payloadOffset);
+    const authTagOffset = cipherText.length - this.aeadAuthTagLen;
+    const authTag = cipherText.subarray(authTagOffset);
     let dst = Buffer.from([]);
     dst = growBufferSize(dst, cipherText.length - this.aeadAuthTagLen);
-    cipherText.slice(0, header.payloadOffset).copy(dst);
+    headerBuffer.copy(dst);
     const iv = this.rtpInitializationVector(header, rolloverCounter);
-    const enc = cipherText.slice(
-      header.payloadOffset,
-      cipherText.length - this.aeadAuthTagLen
-    );
-    const cipher = createDecipheriv3("aes-128-gcm", this.srtpSessionKey, iv);
-    const dec = cipher.update(enc);
+    const enc = cipherText.slice(header.payloadOffset, authTagOffset);
+    const decipher = createDecipheriv3("aes-128-gcm", this.srtpSessionKey, iv);
+    decipher.setAAD(headerBuffer);
+    decipher.setAuthTag(authTag);
+    const dec = decipher.update(enc);
+    finalizeAuthenticatedDecryption(decipher, "SRTP");
     dec.copy(dst, header.payloadOffset);
-    return [dst, header];
+    return [
+      dst,
+      finalizeSrtpRtpHeader(header, dst, "Failed to authenticate SRTP packet")
+    ];
   }
   encryptRTCP(rtcpPacket, srtcpIndex) {
     const ssrc = rtcpPacket.readUInt32BE(4);
@@ -4844,19 +4953,38 @@ var CipherAesGcm = class extends CipherAesBase {
     return dst;
   }
   decryptRTCP(encrypted) {
-    const header = RtcpHeader.deSerialize(encrypted);
-    const aadPos = encrypted.length - srtcpIndexSize2;
-    const dst = Buffer.alloc(aadPos - this.aeadAuthTagLen);
-    encrypted.slice(0, 8).copy(dst);
+    const header = parseSrtcpHeader(
+      encrypted,
+      this.aeadAuthTagLen,
+      srtcpIndexSize2
+    );
+    const srtcpIndexOffset = encrypted.length - srtcpIndexSize2;
+    const authTagOffset = srtcpIndexOffset - this.aeadAuthTagLen;
     const ssrc = encrypted.readUInt32BE(4);
-    let srtcpIndex = encrypted.readUInt32BE(encrypted.length - 4);
-    srtcpIndex &= ~(rtcpEncryptionFlag << 24);
+    const encodedSrtcpIndex = encrypted.readUInt32BE(srtcpIndexOffset);
+    const isEncrypted = encodedSrtcpIndex >>> 31 === 1;
+    const srtcpIndex = encodedSrtcpIndex & ~(rtcpEncryptionFlag << 24);
     const iv = this.rtcpInitializationVector(ssrc, srtcpIndex);
-    const aad = this.rtcpAdditionalAuthenticatedData(encrypted, srtcpIndex);
-    const cipher = createDecipheriv3("aes-128-gcm", this.srtcpSessionKey, iv);
-    cipher.setAAD(aad);
-    const dec = cipher.update(encrypted.slice(8, aadPos));
-    dec.copy(dst, 8);
+    const aad = isEncrypted ? Buffer.concat([
+      encrypted.subarray(0, 8),
+      encrypted.subarray(srtcpIndexOffset)
+    ]) : Buffer.concat([
+      encrypted.subarray(0, authTagOffset),
+      encrypted.subarray(srtcpIndexOffset)
+    ]);
+    const cipherText = isEncrypted ? encrypted.slice(8, authTagOffset) : Buffer.alloc(0);
+    const dst = isEncrypted ? Buffer.alloc(authTagOffset) : Buffer.from(encrypted.subarray(0, authTagOffset));
+    if (isEncrypted) {
+      encrypted.slice(0, 8).copy(dst);
+    }
+    const decipher = createDecipheriv3("aes-128-gcm", this.srtcpSessionKey, iv);
+    decipher.setAAD(aad);
+    decipher.setAuthTag(encrypted.subarray(authTagOffset, srtcpIndexOffset));
+    const dec = decipher.update(cipherText);
+    finalizeAuthenticatedDecryption(decipher, "SRTCP");
+    if (isEncrypted) {
+      dec.copy(dst, 8);
+    }
     return [dst, header];
   }
   // https://tools.ietf.org/html/rfc7714#section-8.1
@@ -4892,6 +5020,15 @@ var CipherAesGcm = class extends CipherAesBase {
 };
 var srtcpIndexSize2 = 4;
 var rtcpEncryptionFlag = 128;
+function finalizeAuthenticatedDecryption(decipher, packetType) {
+  try {
+    decipher.final();
+  } catch {
+    throw new SrtpAuthenticationError(
+      `Failed to authenticate ${packetType} packet`
+    );
+  }
+}
 
 // ../rtp/src/srtp/context/context.ts
 var Context = class {
@@ -5149,12 +5286,29 @@ var SrtpContext2 = class extends Context {
     return enc;
   }
   decryptRtp(cipherText) {
-    const header = RtpHeader.deSerialize(cipherText);
-    const s = this.getSrtpSsrcState(header.ssrc);
-    this.updateRolloverCount(header.sequenceNumber, s);
-    const dec = this.cipher.decryptRtp(cipherText, s.rolloverCounter);
+    const header = parseSrtpRtpHeader(cipherText, this.rtpAuthTagLength);
+    const existingState = this.srtpSSRCStates[header.ssrc];
+    const nextState = existingState ? { ...existingState } : {
+      ssrc: header.ssrc,
+      rolloverCounter: 0,
+      lastSequenceNumber: 0
+    };
+    this.updateRolloverCount(header.sequenceNumber, nextState);
+    const dec = this.cipher.decryptRtp(
+      cipherText,
+      nextState.rolloverCounter,
+      header
+    );
+    if (existingState) {
+      Object.assign(existingState, nextState);
+    } else {
+      this.srtpSSRCStates[header.ssrc] = nextState;
+    }
     return dec;
   }
+  get rtpAuthTagLength() {
+    return this.profile === ProtectionProfileAeadAes128Gcm ? 16 : 10;
+  }
 };
 
 // ../rtp/src/srtp/srtp.ts
@@ -5896,6 +6050,9 @@ var DtlsSocket = class {
       this.sessionType === SessionType.CLIENT
     );
   }
+  get remoteCertificate() {
+    return this.cipher.remoteCertificate;
+  }
 };
 
 // ../dtls/src/client.ts
@@ -6284,6 +6441,16 @@ handlers2[16 /* client_key_exchange_16 */] = ({ cipher, dtls }) => (message) =>
   );
   log16(dtls.sessionId, "setup cipher", cipher.cipher.summary);
 };
+handlers2[11 /* certificate_11 */] = ({ cipher, dtls }) => (message) => {
+  log16(dtls.sessionId, "handshake certificate", message);
+  cipher.remoteCertificate = message.certificateList[0];
+};
+handlers2[15 /* certificate_verify_15 */] = ({ cipher, dtls }) => (message) => {
+  if (!cipher.remoteCertificate) {
+    throw new Error("client certificate missing before certificate verify");
+  }
+  log16(dtls.sessionId, "certificate_verify", message.algorithm);
+};
 handlers2[20 /* finished_20 */] = ({ dtls }) => (message) => {
   log16(dtls.sessionId, "finished", message);
 };
@@ -6350,7 +6517,14 @@ var DtlsServer = class extends DtlsSocket {
           {
             await this.waitForReady(() => !!this.flight6);
             this.flight6?.handleHandshake(handshake);
-            await this.waitForReady(() => this.dtls.checkHandshakesExist([16]));
+            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();
@@ -8600,6 +8774,9 @@ var EventTarget = class extends EventEmitter {
 
 // src/dataChannel.ts
 var log23 = debug("werift:packages/webrtc/src/dataChannel.ts");
+function getDataChannelMessageSize(data) {
+  return Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
+}
 var RTCDataChannel = class extends EventTarget {
   constructor(sctp, parameters, sendOpen = true) {
     super();
@@ -8705,10 +8882,9 @@ var RTCDataChannel = class extends EventTarget {
     }
   }
   send(data) {
-    const size = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
+    const size = this.sctp.datachannelSend(this, data);
     this.messagesSent++;
     this.bytesSent += size;
-    this.sctp.datachannelSend(this, data);
   }
   close() {
     this.sctp.dataChannelClose(this);
@@ -9163,6 +9339,24 @@ function fingerprint(file, hashName) {
   const hash2 = createHash4(hashName).update(file).digest("hex");
   return colon(upper(hash2));
 }
+var fingerprintHashAlgorithms = {
+  sha1: "sha1",
+  "sha-1": "sha1",
+  sha224: "sha224",
+  "sha-224": "sha224",
+  sha256: "sha256",
+  "sha-256": "sha256",
+  sha384: "sha384",
+  "sha-384": "sha384",
+  sha512: "sha512",
+  "sha-512": "sha512"
+};
+function normalizeFingerprintAlgorithm(algorithm) {
+  return fingerprintHashAlgorithms[algorithm.trim().toLowerCase()];
+}
+function normalizeFingerprintValue(value) {
+  return value.replace(/[^0-9a-f]/gi, "").toLowerCase();
+}
 function isDtls(buf) {
   const firstByte = buf[0];
   return firstByte > 19 && firstByte < 64;
@@ -9619,13 +9813,18 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
     return this.localCertificatePromise;
   }
   setRemoteParams(remoteParameters) {
-    this.remoteParameters = remoteParameters;
+    const fingerprints = deduplicateFingerprints([
+      ...this.remoteParameters?.fingerprints ?? [],
+      ...remoteParameters.fingerprints
+    ]);
+    const role = remoteParameters.role === "auto" && this.remoteParameters?.role ? this.remoteParameters.role : remoteParameters.role;
+    this.remoteParameters = new RTCDtlsParameters(fingerprints, role);
   }
   async start() {
     if (this.state !== "new") {
       throw new Error("state must be new");
     }
-    if (this.remoteParameters?.fingerprints.length === 0) {
+    if (!this.remoteParameters || this.remoteParameters.fingerprints.length === 0) {
       throw new Error("remote fingerprint not exist");
     }
     if (this.role === "auto") {
@@ -9644,8 +9843,8 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
           signatureHash: this.localCertificate?.signatureHash,
           transport: createIceTransport(this.iceTransport.connection),
           srtpProfiles: this.srtpProfiles,
-          extendedMasterSecret: true
-          // certificateRequest: true,
+          extendedMasterSecret: true,
+          certificateRequest: true
         });
       } else {
         this.dtls = new DtlsClient({
@@ -9664,7 +9863,9 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
         this.dataReceiver(buf);
       });
       this.dtls.onClose.subscribe(() => {
-        this.setState("closed");
+        if (this.state !== "failed") {
+          this.setState("closed");
+        }
       });
       this.dtls.onConnect.once(r);
       this.dtls.onError.once((error) => {
@@ -9681,16 +9882,70 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
         });
       }
     });
+    try {
+      this.verifyRemoteCertificateFingerprint();
+    } catch (error) {
+      this.setState("failed");
+      this.dtls?.close();
+      throw error;
+    }
     if (this.srtpProfiles.length > 0) {
       this.startSrtp();
     }
-    this.dtls.onConnect.subscribe(() => {
-      this.updateSrtpSession();
-      this.setState("connected");
-    });
     this.setState("connected");
     log27("dtls connected");
   }
+  verifyRemoteCertificateFingerprint() {
+    if (!this.remoteParameters || this.remoteParameters.fingerprints.length === 0) {
+      throw new Error("remote fingerprint not exist");
+    }
+    const remoteCertificate = this.dtls?.remoteCertificate;
+    if (!remoteCertificate) {
+      throw new Error("remote certificate not available");
+    }
+    const supportedFingerprints = this.remoteParameters.fingerprints.flatMap(
+      ({ algorithm, value }) => {
+        const normalizedAlgorithm = normalizeFingerprintAlgorithm(algorithm);
+        if (!normalizedAlgorithm) {
+          return [];
+        }
+        const normalizedValue = normalizeFingerprintValue(value);
+        if (!normalizedValue) {
+          throw new Error("remote fingerprint value is empty");
+        }
+        return [{ normalizedAlgorithm, normalizedValue }];
+      }
+    );
+    if (supportedFingerprints.length === 0) {
+      throw new Error("no supported remote fingerprint algorithms");
+    }
+    const preferredAlgorithm = selectPreferredFingerprintAlgorithm(
+      supportedFingerprints
+    );
+    const expectedFingerprints = supportedFingerprints.filter(
+      ({ normalizedAlgorithm }) => normalizedAlgorithm === preferredAlgorithm
+    );
+    const actualFingerprints = expectedFingerprints.reduce(
+      (acc, { normalizedAlgorithm }) => {
+        if (!acc.has(normalizedAlgorithm)) {
+          acc.set(
+            normalizedAlgorithm,
+            normalizeFingerprintValue(
+              fingerprint(remoteCertificate, normalizedAlgorithm)
+            )
+          );
+        }
+        return acc;
+      },
+      /* @__PURE__ */ new Map()
+    );
+    const matched = expectedFingerprints.some(
+      ({ normalizedAlgorithm, normalizedValue }) => actualFingerprints.get(normalizedAlgorithm) === normalizedValue
+    );
+    if (!matched) {
+      throw new Error("remote certificate fingerprint mismatch");
+    }
+  }
   updateSrtpSession() {
     if (!this.dtls) throw new Error();
     const profile = this.dtls.srtp.srtpProfile;
@@ -9723,8 +9978,23 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
       this.bytesReceived += data.length;
       this.packetsReceived++;
       if (isRtcp(data)) {
-        const dec = this.srtcp.decrypt(data);
-        const rtcpPackets = RtcpPacketConverter.deSerialize(dec);
+        let dec;
+        try {
+          dec = this.srtcp.decrypt(data);
+        } catch (error) {
+          if (error instanceof SrtpAuthenticationError) {
+            log27("dropping invalid SRTCP packet", error);
+            return;
+          }
+          throw error;
+        }
+        let rtcpPackets;
+        try {
+          rtcpPackets = RtcpPacketConverter.deSerialize(dec);
+        } catch (error) {
+          log27("dropping malformed SRTCP packet", error);
+          return;
+        }
         for (const rtcp of rtcpPackets) {
           try {
             this.onRtcp.execute(rtcp);
@@ -9733,8 +10003,23 @@ var RTCDtlsTransport = class _RTCDtlsTransport {
           }
         }
       } else {
-        const dec = this.srtp.decrypt(data);
-        const rtp = RtpPacket.deSerialize(dec);
+        let dec;
+        try {
+          dec = this.srtp.decrypt(data);
+        } catch (error) {
+          if (error instanceof SrtpAuthenticationError) {
+            log27("dropping invalid SRTP packet", error);
+            return;
+          }
+          throw error;
+        }
+        let rtp;
+        try {
+          rtp = RtpPacket.deSerialize(dec);
+        } catch (error) {
+          log27("dropping malformed SRTP packet", error);
+          return;
+        }
         try {
           this.onRtp.execute(rtp);
         } catch (error) {
@@ -9887,6 +10172,31 @@ var RTCDtlsParameters = class {
     this.role = role;
   }
 };
+var deduplicateFingerprints = (fingerprints) => {
+  const seen = /* @__PURE__ */ new Set();
+  return fingerprints.filter(({ algorithm, value }) => {
+    const key = `${normalizeFingerprintAlgorithm(algorithm) ?? algorithm.trim().toLowerCase()}:${normalizeFingerprintValue(value)}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+var preferredFingerprintAlgorithms = [
+  "sha512",
+  "sha384",
+  "sha256",
+  "sha224",
+  "sha1"
+];
+var selectPreferredFingerprintAlgorithm = (fingerprints) => {
+  return preferredFingerprintAlgorithms.find(
+    (algorithm) => fingerprints.some(
+      ({ normalizedAlgorithm }) => normalizedAlgorithm === algorithm
+    )
+  ) ?? fingerprints[0].normalizedAlgorithm;
+};
 var IceTransport = class {
   constructor(ice) {
     this.ice = ice;
@@ -12064,9 +12374,11 @@ function tsnPlusOne(a) {
 
 // src/transport/sctp.ts
 var log30 = debug("werift:packages/webrtc/src/transport/sctp.ts");
-var RTCSctpTransport = class {
-  constructor(port = 5e3) {
+var DEFAULT_MAX_MESSAGE_SIZE = 65536;
+var RTCSctpTransport = class _RTCSctpTransport {
+  constructor(port = 5e3, maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE) {
     this.port = port;
+    this.maxMessageSize = maxMessageSize;
   }
   dtlsTransport;
   sctp;
@@ -12076,6 +12388,7 @@ var RTCSctpTransport = class {
   mLineIndex;
   bundled = false;
   dataChannels = {};
+  remoteMaxMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
   dataChannelQueue = [];
   dataChannelId;
   eventDisposer = [];
@@ -12304,18 +12617,35 @@ var RTCSctpTransport = class {
     }
     this.dataChannelQueue = [];
   }
+  assertSendableMessageSize(size) {
+    if (this.remoteMaxMessageSize !== 0 && size > this.remoteMaxMessageSize) {
+      throw new Error(
+        `max-message-size exceeded: ${size} > ${this.remoteMaxMessageSize}`
+      );
+    }
+  }
   datachannelSend = (channel, data) => {
-    channel.addBufferedAmount(data.length);
+    const userData = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const size = getDataChannelMessageSize(data);
+    this.assertSendableMessageSize(size);
+    channel.addBufferedAmount(size);
     this.dataChannelQueue.push(
-      typeof data === "string" ? [channel, WEBRTC_STRING, Buffer.from(data)] : [channel, WEBRTC_BINARY, data]
+      typeof data === "string" ? [channel, WEBRTC_STRING, userData] : [channel, WEBRTC_BINARY, userData]
     );
     if (this.sctp.associationState !== 4 /* ESTABLISHED */) {
       log30("sctp not established", this.sctp.associationState);
     }
     this.dataChannelFlush();
+    return size;
   };
-  static getCapabilities() {
-    return new RTCSctpCapabilities2(65536);
+  getCapabilities() {
+    return _RTCSctpTransport.getCapabilities(this.maxMessageSize);
+  }
+  static getCapabilities(maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE) {
+    return new RTCSctpCapabilities2(maxMessageSize);
+  }
+  setRemoteMaxMessageSize(maxMessageSize) {
+    this.remoteMaxMessageSize = maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE;
   }
   setRemotePort(port) {
     this.sctp.setRemotePort(port);
@@ -14006,8 +14336,8 @@ var SctpTransportManager = class {
   onDataChannel = new Event();
   constructor() {
   }
-  createSctpTransport() {
-    const sctp = new RTCSctpTransport();
+  createSctpTransport(maxMessageSize) {
+    const sctp = new RTCSctpTransport(5e3, maxMessageSize);
     sctp.mid = void 0;
     sctp.onDataChannel.subscribe((channel) => {
       this.dataChannelsOpened++;
@@ -14065,6 +14395,9 @@ var SctpTransportManager = class {
     if (!this.sctpTransport) {
       return;
     }
+    this.sctpTransport.setRemoteMaxMessageSize(
+      remoteMedia.sctpCapabilities?.maxMessageSize
+    );
     this.sctpRemotePort = remoteMedia.sctpPort;
     if (!this.sctpRemotePort) {
       throw new Error("sctpRemotePort not exist");
@@ -14205,7 +14538,7 @@ var SDPManager = class {
     );
     media.sctpPort = sctp.port;
     media.rtp.muxId = sctp.mid;
-    media.sctpCapabilities = RTCSctpTransport.getCapabilities();
+    media.sctpCapabilities = sctp.getCapabilities();
     this.addTransportDescription(media, sctp.dtlsTransport);
     return media;
   }
@@ -14343,7 +14676,7 @@ var SDPManager = class {
       description.media.push(this.createMediaDescriptionForSctp(sctpTransport));
     }
     if (this.bundlePolicy !== "disable") {
-      const mids = description.media.map((m) => m.direction !== "inactive" ? m.rtp.muxId : void 0).filter((v) => v);
+      const mids = description.media.map((m) => m.rtp.muxId).filter((v) => v);
       if (mids.length) {
         const bundle = new GroupDescription("BUNDLE", mids);
         description.group.push(bundle);
@@ -14413,7 +14746,7 @@ var SDPManager = class {
     if (this.bundlePolicy !== "disable") {
       const bundle = new GroupDescription("BUNDLE", []);
       for (const media of description.media) {
-        if (media.direction !== "inactive") {
+        if (media.rtp.muxId) {
           bundle.items.push(media.rtp.muxId);
         }
       }
@@ -14538,7 +14871,9 @@ var SecureTransportManager = class {
     );
   }
   createTransport() {
-    const [existing] = this.iceTransports;
+    const existing = this.iceTransports.find(
+      (transport) => transport.state !== "closed"
+    );
     const iceGatherer = new RTCIceGatherer({
       ...parseIceServers(this.config.iceServers),
       forceTurn: this.config.iceTransportPolicy === "relay",
@@ -14793,6 +15128,7 @@ var RTCPeerConnection = class extends EventTarget {
   secureManager;
   isClosed = false;
   shouldNegotiationneeded = false;
+  remoteBundleNegotiated = false;
   iceGatheringStateChange = new Event();
   iceConnectionStateChange = new Event();
   signalingStateChange = new Event();
@@ -14942,6 +15278,12 @@ var RTCPeerConnection = class extends EventTarget {
       if (min === max) throw new Error("should not be same value");
       if (min >= max) throw new Error("The min must be less than max");
     }
+    if (!Number.isInteger(this.config.maxMessageSize) || this.config.maxMessageSize < 0) {
+      throw new Error("maxMessageSize must be a non-negative integer");
+    }
+    if (this.sctpManager?.sctpTransport) {
+      this.sctpManager.sctpTransport.maxMessageSize = this.config.maxMessageSize;
+    }
     for (const [i, codecParams] of enumerate2([
       ...this.config.codecs.audio || [],
       ...this.config.codecs.video || []
@@ -14998,7 +15340,9 @@ var RTCPeerConnection = class extends EventTarget {
     return description.toJSON();
   }
   createSctpTransport() {
-    const sctp = this.sctpManager.createSctpTransport();
+    const sctp = this.sctpManager.createSctpTransport(
+      this.config.maxMessageSize
+    );
     const dtlsTransport = this.findOrCreateTransport();
     sctp.setDtlsTransport(dtlsTransport);
     return sctp;
@@ -15035,10 +15379,13 @@ var RTCPeerConnection = class extends EventTarget {
     });
   };
   findOrCreateTransport() {
-    const [existing] = this.iceTransports;
-    if (this.sdpManager.bundlePolicy === "max-bundle" || this.sdpManager.bundlePolicy !== "disable" && this.remoteIsBundled) {
-      if (existing) {
-        return this.dtlsTransports[0];
+    const existingDtlsTransport = this.dtlsTransports.find(
+      (transport) => transport.state !== "closed"
+    );
+    const existing = existingDtlsTransport?.iceTransport;
+    if (this.sdpManager.bundlePolicy === "max-bundle" || this.sdpManager.bundlePolicy !== "disable" && (this.remoteIsBundled || this.remoteBundleNegotiated)) {
+      if (existingDtlsTransport) {
+        return existingDtlsTransport;
       }
     }
     const dtlsTransport = this.secureManager.createTransport();
@@ -15210,6 +15557,11 @@ var RTCPeerConnection = class extends EventTarget {
       sessionDescription,
       this.signalingState
     );
+    if (remoteSdp.group.some(
+      (group) => group.semantic === "BUNDLE" && group.items.length > 0
+    )) {
+      this.remoteBundleNegotiated = true;
+    }
     let bundleTransport;
     const matchTransceiverWithMedia = (transceiver, media) => transceiver.kind === media.kind && [void 0, media.rtp.muxId].includes(transceiver.mid);
     let transports = remoteSdp.media.map((remoteMedia, i) => {
@@ -15427,7 +15779,8 @@ function generateDefaultPeerConfig() {
     bundlePolicy: "max-compat",
     debug: {},
     midSuffix: false,
-    forceTurnTCP: false
+    forceTurnTCP: false,
+    maxMessageSize: DEFAULT_MAX_MESSAGE_SIZE
   };
 }
 var defaultPeerConfig = generateDefaultPeerConfig();
@@ -15480,14 +15833,15 @@ var TransceiverManager = class {
     newTransceiver.options = options;
     this.router.registerRtpSender(newTransceiver.sender);
     const inactiveTransceiverIndex = this.transceivers.findIndex(
-      (t) => t.currentDirection === "inactive"
+      (t) => t.currentDirection === "inactive" && !t.usedForSender
     );
     const inactiveTransceiver = this.transceivers.find(
-      (t) => t.currentDirection === "inactive"
+      (t) => t.currentDirection === "inactive" && !t.usedForSender
     );
     if (inactiveTransceiverIndex > -1 && inactiveTransceiver) {
       this.replaceTransceiver(newTransceiver, inactiveTransceiverIndex);
       newTransceiver.mLineIndex = inactiveTransceiver.mLineIndex;
+      newTransceiver.mid = inactiveTransceiver.mid;
       inactiveTransceiver.setCurrentDirection(void 0);
     } else {
       this.pushTransceiver(newTransceiver);
@@ -15774,6 +16128,7 @@ export {
   Connection,
   ConnectionStates,
   CurveType,
+  DEFAULT_MAX_MESSAGE_SIZE,
   DePacketizerBase,
   Directions,
   DtlsClient,
@@ -15877,6 +16232,7 @@ export {
   SourceDescriptionChunk,
   SourceDescriptionItem,
   SrtcpSession,
+  SrtpAuthenticationError,
   SrtpContext,
   SrtpSession,
   SsrcDescription,
@@ -15935,6 +16291,7 @@ export {
   fingerprint,
   generateStatsId,
   getBit,
+  getDataChannelMessageSize,
   getGlobalIp,
   getHostAddresses,
   getStatsTimestamp,
@@ -15953,6 +16310,8 @@ export {
   milliTime,
   nodeIpAddress,
   normalizeFamilyNodeV18,
+  normalizeFingerprintAlgorithm,
+  normalizeFingerprintValue,
   ntpTime,
   ntpTime2Sec,
   paddingBits,