@matter/thread-br-client 0.0.1

package/dist/cjs/dtls/handshake/DtlsClient.js

@@ -0,0 +1,502 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DtlsClient_exports = {};
+__export(DtlsClient_exports, {
+  DtlsClient: () => DtlsClient
+});
+module.exports = __toCommonJS(DtlsClient_exports);
+var import_general = require("@matter/general");
+var import_DtlsChannel = require("../channel/DtlsChannel.js");
+var import_EcJpakePms = require("../ecjpake/EcJpakePms.js");
+var import_EcJpakeRound = require("../ecjpake/EcJpakeRound.js");
+var import_SchnorrZkp = require("../ecjpake/SchnorrZkp.js");
+var import_HandshakeTranscript = require("../prf/HandshakeTranscript.js");
+var import_TlsPrf = require("../prf/TlsPrf.js");
+var import_ContentType = require("../record/ContentType.js");
+var import_DtlsCipherState = require("../record/DtlsCipherState.js");
+var import_DtlsRecord = require("../record/DtlsRecord.js");
+var import_ChangeCipherSpec = require("./ChangeCipherSpec.js");
+var import_ClientHelloMessage = require("./ClientHelloMessage.js");
+var import_ClientKeyExchangeMessage = require("./ClientKeyExchangeMessage.js");
+var import_FinishedMessage = require("./FinishedMessage.js");
+var import_HandshakeMessage = require("./HandshakeMessage.js");
+var import_HandshakeType = require("./HandshakeType.js");
+var import_HelloVerifyRequestMessage = require("./HelloVerifyRequestMessage.js");
+var import_ServerHelloDoneMessage = require("./ServerHelloDoneMessage.js");
+var import_ServerHelloMessage = require("./ServerHelloMessage.js");
+var import_ServerKeyExchangeMessage = require("./ServerKeyExchangeMessage.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const RANDOM_LEN = 32;
+function bigintFromBE(bytes) {
+  let v = 0n;
+  for (const byte of bytes) {
+    v = v << 8n | BigInt(byte);
+  }
+  return v;
+}
+class DtlsClient {
+  #config;
+  #state = "initial";
+  #transcript = new import_HandshakeTranscript.HandshakeTranscript();
+  #handshakeMessageSeq = 0;
+  #recordSeq = 0n;
+  #lastFlight = new Array();
+  #x2;
+  #X1;
+  #X2;
+  /** Round-1 wire bytes — bytes-identical across cookie-exchange retries (mbedTLS `ecjpake_cache`). */
+  #round1Bytes;
+  /** 32-byte ClientHello.random — bytes-identical across cookie retries. */
+  #clientRandom;
+  #X3;
+  #X4;
+  #serverRandom;
+  #masterSecret;
+  #cipherState;
+  constructor(config) {
+    this.#config = config;
+  }
+  state() {
+    return this.#state;
+  }
+  isEstablished() {
+    return this.#state === "established";
+  }
+  cipherState() {
+    if (!this.isEstablished() || this.#cipherState === void 0) {
+      throw new import_general.ImplementationError(
+        `DtlsClient.cipherState() called in state '${this.#state}' (need 'established')`
+      );
+    }
+    return this.#cipherState;
+  }
+  /** Initial flight: ClientHello with empty cookie. */
+  start() {
+    if (this.#state !== "initial") {
+      throw new import_general.ImplementationError(`DtlsClient.start() called in state '${this.#state}'`);
+    }
+    const random = this.#config.random();
+    if (random.length !== RANDOM_LEN) {
+      throw new import_general.ImplementationError(
+        `DtlsClient config.random() returned ${random.length} bytes, need ${RANDOM_LEN}`
+      );
+    }
+    this.#clientRandom = random;
+    const x1 = this.#config.ephemeralScalar();
+    const x2 = this.#config.ephemeralScalar();
+    const v1 = this.#config.ephemeralScalar();
+    const v2 = this.#config.ephemeralScalar();
+    const round1 = import_EcJpakeRound.EcJpakeRound.buildRound1({ x1, x2, v1, v2, id: import_EcJpakeRound.ECJPAKE_ID_CLIENT });
+    this.#x2 = x2;
+    this.#X1 = round1.kp1.X;
+    this.#X2 = round1.kp2.X;
+    this.#round1Bytes = import_EcJpakeRound.EcJpakeRound.serializeRound1(round1.kp1, round1.kp2);
+    const records = this.#emitClientHello(new Uint8Array(0), false);
+    this.#state = "sent_first_clienthello";
+    return { records };
+  }
+  /** Re-emit the last flight bytes-identically (RFC 6347 §4.2.4). */
+  onRetransmit() {
+    if (this.#state === "initial" || this.#state === "established" || this.#state === "failed") {
+      throw new import_general.ImplementationError(`DtlsClient.onRetransmit() called in state '${this.#state}'`);
+    }
+    return { records: this.#lastFlight.map((r) => r.slice()) };
+  }
+  onDatagram(bytes) {
+    if (this.#state === "established" || this.#state === "failed" || this.#state === "initial") {
+      throw new import_general.ImplementationError(`DtlsClient.onDatagram() called in state '${this.#state}'`);
+    }
+    try {
+      switch (this.#state) {
+        case "sent_first_clienthello":
+          return this.#handleHelloVerifyOrServerHello(this.#splitDatagramIntoRecords(bytes));
+        case "sent_clienthello_with_cookie":
+          return this.#handleServerHelloFlight(this.#splitDatagramIntoRecords(bytes));
+        case "sent_clientkeyexchange_flight":
+          return this.#handleServerFinishedFlightLazy(bytes);
+        default:
+          throw new import_general.InternalError(`DtlsClient: state ${this.#state} cannot consume a datagram`);
+      }
+    } catch (e) {
+      this.#state = "failed";
+      throw e;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Datagram / record splitting
+  #splitDatagramIntoRecords(bytes) {
+    const out = new Array();
+    let p = 0;
+    while (p < bytes.length) {
+      const { record, consumed } = import_DtlsRecord.DtlsRecord.decode(bytes.subarray(p), this.#cipherState);
+      out.push(record);
+      p += consumed;
+    }
+    return out;
+  }
+  #extractHandshakeMessages(records) {
+    const out = new Array();
+    for (const rec of records) {
+      if (rec.type !== import_ContentType.ContentType.HANDSHAKE) {
+        continue;
+      }
+      let p = 0;
+      while (p < rec.fragment.length) {
+        const { message, consumed } = import_HandshakeMessage.HandshakeMessage.decode(rec.fragment.subarray(p));
+        out.push({
+          msgType: message.msgType,
+          body: message.body,
+          transcriptBytes: import_HandshakeMessage.HandshakeMessage.encodeForTranscript(message)
+        });
+        p += consumed;
+      }
+    }
+    return out;
+  }
+  // -----------------------------------------------------------------------
+  // Outbound encoding helpers
+  #emitClientHello(cookie, contributesToTranscript) {
+    const body = import_ClientHelloMessage.ClientHelloMessage.build({
+      random: this.#clientRandom,
+      cookie,
+      ecjpakeKkpp: this.#round1Bytes
+    });
+    const handshake = import_HandshakeMessage.HandshakeMessage.encode({
+      msgType: import_HandshakeType.HandshakeType.CLIENT_HELLO,
+      messageSeq: this.#handshakeMessageSeq,
+      body
+    });
+    if (contributesToTranscript) {
+      this.#transcript.appendHandshakeMessage(
+        import_HandshakeMessage.HandshakeMessage.encodeForTranscript({
+          msgType: import_HandshakeType.HandshakeType.CLIENT_HELLO,
+          messageSeq: this.#handshakeMessageSeq,
+          body
+        })
+      );
+    }
+    const record = import_DtlsRecord.DtlsRecord.encode({
+      type: import_ContentType.ContentType.HANDSHAKE,
+      epoch: 0,
+      sequenceNumber: this.#recordSeq,
+      fragment: handshake
+    });
+    this.#recordSeq += 1n;
+    this.#handshakeMessageSeq += 1;
+    this.#lastFlight = [record];
+    return [record];
+  }
+  // -----------------------------------------------------------------------
+  // State handlers
+  #handleHelloVerifyOrServerHello(records) {
+    const messages = this.#extractHandshakeMessages(records);
+    if (messages.length === 0) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: expected handshake message, got none");
+    }
+    if (messages[0].msgType === import_HandshakeType.HandshakeType.HELLO_VERIFY_REQUEST) {
+      const { cookie } = import_HelloVerifyRequestMessage.HelloVerifyRequestMessage.parse(messages[0].body);
+      this.#transcript = new import_HandshakeTranscript.HandshakeTranscript();
+      const records2 = this.#emitClientHello(cookie, true);
+      this.#state = "sent_clienthello_with_cookie";
+      return { records: records2 };
+    }
+    this.#transcript = new import_HandshakeTranscript.HandshakeTranscript();
+    const firstHelloBody = import_ClientHelloMessage.ClientHelloMessage.build({
+      random: this.#clientRandom,
+      cookie: new Uint8Array(0),
+      ecjpakeKkpp: this.#round1Bytes
+    });
+    this.#transcript.appendHandshakeMessage(
+      import_HandshakeMessage.HandshakeMessage.encodeForTranscript({
+        msgType: import_HandshakeType.HandshakeType.CLIENT_HELLO,
+        messageSeq: 0,
+        body: firstHelloBody
+      })
+    );
+    return this.#consumeServerFlight(messages);
+  }
+  #handleServerHelloFlight(records) {
+    const messages = this.#extractHandshakeMessages(records);
+    return this.#consumeServerFlight(messages);
+  }
+  #consumeServerFlight(messages) {
+    if (messages.length < 3) {
+      throw new import_DtlsChannel.DtlsError(
+        `DtlsClient: server flight needs ServerHello+ServerKeyExchange+ServerHelloDone, got ${messages.length} message(s)`
+      );
+    }
+    const [sh, ske, shd, ...rest] = messages;
+    if (rest.length !== 0) {
+      throw new import_DtlsChannel.DtlsError(
+        `DtlsClient: server flight has ${rest.length} unexpected trailing handshake message(s)`
+      );
+    }
+    if (sh.msgType !== import_HandshakeType.HandshakeType.SERVER_HELLO) {
+      throw new import_DtlsChannel.DtlsError(`DtlsClient: expected ServerHello, got msg_type=${sh.msgType}`);
+    }
+    if (ske.msgType !== import_HandshakeType.HandshakeType.SERVER_KEY_EXCHANGE) {
+      throw new import_DtlsChannel.DtlsError(`DtlsClient: expected ServerKeyExchange, got msg_type=${ske.msgType}`);
+    }
+    if (shd.msgType !== import_HandshakeType.HandshakeType.SERVER_HELLO_DONE) {
+      throw new import_DtlsChannel.DtlsError(`DtlsClient: expected ServerHelloDone, got msg_type=${shd.msgType}`);
+    }
+    const parsedSh = import_ServerHelloMessage.ServerHelloMessage.parse(sh.body);
+    this.#serverRandom = parsedSh.serverRandom;
+    const serverRound1 = import_EcJpakeRound.EcJpakeRound.parseRound1(parsedSh.ecjpakeKkpp);
+    this.#X3 = serverRound1.kp1.X;
+    this.#X4 = serverRound1.kp2.X;
+    if (!import_SchnorrZkp.SchnorrZkp.verify({
+      zkp: serverRound1.kp1.zkp,
+      publicKey: serverRound1.kp1.X,
+      id: import_EcJpakeRound.ECJPAKE_ID_SERVER
+    })) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: server round-1 KP1 ZKP verification failed");
+    }
+    if (!import_SchnorrZkp.SchnorrZkp.verify({
+      zkp: serverRound1.kp2.zkp,
+      publicKey: serverRound1.kp2.X,
+      id: import_EcJpakeRound.ECJPAKE_ID_SERVER
+    })) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: server round-1 KP2 ZKP verification failed");
+    }
+    const skeKp = import_ServerKeyExchangeMessage.ServerKeyExchangeMessage.parse(ske.body);
+    const serverGenerator = import_EcJpakeRound.EcJpakeRound.composeRound2Generator({
+      Xp1: this.#X1,
+      Xp2: this.#X2,
+      Xm1: this.#X3
+    });
+    if (!import_EcJpakeRound.EcJpakeRound.verifyRound2Zkp({
+      kp: skeKp,
+      generator: serverGenerator,
+      peerId: import_EcJpakeRound.ECJPAKE_ID_SERVER
+    })) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: server round-2 ZKP verification failed");
+    }
+    import_ServerHelloDoneMessage.ServerHelloDoneMessage.parse(shd.body);
+    this.#transcript.appendHandshakeMessage(sh.transcriptBytes);
+    this.#transcript.appendHandshakeMessage(ske.transcriptBytes);
+    this.#transcript.appendHandshakeMessage(shd.transcriptBytes);
+    this.#state = "received_serverhello_flight";
+    return this.#emitClientFlight(skeKp.X);
+  }
+  /**
+   * Build the client's CKE + CCS + Finished flight and arm the cipher state.
+   * `serverRound2X` is the server's round-2 public point (`Xp` for the PMS derivation).
+   */
+  #emitClientFlight(serverRound2X) {
+    if (this.#X3 === void 0 || this.#X4 === void 0 || this.#serverRandom === void 0) {
+      throw new import_general.InternalError("DtlsClient: emitClientFlight called before server flight was parsed");
+    }
+    const s = bigintFromBE(this.#config.password);
+    const v3 = this.#config.ephemeralScalar();
+    const clientGenerator = import_EcJpakeRound.EcJpakeRound.composeRound2Generator({
+      Xp1: this.#X3,
+      Xp2: this.#X4,
+      Xm1: this.#X1
+    });
+    const clientRound2 = import_EcJpakeRound.EcJpakeRound.buildRound2({
+      xm2: this.#x2,
+      s,
+      v: v3,
+      id: import_EcJpakeRound.ECJPAKE_ID_CLIENT,
+      generator: clientGenerator
+    });
+    const ckeBody = import_ClientKeyExchangeMessage.ClientKeyExchangeMessage.build(clientRound2);
+    const ckeMsgSeq = this.#handshakeMessageSeq;
+    const ckeHandshake = import_HandshakeMessage.HandshakeMessage.encode({
+      msgType: import_HandshakeType.HandshakeType.CLIENT_KEY_EXCHANGE,
+      messageSeq: ckeMsgSeq,
+      body: ckeBody
+    });
+    this.#handshakeMessageSeq += 1;
+    this.#transcript.appendHandshakeMessage(
+      import_HandshakeMessage.HandshakeMessage.encodeForTranscript({
+        msgType: import_HandshakeType.HandshakeType.CLIENT_KEY_EXCHANGE,
+        messageSeq: ckeMsgSeq,
+        body: ckeBody
+      })
+    );
+    const pms = import_EcJpakePms.EcJpakePms.derive({
+      Xp: serverRound2X,
+      Xp2: this.#X4,
+      xm2: this.#x2,
+      s
+    });
+    const masterSecret = import_TlsPrf.TlsPrf.masterSecret({
+      premasterSecret: pms,
+      clientRandom: this.#clientRandom,
+      serverRandom: this.#serverRandom
+    });
+    this.#masterSecret = masterSecret;
+    const keyBlock = import_TlsPrf.TlsPrf.keyBlock({
+      masterSecret,
+      clientRandom: this.#clientRandom,
+      serverRandom: this.#serverRandom
+    });
+    const cipherState = new import_DtlsCipherState.DtlsCipherState("client", {
+      clientWriteKey: keyBlock.clientWriteKey,
+      serverWriteKey: keyBlock.serverWriteKey,
+      clientWriteSalt: keyBlock.clientWriteIv,
+      serverWriteSalt: keyBlock.serverWriteIv
+    });
+    this.#cipherState = cipherState;
+    const verifyData = import_TlsPrf.TlsPrf.verifyData({
+      masterSecret,
+      role: "client",
+      transcriptDigest: this.#transcript.digest()
+    });
+    const finishedBody = import_FinishedMessage.FinishedMessage.build(verifyData);
+    const finishedMsgSeq = this.#handshakeMessageSeq;
+    const finishedHandshake = import_HandshakeMessage.HandshakeMessage.encode({
+      msgType: import_HandshakeType.HandshakeType.FINISHED,
+      messageSeq: finishedMsgSeq,
+      body: finishedBody
+    });
+    this.#handshakeMessageSeq += 1;
+    this.#transcript.appendHandshakeMessage(
+      import_HandshakeMessage.HandshakeMessage.encodeForTranscript({
+        msgType: import_HandshakeType.HandshakeType.FINISHED,
+        messageSeq: finishedMsgSeq,
+        body: finishedBody
+      })
+    );
+    const ckeRecord = import_DtlsRecord.DtlsRecord.encode({
+      type: import_ContentType.ContentType.HANDSHAKE,
+      epoch: 0,
+      sequenceNumber: this.#recordSeq,
+      fragment: ckeHandshake
+    });
+    this.#recordSeq += 1n;
+    const ccsRecord = import_DtlsRecord.DtlsRecord.encode({
+      type: import_ContentType.ContentType.CHANGE_CIPHER_SPEC,
+      epoch: 0,
+      sequenceNumber: this.#recordSeq,
+      fragment: import_ChangeCipherSpec.CHANGE_CIPHER_SPEC_BODY
+    });
+    this.#recordSeq += 1n;
+    cipherState.advanceWriteEpoch();
+    const finishedSeq = cipherState.nextWriteSeq();
+    const finishedRecord = import_DtlsRecord.DtlsRecord.encode(
+      {
+        type: import_ContentType.ContentType.HANDSHAKE,
+        epoch: cipherState.writeEpoch,
+        sequenceNumber: finishedSeq,
+        fragment: finishedHandshake
+      },
+      cipherState
+    );
+    const flight = [ckeRecord, ccsRecord, finishedRecord];
+    this.#lastFlight = flight;
+    this.#state = "sent_clientkeyexchange_flight";
+    return { records: flight.map((r) => r.slice()) };
+  }
+  /**
+   * Lazy walk over the server's CCS+Finished datagram. CCS lives at epoch 0 (plaintext)
+   * and the Finished record at epoch 1 (encrypted), so we MUST process CCS first to bump
+   * the read epoch before attempting AEAD decryption — eagerly splitting the datagram via
+   * `DtlsRecord.decode` for both records would feed CCS to the codec only after the
+   * decrypt of the Finished record had already failed with a wrong-epoch error.
+   */
+  #handleServerFinishedFlightLazy(bytes) {
+    const cipherState = this.#cipherState;
+    const masterSecret = this.#masterSecret;
+    if (cipherState === void 0 || masterSecret === void 0) {
+      throw new import_general.InternalError("DtlsClient: server-finished handler reached without armed cipher state");
+    }
+    let sawCcs = false;
+    let serverFinishedBody;
+    let serverFinishedMsgSeq = 0;
+    let p = 0;
+    while (p < bytes.length) {
+      if (bytes.length - p < 13) {
+        throw new import_DtlsChannel.DtlsError("DtlsClient: short DTLS record header");
+      }
+      const epoch = bytes[p + 3] << 8 | bytes[p + 4];
+      const length = bytes[p + 11] << 8 | bytes[p + 12];
+      const recordEnd = p + 13 + length;
+      if (recordEnd > bytes.length) {
+        throw new import_DtlsChannel.DtlsError("DtlsClient: DTLS record length overruns datagram");
+      }
+      const recordBytes = bytes.subarray(p, recordEnd);
+      const stateForDecode = epoch === 0 ? void 0 : cipherState;
+      const { record } = import_DtlsRecord.DtlsRecord.decode(recordBytes, stateForDecode);
+      if (record.type === import_ContentType.ContentType.CHANGE_CIPHER_SPEC) {
+        import_ChangeCipherSpec.ChangeCipherSpec.parse(record.fragment);
+        cipherState.advanceReadEpoch();
+        sawCcs = true;
+      } else if (record.type === import_ContentType.ContentType.HANDSHAKE) {
+        if (!sawCcs) {
+          throw new import_DtlsChannel.DtlsError("DtlsClient: encrypted Finished received before ChangeCipherSpec");
+        }
+        if (record.epoch !== cipherState.readEpoch) {
+          throw new import_DtlsChannel.DtlsError(
+            `DtlsClient: server Finished record at epoch ${record.epoch}, expected ${cipherState.readEpoch}`
+          );
+        }
+        let q = 0;
+        while (q < record.fragment.length) {
+          const { message, consumed } = import_HandshakeMessage.HandshakeMessage.decode(record.fragment.subarray(q));
+          if (message.msgType !== import_HandshakeType.HandshakeType.FINISHED) {
+            throw new import_DtlsChannel.DtlsError(`DtlsClient: expected Finished, got msg_type=${message.msgType}`);
+          }
+          serverFinishedBody = message.body;
+          serverFinishedMsgSeq = message.messageSeq;
+          q += consumed;
+        }
+      }
+      p = recordEnd;
+    }
+    if (serverFinishedBody === void 0) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: server flight missing Finished message");
+    }
+    const expected = import_TlsPrf.TlsPrf.verifyData({
+      masterSecret,
+      role: "server",
+      transcriptDigest: this.#transcript.digest()
+    });
+    const actual = import_FinishedMessage.FinishedMessage.parse(serverFinishedBody).verifyData;
+    if (!constantTimeEqual(expected, actual)) {
+      throw new import_DtlsChannel.DtlsError("DtlsClient: server Finished verify_data mismatch");
+    }
+    this.#transcript.appendHandshakeMessage(
+      import_HandshakeMessage.HandshakeMessage.encodeForTranscript({
+        msgType: import_HandshakeType.HandshakeType.FINISHED,
+        messageSeq: serverFinishedMsgSeq,
+        body: serverFinishedBody
+      })
+    );
+    this.#state = "established";
+    return { records: [] };
+  }
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length || a.length !== import_FinishedMessage.FINISHED_VERIFY_DATA_LEN) {
+    return false;
+  }
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+//# sourceMappingURL=DtlsClient.js.map

