@zohocorporation/vault-cli 1.1.2

package/out/util/consts.util.js

@@ -0,0 +1,97 @@
+import os from 'os';
+export var ACCOUNT_ENDPOINTS;
+(function (ACCOUNT_ENDPOINTS) {
+    ACCOUNT_ENDPOINTS["URL_DEVICE_CODE"] = "/oauth/v3/device/code";
+    ACCOUNT_ENDPOINTS["URL_DEVICE_TOKEN"] = "/oauth/v3/device/token";
+    ACCOUNT_ENDPOINTS["URL_GENERATE_TOKEN"] = "/oauth/v2/token";
+})(ACCOUNT_ENDPOINTS || (ACCOUNT_ENDPOINTS = {}));
+export var VAULT_ENDPOINTS;
+(function (VAULT_ENDPOINTS) {
+    VAULT_ENDPOINTS["URL_LOGIN"] = "/api/json/login";
+    VAULT_ENDPOINTS["URL_SEARCH_SECRETS"] = "/api/rest/json/v1/secrets/searchSecret";
+    VAULT_ENDPOINTS["URL_SECRET_TYPES"] = "/api/rest/json/v1/secrettypes";
+    VAULT_ENDPOINTS["URL_ORG_KEY"] = "/api/rest/json/v1/user/orgkey";
+    VAULT_ENDPOINTS["URL_SECRETS"] = "/api/rest/json/v1/secrets";
+    VAULT_ENDPOINTS["URL_V2_SECRETS"] = "/api/rest/json/v2/secrets";
+    VAULT_ENDPOINTS["URL_PASSWORD_POLICIES"] = "/api/rest/json/v1/passwordPolicies";
+    VAULT_ENDPOINTS["URL_DOWNLOAD_FILE"] = "/api/rest/json/v1/secrets/downloadfile";
+    VAULT_ENDPOINTS["URL_OLD_SECRETS"] = "/api/json/secrets";
+    VAULT_ENDPOINTS["URL_SETTINGS_FOR_I18N"] = "/api/rest/json/v1/settings";
+    VAULT_ENDPOINTS["URL_FOLDER"] = "/api/rest/json/v1/chambers";
+    VAULT_ENDPOINTS["URL_LICENSE"] = "/api/rest/json/v1/license";
+    VAULT_ENDPOINTS["USER_CONFIG"] = "/api/rest/json/v1/user/config"; //No I18N
+})(VAULT_ENDPOINTS || (VAULT_ENDPOINTS = {}));
+export const KEYRING_SERVICE = 'zv-node';
+export const KEYRING_ACCOUNT = 'zv-cli';
+export var CREDENTIALS;
+(function (CREDENTIALS) {
+    CREDENTIALS["CLIENT_ID"] = "1004.TY5ZEKIP84H0627578LGYY18TZLB2H";
+    CREDENTIALS["CLIENT_SECRET"] = "35d15c880d053987150acfc0b88710996a981c0cfa"; //"4a33687c70d09f4ccd36da75fe7bdfbf3a4dd95e49"
+})(CREDENTIALS || (CREDENTIALS = {}));
+export var OS;
+(function (OS) {
+    OS["WINDOWS"] = "windows";
+    OS["MAC"] = "mac";
+    OS["LINUX"] = "linux";
+})(OS || (OS = {}));
+export var ACCOUNTS_URL;
+(function (ACCOUNTS_URL) {
+    ACCOUNTS_URL["AU"] = "https://accounts.zoho.com.au";
+    ACCOUNTS_URL["EU"] = "https://accounts.zoho.eu";
+    ACCOUNTS_URL["IN"] = "https://accounts.zoho.in";
+    ACCOUNTS_URL["CN"] = "https://accounts.zoho.com.cn";
+    ACCOUNTS_URL["GEN"] = "https://accounts.zoho.com";
+})(ACCOUNTS_URL || (ACCOUNTS_URL = {}));
+export var VAULT_URL;
+(function (VAULT_URL) {
+    VAULT_URL["AU"] = "https://vault.zoho.com.au";
+    VAULT_URL["EU"] = "https://vault.zoho.eu";
+    VAULT_URL["IN"] = "https://vault.zoho.in";
+    VAULT_URL["CN"] = "https://vault.zoho.com.cn";
+    VAULT_URL["GEN"] = "https://vault.zoho.com";
+})(VAULT_URL || (VAULT_URL = {}));
+export var DC;
+(function (DC) {
+    DC["US"] = "us";
+    DC["EU"] = "eu";
+    DC["AU"] = "au";
+    DC["IN"] = "in";
+    DC["CN"] = "com.cn";
+})(DC || (DC = {}));
+export var OPERATION;
+(function (OPERATION) {
+    OPERATION["GET_SECRET_FILES"] = "GET_SECRET_FILES";
+    OPERATION["GET_LOGIN"] = "GET_LOGIN";
+})(OPERATION || (OPERATION = {}));
+export var SHARING;
+(function (SHARING) {
+    SHARING["MANAGE"] = "MANAGE";
+    SHARING["AUTOLOGIN"] = "AUTOLOGIN";
+    SHARING["VIEW"] = "VIEW";
+    SHARING["MODIFY"] = "MODIFY";
+})(SHARING || (SHARING = {}));
+export const DB_PATH = os.homedir() + '/.config/zv';
+export const DB_NAME = 'zv.db';
+export var MODE;
+(function (MODE) {
+    MODE["DEVELOPMENT"] = "development";
+    MODE["PRODUCTION"] = "production";
+})(MODE || (MODE = {}));
+export var OPTIONS;
+(function (OPTIONS) {
+    OPTIONS["LOGIN"] = "login";
+    OPTIONS["UNLOCK"] = "unlock";
+    OPTIONS["LOCK"] = "lock";
+    OPTIONS["SEARCH"] = "search";
+    OPTIONS["LIST"] = "list";
+    OPTIONS["GET"] = "get";
+    OPTIONS["ADD"] = "add";
+    OPTIONS["GENERATE_TEMPLATE"] = "generate-template";
+    OPTIONS["UPDATE"] = "update";
+    OPTIONS["DOWNLOAD"] = "download";
+    OPTIONS["GENERATE_PASSWORD"] = "generate-password";
+    OPTIONS["LOGOUT"] = "logout";
+    OPTIONS["GET_DEFAULT"] = "get-default";
+    OPTIONS["SET_DEFAULT"] = "set-default";
+})(OPTIONS || (OPTIONS = {}));
+//# sourceMappingURL=consts.util.js.map

