@matter/protocol 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/session/case/CaseClient.js

@@ -0,0 +1,216 @@
+"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 CaseClient_exports = {};
+__export(CaseClient_exports, {
+  CaseClient: () => CaseClient
+});
+module.exports = __toCommonJS(CaseClient_exports);
+var import_general = require("#general");
+var import_CertificateManager = require("../../certificate/CertificateManager.js");
+var import_CaseMessages = require("./CaseMessages.js");
+var import_CaseMessenger = require("./CaseMessenger.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("CaseClient");
+class CaseClient {
+  #sessions;
+  constructor(sessions) {
+    this.#sessions = sessions;
+  }
+  async pair(exchange, fabric, peerNodeId, expectedProcessingTimeMs) {
+    const messenger = new import_CaseMessenger.CaseClientMessenger(exchange, expectedProcessingTimeMs);
+    const initiatorRandom = import_general.Crypto.getRandom();
+    const initiatorSessionId = await this.#sessions.getNextAvailableSessionId();
+    const { operationalIdentityProtectionKey, operationalCert: nodeOpCert, intermediateCACert } = fabric;
+    const { publicKey: initiatorEcdhPublicKey, ecdh } = import_general.Crypto.ecdhGeneratePublicKey();
+    let sigma1Bytes;
+    let resumed = false;
+    let resumptionRecord = this.#sessions.findResumptionRecordByAddress(fabric.addressOf(peerNodeId));
+    if (resumptionRecord !== void 0) {
+      const { sharedSecret, resumptionId } = resumptionRecord;
+      const resumeKey = await import_general.Crypto.hkdf(
+        sharedSecret,
+        import_general.Bytes.concat(initiatorRandom, resumptionId),
+        import_CaseMessages.KDFSR1_KEY_INFO
+      );
+      const initiatorResumeMic = import_general.Crypto.encrypt(resumeKey, new Uint8Array(0), import_CaseMessages.RESUME1_MIC_NONCE);
+      sigma1Bytes = await messenger.sendSigma1({
+        initiatorSessionId,
+        destinationId: fabric.getDestinationId(peerNodeId, initiatorRandom),
+        initiatorEcdhPublicKey,
+        initiatorRandom,
+        resumptionId,
+        initiatorResumeMic,
+        initiatorSessionParams: this.#sessions.sessionParameters
+      });
+    } else {
+      sigma1Bytes = await messenger.sendSigma1({
+        initiatorSessionId,
+        destinationId: fabric.getDestinationId(peerNodeId, initiatorRandom),
+        initiatorEcdhPublicKey,
+        initiatorRandom,
+        initiatorSessionParams: this.#sessions.sessionParameters
+      });
+    }
+    let secureSession;
+    const { sigma2Bytes, sigma2, sigma2Resume } = await messenger.readSigma2();
+    if (sigma2Resume !== void 0) {
+      if (resumptionRecord === void 0) throw new import_general.UnexpectedDataError("Received an unexpected sigma2Resume.");
+      const { sharedSecret, fabric: fabric2, sessionParameters: resumptionSessionParams } = resumptionRecord;
+      const { responderSessionId: peerSessionId, resumptionId, resumeMic } = sigma2Resume;
+      const sessionParameters = {
+        ...exchange.session.parameters,
+        ...resumptionSessionParams ?? {}
+      };
+      const resumeSalt = import_general.Bytes.concat(initiatorRandom, resumptionId);
+      const resumeKey = await import_general.Crypto.hkdf(sharedSecret, resumeSalt, import_CaseMessages.KDFSR2_KEY_INFO);
+      import_general.Crypto.decrypt(resumeKey, resumeMic, import_CaseMessages.RESUME2_MIC_NONCE);
+      const secureSessionSalt = import_general.Bytes.concat(initiatorRandom, resumptionRecord.resumptionId);
+      secureSession = await this.#sessions.createSecureSession({
+        sessionId: initiatorSessionId,
+        fabric: fabric2,
+        peerNodeId,
+        peerSessionId,
+        sharedSecret,
+        salt: secureSessionSalt,
+        isInitiator: true,
+        isResumption: true,
+        peerSessionParameters: sessionParameters
+      });
+      await messenger.sendSuccess();
+      logger.info(
+        `Case client: session resumed with ${messenger.getChannelName()} and parameters`,
+        import_general.Diagnostic.dict(secureSession.parameters)
+      );
+      resumptionRecord.resumptionId = resumptionId;
+      resumptionRecord.sessionParameters = secureSession.parameters;
+      resumed = true;
+    } else {
+      const {
+        responderEcdhPublicKey: peerEcdhPublicKey,
+        encrypted: peerEncrypted,
+        responderRandom,
+        responderSessionId: peerSessionId,
+        responderSessionParams
+      } = sigma2;
+      const sessionParameters = {
+        ...exchange.session.parameters,
+        ...responderSessionParams ?? {}
+      };
+      const sharedSecret = import_general.Crypto.ecdhGenerateSecret(peerEcdhPublicKey, ecdh);
+      const sigma2Salt = import_general.Bytes.concat(
+        operationalIdentityProtectionKey,
+        responderRandom,
+        peerEcdhPublicKey,
+        import_general.Crypto.hash(sigma1Bytes)
+      );
+      const sigma2Key = await import_general.Crypto.hkdf(sharedSecret, sigma2Salt, import_CaseMessages.KDFSR2_INFO);
+      const peerEncryptedData = import_general.Crypto.decrypt(sigma2Key, peerEncrypted, import_CaseMessages.TBE_DATA2_NONCE);
+      const {
+        nodeOpCert: peerNewOpCert,
+        intermediateCACert: peerIntermediateCACert,
+        signature: peerSignature,
+        resumptionId: peerResumptionId
+      } = import_CaseMessages.TlvEncryptedDataSigma2.decode(peerEncryptedData);
+      const peerSignatureData = import_CaseMessages.TlvSignedData.encode({
+        nodeOpCert: peerNewOpCert,
+        intermediateCACert: peerIntermediateCACert,
+        ecdhPublicKey: peerEcdhPublicKey,
+        peerEcdhPublicKey: initiatorEcdhPublicKey
+      });
+      const {
+        ellipticCurvePublicKey: peerPublicKey,
+        subject: { fabricId: peerFabricIdNOCert, nodeId: peerNodeIdNOCert }
+      } = import_CertificateManager.TlvOperationalCertificate.decode(peerNewOpCert);
+      import_general.Crypto.verify((0, import_general.PublicKey)(peerPublicKey), peerSignatureData, peerSignature);
+      if (peerNodeIdNOCert !== peerNodeId) {
+        throw new import_general.UnexpectedDataError(
+          "The node ID in the peer certificate doesn't match the expected peer node ID"
+        );
+      }
+      if (peerNodeIdNOCert !== peerNodeId) {
+        throw new import_general.UnexpectedDataError(
+          "The node ID in the peer certificate doesn't match the expected peer node ID"
+        );
+      }
+      if (peerFabricIdNOCert !== fabric.fabricId) {
+        throw new import_general.UnexpectedDataError(
+          "The fabric ID in the peer certificate doesn't match the expected fabric ID"
+        );
+      }
+      if (peerIntermediateCACert !== void 0) {
+        const {
+          subject: { fabricId: peerFabricIdIcaCert }
+        } = import_CertificateManager.TlvIntermediateCertificate.decode(peerIntermediateCACert);
+        if (peerFabricIdIcaCert !== fabric.fabricId) {
+          throw new import_general.UnexpectedDataError(
+            "The fabric ID in the peer intermediate CA certificate doesn't match the expected fabric ID"
+          );
+        }
+      }
+      fabric.verifyCredentials(peerNewOpCert, peerIntermediateCACert);
+      const sigma3Salt = import_general.Bytes.concat(operationalIdentityProtectionKey, import_general.Crypto.hash([sigma1Bytes, sigma2Bytes]));
+      const sigma3Key = await import_general.Crypto.hkdf(sharedSecret, sigma3Salt, import_CaseMessages.KDFSR3_INFO);
+      const signatureData = import_CaseMessages.TlvSignedData.encode({
+        nodeOpCert,
+        intermediateCACert,
+        ecdhPublicKey: initiatorEcdhPublicKey,
+        peerEcdhPublicKey
+      });
+      const signature = fabric.sign(signatureData);
+      const encryptedData = import_CaseMessages.TlvEncryptedDataSigma3.encode({ nodeOpCert, intermediateCACert, signature });
+      const encrypted = import_general.Crypto.encrypt(sigma3Key, encryptedData, import_CaseMessages.TBE_DATA3_NONCE);
+      const sigma3Bytes = await messenger.sendSigma3({ encrypted });
+      await messenger.waitForSuccess("Success after CASE Sigma3");
+      const secureSessionSalt = import_general.Bytes.concat(
+        operationalIdentityProtectionKey,
+        import_general.Crypto.hash([sigma1Bytes, sigma2Bytes, sigma3Bytes])
+      );
+      secureSession = await this.#sessions.createSecureSession({
+        sessionId: initiatorSessionId,
+        fabric,
+        peerNodeId,
+        peerSessionId,
+        sharedSecret,
+        salt: secureSessionSalt,
+        isInitiator: true,
+        isResumption: false,
+        peerSessionParameters: sessionParameters
+      });
+      logger.info(
+        `Case client: Paired successfully with ${messenger.getChannelName()} and parameters`,
+        import_general.Diagnostic.dict(secureSession.parameters)
+      );
+      resumptionRecord = {
+        fabric,
+        peerNodeId,
+        sharedSecret,
+        resumptionId: peerResumptionId,
+        sessionParameters: secureSession.parameters
+      };
+    }
+    await messenger.close();
+    await this.#sessions.saveResumptionRecord(resumptionRecord);
+    return { session: secureSession, resumed };
+  }
+}
+//# sourceMappingURL=CaseClient.js.map

