@zohocorporation/vault-cli 1.1.2

package/out/js/crypto/index.js

@@ -0,0 +1,139 @@
+import Zohovault from "./zohovault.js";
+import CryptoJS from "./aes.js";
+// import sjcl from "./sjcl.js";
+import crypto from "crypto";
+import RSAKey from "./rsa.js";
+import { Logger } from "../logger/index.js";
+import { JsEncodingUtilImpl, Utilites } from "../../old/index.js";
+var Vault = {
+    encrypt: function (plaintext, password) {
+        if (!plaintext || !password) {
+            return;
+        }
+        return Zohovault.AES.encrypt(plaintext, password, 256);
+    },
+    decrypt: function (ciphertext, password) {
+        if (!ciphertext || !password) {
+            return;
+        }
+        return Zohovault.AES.decrypt(ciphertext, password, 256);
+    },
+    fileEncrypt: function (plaintext, password) {
+        if (!plaintext || !password) {
+            return;
+        }
+        return CryptoJS.AES.encrypt(plaintext, password).toString();
+    },
+    fileDecrypt: function (ciphertext, password) {
+        if (!ciphertext || !password) {
+            return;
+        }
+        return CryptoJS.AES.decrypt(ciphertext, password).toString(CryptoJS.enc.Latin1);
+    },
+    hash: function (plaintext) {
+        if (!plaintext) {
+            return;
+        }
+        return Zohovault.hash(plaintext);
+    },
+    Base64_encode: function (input) {
+        if (!input) {
+            return;
+        }
+        return Zohovault.Base64.encode(input);
+    },
+    Base64_decode: function (input) {
+        if (!input) {
+            return;
+        }
+        return Zohovault.Base64.decode(input);
+    },
+    // RSA_encrypt: function (plaintext, publicKey) {
+    //   if(!plaintext || !publicKey) {
+    //     return
+    //   }
+    //   var rsa = new RSAKey();
+    //   rsa.setPublic(publicKey, "10001");
+    //   var res = rsa.encrypt(plaintext);
+    //   if (res) {
+    //     let ciphertext = res;
+    //     return ciphertext;
+    //   }
+    // },
+    RSA_decrypt: async function (ciphertext, privateKey, keytype) {
+        if (!ciphertext || !privateKey) {
+            return;
+        }
+        switch (keytype) {
+            case "RSA_1024":
+                {
+                    privateKey = privateKey.split(",");
+                    var rsa = new RSAKey();
+                    rsa.setPrivateEx(privateKey[0], privateKey[1], privateKey[2], privateKey[3], privateKey[4], privateKey[5], privateKey[6], privateKey[7]);
+                    if (ciphertext.length === 0) {
+                        return;
+                    }
+                    var plaintext = rsa.decrypt(ciphertext);
+                    return plaintext;
+                }
+            case "RSA_4096":
+                {
+                    const textDecoder = new TextDecoder();
+                    const encodingUtil = new JsEncodingUtilImpl();
+                    const cipherBuffer = encodingUtil.base64ToBytes(ciphertext);
+                    const decryptedBuffer = await crypto.webcrypto.subtle.decrypt({ name: "RSA-OAEP" }, privateKey, cipherBuffer); //No I18N
+                    return textDecoder.decode(decryptedBuffer);
+                }
+            default:
+                Logger.error("Invalid RSA Key Type"); //No I18N
+                return;
+        }
+    },
+    // PBKDF2_key: function (password, salt, iteration) {
+    //   if(!password || !salt || !iteration) {
+    //     return;
+    //   }
+    //   /** SJCL and Crypto-js output compatibility changes
+    //    *  SJCL <SALT> converting toHex() value.
+    //    */
+    //   function toHex(str) {
+    //     var hex = "";
+    //     for (var i = 0; i < str.length; i++) {
+    //       hex += "" + str.charCodeAt(i).toString(16);
+    //     }
+    //     return hex;
+    //   }
+    //   var hmacSHA256 = function (key) {
+    //     var hasher = new sjcl.misc.hmac(key, sjcl.hash.sha256);
+    //     this.encrypt = function () {
+    //       return hasher.encrypt.apply(hasher, arguments);
+    //     };
+    //   };
+    //   var passwordSalt = sjcl.codec.hex.toBits(toHex(salt));
+    //   var derivedKey = sjcl.misc.pbkdf2(
+    //     password,
+    //     passwordSalt,
+    //     iteration,
+    //     256,
+    //     hmacSHA256
+    //   );
+    //   return sjcl.codec.hex.fromBits(derivedKey);
+    // }
+    PBKDF2_key: async function (password, salt, iterations) {
+        try {
+            const saltBuffer = new Uint8Array(salt.split("").map(x => x.charCodeAt(0)));
+            const keyMaterial = await crypto.webcrypto.subtle.importKey("raw", new TextEncoder().encode(password), { name: "PBKDF2" }, false, ["deriveBits", "deriveKey"]); //No I18N
+            const derivedBits = await crypto.webcrypto.subtle.deriveBits({
+                name: "PBKDF2", salt: saltBuffer, iterations, //No I18N
+                hash: "SHA-256" //No I18N
+            }, keyMaterial, 256);
+            return Utilites.bytesToHex(derivedBits);
+        }
+        catch (e) {
+            console.log(e);
+            return "";
+        }
+    }
+};
+export default Vault;
+//# sourceMappingURL=index.js.map