package/out/util/dbutils/db.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=db.types.js.map

package/out/util/dbutils/db.utils.js

@@ -0,0 +1,164 @@
+import { DB_NAME, DB_PATH } from "../consts.util.js";
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import { createTable } from "./dbtable.utils.js";
+import { decryptString } from "../encryptionutil/encryption.uitl.js";
+import { generateWorkspaceHash } from "../../commands/login/login.utils.js";
+import Vault from "../../js/crypto/index.js";
+import { exit } from "node:process";
+import { encryptString } from "../encryptionutil/encryption.uitl.js";
+import { Logger } from "../../js/logger/index.js";
+export const getZvDB = () => {
+    if (!fs.existsSync(DB_PATH)) {
+        fs.mkdirSync(DB_PATH, { recursive: true });
+    }
+    const db = new Database(DB_PATH + '/' + DB_NAME);
+    createTable(db);
+    return db;
+};
+export const insertToTable = (db, configObj) => {
+    try {
+        const { workspace, credentials, language, createdtime, dc, hasmasterkey, defaults, zuid } = configObj;
+        db.prepare('REPLACE INTO zv_config (workspace, credentials, language, createdtime, dc, hasmasterkey, defaults, zuid) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+            .bind(workspace, credentials, language, createdtime, dc, hasmasterkey, defaults, zuid)
+            .run();
+        return true;
+    }
+    catch (err) {
+        Logger.error(err);
+        throw new Error("error while inserting into table zv_config");
+    }
+};
+export const insertToDB = (data) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const { workspace, language, createdtime, credentials, dc, hasmasterkey, defaults, zuid } = data;
+            const lang = await encryptString(language);
+            const cretime = await encryptString(createdtime);
+            const dcEnc = await encryptString(dc);
+            const haskey = hasmasterkey.toString();
+            const cred = await encryptString(JSON.stringify(credentials));
+            const def = await encryptString(Vault.Base64_encode(JSON.stringify(defaults)));
+            const zuidEnc = await encryptString(zuid);
+            const obj = {
+                workspace,
+                credentials: cred,
+                language: lang,
+                createdtime: cretime,
+                dc: dcEnc,
+                hasmasterkey: haskey,
+                defaults: def,
+                zuid: zuidEnc
+            };
+            const db = getZvDB();
+            insertToTable(db, obj);
+            resolve(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(new Error("error while inserting data to DB"));
+        }
+    });
+};
+export const getCredentials = (pathHash) => {
+    const db = getZvDB();
+    try {
+        const data = db.prepare(`SELECT * FROM  zv_config WHERE workspace = ?`).get(pathHash);
+        return data;
+    }
+    catch (err) {
+        new Error("Error while getting credentials");
+    }
+    return null;
+};
+export const updateTable = (pathHash, defaults) => {
+    const db = getZvDB();
+    return new Promise((resolve, reject) => {
+        try {
+            const countStmt = db.prepare(`SELECT COUNT (*) AS count FROM zv_config where workspace = ?`);
+            const res = countStmt.get(pathHash);
+            const { count } = res;
+            if (count === 1) {
+                const updateStmt = db.prepare(`UPDATE zv_config SET defaults = ? WHERE workspace = ?`);
+                updateStmt.run(defaults, pathHash);
+            }
+            resolve(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject("Error while updating defaults.");
+        }
+    });
+};
+export const deleteCredentials = (db) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const workspaceHash = generateWorkspaceHash();
+            db.prepare(`DELETE FROM zv_config WHERE workspace = ?`).bind(workspaceHash).run();
+            resolve(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject("Error while removing user");
+        }
+    });
+};
+export const reset = () => {
+    const db = getZvDB();
+    return new Promise((resolve, reject) => {
+        try {
+            db.prepare(`DROP TABLE IF EXISTS zv_config`).run();
+            resolve(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject("Error while dropping table");
+        }
+    });
+};
+export const decryptUserConfig = async (data) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const { credentials, language, createdtime, dc, hasmasterkey, defaults, zuid } = data;
+            const decryptedCredentials = JSON.parse(await decryptString(credentials));
+            const decryptedLanguage = await decryptString(language);
+            const decryptedCreatedTime = await decryptString(createdtime);
+            const decryptedDC = await decryptString(dc);
+            const modifiedHasmasterkey = (hasmasterkey === "true");
+            const def = JSON.parse(Vault.Base64_decode(await decryptString(defaults)));
+            const decryptedZuid = await decryptString(zuid);
+            const res = {
+                ...data,
+                credentials: decryptedCredentials,
+                language: decryptedLanguage,
+                createdtime: decryptedCreatedTime,
+                dc: decryptedDC,
+                hasmasterkey: modifiedHasmasterkey,
+                defaults: def,
+                zuid: decryptedZuid
+            };
+            resolve(res);
+        }
+        catch (err) {
+            Logger.error(err);
+            console.log("Credentials not found try logging in again");
+            exit(0);
+        }
+    });
+};
+export const getDecryptedCredentials = (pathHash) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const data = getCredentials(pathHash);
+            if (!data) {
+                resolve(undefined);
+            }
+            resolve(await decryptUserConfig(data));
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(new Error("Error while decrypting credentials"));
+        }
+    });
+};
+//# sourceMappingURL=db.utils.js.map

