@matter/thread-br-client 0.0.1

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

@@ -0,0 +1,482 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ImplementationError, InternalError } from "@matter/general";
+import { DtlsError } from "../channel/DtlsChannel.js";
+import { EcJpakePms } from "../ecjpake/EcJpakePms.js";
+import { ECJPAKE_ID_CLIENT, ECJPAKE_ID_SERVER, EcJpakeRound } from "../ecjpake/EcJpakeRound.js";
+import { SchnorrZkp } from "../ecjpake/SchnorrZkp.js";
+import { HandshakeTranscript } from "../prf/HandshakeTranscript.js";
+import { TlsPrf } from "../prf/TlsPrf.js";
+import { ContentType } from "../record/ContentType.js";
+import { DtlsCipherState } from "../record/DtlsCipherState.js";
+import { DtlsRecord } from "../record/DtlsRecord.js";
+import { CHANGE_CIPHER_SPEC_BODY, ChangeCipherSpec } from "./ChangeCipherSpec.js";
+import { ClientHelloMessage } from "./ClientHelloMessage.js";
+import { ClientKeyExchangeMessage } from "./ClientKeyExchangeMessage.js";
+import { FINISHED_VERIFY_DATA_LEN, FinishedMessage } from "./FinishedMessage.js";
+import { HandshakeMessage } from "./HandshakeMessage.js";
+import { HandshakeType } from "./HandshakeType.js";
+import { HelloVerifyRequestMessage } from "./HelloVerifyRequestMessage.js";
+import { ServerHelloDoneMessage } from "./ServerHelloDoneMessage.js";
+import { ServerHelloMessage } from "./ServerHelloMessage.js";
+import { ServerKeyExchangeMessage } from "./ServerKeyExchangeMessage.js";
+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 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 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 ImplementationError(`DtlsClient.start() called in state '${this.#state}'`);
+    }
+    const random = this.#config.random();
+    if (random.length !== RANDOM_LEN) {
+      throw new 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 = EcJpakeRound.buildRound1({ x1, x2, v1, v2, id: ECJPAKE_ID_CLIENT });
+    this.#x2 = x2;
+    this.#X1 = round1.kp1.X;
+    this.#X2 = round1.kp2.X;
+    this.#round1Bytes = 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 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 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 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 } = 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 !== ContentType.HANDSHAKE) {
+        continue;
+      }
+      let p = 0;
+      while (p < rec.fragment.length) {
+        const { message, consumed } = HandshakeMessage.decode(rec.fragment.subarray(p));
+        out.push({
+          msgType: message.msgType,
+          body: message.body,
+          transcriptBytes: HandshakeMessage.encodeForTranscript(message)
+        });
+        p += consumed;
+      }
+    }
+    return out;
+  }
+  // -----------------------------------------------------------------------
+  // Outbound encoding helpers
+  #emitClientHello(cookie, contributesToTranscript) {
+    const body = ClientHelloMessage.build({
+      random: this.#clientRandom,
+      cookie,
+      ecjpakeKkpp: this.#round1Bytes
+    });
+    const handshake = HandshakeMessage.encode({
+      msgType: HandshakeType.CLIENT_HELLO,
+      messageSeq: this.#handshakeMessageSeq,
+      body
+    });
+    if (contributesToTranscript) {
+      this.#transcript.appendHandshakeMessage(
+        HandshakeMessage.encodeForTranscript({
+          msgType: HandshakeType.CLIENT_HELLO,
+          messageSeq: this.#handshakeMessageSeq,
+          body
+        })
+      );
+    }
+    const record = DtlsRecord.encode({
+      type: 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 DtlsError("DtlsClient: expected handshake message, got none");
+    }
+    if (messages[0].msgType === HandshakeType.HELLO_VERIFY_REQUEST) {
+      const { cookie } = HelloVerifyRequestMessage.parse(messages[0].body);
+      this.#transcript = new HandshakeTranscript();
+      const records2 = this.#emitClientHello(cookie, true);
+      this.#state = "sent_clienthello_with_cookie";
+      return { records: records2 };
+    }
+    this.#transcript = new HandshakeTranscript();
+    const firstHelloBody = ClientHelloMessage.build({
+      random: this.#clientRandom,
+      cookie: new Uint8Array(0),
+      ecjpakeKkpp: this.#round1Bytes
+    });
+    this.#transcript.appendHandshakeMessage(
+      HandshakeMessage.encodeForTranscript({
+        msgType: 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 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 DtlsError(
+        `DtlsClient: server flight has ${rest.length} unexpected trailing handshake message(s)`
+      );
+    }
+    if (sh.msgType !== HandshakeType.SERVER_HELLO) {
+      throw new DtlsError(`DtlsClient: expected ServerHello, got msg_type=${sh.msgType}`);
+    }
+    if (ske.msgType !== HandshakeType.SERVER_KEY_EXCHANGE) {
+      throw new DtlsError(`DtlsClient: expected ServerKeyExchange, got msg_type=${ske.msgType}`);
+    }
+    if (shd.msgType !== HandshakeType.SERVER_HELLO_DONE) {
+      throw new DtlsError(`DtlsClient: expected ServerHelloDone, got msg_type=${shd.msgType}`);
+    }
+    const parsedSh = ServerHelloMessage.parse(sh.body);
+    this.#serverRandom = parsedSh.serverRandom;
+    const serverRound1 = EcJpakeRound.parseRound1(parsedSh.ecjpakeKkpp);
+    this.#X3 = serverRound1.kp1.X;
+    this.#X4 = serverRound1.kp2.X;
+    if (!SchnorrZkp.verify({
+      zkp: serverRound1.kp1.zkp,
+      publicKey: serverRound1.kp1.X,
+      id: ECJPAKE_ID_SERVER
+    })) {
+      throw new DtlsError("DtlsClient: server round-1 KP1 ZKP verification failed");
+    }
+    if (!SchnorrZkp.verify({
+      zkp: serverRound1.kp2.zkp,
+      publicKey: serverRound1.kp2.X,
+      id: ECJPAKE_ID_SERVER
+    })) {
+      throw new DtlsError("DtlsClient: server round-1 KP2 ZKP verification failed");
+    }
+    const skeKp = ServerKeyExchangeMessage.parse(ske.body);
+    const serverGenerator = EcJpakeRound.composeRound2Generator({
+      Xp1: this.#X1,
+      Xp2: this.#X2,
+      Xm1: this.#X3
+    });
+    if (!EcJpakeRound.verifyRound2Zkp({
+      kp: skeKp,
+      generator: serverGenerator,
+      peerId: ECJPAKE_ID_SERVER
+    })) {
+      throw new DtlsError("DtlsClient: server round-2 ZKP verification failed");
+    }
+    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 InternalError("DtlsClient: emitClientFlight called before server flight was parsed");
+    }
+    const s = bigintFromBE(this.#config.password);
+    const v3 = this.#config.ephemeralScalar();
+    const clientGenerator = EcJpakeRound.composeRound2Generator({
+      Xp1: this.#X3,
+      Xp2: this.#X4,
+      Xm1: this.#X1
+    });
+    const clientRound2 = EcJpakeRound.buildRound2({
+      xm2: this.#x2,
+      s,
+      v: v3,
+      id: ECJPAKE_ID_CLIENT,
+      generator: clientGenerator
+    });
+    const ckeBody = ClientKeyExchangeMessage.build(clientRound2);
+    const ckeMsgSeq = this.#handshakeMessageSeq;
+    const ckeHandshake = HandshakeMessage.encode({
+      msgType: HandshakeType.CLIENT_KEY_EXCHANGE,
+      messageSeq: ckeMsgSeq,
+      body: ckeBody
+    });
+    this.#handshakeMessageSeq += 1;
+    this.#transcript.appendHandshakeMessage(
+      HandshakeMessage.encodeForTranscript({
+        msgType: HandshakeType.CLIENT_KEY_EXCHANGE,
+        messageSeq: ckeMsgSeq,
+        body: ckeBody
+      })
+    );
+    const pms = EcJpakePms.derive({
+      Xp: serverRound2X,
+      Xp2: this.#X4,
+      xm2: this.#x2,
+      s
+    });
+    const masterSecret = TlsPrf.masterSecret({
+      premasterSecret: pms,
+      clientRandom: this.#clientRandom,
+      serverRandom: this.#serverRandom
+    });
+    this.#masterSecret = masterSecret;
+    const keyBlock = TlsPrf.keyBlock({
+      masterSecret,
+      clientRandom: this.#clientRandom,
+      serverRandom: this.#serverRandom
+    });
+    const cipherState = new DtlsCipherState("client", {
+      clientWriteKey: keyBlock.clientWriteKey,
+      serverWriteKey: keyBlock.serverWriteKey,
+      clientWriteSalt: keyBlock.clientWriteIv,
+      serverWriteSalt: keyBlock.serverWriteIv
+    });
+    this.#cipherState = cipherState;
+    const verifyData = TlsPrf.verifyData({
+      masterSecret,
+      role: "client",
+      transcriptDigest: this.#transcript.digest()
+    });
+    const finishedBody = FinishedMessage.build(verifyData);
+    const finishedMsgSeq = this.#handshakeMessageSeq;
+    const finishedHandshake = HandshakeMessage.encode({
+      msgType: HandshakeType.FINISHED,
+      messageSeq: finishedMsgSeq,
+      body: finishedBody
+    });
+    this.#handshakeMessageSeq += 1;
+    this.#transcript.appendHandshakeMessage(
+      HandshakeMessage.encodeForTranscript({
+        msgType: HandshakeType.FINISHED,
+        messageSeq: finishedMsgSeq,
+        body: finishedBody
+      })
+    );
+    const ckeRecord = DtlsRecord.encode({
+      type: ContentType.HANDSHAKE,
+      epoch: 0,
+      sequenceNumber: this.#recordSeq,
+      fragment: ckeHandshake
+    });
+    this.#recordSeq += 1n;
+    const ccsRecord = DtlsRecord.encode({
+      type: ContentType.CHANGE_CIPHER_SPEC,
+      epoch: 0,
+      sequenceNumber: this.#recordSeq,
+      fragment: CHANGE_CIPHER_SPEC_BODY
+    });
+    this.#recordSeq += 1n;
+    cipherState.advanceWriteEpoch();
+    const finishedSeq = cipherState.nextWriteSeq();
+    const finishedRecord = DtlsRecord.encode(
+      {
+        type: 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 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 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 DtlsError("DtlsClient: DTLS record length overruns datagram");
+      }
+      const recordBytes = bytes.subarray(p, recordEnd);
+      const stateForDecode = epoch === 0 ? void 0 : cipherState;
+      const { record } = DtlsRecord.decode(recordBytes, stateForDecode);
+      if (record.type === ContentType.CHANGE_CIPHER_SPEC) {
+        ChangeCipherSpec.parse(record.fragment);
+        cipherState.advanceReadEpoch();
+        sawCcs = true;
+      } else if (record.type === ContentType.HANDSHAKE) {
+        if (!sawCcs) {
+          throw new DtlsError("DtlsClient: encrypted Finished received before ChangeCipherSpec");
+        }
+        if (record.epoch !== cipherState.readEpoch) {
+          throw new DtlsError(
+            `DtlsClient: server Finished record at epoch ${record.epoch}, expected ${cipherState.readEpoch}`
+          );
+        }
+        let q = 0;
+        while (q < record.fragment.length) {
+          const { message, consumed } = HandshakeMessage.decode(record.fragment.subarray(q));
+          if (message.msgType !== HandshakeType.FINISHED) {
+            throw new 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 DtlsError("DtlsClient: server flight missing Finished message");
+    }
+    const expected = TlsPrf.verifyData({
+      masterSecret,
+      role: "server",
+      transcriptDigest: this.#transcript.digest()
+    });
+    const actual = FinishedMessage.parse(serverFinishedBody).verifyData;
+    if (!constantTimeEqual(expected, actual)) {
+      throw new DtlsError("DtlsClient: server Finished verify_data mismatch");
+    }
+    this.#transcript.appendHandshakeMessage(
+      HandshakeMessage.encodeForTranscript({
+        msgType: HandshakeType.FINISHED,
+        messageSeq: serverFinishedMsgSeq,
+        body: serverFinishedBody
+      })
+    );
+    this.#state = "established";
+    return { records: [] };
+  }
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length || a.length !== 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;
+}
+export {
+  DtlsClient
+};
+//# sourceMappingURL=DtlsClient.js.map

