@zohocorporation/vault-cli 1.1.2

package/out/old/List.js

@@ -0,0 +1,197 @@
+import { Utilities, _pull } from "../util/index.util.js";
+import { PasswordTypes } from "../util/passwordtypes.util.js";
+import { I18N } from "../js/I18n/index.js";
+import { Login } from "../util/login.util.js";
+import wrap from "word-wrap";
+import * as stringSimilarity from "string-similarity";
+import { OPTIONS, VAULT_ENDPOINTS } from "../util/consts.util.js";
+import { header } from "../commands/login/login.utils.js";
+import { Logger } from "../js/logger/index.js";
+// var stringSimilarity = require("string-similarity"); //No I18N
+let i18nText;
+export class List extends Login {
+    constructor(typeId, show, type, verbose) {
+        super();
+        this.fields = ["secretname", "description", "tags"];
+        i18nText = new I18N();
+        this.showPassword = show;
+        this.typeId = typeId;
+        this.type = type;
+        this.verbose = verbose;
+    }
+    async listSecrets() {
+        await this.getDcAndSetHeader();
+        this.masterKey = await this.getMasterKeyAfterConfiguration();
+        if (this.type === "password") {
+            if (this.typeId === undefined) {
+                this.typeId = "";
+            }
+            const resp = await _pull(header, Utilities.getVaultUrl(this.dc) + VAULT_ENDPOINTS.URL_SECRETS, {
+                isAsc: 'true',
+                pageNum: 0,
+                rowPerPage: -1,
+                secretType: this.typeId
+            });
+            if (resp.data.operation.result.status !== "Success") {
+                console.log(i18nText.getI18nMsg("vault.list.errorListing"));
+                console.log(resp.data.operation.result.message);
+                process.exit(1);
+            }
+            let secrets = resp.data.operation.Details;
+            if (secrets === undefined || secrets.length === 0) {
+                console.log(i18nText.getI18nMsg("vault.list.noPasswordFound"));
+                process.exit(1);
+            }
+            let arr = [];
+            if (this.verbose) {
+                let secretType = {};
+                let templates = await PasswordTypes.getPasswordTypes(this.dc, undefined, OPTIONS.LIST, false);
+                for (let id in templates) {
+                    secretType[templates[id].secret_type_name] = [];
+                }
+                for (let i = 0; i < secrets.length; i++) {
+                    try {
+                        secretType[templates[secrets[i].accounttype].secret_type_name].push(secrets[i]);
+                    }
+                    catch (e) {
+                        Logger.error(e);
+                    }
+                }
+                for (let name in secretType) {
+                    arr = [];
+                    if (secretType[name].length > 0) {
+                        console.log(i18nText.getI18nMsg("vault.list.listsecrets_category") + `${name}`);
+                        for (let i = 0; i < secretType[name].length; i++) {
+                            let secretData = templates[secretType[name][i].accounttype];
+                            await this.decryptSecretObject(secretType[name][i], secretData.secret_type_fields, this.showPassword);
+                            let obj = [];
+                            let fileArr = this.formatFilesArr(secretType[name][i].files);
+                            obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_passwordId")] = wrap(secretType[name][i].secretid);
+                            obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_passwordName")] = wrap(secretType[name][i].secretname, { width: 10 });
+                            obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_Description")] = wrap(secretType[name][i].description, { width: 10 });
+                            secretData = secretType[name][i].secretData;
+                            if (!secretData) {
+                                continue;
+                            }
+                            for (const [key, value] of Object.entries(secretData)) {
+                                let label = key;
+                                let name = value;
+                                if (key === "username") {
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_username"); //No I18N
+                                }
+                                else if (key === "password") {
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_password"); //No I18N
+                                }
+                                else if (key === "file") { //File Attachments 
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_file"); //No I18N
+                                }
+                                else if (key === "agency") { //Health Care Agency
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_agency"); //No I18N
+                                }
+                                else if (key === "policyno") { //Health Care Agency
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_policyno"); //No I18N
+                                }
+                                else if (key === "groupno") { //Health care Agency
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_groupno"); //No I18N
+                                }
+                                else if (key === "name") { //category :- Social Security Account
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_name"); //No I18N
+                                }
+                                else if (key === "ssno") { // Social Security Account
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_ssno"); //No I18N
+                                }
+                                else if (key === "accno") { //Bank Account
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_accno"); //No I18N
+                                }
+                                else if (key === "bankid") { //Bank Account
+                                    label = i18nText.getI18nMsg("vault.search.formatDataForTable_head_bankid"); //No I18N
+                                }
+                                if (name === "file") {
+                                    obj[label] = wrap(fileArr[value], { width: 10 });
+                                }
+                                else {
+                                    if (obj.hasOwnProperty(label)) {
+                                        obj[wrap(`${label}(${name})`)] = wrap(value, { width: 10 });
+                                    }
+                                    else {
+                                        obj[label] = wrap(value, { width: 10 });
+                                    }
+                                }
+                            }
+                            arr.push(obj);
+                        }
+                        Utilities.printTable(arr);
+                        console.log(`\nTotal: ${arr.length} password(s) retrieved\n`);
+                    }
+                }
+            }
+            else {
+                let arr = [];
+                for (let i = 0; i < secrets.length; i++) {
+                    let obj = {};
+                    obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_passwordId")] = secrets[i].secretid;
+                    obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_passwordName")] = wrap(secrets[i].secretname, { width: 10 });
+                    obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_Description")] = wrap(secrets[i].description, { width: 10 });
+                    obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_ownerName")] = secrets[i].ownerdetails.USERNAME;
+                    obj[i18nText.getI18nMsg("vault.search.formatDataForTable_head_owneremail")] = wrap(secrets[i].ownerdetails.EMAIL, { width: 15 });
+                    arr.push(obj);
+                }
+                Utilities.printTable(arr);
+                console.log(`\nTotal: ${arr.length} password(s) retrieved\n`);
+            }
+        }
+        else if (this.type === "category") {
+            const pTypes = await PasswordTypes.getPasswordTypes(this.dc, undefined, OPTIONS.LIST, true);
+            const arr = this.formatTypesForTable(pTypes);
+        }
+        else if (this.type === "folder") {
+            let folders = await _pull(header, Utilities.getVaultUrl(this.dc) + VAULT_ENDPOINTS.URL_FOLDER, {
+                pageNum: 1,
+                rowPerPage: -1
+            });
+            folders = folders.data.operation.Details;
+            let folderTable = [];
+            for (let i = 0; i < folders.length; i++) {
+                folderTable.push({
+                    'ID': folders[i].chamberid,
+                    'Name': folders[i].chambername,
+                    'Password Count': folders[i].secretcount
+                });
+            }
+            Utilities.printTable(folderTable);
+        }
+        else {
+            const category = ["password", "category", "folder"]; //No I18N
+            var matches = stringSimilarity.findBestMatch(this.type, category);
+            let bestCommand = matches.bestMatch.target;
+            console.log(i18nText.getI18nMsg("vault.list.category_suggestion"), bestCommand);
+        }
+    }
+    formatTypesForTable(pTypes) {
+        const arr = [];
+        let i = 0;
+        for (const pTypeId in pTypes) {
+            const pType = pTypes[pTypeId];
+            arr.push({
+                SNO: ++i,
+                "Category ID": pTypeId, //No I18N
+                "Category Name": pType.secret_type_name //No I18N
+            });
+        }
+        Utilities.printTable(arr);
+        return arr;
+    }
+    formatFilesArr(files) {
+        if (files === undefined) {
+            return [];
+        }
+        const filesArr = JSON.parse(files);
+        let filesObj = {};
+        for (let i = 0; i < filesArr.length; i++) {
+            const file = filesArr[i];
+            filesObj[file.column] = file.name;
+        }
+        return filesObj;
+    }
+}
+//# sourceMappingURL=List.js.map

