@matter/general 0.14.1-alpha.0-20250606-a9bcd03f9 → 0.15.0-alpha.0-20250612-ddd428561

package/dist/esm/crypto/StandardCrypto.js

@@ -0,0 +1,188 @@
+/**
+ * @license
+ *
+ * Portions copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DerBigUint, DerCodec, DerError } from "#codec/DerCodec.js";
+import { Boot } from "#util/Boot.js";
+import { Bytes } from "#util/Bytes.js";
+import { Ccm } from "./aes/Ccm.js";
+import { Crypto, CRYPTO_SYMMETRIC_KEY_LENGTH } from "./Crypto.js";
+import { CryptoVerifyError, KeyInputError } from "./CryptoError.js";
+import { CurveType, Key, KeyType } from "./Key.js";
+const subtle = globalThis.crypto.subtle;
+const SIGNATURE_ALGORITHM = {
+  name: "ECDSA",
+  namedCurve: "P-256",
+  hash: { name: "SHA-256" }
+};
+class StandardCrypto {
+  implementationName = "JS";
+  static provider() {
+    return new StandardCrypto();
+  }
+  getRandomData(length) {
+    const result = new Uint8Array(length);
+    crypto.getRandomValues(result);
+    return result;
+  }
+  encrypt(key, data, nonce, associatedData) {
+    const ccm = Ccm(key);
+    return ccm.encrypt({ pt: data, nonce, adata: associatedData });
+  }
+  decrypt(key, data, nonce, associatedData) {
+    const ccm = Ccm(key);
+    return ccm.decrypt({ ct: data, nonce, adata: associatedData });
+  }
+  async computeSha256(buffer) {
+    if (Array.isArray(buffer)) {
+      buffer = Bytes.concat(...buffer);
+    }
+    return new Uint8Array(await subtle.digest("SHA-256", buffer));
+  }
+  async createPbkdf2Key(secret, salt, iteration, keyLength) {
+    const key = await importKey("raw", secret, "PBKDF2", false, ["deriveBits"]);
+    const bits = await subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt,
+        iterations: iteration
+      },
+      key,
+      keyLength * 8
+    );
+    return new Uint8Array(bits);
+  }
+  async createHkdfKey(secret, salt, info, length = CRYPTO_SYMMETRIC_KEY_LENGTH) {
+    const key = await importKey("raw", secret, "HKDF", false, ["deriveBits"]);
+    const bits = await subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt,
+        info
+      },
+      key,
+      8 * length
+    );
+    return new Uint8Array(bits);
+  }
+  async signHmac(secret, data) {
+    const key = await importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    return new Uint8Array(await subtle.sign("HMAC", key, data));
+  }
+  async signEcdsa(key, data, dsaEncoding) {
+    if (Array.isArray(data)) {
+      data = Bytes.concat(...data);
+    }
+    const { crv, kty, d, x, y } = key;
+    key = {
+      kty,
+      crv,
+      d,
+      x,
+      y,
+      ext: true,
+      // Required by some subtle implementations to sign
+      key_ops: ["sign"]
+    };
+    const subtleKey = await importKey("jwk", key, SIGNATURE_ALGORITHM, false, ["sign"]);
+    const ieeeP1363 = await subtle.sign(SIGNATURE_ALGORITHM, subtleKey, data);
+    if (dsaEncoding !== "der") return new Uint8Array(ieeeP1363);
+    const bytesPerComponent = ieeeP1363.byteLength / 2;
+    return DerCodec.encode({
+      r: DerBigUint(ieeeP1363.slice(0, bytesPerComponent)),
+      s: DerBigUint(ieeeP1363.slice(bytesPerComponent))
+    });
+  }
+  async verifyEcdsa(key, data, signature, dsaEncoding) {
+    const { crv, kty, x, y } = key;
+    key = { crv, kty, x, y };
+    const subtleKey = await importKey("jwk", key, SIGNATURE_ALGORITHM, false, ["verify"]);
+    if (dsaEncoding === "der") {
+      try {
+        const decoded = DerCodec.decode(signature);
+        const r = DerCodec.decodeBigUint(decoded?._elements?.[0], 32);
+        const s = DerCodec.decodeBigUint(decoded?._elements?.[1], 32);
+        signature = Bytes.concat(r, s);
+      } catch (cause) {
+        DerError.accept(cause);
+        throw new CryptoVerifyError("Invalid DER signature", { cause });
+      }
+    }
+    const verified = await subtle.verify(SIGNATURE_ALGORITHM, subtleKey, signature, data);
+    if (!verified) {
+      throw new CryptoVerifyError("Signature verification failed");
+    }
+  }
+  async createKeyPair() {
+    const subtleKey = await subtle.generateKey(
+      {
+        // We must specify either ECDH or ECDSA to get an EC key but we may use the key for either (but not for
+        // both)
+        name: "ECDH",
+        namedCurve: "P-256"
+      },
+      true,
+      // We must also specify usage but will drop this on export
+      ["deriveKey"]
+    );
+    const key = await subtle.exportKey("jwk", subtleKey.privateKey);
+    return Key({
+      kty: KeyType.EC,
+      crv: CurveType.p256,
+      d: key.d,
+      x: key.x,
+      y: key.y
+    });
+  }
+  async generateDhSecret(key, peerKey) {
+    const subtleKey = await importKey(
+      "jwk",
+      key,
+      {
+        name: "ECDH",
+        namedCurve: "P-256"
+      },
+      false,
+      ["deriveBits"]
+    );
+    const subtlePeerKey = await importKey(
+      "jwk",
+      peerKey,
+      {
+        name: "ECDH",
+        namedCurve: "P-256"
+      },
+      false,
+      []
+    );
+    const secret = await subtle.deriveBits(
+      {
+        name: "ECDH",
+        public: subtlePeerKey
+      },
+      subtleKey,
+      256
+    );
+    return new Uint8Array(secret);
+  }
+}
+if (globalThis.crypto?.subtle?.[Symbol.toStringTag] === "SubtleCrypto") {
+  Boot.init(() => {
+    Crypto.provider = StandardCrypto.provider;
+  });
+}
+async function importKey(...params) {
+  try {
+    return await crypto.subtle.importKey(...params);
+  } catch (cause) {
+    throw new KeyInputError("Invalid key", { cause });
+  }
+}
+export {
+  StandardCrypto
+};
+//# sourceMappingURL=StandardCrypto.js.map

package/dist/esm/crypto/StandardCrypto.js.map

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

package/dist/esm/crypto/aes/Aes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * SJCL: https://github.com/bitwiseshiftleft/sjcl/blob/master/core/aes.js
+ *
+ * OpenSSL: https://github.com/openssl/openssl/blob/master/crypto/aes/aes_core.c
+ */
+import { WordArray } from "./WordArray.js";
+/**
+ * AES core block cipher implementation.
+ *
+ * WARNING: Unaudited.  Consider platform replacement if available.
+ */
+export declare function Aes(key: Uint8Array): {
+    encrypt(pt: WordArray, ct?: WordArray): WordArray;
+    decrypt(ct: WordArray, pt?: WordArray): WordArray;
+};
+//# sourceMappingURL=Aes.d.ts.map

