@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/cjs/crypto/Crypto.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const AES_js_1 = __importDefault(require("./nodejs/AES.js"));
+const ARIA_js_1 = __importDefault(require("./nodejs/ARIA.js"));
+const ECIES_js_1 = __importDefault(require("./nodejs/ECIES.js"));
+const RSA_Hybrid_js_1 = __importDefault(require("./nodejs/RSA-Hybrid.js"));
+const NativeCrypto_js_1 = __importDefault(require("./nodejs/NativeCrypto.js"));
+class Crypto {
+    /**
+     * Used to encrypt data before sending it to blockchain
+     * @param algorithm - encryption algorithm
+     * @param content - string data to encrypt
+     * @param key - key in string format (default encoding base64)
+     * @param encoding - encoding of key and output data
+     * @returns {Promise<Encryption>} - object what contains encrypted data, key and spec to decryption
+     */
+    static async encrypt(content, encryption) {
+        switch (encryption.algo) {
+            case dto_js_1.CryptoAlgorithm.AES:
+                return await AES_js_1.default.encrypt(content, encryption);
+            case dto_js_1.CryptoAlgorithm.ARIA:
+                return await ARIA_js_1.default.encrypt(content, encryption);
+            case dto_js_1.CryptoAlgorithm.ECIES:
+                return await ECIES_js_1.default.encrypt(content, encryption);
+            case dto_js_1.CryptoAlgorithm.RSAHybrid:
+                return await RSA_Hybrid_js_1.default.encrypt(content, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param algorithm - file encryption algorithm
+     * @param key – key that will be used to encrypt data
+     * @returns {Promise<Encryption>} - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        switch (encryption.algo) {
+            case dto_js_1.CryptoAlgorithm.AES:
+                return await AES_js_1.default.encryptStream(inputStream, outputStream, encryption);
+            case dto_js_1.CryptoAlgorithm.ARIA:
+                return await ARIA_js_1.default.encryptStream(inputStream, outputStream, encryption);
+            case dto_js_1.CryptoAlgorithm.RSAHybrid:
+                return await RSA_Hybrid_js_1.default.encryptStream(inputStream, outputStream, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Used to decrypt data from blockchain
+     * @param encryption - object what contains encrypted data, key and spec to decryption
+     * @returns {Promise<string>} - decrypted string
+     */
+    static async decrypt(encryption) {
+        switch (encryption.algo) {
+            case dto_js_1.CryptoAlgorithm.AES:
+                return AES_js_1.default.decrypt(encryption);
+            case dto_js_1.CryptoAlgorithm.ARIA:
+                return ARIA_js_1.default.decrypt(encryption);
+            case dto_js_1.CryptoAlgorithm.ECIES:
+                return await ECIES_js_1.default.decrypt(encryption);
+            case dto_js_1.CryptoAlgorithm.RSAHybrid:
+                return RSA_Hybrid_js_1.default.decrypt(encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption – encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        switch (encryption.algo) {
+            case dto_js_1.CryptoAlgorithm.AES:
+                return await AES_js_1.default.decryptStream(inputStream, outputStream, encryption);
+            case dto_js_1.CryptoAlgorithm.ARIA:
+                return await ARIA_js_1.default.decryptStream(inputStream, outputStream, encryption);
+            case dto_js_1.CryptoAlgorithm.RSAHybrid:
+                return await RSA_Hybrid_js_1.default.decryptStream(inputStream, outputStream, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    static async createHash(param1, hashInfo) {
+        const { algo, encoding } = hashInfo;
+        return Buffer.isBuffer(param1)
+            ? NativeCrypto_js_1.default.createHashFromBuffer(param1, algo, encoding)
+            : await NativeCrypto_js_1.default.createHashFromStream(param1, algo, encoding);
+    }
+}
+exports.default = Crypto;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3J5cHRvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NyeXB0by9DcnlwdG8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxtREFRZ0M7QUFFaEMsNkRBQWtDO0FBQ2xDLCtEQUFvQztBQUNwQyxpRUFBc0M7QUFDdEMsMkVBQStDO0FBQy9DLCtFQUFvRDtBQUdwRCxNQUFNLE1BQU07SUFDVjs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBZSxFQUFFLFVBQXNCO1FBQzFELFFBQVEsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3hCLEtBQUssd0JBQWUsQ0FBQyxHQUFHO2dCQUN0QixPQUFPLE1BQU0sZ0JBQUcsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRWhELEtBQUssd0JBQWUsQ0FBQyxJQUFJO2dCQUN2QixPQUFPLE1BQU0saUJBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRWpELEtBQUssd0JBQWUsQ0FBQyxLQUFLO2dCQUN4QixPQUFPLE1BQU0sa0JBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRWxELEtBQUssd0JBQWUsQ0FBQyxTQUFTO2dCQUM1QixPQUFPLE1BQU0sdUJBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRXREO2dCQUNFLE1BQU0sS0FBSyxDQUFDLEdBQUcsVUFBVSxDQUFDLElBQUksMEJBQTBCLENBQUMsQ0FBQztRQUM5RCxDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSSxNQUFNLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FDL0IsV0FBMEIsRUFDMUIsWUFBNEIsRUFDNUIsVUFBc0I7UUFFdEIsUUFBUSxVQUFVLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDeEIsS0FBSyx3QkFBZSxDQUFDLEdBQUc7Z0JBQ3RCLE9BQU8sTUFBTSxnQkFBRyxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsWUFBWSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBQ3hFLEtBQUssd0JBQWUsQ0FBQyxJQUFJO2dCQUN2QixPQUFPLE1BQU0saUJBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLFlBQVksRUFBRSxVQUFVLENBQUMsQ0FBQztZQUN6RSxLQUFLLHdCQUFlLENBQUMsU0FBUztnQkFDNUIsT0FBTyxNQUFNLHVCQUFTLENBQUMsYUFBYSxDQUFDLFdBQVcsRUFBRSxZQUFZLEVBQUUsVUFBVSxDQUFDLENBQUM7WUFDOUU7Z0JBQ0UsTUFBTSxLQUFLLENBQUMsR0FBRyxVQUFVLENBQUMsSUFBSSwwQkFBMEIsQ0FBQyxDQUFDO1FBQzlELENBQUM7SUFDSCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQXNCO1FBQ3pDLFFBQVEsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3hCLEtBQUssd0JBQWUsQ0FBQyxHQUFHO2dCQUN0QixPQUFPLGdCQUFHLENBQUMsT0FBTyxDQUFDLFVBQTJCLENBQUMsQ0FBQztZQUVsRCxLQUFLLHdCQUFlLENBQUMsSUFBSTtnQkFDdkIsT0FBTyxpQkFBSSxDQUFDLE9BQU8sQ0FBQyxVQUE0QixDQUFDLENBQUM7WUFFcEQsS0FBSyx3QkFBZSxDQUFDLEtBQUs7Z0JBQ3hCLE9BQU8sTUFBTSxrQkFBSyxDQUFDLE9BQU8sQ0FBQyxVQUE2QixDQUFDLENBQUM7WUFFNUQsS0FBSyx3QkFBZSxDQUFDLFNBQVM7Z0JBQzVCLE9BQU8sdUJBQVMsQ0FBQyxPQUFPLENBQUMsVUFBaUMsQ0FBQyxDQUFDO1lBRTlEO2dCQUNFLE1BQU0sS0FBSyxDQUFDLEdBQUcsVUFBVSxDQUFDLElBQUksMEJBQTBCLENBQUMsQ0FBQztRQUM5RCxDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksTUFBTSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQy9CLFdBQTBCLEVBQzFCLFlBQTRCLEVBQzVCLFVBQXNCO1FBRXRCLFFBQVEsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3hCLEtBQUssd0JBQWUsQ0FBQyxHQUFHO2dCQUN0QixPQUFPLE1BQU0sZ0JBQUcsQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLFlBQVksRUFBRSxVQUEyQixDQUFDLENBQUM7WUFDekYsS0FBSyx3QkFBZSxDQUFDLElBQUk7Z0JBQ3ZCLE9BQU8sTUFBTSxpQkFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsWUFBWSxFQUFFLFVBQTRCLENBQUMsQ0FBQztZQUMzRixLQUFLLHdCQUFlLENBQUMsU0FBUztnQkFDNUIsT0FBTyxNQUFNLHVCQUFTLENBQUMsYUFBYSxDQUNsQyxXQUFXLEVBQ1gsWUFBWSxFQUNaLFVBQWlDLENBQ2xDLENBQUM7WUFDSjtnQkFDRSxNQUFNLEtBQUssQ0FBQyxHQUFHLFVBQVUsQ0FBQyxJQUFJLDBCQUEwQixDQUFDLENBQUM7UUFDOUQsQ0FBQztJQUNILENBQUM7SUFtQk0sTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQzVCLE1BQXlCLEVBQ3pCLFFBQTRCO1FBRTVCLE1BQU0sRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEdBQUcsUUFBUSxDQUFDO1FBQ3BDLE9BQU8sTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUM7WUFDNUIsQ0FBQyxDQUFDLHlCQUFZLENBQUMsb0JBQW9CLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUM7WUFDM0QsQ0FBQyxDQUFDLE1BQU0seUJBQVksQ0FBQyxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7Q0FDRjtBQUVELGtCQUFlLE1BQU0sQ0FBQyJ9

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

@@ -0,0 +1,2 @@
+import Crypto from './Crypto.js';
+export default Crypto;

package/{build → dist/cjs}/crypto/index.js

@@ -3,6 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Crypto_1 = __importDefault(require("./Crypto"));
-exports.default = Crypto_1.default;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsc0RBQThCO0FBQzlCLGtCQUFlLGdCQUFNLENBQUMifQ==
+const Crypto_js_1 = __importDefault(require("./Crypto.js"));
+exports.default = Crypto_js_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsNERBQWlDO0FBQ2pDLGtCQUFlLG1CQUFNLENBQUMifQ==

package/dist/cjs/crypto/nodejs/AES.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const NativeCrypto_js_1 = __importDefault(require("./NativeCrypto.js"));
+class AES {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || dto_js_1.Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto_js_1.default.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: dto_js_1.CryptoAlgorithm.AES,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param algorithm - file encryption algorithm
+     * @param key – key that will be used to encrypt data
+     * @returns {Promise<Encryption>} - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || dto_js_1.Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto_js_1.default.encryptStream(keyBuffer, inputStream, outputStream, encryption.cipher);
+        return {
+            algo: encryption.algo,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    static decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        return NativeCrypto_js_1.default.decrypt(key, encryption.ciphertext, encryption.cipher, params, encryption.encoding);
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption – encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        await NativeCrypto_js_1.default.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+}
+exports.default = AES;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/crypto/nodejs/ARIA.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const NativeCrypto_js_1 = __importDefault(require("./NativeCrypto.js"));
+class ARIA {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || dto_js_1.Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto_js_1.default.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: dto_js_1.CryptoAlgorithm.ARIA,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param algorithm - file encryption algorithm
+     * @param key – key that will be used to encrypt data
+     * @returns {Promise<Encryption>} - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || dto_js_1.Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto_js_1.default.encryptStream(keyBuffer, inputStream, outputStream, encryption.cipher);
+        return {
+            algo: dto_js_1.CryptoAlgorithm.ARIA,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    static decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        return NativeCrypto_js_1.default.decrypt(key, encryption.ciphertext, encryption.cipher, params, encryption.encoding);
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption – encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        await NativeCrypto_js_1.default.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+}
+exports.default = ARIA;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/crypto/nodejs/ECIES.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const crypto_1 = __importDefault(require("crypto"));
+class ECIES {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        const ecdh = crypto_1.default.createECDH('secp256k1');
+        ecdh.generateKeys();
+        const epk = ecdh.getPublicKey();
+        const pk = ecdh.computeSecret(Buffer.from(encryption.key, encryption.encoding));
+        const hash = crypto_1.default.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.slice(0, 32), macKey = hash.slice(32);
+        const iv = crypto_1.default.randomBytes(16);
+        const cipher = crypto_1.default.createCipheriv('aes-256-cbc', cipherKey, iv);
+        let ct = cipher.update(content);
+        ct = Buffer.concat([ct, cipher.final()]);
+        const dataToMac = Buffer.concat([iv, epk, ct]);
+        const mac = crypto_1.default.createHmac('sha256', macKey).update(dataToMac).digest();
+        return {
+            iv: iv.toString(encryption.encoding),
+            ephemPublicKey: epk.toString(encryption.encoding),
+            mac: mac.toString(encryption.encoding),
+            encoding: encryption.encoding,
+            algo: dto_js_1.CryptoAlgorithm.ECIES,
+            ciphertext: ct.toString(encryption.encoding),
+        };
+    }
+    static async decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const iv = Buffer.from(encryption.iv, encryption.encoding), epk = Buffer.from(encryption.ephemPublicKey, encryption.encoding), ct = Buffer.from(encryption.ciphertext, encryption.encoding), mac = Buffer.from(encryption.mac, encryption.encoding);
+        const ecdh = crypto_1.default.createECDH('secp256k1');
+        ecdh.setPrivateKey(Buffer.from(encryption.key, encryption.encoding));
+        const pk = ecdh.computeSecret(epk);
+        const hash = crypto_1.default.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.slice(0, 32), macKey = hash.slice(32);
+        const m = crypto_1.default
+            .createHmac('sha256', macKey)
+            .update(Buffer.concat([iv, epk, ct]))
+            .digest();
+        if (m.compare(mac) !== 0 || mac.compare(m) !== 0) {
+            throw new Error('Corrupted Ecies body: unmatched authentication code');
+        }
+        const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', cipherKey, iv);
+        const pt = decipher.update(ct);
+        const result = Buffer.concat([pt, decipher.final()]);
+        return result.toString('binary');
+    }
+}
+exports.default = ECIES;
+//# sourceMappingURL=data:application/json;base64,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

package/{build → dist/cjs}/crypto/nodejs/NativeCrypto.d.ts

@@ -41,14 +41,14 @@ declare class NativeCrypto {
     static createKey(cipher: string): Buffer;
     static createIV(cipher: string): Buffer;
     static createCipher(cipher: string, key: Buffer, iv: Buffer): Cipher;
-    static createDecipher(cipher: string, key: Buffer, iv?: Buffer, mac?: Buffer): Decipher;
+    static createDecipher(cipher: string, key: Buffer, iv: Buffer, mac?: Buffer): Decipher;
     static encrypt(key: Buffer, content: string, cipherName: string, outputEncoding?: Encoding, inputEncoding?: BufferEncoding): Partial<EncryptionWithMacIV>;
     static encryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: any, encoding?: Encoding): Promise<Partial<EncryptionWithMacIV>>;
-    static decrypt(key: Buffer, content: string, cipherName: string, params?: {
+    static decrypt(key: Buffer, content: string, cipherName: string, params: {
         iv: Buffer;
         mac?: Buffer;
     }, inputEncoding?: Encoding, outputEncoding?: BufferEncoding): string;
-    static decryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, params?: {
+    static decryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, params: {
         iv: Buffer;
         mac: Buffer;
     }): Promise<void>;

package/dist/cjs/crypto/nodejs/NativeCrypto.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const events_1 = require("events");
+const dto_js_1 = require("@super-protocol/dto-js");
+/**
+ *
+ */
+class NativeCrypto {
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.mode === 'mode'
+     * ```
+     * but it doesn't work in browser
+     */
+    static isCCM = (cipher) => /ccm/i.test(cipher) || cipher === 'chacha20-poly1305';
+    static isGCM = (cipher) => /gcm/i.test(cipher);
+    static isOCB = (cipher) => /ocb/i.test(cipher);
+    static isECB = (cipher) => /ecb/i.test(cipher) || cipher === 'des-ede' || cipher === 'des-ede3';
+    static isRC4 = (cipher) => /^rc4/i.test(cipher);
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getKeyLength(cipher) {
+        if (/256\-xts/.test(cipher)) {
+            return 64;
+        }
+        if (/256|128\-xts|chacha20/.test(cipher) && cipher !== 'aes-128-cbc-hmac-sha256') {
+            return 32;
+        }
+        if (/192|des\-ede3|desx|des3$/.test(cipher) || cipher === 'id-smime-alg-cms3deswrap') {
+            return 24;
+        }
+        if (/128|des\-ede/.test(cipher)) {
+            return 16;
+        }
+        if (/64|des/.test(cipher)) {
+            return 8;
+        }
+        if (/40/.test(cipher)) {
+            return 5;
+        }
+        return 16;
+    }
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getIVLength(cipher) {
+        if (this.isCCM(cipher) || this.isGCM(cipher) || this.isOCB(cipher)) {
+            return 12;
+        }
+        if (/wrap\-pad/.test(cipher)) {
+            return 4;
+        }
+        if (/wrap|cast|des|bf|blowfish|idea|rc2/.test(cipher)) {
+            return 8;
+        }
+        return 16;
+    }
+    static createKey(cipher) {
+        const length = this.getKeyLength(cipher);
+        return (0, crypto_1.randomBytes)(length);
+    }
+    static createIV(cipher) {
+        const length = this.getIVLength(cipher);
+        return (0, crypto_1.randomBytes)(length);
+    }
+    static createCipher(cipher, key, iv) {
+        if (this.isECB(cipher) || this.isRC4(cipher)) {
+            throw new Error(`Cipher "${cipher}" is not supported`);
+        }
+        if (this.isCCM(cipher) || this.isOCB(cipher)) {
+            const options = {
+                authTagLength: 16,
+            };
+            return (0, crypto_1.createCipheriv)(cipher, key, iv, options);
+        }
+        return (0, crypto_1.createCipheriv)(cipher, key, iv);
+    }
+    static createDecipher(cipher, key, iv, mac) {
+        const options = {};
+        if (this.isCCM(cipher) || this.isOCB(cipher)) {
+            options.authTagLength = 16;
+        }
+        const decipher = (0, crypto_1.createDecipheriv)(cipher, key, iv, options);
+        if (mac) {
+            decipher.setAuthTag(mac);
+        }
+        return decipher;
+    }
+    static encrypt(key, content, cipherName, outputEncoding = dto_js_1.Encoding.base64, 
+    // TODO: replace BufferEncoding with Encoding
+    inputEncoding = 'binary') {
+        const iv = this.createIV(cipherName);
+        const result = {};
+        const cipher = this.createCipher(cipherName, key, iv);
+        result.ciphertext = cipher.update(content, inputEncoding, outputEncoding);
+        result.ciphertext += cipher.final(outputEncoding);
+        if (!this.isECB(cipherName) && !this.isRC4(cipherName)) {
+            result.iv = iv.toString(outputEncoding);
+        }
+        if (this.isCCM(cipherName) || this.isGCM(cipherName) || this.isOCB(cipherName)) {
+            result.mac = cipher.getAuthTag().toString(outputEncoding);
+        }
+        return result;
+    }
+    static async encryptStream(key, inputStream, outputStream, cipherName, encoding = dto_js_1.Encoding.base64) {
+        const iv = this.createIV(cipherName);
+        const result = {};
+        const cipher = this.createCipher(cipherName, key, iv);
+        inputStream.pipe(cipher).pipe(outputStream);
+        await (0, events_1.once)(outputStream, 'finish');
+        result.iv = iv.toString(encoding);
+        if (this.isCCM(cipherName) || this.isGCM(cipherName)) {
+            result.mac = cipher.getAuthTag().toString(encoding);
+        }
+        return result;
+    }
+    static decrypt(key, content, cipherName, params, inputEncoding = dto_js_1.Encoding.base64, 
+    // TODO: replace BufferEncoding with Encoding
+    outputEncoding = 'binary') {
+        const decipher = this.createDecipher(cipherName, key, params.iv, params?.mac);
+        let decrypted = decipher.update(content, inputEncoding, outputEncoding);
+        decrypted += decipher.final(outputEncoding);
+        return decrypted;
+    }
+    static async decryptStream(key, inputStream, outputStream, cipherName, params) {
+        const decipher = this.createDecipher(cipherName, key, params.iv, params.mac);
+        inputStream.pipe(decipher).pipe(outputStream);
+        await (0, events_1.once)(outputStream, 'finish');
+    }
+    static createHashFromBuffer(data, algorithm, encoding = dto_js_1.Encoding.base64) {
+        const hash = (0, crypto_1.createHash)(algorithm);
+        hash.update(data);
+        return {
+            algo: algorithm,
+            encoding,
+            hash: hash.digest(encoding),
+        };
+    }
+    static createHashFromStream(inputStream, algorithm, encoding = dto_js_1.Encoding.base64) {
+        const hash = (0, crypto_1.createHash)(algorithm);
+        return new Promise((resolve) => {
+            hash.on('finish', () => {
+                resolve({
+                    algo: algorithm,
+                    encoding,
+                    hash: hash.digest(encoding),
+                });
+            });
+            inputStream.pipe(hash);
+        });
+    }
+}
+exports.default = NativeCrypto;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmF0aXZlQ3J5cHRvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NyeXB0by9ub2RlanMvTmF0aXZlQ3J5cHRvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsbUNBVWdCO0FBRWhCLG1DQUE4QjtBQUU5QixtREFBNEY7QUFFNUY7O0dBRUc7QUFDSCxNQUFNLFlBQVk7SUFDaEI7Ozs7OztPQU1HO0lBQ0ksTUFBTSxDQUFVLEtBQUssR0FBRyxDQUFDLE1BQWMsRUFBVyxFQUFFLENBQ3pELE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxLQUFLLG1CQUFtQixDQUFDO0lBQ2pELE1BQU0sQ0FBVSxLQUFLLEdBQUcsQ0FBQyxNQUFjLEVBQVcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDekUsTUFBTSxDQUFVLEtBQUssR0FBRyxDQUFDLE1BQWMsRUFBVyxFQUFFLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN6RSxNQUFNLENBQVUsS0FBSyxHQUFHLENBQUMsTUFBYyxFQUFXLEVBQUUsQ0FDekQsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxNQUFNLEtBQUssU0FBUyxJQUFJLE1BQU0sS0FBSyxVQUFVLENBQUM7SUFDaEUsTUFBTSxDQUFVLEtBQUssR0FBRyxDQUFDLE1BQWMsRUFBVyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUVqRjs7Ozs7O09BTUc7SUFDSSxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQWM7UUFDdkMsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDNUIsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBQ0QsSUFBSSx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxLQUFLLHlCQUF5QixFQUFFLENBQUM7WUFDakYsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBQ0QsSUFBSSwwQkFBMEIsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxLQUFLLDBCQUEwQixFQUFFLENBQUM7WUFDckYsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBQ0QsSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDaEMsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBQ0QsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDMUIsT0FBTyxDQUFDLENBQUM7UUFDWCxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDdEIsT0FBTyxDQUFDLENBQUM7UUFDWCxDQUFDO1FBQ0QsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFjO1FBQ3RDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUNuRSxPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFDRCxJQUFJLFdBQVcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUM3QixPQUFPLENBQUMsQ0FBQztRQUNYLENBQUM7UUFDRCxJQUFJLG9DQUFvQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQ3RELE9BQU8sQ0FBQyxDQUFDO1FBQ1gsQ0FBQztRQUNELE9BQU8sRUFBRSxDQUFDO0lBQ1osQ0FBQztJQUVNLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBYztRQUNwQyxNQUFNLE1BQU0sR0FBVyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2pELE9BQU8sSUFBQSxvQkFBVyxFQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzdCLENBQUM7SUFDTSxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQWM7UUFDbkMsTUFBTSxNQUFNLEdBQVcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNoRCxPQUFPLElBQUEsb0JBQVcsRUFBQyxNQUFNLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRU0sTUFBTSxDQUFDLFlBQVksQ0FBQyxNQUFjLEVBQUUsR0FBVyxFQUFFLEVBQVU7UUFDaEUsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUM3QyxNQUFNLElBQUksS0FBSyxDQUFDLFdBQVcsTUFBTSxvQkFBb0IsQ0FBQyxDQUFDO1FBQ3pELENBQUM7UUFFRCxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQzdDLE1BQU0sT0FBTyxHQUFxQjtnQkFDaEMsYUFBYSxFQUFFLEVBQUU7YUFDbEIsQ0FBQztZQUNGLE9BQU8sSUFBQSx1QkFBYyxFQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELENBQUM7UUFDRCxPQUFPLElBQUEsdUJBQWMsRUFBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFDTSxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQWMsRUFBRSxHQUFXLEVBQUUsRUFBVSxFQUFFLEdBQVk7UUFDaEYsTUFBTSxPQUFPLEdBQXFCLEVBQUUsQ0FBQztRQUNyQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQzdDLE9BQU8sQ0FBQyxhQUFhLEdBQUcsRUFBRSxDQUFDO1FBQzdCLENBQUM7UUFDRCxNQUFNLFFBQVEsR0FBZ0IsSUFBQSx5QkFBZ0IsRUFBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxPQUFPLENBQWdCLENBQUM7UUFDeEYsSUFBSSxHQUFHLEVBQUUsQ0FBQztZQUNSLFFBQVEsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDM0IsQ0FBQztRQUNELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7SUFFTSxNQUFNLENBQUMsT0FBTyxDQUNuQixHQUFXLEVBQ1gsT0FBZSxFQUNmLFVBQWtCLEVBQ2xCLGlCQUEyQixpQkFBUSxDQUFDLE1BQU07SUFDMUMsNkNBQTZDO0lBQzdDLGdCQUFnQyxRQUFRO1FBRXhDLE1BQU0sRUFBRSxHQUFXLElBQUksQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDN0MsTUFBTSxNQUFNLEdBQWlDLEVBQUUsQ0FBQztRQUVoRCxNQUFNLE1BQU0sR0FBVyxJQUFJLENBQUMsWUFBWSxDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFOUQsTUFBTSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDMUUsTUFBTSxDQUFDLFVBQVUsSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBRWxELElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO1lBQ3ZELE1BQU0sQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUMxQyxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO1lBQy9FLE1BQU0sQ0FBQyxHQUFHLEdBQUksTUFBb0IsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDM0UsQ0FBQztRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FDL0IsR0FBVyxFQUNYLFdBQXVCLEVBQ3ZCLFlBQXlCLEVBQ3pCLFVBQWUsRUFDZixXQUFxQixpQkFBUSxDQUFDLE1BQU07UUFFcEMsTUFBTSxFQUFFLEdBQVcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUM3QyxNQUFNLE1BQU0sR0FBaUMsRUFBRSxDQUFDO1FBRWhELE1BQU0sTUFBTSxHQUFXLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUU5RCxXQUFXLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUM1QyxNQUFNLElBQUEsYUFBSSxFQUFDLFlBQVksRUFBRSxRQUFRLENBQUMsQ0FBQztRQUVuQyxNQUFNLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDbEMsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQztZQUNyRCxNQUFNLENBQUMsR0FBRyxHQUFJLE1BQW9CLENBQUMsVUFBVSxFQUFFLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3JFLENBQUM7UUFFRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRU0sTUFBTSxDQUFDLE9BQU8sQ0FDbkIsR0FBVyxFQUNYLE9BQWUsRUFDZixVQUFrQixFQUNsQixNQUdDLEVBQ0QsZ0JBQTBCLGlCQUFRLENBQUMsTUFBTTtJQUN6Qyw2Q0FBNkM7SUFDN0MsaUJBQWlDLFFBQVE7UUFFekMsTUFBTSxRQUFRLEdBQWEsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1FBRXhGLElBQUksU0FBUyxHQUFXLFFBQVEsQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQztRQUNoRixTQUFTLElBQUksUUFBUSxDQUFDLEtBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUU1QyxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQy9CLEdBQVcsRUFDWCxXQUF1QixFQUN2QixZQUF5QixFQUN6QixVQUFrQixFQUNsQixNQUdDO1FBRUQsTUFBTSxRQUFRLEdBQWEsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBRXZGLFdBQVcsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzlDLE1BQU0sSUFBQSxhQUFJLEVBQUMsWUFBWSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFTSxNQUFNLENBQUMsb0JBQW9CLENBQ2hDLElBQVksRUFDWixTQUF3QixFQUN4QixRQUFRLEdBQUcsaUJBQVEsQ0FBQyxNQUFNO1FBRTFCLE1BQU0sSUFBSSxHQUFHLElBQUEsbUJBQVUsRUFBQyxTQUFTLENBQUMsQ0FBQztRQUNuQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2xCLE9BQU87WUFDTCxJQUFJLEVBQUUsU0FBUztZQUNmLFFBQVE7WUFDUixJQUFJLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUM7U0FDNUIsQ0FBQztJQUNKLENBQUM7SUFFTSxNQUFNLENBQUMsb0JBQW9CLENBQ2hDLFdBQXFCLEVBQ3JCLFNBQXdCLEVBQ3hCLFFBQVEsR0FBRyxpQkFBUSxDQUFDLE1BQU07UUFFMUIsTUFBTSxJQUFJLEdBQUcsSUFBQSxtQkFBVSxFQUFDLFNBQVMsQ0FBQyxDQUFDO1FBRW5DLE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRTtZQUM3QixJQUFJLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxHQUFHLEVBQUU7Z0JBQ3JCLE9BQU8sQ0FBQztvQkFDTixJQUFJLEVBQUUsU0FBUztvQkFDZixRQUFRO29CQUNSLElBQUksRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQztpQkFDNUIsQ0FBQyxDQUFDO1lBQ0wsQ0FBQyxDQUFDLENBQUM7WUFFSCxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7QUFHSCxrQkFBZSxZQUFZLENBQUMifQ==

package/dist/cjs/crypto/nodejs/RSA-Hybrid.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const crypto_1 = require("crypto");
+const NativeCrypto_js_1 = __importDefault(require("./NativeCrypto.js"));
+class RSAHybrid {
+    static getKeyFingerprint(key) {
+        const jsonKey = key.export({ format: 'jwk' });
+        const buffer = Buffer.concat([
+            Buffer.from('ssh-rsa'),
+            Buffer.from(jsonKey.e || ''),
+            Buffer.from(jsonKey.n || ''),
+        ]);
+        const hex = (0, crypto_1.createHash)('md5').update(buffer).digest('hex');
+        return hex.match(/.{2}/g).join(':');
+    }
+    static publicEncrypt(rsaKey, aesKey) {
+        const publicKey = (0, crypto_1.createPublicKey)({
+            key: rsaKey,
+            format: 'pem',
+        });
+        const encryptedKey = (0, crypto_1.publicEncrypt)({
+            key: publicKey,
+            padding: crypto_1.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256',
+        }, Buffer.from(aesKey));
+        const keyFingerprint = this.getKeyFingerprint(publicKey);
+        return {
+            [keyFingerprint]: encryptedKey.toString('base64'),
+        };
+    }
+    static privateDecrypt(rsaKey, keys) {
+        const privateKey = (0, crypto_1.createPrivateKey)({
+            key: rsaKey,
+            format: 'pem',
+        });
+        const keyFingerprint = this.getKeyFingerprint(privateKey);
+        const encryptedKey = keys[keyFingerprint];
+        const aesKey = (0, crypto_1.privateDecrypt)({
+            key: privateKey,
+            padding: crypto_1.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256',
+        }, Buffer.from(encryptedKey, 'base64'));
+        return aesKey;
+    }
+    static encrypt(content, encryption) {
+        const aesKey = (0, crypto_1.randomBytes)(32);
+        const keys = this.publicEncrypt(encryption.key, aesKey);
+        const encrypted = NativeCrypto_js_1.default.encrypt(aesKey, content, dto_js_1.Cipher.AES_256_GCM, encryption.encoding);
+        return {
+            ...encrypted,
+            encoding: encryption.encoding,
+            algo: dto_js_1.CryptoAlgorithm.RSAHybrid,
+            cipher: dto_js_1.Cipher.RSA_OAEP_AES_GCM,
+            keys: JSON.stringify(keys),
+        };
+    }
+    static async encryptStream(inputStream, outputStream, encryption) {
+        const aesKey = (0, crypto_1.randomBytes)(32);
+        const keys = this.publicEncrypt(encryption.key, aesKey);
+        const encrypted = (await NativeCrypto_js_1.default.encryptStream(aesKey, inputStream, outputStream, dto_js_1.Cipher.AES_256_GCM, encryption.encoding));
+        return {
+            ...encrypted,
+            encoding: encryption.encoding,
+            algo: dto_js_1.CryptoAlgorithm.RSAHybrid,
+            cipher: dto_js_1.Cipher.RSA_OAEP_AES_GCM,
+            keys: JSON.stringify(keys),
+        };
+    }
+    static decrypt(encryption) {
+        const iv = Buffer.from(encryption.iv, encryption.encoding);
+        const mac = Buffer.from(encryption.mac, encryption.encoding);
+        const aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+        const decrypted = NativeCrypto_js_1.default.decrypt(aesKey, encryption.ciphertext, dto_js_1.Cipher.AES_256_GCM, {
+            iv,
+            mac,
+        }, encryption.encoding);
+        return decrypted;
+    }
+    static async decryptStream(inputStream, outputStream, encryption) {
+        const iv = Buffer.from(encryption.iv, encryption.encoding);
+        const mac = Buffer.from(encryption.mac, encryption.encoding);
+        const aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+        await NativeCrypto_js_1.default.decryptStream(aesKey, inputStream, outputStream, dto_js_1.Cipher.AES_256_GCM, {
+            iv,
+            mac,
+        });
+    }
+}
+exports.default = RSAHybrid;
+//# sourceMappingURL=data:application/json;base64,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