package/out/util/dbutils/dbtable.utils.js

@@ -0,0 +1,19 @@
+export const createTable = (db) => {
+    try {
+        db.prepare(`CREATE TABLE IF NOT EXISTS zv_config(
+            workspace VARCHAR PRIMARY KEY,
+            credentials VARCHAR,
+            language VARCHAR,
+            createdtime VARCHAR,
+            dc VARCHAR,
+            hasmasterkey VARCHAR,
+            defaults VARCHAR,
+            zuid VARCHAR
+        )`).run();
+        return true;
+    }
+    catch (err) {
+        throw new Error("Error while creating table");
+    }
+};
+//# sourceMappingURL=dbtable.utils.js.map

package/out/util/dev.utils.js

@@ -0,0 +1,14 @@
+import { MODE } from "./consts.util.js";
+export const getConfig = () => {
+    if (process.env.MODE === MODE.DEVELOPMENT) {
+        return {
+            MODE: process.env.MODE,
+            ACCOUNTS_URL: process.env.ACCOUNTS_URL,
+            VAULT_URL: process.env.VAULT_URL,
+            CLIENT_ID: process.env.CLIENT_ID,
+            CLIENT_SECRET: process.env.CLIENT_SECRET
+        };
+    }
+    return { MODE: MODE.PRODUCTION, ACCOUNTS_URL: '', VAULT_URL: '', CLIENT_ID: '', CLIENT_SECRET: '' };
+};
+//# sourceMappingURL=dev.utils.js.map

