@suveren/gateway 0.40.0 → 0.41.0

package/node_modules/@hap/core/node_modules/@hpke/core/script/mod.js

@@ -0,0 +1,47 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@hpke/common", "./src/aeads/aesGcm.js", "./src/aeads/exportOnly.js", "./src/native.js", "./src/kems/dhkemX25519.js", "./src/kems/dhkemX448.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DhkemX448HkdfSha512 = exports.DhkemX25519HkdfSha256 = exports.HkdfSha512 = exports.HkdfSha384 = exports.HkdfSha256 = exports.DhkemP521HkdfSha512 = exports.DhkemP384HkdfSha384 = exports.DhkemP256HkdfSha256 = exports.CipherSuite = exports.ExportOnly = exports.Aes256Gcm = exports.Aes128Gcm = exports.ValidationError = exports.SerializeError = exports.SealError = exports.OpenError = exports.NotSupportedError = exports.MessageLimitReachedError = exports.KemId = exports.KdfId = exports.InvalidParamError = exports.HpkeError = exports.ExportError = exports.EncapError = exports.DeserializeError = exports.DeriveKeyPairError = exports.DecapError = exports.AeadId = void 0;
+    var common_1 = require("@hpke/common");
+    Object.defineProperty(exports, "AeadId", { enumerable: true, get: function () { return common_1.AeadId; } });
+    Object.defineProperty(exports, "DecapError", { enumerable: true, get: function () { return common_1.DecapError; } });
+    Object.defineProperty(exports, "DeriveKeyPairError", { enumerable: true, get: function () { return common_1.DeriveKeyPairError; } });
+    Object.defineProperty(exports, "DeserializeError", { enumerable: true, get: function () { return common_1.DeserializeError; } });
+    Object.defineProperty(exports, "EncapError", { enumerable: true, get: function () { return common_1.EncapError; } });
+    Object.defineProperty(exports, "ExportError", { enumerable: true, get: function () { return common_1.ExportError; } });
+    Object.defineProperty(exports, "HpkeError", { enumerable: true, get: function () { return common_1.HpkeError; } });
+    Object.defineProperty(exports, "InvalidParamError", { enumerable: true, get: function () { return common_1.InvalidParamError; } });
+    Object.defineProperty(exports, "KdfId", { enumerable: true, get: function () { return common_1.KdfId; } });
+    Object.defineProperty(exports, "KemId", { enumerable: true, get: function () { return common_1.KemId; } });
+    Object.defineProperty(exports, "MessageLimitReachedError", { enumerable: true, get: function () { return common_1.MessageLimitReachedError; } });
+    Object.defineProperty(exports, "NotSupportedError", { enumerable: true, get: function () { return common_1.NotSupportedError; } });
+    Object.defineProperty(exports, "OpenError", { enumerable: true, get: function () { return common_1.OpenError; } });
+    Object.defineProperty(exports, "SealError", { enumerable: true, get: function () { return common_1.SealError; } });
+    Object.defineProperty(exports, "SerializeError", { enumerable: true, get: function () { return common_1.SerializeError; } });
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return common_1.ValidationError; } });
+    var aesGcm_js_1 = require("./src/aeads/aesGcm.js");
+    Object.defineProperty(exports, "Aes128Gcm", { enumerable: true, get: function () { return aesGcm_js_1.Aes128Gcm; } });
+    Object.defineProperty(exports, "Aes256Gcm", { enumerable: true, get: function () { return aesGcm_js_1.Aes256Gcm; } });
+    var exportOnly_js_1 = require("./src/aeads/exportOnly.js");
+    Object.defineProperty(exports, "ExportOnly", { enumerable: true, get: function () { return exportOnly_js_1.ExportOnly; } });
+    var native_js_1 = require("./src/native.js");
+    Object.defineProperty(exports, "CipherSuite", { enumerable: true, get: function () { return native_js_1.CipherSuite; } });
+    Object.defineProperty(exports, "DhkemP256HkdfSha256", { enumerable: true, get: function () { return native_js_1.DhkemP256HkdfSha256; } });
+    Object.defineProperty(exports, "DhkemP384HkdfSha384", { enumerable: true, get: function () { return native_js_1.DhkemP384HkdfSha384; } });
+    Object.defineProperty(exports, "DhkemP521HkdfSha512", { enumerable: true, get: function () { return native_js_1.DhkemP521HkdfSha512; } });
+    Object.defineProperty(exports, "HkdfSha256", { enumerable: true, get: function () { return native_js_1.HkdfSha256; } });
+    Object.defineProperty(exports, "HkdfSha384", { enumerable: true, get: function () { return native_js_1.HkdfSha384; } });
+    Object.defineProperty(exports, "HkdfSha512", { enumerable: true, get: function () { return native_js_1.HkdfSha512; } });
+    var dhkemX25519_js_1 = require("./src/kems/dhkemX25519.js");
+    Object.defineProperty(exports, "DhkemX25519HkdfSha256", { enumerable: true, get: function () { return dhkemX25519_js_1.DhkemX25519HkdfSha256; } });
+    var dhkemX448_js_1 = require("./src/kems/dhkemX448.js");
+    Object.defineProperty(exports, "DhkemX448HkdfSha512", { enumerable: true, get: function () { return dhkemX448_js_1.DhkemX448HkdfSha512; } });
+});

