@privateaim/kit 0.8.4 → 0.8.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.8.5](https://github.com/PrivateAIM/hub/compare/v0.8.4...v0.8.5) (2025-01-22)
+
+
+### Features
+
+* basic web crypto implementation (P.P. research-project) + node key-pair generation ([#912](https://github.com/PrivateAIM/hub/issues/912)) ([8cdb9d8](https://github.com/PrivateAIM/hub/commit/8cdb9d8ff140400426ccbd61f254a47fa0e3fab1))
+
+
+### Bug Fixes
+
+* **deps:** bump @authup/core-kit from 1.0.0-beta.22 to 1.0.0-beta.23 ([#896](https://github.com/PrivateAIM/hub/issues/896)) ([e0dcfed](https://github.com/PrivateAIM/hub/commit/e0dcfed47320bd53fadbca11a05ca677ed0ef7ff))
+* **deps:** bump authup to v1.0.0-beta.24 ([#963](https://github.com/PrivateAIM/hub/issues/963)) ([90c40c0](https://github.com/PrivateAIM/hub/commit/90c40c0d55018557ee8bb381aad7e3cfbcd29b83))
+
 ## [0.8.4](https://github.com/PrivateAIM/hub/compare/v0.8.3...v0.8.4) (2024-10-24)
 
 

package/dist/crypto/asymmetric/constants.d.ts

@@ -0,0 +1,5 @@
+export declare enum AsymmetricCryptoAlgorithmName {
+    RSA_OAEP = "RSA-OAEP",
+    ECDH = "ECDH"
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/crypto/asymmetric/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/crypto/asymmetric/constants.ts"],"names":[],"mappings":"AAOA,oBAAY,6BAA6B;IACrC,QAAQ,aAAa;IAErB,IAAI,SAAS;CAChB"}

package/dist/crypto/asymmetric/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { AsymmetricAlgorithmImportParams } from './types';
+export declare function exportAsymmetricPublicKey(key: CryptoKey): Promise<string>;
+export declare function exportAsymmetricPrivateKey(key: CryptoKey): Promise<string>;
+export declare function importAsymmetricPublicKey(pem: string, params: AsymmetricAlgorithmImportParams): Promise<CryptoKey>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/crypto/asymmetric/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/crypto/asymmetric/helpers.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAM/D,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO/E;AAED,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAOhF;AAED,wBAAsB,yBAAyB,CAC3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,+BAA+B,GACxC,OAAO,CAAC,SAAS,CAAC,CAuBpB"}

package/dist/crypto/asymmetric/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './helpers';
+export * from './module';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto/asymmetric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/asymmetric/index.ts"],"names":[],"mappings":"AAOA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/crypto/asymmetric/module.d.ts

@@ -0,0 +1,14 @@
+import type { AsymmetricAlgorithmImportParams, AsymmetricAlgorithmParams } from './types';
+export declare class CryptoAsymmetricAlgorithm {
+    readonly algorithm: AsymmetricAlgorithmParams;
+    protected keyPair: CryptoKeyPair | undefined;
+    constructor(algorithm: AsymmetricAlgorithmParams);
+    buildImportParams(): AsymmetricAlgorithmImportParams;
+    generateKeyPair(): Promise<CryptoKeyPair>;
+    useKeyPair(): Promise<CryptoKeyPair>;
+    exportPublicKey(): Promise<string>;
+    exportPrivateKey(): Promise<string>;
+    encrypt(data: Buffer, remoteKey?: CryptoKey): Promise<ArrayBuffer>;
+    decrypt(data: Buffer, remoteKey?: CryptoKey): Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/crypto/asymmetric/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/crypto/asymmetric/module.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,+BAA+B,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAG1F,qBAAa,yBAAyB;IAClC,SAAgB,SAAS,EAAE,yBAAyB,CAAC;IAErD,SAAS,CAAC,OAAO,EAAG,aAAa,GAAG,SAAS,CAAC;gBAElC,SAAS,EAAE,yBAAyB;IAWhD,iBAAiB,IAAK,+BAA+B;IAmB/C,eAAe,IAAK,OAAO,CAAC,aAAa,CAAC;IAwB1C,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC;IAQpC,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC;IAMlC,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAMnC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS;IAoD3C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS;CA+CpD"}

package/dist/crypto/asymmetric/types.d.ts

@@ -0,0 +1,3 @@
+export type AsymmetricAlgorithmParams = RsaHashedKeyGenParams | EcKeyGenParams;
+export type AsymmetricAlgorithmImportParams = RsaHashedImportParams | EcKeyImportParams;
+//# sourceMappingURL=types.d.ts.map

package/dist/crypto/asymmetric/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/crypto/asymmetric/types.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,yBAAyB,GAAG,qBAAqB,GAAG,cAAc,CAAC;AAC/E,MAAM,MAAM,+BAA+B,GAAG,qBAAqB,GAAG,iBAAiB,CAAC"}

package/dist/crypto/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asymmetric';
+export * from './symmetric';
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAOA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dist/crypto/symmetric/index.d.ts

@@ -0,0 +1,3 @@
+export * from './module';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto/symmetric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/symmetric/index.ts"],"names":[],"mappings":"AAOA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/crypto/symmetric/module.d.ts

@@ -0,0 +1,10 @@
+import type { SymmetricAlgorithmParams } from './types';
+export declare class CryptoSymmetricAlgorithm {
+    protected algorithm: SymmetricAlgorithmParams;
+    constructor(algorithm: SymmetricAlgorithmParams);
+    generateKey(): Promise<CryptoKey>;
+    importKey(buffer: Buffer | ArrayBuffer): Promise<CryptoKey>;
+    encrypt(key: CryptoKey, iv: Buffer, data: Buffer): Promise<Buffer>;
+    decrypt(key: CryptoKey, data: Buffer): Promise<Buffer>;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/crypto/symmetric/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/crypto/symmetric/module.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExD,qBAAa,wBAAwB;IACjC,SAAS,CAAC,SAAS,EAAG,wBAAwB,CAAC;gBAEnC,SAAS,EAAE,wBAAwB;IAIzC,WAAW,IAAK,OAAO,CAAC,SAAS,CAAC;IAWlC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAI,OAAO,CAAC,SAAS,CAAC;IAa5D,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAI,OAAO,CAAC,MAAM,CAAC;IAgBnE,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAI,OAAO,CAAC,MAAM,CAAC;CAchE"}

package/dist/crypto/symmetric/types.d.ts

@@ -0,0 +1,3 @@
+import type { webcrypto } from 'crypto';
+export type SymmetricAlgorithmParams = webcrypto.AesKeyGenParams;
+//# sourceMappingURL=types.d.ts.map

package/dist/crypto/symmetric/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/crypto/symmetric/types.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAAC,eAAe,CAAC"}

package/dist/index.cjs

@@ -2,6 +2,426 @@
 
 var nanoid = require('nanoid');
 
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ var AsymmetricCryptoAlgorithmName = /*#__PURE__*/ function(AsymmetricCryptoAlgorithmName) {
+    AsymmetricCryptoAlgorithmName["RSA_OAEP"] = "RSA-OAEP";
+    AsymmetricCryptoAlgorithmName["ECDH"] = "ECDH";
+    return AsymmetricCryptoAlgorithmName;
+}({});
+
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function arrayBufferToBase64(arrayBuffer) {
+    return btoa(String.fromCharCode.apply(null, new Uint8Array(arrayBuffer)));
+}
+function exportAsymmetricPublicKey(key) {
+    return _exportAsymmetricPublicKey.apply(this, arguments);
+}
+function _exportAsymmetricPublicKey() {
+    _exportAsymmetricPublicKey = _async_to_generator$2(function*(key) {
+        const exported = yield crypto.subtle.exportKey('spki', key);
+        return `-----BEGIN PUBLIC KEY-----\n${arrayBufferToBase64(exported)}\n-----END PUBLIC KEY-----`;
+    });
+    return _exportAsymmetricPublicKey.apply(this, arguments);
+}
+function exportAsymmetricPrivateKey(key) {
+    return _exportAsymmetricPrivateKey.apply(this, arguments);
+}
+function _exportAsymmetricPrivateKey() {
+    _exportAsymmetricPrivateKey = _async_to_generator$2(function*(key) {
+        const exported = yield crypto.subtle.exportKey('pkcs8', key);
+        return `-----BEGIN PRIVATE KEY-----\n${arrayBufferToBase64(exported)}\n-----END PRIVATE KEY-----`;
+    });
+    return _exportAsymmetricPrivateKey.apply(this, arguments);
+}
+function importAsymmetricPublicKey(pem, params) {
+    return _importAsymmetricPublicKey.apply(this, arguments);
+}
+function _importAsymmetricPublicKey() {
+    _importAsymmetricPublicKey = _async_to_generator$2(function*(pem, params) {
+        const pemHeader = '-----BEGIN PUBLIC KEY-----';
+        const pemFooter = '-----END PUBLIC KEY-----';
+        const pemContents = pem.substring(pemHeader.length, pem.length - pemFooter.length);
+        const buffer = Buffer.from(pemContents, 'base64');
+        if (params.name === 'ECDH') {
+            return crypto.subtle.importKey('spki', buffer, params, true, [
+                'deriveKey'
+            ]);
+        }
+        return crypto.subtle.importKey('spki', buffer, params, true, [
+            'encrypt'
+        ]);
+    });
+    return _importAsymmetricPublicKey.apply(this, arguments);
+}
+
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+class CryptoAsymmetricAlgorithm {
+    buildImportParams() {
+        if (this.algorithm.name === AsymmetricCryptoAlgorithmName.RSA_OAEP) {
+            return {
+                name: 'RSA-OAEP',
+                hash: 'SHA-256'
+            };
+        }
+        if (this.algorithm.name === AsymmetricCryptoAlgorithmName.ECDH) {
+            return {
+                name: 'ECDH',
+                namedCurve: this.algorithm.namedCurve,
+                hash: 'SHA-256'
+            };
+        }
+        throw new Error('Import params could not be created.');
+    }
+    generateKeyPair() {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.RSA_OAEP) {
+                _this.keyPair = yield crypto.subtle.generateKey(_this.algorithm, true, [
+                    'encrypt',
+                    'decrypt'
+                ]);
+                return _this.keyPair;
+            }
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.ECDH) {
+                _this.keyPair = yield crypto.subtle.generateKey(_this.algorithm, true, [
+                    'deriveKey'
+                ]);
+                return _this.keyPair;
+            }
+            throw new Error('The algorithm is not supported for key generation.');
+        })();
+    }
+    useKeyPair() {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            if (typeof _this.keyPair !== 'undefined') {
+                return _this.keyPair;
+            }
+            return _this.generateKeyPair();
+        })();
+    }
+    exportPublicKey() {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            const keyPair = yield _this.useKeyPair();
+            return exportAsymmetricPublicKey(keyPair.publicKey);
+        })();
+    }
+    exportPrivateKey() {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            const keyPair = yield _this.useKeyPair();
+            return exportAsymmetricPrivateKey(keyPair.privateKey);
+        })();
+    }
+    encrypt(data, remoteKey) {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            const keyPair = yield _this.useKeyPair();
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.RSA_OAEP) {
+                return crypto.subtle.encrypt({
+                    name: 'RSA-OAEP'
+                }, remoteKey || keyPair.publicKey, data);
+            }
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.ECDH) {
+                if (typeof remoteKey === 'undefined') {
+                    throw new Error('Remote public key is required.');
+                }
+                const array = new Uint8Array(16);
+                const iv = crypto.getRandomValues(array);
+                const key = yield crypto.subtle.deriveKey({
+                    name: 'ECDH',
+                    public: remoteKey
+                }, keyPair.privateKey, {
+                    name: 'AES-GCM',
+                    length: 256
+                }, true, [
+                    'encrypt'
+                ]);
+                const arrayBuffer = yield crypto.subtle.encrypt({
+                    name: 'AES-GCM',
+                    length: 256,
+                    iv
+                }, key, data);
+                const buffer = Buffer.from(arrayBuffer);
+                return Buffer.concat([
+                    iv,
+                    buffer
+                ]);
+            }
+            throw new Error('Unsupported algorithm for encryption.');
+        })();
+    }
+    decrypt(data, remoteKey) {
+        var _this = this;
+        return _async_to_generator$1(function*() {
+            const keyPair = yield _this.useKeyPair();
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.RSA_OAEP) {
+                return crypto.subtle.decrypt({
+                    name: 'RSA-OAEP'
+                }, keyPair.privateKey, data);
+            }
+            if (_this.algorithm.name === AsymmetricCryptoAlgorithmName.ECDH) {
+                if (typeof remoteKey === 'undefined') {
+                    throw new Error('Remote public key is required.');
+                }
+                const iv = data.slice(0, 16);
+                const key = yield crypto.subtle.deriveKey({
+                    name: 'ECDH',
+                    public: remoteKey
+                }, keyPair.privateKey, {
+                    name: 'AES-GCM',
+                    length: 256
+                }, true, [
+                    'decrypt'
+                ]);
+                return crypto.subtle.decrypt({
+                    name: 'AES-GCM',
+                    length: 256,
+                    iv
+                }, key, data.slice(16));
+            }
+            throw new Error('Unsupported algorithm for decryption.');
+        })();
+    }
+    constructor(algorithm){
+        _define_property$1(this, "algorithm", undefined);
+        _define_property$1(this, "keyPair", undefined);
+        if (algorithm.name === AsymmetricCryptoAlgorithmName.RSA_OAEP) {
+            algorithm = _object_spread_props(_object_spread({}, algorithm), {
+                publicExponent: new Uint8Array([
+                    1,
+                    0,
+                    1
+                ])
+            });
+        }
+        this.algorithm = algorithm;
+    }
+}
+
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class CryptoSymmetricAlgorithm {
+    generateKey() {
+        var _this = this;
+        return _async_to_generator(function*() {
+            return crypto.subtle.generateKey({
+                name: _this.algorithm.name,
+                length: 256
+            }, true, [
+                'encrypt',
+                'decrypt'
+            ]);
+        })();
+    }
+    importKey(buffer) {
+        var _this = this;
+        return _async_to_generator(function*() {
+            return crypto.subtle.importKey('raw', buffer, {
+                name: _this.algorithm.name,
+                length: 256
+            }, true, [
+                'encrypt',
+                'decrypt'
+            ]);
+        })();
+    }
+    encrypt(key, iv, data) {
+        var _this = this;
+        return _async_to_generator(function*() {
+            const arrayBuffer = yield crypto.subtle.encrypt({
+                name: _this.algorithm.name,
+                length: 256,
+                iv
+            }, key, data);
+            const buffer = Buffer.from(arrayBuffer);
+            return Buffer.concat([
+                iv,
+                buffer
+            ]);
+        })();
+    }
+    decrypt(key, data) {
+        var _this = this;
+        return _async_to_generator(function*() {
+            const iv = data.slice(0, 16);
+            const arrayBuffer = yield crypto.subtle.decrypt({
+                name: _this.algorithm.name,
+                length: 256,
+                iv
+            }, key, data.slice(16));
+            return Buffer.from(arrayBuffer);
+        })();
+    }
+    constructor(algorithm){
+        _define_property(this, "algorithm", undefined);
+        this.algorithm = algorithm;
+    }
+}
+
 /*
  * Copyright (c) 2021-2024.
  * Author Peter Placzek (tada5hi)
@@ -193,15 +613,21 @@ const registryRobotSecretRegex = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$/;
     return EnvironmentName;
 }({});
 
+exports.AsymmetricCryptoAlgorithmName = AsymmetricCryptoAlgorithmName;
+exports.CryptoAsymmetricAlgorithm = CryptoAsymmetricAlgorithm;
+exports.CryptoSymmetricAlgorithm = CryptoSymmetricAlgorithm;
 exports.EnvironmentName = EnvironmentName;
 exports.PermissionName = PermissionName;
 exports.alphaNumHyphenUnderscoreRegex = alphaNumHyphenUnderscoreRegex;
 exports.createNanoID = createNanoID;
 exports.deleteUndefinedObjectProperties = deleteUndefinedObjectProperties;
 exports.detectProxyConnectionConfig = detectProxyConnectionConfig;
+exports.exportAsymmetricPrivateKey = exportAsymmetricPrivateKey;
+exports.exportAsymmetricPublicKey = exportAsymmetricPublicKey;
 exports.getHostNameFromString = getHostNameFromString;
 exports.hasOwnProperty = hasOwnProperty;
 exports.hexToUTF8 = hexToUTF8;
+exports.importAsymmetricPublicKey = importAsymmetricPublicKey;
 exports.isBool = isBool;
 exports.isBoolFalse = isBoolFalse;
 exports.isBoolTrue = isBoolTrue;