@suveren/gateway 0.40.0 → 0.41.1

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/kems/dhkemPrimitives/x448.js

@@ -0,0 +1,228 @@
+(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.X448 = void 0;
+    const common_1 = require("@hpke/common");
+    const ALG_NAME = "X448";
+    // deno-fmt-ignore
+    const PKCS8_ALG_ID_X448 = new Uint8Array([
+        0x30, 0x46, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06,
+        0x03, 0x2b, 0x65, 0x6f, 0x04, 0x3a, 0x04, 0x38,
+    ]);
+    const BASE_POINT_X448 = /* @__PURE__ */ (() => {
+        const p = new Uint8Array(56);
+        p[0] = 5;
+        return p;
+    })();
+    class X448 extends common_1.NativeAlgorithm {
+        constructor(hkdf) {
+            super();
+            Object.defineProperty(this, "_hkdf", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_alg", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_nPk", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_nSk", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_nDh", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_pkcs8AlgId", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            this._alg = { name: ALG_NAME };
+            this._hkdf = hkdf;
+            this._nPk = 56;
+            this._nSk = 56;
+            this._nDh = 56;
+            this._pkcs8AlgId = PKCS8_ALG_ID_X448;
+        }
+        async serializePublicKey(key) {
+            await this._setup();
+            try {
+                return await this._api.exportKey("raw", key);
+            }
+            catch (e) {
+                throw new common_1.SerializeError(e);
+            }
+        }
+        async deserializePublicKey(key) {
+            await this._setup();
+            try {
+                return await this._importRawKey((0, common_1.toArrayBuffer)(key), true);
+            }
+            catch (e) {
+                throw new common_1.DeserializeError(e);
+            }
+        }
+        async serializePrivateKey(key) {
+            await this._setup();
+            try {
+                const jwk = await this._api.exportKey("jwk", key);
+                if (!("d" in jwk)) {
+                    throw new Error("Not private key");
+                }
+                return (0, common_1.base64UrlToBytes)(jwk["d"]).buffer;
+            }
+            catch (e) {
+                throw new common_1.SerializeError(e);
+            }
+        }
+        async deserializePrivateKey(key) {
+            await this._setup();
+            try {
+                return await this._importRawKey((0, common_1.toArrayBuffer)(key), false);
+            }
+            catch (e) {
+                throw new common_1.DeserializeError(e);
+            }
+        }
+        async importKey(format, key, isPublic) {
+            await this._setup();
+            try {
+                if (format === "raw") {
+                    return await this._importRawKey(key, isPublic);
+                }
+                // jwk
+                if (key instanceof ArrayBuffer) {
+                    throw new Error("Invalid jwk key format");
+                }
+                return await this._importJWK(key, isPublic);
+            }
+            catch (e) {
+                throw new common_1.DeserializeError(e);
+            }
+        }
+        async generateKeyPair() {
+            await this._setup();
+            try {
+                return await this._api.generateKey(ALG_NAME, true, common_1.KEM_USAGES);
+            }
+            catch (e) {
+                throw new common_1.NotSupportedError(e);
+            }
+        }
+        async deriveKeyPair(ikm) {
+            await this._setup();
+            try {
+                const rawIkm = (0, common_1.toArrayBuffer)(ikm);
+                const dkpPrk = await this._hkdf.labeledExtract(common_1.EMPTY, common_1.LABEL_DKP_PRK, new Uint8Array(rawIkm));
+                const rawSk = await this._hkdf.labeledExpand(dkpPrk, common_1.LABEL_SK, common_1.EMPTY, this._nSk);
+                const rawSkBytes = new Uint8Array(rawSk);
+                const sk = await this._deserializePkcs8Key(rawSkBytes);
+                rawSkBytes.fill(0);
+                return {
+                    privateKey: sk,
+                    publicKey: await this.derivePublicKey(sk),
+                };
+            }
+            catch (e) {
+                throw new common_1.DeriveKeyPairError(e);
+            }
+        }
+        async derivePublicKey(key) {
+            await this._setup();
+            try {
+                const jwk = await this._api.exportKey("jwk", key);
+                delete jwk["d"];
+                delete jwk["key_ops"];
+                return await this._api.importKey("jwk", jwk, this._alg, true, []);
+            }
+            catch {
+                try {
+                    // Some runtimes cannot export JWK from imported X448 private keys.
+                    const bp = await this._api.importKey("raw", BASE_POINT_X448.buffer, this._alg, true, []);
+                    const bits = await this._api.deriveBits({
+                        name: ALG_NAME,
+                        public: bp,
+                    }, key, this._nPk * 8);
+                    return await this._api.importKey("raw", bits, this._alg, true, []);
+                }
+                catch (e) {
+                    throw new common_1.DeserializeError(e);
+                }
+            }
+        }
+        async dh(sk, pk) {
+            await this._setup();
+            try {
+                const bits = await this._api.deriveBits({
+                    name: ALG_NAME,
+                    public: pk,
+                }, sk, this._nDh * 8);
+                return bits;
+            }
+            catch (e) {
+                throw new common_1.SerializeError(e);
+            }
+        }
+        async _importRawKey(key, isPublic) {
+            if (isPublic && key.byteLength !== this._nPk) {
+                throw new Error("Invalid public key for the ciphersuite");
+            }
+            if (!isPublic && key.byteLength !== this._nSk) {
+                throw new Error("Invalid private key for the ciphersuite");
+            }
+            if (isPublic) {
+                return await this._api.importKey("raw", key, this._alg, true, []);
+            }
+            return await this._deserializePkcs8Key(new Uint8Array(key));
+        }
+        async _importJWK(key, isPublic) {
+            if (typeof key.kty === "undefined" || key.kty !== "OKP") {
+                throw new Error(`Invalid kty: ${key.crv}`);
+            }
+            if (typeof key.crv === "undefined" || key.crv !== ALG_NAME) {
+                throw new Error(`Invalid crv: ${key.crv}`);
+            }
+            if (isPublic) {
+                if (typeof key.d !== "undefined") {
+                    throw new Error("Invalid key: `d` should not be set");
+                }
+                return await this._api.importKey("jwk", key, this._alg, true, []);
+            }
+            if (typeof key.d === "undefined") {
+                throw new Error("Invalid key: `d` not found");
+            }
+            return await this._api.importKey("jwk", key, this._alg, true, common_1.KEM_USAGES);
+        }
+        async _deserializePkcs8Key(k) {
+            const pkcs8Key = new Uint8Array(this._pkcs8AlgId.length + k.length);
+            pkcs8Key.set(this._pkcs8AlgId, 0);
+            pkcs8Key.set(k, this._pkcs8AlgId.length);
+            return await this._api.importKey("pkcs8", pkcs8Key, this._alg, true, common_1.KEM_USAGES);
+        }
+    }
+    exports.X448 = X448;
+});

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

