@hpke/cose 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ajitomi Daisuke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,70 @@
-# Temporary Holding Version
+# @hpke/cose
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A TypeScript implementation of
+[COSE-HPKE (draft-ietf-cose-hpke)](https://datatracker.ietf.org/doc/draft-ietf-cose-hpke/)
+built on top of
+[@hpke/core](https://github.com/dajiaji/hpke-js/tree/main/packages/core). It is
+tested against the test vectors in
+[draft-ietf-cose-hpke-27](https://datatracker.ietf.org/doc/html/draft-ietf-cose-hpke-27).
+
+## Features
+
+- **COSE_Encrypt0** (Integrated Encryption) — single-recipient HPKE encryption
+  directly into the COSE_Encrypt0 structure.
+- **COSE_Encrypt** (Key Encryption) — multi-recipient HPKE key wrapping with a
+  content encryption key.
+
+## Supported Environments
+
+This package is distributed as ESM only. On Node.js, version 20 or later is
+required.
+
+## Supported Algorithms
+
+| Name   | COSE Value | KEM                        | KDF         | AEAD             |
+| ------ | ---------- | -------------------------- | ----------- | ---------------- |
+| HPKE-0 | 35         | DHKEM(P-256, HKDF-SHA256)  | HKDF-SHA256 | AES-128-GCM      |
+| HPKE-1 | 37         | DHKEM(P-384, HKDF-SHA384)  | HKDF-SHA384 | AES-256-GCM      |
+| HPKE-2 | 39         | DHKEM(P-521, HKDF-SHA512)  | HKDF-SHA512 | AES-256-GCM      |
+| HPKE-3 | 41         | DHKEM(X25519, HKDF-SHA256) | HKDF-SHA256 | AES-128-GCM      |
+| HPKE-4 | 42         | DHKEM(X25519, HKDF-SHA256) | HKDF-SHA256 | ChaCha20Poly1305 |
+| HPKE-5 | 43         | DHKEM(X448, HKDF-SHA512)   | HKDF-SHA512 | AES-256-GCM      |
+| HPKE-6 | 44         | DHKEM(X448, HKDF-SHA512)   | HKDF-SHA512 | ChaCha20Poly1305 |
+| HPKE-7 | 45         | DHKEM(P-256, HKDF-SHA256)  | HKDF-SHA256 | AES-256-GCM      |
+
+Key Encryption variants (HPKE-0-KE through HPKE-7-KE) use COSE values 46–53.
+
+## Usage
+
+### COSE_Encrypt0 (Integrated Encryption)
+
+```ts
+import { createHpke3 } from "@hpke/cose";
+
+const enc0 = createHpke3();
+const rkp = await enc0.suite.kem.generateKeyPair();
+
+const ct = await enc0.seal(rkp.publicKey, new TextEncoder().encode("hello"));
+const pt = await enc0.open(rkp, ct);
+// new TextDecoder().decode(pt) === "hello"
+```
+
+### COSE_Encrypt (Key Encryption)
+
+```ts
+import { ContentAlg, createHpke3Ke } from "@hpke/cose";
+
+const enc = createHpke3Ke(ContentAlg.A128GCM);
+const rkp = await enc.generateKemKeyPair();
+
+const ct = await enc.seal(
+  [{ recipientPublicKey: rkp.publicKey }],
+  new TextEncoder().encode("hello"),
+);
+const pt = await enc.open(rkp, ct);
+// new TextDecoder().decode(pt) === "hello"
+```
+
+## License
+
+MIT

package/esm/mod.d.ts

@@ -0,0 +1,16 @@
+export { ContentAlg, CoseHpkeAlg } from "./src/alg.js";
+export type { CoseEncrypt0, CoseEncrypt0DetachedResult, CoseEncrypt0Options, } from "./src/encrypt0.js";
+export type { CoseEncrypt } from "./src/encrypt.js";
+export type { ContentCrypto, CoseEncryptDetachedResult, CoseEncryptOpenOptions, CoseEncryptSealOptions, CoseRecipient, } from "./src/encrypt.js";
+export { CoseError } from "./src/errors.js";
+export { buildEc2CoseKey, buildOkpCoseKey, CoseCrv, CoseKty, extractCurve, extractPrivateKeyBytes, extractPublicKeyBytes, } from "./src/coseKey.js";
+export type { CoseKeyBuildOptions } from "./src/coseKey.js";
+export { createHpke0, createHpke0Ke } from "./src/hpke0.js";
+export { createHpke1, createHpke1Ke } from "./src/hpke1.js";
+export { createHpke2, createHpke2Ke } from "./src/hpke2.js";
+export { createHpke3, createHpke3Ke } from "./src/hpke3.js";
+export { createHpke4, createHpke4Ke } from "./src/hpke4.js";
+export { createHpke5, createHpke5Ke } from "./src/hpke5.js";
+export { createHpke6, createHpke6Ke } from "./src/hpke6.js";
+export { createHpke7, createHpke7Ke } from "./src/hpke7.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EACV,YAAY,EACZ,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EACV,aAAa,EACb,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,GACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EACL,eAAe,EACf,eAAe,EACf,OAAO,EACP,OAAO,EACP,YAAY,EACZ,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/esm/mod.js

@@ -0,0 +1,11 @@
+export { ContentAlg, CoseHpkeAlg } from "./src/alg.js";
+export { CoseError } from "./src/errors.js";
+export { buildEc2CoseKey, buildOkpCoseKey, CoseCrv, CoseKty, extractCurve, extractPrivateKeyBytes, extractPublicKeyBytes, } from "./src/coseKey.js";
+export { createHpke0, createHpke0Ke } from "./src/hpke0.js";
+export { createHpke1, createHpke1Ke } from "./src/hpke1.js";
+export { createHpke2, createHpke2Ke } from "./src/hpke2.js";
+export { createHpke3, createHpke3Ke } from "./src/hpke3.js";
+export { createHpke4, createHpke4Ke } from "./src/hpke4.js";
+export { createHpke5, createHpke5Ke } from "./src/hpke5.js";
+export { createHpke6, createHpke6Ke } from "./src/hpke6.js";
+export { createHpke7, createHpke7Ke } from "./src/hpke7.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/src/alg.d.ts

@@ -0,0 +1,60 @@
+/**
+ * COSE HPKE algorithm identifiers from draft-ietf-cose-hpke-27.
+ *
+ * Integrated Encryption (COSE_Encrypt0): values 35–45.
+ * Key Encryption (COSE_Encrypt): values 46–53.
+ */
+export declare const CoseHpkeAlg: {
+    /** DHKEM(P-256), HKDF-SHA256, AES-128-GCM */
+    readonly HPKE_0: 35;
+    /** DHKEM(P-384), HKDF-SHA384, AES-256-GCM */
+    readonly HPKE_1: 37;
+    /** DHKEM(P-521), HKDF-SHA512, AES-256-GCM */
+    readonly HPKE_2: 39;
+    /** DHKEM(X25519), HKDF-SHA256, AES-128-GCM */
+    readonly HPKE_3: 41;
+    /** DHKEM(X25519), HKDF-SHA256, ChaCha20Poly1305 */
+    readonly HPKE_4: 42;
+    /** DHKEM(X448), HKDF-SHA512, AES-256-GCM */
+    readonly HPKE_5: 43;
+    /** DHKEM(X448), HKDF-SHA512, ChaCha20Poly1305 */
+    readonly HPKE_6: 44;
+    /** DHKEM(P-256), HKDF-SHA256, AES-256-GCM */
+    readonly HPKE_7: 45;
+    /** Key Encryption: DHKEM(P-256), HKDF-SHA256, AES-128-GCM */
+    readonly HPKE_0_KE: 46;
+    /** Key Encryption: DHKEM(P-384), HKDF-SHA384, AES-256-GCM */
+    readonly HPKE_1_KE: 47;
+    /** Key Encryption: DHKEM(P-521), HKDF-SHA512, AES-256-GCM */
+    readonly HPKE_2_KE: 48;
+    /** Key Encryption: DHKEM(X25519), HKDF-SHA256, AES-128-GCM */
+    readonly HPKE_3_KE: 49;
+    /** Key Encryption: DHKEM(X25519), HKDF-SHA256, ChaCha20Poly1305 */
+    readonly HPKE_4_KE: 50;
+    /** Key Encryption: DHKEM(X448), HKDF-SHA512, AES-256-GCM */
+    readonly HPKE_5_KE: 51;
+    /** Key Encryption: DHKEM(X448), HKDF-SHA512, ChaCha20Poly1305 */
+    readonly HPKE_6_KE: 52;
+    /** Key Encryption: DHKEM(P-256), HKDF-SHA256, AES-256-GCM */
+    readonly HPKE_7_KE: 53;
+};
+export type CoseHpkeAlg = (typeof CoseHpkeAlg)[keyof typeof CoseHpkeAlg];
+/** COSE content-encryption algorithm identifiers. */
+export declare const ContentAlg: {
+    /** AES-128-GCM (COSE alg value 1) */
+    readonly A128GCM: 1;
+    /** AES-256-GCM (COSE alg value 3) */
+    readonly A256GCM: 3;
+    /** ChaCha20/Poly1305 (COSE alg value 24) */
+    readonly CHACHA20POLY1305: 24;
+};
+export type ContentAlg = (typeof ContentAlg)[keyof typeof ContentAlg];
+/** Content key sizes in bytes for each ContentAlg. */
+export declare function contentKeySize(alg: ContentAlg): number;
+/** Content nonce sizes in bytes for each ContentAlg. */
+export declare function contentNonceSize(_alg: ContentAlg): number;
+/** Whether the algorithm is for Key Encryption (COSE_Encrypt). */
+export declare function isKeyEncryption(alg: CoseHpkeAlg): boolean;
+/** Whether the algorithm is for Integrated Encryption (COSE_Encrypt0). */
+export declare function isIntegratedEncryption(alg: CoseHpkeAlg): boolean;
+//# sourceMappingURL=alg.d.ts.map

package/esm/src/alg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg.d.ts","sourceRoot":"","sources":["../../src/src/alg.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB,6CAA6C;;IAE7C,6CAA6C;;IAE7C,6CAA6C;;IAE7C,8CAA8C;;IAE9C,mDAAmD;;IAEnD,4CAA4C;;IAE5C,iDAAiD;;IAEjD,6CAA6C;;IAE7C,6DAA6D;;IAE7D,6DAA6D;;IAE7D,6DAA6D;;IAE7D,8DAA8D;;IAE9D,mEAAmE;;IAEnE,4DAA4D;;IAE5D,iEAAiE;;IAEjE,6DAA6D;;CAErD,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAEzE,qDAAqD;AACrD,eAAO,MAAM,UAAU;IACrB,qCAAqC;;IAErC,qCAAqC;;IAErC,4CAA4C;;CAEpC,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEtE,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAWtD;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAGzD;AAuBD,kEAAkE;AAClE,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAEhE"}

package/esm/src/alg.js

@@ -0,0 +1,96 @@
+import { CoseError } from "./errors.js";
+/**
+ * COSE HPKE algorithm identifiers from draft-ietf-cose-hpke-27.
+ *
+ * Integrated Encryption (COSE_Encrypt0): values 35–45.
+ * Key Encryption (COSE_Encrypt): values 46–53.
+ */
+export const CoseHpkeAlg = {
+    /** DHKEM(P-256), HKDF-SHA256, AES-128-GCM */
+    HPKE_0: 35,
+    /** DHKEM(P-384), HKDF-SHA384, AES-256-GCM */
+    HPKE_1: 37,
+    /** DHKEM(P-521), HKDF-SHA512, AES-256-GCM */
+    HPKE_2: 39,
+    /** DHKEM(X25519), HKDF-SHA256, AES-128-GCM */
+    HPKE_3: 41,
+    /** DHKEM(X25519), HKDF-SHA256, ChaCha20Poly1305 */
+    HPKE_4: 42,
+    /** DHKEM(X448), HKDF-SHA512, AES-256-GCM */
+    HPKE_5: 43,
+    /** DHKEM(X448), HKDF-SHA512, ChaCha20Poly1305 */
+    HPKE_6: 44,
+    /** DHKEM(P-256), HKDF-SHA256, AES-256-GCM */
+    HPKE_7: 45,
+    /** Key Encryption: DHKEM(P-256), HKDF-SHA256, AES-128-GCM */
+    HPKE_0_KE: 46,
+    /** Key Encryption: DHKEM(P-384), HKDF-SHA384, AES-256-GCM */
+    HPKE_1_KE: 47,
+    /** Key Encryption: DHKEM(P-521), HKDF-SHA512, AES-256-GCM */
+    HPKE_2_KE: 48,
+    /** Key Encryption: DHKEM(X25519), HKDF-SHA256, AES-128-GCM */
+    HPKE_3_KE: 49,
+    /** Key Encryption: DHKEM(X25519), HKDF-SHA256, ChaCha20Poly1305 */
+    HPKE_4_KE: 50,
+    /** Key Encryption: DHKEM(X448), HKDF-SHA512, AES-256-GCM */
+    HPKE_5_KE: 51,
+    /** Key Encryption: DHKEM(X448), HKDF-SHA512, ChaCha20Poly1305 */
+    HPKE_6_KE: 52,
+    /** Key Encryption: DHKEM(P-256), HKDF-SHA256, AES-256-GCM */
+    HPKE_7_KE: 53,
+};
+/** COSE content-encryption algorithm identifiers. */
+export const ContentAlg = {
+    /** AES-128-GCM (COSE alg value 1) */
+    A128GCM: 1,
+    /** AES-256-GCM (COSE alg value 3) */
+    A256GCM: 3,
+    /** ChaCha20/Poly1305 (COSE alg value 24) */
+    CHACHA20POLY1305: 24,
+};
+/** Content key sizes in bytes for each ContentAlg. */
+export function contentKeySize(alg) {
+    switch (alg) {
+        case ContentAlg.A128GCM:
+            return 16;
+        case ContentAlg.A256GCM:
+            return 32;
+        case ContentAlg.CHACHA20POLY1305:
+            return 32;
+        default:
+            throw new CoseError(`Unsupported content algorithm: ${alg}`);
+    }
+}
+/** Content nonce sizes in bytes for each ContentAlg. */
+export function contentNonceSize(_alg) {
+    // AES-128-GCM, AES-256-GCM, and ChaCha20/Poly1305 all use 12-byte nonces
+    return 12;
+}
+const KEY_ENCRYPTION_ALGS = new Set([
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+]);
+const INTEGRATED_ENCRYPTION_ALGS = new Set([
+    35,
+    37,
+    39,
+    41,
+    42,
+    43,
+    44,
+    45,
+]);
+/** Whether the algorithm is for Key Encryption (COSE_Encrypt). */
+export function isKeyEncryption(alg) {
+    return KEY_ENCRYPTION_ALGS.has(alg);
+}
+/** Whether the algorithm is for Integrated Encryption (COSE_Encrypt0). */
+export function isIntegratedEncryption(alg) {
+    return INTEGRATED_ENCRYPTION_ALGS.has(alg);
+}

package/esm/src/cbor/decoder.d.ts

@@ -0,0 +1,4 @@
+import type { CborValue } from "./types.js";
+/** Decode a CBOR byte string into a CborValue. */
+export declare function decode(data: Uint8Array): CborValue;
+//# sourceMappingURL=decoder.d.ts.map

package/esm/src/cbor/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../src/src/cbor/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA+I5C,kDAAkD;AAClD,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAOlD"}

package/esm/src/cbor/decoder.js

@@ -0,0 +1,148 @@
+/** Maximum nesting depth of data items. COSE structures stay far below this. */
+const MAX_NESTING_DEPTH = 32;
+class Decoder {
+    constructor(data) {
+        Object.defineProperty(this, "_data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_depth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._data = data;
+        this._pos = 0;
+        this._depth = 0;
+    }
+    get position() {
+        return this._pos;
+    }
+    decode() {
+        if (this._depth >= MAX_NESTING_DEPTH) {
+            throw new Error("CBOR: nesting too deep");
+        }
+        this._depth++;
+        const value = this._decodeItem();
+        this._depth--;
+        return value;
+    }
+    _decodeItem() {
+        if (this._pos >= this._data.length) {
+            throw new Error("CBOR: unexpected end of input");
+        }
+        const initial = this._data[this._pos++];
+        const major = initial >> 5;
+        const additional = initial & 0x1f;
+        switch (major) {
+            case 0: // unsigned int
+                return this._readUint(additional);
+            case 1: // negative int
+                return -1 - this._readUint(additional);
+            case 2: // byte string
+                return this._readBytes(this._readUint(additional));
+            case 3: // text string
+                return this._readText(this._readUint(additional));
+            case 4: // array
+                return this._readArray(this._readUint(additional));
+            case 5: // map
+                return this._readMap(this._readUint(additional));
+            case 6: // tag (skip tag number, return inner value)
+                this._readUint(additional);
+                return this.decode();
+            case 7: // simple/float
+                if (additional === 22) {
+                    return null;
+                }
+                throw new Error(`CBOR: unsupported simple value ${additional}`);
+            default:
+                throw new Error(`CBOR: unsupported major type ${major}`);
+        }
+    }
+    _readUint(additional) {
+        if (additional < 24) {
+            return additional;
+        }
+        if (additional === 24) {
+            return this._data[this._pos++];
+        }
+        if (additional === 25) {
+            const val = (this._data[this._pos] << 8) | this._data[this._pos + 1];
+            this._pos += 2;
+            return val;
+        }
+        if (additional === 26) {
+            const val = (this._data[this._pos] << 24) |
+                (this._data[this._pos + 1] << 16) |
+                (this._data[this._pos + 2] << 8) |
+                this._data[this._pos + 3];
+            this._pos += 4;
+            return val >>> 0; // unsigned
+        }
+        if (additional === 27) {
+            const dv = new DataView(this._data.buffer, this._data.byteOffset + this._pos, 8);
+            const val = dv.getBigUint64(0);
+            this._pos += 8;
+            if (val > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new Error("CBOR: integer too large for number");
+            }
+            return Number(val);
+        }
+        throw new Error(`CBOR: unsupported additional info ${additional}`);
+    }
+    _readBytes(len) {
+        const slice = this._data.slice(this._pos, this._pos + len);
+        this._pos += len;
+        return slice;
+    }
+    _readText(len) {
+        const bytes = this._readBytes(len);
+        try {
+            return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+        }
+        catch {
+            throw new Error("CBOR: invalid UTF-8 in text string");
+        }
+    }
+    _readArray(len) {
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+            arr.push(this.decode());
+        }
+        return arr;
+    }
+    _readMap(len) {
+        const map = new Map();
+        for (let i = 0; i < len; i++) {
+            const key = this.decode();
+            if (typeof key !== "number" && typeof key !== "string") {
+                throw new Error("CBOR: unsupported map key type");
+            }
+            // RFC 9052 Section 3: a message with a repeated label MUST be rejected.
+            if (map.has(key)) {
+                throw new Error("CBOR: duplicate map key");
+            }
+            const val = this.decode();
+            map.set(key, val);
+        }
+        return map;
+    }
+}
+/** Decode a CBOR byte string into a CborValue. */
+export function decode(data) {
+    const decoder = new Decoder(data);
+    const value = decoder.decode();
+    if (decoder.position !== data.length) {
+        throw new Error("CBOR: trailing bytes after decoded value");
+    }
+    return value;
+}

package/esm/src/cbor/encoder.d.ts

@@ -0,0 +1,6 @@
+import type { CborValue } from "./types.js";
+/** Encode a CborValue into a CBOR byte string. */
+export declare function encode(value: CborValue): Uint8Array;
+/** Encode a CborValue wrapped in a CBOR tag (major type 6). */
+export declare function encodeTagged(tag: number, value: CborValue): Uint8Array;
+//# sourceMappingURL=encoder.d.ts.map

package/esm/src/cbor/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/src/cbor/encoder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAkH5C,kDAAkD;AAClD,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAEnD;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,UAAU,CAEtE"}

package/esm/src/cbor/encoder.js

@@ -0,0 +1,109 @@
+function encodeHead(major, value) {
+    const mt = major << 5;
+    if (value < 24) {
+        return new Uint8Array([mt | value]);
+    }
+    if (value < 0x100) {
+        return new Uint8Array([mt | 24, value]);
+    }
+    if (value < 0x10000) {
+        const buf = new Uint8Array(3);
+        buf[0] = mt | 25;
+        buf[1] = (value >> 8) & 0xff;
+        buf[2] = value & 0xff;
+        return buf;
+    }
+    if (value < 0x100000000) {
+        const buf = new Uint8Array(5);
+        buf[0] = mt | 26;
+        buf[1] = (value >> 24) & 0xff;
+        buf[2] = (value >> 16) & 0xff;
+        buf[3] = (value >> 8) & 0xff;
+        buf[4] = value & 0xff;
+        return buf;
+    }
+    // 64-bit: use DataView for values > 32 bits
+    const buf = new Uint8Array(9);
+    buf[0] = mt | 27;
+    const dv = new DataView(buf.buffer);
+    dv.setBigUint64(1, BigInt(value));
+    return buf;
+}
+function encodeValue(value) {
+    if (value === null) {
+        return [new Uint8Array([0xf6])]; // major 7, simple value 22
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value)) {
+            throw new Error("CBOR: float encoding is not supported");
+        }
+        if (value >= 0) {
+            return [encodeHead(0, value)]; // major 0: unsigned int
+        }
+        // negative int: major 1, value = -1 - n
+        return [encodeHead(1, -1 - value)];
+    }
+    if (typeof value === "string") {
+        const encoded = new TextEncoder().encode(value);
+        return [encodeHead(3, encoded.length), encoded]; // major 3: text string
+    }
+    if (value instanceof Uint8Array) {
+        return [encodeHead(2, value.length), value]; // major 2: byte string
+    }
+    if (Array.isArray(value)) {
+        const parts = [encodeHead(4, value.length)]; // major 4: array
+        for (const item of value) {
+            parts.push(...encodeValue(item));
+        }
+        return parts;
+    }
+    if (value instanceof Map) {
+        // COSE deterministic encoding: sort by encoded key bytes (lexicographic)
+        const entries = [];
+        for (const [k, v] of value) {
+            const keyParts = encodeValue(k);
+            const keyBytes = concat(keyParts);
+            entries.push({ keyBytes, valParts: encodeValue(v) });
+        }
+        entries.sort((a, b) => compareBytes(a.keyBytes, b.keyBytes));
+        const parts = [encodeHead(5, entries.length)]; // major 5: map
+        for (const entry of entries) {
+            parts.push(entry.keyBytes);
+            for (const vp of entry.valParts) {
+                parts.push(vp);
+            }
+        }
+        return parts;
+    }
+    throw new Error("CBOR: unsupported value type");
+}
+function compareBytes(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (a[i] !== b[i]) {
+            return a[i] - b[i];
+        }
+    }
+    return a.length - b.length;
+}
+function concat(parts) {
+    let total = 0;
+    for (const p of parts) {
+        total += p.length;
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        result.set(p, offset);
+        offset += p.length;
+    }
+    return result;
+}
+/** Encode a CborValue into a CBOR byte string. */
+export function encode(value) {
+    return concat(encodeValue(value));
+}
+/** Encode a CborValue wrapped in a CBOR tag (major type 6). */
+export function encodeTagged(tag, value) {
+    return concat([encodeHead(6, tag), ...encodeValue(value)]);
+}

