autho 0.0.2 → 0.0.3

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "autho",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "index.js",
   "type": "module",
-  "bin":{
-    "autho": "./src/cli/bin.js"},
+  "bin": {
+    "autho": "src/cli/bin.js"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/src/cli/bin.js

@@ -13,9 +13,14 @@ const program = new Command();
 
 const getSecret = async (config) => {
   const existingSecrets = config.get("secrets", []);
+
+  if (existingSecrets.length === 0) {
+    throw new Error("No secrets found");
+  }
+
   const choices = existingSecrets.map((secret) => ({
     value: secret.id,
-    name: secret.name,
+    name: `${secret.name} (${secret.typeOptions.username || secret.id})`,
   }));
 
   const { id: secretId } = await prompt({
@@ -25,7 +30,6 @@ const getSecret = async (config) => {
     choices,
     required: true,
   });
-
   const secrets = new Secrets(config);
   const secret = await secrets.get(secretId);
 
@@ -46,19 +50,13 @@ program
       const masterPassword = args.password
         ? args.password
         : await ask({
-            name: "masterPassword",
-            message: "Password:",
-            type: "password",
-            required: true,
-          });
+          name: "masterPassword",
+          message: "Password:",
+          type: "password",
+          required: true,
+        });
       const masterPasswordHash = Cipher.hash(masterPassword);
       const config = new Config({ encryptionKey: masterPasswordHash });
-      let salt = config.get();
-
-      if (!salt) {
-        salt = Cipher.random();
-        config.set("salt", salt);
-      }
 
       let choices = [
         { value: "create", name: "Create new secret" },
@@ -79,23 +77,33 @@ program
 
         case "read":
           const readSecret = await getSecret(config);
-    
-            switch (readSecret.type) {
-              case "otp":
-                const otp = new OTP(config, readSecret, masterPasswordHash);
-                console.log(otp.generate());
-                setTimeout(() => {
-                  console.log("Expired");
-                  process.exit(0);
-                }, 30000);
-                break;
-            }
-          
+          readSecret.value = Cipher.decrypt(readSecret.value, readSecret.publicKey, masterPasswordHash)
+
+          switch (readSecret.type) {
+            case "password":
+              console.log("Username:", readSecret.typeOptions.username);
+              console.log("Password:", readSecret.value);
+              break;
+            case "note":
+              console.log("Note:", readSecret.value);
+              break;
+            case "otp":
+              const otp = new OTP(readSecret);
+              console.log("OTP code:", otp.generate());
+              setTimeout(() => {
+                console.log("Expired");
+                process.exit(0);
+              }, 30000);
+              break;
+          }
+
           break;
         case "delete":
-            const deleteSecret = getSecret(config);
-            const secrets = new Secrets(config);
-            secrets.remove(deleteSecret.id)
+          const deleteSecret = await getSecret(config);
+          const secrets = new Secrets(config);
+          await secrets.remove(deleteSecret.id)
+          console.log("Removed");
+          process.exit(0);
           break;
       }
     } catch (error) {

package/src/cli/wizards/createSecret.js

@@ -12,9 +12,9 @@ const wizard = async (config, masterPasswordHash) => {
     {
       name: "type",
       message: "type:",
-      type: "choice",
-      default: "otp",
-      choices: ["otp"],
+      type: "list",
+      default: "password",
+      choices: ["password", "otp", "note"],
       required: true,
     }
   ]);
