Update folder structure

frontend/components/utilities/secrets/getSecretsForProject.js

@@ -0,0 +1,105 @@
+import getSecrets from "~/pages/api/files/GetSecrets";
+
+import guidGenerator from "../randomId";
+
+const {
+	decryptAssymmetric,
+	decryptSymmetric,
+} = require("../cryptography/crypto");
+const nacl = require("tweetnacl");
+nacl.util = require("tweetnacl-util");
+
+const envMapping = {
+	Development: "dev",
+	Staging: "staging",
+	Production: "prod",
+	Testing: "test",
+};
+
+const getSecretsForProject = async ({
+	env,
+	setFileState,
+	setIsKeyAvailable,
+	setData,
+	workspaceId,
+}) => {
+	try {
+		let file;
+		try {
+			file = await getSecrets(workspaceId, envMapping[env]);
+
+			setFileState(file);
+		} catch (error) {
+			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
+		);
+
+		const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY");
+
+		let tempFileState = [];
+		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,
+			});
+
+			file.secrets.map((secretPair) => {
+				// decrypt .env file with symmetric key
+				const plainTextKey = decryptSymmetric({
+					ciphertext: secretPair.secretKey.ciphertext,
+					iv: secretPair.secretKey.iv,
+					tag: secretPair.secretKey.tag,
+					key,
+				});
+
+				const plainTextValue = decryptSymmetric({
+					ciphertext: secretPair.secretValue.ciphertext,
+					iv: secretPair.secretValue.iv,
+					tag: secretPair.secretValue.tag,
+					key,
+				});
+				tempFileState.push({
+					key: plainTextKey,
+					value: plainTextValue,
+					type: secretPair.type,
+				});
+			});
+		}
+		setFileState(tempFileState);
+
+		setData(
+			tempFileState.map((line, index) => [
+				guidGenerator(),
+				index,
+				line["key"],
+				line["value"],
+				line["type"],
+			])
+			// .sort((a, b) =>
+			// 	sortMethod == "alphabetical"
+			// 		? a[2].localeCompare(b[2])
+			// 		: b[2].localeCompare(a[2])
+			// )
+		);
+		return tempFileState.map((line, index) => [
+			guidGenerator(),
+			index,
+			line["key"],
+			line["value"],
+			line["type"],
+		]);
+	} catch (error) {
+		console.log(
+			"Something went wrong during accessing or decripting secrets."
+		);
+	}
+	return true;
+};
+
+export default getSecretsForProject;

frontend/components/utilities/secrets/pushKeys.js

@@ -0,0 +1,109 @@
+import uploadSecrets from "~/pages/api/files/UploadSecrets";
+import getLatestFileKey from "~/pages/api/workspace/getLatestFileKey";
+import getWorkspaceKeys from "~/pages/api/workspace/getWorkspaceKeys";
+
+const crypto = require("crypto");
+const {
+	decryptAssymmetric,
+	decryptSymmetric,
+	encryptSymmetric,
+	encryptAssymmetric,
+} = require("../cryptography/crypto");
+const nacl = require("tweetnacl");
+nacl.util = require("tweetnacl-util");
+
+const envMapping = {
+	Development: "dev",
+	Staging: "staging",
+	Production: "prod",
+	Testing: "test",
+};
+
+const pushKeys = async (obj, workspaceId, env) => {
+	let sharedKey = await getLatestFileKey(workspaceId);
+
+	const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY");
+
+	let randomBytes;
+	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");
+	}
+
+	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][0],
+			key: randomBytes,
+		});
+
+		const visibility = obj[key][1] != null ? obj[key][1] : "personal";
+
+		return {
+			ciphertextKey,
+			ivKey,
+			tagKey,
+			hashKey: crypto.createHash("sha256").update(key).digest("hex"),
+			ciphertextValue,
+			ivValue,
+			tagValue,
+			hashValue: crypto
+				.createHash("sha256")
+				.update(obj[key][0])
+				.digest("hex"),
+			type: visibility,
+		};
+	});
+
+	// obtain public keys of all receivers (i.e. members in workspace)
+	const publicKeys = await getWorkspaceKeys({
+		workspaceId,
+	});
+
+	// assymmetrically encrypt key with each receiver public keys
+	const keys = publicKeys.map((k) => {
+		const { ciphertext, nonce } = encryptAssymmetric({
+			plaintext: randomBytes,
+			publicKey: k.publicKey,
+			privateKey: PRIVATE_KEY,
+		});
+
+		return {
+			encryptedKey: ciphertext,
+			nonce,
+			userId: k.userId,
+		};
+	});
+
+	// send payload
+	await uploadSecrets({
+		workspaceId,
+		secrets,
+		keys,
+		environment: envMapping[env],
+	});
+};
+
+export default pushKeys;

frontend/components/utilities/secrets/pushKeysIntegration.js

@@ -0,0 +1,74 @@
+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;