package/out/old/Login.js

@@ -0,0 +1,287 @@
+import Vault from "../js/crypto/index.js";
+import { Logger } from "../js/logger/index.js";
+import inquirer from "inquirer";
+import { getDecryptedCredentials, insertToDB } from "../util/dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../commands/login/login.utils.js";
+import { MODE } from "../util/consts.util.js";
+import { CREDENTIALS } from "../util/consts.util.js";
+import { getConfig } from "../util/dev.utils.js";
+import chalk from "chalk";
+import { setHeaders, urlGenerateToken, urlLogin, Utilites, _pull, urlOrgKey, } from "./index.js";
+import { Utilities } from "../util/index.util.js";
+import { DC } from "../util/consts.util.js";
+import { exit } from "node:process";
+export class Login {
+    constructor(passphrase) {
+        this.passphrase = passphrase;
+    }
+    getDcAndSetHeader = async () => {
+        const data = await getDecryptedCredentials(generateWorkspaceHash());
+        if (!data) {
+            throw new Error("cannot find data"); //NO I18N
+        }
+        const { credentials, createdtime, dc } = data;
+        const { access_token, refresh_token } = credentials;
+        this.accessToken = !!access_token ? access_token : "";
+        this.refreshToken = !!refresh_token ? refresh_token : "";
+        this.createdTime = !!createdtime ? +createdtime : 0;
+        this.dc = !!dc ? dc : DC.US;
+        await this.checkAccessTokenValidity();
+        setHeaders("Authorization", `Zoho-oauthtoken ${this.accessToken}`);
+    };
+    async getAccessTokenforunlock() {
+        const data = await getDecryptedCredentials(generateWorkspaceHash());
+        if (!data) {
+            console.log(`No credentails found try ${chalk.green('zv login')}`);
+            exit(0);
+        }
+        const { credentials } = data;
+        return credentials.access_token;
+    }
+    async getKeyForToken() {
+        if (this.tokenSalt === undefined) {
+            this.tokenSalt = Utilites.generateRandomToken(40);
+        }
+        return await Vault.PBKDF2_key(this.masterKey, this.tokenSalt, this.iteration);
+    }
+    async refreshAccessToken() {
+        /*
+              generate new access token with the help of refresh token
+             */
+        const config = getConfig();
+        let { MODE: mode, CLIENT_ID, CLIENT_SECRET } = config;
+        if (mode === MODE.PRODUCTION) {
+            CLIENT_ID = CREDENTIALS.CLIENT_ID;
+            CLIENT_SECRET = CREDENTIALS.CLIENT_SECRET;
+        }
+        let newCreatedTime = Date.now();
+        let data = {
+            refresh_token: this.refreshToken,
+            client_id: CLIENT_ID,
+            client_secret: CLIENT_SECRET,
+            grant_type: "refresh_token",
+        };
+        try {
+            let resp = await _pull(Utilites.getAccountsUrl(this.dc) + urlGenerateToken, data, "POST");
+            resp = resp.data;
+            if (resp.hasOwnProperty("access_token")) {
+                this.accessToken = resp.access_token;
+                const cred = await getDecryptedCredentials(generateWorkspaceHash());
+                if (!cred) {
+                    console.log(`Credentials not found, try ${chalk.green('zv login')} again`);
+                    exit(0);
+                }
+                const { credentials } = cred;
+                credentials.access_token = resp.access_token;
+                credentials.refresh_token = data.refresh_token;
+                let modifiedData = { ...cred, dc: this.dc, createdtime: newCreatedTime.toString() };
+                insertToDB(modifiedData);
+            }
+        }
+        catch (e) {
+            Logger.error(e);
+        }
+    }
+    async checkAccessTokenValidity() {
+        const localtime = Date.now();
+        let diffMs = localtime - this.createdTime; // milliseconds between now & Christmas
+        let diffMins = Math.abs(Math.round(diffMs / 1000 / 60));
+        if (diffMins > 50) {
+            await this.refreshAccessToken();
+        }
+    }
+    async get_salt() {
+        const resp = await _pull(Utilites.getVaultUrl(this.dc) + urlLogin, { OPERATION_NAME: "GET_LOGIN" }, "POST");
+        const { ITERATION, PASSPHRASE, LOGIN, SALT } = resp.data.operation.details;
+        this.iteration = ITERATION;
+        this.passauth = PASSPHRASE;
+        this.loginType = LOGIN;
+        this.salt = SALT;
+    }
+    async getMasterKey(passphrase) {
+        if (this.salt === undefined) {
+            await this.get_salt();
+        }
+        if (this.masterKey === undefined) {
+            let masterKey;
+            if (this.loginType === "PBKDF2_AES") {
+                masterKey = await Vault.PBKDF2_key(passphrase, this.salt, this.iteration);
+            }
+            else {
+                //TODO check this case
+                masterKey = Vault.hash(passphrase);
+            }
+            if (this.checkLogin(masterKey)) {
+                this.masterKey = masterKey;
+                return masterKey;
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return this.masterKey;
+        }
+    }
+    checkLogin(masterKey) {
+        const decryptedPassAuth = Vault.decrypt(this.passauth, masterKey);
+        try {
+            return !isNaN(Date.parse(JSON.parse(decryptedPassAuth).date));
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async getMasterKeyAfterConfiguration() {
+        const isCLITrusted = await Utilities.isTrusted();
+        if (isCLITrusted.status) {
+            return isCLITrusted.masterKey;
+        }
+        let passphraseVerified = false;
+        let passphraseMsg = "Please enter your master password: "; //No I18N
+        while (!passphraseVerified) {
+            let passphrase_inp = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "val",
+                    mask: "*",
+                    message: passphraseMsg,
+                },
+            ]);
+            let passphrase = passphrase_inp.val;
+            const masterKey = await this.getMasterKey(passphrase);
+            if (masterKey === undefined) {
+                passphraseMsg = "Invalid master password. Please try again."; //No I18N
+            }
+            else {
+                return masterKey;
+            }
+        }
+    }
+    async getOrgKey() {
+        const userConfig = await getDecryptedCredentials(generateWorkspaceHash());
+        const { credentials } = userConfig;
+        if (credentials && credentials.orgkey) {
+            return credentials.orgkey;
+        }
+        if (this.orgKey === undefined) {
+            const resp = await _pull(Utilites.getVaultUrl(this.dc) + urlOrgKey, {});
+            // const { privateKey, sharedKey } = resp.data.operation.Details;
+            // const pri = Vault.decrypt(privateKey, this.masterKey, 256);
+            // this.orgKey = Vault.RSA_decrypt(sharedKey, pri);
+            const keys = {
+                privateKey: resp.data.operation.Details.privateKey,
+                rsaKeyType: resp.data.operation.Details.rsaKeyType || "RSA_1024", //No I18N
+                sharedKey: resp.data.operation.Details.sharedKey
+            };
+            const pri = Vault.decrypt(keys.privateKey, this.masterKey, 256);
+            switch (keys.rsaKeyType) {
+                case "RSA_1024":
+                    this.orgKey = await Vault.RSA_decrypt(keys.sharedKey, pri, keys.rsaKeyType);
+                    break;
+                case "RSA_4096":
+                    const privateKey = await Utilites.importPrivateKey(pri);
+                    this.orgKey = await Vault.RSA_decrypt(keys.sharedKey, privateKey, keys.rsaKeyType);
+                    break;
+                default:
+                    Logger.error("Invalid RSA Key Type"); //No I18N
+                    return;
+            }
+        }
+        credentials.orgkey = this.orgKey ? this.orgKey : '';
+        await insertToDB(userConfig);
+        return this.orgKey;
+    }
+    async decryptSecretObj(secret, notSafe, 
+    // obj
+    { secret_type_fields: template, secret_type_name }) {
+        notSafe = !notSafe;
+        if (secret.secretData != undefined) {
+            let secretData = JSON.parse(secret.secretData);
+            let key = secret.isshared === "NO" ? this.masterKey : await this.getOrgKey();
+            for (let column in secretData) {
+                secretData[column] = Vault.decrypt(secretData[column], key);
+            }
+            for (let i = 0; i < template.length; i++) {
+                let column = template[i];
+                if (column.type === "password" &&
+                    ((secret.sharinglevel !== undefined &&
+                        Utilites.getSharingPrivilege(secret.sharinglevel) === "AUTOLOGIN") ||
+                        notSafe)) {
+                    column.value = "********";
+                }
+                else {
+                    column.value = secretData[column.name];
+                }
+            }
+            if (secret.notes !== "" && typeof secret.notes !== "undefined") {
+                secret.notes = Vault.decrypt(secret.notes, key);
+            }
+            if (secret.encdescription != undefined && secret.encdescription != "") // changes for new encrypted fields
+             {
+                secret.decdescription = Vault.decrypt(secret.encdescription, key);
+            }
+            if (secret.encryptedtags != undefined && secret.encryptedtags != "") {
+                secret.decryptedtags = Vault.decrypt(secret.encryptedtags, key);
+            }
+            if (secret.encsecretname != undefined && secret.encsecretname != "") {
+                secret.decsecretname = Vault.decrypt(secret.encsecretname, key);
+            }
+            if (secret.encryptedurls != undefined && secret.encryptedurls != "") {
+                if (secret.encryptedurls.length > 1) {
+                    let i = 0;
+                    for (let url in secret.encryptedurls) {
+                        secret.decryptedurls[i] = Vault.decrypt(secret.encryptedurls[url], key);
+                        i++;
+                    }
+                }
+                else {
+                    secret.decryptedurls = Vault.decrypt(secret.encryptedurls[0], key);
+                }
+            }
+            secret.secretData = template;
+            secret.secretTypeName = secret_type_name;
+            if (secret.customcolumn !== undefined) {
+                let customCols;
+                try {
+                    customCols = JSON.parse(Vault.Base64_decode(secret.customcolumn))
+                        .customcol;
+                }
+                catch (err) {
+                    customCols = {};
+                }
+                for (let i = 0; i < customCols.length; i++) {
+                    let column = customCols[i];
+                    if (column.type === "password" &&
+                        ((secret.sharinglevel !== undefined &&
+                            Utilites.getSharingPrivilege(secret.sharinglevel) ===
+                                "AUTOLOGIN") ||
+                            notSafe)) {
+                        column.value = "*******";
+                    }
+                    else {
+                        column.value = Vault.decrypt(column.value, key);
+                    }
+                }
+                secret.customcolumn = { customcol: customCols };
+            }
+        }
+        else {
+            if (secret.accesssctrlconfigured == "true") {
+                console.log("password need access control");
+            }
+            else {
+                console.log("error in fetching secrets");
+            }
+        }
+    }
+    async fullencrypt_decrypt(new_fields, isshared) {
+        let decrypted_field;
+        let key = isshared === "NO" ? this.masterKey : await this.getOrgKey(); //No I18N
+        if (new_fields != undefined) {
+            decrypted_field = Vault.decrypt(new_fields, key);
+        }
+        return decrypted_field;
+    }
+}
+//# sourceMappingURL=Login.js.map

package/out/old/Logout.js

@@ -0,0 +1,21 @@
+import { I18N } from "../js/I18n/index.js";
+import { deleteCredentials, getZvDB } from "../util/dbutils/db.utils.js";
+import { Login } from "../util/login.util.js";
+import { deleteFromKeyring } from "../util/keyringutil/keyring.util.js";
+import { KEYRING_SERVICE, KEYRING_ACCOUNT } from "../util/consts.util.js";
+let i18nText = new I18N();
+export class Logout extends Login {
+    async clearAllFiles() {
+        const db = getZvDB();
+        await deleteCredentials(db);
+        try {
+            await deleteFromKeyring(KEYRING_SERVICE, KEYRING_ACCOUNT);
+        }
+        catch (_) {
+            // Keyring entry may not exist — safe to ignore
+        }
+        delete process.env.zv_keys;
+        console.log(i18nText.getI18nMsg("vault.logout.success"));
+    }
+}
+//# sourceMappingURL=Logout.js.map