package/dist/cjs/session/case/CaseClient.js.map

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

package/dist/cjs/session/case/CaseMessages.d.ts

@@ -0,0 +1,82 @@
+export declare const KDFSR1_KEY_INFO: Uint8Array;
+export declare const KDFSR2_KEY_INFO: Uint8Array;
+export declare const RESUME1_MIC_NONCE: Uint8Array;
+export declare const RESUME2_MIC_NONCE: Uint8Array;
+export declare const KDFSR2_INFO: Uint8Array;
+export declare const KDFSR3_INFO: Uint8Array;
+export declare const TBE_DATA2_NONCE: Uint8Array;
+export declare const TBE_DATA3_NONCE: Uint8Array;
+/** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
+export declare const TlvCaseSigma1: import("#types").ObjectSchema<{
+    initiatorRandom: import("#types").FieldType<Uint8Array>;
+    initiatorSessionId: import("#types").FieldType<number>;
+    destinationId: import("#types").FieldType<Uint8Array>;
+    initiatorEcdhPublicKey: import("#types").FieldType<Uint8Array>;
+    initiatorSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+        idleIntervalMs: import("#types").OptionalFieldType<number>;
+        activeIntervalMs: import("#types").OptionalFieldType<number>;
+        activeThresholdMs: import("#types").OptionalFieldType<number>;
+        dataModelRevision: import("#types").OptionalFieldType<number>;
+        interactionModelRevision: import("#types").OptionalFieldType<number>;
+        specificationVersion: import("#types").OptionalFieldType<number>;
+        maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+    }>>;
+    resumptionId: import("#types").OptionalFieldType<Uint8Array>;
+    initiatorResumeMic: import("#types").OptionalFieldType<Uint8Array>;
+}>;
+/** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
+export declare const TlvCaseSigma2: import("#types").ObjectSchema<{
+    responderRandom: import("#types").FieldType<Uint8Array>;
+    responderSessionId: import("#types").FieldType<number>;
+    responderEcdhPublicKey: import("#types").FieldType<Uint8Array>;
+    encrypted: import("#types").FieldType<Uint8Array>;
+    responderSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+        idleIntervalMs: import("#types").OptionalFieldType<number>;
+        activeIntervalMs: import("#types").OptionalFieldType<number>;
+        activeThresholdMs: import("#types").OptionalFieldType<number>;
+        dataModelRevision: import("#types").OptionalFieldType<number>;
+        interactionModelRevision: import("#types").OptionalFieldType<number>;
+        specificationVersion: import("#types").OptionalFieldType<number>;
+        maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+    }>>;
+}>;
+/** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
+export declare const TlvCaseSigma2Resume: import("#types").ObjectSchema<{
+    resumptionId: import("#types").FieldType<Uint8Array>;
+    resumeMic: import("#types").FieldType<Uint8Array>;
+    responderSessionId: import("#types").FieldType<number>;
+    responderSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+        idleIntervalMs: import("#types").OptionalFieldType<number>;
+        activeIntervalMs: import("#types").OptionalFieldType<number>;
+        activeThresholdMs: import("#types").OptionalFieldType<number>;
+        dataModelRevision: import("#types").OptionalFieldType<number>;
+        interactionModelRevision: import("#types").OptionalFieldType<number>;
+        specificationVersion: import("#types").OptionalFieldType<number>;
+        maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+    }>>;
+}>;
+/** @see {@link MatterSpecification.v13.Core} § 4.14.2.3 */
+export declare const TlvCaseSigma3: import("#types").ObjectSchema<{
+    encrypted: import("#types").FieldType<Uint8Array>;
+}>;
+/** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
+export declare const TlvSignedData: import("#types").ObjectSchema<{
+    nodeOpCert: import("#types").FieldType<Uint8Array>;
+    intermediateCACert: import("#types").OptionalFieldType<Uint8Array>;
+    ecdhPublicKey: import("#types").FieldType<Uint8Array>;
+    peerEcdhPublicKey: import("#types").FieldType<Uint8Array>;
+}>;
+/** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
+export declare const TlvEncryptedDataSigma2: import("#types").ObjectSchema<{
+    nodeOpCert: import("#types").FieldType<Uint8Array>;
+    intermediateCACert: import("#types").OptionalFieldType<Uint8Array>;
+    signature: import("#types").FieldType<Uint8Array>;
+    resumptionId: import("#types").FieldType<Uint8Array>;
+}>;
+/** @see {@link MatterSpecification.v10.Core} § 4.13.2.3 */
+export declare const TlvEncryptedDataSigma3: import("#types").ObjectSchema<{
+    nodeOpCert: import("#types").FieldType<Uint8Array>;
+    intermediateCACert: import("#types").OptionalFieldType<Uint8Array>;
+    signature: import("#types").FieldType<Uint8Array>;
+}>;
+//# sourceMappingURL=CaseMessages.d.ts.map