@@ -22,29 +22,71 @@ const wizard = async (config, masterPasswordHash) => {
   let newSecret = {};
 
   switch (info.type) {
+    case "password":
+      const password = await prompt([
+        {
+          name: "username",
+          message: "username:",
+          type: "input",
+          required: true,
+        },
+        {
+          name: "value",
+          message: "password:",
+          type: "password",
+          required: true,
+        },
+      ]);
+      newSecret = {
+        name: info.name,
+        type: info.type,
+        value: password.value,
+        typeOptions: {
+          username: password.username,
+        },
+      };
+      break;
+    case "note":
+      const note = await prompt([
+        {
+          name: "value",
+          message: "note:",
+          type: "password",
+          required: true,
+        },
+      ]);
+      newSecret = {
+        name: info.name,
+        type: info.type,
+        value: note.value,
+        typeOptions: {
+
+        },
+      };
+      break;
     case "otp":
-        const secret = await prompt([
-            {
-                name: "username",
-                message: "username:",
-                type: "input",
-                required: true,
-              },
-            {
-              name: "value",
-              message: "value:",
-              type: "password",
-              required: true,
-            },
-          ]);
-          newSecret = {
-            name: info.name,
-            type: info.type,
-            value: secret.value,
-            typeOptions: {
-              username: secret.username,
-            },
-          };
+      const otp = await prompt([
+        {
+          name: "username",
+          message: "username:",
+          type: "input",
+          required: true,
+        },
+        {
+          name: "value",
+          message: "value:",
+          type: "password",
+          required: true,
+        },
+      ]);
+      newSecret = {
+        name: info.name,
+        type: info.type,
+        value: otp.value,
+        typeOptions: {
+          username: otp.username,
+        },
+      };
       break;
   }
 

package/src/models/Secret.js

@@ -2,10 +2,10 @@ import Joi from 'joi';
 import Cipher from "../sdk/cipher.js";
 
 export const createSecretSchema = Joi.object({
-    id: Joi.string().default(Cipher.random()), 
+    id: Joi.string().default(Cipher.randomString()), 
     protected: Joi.boolean().default(false), // ask for password
     name: Joi.string().required(),
-    type: Joi.string().required().valid('otp'),
+    type: Joi.string().required().valid('otp', 'password', 'note'),
     value: Joi.string().required(),
     typeOptions: Joi.object().default({}),
     createdAt: Joi.date().default(new Date()),

package/src/sdk/cipher.js

@@ -1,10 +1,10 @@
 import crypto from "crypto";
 
+const algorithm = "aes-256-ctr";
+const IV_LENGTH = 16;
+
 export default class Cipher {
-  constructor(config) {
-    this.config = config;
-    this.salt = config.get("salt", "");
-  }
+  constructor() { }
 
   static hash(text) {
     const hash = crypto.createHash("sha256");
@@ -13,38 +13,42 @@ export default class Cipher {
     return hash.digest("hex");
   }
 
-  static random() {
-    const rnd = crypto.randomBytes(16).toString("hex");
+  static random(size = IV_LENGTH) {
+    const rnd = crypto.randomBytes(size);
 
     return rnd;
   }
 
-  static createKey(salt="") {
-    const rnd = Cipher.random(salt)
+  static randomString() {
+    const rnd = Cipher.random().toString("hex");
 
-    return Cipher.hash(salt+rnd);
+    return rnd;
   }
 
-  encrypt(text, password) {
-    const publicKey = Cipher.createKey(this.salt);
-    const cipher = crypto.createCipher(
-      "aes-256-cbc",
-       publicKey + password
+  static encrypt(text, password) {
+    const publicKey = Cipher.randomString();
+    let cipher = crypto.createCipheriv(
+      algorithm,
+      Buffer.from(password, "hex"),
+      Buffer.from(publicKey, "hex"),
     );
-    let encrypted = cipher.update(text, "utf8", "hex");
-    encrypted += cipher.final("hex");
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    encrypted = encrypted.toString("hex");
 
     return { publicKey, encrypted };
   }
 
-  decrypt(encryptedText, publicKey, password) {
-    const decipher = crypto.createDecipher(
-      "aes-256-cbc",
-      publicKey + password
+  static decrypt(encryptedText, publicKey, password) {
+    encryptedText = Buffer.from(encryptedText, "hex");
+    let decipher = crypto.createDecipheriv(
+      algorithm,
+      Buffer.from(password, "hex"),
+      Buffer.from(publicKey, "hex")
     );
-    let decrypted = decipher.update(encryptedText, "hex", "utf8");
-    decrypted += decipher.final("utf8");
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
 
-    return decrypted;
+    return decrypted.toString();
   }
 }

package/src/sdk/config.js

@@ -1,9 +1,11 @@
 import Conf from "conf";
 
+const { AUTHO_ENCRYPTION_KEY = "", AUTHO_NAME = 'default' } = process.env;
+
 export default class Config {
     constructor({
-        encryptionKey,
-        configName='default'
+        encryptionKey = AUTHO_ENCRYPTION_KEY,
+        configName = AUTHO_NAME
     }) {
         this.config = new Conf({ projectName: "autho", encryptionKey, configName });
     }

package/src/sdk/otp.js

@@ -1,16 +1,15 @@
 import * as OTPAuth from "otpauth";
-import Cipher from "./cipher.js";
 
 export default class OTP {
-  constructor(config, secret, password) {
-    const cipher = new Cipher(config);
+  constructor(secret) {
+
     const options = {
-      issuer: "ACME",
+      issuer: "Autho",
       label: secret.name,
       algorithm: "SHA1",
       digits: 6,
       period: 30,
-      secret: cipher.decrypt(secret.value, secret.publicKey, password),
+      secret: secret.value,
     };
 
     this.totp = new OTPAuth.TOTP(options);

package/src/sdk/secrets.js

@@ -4,7 +4,6 @@ import Cipher from "./cipher.js";
 export default class Secrets {
   constructor(config) {
     this.config = config;
-    this.cipher = new Cipher(config);
   }
 
   get secrets() {
@@ -25,7 +24,7 @@ export default class Secrets {
       throw new Error(error);
     }
 
-    const { publicKey, encrypted } = this.cipher.encrypt(value.value, password);
+    const { publicKey, encrypted } = Cipher.encrypt(value.value, password);
     value.value = encrypted;
     value.publicKey = publicKey;
 
@@ -35,4 +34,8 @@ export default class Secrets {
   async remove(id) {
     this.secrets = this.secrets.filter((secret) => secret.id != id);
   }
+
+  async clear() {
+    this.secrets = [];
+  }
 }