@raketa-cloud/admin 0.0.99 → 0.0.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.99",
+  "version": "0.0.100",
   "main": "src/index.js",
   "scripts": {
     "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",

package/src/cipher.js

@@ -0,0 +1,49 @@
+import {
+  pbkdf2Sync,
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+} from "node:crypto";
+
+const ALGORITHM = "aes-256-cbc";
+const IV = randomBytes(16);
+const SALT = "some string to have a salt value..";
+
+function deriveKey(password) {
+  return pbkdf2Sync(password, SALT, 100000, 32, "sha256");
+}
+
+function encrypt(plaintext, config) {
+  const cipher = createCipheriv(
+    ALGORITHM,
+    deriveKey(config.secrets.crypto_secret),
+    IV
+  );
+
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+
+  encrypted += cipher.final("hex");
+
+  return `${IV.toString("hex")}:${encrypted}`;
+}
+
+function decrypt(encryptedText, config) {
+  const [ivHex, encrypted] = encryptedText.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+
+  const decipher = createDecipheriv(
+    ALGORITHM,
+    deriveKey(config.secrets.crypto_secret),
+    iv
+  );
+
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+
+  return decrypted;
+}
+
+export default {
+  encrypt,
+  decrypt,
+};

package/src/cloud/Settings.js

@@ -6,17 +6,11 @@ import {
 
 export default class Settings extends RaketaClient {
   async find(locale) {
-    const {
-      setting,
-    } = await this.query(SettingDocument, {
+    const { setting } = await this.query(SettingDocument, {
       locale,
     });
 
-    if (!setting?.value) {
-      this.logError(`Cannot find settings for ${locale} locale.`)
-    }
-
-    return setting.value;
+    return setting?.value || {};
   }
 
   async update(locale, params) {

package/src/setupAuthentication.js

@@ -1,45 +1,30 @@
-import { createHmac, randomBytes } from "node:crypto";
 import ejs from "ejs";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
 import currentPath from "./currentPath.cjs";
 import AuthHelper from "./helpers/AuthHelper";
-// TODO: Maybe change the encryption mechanism?
-import simpleCipher from "./simpleCipher";
+import cipher from "./cipher";
 
-// Generate a random signing secret on every server restart
-// const SIGNING_SECRET = randomBytes(64).toString("hex");
 const DELIMITER = ",";
 
-function calculateHash(text, config) {
-  return createHmac("sha256", config.secrets.signing_secret)
-    .update(text)
-    .digest("hex");
-}
-
 function obfuscateToken(token, config) {
   const date = new Date();
   const timestamp = date.getTime() + 2 * 60000;
-  const timestamped = [token, timestamp].join(DELIMITER);
-  const hash = calculateHash(timestamped, config);
-  const signed = [hash, timestamped].join(DELIMITER);
+  const data = [token, timestamp].join(DELIMITER);
 
-  return Buffer.from(simpleCipher.encrypt(signed, config)).toString("base64");
+  return Buffer.from(cipher.encrypt(data, config)).toString("base64");
 }
 
 function extractToken(text, config) {
   const encrypted = Buffer.from(text, "base64").toString("ascii");
-  const signed = simpleCipher.decrypt(encrypted, config);
-  const [hash, token, timestamp] = signed.split(DELIMITER);
+  const data = cipher.decrypt(encrypted, config);
+  const [token, timestamp] = data.split(DELIMITER);
+
   const tDate = new Date(Number.parseInt(timestamp, 10));
 
   if (tDate < new Date()) {
     return null;
   }
 
-  if (hash !== calculateHash([token, timestamp].join(DELIMITER), config)) {
-    return null;
-  }
-
   return token;
 }
 

package/src/simpleCipher.js

@@ -1,58 +0,0 @@
-const ALPHABET =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
-
-function generateEncryptionLookup(key) {
-  const lookup = {};
-
-  ALPHABET.split("").forEach((char, index) => {
-    lookup[char] = key[index];
-  });
-
-  return lookup;
-}
-
-function generateDecryptionLookup(key) {
-  const lookup = {};
-
-  key.split("").forEach((char, index) => {
-    lookup[char] = ALPHABET[index];
-  });
-
-  return lookup;
-}
-
-// function generateKey() {
-//   const shuffled = ALPHABET.split("")
-//     .sort(() => Math.random() - 0.5)
-//     .join("");
-
-//   return shuffled;
-// }
-
-// Scramble lookup maps on every server restart
-// const CIPHER_KEY = generateKey();
-// const ENCRYPT_LOOKUP = generateEncryptionLookup(CIPHER_KEY);
-// const DECRYPT_LOOKUP = generateDecryptionLookup(CIPHER_KEY);
-
-function encrypt(plaintext, config) {
-  const ecryptLookup = generateEncryptionLookup(config.secrets.crypto_secret);
-
-  return plaintext
-    .split("")
-    .map((char) => ecryptLookup[char] || char)
-    .join("");
-}
-
-function decrypt(ciphertext, config) {
-  const decryptLookup = generateDecryptionLookup(config.secrets.crypto_secret);
-
-  return ciphertext
-    .split("")
-    .map((char) => decryptLookup[char] || char)
-    .join("");
-}
-
-export default {
-  encrypt,
-  decrypt,
-};