package/dist/cjs/dtls/handshake/DtlsClient.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/DtlsClient.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/dtls/handshake/FinishedMessage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const FinishedMessage: {
+    build(verifyData: Uint8Array): Uint8Array;
+    parse(body: Uint8Array): {
+        verifyData: Uint8Array;
+    };
+};
+export declare const FINISHED_VERIFY_DATA_LEN = 12;
+//# sourceMappingURL=FinishedMessage.d.ts.map

package/dist/cjs/dtls/handshake/FinishedMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinishedMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/FinishedMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH,eAAO,MAAM,eAAe;IACxB,KAAK,aAAa,UAAU,GAAG,UAAU;IAQzC,KAAK,OAAO,UAAU,GAAG;QAAE,UAAU,EAAE,UAAU,CAAA;KAAE;CAM7C,CAAC;AAEX,eAAO,MAAM,wBAAwB,KAAkB,CAAC"}

package/dist/cjs/dtls/handshake/FinishedMessage.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FinishedMessage_exports = {};
+__export(FinishedMessage_exports, {
+  FINISHED_VERIFY_DATA_LEN: () => FINISHED_VERIFY_DATA_LEN,
+  FinishedMessage: () => FinishedMessage
+});
+module.exports = __toCommonJS(FinishedMessage_exports);
+var import_general = require("@matter/general");
+var import_DtlsChannel = require("../channel/DtlsChannel.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const VERIFY_DATA_LEN = 12;
+const FinishedMessage = {
+  build(verifyData) {
+    if (verifyData.length !== VERIFY_DATA_LEN) {
+      throw new import_general.InternalError(`Finished verify_data must be ${VERIFY_DATA_LEN} bytes, got ${verifyData.length}`);
+    }
+    return verifyData.slice();
+  },
+  parse(body) {
+    if (body.length !== VERIFY_DATA_LEN) {
+      throw new import_DtlsChannel.DtlsError(`Finished body must be ${VERIFY_DATA_LEN} bytes, got ${body.length}`);
+    }
+    return { verifyData: body.slice() };
+  }
+};
+const FINISHED_VERIFY_DATA_LEN = VERIFY_DATA_LEN;
+//# sourceMappingURL=FinishedMessage.js.map

package/dist/cjs/dtls/handshake/FinishedMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/FinishedMessage.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAA8B;AAC9B,yBAA0B;AAd1B;AAAA;AAAA;AAAA;AAAA;AAgBA,MAAM,kBAAkB;AAEjB,MAAM,kBAAkB;AAAA,EAC3B,MAAM,YAAoC;AACtC,QAAI,WAAW,WAAW,iBAAiB;AACvC,YAAM,IAAI,6BAAc,gCAAgC,eAAe,eAAe,WAAW,MAAM,EAAE;AAAA,IAC7G;AAEA,WAAO,WAAW,MAAM;AAAA,EAC5B;AAAA,EAEA,MAAM,MAA8C;AAChD,QAAI,KAAK,WAAW,iBAAiB;AACjC,YAAM,IAAI,6BAAU,yBAAyB,eAAe,eAAe,KAAK,MAAM,EAAE;AAAA,IAC5F;AACA,WAAO,EAAE,YAAY,KAAK,MAAM,EAAE;AAAA,EACtC;AACJ;AAEO,MAAM,2BAA2B;",
+  "names": []
+}

