@suveren/gateway 0.40.0 → 0.41.1

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

@@ -0,0 +1,230 @@
+(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.XCurveNativeDhkemPrimitives = void 0;
+    const common_1 = require("@hpke/common");
+    class XCurveNativeDhkemPrimitives extends common_1.NativeAlgorithm {
+        constructor(algName, nSize, pkcs8AlgId, basePoint, 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
+            });
+            Object.defineProperty(this, "_algName", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_basePoint", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            this._algName = algName;
+            this._alg = { name: algName };
+            this._hkdf = hkdf;
+            this._nPk = nSize;
+            this._nSk = nSize;
+            this._nDh = nSize;
+            this._pkcs8AlgId = pkcs8AlgId;
+            this._basePoint = basePoint;
+        }
+        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(this._algName, 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 {
+                    const bp = await this._api.importKey("raw", this._basePoint.buffer, this._alg, true, []);
+                    const bits = await this._api.deriveBits({
+                        name: this._algName,
+                        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: this._algName,
+                    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 !== this._algName) {
+                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.XCurveNativeDhkemPrimitives = XCurveNativeDhkemPrimitives;
+});

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 09 Oct 2026 18:42:20 GMT
+ * Last updated: Wed, 28 Oct 2026 18:34:16 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.6.5",
+    "version": "26.6.6",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -135,6 +135,6 @@
         "undici-types": "~8.9.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "3196021f34db9bcb68a729bd29ff60434d3b4c5f49619270db25e7dbd6dc651c",
+    "typesPublisherContentHash": "53beb6693c262ca57af67f961a0fd8dbb7ffa495737a63f1676f34d45ddaa189",
     "typeScriptVersion": "5.6"
 }