@@ -0,0 +1,38 @@
+import { Dhkem, KemId } from "@hpke/common";
+/**
+ * The DHKEM(X25519, HKDF-SHA256) for HPKE KEM implementing {@link KemInterface}.
+ *
+ * The instance of this class can be specified to the
+ * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes128Gcm,
+ *   CipherSuite,
+ *   HkdfSha256,
+ *   DhkemX25519HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemX25519HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export declare class DhkemX25519HkdfSha256 extends Dhkem {
+    /** KemId.DhkemX25519HkdfSha256 (0x0020) */
+    id: KemId;
+    /** 32 */
+    secretSize: number;
+    /** 32 */
+    encSize: number;
+    /** 32 */
+    publicKeySize: number;
+    /** 32 */
+    privateKeySize: number;
+    constructor();
+}
+//# sourceMappingURL=dhkemX25519.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dhkemX25519.d.ts","sourceRoot":"","sources":["../../../src/src/kems/dhkemX25519.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,KAAK,EAAE,MAAM,cAAc,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,2CAA2C;IAClC,EAAE,EAAE,KAAK,CAA+B;IACjD,SAAS;IACA,UAAU,EAAE,MAAM,CAAM;IACjC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;IAC9B,SAAS;IACA,aAAa,EAAE,MAAM,CAAM;IACpC,SAAS;IACA,cAAc,EAAE,MAAM,CAAM;;CAMtC"}

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/kems/dhkemX25519.js

