@ocap/mcrypto 1.18.39 → 1.18.40-beta.2

package/lib/crypter/aes.d.ts

@@ -1,7 +1,8 @@
+import { BytesType, EncodingType } from '@ocap/util';
 import Crypter from '../protocols/crypter';
 declare class AesCrypter extends Crypter {
-    encrypt(message: string | object, secret: string): string;
-    decrypt(cipher: string, secret: string, outputEncoding?: string): string;
+    encrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
+    decrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
 }
 declare const _default: AesCrypter;
 export default _default;

package/lib/crypter/aes.js

@@ -1,54 +1,30 @@
 "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;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AesCrypter = void 0;
-const AES = __importStar(require("crypto-js/aes"));
-const enc_latin1_1 = __importDefault(require("crypto-js/enc-latin1"));
-const enc_utf8_1 = __importDefault(require("crypto-js/enc-utf8"));
-const enc_utf16_1 = __importDefault(require("crypto-js/enc-utf16"));
-const enc_base64_1 = __importDefault(require("crypto-js/enc-base64"));
-const enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
+// For browsers, may need: https://www.npmjs.com/package/crypto-browserify
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("@ocap/util");
 const crypter_1 = __importDefault(require("../protocols/crypter"));
-const encoders = {
-    latin1: enc_latin1_1.default,
-    utf8: enc_utf8_1.default,
-    hex: enc_hex_1.default,
-    utf16: enc_utf16_1.default,
-    base64: enc_base64_1.default,
-};
-// AES-CBC-256
+const sha3_1 = __importDefault(require("../hasher/sha3"));
+const encode_1 = require("../encode");
+// AES-ECB-256
 class AesCrypter extends crypter_1.default {
-    encrypt(message, secret) {
-        const text = typeof message === 'string' ? message : JSON.stringify(message);
-        return AES.encrypt(text, secret).toString();
+    encrypt(message, secret, encoding = 'hex') {
+        const key = sha3_1.default.hash256(secret, 1, 'buffer');
+        const cipher = crypto_1.default.createCipheriv('aes-256-ecb', key, '');
+        cipher.setAutoPadding(true);
+        const output = cipher.update((0, util_1.toBuffer)(message));
+        return (0, encode_1.encode)(Buffer.concat([output, cipher.final()]), encoding);
     }
-    decrypt(cipher, secret, outputEncoding = 'utf8') {
-        return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+    decrypt(message, secret, encoding = 'hex') {
+        const key = sha3_1.default.hash256(secret, 1, 'buffer');
+        const decipher = crypto_1.default.createDecipheriv('aes-256-ecb', key, '');
+        decipher.setAutoPadding(true);
+        const output = decipher.update((0, util_1.toBuffer)(message));
+        return (0, encode_1.encode)(Buffer.concat([output, decipher.final()]), encoding);
     }
 }
 exports.AesCrypter = AesCrypter;

package/lib/crypter/rsa-browserify.d.ts

@@ -0,0 +1,9 @@
+declare class RSABrowserCrypter {
+    genKeyPair(length?: number): Promise<CryptoKeyPair>;
+    formatPublicKey(key: CryptoKey): Promise<string>;
+    encrypt(message: string, key: CryptoKey): Promise<string>;
+    decrypt(message: string, key: CryptoKey): Promise<string>;
+}
+declare const _default: RSABrowserCrypter;
+export default _default;
+export { RSABrowserCrypter };

package/lib/crypter/rsa-browserify.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSABrowserCrypter = void 0;
+// https://stackoverflow.com/questions/70056340/how-can-i-generate-an-rsa-pair-that-works-both-in-node-js-and-browser
+// https://stackoverflow.com/questions/62948516/using-native-javascript-subtlecrypto-to-encrypt-using-rsa
+const util_1 = require("@ocap/util");
+const crypto = window.crypto.subtle;
+// @ts-ignore
+const ab2str = (buffer) => String.fromCharCode.apply(null, new Uint8Array(buffer));
+const RSA_ALGORITHM = 'RSA-OAEP';
+// RSA-OAEP
+class RSABrowserCrypter {
+    genKeyPair(length = 2048) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return crypto.generateKey({
+                name: RSA_ALGORITHM,
+                modulusLength: length,
+                publicExponent: new Uint8Array([1, 0, 1]),
+                hash: 'SHA-256',
+            }, true, ['encrypt', 'decrypt']);
+        });
+    }
+    formatPublicKey(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exported = yield crypto.exportKey('spki', key);
+            const base64 = window.btoa(ab2str(exported));
+            return `-----BEGIN PUBLIC KEY-----\n${base64}\n-----END PUBLIC KEY-----`;
+        });
+    }
+    encrypt(message, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encrypted = yield crypto.encrypt({ name: RSA_ALGORITHM }, key, new TextEncoder().encode(message));
+            return (0, util_1.toBase58)(new Uint8Array(encrypted));
+        });
+    }
+    decrypt(message, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decrypted = yield crypto.decrypt({ name: RSA_ALGORITHM }, key, (0, util_1.fromBase58)(message));
+            return Buffer.from(new Uint8Array(decrypted)).toString('utf8');
+        });
+    }
+}
+exports.RSABrowserCrypter = RSABrowserCrypter;
+exports.default = new RSABrowserCrypter();

package/lib/crypter/rsa.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import crypto from 'crypto';
+import { BytesType, EncodingType } from '@ocap/util';
+import Crypter from '../protocols/crypter';
+declare class RSACrypter extends Crypter {
+    genKeyPair(length?: number): crypto.KeyPairSyncResult<string, string>;
+    encrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+    decrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+}
+declare const _default: RSACrypter;
+export default _default;
+export { RSACrypter };

package/lib/crypter/rsa.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSACrypter = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("@ocap/util");
+const crypter_1 = __importDefault(require("../protocols/crypter"));
+const encode_1 = require("../encode");
+// RSA-OAEP
+class RSACrypter extends crypter_1.default {
+    genKeyPair(length = 2048) {
+        return crypto_1.default.generateKeyPairSync('rsa', {
+            modulusLength: length,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+            },
+        });
+    }
+    encrypt(message, key, encoding = 'hex') {
+        return (0, encode_1.encode)(crypto_1.default.publicEncrypt(key, (0, util_1.toBuffer)(message)), encoding);
+    }
+    decrypt(message, key, encoding = 'hex') {
+        return (0, encode_1.encode)(crypto_1.default.privateDecrypt(key, (0, util_1.toBuffer)(message)), encoding);
+    }
+}
+exports.RSACrypter = RSACrypter;
+exports.default = new RSACrypter();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/mcrypto",
-  "version": "1.18.39",
+  "version": "1.18.40-beta.2",
   "description": "Crypto lib that provides signer,crypter,hasher interface",
   "keywords": [
     "crypto",
@@ -71,6 +71,5 @@
   "resolutions": {
     "bn.js": "5.2.1",
     "elliptic": "6.5.3"
-  },
-  "gitHead": "95f7a60030ed923ac83fed697f208a9b8d555f59"
+  }
 }