@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/mjs/crypto/Crypto.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Encryption, Hash } from '@super-protocol/dto-js';
+import fs from 'fs';
+import { Readable } from 'stream';
+declare 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 encrypt(content: string, encryption: Encryption): Promise<Encryption>;
+    /**
+     * 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 encryptStream(inputStream: fs.ReadStream, outputStream: fs.WriteStream, encryption: Encryption): Promise<Encryption>;
+    /**
+     * Used to decrypt data from blockchain
+     * @param encryption - object what contains encrypted data, key and spec to decryption
+     * @returns {Promise<string>} - decrypted string
+     */
+    static decrypt(encryption: Encryption): Promise<string>;
+    /**
+     * 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 decryptStream(inputStream: fs.ReadStream, outputStream: fs.WriteStream, encryption: Encryption): Promise<void>;
+    /**
+     * Create hash from content
+     * @param content - buffer data to create hash from
+     * @param hashInfo - information about hash algorithm and encoding
+     * @returns Hash structure with hash itself hash algorithm and encoding
+     */
+    static createHash(content: Buffer, hashInfo: Omit<Hash, 'hash'>): Promise<Hash>;
+    /**
+     * Create hash from stream
+     * @param inputStream - readable stream
+     * @param hashInfo - information about hash algorithm and encoding
+     * @returns Hash structure with hash itself hash algorithm and encoding
+     */
+    static createHash(inputStream: Readable, hashInfo: Omit<Hash, 'hash'>): Promise<Hash>;
+}
+export default Crypto;

package/dist/mjs/crypto/Crypto.js

@@ -0,0 +1,95 @@
+import { CryptoAlgorithm, } from '@super-protocol/dto-js';
+import AES from './nodejs/AES.js';
+import ARIA from './nodejs/ARIA.js';
+import ECIES from './nodejs/ECIES.js';
+import RSAHybrid from './nodejs/RSA-Hybrid.js';
+import NativeCrypto from './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 CryptoAlgorithm.AES:
+                return await AES.encrypt(content, encryption);
+            case CryptoAlgorithm.ARIA:
+                return await ARIA.encrypt(content, encryption);
+            case CryptoAlgorithm.ECIES:
+                return await ECIES.encrypt(content, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return await RSAHybrid.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 CryptoAlgorithm.AES:
+                return await AES.encryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.ARIA:
+                return await ARIA.encryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return await RSAHybrid.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 CryptoAlgorithm.AES:
+                return AES.decrypt(encryption);
+            case CryptoAlgorithm.ARIA:
+                return ARIA.decrypt(encryption);
+            case CryptoAlgorithm.ECIES:
+                return await ECIES.decrypt(encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return RSAHybrid.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 CryptoAlgorithm.AES:
+                return await AES.decryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.ARIA:
+                return await ARIA.decryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return await RSAHybrid.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.createHashFromBuffer(param1, algo, encoding)
+            : await NativeCrypto.createHashFromStream(param1, algo, encoding);
+    }
+}
+export default Crypto;
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/mjs/crypto/index.js

@@ -0,0 +1,3 @@
+import Crypto from './Crypto.js';
+export default Crypto;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUNqQyxlQUFlLE1BQU0sQ0FBQyJ9

package/dist/mjs/crypto/nodejs/AES.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { AESEncryption, Encryption } from '@super-protocol/dto-js';
+import { ReadStream, WriteStream } from 'fs';
+declare class AES {
+    static encrypt(content: string, encryption: Encryption): Promise<AESEncryption>;
+    /**
+     * 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 encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<AESEncryption>;
+    static decrypt(encryption: AESEncryption): string;
+    /**
+     * 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 decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: AESEncryption): Promise<void>;
+}
+export default AES;

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

@@ -0,0 +1,74 @@
+import { Cipher, CryptoAlgorithm, } from '@super-protocol/dto-js';
+import NativeCrypto from './NativeCrypto.js';
+class AES {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: 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 || Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto.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.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.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+}
+export default AES;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/ARIA.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { ARIAEncryption, Encryption } from '@super-protocol/dto-js';
+import { ReadStream, WriteStream } from 'fs';
+declare class ARIA {
+    static encrypt(content: string, encryption: Encryption): Promise<ARIAEncryption>;
+    /**
+     * 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 encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<ARIAEncryption>;
+    static decrypt(encryption: ARIAEncryption): string;
+    /**
+     * 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 decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: ARIAEncryption): Promise<void>;
+}
+export default ARIA;

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

@@ -0,0 +1,73 @@
+import { CryptoAlgorithm, Cipher, } from '@super-protocol/dto-js';
+import NativeCrypto from './NativeCrypto.js';
+class ARIA {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: 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 || Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto.encryptStream(keyBuffer, inputStream, outputStream, encryption.cipher);
+        return {
+            algo: 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.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.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+}
+export default ARIA;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/ECIES.d.ts

@@ -0,0 +1,6 @@
+import { ECIESEncryption, Encryption } from '@super-protocol/dto-js';
+declare class ECIES {
+    static encrypt(content: string, encryption: Encryption): Promise<ECIESEncryption>;
+    static decrypt(encryption: ECIESEncryption): Promise<string>;
+}
+export default ECIES;

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

@@ -0,0 +1,51 @@
+import { CryptoAlgorithm } from '@super-protocol/dto-js';
+import crypto from 'crypto';
+class ECIES {
+    static async encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        const ecdh = crypto.createECDH('secp256k1');
+        ecdh.generateKeys();
+        const epk = ecdh.getPublicKey();
+        const pk = ecdh.computeSecret(Buffer.from(encryption.key, encryption.encoding));
+        const hash = crypto.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.slice(0, 32), macKey = hash.slice(32);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.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.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: 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.createECDH('secp256k1');
+        ecdh.setPrivateKey(Buffer.from(encryption.key, encryption.encoding));
+        const pk = ecdh.computeSecret(epk);
+        const hash = crypto.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.slice(0, 32), macKey = hash.slice(32);
+        const m = crypto
+            .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.createDecipheriv('aes-256-cbc', cipherKey, iv);
+        const pt = decipher.update(ct);
+        const result = Buffer.concat([pt, decipher.final()]);
+        return result.toString('binary');
+    }
+}
+export default ECIES;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+/// <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)!.mode === 'mode'
+     * ```
+     * but it doesn't work in browser
+     */
+    static readonly isCCM: (cipher: string) => boolean;
+    static readonly isGCM: (cipher: string) => boolean;
+    static readonly isOCB: (cipher: string) => boolean;
+    static readonly isECB: (cipher: string) => boolean;
+    static readonly isRC4: (cipher: string) => boolean;
+    /**
+     * 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: any, 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;