package/node_modules/@hap/core/node_modules/@hpke/core/script/package.json

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

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/aesGcm.d.ts

@@ -0,0 +1,80 @@
+import type { AeadEncryptionContext, AeadInterface } from "@hpke/common";
+import { AeadId, NativeAlgorithm } from "@hpke/common";
+export declare class AesGcmContext extends NativeAlgorithm implements AeadEncryptionContext {
+    private _rawKey;
+    private _key;
+    constructor(key: ArrayBufferLike | ArrayBufferView);
+    seal(iv: ArrayBufferLike | ArrayBufferView, data: ArrayBufferLike | ArrayBufferView, aad: ArrayBufferLike | ArrayBufferView): Promise<ArrayBuffer>;
+    open(iv: ArrayBufferLike | ArrayBufferView, data: ArrayBufferLike | ArrayBufferView, aad: ArrayBufferLike | ArrayBufferView): Promise<ArrayBuffer>;
+    protected _setupKey(): Promise<void>;
+    private _importKey;
+}
+/**
+ * The AES-128-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes128Gcm`.
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes128Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export declare class Aes128Gcm implements AeadInterface {
+    /** AeadId.Aes128Gcm (0x0001) */
+    readonly id: AeadId;
+    /** 16 */
+    readonly keySize: number;
+    /** 12 */
+    readonly nonceSize: number;
+    /** 16 */
+    readonly tagSize: number;
+    createEncryptionContext(key: ArrayBufferLike | ArrayBufferView): AeadEncryptionContext;
+}
+/**
+ * The AES-256-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes256Gcm`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes256Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes256Gcm(),
+ * });
+ * ```
+ */
+export declare class Aes256Gcm extends Aes128Gcm {
+    /** AeadId.Aes256Gcm (0x0002) */
+    id: AeadId;
+    /** 32 */
+    keySize: number;
+    /** 12 */
+    nonceSize: number;
+    /** 16 */
+    tagSize: number;
+}
+//# sourceMappingURL=aesGcm.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/aesGcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aesGcm.d.ts","sourceRoot":"","sources":["../../../src/src/aeads/aesGcm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAEL,MAAM,EACN,eAAe,EAEhB,MAAM,cAAc,CAAC;AAEtB,qBAAa,aAAc,SAAQ,eACjC,YAAW,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,IAAI,CAAoC;gBAE7B,GAAG,EAAE,eAAe,GAAG,eAAe;IAK5C,IAAI,CACf,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,IAAI,EAAE,eAAe,GAAG,eAAe,EACvC,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,OAAO,CAAC,WAAW,CAAC;IAeV,IAAI,CACf,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,IAAI,EAAE,eAAe,GAAG,eAAe,EACvC,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,OAAO,CAAC,WAAW,CAAC;cAeP,SAAS;YAWX,UAAU;CASzB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,SAAU,YAAW,aAAa;IAC7C,gCAAgC;IAChC,SAAgB,EAAE,EAAE,MAAM,CAAoB;IAC9C,SAAS;IACT,SAAgB,OAAO,EAAE,MAAM,CAAM;IACrC,SAAS;IACT,SAAgB,SAAS,EAAE,MAAM,CAAM;IACvC,SAAS;IACT,SAAgB,OAAO,EAAE,MAAM,CAAM;IAE9B,uBAAuB,CAC5B,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,qBAAqB;CAGzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,SAAU,SAAQ,SAAS;IACtC,gCAAgC;IACvB,EAAE,EAAE,MAAM,CAAoB;IACvC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;IAC9B,SAAS;IACA,SAAS,EAAE,MAAM,CAAM;IAChC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;CAC/B"}

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/aesGcm.js