package/dist/cjs/session/case/CaseMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseMessages.d.ts","sourceRoot":"","sources":["../../../../src/session/case/CaseMessages.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,eAAe,YAAoC,CAAC;AACjE,eAAO,MAAM,eAAe,YAAoC,CAAC;AACjE,eAAO,MAAM,iBAAiB,YAAoC,CAAC;AACnE,eAAO,MAAM,iBAAiB,YAAoC,CAAC;AACnE,eAAO,MAAM,WAAW,YAA6B,CAAC;AACtD,eAAO,MAAM,WAAW,YAA6B,CAAC;AACtD,eAAO,MAAM,eAAe,YAAoC,CAAC;AACjE,eAAO,MAAM,eAAe,YAAoC,CAAC;AAEjE,2DAA2D;AAC3D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;EAQxB,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;EAMxB,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;EAK9B,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa;;EAExB,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB;;;;;EAKjC,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,sBAAsB;;;;EAIjC,CAAC"}

package/dist/cjs/session/case/CaseMessages.js

@@ -0,0 +1,97 @@
+"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 CaseMessages_exports = {};
+__export(CaseMessages_exports, {
+  KDFSR1_KEY_INFO: () => KDFSR1_KEY_INFO,
+  KDFSR2_INFO: () => KDFSR2_INFO,
+  KDFSR2_KEY_INFO: () => KDFSR2_KEY_INFO,
+  KDFSR3_INFO: () => KDFSR3_INFO,
+  RESUME1_MIC_NONCE: () => RESUME1_MIC_NONCE,
+  RESUME2_MIC_NONCE: () => RESUME2_MIC_NONCE,
+  TBE_DATA2_NONCE: () => TBE_DATA2_NONCE,
+  TBE_DATA3_NONCE: () => TBE_DATA3_NONCE,
+  TlvCaseSigma1: () => TlvCaseSigma1,
+  TlvCaseSigma2: () => TlvCaseSigma2,
+  TlvCaseSigma2Resume: () => TlvCaseSigma2Resume,
+  TlvCaseSigma3: () => TlvCaseSigma3,
+  TlvEncryptedDataSigma2: () => TlvEncryptedDataSigma2,
+  TlvEncryptedDataSigma3: () => TlvEncryptedDataSigma3,
+  TlvSignedData: () => TlvSignedData
+});
+module.exports = __toCommonJS(CaseMessages_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_PaseMessages = require("../pase/PaseMessages.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const CASE_SIGNATURE_LENGTH = import_general.CRYPTO_GROUP_SIZE_BYTES * 2;
+const KDFSR1_KEY_INFO = import_general.Bytes.fromString("Sigma1_Resume");
+const KDFSR2_KEY_INFO = import_general.Bytes.fromString("Sigma2_Resume");
+const RESUME1_MIC_NONCE = import_general.Bytes.fromString("NCASE_SigmaS1");
+const RESUME2_MIC_NONCE = import_general.Bytes.fromString("NCASE_SigmaS2");
+const KDFSR2_INFO = import_general.Bytes.fromString("Sigma2");
+const KDFSR3_INFO = import_general.Bytes.fromString("Sigma3");
+const TBE_DATA2_NONCE = import_general.Bytes.fromString("NCASE_Sigma2N");
+const TBE_DATA3_NONCE = import_general.Bytes.fromString("NCASE_Sigma3N");
+const TlvCaseSigma1 = (0, import_types.TlvObject)({
+  initiatorRandom: (0, import_types.TlvField)(1, import_types.TlvByteString.bound({ length: 32 })),
+  initiatorSessionId: (0, import_types.TlvField)(2, import_types.TlvUInt16),
+  destinationId: (0, import_types.TlvField)(3, import_types.TlvByteString.bound({ length: import_general.CRYPTO_HASH_LEN_BYTES })),
+  initiatorEcdhPublicKey: (0, import_types.TlvField)(4, import_types.TlvByteString.bound({ length: import_general.CRYPTO_PUBLIC_KEY_SIZE_BYTES })),
+  initiatorSessionParams: (0, import_types.TlvOptionalField)(5, import_PaseMessages.TlvSessionParameters),
+  resumptionId: (0, import_types.TlvOptionalField)(6, import_types.TlvByteString.bound({ length: 16 })),
+  initiatorResumeMic: (0, import_types.TlvOptionalField)(7, import_types.TlvByteString.bound({ length: import_general.CRYPTO_AEAD_MIC_LENGTH_BYTES }))
+});
+const TlvCaseSigma2 = (0, import_types.TlvObject)({
+  responderRandom: (0, import_types.TlvField)(1, import_types.TlvByteString.bound({ length: 32 })),
+  responderSessionId: (0, import_types.TlvField)(2, import_types.TlvUInt16),
+  responderEcdhPublicKey: (0, import_types.TlvField)(3, import_types.TlvByteString.bound({ length: import_general.CRYPTO_PUBLIC_KEY_SIZE_BYTES })),
+  encrypted: (0, import_types.TlvField)(4, import_types.TlvByteString),
+  responderSessionParams: (0, import_types.TlvOptionalField)(5, import_PaseMessages.TlvSessionParameters)
+});
+const TlvCaseSigma2Resume = (0, import_types.TlvObject)({
+  resumptionId: (0, import_types.TlvField)(1, import_types.TlvByteString.bound({ length: 16 })),
+  resumeMic: (0, import_types.TlvField)(2, import_types.TlvByteString.bound({ length: 16 })),
+  responderSessionId: (0, import_types.TlvField)(3, import_types.TlvUInt16),
+  responderSessionParams: (0, import_types.TlvOptionalField)(4, import_PaseMessages.TlvSessionParameters)
+});
+const TlvCaseSigma3 = (0, import_types.TlvObject)({
+  encrypted: (0, import_types.TlvField)(1, import_types.TlvByteString)
+});
+const TlvSignedData = (0, import_types.TlvObject)({
+  nodeOpCert: (0, import_types.TlvField)(1, import_types.TlvByteString),
+  intermediateCACert: (0, import_types.TlvOptionalField)(2, import_types.TlvByteString),
+  ecdhPublicKey: (0, import_types.TlvField)(3, import_types.TlvByteString.bound({ length: import_general.CRYPTO_PUBLIC_KEY_SIZE_BYTES })),
+  peerEcdhPublicKey: (0, import_types.TlvField)(4, import_types.TlvByteString.bound({ length: import_general.CRYPTO_PUBLIC_KEY_SIZE_BYTES }))
+});
+const TlvEncryptedDataSigma2 = (0, import_types.TlvObject)({
+  nodeOpCert: (0, import_types.TlvField)(1, import_types.TlvByteString),
+  intermediateCACert: (0, import_types.TlvOptionalField)(2, import_types.TlvByteString),
+  signature: (0, import_types.TlvField)(3, import_types.TlvByteString.bound({ length: CASE_SIGNATURE_LENGTH })),
+  resumptionId: (0, import_types.TlvField)(4, import_types.TlvByteString.bound({ length: 16 }))
+});
+const TlvEncryptedDataSigma3 = (0, import_types.TlvObject)({
+  nodeOpCert: (0, import_types.TlvField)(1, import_types.TlvByteString),
+  intermediateCACert: (0, import_types.TlvOptionalField)(2, import_types.TlvByteString),
+  signature: (0, import_types.TlvField)(3, import_types.TlvByteString.bound({ length: CASE_SIGNATURE_LENGTH }))
+});
+//# sourceMappingURL=CaseMessages.js.map

package/dist/cjs/session/case/CaseMessages.js.map

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

package/dist/cjs/session/case/CaseMessenger.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TypeFromSchema } from "#types";
+import { SecureChannelMessenger } from "../../securechannel/SecureChannelMessenger.js";
+import { TlvCaseSigma1, TlvCaseSigma2, TlvCaseSigma2Resume, TlvCaseSigma3 } from "./CaseMessages.js";
+export declare class CaseServerMessenger extends SecureChannelMessenger {
+    readSigma1(): Promise<{
+        sigma1Bytes: Uint8Array;
+        sigma1: import("#types").TypeFromFields<{
+            initiatorRandom: import("#types").FieldType<Uint8Array>;
+            initiatorSessionId: import("#types").FieldType<number>;
+            destinationId: import("#types").FieldType<Uint8Array>;
+            initiatorEcdhPublicKey: import("#types").FieldType<Uint8Array>;
+            initiatorSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+                idleIntervalMs: import("#types").OptionalFieldType<number>;
+                activeIntervalMs: import("#types").OptionalFieldType<number>;
+                activeThresholdMs: import("#types").OptionalFieldType<number>;
+                dataModelRevision: import("#types").OptionalFieldType<number>;
+                interactionModelRevision: import("#types").OptionalFieldType<number>;
+                specificationVersion: import("#types").OptionalFieldType<number>;
+                maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+            }>>;
+            resumptionId: import("#types").OptionalFieldType<Uint8Array>;
+            initiatorResumeMic: import("#types").OptionalFieldType<Uint8Array>;
+        }>;
+    }>;
+    sendSigma2(sigma2: TypeFromSchema<typeof TlvCaseSigma2>): Promise<Uint8Array>;
+    sendSigma2Resume(sigma2Resume: TypeFromSchema<typeof TlvCaseSigma2Resume>): Promise<Uint8Array>;
+    readSigma3(): Promise<{
+        sigma3Bytes: Uint8Array;
+        sigma3: import("#types").TypeFromFields<{
+            encrypted: import("#types").FieldType<Uint8Array>;
+        }>;
+    }>;
+}
+export declare class CaseClientMessenger extends SecureChannelMessenger {
+    sendSigma1(sigma1: TypeFromSchema<typeof TlvCaseSigma1>): Promise<Uint8Array>;
+    readSigma2(): Promise<{
+        sigma2Bytes: Uint8Array;
+        sigma2: import("#types").TypeFromFields<{
+            responderRandom: import("#types").FieldType<Uint8Array>;
+            responderSessionId: import("#types").FieldType<number>;
+            responderEcdhPublicKey: import("#types").FieldType<Uint8Array>;
+            encrypted: import("#types").FieldType<Uint8Array>;
+            responderSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+                idleIntervalMs: import("#types").OptionalFieldType<number>;
+                activeIntervalMs: import("#types").OptionalFieldType<number>;
+                activeThresholdMs: import("#types").OptionalFieldType<number>;
+                dataModelRevision: import("#types").OptionalFieldType<number>;
+                interactionModelRevision: import("#types").OptionalFieldType<number>;
+                specificationVersion: import("#types").OptionalFieldType<number>;
+                maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+            }>>;
+        }>;
+        sigma2Resume?: undefined;
+    } | {
+        sigma2Resume: import("#types").TypeFromFields<{
+            resumptionId: import("#types").FieldType<Uint8Array>;
+            resumeMic: import("#types").FieldType<Uint8Array>;
+            responderSessionId: import("#types").FieldType<number>;
+            responderSessionParams: import("#types").OptionalFieldType<import("#types").TypeFromFields<{
+                idleIntervalMs: import("#types").OptionalFieldType<number>;
+                activeIntervalMs: import("#types").OptionalFieldType<number>;
+                activeThresholdMs: import("#types").OptionalFieldType<number>;
+                dataModelRevision: import("#types").OptionalFieldType<number>;
+                interactionModelRevision: import("#types").OptionalFieldType<number>;
+                specificationVersion: import("#types").OptionalFieldType<number>;
+                maxPathsPerInvoke: import("#types").OptionalFieldType<number>;
+            }>>;
+        }>;
+        sigma2Bytes?: undefined;
+        sigma2?: undefined;
+    }>;
+    sendSigma3(sigma3: TypeFromSchema<typeof TlvCaseSigma3>): Promise<Uint8Array>;
+}
+//# sourceMappingURL=CaseMessenger.d.ts.map