package/dist/esm/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/esm/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/esm/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/esm/dtls/handshake/FinishedMessage.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+import { DtlsError } from "../channel/DtlsChannel.js";
+const VERIFY_DATA_LEN = 12;
+const FinishedMessage = {
+  build(verifyData) {
+    if (verifyData.length !== VERIFY_DATA_LEN) {
+      throw new 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 DtlsError(`Finished body must be ${VERIFY_DATA_LEN} bytes, got ${body.length}`);
+    }
+    return { verifyData: body.slice() };
+  }
+};
+const FINISHED_VERIFY_DATA_LEN = VERIFY_DATA_LEN;
+export {
+  FINISHED_VERIFY_DATA_LEN,
+  FinishedMessage
+};
+//# sourceMappingURL=FinishedMessage.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/FinishedMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,SAAS,qBAAqB;AAC9B,SAAS,iBAAiB;AAE1B,MAAM,kBAAkB;AAEjB,MAAM,kBAAkB;AAAA,EAC3B,MAAM,YAAoC;AACtC,QAAI,WAAW,WAAW,iBAAiB;AACvC,YAAM,IAAI,cAAc,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,UAAU,yBAAyB,eAAe,eAAe,KAAK,MAAM,EAAE;AAAA,IAC5F;AACA,WAAO,EAAE,YAAY,KAAK,MAAM,EAAE;AAAA,EACtC;AACJ;AAEO,MAAM,2BAA2B;",
+  "names": []
+}

package/dist/esm/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/esm/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"}