package/dist/esm/crypto/aes/Aes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Aes.d.ts","sourceRoot":"","sources":["../../../../src/crypto/aes/Aes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,UAAU;gBAIf,SAAS;gBAIT,SAAS;EAI5B"}

package/dist/esm/crypto/aes/Aes.js

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { WordArray } from "./WordArray.js";
+function Aes(key) {
+  const { encryptKey, decryptKey } = expandKey(key);
+  return {
+    encrypt(pt, ct = pt) {
+      return crypt(pt, ct, encryptKey, Tables.enc);
+    },
+    decrypt(ct, pt = ct) {
+      return crypt(ct, pt, decryptKey, Tables.dec);
+    }
+  };
+}
+let etabs, dtabs;
+const Tables = {
+  get enc() {
+    if (!etabs) {
+      generateTables();
+    }
+    return etabs;
+  },
+  get dec() {
+    if (!dtabs) {
+      generateTables();
+    }
+    return dtabs;
+  }
+};
+const mixNames = ["mix1", "mix2", "mix3", "mix4"];
+function generateTables() {
+  etabs = Tables2();
+  dtabs = Tables2();
+  const d = Table(), th = Table();
+  let i, x, xInv, x2, x4, x8, s, tEnc, tDec;
+  for (i = 0; i < 256; i++) {
+    th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
+  }
+  for (x = xInv = 0; !etabs.sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
+    s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
+    s = s >> 8 ^ s & 255 ^ 99;
+    etabs.sbox[x] = s;
+    dtabs.sbox[s] = x;
+    x8 = d[x4 = d[x2 = d[x]]];
+    tDec = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
+    tEnc = d[s] * 257 ^ s * 16843008;
+    for (const name of mixNames) {
+      etabs[name][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
+      dtabs[name][s] = tDec = tDec << 24 ^ tDec >>> 8;
+    }
+  }
+  function Tables2() {
+    return Object.fromEntries([...mixNames, "sbox"].map((k) => [k, Table()]));
+  }
+  function Table() {
+    return WordArray(256);
+  }
+}
+function crypt(input, output, roundKeys, tabs) {
+  const decrypt = tabs === dtabs, numRounds = roundKeys.length / 4 - 2;
+  const { mix1, mix2, mix3, mix4, sbox } = tabs;
+  let a = input[0] ^ roundKeys[0], b = input[decrypt ? 3 : 1] ^ roundKeys[1], c = input[2] ^ roundKeys[2], d = input[decrypt ? 1 : 3] ^ roundKeys[3], roundKeyAt = 4;
+  for (let i = 0; i < numRounds; i++) {
+    const atemp = mix1[a >>> 24] ^ mix2[b >> 16 & 255] ^ mix3[c >> 8 & 255] ^ mix4[d & 255] ^ roundKeys[roundKeyAt++];
+    const btemp = mix1[b >>> 24] ^ mix2[c >> 16 & 255] ^ mix3[d >> 8 & 255] ^ mix4[a & 255] ^ roundKeys[roundKeyAt++];
+    const ctemp = mix1[c >>> 24] ^ mix2[d >> 16 & 255] ^ mix3[a >> 8 & 255] ^ mix4[b & 255] ^ roundKeys[roundKeyAt++];
+    d = mix1[d >>> 24] ^ mix2[a >> 16 & 255] ^ mix3[b >> 8 & 255] ^ mix4[c & 255] ^ roundKeys[roundKeyAt++];
+    a = atemp;
+    b = btemp;
+    c = ctemp;
+  }
+  for (let i = 0; i < 4; i++) {
+    output[decrypt ? 3 & -i : i] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ roundKeys[roundKeyAt++];
+    const atemp = a;
+    a = b;
+    b = c;
+    c = d;
+    d = atemp;
+  }
+  return output;
+}
+function expandKey(key) {
+  const inputLength = key.length / 4, roundsNeeded = inputLength + 7, wordsNeeded = roundsNeeded * 4, encryptKey = WordArray.fromByteArray(key, wordsNeeded), sbox = Tables.enc.sbox;
+  for (let i = inputLength, rcon = 1; i < wordsNeeded; i++) {
+    let temp = encryptKey[i - 1];
+    if (i % inputLength === 0 || inputLength === 8 && i % inputLength === 4) {
+      temp = sbox[temp >>> 24] << 24 ^ sbox[temp >> 16 & 255] << 16 ^ sbox[temp >> 8 & 255] << 8 ^ sbox[temp & 255];
+      if (i % inputLength === 0) {
+        temp = temp << 8 ^ temp >>> 24 ^ rcon << 24;
+        rcon = rcon << 1 ^ (rcon >> 7) * 283;
+      }
+    }
+    encryptKey[i] = encryptKey[i - inputLength] ^ temp;
+  }
+  const { mix1, mix2, mix3, mix4 } = Tables.dec, decryptKey = WordArray(encryptKey.length);
+  for (let i = encryptKey.length, j = 0; i; j++, i--) {
+    const tmp = encryptKey[j & 3 ? i : i - 4];
+    if (i <= 4 || j < 4) {
+      decryptKey[j] = tmp;
+    } else {
+      decryptKey[j] = mix1[sbox[tmp >>> 24]] ^ mix2[sbox[tmp >> 16 & 255]] ^ mix3[sbox[tmp >> 8 & 255]] ^ mix4[sbox[tmp & 255]];
+    }
+  }
+  return { encryptKey, decryptKey };
+}
+export {
+  Aes
+};
+//# sourceMappingURL=Aes.js.map

package/dist/esm/crypto/aes/Aes.js.map

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

package/dist/esm/crypto/aes/Ccm.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * WARNING: Unaudited.  Consider platform replacement if available.
+ *
+ * This AES-CCM implementation is tailored for Matter:
+ *
+ * * Only supports 2-byte length
+ *
+ * * Only supports 13-byte nonce
+ *
+ * * Stores the MIC in the ciphertext buffer following the ciphertext
+ *
+ * * Our AES implementation supports multiple key sizes but only 16 bytes are legal
+ *
+ * We take a few approaches to improve performance:
+ *
+ * * Uses singletons for temporary working buffers to avoid GC
+ *
+ * * Uses Uint8Array, Int32Array and DataView depending on which is most efficient while addressing platform byte order
+ *
+ * * Performs data conversion one block at a time rather than converting entire input/output buffer
+ *
+ * * Functions are monomorphic and should JIT well
+ *
+ * Implementation notes:
+ *
+ * * Data operations operate on 128-bit blocks, either as bytes or as 4 32-bit words in platform byte order.  We share
+ *   underlying memory for both formats, but on little-endian platforms they are not directly interchangeable without a
+ *   round-trip through a DataView
+ *
+ * * We encode words as a signed Int32Array because JS bit operations operate on signed 32-bit integers and a
+ *   Uint32Array would require manually casting from signed to unsigned
+ *
+ * * Use of singleton buffers require this code to be synchronous.  If that were to change we would need to convert to a
+ *   buffer pool
+ *
+ * * Some functions only modify singleton buffers and thus do not directly return a value
+ *
+ * * We use {@link DataView} to read/write words where possible.  However, byte buffers may not align to word
+ *   boundaries.  We detect this case and manually read/write the last word
+ */
+export declare function Ccm(key: Uint8Array): {
+    encrypt(input: Ccm.EncryptInput): Uint8Array;
+    decrypt(input: Ccm.DecryptInput): Uint8Array;
+};
+export declare namespace Ccm {
+    interface Input {
+        nonce: Uint8Array;
+        adata: Uint8Array | undefined;
+    }
+    interface EncryptInput extends Input {
+        /**
+         * Plaintext
+         */
+        pt: Uint8Array;
+    }
+    interface DecryptInput extends Input {
+        /**
+         * Ciphertext + tag
+         */
+        ct: Uint8Array;
+    }
+}
+export declare const BYTES_IN_LENGTH = 2;
+export declare const MAX_CIPHERTEXT_LENGTH: number;
+export declare const MAX_PLAINTEXT_LENGTH: number;
+//# sourceMappingURL=Ccm.d.ts.map

package/dist/esm/crypto/aes/Ccm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ccm.d.ts","sourceRoot":"","sources":["../../../../src/crypto/aes/Ccm.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,UAAU;mBAIZ,GAAG,CAAC,YAAY,GAAG,UAAU;mBA8B7B,GAAG,CAAC,YAAY,GAAG,UAAU;EA6JnD;AAED,yBAAiB,GAAG,CAAC;IACjB,UAAiB,KAAK;QAClB,KAAK,EAAE,UAAU,CAAC;QAClB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC;KACjC;IAED,UAAiB,YAAa,SAAQ,KAAK;QACvC;;WAEG;QACH,EAAE,EAAE,UAAU,CAAC;KAClB;IAED,UAAiB,YAAa,SAAQ,KAAK;QACvC;;WAEG;QACH,EAAE,EAAE,UAAU,CAAC;KAClB;CACJ;AAED,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AACtE,eAAO,MAAM,oBAAoB,QAAuD,CAAC"}

package/dist/esm/crypto/aes/Ccm.js

@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CRYPTO_AEAD_MIC_LENGTH_BYTES, CRYPTO_AEAD_NONCE_LENGTH_BYTES } from "#crypto/CryptoConstants.js";
+import { CryptoInputError } from "#crypto/CryptoError.js";
+import { Aes } from "./Aes.js";
+import { WordArray } from "./WordArray.js";
+function Ccm(key) {
+  const aes = Aes(key);
+  return {
+    encrypt(input) {
+      validateNonceAndAdata(input);
+      const ptLength = input.pt.length;
+      if (ptLength > MAX_PLAINTEXT_LENGTH) {
+        throw new CryptoInputError(
+          `Cannot encrypt plaintext exceeding maximum length of ${MAX_PLAINTEXT_LENGTH}`
+        );
+      }
+      const ptView = new DataView(input.pt.buffer);
+      const ct = new Uint8Array(ptLength + CRYPTO_AEAD_MIC_LENGTH_BYTES);
+      const ctView = new DataView(ct.buffer);
+      cbcMac(input, ptView, ptLength);
+      ctr(input, ptView, ctView, ptLength, computedMic);
+      for (let i = 0; i < computedMic.words.length; i++) {
+        ctView.setInt32(input.pt.length + i * 4, computedMic.words[i]);
+      }
+      return ct;
+    },
+    decrypt(input) {
+      validateNonceAndAdata(input);
+      if (input.ct.length > MAX_CIPHERTEXT_LENGTH) {
+        throw new CryptoInputError(
+          `Cannot decrypt ciphertext longer than maximum length of ${MAX_CIPHERTEXT_LENGTH}`
+        );
+      }
+      const ptLength = input.ct.length - CRYPTO_AEAD_MIC_LENGTH_BYTES;
+      if (ptLength < 0) {
+        throw new CryptoInputError(
+          `Cannot decrypt ciphertext shorter than minimum length of ${CRYPTO_AEAD_MIC_LENGTH_BYTES}`
+        );
+      }
+      const ctView = new DataView(input.ct.buffer, input.ct.byteOffset, ptLength);
+      WordArray.bytesToBlock(
+        new DataView(input.ct.buffer, input.ct.byteOffset, input.ct.byteLength),
+        inputMic.words,
+        ptLength
+      );
+      const pt = new Uint8Array(ptLength);
+      const ptView = new DataView(pt.buffer);
+      ctr(input, ctView, ptView, ptLength, inputMic);
+      cbcMac(input, ptView, ptLength);
+      for (let i = 0; i < computedMic.words.length; i++) {
+        if (inputMic.words[i] !== computedMic.words[i]) {
+          throw new CryptoInputError("Message authentication failed due to invalid signature");
+        }
+      }
+      return pt;
+    }
+  };
+  function cbcMac(input, pt, ptLength) {
+    const adataLength = input.adata?.length;
+    computedMic.bytes[0] = (adataLength ? 1 << 6 : 0) | CRYPTO_AEAD_MIC_LENGTH_BYTES - 2 << 2 | BYTES_IN_LENGTH - 1;
+    computedMic.bytes.set(input.nonce, 1);
+    WordArray.bytesToBlock(computedMic.view, computedMic.words);
+    computedMic.words[3] = computedMic.words[3] & 4294901760 | ptLength;
+    aes.encrypt(computedMic.words);
+    if (adataLength) {
+      tempBlock1.view.setInt16(0, input.adata.length);
+      for (let i = 0; i < 14; i++) {
+        tempBlock1.bytes[i + 2] = i < adataLength ? input.adata[i] : 0;
+      }
+      WordArray.bytesToBlock(tempBlock1.view, tempBlock1.words);
+      add();
+      if (adataLength > 14) {
+        const adataView = new DataView(input.adata.buffer);
+        for (let i = 14; i < adataLength; i += 16) {
+          WordArray.bytesToBlock(adataView, tempBlock1.words, i);
+          add();
+        }
+      }
+    }
+    if (ptLength) {
+      for (let i = 0; i < ptLength; i += 16) {
+        WordArray.bytesToBlock(pt, tempBlock1.words, i);
+        add();
+      }
+    }
+    function add() {
+      computedMic.words[0] ^= tempBlock1.words[0];
+      computedMic.words[1] ^= tempBlock1.words[1];
+      computedMic.words[2] ^= tempBlock1.words[2];
+      computedMic.words[3] ^= tempBlock1.words[3];
+      aes.encrypt(computedMic.words);
+    }
+  }
+  function ctr(input, from, to, ptLength, mic) {
+    tempBlock1.bytes[0] = BYTES_IN_LENGTH - 1;
+    tempBlock1.bytes.set(input.nonce, 1);
+    tempBlock1.bytes[14] = 0;
+    tempBlock1.bytes[15] = 0;
+    WordArray.bytesToBlock(tempBlock1.view, ctrBlock.words);
+    aes.encrypt(ctrBlock.words, tempBlock1.words);
+    mic.words[0] ^= tempBlock1.words[0];
+    mic.words[1] ^= tempBlock1.words[1];
+    mic.words[2] ^= tempBlock1.words[2];
+    mic.words[3] ^= tempBlock1.words[3];
+    for (let i = 0; i < ptLength; ) {
+      ctrBlock.words[3]++;
+      WordArray.bytesToBlock(from, tempBlock1.words, i);
+      aes.encrypt(ctrBlock.words, tempBlock2.words);
+      for (let j = 0; j < 4 && i < ptLength; j++, i += 4) {
+        const tempWord = tempBlock2.words[j];
+        if (i + 4 < ptLength) {
+          to.setInt32(i, from.getInt32(i) ^ tempWord);
+        } else {
+          const partial = WordArray.readPartialWord(from, i, ptLength - i) ^ tempWord;
+          WordArray.writePartialWord(partial, to, i, ptLength - i);
+        }
+      }
+    }
+  }
+}
+const BYTES_IN_LENGTH = 2;
+const MAX_CIPHERTEXT_LENGTH = Math.pow(2, BYTES_IN_LENGTH * 8);
+const MAX_PLAINTEXT_LENGTH = MAX_CIPHERTEXT_LENGTH - CRYPTO_AEAD_MIC_LENGTH_BYTES;
+class SingletonBuffer {
+  #words;
+  #bytes;
+  #view;
+  get words() {
+    if (this.#words === void 0) {
+      this.#words = new Int32Array(4);
+    }
+    return this.#words;
+  }
+  get bytes() {
+    if (this.#bytes === void 0) {
+      this.#bytes = new Uint8Array(this.words.buffer);
+    }
+    return this.#bytes;
+  }
+  /**
+   * The word and byte views of the buffer above are insufficient because we must account for platform endianness.  So
+   * we also make a DataView available.
+   */
+  get view() {
+    if (this.#view === void 0) {
+      this.#view = new DataView(this.words.buffer);
+    }
+    return this.#view;
+  }
+}
+const computedMic = new SingletonBuffer();
+const inputMic = new SingletonBuffer();
+const ctrBlock = new SingletonBuffer();
+const tempBlock1 = new SingletonBuffer();
+const tempBlock2 = new SingletonBuffer();
+function validateNonceAndAdata(input) {
+  if (input.nonce.length !== CRYPTO_AEAD_NONCE_LENGTH_BYTES) {
+    throw new CryptoInputError("Nonce must be 13 bytes");
+  }
+  if (input.adata && input.adata.length > 65535) {
+    throw new CryptoInputError(`Associated adata exceeds maximum length of ${MAX_PLAINTEXT_LENGTH}`);
+  }
+}
+export {
+  BYTES_IN_LENGTH,
+  Ccm,
+  MAX_CIPHERTEXT_LENGTH,
+  MAX_PLAINTEXT_LENGTH
+};
+//# sourceMappingURL=Ccm.js.map