package/dist/cjs/session/case/CaseMessenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseMessenger.d.ts","sourceRoot":"","sources":["../../../../src/session/case/CaseMessenger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAqB,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+CAA+C,CAAC;AACvF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAErG,qBAAa,mBAAoB,SAAQ,sBAAsB;IACrD,UAAU;;;;;;;;;;;;;;;;;;;;IAKhB,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,OAAO,aAAa,CAAC;IAIvD,gBAAgB,CAAC,YAAY,EAAE,cAAc,CAAC,OAAO,mBAAmB,CAAC;IAInE,UAAU;;;;;;CAInB;AAED,qBAAa,mBAAoB,SAAQ,sBAAsB;IAC3D,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,OAAO,aAAa,CAAC;IAIjD,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBhB,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,OAAO,aAAa,CAAC;CAG1D"}

package/dist/cjs/session/case/CaseMessenger.js

@@ -0,0 +1,74 @@
+"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 CaseMessenger_exports = {};
+__export(CaseMessenger_exports, {
+  CaseClientMessenger: () => CaseClientMessenger,
+  CaseServerMessenger: () => CaseServerMessenger
+});
+module.exports = __toCommonJS(CaseMessenger_exports);
+var import_general = require("#general");
+var import_types = require("#types");
+var import_SecureChannelMessenger = require("../../securechannel/SecureChannelMessenger.js");
+var import_CaseMessages = require("./CaseMessages.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class CaseServerMessenger extends import_SecureChannelMessenger.SecureChannelMessenger {
+  async readSigma1() {
+    const { payload } = await this.nextMessage("CASE Sigma1", import_types.SecureMessageType.Sigma1);
+    return { sigma1Bytes: payload, sigma1: import_CaseMessages.TlvCaseSigma1.decode(payload) };
+  }
+  sendSigma2(sigma2) {
+    return this.send(sigma2, import_types.SecureMessageType.Sigma2, import_CaseMessages.TlvCaseSigma2);
+  }
+  sendSigma2Resume(sigma2Resume) {
+    return this.send(sigma2Resume, import_types.SecureMessageType.Sigma2Resume, import_CaseMessages.TlvCaseSigma2Resume);
+  }
+  async readSigma3() {
+    const { payload } = await this.nextMessage("CASE Sigma3", import_types.SecureMessageType.Sigma3);
+    return { sigma3Bytes: payload, sigma3: import_CaseMessages.TlvCaseSigma3.decode(payload) };
+  }
+}
+class CaseClientMessenger extends import_SecureChannelMessenger.SecureChannelMessenger {
+  sendSigma1(sigma1) {
+    return this.send(sigma1, import_types.SecureMessageType.Sigma1, import_CaseMessages.TlvCaseSigma1);
+  }
+  async readSigma2() {
+    const {
+      payload,
+      payloadHeader: { messageType }
+    } = await this.nextMessage("CASE Sigma2 or Sigma2Resume");
+    switch (messageType) {
+      case import_types.SecureMessageType.Sigma2:
+        return { sigma2Bytes: payload, sigma2: import_CaseMessages.TlvCaseSigma2.decode(payload) };
+      case import_types.SecureMessageType.Sigma2Resume:
+        return { sigma2Resume: import_CaseMessages.TlvCaseSigma2Resume.decode(payload) };
+      default:
+        throw new import_general.MatterFlowError(
+          `Received unexpected message type while expecting CASE Sigma2: ${messageType}, expected: ${import_types.SecureMessageType.Sigma2} or ${import_types.SecureMessageType.Sigma2Resume}`
+        );
+    }
+  }
+  sendSigma3(sigma3) {
+    return this.send(sigma3, import_types.SecureMessageType.Sigma3, import_CaseMessages.TlvCaseSigma3);
+  }
+}
+//# sourceMappingURL=CaseMessenger.js.map