@@ -0,0 +1,80 @@
+(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", "./dhkemPrimitives/x25519.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DhkemX25519HkdfSha256 = void 0;
+    const common_1 = require("@hpke/common");
+    const x25519_js_1 = require("./dhkemPrimitives/x25519.js");
+    /**
+     * The DHKEM(X25519, HKDF-SHA256) for HPKE KEM implementing {@link KemInterface}.
+     *
+     * The instance of this class can be specified to the
+     * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   Aes128Gcm,
+     *   CipherSuite,
+     *   HkdfSha256,
+     *   DhkemX25519HkdfSha256,
+     * } from "@hpke/core";
+     *
+     * const suite = new CipherSuite({
+     *   kem: new DhkemX25519HkdfSha256(),
+     *   kdf: new HkdfSha256(),
+     *   aead: new Aes128Gcm(),
+     * });
+     * ```
+     */
+    class DhkemX25519HkdfSha256 extends common_1.Dhkem {
+        constructor() {
+            const kdf = new common_1.HkdfSha256Native();
+            super(common_1.KemId.DhkemX25519HkdfSha256, new x25519_js_1.X25519(kdf), kdf);
+            /** KemId.DhkemX25519HkdfSha256 (0x0020) */
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.KemId.DhkemX25519HkdfSha256
+            });
+            /** 32 */
+            Object.defineProperty(this, "secretSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            /** 32 */
+            Object.defineProperty(this, "encSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            /** 32 */
+            Object.defineProperty(this, "publicKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            /** 32 */
+            Object.defineProperty(this, "privateKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+        }
+    }
+    exports.DhkemX25519HkdfSha256 = DhkemX25519HkdfSha256;
+});

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

@@ -0,0 +1,38 @@
+import { Dhkem, KemId } from "@hpke/common";
+/**
+ * The DHKEM(X448, HKDF-SHA512) for HPKE KEM implementing {@link KemInterface}.
+ *
+ * The instance of this class can be specified to the
+ * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes256Gcm,
+ *   CipherSuite,
+ *   HkdfSha512,
+ *   DhkemX448HkdfSha512,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemX448HkdfSha512(),
+ *   kdf: new HkdfSha512(),
+ *   aead: new Aes256Gcm(),
+ * });
+ * ```
+ */
+export declare class DhkemX448HkdfSha512 extends Dhkem {
+    /** KemId.DhkemX448HkdfSha512 (0x0021) */
+    id: KemId;
+    /** 64 */
+    secretSize: number;
+    /** 56 */
+    encSize: number;
+    /** 56 */
+    publicKeySize: number;
+    /** 56 */
+    privateKeySize: number;
+    constructor();
+}
+//# sourceMappingURL=dhkemX448.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dhkemX448.d.ts","sourceRoot":"","sources":["../../../src/src/kems/dhkemX448.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,KAAK,EAAE,MAAM,cAAc,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,yCAAyC;IAChC,EAAE,EAAE,KAAK,CAA6B;IAC/C,SAAS;IACA,UAAU,EAAE,MAAM,CAAM;IACjC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;IAC9B,SAAS;IACA,aAAa,EAAE,MAAM,CAAM;IACpC,SAAS;IACA,cAAc,EAAE,MAAM,CAAM;;CAMtC"}

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/kems/dhkemX448.js

@@ -0,0 +1,80 @@
+(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", "./dhkemPrimitives/x448.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DhkemX448HkdfSha512 = void 0;
+    const common_1 = require("@hpke/common");
+    const x448_js_1 = require("./dhkemPrimitives/x448.js");
+    /**
+     * The DHKEM(X448, HKDF-SHA512) for HPKE KEM implementing {@link KemInterface}.
+     *
+     * The instance of this class can be specified to the
+     * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   Aes256Gcm,
+     *   CipherSuite,
+     *   HkdfSha512,
+     *   DhkemX448HkdfSha512,
+     * } from "@hpke/core";
+     *
+     * const suite = new CipherSuite({
+     *   kem: new DhkemX448HkdfSha512(),
+     *   kdf: new HkdfSha512(),
+     *   aead: new Aes256Gcm(),
+     * });
+     * ```
+     */
+    class DhkemX448HkdfSha512 extends common_1.Dhkem {
+        constructor() {
+            const kdf = new common_1.HkdfSha512Native();
+            super(common_1.KemId.DhkemX448HkdfSha512, new x448_js_1.X448(kdf), kdf);
+            /** KemId.DhkemX448HkdfSha512 (0x0021) */
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.KemId.DhkemX448HkdfSha512
+            });
+            /** 64 */
+            Object.defineProperty(this, "secretSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 64
+            });
+            /** 56 */
+            Object.defineProperty(this, "encSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 56
+            });
+            /** 56 */
+            Object.defineProperty(this, "publicKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 56
+            });
+            /** 56 */
+            Object.defineProperty(this, "privateKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 56
+            });
+        }
+    }
+    exports.DhkemX448HkdfSha512 = DhkemX448HkdfSha512;
+});

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

@@ -0,0 +1,5 @@
+export declare class Mutex {
+    #private;
+    lock(): Promise<() => void>;
+}
+//# sourceMappingURL=mutex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutex.d.ts","sourceRoot":"","sources":["../../src/src/mutex.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK;;IAGV,IAAI,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;CAUlC"}

package/node_modules/@hap/core/node_modules/@hpke/core/script/src/mutex.js

@@ -0,0 +1,42 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _Mutex_locked;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Mutex = void 0;
+    class Mutex {
+        constructor() {
+            _Mutex_locked.set(this, Promise.resolve());
+        }
+        async lock() {
+            let releaseLock;
+            const nextLock = new Promise((resolve) => {
+                releaseLock = resolve;
+            });
+            const previousLock = __classPrivateFieldGet(this, _Mutex_locked, "f");
+            __classPrivateFieldSet(this, _Mutex_locked, nextLock, "f");
+            await previousLock;
+            return releaseLock;
+        }
+    }
+    exports.Mutex = Mutex;
+    _Mutex_locked = new WeakMap();
+});