package/esm/src/cbor/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A CBOR value that can be encoded/decoded by the minimal CBOR codec.
+ *
+ * Supported types: unsigned integer, negative integer, byte string,
+ * text string, array, map (with integer or text keys), and null.
+ */
+export type CborValue = number | Uint8Array | string | CborValue[] | Map<CborValue, CborValue> | null;
+//# sourceMappingURL=types.d.ts.map

package/esm/src/cbor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/src/cbor/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,UAAU,GACV,MAAM,GACN,SAAS,EAAE,GACX,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,GACzB,IAAI,CAAC"}

package/esm/src/cbor/types.js

@@ -0,0 +1 @@
+export {};

package/esm/src/contentAesGcm.d.ts

@@ -0,0 +1,3 @@
+import type { ContentCrypto } from "./encrypt.js";
+export declare const aesGcmContentCrypto: ContentCrypto;
+//# sourceMappingURL=contentAesGcm.d.ts.map

package/esm/src/contentAesGcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentAesGcm.d.ts","sourceRoot":"","sources":["../../src/src/contentAesGcm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAUlD,eAAO,MAAM,mBAAmB,EAAE,aAqCjC,CAAC"}

package/esm/src/contentAesGcm.js

@@ -0,0 +1,30 @@
+/** Convert Uint8Array → ArrayBuffer (handles subarrays). */
+function ab(u) {
+    return u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+}
+export const aesGcmContentCrypto = {
+    async seal(key, nonce, plaintext, aad) {
+        const s = globalThis.crypto.subtle;
+        const k = await s.importKey("raw", ab(key), "AES-GCM", false, [
+            "encrypt",
+        ]);
+        return new Uint8Array(await s.encrypt({
+            name: "AES-GCM",
+            iv: ab(nonce),
+            additionalData: ab(aad),
+            tagLength: 128,
+        }, k, ab(plaintext)));
+    },
+    async open(key, nonce, ciphertext, aad) {
+        const s = globalThis.crypto.subtle;
+        const k = await s.importKey("raw", ab(key), "AES-GCM", false, [
+            "decrypt",
+        ]);
+        return new Uint8Array(await s.decrypt({
+            name: "AES-GCM",
+            iv: ab(nonce),
+            additionalData: ab(aad),
+            tagLength: 128,
+        }, k, ab(ciphertext)));
+    },
+};