@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

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

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const crypto_1 = __importStar(require("crypto"));
+class ECIES {
+    static 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.subarray(0, 32), macKey = hash.subarray(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 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.subarray(0, 32), macKey = hash.subarray(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');
+    }
+    static getPublicFromPrivate(privateKey) {
+        const ecdh = crypto_1.default.createECDH('secp256k1');
+        ecdh.setPrivateKey(Buffer.from(privateKey.key, privateKey.encoding));
+        return ecdh.getPublicKey(privateKey.encoding);
+    }
+    static getPublicKeyEncryption = (encryption) => {
+        if (encryption.algo !== dto_js_1.CryptoAlgorithm.ECIES) {
+            throw Error('Only ECIES result encryption is supported');
+        }
+        if (encryption.encoding !== dto_js_1.Encoding.base64) {
+            throw new Error('Only base64 result encryption is supported');
+        }
+        if (!encryption.key) {
+            throw new Error('Encryption private key is not provided');
+        }
+        return {
+            algo: encryption.algo,
+            encoding: encryption.encoding,
+            key: this.getPublicFromPrivate(encryption),
+        };
+    };
+    static generateKeys(namedCurve = 'secp256k1') {
+        return new Promise((resolve, reject) => {
+            (0, crypto_1.generateKeyPair)('ec', { namedCurve }, (err, publicKey, privateKey) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve({ publicKey, privateKey });
+            });
+        });
+    }
+}
+exports.default = ECIES;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/crypto/nodejs/NativeCrypto.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+import { Cipher, Decipher } from 'crypto';
+import { Readable } from 'stream';
+import { Encoding, EncryptionWithMacIV, Hash, HashAlgorithm } from '@super-protocol/dto-js';
+/**
+ *
+ */
+declare class NativeCrypto {
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getKeyLength(cipher: string): number;
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getIVLength(cipher: string): number;
+    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 encrypt(key: Buffer, content: string, cipherName: string, outputEncoding?: Encoding, inputEncoding?: BufferEncoding): Partial<EncryptionWithMacIV>;
+    static encryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, encoding?: Encoding): Promise<Partial<EncryptionWithMacIV>>;
+    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: {
+        iv: Buffer;
+        mac?: Buffer;
+    }): Promise<void>;
+    static createHashFromBuffer(data: Buffer, algorithm: HashAlgorithm, encoding?: Encoding): Hash;
+    static createHashFromStream(inputStream: Readable, algorithm: HashAlgorithm, encoding?: Encoding): Promise<Hash>;
+}
+export default NativeCrypto;

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

