Merge branch 'main' of github.com:LemmyMwaura/infisical into secrets-dash-jumping-bug-#51

frontend/components/utilities/SecurityClient.js

@@ -1,24 +0,0 @@
-import token from "~/pages/api/auth/Token";
-
-export default class SecurityClient {
-  static #token = "";
-
-  constructor() {}
-
-  static setToken(token) {
-    this.#token = token;
-  }
-
-  static async fetchCall(resource, options) {
-    let req = new Request(resource, options);
-
-    if (this.#token == "") {
-      this.setToken(await token());
-    }
-
-    if (this.#token) {
-      req.headers.set("Authorization", "Bearer " + this.#token);
-      return fetch(req);
-    }
-  }
-}

frontend/components/utilities/SecurityClient.ts

@@ -0,0 +1,27 @@
+import token from '~/pages/api/auth/Token';
+
+export default class SecurityClient {
+  static #token = '';
+
+  constructor() {}
+
+  static setToken(token: string) {
+    this.#token = token;
+  }
+
+  static async fetchCall(
+    resource: RequestInfo,
+    options?: RequestInit | undefined
+  ) {
+    const req = new Request(resource, options);
+
+    if (this.#token == '') {
+      this.setToken(await token());
+    }
+
+    if (this.#token) {
+      req.headers.set('Authorization', 'Bearer ' + this.#token);
+      return fetch(req);
+    }
+  }
+}

frontend/components/utilities/attemptLogin.js

@@ -1,17 +1,17 @@
-import Aes256Gcm from "~/components/utilities/cryptography/aes-256-gcm";
-import login1 from "~/pages/api/auth/Login1";
-import login2 from "~/pages/api/auth/Login2";
-import getOrganizations from "~/pages/api/organization/getOrgs";
-import getOrganizationUserProjects from "~/pages/api/organization/GetOrgUserProjects";
+import Aes256Gcm from '~/components/utilities/cryptography/aes-256-gcm';
+import login1 from '~/pages/api/auth/Login1';
+import login2 from '~/pages/api/auth/Login2';
+import getOrganizations from '~/pages/api/organization/getOrgs';
+import getOrganizationUserProjects from '~/pages/api/organization/GetOrgUserProjects';
 
-import pushKeys from "./secrets/pushKeys";
-import { saveTokenToLocalStorage } from "./saveTokenToLocalStorage";
-import SecurityClient from "./SecurityClient";
-import Telemetry from "./telemetry/Telemetry";
+import pushKeys from './secrets/pushKeys';
+import Telemetry from './telemetry/Telemetry';
+import { saveTokenToLocalStorage } from './saveTokenToLocalStorage';
+import SecurityClient from './SecurityClient';
 
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
-const jsrp = require("jsrp");
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+const jsrp = require('jsrp');
 const client = new jsrp.client();
 
 /**
@@ -37,7 +37,7 @@ const attemptLogin = async (
     client.init(
       {
         username: email,
-        password: password,
+        password: password
       },
       async () => {
         const clientPublicKey = client.getPublicKey();
@@ -54,54 +54,53 @@ const attemptLogin = async (
             await login2(email, clientProof);
           SecurityClient.setToken(token);
 
-          const privateKey = Aes256Gcm.decrypt(
-            encryptedPrivateKey,
+          const privateKey = Aes256Gcm.decrypt({
+            ciphertext: encryptedPrivateKey,
             iv,
             tag,
-            password
+            secret: password
               .slice(0, 32)
               .padStart(
                 32 + (password.slice(0, 32).length - new Blob([password]).size),
-                "0"
+                '0'
               )
-          );
+          });
 
           saveTokenToLocalStorage({
-            token,
             publicKey,
             encryptedPrivateKey,
             iv,
             tag,
-            privateKey,
+            privateKey
           });
 
           const userOrgs = await getOrganizations();
           const userOrgsData = userOrgs.map((org) => org._id);
 
           let orgToLogin;
-          if (userOrgsData.includes(localStorage.getItem("orgData.id"))) {
-            orgToLogin = localStorage.getItem("orgData.id");
+          if (userOrgsData.includes(localStorage.getItem('orgData.id'))) {
+            orgToLogin = localStorage.getItem('orgData.id');
           } else {
             orgToLogin = userOrgsData[0];
-            localStorage.setItem("orgData.id", orgToLogin);
+            localStorage.setItem('orgData.id', orgToLogin);
           }
 
           let orgUserProjects = await getOrganizationUserProjects({
-            orgId: orgToLogin,
+            orgId: orgToLogin
           });
 
           orgUserProjects = orgUserProjects?.map((project) => project._id);
           let projectToLogin;
           if (
-            orgUserProjects.includes(localStorage.getItem("projectData.id"))
+            orgUserProjects.includes(localStorage.getItem('projectData.id'))
           ) {
-            projectToLogin = localStorage.getItem("projectData.id");
+            projectToLogin = localStorage.getItem('projectData.id');
           } else {
             try {
               projectToLogin = orgUserProjects[0];
-              localStorage.setItem("projectData.id", projectToLogin);
+              localStorage.setItem('projectData.id', projectToLogin);
             } catch (error) {
-              console.log("ERROR: User likely has no projects. ", error);
+              console.log('ERROR: User likely has no projects. ', error);
             }
           }
 
@@ -110,38 +109,35 @@ const attemptLogin = async (
             await pushKeys({
               obj: {
                 DATABASE_URL: [
-                  "mongodb+srv://${DB_USERNAME}:${DB_PASSWORD}@mongodb.net",
-                  "personal",
+                  'mongodb+srv://${DB_USERNAME}:${DB_PASSWORD}@mongodb.net',
+                  'personal'
                 ],
-                DB_USERNAME: ["user1234", "personal"],
-                DB_PASSWORD: ["ah8jak3hk8dhiu4dw7whxwe1l", "personal"],
-                TWILIO_AUTH_TOKEN: [
-                  "hgSIwDAKvz8PJfkj6xkzYqzGmAP3HLuG",
-                  "shared",
-                ],
-                WEBSITE_URL: ["http://localhost:3000", "shared"],
-                STRIPE_SECRET_KEY: ["sk_test_7348oyho4hfq398HIUOH78", "shared"],
+                DB_USERNAME: ['user1234', 'personal'],
+                DB_PASSWORD: ['example_password', 'personal'],
+                TWILIO_AUTH_TOKEN: ['example_twillion_token', 'shared'],
+                WEBSITE_URL: ['http://localhost:3000', 'shared'],
+                STRIPE_SECRET_KEY: ['sk_test_7348oyho4hfq398HIUOH78', 'shared']
               },
               workspaceId: projectToLogin,
-              env: "Development",
+              env: 'Development'
             });
           }
           if (email) {
             telemetry.identify(email);
-            telemetry.capture("User Logged In");
+            telemetry.capture('User Logged In');
           }
 
           if (isLogin) {
-            router.push("/dashboard/");
+            router.push('/dashboard/');
           }
         } catch (error) {
           setErrorLogin(true);
-          console.log("Login response not available");
+          console.log('Login response not available');
         }
       }
     );
   } catch (error) {
-    console.log("Something went wrong during authentication");
+    console.log('Something went wrong during authentication');
   }
   return true;
 };

frontend/components/utilities/checks/OnboardingCheck.ts

@@ -0,0 +1,71 @@
+import getOrganizationUsers from '~/pages/api/organization/GetOrgUsers';
+import checkUserAction from '~/pages/api/userActions/checkUserAction';
+
+interface OnboardingCheckProps {
+  setTotalOnboardingActionsDone?: (value: number) => void;
+  setHasUserClickedSlack?: (value: boolean) => void;
+  setHasUserClickedIntro?: (value: boolean) => void;
+  setHasUserStarred?: (value: boolean) => void;
+  setHasUserPushedSecrets?: (value: boolean) => void;
+  setUsersInOrg?: (value: boolean) => void;
+}
+
+/**
+ * This function checks which onboarding steps a user has already finished.
+ */
+const onboardingCheck = async ({
+  setTotalOnboardingActionsDone,
+  setHasUserClickedSlack,
+  setHasUserClickedIntro,
+  setHasUserStarred,
+  setHasUserPushedSecrets,
+  setUsersInOrg
+}: OnboardingCheckProps) => {
+  let countActions = 0;
+  const userActionSlack = await checkUserAction({
+    action: 'slack_cta_clicked'
+  });
+  if (userActionSlack) {
+    countActions = countActions + 1;
+  }
+  setHasUserClickedSlack &&
+    setHasUserClickedSlack(userActionSlack ? true : false);
+
+  const userActionSecrets = await checkUserAction({
+    action: 'first_time_secrets_pushed'
+  });
+  if (userActionSecrets) {
+    countActions = countActions + 1;
+  }
+  setHasUserPushedSecrets &&
+    setHasUserPushedSecrets(userActionSecrets ? true : false);
+
+  const userActionIntro = await checkUserAction({
+    action: 'intro_cta_clicked'
+  });
+  if (userActionIntro) {
+    countActions = countActions + 1;
+  }
+  setHasUserClickedIntro &&
+    setHasUserClickedIntro(userActionIntro ? true : false);
+
+  const userActionStar = await checkUserAction({
+    action: 'star_cta_clicked'
+  });
+  if (userActionStar) {
+    countActions = countActions + 1;
+  }
+  setHasUserStarred && setHasUserStarred(userActionStar ? true : false);
+
+  const orgId = localStorage.getItem('orgData.id');
+  const orgUsers = await getOrganizationUsers({
+    orgId: orgId ? orgId : ''
+  });
+  if (orgUsers.length > 1) {
+    countActions = countActions + 1;
+  }
+  setUsersInOrg && setUsersInOrg(orgUsers.length > 1);
+  setTotalOnboardingActionsDone && setTotalOnboardingActionsDone(countActions);
+};
+
+export default onboardingCheck;

frontend/components/utilities/cryptography/aes-256-gcm.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Provides easy encryption/decryption methods using AES 256 GCM.
- */
-
-"use strict";
-
-const crypto = require("crypto");
-
-const ALGORITHM = "aes-256-gcm";
-const BLOCK_SIZE_BYTES = 16; // 128 bit
-
-/**
- * Provides easy encryption/decryption methods using AES 256 GCM.
- */
-class Aes256Gcm {
-  /**
-   * No need to run the constructor. The class only has static methods.
-   */
-  constructor() {}
-
-  /**
-   * Encrypts text with AES 256 GCM.
-   * @param {string} text - Cleartext to encode.
-   * @param {string} secret - Shared secret key, must be 32 bytes.
-   * @returns {object}
-   */
-  static encrypt(text, secret) {
-    const iv = crypto.randomBytes(BLOCK_SIZE_BYTES);
-    const cipher = crypto.createCipheriv(ALGORITHM, secret, iv);
-
-    let ciphertext = cipher.update(text, "utf8", "base64");
-    ciphertext += cipher.final("base64");
-    return {
-      ciphertext,
-      iv: iv.toString("base64"),
-      tag: cipher.getAuthTag().toString("base64"),
-    };
-  }
-
-  /**
-   * Decrypts AES 256 CGM encrypted text.
-   * @param {string} ciphertext - Base64-encoded ciphertext.
-   * @param {string} iv - The base64-encoded initialization vector.
-   * @param {string} tag - The base64-encoded authentication tag generated by getAuthTag().
-   * @param {string} secret - Shared secret key, must be 32 bytes.
-   * @returns {string}
-   */
-  static decrypt(ciphertext, iv, tag, secret) {
-    const decipher = crypto.createDecipheriv(
-      ALGORITHM,
-      secret,
-      Buffer.from(iv, "base64")
-    );
-    decipher.setAuthTag(Buffer.from(tag, "base64"));
-
-    let cleartext = decipher.update(ciphertext, "base64", "utf8");
-    cleartext += decipher.final("utf8");
-
-    return cleartext;
-  }
-}
-
-module.exports = Aes256Gcm;

frontend/components/utilities/cryptography/aes-256-gcm.ts

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Provides easy encryption/decryption methods using AES 256 GCM.
+ */
+
+import crypto from 'crypto';
+
+const ALGORITHM = 'aes-256-gcm';
+const BLOCK_SIZE_BYTES = 16; // 128 bit
+
+interface EncryptProps {
+  text: string;
+  secret: string;
+}
+
+interface DecryptProps {
+  ciphertext: string;
+  iv: string;
+  tag: string;
+  secret: string;
+}
+
+interface EncryptOutputProps {
+  ciphertext: string;
+  iv: string;
+  tag: string;
+}
+
+/**
+ * Provides easy encryption/decryption methods using AES 256 GCM.
+ */
+class Aes256Gcm {
+  /**
+   * No need to run the constructor. The class only has static methods.
+   */
+  constructor() {}
+
+  /**
+   * Encrypts text with AES 256 GCM.
+   * @param {object} obj
+   * @param {string} obj.text - Cleartext to encode.
+   * @param {string} obj.secret - Shared secret key, must be 32 bytes.
+   * @returns {object}
+   */
+  // { ciphertext: string; iv: string; tag: string; }
+  static encrypt({ text, secret }: EncryptProps): EncryptOutputProps {
+    const iv = crypto.randomBytes(BLOCK_SIZE_BYTES);
+    const cipher = crypto.createCipheriv(ALGORITHM, secret, iv);
+
+    let ciphertext = cipher.update(text, 'utf8', 'base64');
+    ciphertext += cipher.final('base64');
+    return {
+      ciphertext,
+      iv: iv.toString('base64'),
+      tag: cipher.getAuthTag().toString('base64')
+    };
+  }
+
+  /**
+   * Decrypts AES 256 CGM encrypted text.
+   * @param {object} obj
+   * @param {string} obj.ciphertext - Base64-encoded ciphertext.
+   * @param {string} obj.iv - The base64-encoded initialization vector.
+   * @param {string} obj.tag - The base64-encoded authentication tag generated by getAuthTag().
+   * @param {string} obj.secret - Shared secret key, must be 32 bytes.
+   * @returns {string}
+   */
+  static decrypt({ ciphertext, iv, tag, secret }: DecryptProps): string {
+    const decipher = crypto.createDecipheriv(
+      ALGORITHM,
+      secret,
+      Buffer.from(iv, 'base64')
+    );
+    decipher.setAuthTag(Buffer.from(tag, 'base64'));
+
+    let cleartext = decipher.update(ciphertext, 'base64', 'utf8');
+    cleartext += decipher.final('utf8');
+
+    return cleartext;
+  }
+}
+
+export default Aes256Gcm;

frontend/components/utilities/cryptography/changePassword.js

@@ -1,11 +1,11 @@
-import changePassword2 from "~/pages/api/auth/ChangePassword2";
-import SRP1 from "~/pages/api/auth/SRP1";
+import changePassword2 from '~/pages/api/auth/ChangePassword2';
+import SRP1 from '~/pages/api/auth/SRP1';
 
-import Aes256Gcm from "./aes-256-gcm";
+import Aes256Gcm from './aes-256-gcm';
 
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
-const jsrp = require("jsrp");
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+const jsrp = require('jsrp');
 const clientOldPassword = new jsrp.client();
 const clientNewPassword = new jsrp.client();
 
@@ -34,7 +34,7 @@ const changePassword = async (
     clientOldPassword.init(
       {
         username: email,
-        password: currentPassword,
+        password: currentPassword
       },
       async () => {
         const clientPublicKey = clientOldPassword.getPublicKey();
@@ -42,13 +42,13 @@ const changePassword = async (
         let serverPublicKey, salt;
         try {
           const res = await SRP1({
-            clientPublicKey: clientPublicKey,
+            clientPublicKey: clientPublicKey
           });
           serverPublicKey = res.serverPublicKey;
           salt = res.salt;
         } catch (err) {
           setCurrentPasswordError(true);
-          console.log("Wrong current password", err, 1);
+          console.log('Wrong current password', err, 1);
         }
 
         clientOldPassword.setSalt(salt);
@@ -58,27 +58,27 @@ const changePassword = async (
         clientNewPassword.init(
           {
             username: email,
-            password: newPassword,
+            password: newPassword
           },
           async () => {
             clientNewPassword.createVerifier(async (err, result) => {
               // The Blob part here is needed to account for symbols that count as 2+ bytes (e.g., é, å, ø)
-              let { ciphertext, iv, tag } = Aes256Gcm.encrypt(
-                localStorage.getItem("PRIVATE_KEY"),
-                newPassword
+              const { ciphertext, iv, tag } = Aes256Gcm.encrypt({
+                text: localStorage.getItem('PRIVATE_KEY'),
+                secret: newPassword
                   .slice(0, 32)
                   .padStart(
                     32 +
                       (newPassword.slice(0, 32).length -
                         new Blob([newPassword]).size),
-                    "0"
+                    '0'
                   )
-              );
+              });
 
               if (ciphertext) {
-                localStorage.setItem("encryptedPrivateKey", ciphertext);
-                localStorage.setItem("iv", iv);
-                localStorage.setItem("tag", tag);
+                localStorage.setItem('encryptedPrivateKey', ciphertext);
+                localStorage.setItem('iv', iv);
+                localStorage.setItem('tag', tag);
 
                 let res;
                 try {
@@ -88,14 +88,14 @@ const changePassword = async (
                     tag,
                     salt: result.salt,
                     verifier: result.verifier,
-                    clientProof,
+                    clientProof
                   });
                   if (res.status == 400) {
                     setCurrentPasswordError(true);
                   } else if (res.status == 200) {
                     setPasswordChanged(true);
-                    setCurrentPassword("");
-                    setNewPassword("");
+                    setCurrentPassword('');
+                    setNewPassword('');
                   }
                 } catch (err) {
                   setCurrentPasswordError(true);
@@ -108,7 +108,7 @@ const changePassword = async (
       }
     );
   } catch (error) {
-    console.log("Something went wrong during changing the password");
+    console.log('Something went wrong during changing the password');
   }
   return true;
 };

frontend/components/utilities/cryptography/crypto.ts

@@ -1,12 +1,12 @@
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
-const aes = require("./aes-256-gcm");
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+import aes from './aes-256-gcm';
 
 type encryptAsymmetricProps = {
   plaintext: string;
   publicKey: string;
   privateKey: string;
-}
+};
 
 /**
  * Return assymmetrically encrypted [plaintext] using [publicKey] where
@@ -19,7 +19,11 @@ type encryptAsymmetricProps = {
  * @returns {String} ciphertext - base64-encoded ciphertext
  * @returns {String} nonce - base64-encoded nonce
  */
-const encryptAssymmetric = ({ plaintext, publicKey, privateKey }: encryptAsymmetricProps): object => {
+const encryptAssymmetric = ({
+  plaintext,
+  publicKey,
+  privateKey
+}: encryptAsymmetricProps): object => {
   const nonce = nacl.randomBytes(24);
   const ciphertext = nacl.box(
     nacl.util.decodeUTF8(plaintext),
@@ -30,7 +34,7 @@ const encryptAssymmetric = ({ plaintext, publicKey, privateKey }: encryptAsymmet
 
   return {
     ciphertext: nacl.util.encodeBase64(ciphertext),
-    nonce: nacl.util.encodeBase64(nonce),
+    nonce: nacl.util.encodeBase64(nonce)
   };
 };
 
@@ -39,7 +43,7 @@ type decryptAsymmetricProps = {
   nonce: string;
   publicKey: string;
   privateKey: string;
-}
+};
 
 /**
  * Return assymmetrically decrypted [ciphertext] using [privateKey] where
@@ -49,9 +53,13 @@ type decryptAsymmetricProps = {
  * @param {String} obj.nonce - nonce
  * @param {String} obj.publicKey - base64-encoded public key of the sender
  * @param {String} obj.privateKey - base64-encoded private key of the receiver (current user)
- * @param {String} plaintext - UTF8 plaintext
  */
-const decryptAssymmetric = ({ ciphertext, nonce, publicKey, privateKey }: decryptAsymmetricProps): string => {
+const decryptAssymmetric = ({
+  ciphertext,
+  nonce,
+  publicKey,
+  privateKey
+}: decryptAsymmetricProps): string => {
   const plaintext = nacl.box.open(
     nacl.util.decodeBase64(ciphertext),
     nacl.util.decodeBase64(nonce),
@@ -65,7 +73,7 @@ const decryptAssymmetric = ({ ciphertext, nonce, publicKey, privateKey }: decryp
 type encryptSymmetricProps = {
   plaintext: string;
   key: string;
-}
+};
 
 /**
  * Return symmetrically encrypted [plaintext] using [key].
@@ -73,15 +81,18 @@ type encryptSymmetricProps = {
  * @param {String} obj.plaintext - plaintext to encrypt
  * @param {String} obj.key - 16-byte hex key
  */
-const encryptSymmetric = ({ plaintext, key }: encryptSymmetricProps): object => {
+const encryptSymmetric = ({
+  plaintext,
+  key
+}: encryptSymmetricProps): object => {
   let ciphertext, iv, tag;
   try {
-    const obj = aes.encrypt(plaintext, key);
+    const obj = aes.encrypt({ text: plaintext, secret: key });
     ciphertext = obj.ciphertext;
     iv = obj.iv;
     tag = obj.tag;
   } catch (err) {
-    console.log("Failed to perform encryption");
+    console.log('Failed to perform encryption');
     console.log(err);
     process.exit(1);
   }
@@ -89,7 +100,7 @@ const encryptSymmetric = ({ plaintext, key }: encryptSymmetricProps): object =>
   return {
     ciphertext,
     iv,
-    tag,
+    tag
   };
 };
 
@@ -98,7 +109,7 @@ type decryptSymmetricProps = {
   iv: string;
   tag: string;
   key: string;
-}
+};
 
 /**
  * Return symmetrically decypted [ciphertext] using [iv], [tag],
@@ -110,12 +121,17 @@ type decryptSymmetricProps = {
  * @param {String} obj.key - 32-byte hex key
  *
  */
-const decryptSymmetric = ({ ciphertext, iv, tag, key }: decryptSymmetricProps): string => {
+const decryptSymmetric = ({
+  ciphertext,
+  iv,
+  tag,
+  key
+}: decryptSymmetricProps): string => {
   let plaintext;
   try {
-    plaintext = aes.decrypt(ciphertext, iv, tag, key);
+    plaintext = aes.decrypt({ ciphertext, iv, tag, secret: key });
   } catch (err) {
-    console.log("Failed to perform decryption");
+    console.log('Failed to perform decryption');
     process.exit(1);
   }
 
@@ -126,5 +142,5 @@ export {
   decryptAssymmetric,
   decryptSymmetric,
   encryptAssymmetric,
-  encryptSymmetric,
+  encryptSymmetric
 };

frontend/components/utilities/cryptography/issueBackupKey.js

@@ -1,98 +0,0 @@
-import issueBackupPrivateKey from "~/pages/api/auth/IssueBackupPrivateKey";
-import SRP1 from "~/pages/api/auth/SRP1";
-
-import generateBackupPDF from "../generateBackupPDF";
-import Aes256Gcm from "./aes-256-gcm";
-
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
-const jsrp = require("jsrp");
-const clientPassword = new jsrp.client();
-const clientKey = new jsrp.client();
-const crypto = require("crypto");
-
-/**
- * This function loggs in the user (whether it's right after signup, or a normal login)
- * @param {*} email
- * @param {*} password
- * @param {*} setErrorLogin
- * @param {*} router
- * @param {*} isSignUp
- * @returns
- */
-const issueBackupKey = async ({
-  email,
-  password,
-  personalName,
-  setBackupKeyError,
-  setBackupKeyIssued,
-}) => {
-  try {
-    setBackupKeyError(false);
-    setBackupKeyIssued(false);
-    clientPassword.init(
-      {
-        username: email,
-        password: password,
-      },
-      async () => {
-        const clientPublicKey = clientPassword.getPublicKey();
-
-        let serverPublicKey, salt;
-        try {
-          const res = await SRP1({
-            clientPublicKey: clientPublicKey,
-          });
-          serverPublicKey = res.serverPublicKey;
-          salt = res.salt;
-        } catch (err) {
-          setBackupKeyError(true);
-          console.log("Wrong current password", err, 1);
-        }
-
-        clientPassword.setSalt(salt);
-        clientPassword.setServerPublicKey(serverPublicKey);
-        const clientProof = clientPassword.getProof(); // called M1
-
-        const generatedKey = crypto.randomBytes(16).toString("hex");
-
-        clientKey.init(
-          {
-            username: email,
-            password: generatedKey,
-          },
-          async () => {
-            clientKey.createVerifier(async (err, result) => {
-              let { ciphertext, iv, tag } = Aes256Gcm.encrypt(
-                localStorage.getItem("PRIVATE_KEY"),
-                generatedKey
-              );
-
-              const res = await issueBackupPrivateKey({
-                encryptedPrivateKey: ciphertext,
-                iv,
-                tag,
-                salt: result.salt,
-                verifier: result.verifier,
-                clientProof,
-              });
-
-              if (res.status == 400) {
-                setBackupKeyError(true);
-              } else if (res.status == 200) {
-                generateBackupPDF(personalName, email, generatedKey);
-                setBackupKeyIssued(true);
-              }
-            });
-          }
-        );
-      }
-    );
-  } catch (error) {
-    setBackupKeyError(true);
-    console.log("Failed to issue a backup key");
-  }
-  return true;
-};
-
-export default issueBackupKey;

frontend/components/utilities/cryptography/issueBackupKey.ts

@@ -0,0 +1,113 @@
+import issueBackupPrivateKey from '~/pages/api/auth/IssueBackupPrivateKey';
+import SRP1 from '~/pages/api/auth/SRP1';
+
+import generateBackupPDF from '../generateBackupPDF';
+import Aes256Gcm from './aes-256-gcm';
+
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+const jsrp = require('jsrp');
+const clientPassword = new jsrp.client();
+const clientKey = new jsrp.client();
+const crypto = require('crypto');
+
+interface BackupKeyProps {
+  email: string;
+  password: string;
+  personalName: string;
+  setBackupKeyError: (value: boolean) => void;
+  setBackupKeyIssued: (value: boolean) => void;
+}
+
+/**
+ * This function issue a backup key for a user
+ * @param {obkect} obj
+ * @param {string} obj.email - email of a user issuing a backup key
+ * @param {string} obj.password - password of a user issuing a backup key
+ * @param {string} obj.personalName - name of a user issuing a backup key
+ * @param {function} obj.setBackupKeyError - state function that turns true if there is an erorr with a backup key
+ * @param {function} obj.setBackupKeyIssued - state function that turns true if a backup key was issued correctly
+ * @returns
+ */
+const issueBackupKey = async ({
+  email,
+  password,
+  personalName,
+  setBackupKeyError,
+  setBackupKeyIssued
+}: BackupKeyProps) => {
+  try {
+    setBackupKeyError(false);
+    setBackupKeyIssued(false);
+    clientPassword.init(
+      {
+        username: email,
+        password: password
+      },
+      async () => {
+        const clientPublicKey = clientPassword.getPublicKey();
+
+        let serverPublicKey, salt;
+        try {
+          const res = await SRP1({
+            clientPublicKey: clientPublicKey
+          });
+          serverPublicKey = res.serverPublicKey;
+          salt = res.salt;
+        } catch (err) {
+          setBackupKeyError(true);
+          console.log('Wrong current password', err, 1);
+        }
+
+        clientPassword.setSalt(salt);
+        clientPassword.setServerPublicKey(serverPublicKey);
+        const clientProof = clientPassword.getProof(); // called M1
+
+        const generatedKey = crypto.randomBytes(16).toString('hex');
+
+        clientKey.init(
+          {
+            username: email,
+            password: generatedKey
+          },
+          async () => {
+            clientKey.createVerifier(
+              async (err: any, result: { salt: string; verifier: string }) => {
+                const { ciphertext, iv, tag } = Aes256Gcm.encrypt({
+                  text: String(localStorage.getItem('PRIVATE_KEY')),
+                  secret: generatedKey
+                });
+
+                const res = await issueBackupPrivateKey({
+                  encryptedPrivateKey: ciphertext,
+                  iv,
+                  tag,
+                  salt: result.salt,
+                  verifier: result.verifier,
+                  clientProof
+                });
+
+                if (res?.status == 400) {
+                  setBackupKeyError(true);
+                } else if (res?.status == 200) {
+                  generateBackupPDF({
+                    personalName,
+                    personalEmail: email,
+                    generatedKey
+                  });
+                  setBackupKeyIssued(true);
+                }
+              }
+            );
+          }
+        );
+      }
+    );
+  } catch (error) {
+    setBackupKeyError(true);
+    console.log('Failed to issue a backup key');
+  }
+  return true;
+};
+
+export default issueBackupKey;

frontend/components/utilities/file.ts

@@ -6,21 +6,21 @@ const LINE =
  * @param {Buffer} src - source buffer
  * @returns {String} text - text of buffer
  */
-function parse(src) {
-  const obj = {};
+function parse(src: Buffer) {
+  const obj: Record<string, string> = {};
 
   // Convert buffer to string
   let lines = src.toString();
 
   // Convert line breaks to same format
-  lines = lines.replace(/\r\n?/gm, "\n");
+  lines = lines.replace(/\r\n?/gm, '\n');
 
   let match;
   while ((match = LINE.exec(lines)) != null) {
     const key = match[1];
 
     // Default undefined or null to empty string
-    let value = match[2] || "";
+    let value = match[2] || '';
 
     // Remove whitespace
     value = value.trim();
@@ -29,12 +29,12 @@ function parse(src) {
     const maybeQuote = value[0];
 
     // Remove surrounding quotes
-    value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+    value = value.replace(/^(['"`])([\s\S]*)\1$/gm, '$2');
 
     // Expand newlines if double quoted
     if (maybeQuote === '"') {
-      value = value.replace(/\\n/g, "\n");
-      value = value.replace(/\\r/g, "\r");
+      value = value.replace(/\\n/g, '\n');
+      value = value.replace(/\\r/g, '\r');
     }
 
     // Add to object

frontend/components/utilities/randomId.ts

@@ -3,19 +3,19 @@
  * @returns
  */
 const guidGenerator = () => {
-  var S4 = function () {
+  const S4 = function () {
     return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
   };
   return (
     S4() +
     S4() +
-    "-" +
+    '-' +
     S4() +
-    "-" +
+    '-' +
     S4() +
-    "-" +
+    '-' +
     S4() +
-    "-" +
+    '-' +
     S4() +
     S4() +
     S4()

frontend/components/utilities/secrets/getSecretsForProject.ts

@@ -1,22 +1,30 @@
-import getSecrets from "~/pages/api/files/GetSecrets";
+import getSecrets from '~/pages/api/files/GetSecrets';
 
-import { envMapping } from "../../../public/data/frequentConstants";
-import guidGenerator from "../randomId";
+import { envMapping } from '../../../public/data/frequentConstants';
+import guidGenerator from '../randomId';
 
 const {
   decryptAssymmetric,
-  decryptSymmetric,
-} = require("../cryptography/crypto");
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
+  decryptSymmetric
+} = require('../cryptography/crypto');
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+
+interface Props {
+  env: keyof typeof envMapping;
+  setFileState: any;
+  setIsKeyAvailable: any;
+  setData: any;
+  workspaceId: string;
+}
 
 const getSecretsForProject = async ({
   env,
   setFileState,
   setIsKeyAvailable,
   setData,
-  workspaceId,
-}) => {
+  workspaceId
+}: Props) => {
   try {
     let file;
     try {
@@ -24,44 +32,42 @@ const getSecretsForProject = async ({
 
       setFileState(file);
     } catch (error) {
-      console.log("ERROR: Not able to access the latest file");
+      console.log('ERROR: Not able to access the latest file');
     }
     // This is called isKeyAvilable but what it really means is if a person is able to create new key pairs
-    setIsKeyAvailable(
-      !file.key ? (file.secrets.length == 0 ? true : false) : true
-    );
+    setIsKeyAvailable(!file.key ? file.secrets.length == 0 : true);
 
-    const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY");
+    const PRIVATE_KEY = localStorage.getItem('PRIVATE_KEY');
 
-    let tempFileState = [];
+    const tempFileState: { key: string; value: string; type: string }[] = [];
     if (file.key) {
       // assymmetrically decrypt symmetric key with local private key
       const key = decryptAssymmetric({
         ciphertext: file.key.encryptedKey,
         nonce: file.key.nonce,
         publicKey: file.key.sender.publicKey,
-        privateKey: PRIVATE_KEY,
+        privateKey: PRIVATE_KEY
       });
 
-      file.secrets.map((secretPair) => {
+      file.secrets.map((secretPair: any) => {
         // decrypt .env file with symmetric key
         const plainTextKey = decryptSymmetric({
           ciphertext: secretPair.secretKey.ciphertext,
           iv: secretPair.secretKey.iv,
           tag: secretPair.secretKey.tag,
-          key,
+          key
         });
 
         const plainTextValue = decryptSymmetric({
           ciphertext: secretPair.secretValue.ciphertext,
           iv: secretPair.secretValue.iv,
           tag: secretPair.secretValue.tag,
-          key,
+          key
         });
         tempFileState.push({
           key: plainTextKey,
           value: plainTextValue,
-          type: secretPair.type,
+          type: secretPair.type
         });
       });
     }
@@ -72,9 +78,9 @@ const getSecretsForProject = async ({
         return {
           id: guidGenerator(),
           pos: index,
-          key: line["key"],
-          value: line["value"],
-          type: line["type"]
+          key: line['key'],
+          value: line['value'],
+          type: line['type']
         }
       })
     );
@@ -82,12 +88,12 @@ const getSecretsForProject = async ({
     return tempFileState.map((line, index) => [
       guidGenerator(),
       index,
-      line["key"],
-      line["value"],
-      line["type"],
+      line['key'],
+      line['value'],
+      line['type']
     ]);
   } catch (error) {
-    console.log("Something went wrong during accessing or decripting secrets.");
+    console.log('Something went wrong during accessing or decripting secrets.');
   }
   return true;
 };

frontend/components/utilities/secrets/pushKeysIntegration.js

@@ -1,74 +0,0 @@
-import publicKeyInfical from "~/pages/api/auth/publicKeyInfisical";
-import changeHerokuConfigVars from "~/pages/api/integrations/ChangeHerokuConfigVars";
-
-const crypto = require("crypto");
-const {
-  encryptSymmetric,
-  encryptAssymmetric,
-} = require("../cryptography/crypto");
-const nacl = require("tweetnacl");
-nacl.util = require("tweetnacl-util");
-
-const pushKeysIntegration = async ({ obj, integrationId }) => {
-  const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY");
-
-  let randomBytes = crypto.randomBytes(16).toString("hex");
-
-  const secrets = Object.keys(obj).map((key) => {
-    // encrypt key
-    const {
-      ciphertext: ciphertextKey,
-      iv: ivKey,
-      tag: tagKey,
-    } = encryptSymmetric({
-      plaintext: key,
-      key: randomBytes,
-    });
-
-    // encrypt value
-    const {
-      ciphertext: ciphertextValue,
-      iv: ivValue,
-      tag: tagValue,
-    } = encryptSymmetric({
-      plaintext: obj[key],
-      key: randomBytes,
-    });
-
-    const visibility = "shared";
-
-    return {
-      ciphertextKey,
-      ivKey,
-      tagKey,
-      hashKey: crypto.createHash("sha256").update(key).digest("hex"),
-      ciphertextValue,
-      ivValue,
-      tagValue,
-      hashValue: crypto.createHash("sha256").update(obj[key]).digest("hex"),
-      type: visibility,
-    };
-  });
-
-  // obtain public keys of all receivers (i.e. members in workspace)
-  let publicKeyInfisical = await publicKeyInfical();
-
-  publicKeyInfisical = (await publicKeyInfisical.json()).publicKey;
-
-  // assymmetrically encrypt key with each receiver public keys
-
-  const { ciphertext, nonce } = encryptAssymmetric({
-    plaintext: randomBytes,
-    publicKey: publicKeyInfisical,
-    privateKey: PRIVATE_KEY,
-  });
-
-  const key = {
-    encryptedKey: ciphertext,
-    nonce,
-  };
-
-  changeHerokuConfigVars({ integrationId, key, secrets });
-};
-
-export default pushKeysIntegration;

frontend/components/utilities/secrets/pushKeysIntegration.ts

@@ -0,0 +1,79 @@
+import publicKeyInfical from '~/pages/api/auth/publicKeyInfisical';
+import changeHerokuConfigVars from '~/pages/api/integrations/ChangeHerokuConfigVars';
+
+const crypto = require('crypto');
+const {
+  encryptSymmetric,
+  encryptAssymmetric
+} = require('../cryptography/crypto');
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+
+interface Props {
+  obj: Record<string, string>;
+  integrationId: string;
+}
+
+const pushKeysIntegration = async ({ obj, integrationId }: Props) => {
+  const PRIVATE_KEY = localStorage.getItem('PRIVATE_KEY');
+
+  const randomBytes = crypto.randomBytes(16).toString('hex');
+
+  const secrets = Object.keys(obj).map((key) => {
+    // encrypt key
+    const {
+      ciphertext: ciphertextKey,
+      iv: ivKey,
+      tag: tagKey
+    } = encryptSymmetric({
+      plaintext: key,
+      key: randomBytes
+    });
+
+    // encrypt value
+    const {
+      ciphertext: ciphertextValue,
+      iv: ivValue,
+      tag: tagValue
+    } = encryptSymmetric({
+      plaintext: obj[key],
+      key: randomBytes
+    });
+
+    const visibility = 'shared';
+
+    return {
+      ciphertextKey,
+      ivKey,
+      tagKey,
+      hashKey: crypto.createHash('sha256').update(key).digest('hex'),
+      ciphertextValue,
+      ivValue,
+      tagValue,
+      hashValue: crypto.createHash('sha256').update(obj[key]).digest('hex'),
+      type: visibility
+    };
+  });
+
+  // obtain public keys of all receivers (i.e. members in workspace)
+  const publicKeyInfisical = await publicKeyInfical();
+
+  const publicKey = (await publicKeyInfisical.json()).publicKey;
+
+  // assymmetrically encrypt key with each receiver public keys
+
+  const { ciphertext, nonce } = encryptAssymmetric({
+    plaintext: randomBytes,
+    publicKey,
+    privateKey: PRIVATE_KEY
+  });
+
+  const key = {
+    encryptedKey: ciphertext,
+    nonce
+  };
+
+  changeHerokuConfigVars({ integrationId, key, secrets });
+};
+
+export default pushKeysIntegration;