package/out/util/encryptionutil/encryption.uitl.js

@@ -0,0 +1,108 @@
+import webcrypto from "node:crypto";
+import { readFromKeyring, writeToKeyring } from "../keyringutil/keyring.util.js";
+import { reset } from "../dbutils/db.utils.js";
+import { Logger } from "../../js/logger/index.js";
+import { KEYRING_SERVICE, KEYRING_ACCOUNT } from "../consts.util.js";
+const { subtle } = webcrypto;
+const generateAESKeyAndIV = async () => {
+    try {
+        const key = await subtle.generateKey({
+            name: 'AES-GCM',
+            length: 256
+        }, true, ['encrypt', 'decrypt']);
+        const webkey = await subtle.exportKey('jwk', key);
+        const iv = Array.from(webcrypto.getRandomValues(new Uint8Array(12)));
+        return { webkey, iv };
+    }
+    catch (err) {
+        Logger.error(err);
+        // console.log("Error while generating AES key and IV");
+    }
+};
+export const getEncryptionKey = async () => {
+    try {
+        let res = await readFromKeyring(KEYRING_SERVICE, KEYRING_ACCOUNT);
+        if (!res) {
+            await reset();
+            const keyData = await generateAESKeyAndIV();
+            await writeToKeyring(JSON.stringify(keyData), KEYRING_SERVICE, KEYRING_ACCOUNT);
+            res = await readFromKeyring(KEYRING_SERVICE, KEYRING_ACCOUNT);
+        }
+        return JSON.parse(res);
+    }
+    catch (err) {
+        Logger.error(err);
+        // console.log("Error while getting encryption key.");
+    }
+};
+export const getFormattedCredentials = async () => {
+    try {
+        const encryptionCredentials = await getEncryptionKey();
+        const { webkey, iv: ivBuffer } = encryptionCredentials;
+        const key = await subtle.importKey('jwk', webkey, 'AES-GCM', true, ['encrypt', 'decrypt']);
+        const iv = new Uint8Array(ivBuffer).slice(0, 12);
+        return { key, iv };
+    }
+    catch (err) {
+        Logger.error(err);
+        // console.log("Error while getting formatted credentials");
+    }
+};
+export const encryptString = async (plainText) => {
+    try {
+        const en = new TextEncoder();
+        const encodedText = en.encode(plainText);
+        const formattedCredentials = await getFormattedCredentials();
+        if (!formattedCredentials) {
+            throw new Error();
+        }
+        const { key, iv } = await getFormattedCredentials();
+        const cipherText = await subtle.encrypt({
+            name: 'AES-GCM',
+            iv
+        }, key, encodedText);
+        return Buffer.from(cipherText).toString('base64');
+    }
+    catch (err) {
+        Logger.error(err);
+        // console.log("Error while encrypting string");
+    }
+};
+export const str2ab = (str) => {
+    try {
+        let binaryString = Buffer.from(str, 'base64').toString('binary');
+        let buf = new ArrayBuffer(binaryString.length); // 2 bytes for each char
+        let bufView = new Uint8Array(buf);
+        for (let i = 0, strLen = binaryString.length; i < strLen; i++) {
+            bufView[i] = binaryString.charCodeAt(i);
+        }
+        return buf;
+    }
+    catch (err) {
+        Logger.error(err);
+        // console.log("Error while converting string to arraybuffer")
+    }
+};
+export const decryptString = async (cipherText) => {
+    try {
+        const dc = new TextDecoder();
+        let formattedCredentials = await getFormattedCredentials();
+        if (!formattedCredentials) {
+            throw new Error();
+        }
+        const { key, iv } = formattedCredentials;
+        const cipherTextBuffer = str2ab(cipherText);
+        if (!cipherTextBuffer) {
+            throw new Error();
+        }
+        const plainTextBuffer = await subtle.decrypt({
+            name: 'AES-GCM',
+            iv: iv
+        }, key, cipherTextBuffer);
+        return dc.decode(plainTextBuffer);
+    }
+    catch (err) {
+        Logger.error(err);
+    }
+};
+//# sourceMappingURL=encryption.uitl.js.map