@@ -0,0 +1,183 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@hpke/common"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Aes256Gcm = exports.Aes128Gcm = exports.AesGcmContext = void 0;
+    const common_1 = require("@hpke/common");
+    class AesGcmContext extends common_1.NativeAlgorithm {
+        constructor(key) {
+            super();
+            Object.defineProperty(this, "_rawKey", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_key", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: undefined
+            });
+            this._rawKey = (0, common_1.toArrayBuffer)(key);
+        }
+        async seal(iv, data, aad) {
+            await this._setupKey();
+            const alg = {
+                name: "AES-GCM",
+                iv: (0, common_1.toArrayBuffer)(iv),
+                additionalData: (0, common_1.toArrayBuffer)(aad),
+            };
+            const ct = await this._api.encrypt(alg, this._key, (0, common_1.toArrayBuffer)(data));
+            return ct;
+        }
+        async open(iv, data, aad) {
+            await this._setupKey();
+            const alg = {
+                name: "AES-GCM",
+                iv: (0, common_1.toArrayBuffer)(iv),
+                additionalData: (0, common_1.toArrayBuffer)(aad),
+            };
+            const pt = await this._api.decrypt(alg, this._key, (0, common_1.toArrayBuffer)(data));
+            return pt;
+        }
+        async _setupKey() {
+            if (this._key !== undefined) {
+                return;
+            }
+            await this._setup();
+            const key = await this._importKey(this._rawKey);
+            (new Uint8Array(this._rawKey)).fill(0);
+            this._key = key;
+            return;
+        }
+        async _importKey(key) {
+            return await this._api.importKey("raw", key, { name: "AES-GCM" }, true, common_1.AEAD_USAGES);
+        }
+    }
+    exports.AesGcmContext = AesGcmContext;
+    /**
+     * The AES-128-GCM for HPKE AEAD implementing {@link AeadInterface}.
+     *
+     * When using `@hpke/core`, the instance of this class must be specified
+     * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes128Gcm`.
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   Aes128Gcm,
+     *   CipherSuite,
+     *   DhkemP256HkdfSha256,
+     *   HkdfSha256,
+     * } from "@hpke/core";
+     *
+     * const suite = new CipherSuite({
+     *   kem: new DhkemP256HkdfSha256(),
+     *   kdf: new HkdfSha256(),
+     *   aead: new Aes128Gcm(),
+     * });
+     * ```
+     */
+    class Aes128Gcm {
+        constructor() {
+            /** AeadId.Aes128Gcm (0x0001) */
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.AeadId.Aes128Gcm
+            });
+            /** 16 */
+            Object.defineProperty(this, "keySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 16
+            });
+            /** 12 */
+            Object.defineProperty(this, "nonceSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 12
+            });
+            /** 16 */
+            Object.defineProperty(this, "tagSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 16
+            });
+        }
+        createEncryptionContext(key) {
+            return new AesGcmContext(key);
+        }
+    }
+    exports.Aes128Gcm = Aes128Gcm;
+    /**
+     * The AES-256-GCM for HPKE AEAD implementing {@link AeadInterface}.
+     *
+     * When using `@hpke/core`, the instance of this class must be specified
+     * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes256Gcm`
+     * as follows:
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   Aes256Gcm,
+     *   CipherSuite,
+     *   DhkemP256HkdfSha256,
+     *   HkdfSha256,
+     * } from "@hpke/core";
+     *
+     * const suite = new CipherSuite({
+     *   kem: new DhkemP256HkdfSha256(),
+     *   kdf: new HkdfSha256(),
+     *   aead: new Aes256Gcm(),
+     * });
+     * ```
+     */
+    class Aes256Gcm extends Aes128Gcm {
+        constructor() {
+            super(...arguments);
+            /** AeadId.Aes256Gcm (0x0002) */
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.AeadId.Aes256Gcm
+            });
+            /** 32 */
+            Object.defineProperty(this, "keySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            /** 12 */
+            Object.defineProperty(this, "nonceSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 12
+            });
+            /** 16 */
+            Object.defineProperty(this, "tagSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 16
+            });
+        }
+    }
+    exports.Aes256Gcm = Aes256Gcm;
+});

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/exportOnly.d.ts

@@ -0,0 +1,34 @@
+import type { AeadEncryptionContext, AeadInterface } from "@hpke/common";
+import { AeadId } from "@hpke/common";
+/**
+ * The ExportOnly mode for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.ExportOnly`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   ExportOnly,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new ExportOnly(),
+ * });
+ * ```
+ */
+export declare class ExportOnly implements AeadInterface {
+    readonly id: AeadId;
+    readonly keySize: number;
+    readonly nonceSize: number;
+    readonly tagSize: number;
+    createEncryptionContext(_key: ArrayBufferLike | ArrayBufferView): AeadEncryptionContext;
+}
+//# sourceMappingURL=exportOnly.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/exportOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportOnly.d.ts","sourceRoot":"","sources":["../../../src/src/aeads/exportOnly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,MAAM,EAAqB,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,UAAW,YAAW,aAAa;IAC9C,SAAgB,EAAE,EAAE,MAAM,CAAqB;IAC/C,SAAgB,OAAO,EAAE,MAAM,CAAK;IACpC,SAAgB,SAAS,EAAE,MAAM,CAAK;IACtC,SAAgB,OAAO,EAAE,MAAM,CAAK;IAE7B,uBAAuB,CAC5B,IAAI,EAAE,eAAe,GAAG,eAAe,GACtC,qBAAqB;CAGzB"}

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/aeads/exportOnly.js