package/dist/cjs/dtls/handshake/HandshakeMessage.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { HandshakeType } from "./HandshakeType.js";
+/** Length of the DTLS 1.2 handshake message header (RFC 6347 §4.2.2). */
+export declare const DTLS_HANDSHAKE_HEADER_LEN = 12;
+/** Length of the TLS 1.2 handshake message header (RFC 5246 §7.4). */
+export declare const TLS_HANDSHAKE_HEADER_LEN = 4;
+/** Maximum value representable in a 24-bit unsigned big-endian field. */
+export declare const UINT24_MAX: number;
+/**
+ * One full (unfragmented) DTLS 1.2 handshake message (RFC 6347 §4.2.2). For the
+ * EC-JPAKE handshake we never produce or consume fragmented handshake messages
+ * — every flight fits in the conservative 1280-byte UDP MTU when measured per
+ * record, and mbedTLS does not fragment the messages we exchange — so the
+ * `fragment_offset` is always 0 and `fragment_length` always equals `length`.
+ *
+ * For a fragmented message the body would be only `fragment_length` bytes long;
+ * fragmented input is rejected by {@link HandshakeMessage.decode} until we need
+ * it. (Sub-batch 5 will add a reassembler if real-world traces ever fragment.)
+ */
+export interface HandshakeMessage {
+    msgType: HandshakeType;
+    messageSeq: number;
+    body: Uint8Array;
+}
+/**
+ * DTLS 1.2 handshake message envelope codec (RFC 6347 §4.2.2).
+ *
+ * `encode` produces the wire form: `type(1) || length(3) || message_seq(2) ||
+ * fragment_offset(3) || fragment_length(3) || body`. We always emit the
+ * unfragmented form (`fragment_offset=0`, `fragment_length=body.length`).
+ *
+ * `encodeForTranscript` emits the **full DTLS 1.2 form** — same 12-byte header
+ * as `encode` — required by the running handshake-transcript hash. mbedTLS
+ * (and OpenThread BRs built on it) feed the full DTLS handshake bytes
+ * including `message_seq` / `fragment_offset` / `fragment_length` into the
+ * Finished MAC; an earlier reading of RFC 6347 §4.2.6 incorrectly suggested
+ * stripping them. The `fragment_offset`/`fragment_length` are normalised to
+ * the unfragmented form (0 / body.length) regardless of how the message was
+ * actually fragmented on the wire (RFC 6347 §4.2.6 second paragraph).
+ *
+ * `decode` parses one DTLS handshake message off the front of the buffer; it
+ * requires the message to be unfragmented (`fragment_offset=0`,
+ * `fragment_length=length`).
+ */
+export declare namespace HandshakeMessage {
+    function encode(message: HandshakeMessage): Uint8Array;
+    function encodeForTranscript(message: HandshakeMessage): Uint8Array;
+    interface DecodeResult {
+        message: HandshakeMessage;
+        consumed: number;
+    }
+    function decode(bytes: Uint8Array): DecodeResult;
+}
+//# sourceMappingURL=HandshakeMessage.d.ts.map

package/dist/cjs/dtls/handshake/HandshakeMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandshakeMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/HandshakeMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,aAAa,EAAmB,MAAM,oBAAoB,CAAC;AAEpE,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,sEAAsE;AACtE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,yEAAyE;AACzE,eAAO,MAAM,UAAU,QAAgB,CAAC;AAKxC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;CACpB;AAqBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yBAAiB,gBAAgB,CAAC,CAAC;IAC/B,SAAgB,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU,CAmB5D;IAED,SAAgB,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU,CAEzE;IAED,UAAiB,YAAY;QACzB,OAAO,EAAE,gBAAgB,CAAC;QAC1B,QAAQ,EAAE,MAAM,CAAC;KACpB;IAED,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAiCtD;CACJ"}