package/dist/esm/crypto/aes/Ccm.js.map

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

package/dist/esm/crypto/aes/WordArray.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A 32-bit word array for AES algorithm.
+ *
+ * Note that we use signed integers so we can use JS bit shifts with signed 32-bit numbers.
+ */
+export type WordArray = Int32Array;
+export declare function WordArray(length: number): WordArray;
+export declare namespace WordArray {
+    function fromByteArray(bytes: Uint8Array, alignment?: number): WordArray;
+    function fromByteView(bytes: DataView, alignment?: number): WordArray;
+    /**
+     * Copy bytes into a 4-word block.  If the input bytes is too short sets missing bytes to zero.
+     */
+    function bytesToBlock(bytes: DataView, block: WordArray, byteOffset?: number): void;
+    /**
+     * Read a word from a byte array that may be smaller than four bytes.  On little-endian platforms, flips the byte
+     * order.
+     */
+    function readPartialWord(bytes: DataView, offset: number, bytesAvailable?: number): number;
+    /**
+     * Inverse of {@link writePartialWord}.
+     */
+    function writePartialWord(word: number, bytes: DataView, offset: number, bytesAvailable?: number): void;
+}
+//# sourceMappingURL=WordArray.d.ts.map

package/dist/esm/crypto/aes/WordArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WordArray.d.ts","sourceRoot":"","sources":["../../../../src/crypto/aes/WordArray.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AAEnC,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAEnD;AAKD,yBAAiB,SAAS,CAAC;IACvB,SAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,SAAI,aAE7D;IAED,SAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,SAAI,aAiB1D;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,MAAM,QAalF;IAED;;;OAGG;IACH,SAAgB,eAAe,CAC3B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,MAAM,EACd,cAAc,SAA4B,GAC3C,MAAM,CAYR;IAED;;OAEG;IACH,SAAgB,gBAAgB,CAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,MAAM,EACd,cAAc,SAAyC,QAY1D;CACJ"}