chore(frontend): changed source code to src folder from root

frontend/src/components/utilities/secrets/checkOverrides.ts

@@ -0,0 +1,26 @@
+import { SecretDataProps } from "public/data/frequentInterfaces";
+
+/**
+ * This function downloads the secrets as a .env file
+ * @param {object} obj 
+ * @param {SecretDataProps[]} obj.data - secrets that we want to check for overrides
+ * @returns 
+ */
+const checkOverrides = async ({ data }: { data: SecretDataProps[]; }) => {
+  let secrets : SecretDataProps[] = data!.map((secret) => Object.create(secret));
+  const overridenSecrets = data!.filter(
+    (secret) => (secret.valueOverride == undefined || secret?.value != secret?.valueOverride) ? 'shared' : 'personal'
+  );
+  if (overridenSecrets.length) {
+    overridenSecrets.forEach((secret) => {
+      const index = secrets!.findIndex(
+        (_secret) => _secret.key === secret.key && (secret.valueOverride == undefined || secret?.value != secret?.valueOverride)
+      );
+      secrets![index].value = secret.value;
+    });
+    secrets = secrets!.filter((secret) => (secret.valueOverride == undefined || secret?.value != secret?.valueOverride));
+  }
+  return secrets;
+}
+
+export default checkOverrides;

frontend/src/components/utilities/secrets/downloadDotEnv.ts

@@ -0,0 +1,39 @@
+import { envMapping } from "public/data/frequentConstants";
+import { SecretDataProps } from "public/data/frequentInterfaces";
+
+import checkOverrides from './checkOverrides';
+
+
+/**
+ * This function downloads the secrets as a .env file
+ * @param {object} obj 
+ * @param {SecretDataProps[]} obj.data - secrets that we want to download
+ * @param {string} obj.env - the environment which we're downloading (used for naming the file)
+ */
+const downloadDotEnv = async ({ data, env }: { data: SecretDataProps[]; env: string; }) => {
+  if (!data) return;
+  const secrets = await checkOverrides({ data });
+
+  const file = secrets!
+    .map(
+      (item: SecretDataProps) =>
+        `${
+          item.comment
+            ? item.comment
+                .split('\n')
+                .map((comment) => '# '.concat(comment))
+                .join('\n') + '\n'
+            : ''
+        }` + [item.key, item.value].join('=')
+    )
+    .join('\n');
+
+    const blob = new Blob([file]);
+    const fileDownloadUrl = URL.createObjectURL(blob);
+    const alink = document.createElement('a');
+    alink.href = fileDownloadUrl;
+    alink.download = env + '.env';
+    alink.click();
+}
+
+export default downloadDotEnv;

frontend/src/components/utilities/secrets/downloadYaml.ts

@@ -0,0 +1,46 @@
+// import YAML from 'yaml';
+// import { YAMLSeq } from 'yaml/types';
+
+import { SecretDataProps } from "public/data/frequentInterfaces";
+
+// import { envMapping } from "../../../public/data/frequentConstants";
+// import checkOverrides from './checkOverrides';
+
+
+/**
+ * This function downloads the secrets as a .yml file
+ * @param {object} obj 
+ * @param {SecretDataProps[]} obj.data - secrets that we want to download
+ * @param {string} obj.env - used for naming the file
+ * @returns 
+ */
+const downloadYaml = async ({ data, env }: { data: SecretDataProps[]; env: string; }) => {
+  // if (!data) return;
+  // const doc = new YAML.Document();
+  // doc.contents = new YAMLSeq();
+  // const secrets = await checkOverrides({ data });
+  // secrets.forEach((secret) => {
+  //   const pair = YAML.createNode({ [secret.key]: secret.value });
+  //   pair.commentBefore = secret.comment
+  //     .split('\n')
+  //     .map((line) => (line ? ' '.concat(line) : ''))
+  //     .join('\n');
+  //   doc.add(pair);
+  // });
+
+  // const file = doc
+  //   .toString()
+  //   .split('\n')
+  //   .map((line) => (line.startsWith('-') ? line.replace('- ', '') : line))
+  //   .join('\n');
+
+  // const blob = new Blob([file]);
+  // const fileDownloadUrl = URL.createObjectURL(blob);
+  // const alink = document.createElement('a');
+  // alink.href = fileDownloadUrl;
+  // alink.download = envMapping[env] + '.yml';
+  // alink.click();
+  return;
+}
+
+export default downloadYaml;