@@ -0,0 +1,154 @@
+"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");
+const utils_js_1 = require("../utils.js");
+/**
+ *
+ */
+class NativeCrypto {
+    /**
+     * 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 ((0, utils_js_1.isCCM)(cipher) || (0, utils_js_1.isGCM)(cipher) || (0, utils_js_1.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 ((0, utils_js_1.isECB)(cipher) || (0, utils_js_1.isRC4)(cipher)) {
+            throw new Error(`Cipher "${cipher}" is not supported`);
+        }
+        if ((0, utils_js_1.isCCM)(cipher) || (0, utils_js_1.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 ((0, utils_js_1.isCCM)(cipher) || (0, utils_js_1.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 (!(0, utils_js_1.isECB)(cipherName) && !(0, utils_js_1.isRC4)(cipherName)) {
+            result.iv = iv.toString(outputEncoding);
+        }
+        if ((0, utils_js_1.isCCM)(cipherName) || (0, utils_js_1.isGCM)(cipherName) || (0, utils_js_1.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 ((0, utils_js_1.isCCM)(cipherName) || (0, utils_js_1.isGCM)(cipherName) || (0, utils_js_1.isOCB)(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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmF0aXZlQ3J5cHRvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NyeXB0by9ub2RlanMvTmF0aXZlQ3J5cHRvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQ0EsbUNBVWdCO0FBRWhCLG1DQUE4QjtBQUM5QixtREFBNEY7QUFDNUYsMENBQWdFO0FBRWhFOztHQUVHO0FBQ0gsTUFBTSxZQUFZO0lBQ2hCOzs7Ozs7T0FNRztJQUNJLE1BQU0sQ0FBQyxZQUFZLENBQUMsTUFBYztRQUN2QyxJQUFJLFNBQVMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUMzQixPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFDRCxJQUFJLHNCQUFzQixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxNQUFNLEtBQUsseUJBQXlCLEVBQUUsQ0FBQztZQUNoRixPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFDRCxJQUFJLHlCQUF5QixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxNQUFNLEtBQUssMEJBQTBCLEVBQUUsQ0FBQztZQUNwRixPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFDRCxJQUFJLGFBQWEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUMvQixPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFDRCxJQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUMxQixPQUFPLENBQUMsQ0FBQztRQUNYLENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUN0QixPQUFPLENBQUMsQ0FBQztRQUNYLENBQUM7UUFDRCxPQUFPLEVBQUUsQ0FBQztJQUNaLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQWM7UUFDdEMsSUFBSSxJQUFBLGdCQUFLLEVBQUMsTUFBTSxDQUFDLElBQUksSUFBQSxnQkFBSyxFQUFDLE1BQU0sQ0FBQyxJQUFJLElBQUEsZ0JBQUssRUFBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQ3BELE9BQU8sRUFBRSxDQUFDO1FBQ1osQ0FBQztRQUNELElBQUksVUFBVSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQzVCLE9BQU8sQ0FBQyxDQUFDO1FBQ1gsQ0FBQztRQUNELElBQUksb0NBQW9DLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDdEQsT0FBTyxDQUFDLENBQUM7UUFDWCxDQUFDO1FBQ0QsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBRU0sTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFjO1FBQ3BDLE1BQU0sTUFBTSxHQUFXLElBQUksQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDakQsT0FBTyxJQUFBLG9CQUFXLEVBQUMsTUFBTSxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUNNLE1BQU0sQ0FBQyxRQUFRLENBQUMsTUFBYztRQUNuQyxNQUFNLE1BQU0sR0FBVyxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2hELE9BQU8sSUFBQSxvQkFBVyxFQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzdCLENBQUM7SUFFTSxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQWMsRUFBRSxHQUFXLEVBQUUsRUFBVTtRQUNoRSxJQUFJLElBQUEsZ0JBQUssRUFBQyxNQUFNLENBQUMsSUFBSSxJQUFBLGdCQUFLLEVBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUNuQyxNQUFNLElBQUksS0FBSyxDQUFDLFdBQVcsTUFBTSxvQkFBb0IsQ0FBQyxDQUFDO1FBQ3pELENBQUM7UUFFRCxJQUFJLElBQUEsZ0JBQUssRUFBQyxNQUFNLENBQUMsSUFBSSxJQUFBLGdCQUFLLEVBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUNuQyxNQUFNLE9BQU8sR0FBcUI7Z0JBQ2hDLGFBQWEsRUFBRSxFQUFFO2FBQ2xCLENBQUM7WUFDRixPQUFPLElBQUEsdUJBQWMsRUFBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNsRCxDQUFDO1FBQ0QsT0FBTyxJQUFBLHVCQUFjLEVBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBQ00sTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFjLEVBQUUsR0FBVyxFQUFFLEVBQVUsRUFBRSxHQUFZO1FBQ2hGLE1BQU0sT0FBTyxHQUFxQixFQUFFLENBQUM7UUFDckMsSUFBSSxJQUFBLGdCQUFLLEVBQUMsTUFBTSxDQUFDLElBQUksSUFBQSxnQkFBSyxFQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDbkMsT0FBTyxDQUFDLGFBQWEsR0FBRyxFQUFFLENBQUM7UUFDN0IsQ0FBQztRQUNELE1BQU0sUUFBUSxHQUFnQixJQUFBLHlCQUFnQixFQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLE9BQU8sQ0FBZ0IsQ0FBQztRQUN4RixJQUFJLEdBQUcsRUFBRSxDQUFDO1lBQ1IsUUFBUSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUMzQixDQUFDO1FBQ0QsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxPQUFPLENBQ25CLEdBQVcsRUFDWCxPQUFlLEVBQ2YsVUFBa0IsRUFDbEIsaUJBQTJCLGlCQUFRLENBQUMsTUFBTTtJQUMxQyw2Q0FBNkM7SUFDN0MsZ0JBQWdDLFFBQVE7UUFFeEMsTUFBTSxFQUFFLEdBQVcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUM3QyxNQUFNLE1BQU0sR0FBaUMsRUFBRSxDQUFDO1FBRWhELE1BQU0sTUFBTSxHQUFXLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUU5RCxNQUFNLENBQUMsVUFBVSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQztRQUMxRSxNQUFNLENBQUMsVUFBVSxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFbEQsSUFBSSxDQUFDLElBQUEsZ0JBQUssRUFBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUEsZ0JBQUssRUFBQyxVQUFVLENBQUMsRUFBRSxDQUFDO1lBQzdDLE1BQU0sQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUMxQyxDQUFDO1FBQ0QsSUFBSSxJQUFBLGdCQUFLLEVBQUMsVUFBVSxDQUFDLElBQUksSUFBQSxnQkFBSyxFQUFDLFVBQVUsQ0FBQyxJQUFJLElBQUEsZ0JBQUssRUFBQyxVQUFVLENBQUMsRUFBRSxDQUFDO1lBQ2hFLE1BQU0sQ0FBQyxHQUFHLEdBQUksTUFBb0IsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDM0UsQ0FBQztRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FDL0IsR0FBVyxFQUNYLFdBQXVCLEVBQ3ZCLFlBQXlCLEVBQ3pCLFVBQWtCLEVBQ2xCLFdBQXFCLGlCQUFRLENBQUMsTUFBTTtRQUVwQyxNQUFNLEVBQUUsR0FBVyxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzdDLE1BQU0sTUFBTSxHQUFpQyxFQUFFLENBQUM7UUFFaEQsTUFBTSxNQUFNLEdBQVcsSUFBSSxDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRTlELFdBQVcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzVDLE1BQU0sSUFBQSxhQUFJLEVBQUMsWUFBWSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBRW5DLE1BQU0sQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUNsQyxJQUFJLElBQUEsZ0JBQUssRUFBQyxVQUFVLENBQUMsSUFBSSxJQUFBLGdCQUFLLEVBQUMsVUFBVSxDQUFDLElBQUksSUFBQSxnQkFBSyxFQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDaEUsTUFBTSxDQUFDLEdBQUcsR0FBSSxNQUFvQixDQUFDLFVBQVUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUNyRSxDQUFDO1FBRUQsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxPQUFPLENBQ25CLEdBQVcsRUFDWCxPQUFlLEVBQ2YsVUFBa0IsRUFDbEIsTUFHQyxFQUNELGdCQUEwQixpQkFBUSxDQUFDLE1BQU07SUFDekMsNkNBQTZDO0lBQzdDLGlCQUFpQyxRQUFRO1FBRXpDLE1BQU0sUUFBUSxHQUFhLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxHQUFHLENBQUMsQ0FBQztRQUV4RixJQUFJLFNBQVMsR0FBVyxRQUFRLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDaEYsU0FBUyxJQUFJLFFBQVEsQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFNUMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUMvQixHQUFXLEVBQ1gsV0FBdUIsRUFDdkIsWUFBeUIsRUFDekIsVUFBa0IsRUFDbEIsTUFHQztRQUVELE1BQU0sUUFBUSxHQUFhLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUV2RixXQUFXLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUM5QyxNQUFNLElBQUEsYUFBSSxFQUFDLFlBQVksRUFBRSxRQUFRLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRU0sTUFBTSxDQUFDLG9CQUFvQixDQUNoQyxJQUFZLEVBQ1osU0FBd0IsRUFDeEIsUUFBUSxHQUFHLGlCQUFRLENBQUMsTUFBTTtRQUUxQixNQUFNLElBQUksR0FBRyxJQUFBLG1CQUFVLEVBQUMsU0FBUyxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNsQixPQUFPO1lBQ0wsSUFBSSxFQUFFLFNBQVM7WUFDZixRQUFRO1lBQ1IsSUFBSSxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDO1NBQzVCLENBQUM7SUFDSixDQUFDO0lBRU0sTUFBTSxDQUFDLG9CQUFvQixDQUNoQyxXQUFxQixFQUNyQixTQUF3QixFQUN4QixRQUFRLEdBQUcsaUJBQVEsQ0FBQyxNQUFNO1FBRTFCLE1BQU0sSUFBSSxHQUFHLElBQUEsbUJBQVUsRUFBQyxTQUFTLENBQUMsQ0FBQztRQUVuQyxPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7WUFDN0IsSUFBSSxDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFO2dCQUNyQixPQUFPLENBQUM7b0JBQ04sSUFBSSxFQUFFLFNBQVM7b0JBQ2YsUUFBUTtvQkFDUixJQUFJLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUM7aUJBQzVCLENBQUMsQ0FBQztZQUNMLENBQUMsQ0FBQyxDQUFDO1lBRUgsV0FBVyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN6QixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQUVELGtCQUFlLFlBQVksQ0FBQyJ9

package/dist/cjs/crypto/nodejs/RSA-Hybrid.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+import { Encryption, RSAHybridEncryption } from '@super-protocol/dto-js';
+import { KeyObject } from 'crypto';
+declare class RSAHybrid {
+    static getKeyFingerprint(key: KeyObject): string;
+    private static publicEncrypt;
+    private static privateDecrypt;
+    static encrypt(content: string, encryption: Encryption): RSAHybridEncryption;
+    static encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<RSAHybridEncryption>;
+    static decrypt(encryption: RSAHybridEncryption): string;
+    static decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: RSAHybridEncryption): Promise<void>;
+}
+export default RSAHybrid;

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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

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { CryptoAlgorithm } from '@super-protocol/dto-js';
+import { KeyObject } from 'crypto';
+export type AsymmetricKeys = {
+    publicKey: KeyObject;
+    privateKey: KeyObject;
+};
+export type SymmetricKey = Buffer;
+export type CryptoKeyType<T extends CryptoAlgorithm> = T extends CryptoAlgorithm.ECIES ? AsymmetricKeys : T extends CryptoAlgorithm.AES ? SymmetricKey : never;

package/dist/cjs/crypto/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

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

@@ -0,0 +1,15 @@
+import { DirHash, FileInfo } from '@super-protocol/dto-js';
+/**
+ * Here would be better to check cipher type using
+ * ```
+ * getCipherInfo(cipher)!.mode === 'mode'
+ * ```
+ * but it doesn't work in browser
+ */
+export declare const isCCM: (cipher: string) => boolean;
+export declare const isGCM: (cipher: string) => boolean;
+export declare const isOCB: (cipher: string) => boolean;
+export declare const isECB: (cipher: string) => boolean;
+export declare const isRC4: (cipher: string) => boolean;
+export declare const isAuthTagRequired: (cipherName: string) => boolean;
+export declare const getDirHashFileContents: (files: Record<string, FileInfo>) => Promise<DirHash>;

package/dist/cjs/crypto/utils.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 });
+exports.getDirHashFileContents = exports.isAuthTagRequired = exports.isRC4 = exports.isECB = exports.isOCB = exports.isGCM = exports.isCCM = void 0;
+const dto_js_1 = require("@super-protocol/dto-js");
+const Crypto_js_1 = __importDefault(require("./Crypto.js"));
+/**
+ * Here would be better to check cipher type using
+ * ```
+ * getCipherInfo(cipher)!.mode === 'mode'
+ * ```
+ * but it doesn't work in browser
+ */
+const isCCM = (cipher) => /ccm/i.test(cipher) || cipher === 'chacha20-poly1305';
+exports.isCCM = isCCM;
+const isGCM = (cipher) => /gcm/i.test(cipher);
+exports.isGCM = isGCM;
+const isOCB = (cipher) => /ocb/i.test(cipher);
+exports.isOCB = isOCB;
+const isECB = (cipher) => /ecb/i.test(cipher) || cipher === 'des-ede' || cipher === 'des-ede3';
+exports.isECB = isECB;
+const isRC4 = (cipher) => /^rc4/i.test(cipher);
+exports.isRC4 = isRC4;
+const isAuthTagRequired = (cipherName) => {
+    return (0, exports.isCCM)(cipherName) || (0, exports.isGCM)(cipherName) || (0, exports.isOCB)(cipherName);
+};
+exports.isAuthTagRequired = isAuthTagRequired;
+const getDirHashFileContents = async (files) => {
+    const sortedFiles = Object.entries(files).map(([path, info]) => {
+        if (path.length === 0) {
+            throw new Error('Filename cannot be empty');
+        }
+        const subResult = {
+            filename: path,
+            encoding: typeof info.hash === 'string' ? dto_js_1.Encoding.hex : info.hash.encoding,
+            size: info.size,
+            is_prefix: info.is_prefix,
+        };
+        if (typeof info.hash === 'string') {
+            const match = info.hash.match(/^([^:]+):(.+)$/);
+            if (match?.length !== 3) {
+                throw new Error(`Invalid hash format for filename ${path}: ${info.hash}`);
+            }
+            return {
+                ...subResult,
+                algo: match[1],
+                hash: match[2],
+                encodedHash: info.hash,
+            };
+        }
+        const hashHex = Buffer.from(info.hash.hash, info.hash.encoding).toString(dto_js_1.Encoding.hex);
+        return {
+            ...subResult,
+            algo: info.hash.algo,
+            hash: info.hash.hash,
+            encodedHash: `${info.hash.algo}:${hashHex}`,
+        };
+    });
+    let buffer = Buffer.alloc(0);
+    let totalSize = 0;
+    sortedFiles.sort((a, b) => preparedValue(a).localeCompare(preparedValue(b)));
+    sortedFiles.forEach((info) => {
+        buffer = Buffer.concat([
+            buffer,
+            Buffer.from(info.filename, 'utf-8'),
+            Buffer.from(info.hash, info.encoding),
+        ]);
+        totalSize += info.size;
+    });
+    const rootHash = await Crypto_js_1.default.createHash(buffer, {
+        algo: dto_js_1.HashAlgorithm.SHA256,
+        encoding: dto_js_1.Encoding.hex,
+    });
+    return {
+        entries: Object.fromEntries(sortedFiles.map((info) => {
+            return [
+                info.filename,
+                {
+                    hash: info.encodedHash,
+                    size: info.size,
+                    is_prefix: info.is_prefix || false,
+                },
+            ];
+        })),
+        hash: `${rootHash.algo}:${rootHash.hash}`,
+        size: totalSize,
+        version: 1,
+    };
+};
+exports.getDirHashFileContents = getDirHashFileContents;
+const preparedValue = (value) => `${value.hash}:${value.filename}`;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/crypto/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};