package/dist/cjs/session/case/CaseMessenger.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/session/case/CaseMessenger.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAgC;AAChC,mBAAkD;AAClD,oCAAuC;AACvC,0BAAiF;AATjF;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,4BAA4B,qDAAuB;AAAA,EAC5D,MAAM,aAAa;AACf,UAAM,EAAE,QAAQ,IAAI,MAAM,KAAK,YAAY,eAAe,+BAAkB,MAAM;AAClF,WAAO,EAAE,aAAa,SAAS,QAAQ,kCAAc,OAAO,OAAO,EAAE;AAAA,EACzE;AAAA,EAEA,WAAW,QAA8C;AACrD,WAAO,KAAK,KAAK,QAAQ,+BAAkB,QAAQ,iCAAa;AAAA,EACpE;AAAA,EAEA,iBAAiB,cAA0D;AACvE,WAAO,KAAK,KAAK,cAAc,+BAAkB,cAAc,uCAAmB;AAAA,EACtF;AAAA,EAEA,MAAM,aAAa;AACf,UAAM,EAAE,QAAQ,IAAI,MAAM,KAAK,YAAY,eAAe,+BAAkB,MAAM;AAClF,WAAO,EAAE,aAAa,SAAS,QAAQ,kCAAc,OAAO,OAAO,EAAE;AAAA,EACzE;AACJ;AAEO,MAAM,4BAA4B,qDAAuB;AAAA,EAC5D,WAAW,QAA8C;AACrD,WAAO,KAAK,KAAK,QAAQ,+BAAkB,QAAQ,iCAAa;AAAA,EACpE;AAAA,EAEA,MAAM,aAAa;AACf,UAAM;AAAA,MACF;AAAA,MACA,eAAe,EAAE,YAAY;AAAA,IACjC,IAAI,MAAM,KAAK,YAAY,6BAA6B;AACxD,YAAQ,aAAa;AAAA,MACjB,KAAK,+BAAkB;AACnB,eAAO,EAAE,aAAa,SAAS,QAAQ,kCAAc,OAAO,OAAO,EAAE;AAAA,MACzE,KAAK,+BAAkB;AACnB,eAAO,EAAE,cAAc,wCAAoB,OAAO,OAAO,EAAE;AAAA,MAC/D;AACI,cAAM,IAAI;AAAA,UACN,iEAAiE,WAAW,eAAe,+BAAkB,MAAM,OAAO,+BAAkB,YAAY;AAAA,QAC5J;AAAA,IACR;AAAA,EACJ;AAAA,EAEA,WAAW,QAA8C;AACrD,WAAO,KAAK,KAAK,QAAQ,+BAAkB,QAAQ,iCAAa;AAAA,EACpE;AACJ;",
+  "names": []
+}

package/dist/cjs/session/case/CaseServer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SessionManager } from "#session/SessionManager.js";
+import { FabricManager } from "../../fabric/FabricManager.js";
+import { MessageExchange } from "../../protocol/MessageExchange.js";
+import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
+export declare class CaseServer implements ProtocolHandler {
+    #private;
+    constructor(sessions: SessionManager, fabrics: FabricManager);
+    onNewExchange(exchange: MessageExchange): Promise<void>;
+    getId(): number;
+    private handleSigma1;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=CaseServer.d.ts.map

package/dist/cjs/session/case/CaseServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseServer.d.ts","sourceRoot":"","sources":["../../../../src/session/case/CaseServer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,aAAa,EAAuB,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAmBpE,qBAAa,UAAW,YAAW,eAAe;;gBAIlC,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa;IAKtD,aAAa,CAAC,QAAQ,EAAE,eAAe;IAoB7C,KAAK,IAAI,MAAM;YAID,YAAY;IAyMpB,KAAK;CAGd"}