frontend/src/components/utilities/secrets/encryptSecrets.ts

@@ -0,0 +1,115 @@
+import { SecretDataProps } from "public/data/frequentInterfaces";
+
+import getLatestFileKey from "~/pages/api/workspace/getLatestFileKey";
+
+const crypto = require("crypto");
+const {
+  decryptAssymmetric,
+  encryptSymmetric,
+} = require("../cryptography/crypto");
+const nacl = require("tweetnacl");
+nacl.util = require("tweetnacl-util");
+
+
+interface EncryptedSecretProps {
+  id: string;
+  createdAt: string;
+  environment: string;
+  secretCommentCiphertext: string;
+  secretCommentIV: string;
+  secretCommentTag: string;
+  secretKeyCiphertext: string;
+  secretKeyIV: string;
+  secretKeyTag: string;
+  secretValueCiphertext: string;
+  secretValueIV: string;
+  secretValueTag: string;
+  type: "personal" | "shared";
+}
+
+/**
+ * Encypt secrets before pushing the to the DB
+ * @param {object} obj 
+ * @param {object} obj.secretsToEncrypt - secrets that we want to encrypt
+ * @param {object} obj.workspaceId - the id of a project in which we are encrypting secrets
+ * @returns 
+ */
+const encryptSecrets = async ({ secretsToEncrypt, workspaceId, env }: { secretsToEncrypt: SecretDataProps[]; workspaceId: string; env: string; }) => {
+  let secrets;
+  try {
+    const sharedKey = await getLatestFileKey({ workspaceId });
+
+    const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY");
+
+    let randomBytes: string;
+    if (Object.keys(sharedKey).length > 0) {
+      // case: a (shared) key exists for the workspace
+      randomBytes = decryptAssymmetric({
+        ciphertext: sharedKey.latestKey.encryptedKey,
+        nonce: sharedKey.latestKey.nonce,
+        publicKey: sharedKey.latestKey.sender.publicKey,
+        privateKey: PRIVATE_KEY,
+      });
+    } else {
+      // case: a (shared) key does not exist for the workspace
+      randomBytes = crypto.randomBytes(16).toString("hex");
+    }
+    
+    secrets = secretsToEncrypt.map((secret) => {
+      // encrypt key
+      const {
+        ciphertext: secretKeyCiphertext,
+        iv: secretKeyIV,
+        tag: secretKeyTag,
+      } = encryptSymmetric({
+        plaintext: secret.key,
+        key: randomBytes,
+      });
+
+      // encrypt value
+      const {
+        ciphertext: secretValueCiphertext,
+        iv: secretValueIV,
+        tag: secretValueTag,
+      } = encryptSymmetric({
+        plaintext: secret.value,
+        key: randomBytes,
+      });
+
+      // encrypt comment
+      const {
+        ciphertext: secretCommentCiphertext,
+        iv: secretCommentIV,
+        tag: secretCommentTag,
+      } = encryptSymmetric({
+        plaintext: secret.comment ?? '',
+        key: randomBytes,
+      });
+
+      const result: EncryptedSecretProps = {
+        id: secret.id,
+        createdAt: '',
+        environment: env,
+        secretKeyCiphertext,
+        secretKeyIV,
+        secretKeyTag,
+        secretValueCiphertext,
+        secretValueIV,
+        secretValueTag,
+        secretCommentCiphertext,
+        secretCommentIV,
+        secretCommentTag,
+        type: (secret.valueOverride == undefined || secret?.value != secret?.valueOverride) ? 'shared' : 'personal',
+      };
+
+      return result;
+    });
+  } catch (error) {
+    console.log("Error while encrypting secrets");
+  }
+
+  return secrets;
+  
+}
+
+export default encryptSecrets;

frontend/src/components/utilities/secrets/getSecretsForProject.ts