@@ -0,0 +1,70 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@hpke/common"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExportOnly = void 0;
+    const common_1 = require("@hpke/common");
+    /**
+     * The ExportOnly mode for HPKE AEAD implementing {@link AeadInterface}.
+     *
+     * When using `@hpke/core`, the instance of this class must be specified
+     * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.ExportOnly`
+     * as follows:
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   CipherSuite,
+     *   DhkemP256HkdfSha256,
+     *   ExportOnly,
+     *   HkdfSha256,
+     * } from "@hpke/core";
+     *
+     * const suite = new CipherSuite({
+     *   kem: new DhkemP256HkdfSha256(),
+     *   kdf: new HkdfSha256(),
+     *   aead: new ExportOnly(),
+     * });
+     * ```
+     */
+    class ExportOnly {
+        constructor() {
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.AeadId.ExportOnly
+            });
+            Object.defineProperty(this, "keySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            Object.defineProperty(this, "nonceSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            Object.defineProperty(this, "tagSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+        }
+        createEncryptionContext(_key) {
+            throw new common_1.NotSupportedError("Export only");
+        }
+    }
+    exports.ExportOnly = ExportOnly;
+});

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/cipherSuiteNative.d.ts

@@ -0,0 +1,145 @@
+import type { AeadInterface, KdfInterface, KemInterface, RecipientContextParams, SenderContextParams } from "@hpke/common";
+import { NativeAlgorithm } from "@hpke/common";
+import type { CipherSuiteParams } from "./interfaces/cipherSuiteParams.js";
+import type { RecipientContext, SenderContext } from "./interfaces/encryptionContext.js";
+import type { CipherSuiteSealResponse } from "./interfaces/responses.js";
+/**
+ * The Hybrid Public Key Encryption (HPKE) ciphersuite,
+ * which is implemented using only
+ * {@link https://www.w3.org/TR/WebCryptoAPI/ | Web Cryptography API}.
+ *
+ * This is the super class of {@link CipherSuite} and the same as
+ * {@link https://jsr.io/@hpke/core/doc/~/CipherSuite | @hpke/core#CipherSuite} as follows:
+ * which supports only the ciphersuites that can be implemented on the native
+ * {@link https://www.w3.org/TR/WebCryptoAPI/ | Web Cryptography API}.
+ * Therefore, the following cryptographic algorithms are not supported for now:
+ *   - DHKEM(X25519, HKDF-SHA256)
+ *   - DHKEM(X448, HKDF-SHA512)
+ *   - ChaCha20Poly1305
+ *
+ * In addtion, the HKDF functions contained in this class can only derive
+ * keys of the same length as the `hashSize`.
+ *
+ * If you want to use the unsupported cryptographic algorithms
+ * above or derive keys longer than the `hashSize`,
+ * please use {@link CipherSuite}.
+ *
+ * This class provides following functions:
+ *
+ * - Creates encryption contexts both for senders and recipients.
+ *   - {@link createSenderContext}
+ *   - {@link createRecipientContext}
+ * - Provides single-shot encryption API.
+ *   - {@link seal}
+ *   - {@link open}
+ *
+ * The calling of the constructor of this class is the starting
+ * point for HPKE operations for both senders and recipients.
+ *
+ * @example Use only ciphersuites supported by Web Cryptography API.
+ *
+ * ```ts
+ * import {
+ *   Aes128Gcm,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ *   CipherSuite,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ *
+ * @example Use a ciphersuite which is currently not supported by Web Cryptography API.
+ *
+ * ```ts
+ * import { Aes128Gcm, HkdfSha256, CipherSuite } from "@hpke/core";
+ * // Use an extension module.
+ * import { DhkemX25519HkdfSha256 } from "@hpke/dhkem-x25519";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemX25519HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export declare class CipherSuiteNative extends NativeAlgorithm {
+    protected _kem: KemInterface;
+    private _kdf;
+    private _aead;
+    private _suiteId;
+    /**
+     * @param params A set of parameters for building a cipher suite.
+     *
+     * If the error occurred, throws {@link InvalidParamError}.
+     *
+     * @throws {@link InvalidParamError}
+     */
+    constructor(params: CipherSuiteParams);
+    /**
+     * Gets the KEM context of the ciphersuite.
+     */
+    get kem(): KemInterface;
+    /**
+     * Gets the KDF context of the ciphersuite.
+     */
+    get kdf(): KdfInterface;
+    /**
+     * Gets the AEAD context of the ciphersuite.
+     */
+    get aead(): AeadInterface;
+    /**
+     * Creates an encryption context for a sender.
+     *
+     * If the error occurred, throws {@link DecapError} | {@link ValidationError}.
+     *
+     * @param params A set of parameters for the sender encryption context.
+     * @returns A sender encryption context.
+     * @throws {@link EncapError}, {@link ValidationError}
+     */
+    createSenderContext(params: SenderContextParams): Promise<SenderContext>;
+    /**
+     * Creates an encryption context for a recipient.
+     *
+     * If the error occurred, throws {@link DecapError}
+     * | {@link DeserializeError} | {@link ValidationError}.
+     *
+     * @param params A set of parameters for the recipient encryption context.
+     * @returns A recipient encryption context.
+     * @throws {@link DecapError}, {@link DeserializeError}, {@link ValidationError}
+     */
+    createRecipientContext(params: RecipientContextParams): Promise<RecipientContext>;
+    /**
+     * Encrypts a message to a recipient.
+     *
+     * If the error occurred, throws `EncapError` | `MessageLimitReachedError` | `SealError` | `ValidationError`.
+     *
+     * @param params A set of parameters for building a sender encryption context.
+     * @param pt A plain text as bytes to be encrypted.
+     * @param aad Additional authenticated data as bytes fed by an application.
+     * @returns A cipher text and an encapsulated key as bytes.
+     * @throws {@link EncapError}, {@link MessageLimitReachedError}, {@link SealError}, {@link ValidationError}
+     */
+    seal(params: SenderContextParams, pt: ArrayBufferLike | ArrayBufferView, aad?: ArrayBufferLike | ArrayBufferView): Promise<CipherSuiteSealResponse>;
+    /**
+     * Decrypts a message from a sender.
+     *
+     * If the error occurred, throws `DecapError` | `DeserializeError` | `OpenError` | `ValidationError`.
+     *
+     * @param params A set of parameters for building a recipient encryption context.
+     * @param ct An encrypted text as bytes to be decrypted.
+     * @param aad Additional authenticated data as bytes fed by an application.
+     * @returns A decrypted plain text as bytes.
+     * @throws {@link DecapError}, {@link DeserializeError}, {@link OpenError}, {@link ValidationError}
+     */
+    open(params: RecipientContextParams, ct: ArrayBufferLike | ArrayBufferView, aad?: ArrayBufferLike | ArrayBufferView): Promise<ArrayBuffer>;
+    private _keySchedule;
+    private _keyScheduleS;
+    private _keyScheduleR;
+    private _validateInputLength;
+}
+//# sourceMappingURL=cipherSuiteNative.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/cipherSuiteNative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cipherSuiteNative.d.ts","sourceRoot":"","sources":["../../src/src/cipherSuiteNative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EAEZ,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EASL,eAAe,EAEhB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAoCzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC;IAC7B,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;;;;OAMG;gBACS,MAAM,EAAE,iBAAiB;IA4BrC;;OAEG;IACH,IAAW,GAAG,IAAI,YAAY,CAE7B;IAED;;OAEG;IACH,IAAW,GAAG,IAAI,YAAY,CAE7B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,aAAa,CAE/B;IAED;;;;;;;;OAQG;IACU,mBAAmB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,aAAa,CAAC;IAgBzB;;;;;;;;;OASG;IACU,sBAAsB,CACjC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,gBAAgB,CAAC;IAgB5B;;;;;;;;;;OAUG;IACU,IAAI,CACf,MAAM,EAAE,mBAAmB,EAC3B,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,GAAG,GAAE,eAAe,GAAG,eAA6C,GACnE,OAAO,CAAC,uBAAuB,CAAC;IAQnC;;;;;;;;;;OAUG;IACU,IAAI,CACf,MAAM,EAAE,sBAAsB,EAC9B,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,GAAG,GAAE,eAAe,GAAG,eAA6C,GACnE,OAAO,CAAC,WAAW,CAAC;YAoBT,YAAY;YAqFZ,aAAa;YAuBb,aAAa;IAgB3B,OAAO,CAAC,oBAAoB;CAsB7B"}