@@ -0,0 +1,141 @@
+import getSecrets from '~/pages/api/files/GetSecrets';
+import getLatestFileKey from '~/pages/api/workspace/getLatestFileKey';
+
+const {
+  decryptAssymmetric,
+  decryptSymmetric
+} = require('../cryptography/crypto');
+const nacl = require('tweetnacl');
+nacl.util = require('tweetnacl-util');
+
+interface EncryptedSecretProps {
+  _id: string;
+  createdAt: string;
+  environment: string;
+  secretCommentCiphertext: string;
+  secretCommentIV: string;
+  secretCommentTag: string;
+  secretKeyCiphertext: string;
+  secretKeyIV: string;
+  secretKeyTag: string;
+  secretValueCiphertext: string;
+  secretValueIV: string;
+  secretValueTag: string;
+  type: "personal" | "shared";
+}
+
+interface SecretProps { 
+  key: string; 
+  value: string; 
+  type: 'personal' | 'shared'; 
+  comment: string; 
+  id: string;
+}
+
+interface FunctionProps {
+  env: string;
+  setIsKeyAvailable: any;
+  setData: any;
+  workspaceId: string;
+}
+
+/**
+ * Gets the secrets for a certain project
+ * @param {object} obj
+ * @param {string} obj.env - environment for which we are getting secrets
+ * @param {boolean} obj.isKeyAvailable - if a person is able to create new key pairs
+ * @param {function} obj.setData - state function that manages the state of secrets in the dashboard
+ * @param {string} obj.workspaceId - id of a workspace for which we are getting secrets
+ */
+const getSecretsForProject = async ({
+  env,
+  setIsKeyAvailable,
+  setData,
+  workspaceId
+}: FunctionProps) => {
+  try {
+    let encryptedSecrets;
+    try {
+      encryptedSecrets = await getSecrets(workspaceId, env);
+    } catch (error) {
+      console.log('ERROR: Not able to access the latest version of secrets');
+    }
+
+    const latestKey = await getLatestFileKey({ workspaceId })
+    // This is called isKeyAvailable but what it really means is if a person is able to create new key pairs
+    setIsKeyAvailable(!latestKey ? encryptedSecrets.length == 0 : true);
+
+    const PRIVATE_KEY = localStorage.getItem('PRIVATE_KEY');
+
+    const tempDecryptedSecrets: SecretProps[] = [];
+    if (latestKey) {
+      // assymmetrically decrypt symmetric key with local private key
+      const key = decryptAssymmetric({
+        ciphertext: latestKey.latestKey.encryptedKey,
+        nonce: latestKey.latestKey.nonce,
+        publicKey: latestKey.latestKey.sender.publicKey,
+        privateKey: PRIVATE_KEY
+      });
+
+      // decrypt secret keys, values, and comments
+      encryptedSecrets.map((secret: EncryptedSecretProps) => {
+        const plainTextKey = decryptSymmetric({
+          ciphertext: secret.secretKeyCiphertext,
+          iv: secret.secretKeyIV,
+          tag: secret.secretKeyTag,
+          key
+        });
+
+        const plainTextValue = decryptSymmetric({
+          ciphertext: secret.secretValueCiphertext,
+          iv: secret.secretValueIV,
+          tag: secret.secretValueTag,
+          key
+        });
+
+        let plainTextComment;
+        if (secret.secretCommentCiphertext) {
+          plainTextComment = decryptSymmetric({
+            ciphertext: secret.secretCommentCiphertext,
+            iv: secret.secretCommentIV,
+            tag: secret.secretCommentTag,
+            key
+          });
+        } else {
+          plainTextComment = "";
+        }
+
+        tempDecryptedSecrets.push({
+          id: secret._id,
+          key: plainTextKey,
+          value: plainTextValue,
+          type: secret.type,
+          comment: plainTextComment
+        });
+      });
+    }
+
+    const secretKeys = [...new Set(tempDecryptedSecrets.map(secret => secret.key))];
+
+    
+    const result = secretKeys.map((key, index) => {
+      return {
+        id: tempDecryptedSecrets.filter(secret => secret.key == key && secret.type == 'shared')[0]?.id,
+        idOverride: tempDecryptedSecrets.filter(secret => secret.key == key && secret.type == 'personal')[0]?.id,
+        pos: index,
+        key: key,
+        value: tempDecryptedSecrets.filter(secret => secret.key == key && secret.type == 'shared')[0]?.value,
+        valueOverride: tempDecryptedSecrets.filter(secret => secret.key == key && secret.type == 'personal')[0]?.value,
+        comment: tempDecryptedSecrets.filter(secret => secret.key == key && secret.type == 'shared')[0]?.comment,
+      }
+    });
+
+    setData(result);
+    return result;
+  } catch (error) {
+    console.log('Something went wrong during accessing or decripting secrets.');
+  }
+  return [];
+};
+
+export default getSecretsForProject;