autho 0.0.4 → 0.0.7

package/package.json

@@ -1,25 +1,53 @@
 {
   "name": "autho",
-  "version": "0.0.4",
-  "main": "index.js",
-  "type": "module",
+  "version": "0.0.7",
+  "main": "build/bin.js",
+  "type": "commonjs",
   "bin": {
-    "autho": "src/cli/bin.js"
+    "autho": "build/bin.js"
   },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "keywords": [
+    "secrets",
+    "otp"
+  ],
+  "author": "Nir Adler",
+  "license": "MIT",
+  "description": "Open Source Authentication and Password Management Tool",
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "esbuild": "0.20.2",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "globals": "^15.0.0",
+    "jest": "^29.7.0",
+    "pkg": "^5.8.1",
+    "prettier": "^3.2.5"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "commander": "^12.0.0",
-    "conf": "^12.0.0",
-    "inquirer": "^9.2.17",
-    "inquirer-autocomplete-standalone": "^0.8.1",
-    "joi": "^17.12.2",
-    "otpauth": "^9.2.2"
+  "files": [
+    "build/bin.js"
+  ],
+  "pkg": {
+    "scripts": "build/**/*.js",
+    "assets": [],
+    "targets": [
+      "node18-win-x64",
+      "node18-linux-arm64",
+      "node18-linux-x64",
+      "node18-macos-x64"
+    ],
+    "outputPath": "dist"
   },
-  "devDependencies": {},
-  "description": "Open Source Authentication and Password Management Tool"
-}
+  "scripts": {
+    "format": "prettier --check .",
+    "format:write": "prettier --write .",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "build": "esbuild packages/cli/bin.js --bundle --platform=node --target=node18 --outdir=build",
+    "pkg": "npm run pkg:linux && npm run pkg:macos && npm run pkg:win",
+    "pkg:macos-arm64": "pkg build/bin.js --output dist/autho --target node18-macos-arm64",
+    "pkg:macos": "pkg build/bin.js --output dist/autho-macos --target node18-macos-x64",
+    "pkg:linux": "pkg build/bin.js --output dist/autho-linux --target node18-linux-x64",
+    "pkg:win": "pkg build/bin.js --output dist/autho-win --target node18-win-x64",
+    "release": "gh release create v0.0.6 ./dist"
+  }
+}

package/src/cli/bin.js

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from "commander";
-import chalk from "chalk";
-import { prompt, ask } from "./utils.js";
-import DB from "../sdk/db.js";
-import Cipher from "../sdk/cipher.js";
-import createSecret from "./wizards/createSecret.js";
-import getEncryptionKey from "./wizards/getEncryptionKey.js";
-import getSecret from "./wizards/getSecret.js";
-import Secrets from "../sdk/secrets.js";
-import OTP from "../sdk/otp.js";
-
-const program = new Command();
-
-//type AppOptions = {
-//   masterPasswordHash?: string;
-//   masterPassword?: string;
-//   appFolder?: string;
-// };
-
-class App {
-  constructor(options = {}) {
-    let masterPasswordHash =
-      options.masterPasswordHash || process.env.AUTHO_MASTER_PASSWORD_HASH;
-    const masterPassword = options.masterPassword || process.env.AUTHO_MASTER_PASSWORD;
-    if (!masterPasswordHash && !masterPassword) {
-      throw new Error("Master password or master password hash is required")
-    }
-    masterPasswordHash =
-      masterPasswordHash ||
-      Cipher.hash(masterPassword);
-    this.db = new DB({ encryptionKey: masterPasswordHash });
-    this.secrets = new Secrets(this);
-  }
-
-}
-
-program
-  .name("autho")
-  .description("Secrets manager")
-  .version("0.0.1")
-  .option("-p, --password <password>", "Master password")
-  .action(async (args) => {
-    try {
-      const masterPassword = args.password
-        ? args.password
-        : await ask({
-          name: "masterPassword",
-          message: "Password:",
-          type: "password",
-          required: true,
-        });
-
-      const app = new App({ masterPassword });
-
-      let choices = [
-        { value: "create", name: "Create new secret" },
-        { value: "read", name: "Read secret" },
-        { value: "delete", name: "Delete secret" },
-      ];
-
-      const { action } = await prompt({
-        name: "action",
-        type: "list",
-        choices,
-        required: true,
-      });
-
-      switch (action) {
-        case "create":
-          await createSecret(app);
-          break;
-
-        case "read":
-          const readSecret = await getSecret(app);
-          let encryptionKey = app.db.encryptionKey
-          if (readSecret.protected) {
-            encryptionKey = await getEncryptionKey()
-          }
-
-          readSecret.value = Cipher.decrypt(
-            readSecret.value,
-            readSecret.publicKey,
-            encryptionKey,
-            readSecret.signature
-          );
-          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 = await getSecret(app);
-          await app.secrets.remove(deleteSecret.id);
-          console.log("Removed");
-          process.exit(0);
-         default:
-          console.log("Unknown action:", action);
-          process.exit(1);
-      }
-    } catch (error) {
-      console.log(
-        chalk.redBright("Something went wrong, Error: "),
-        error.message
-      );
-      console.log(error.stack);
-      process.exit(1);
-    }
-  });
-
-program.parse();

package/src/cli/utils.js

@@ -1,15 +0,0 @@
-import inquirer from "inquirer";
-
-export const prompt = inquirer.prompt;
-
-export const ask = async ({ name = "", message = "", type = "input" }) => {
-  const answers = await inquirer.prompt([
-    {
-      name,
-      message,
-      type,
-    },
-  ]);
-
-  return answers[name];
-};

package/src/cli/wizards/createSecret.js

@@ -1,106 +0,0 @@
-import { prompt } from "../utils.js";
-import getEncryptionKey from "./getEncryptionKey.js";
-
-const wizard = async (app) => {
-  const secrets = app.secrets;
-  const info = await prompt([
-    {
-      name: "name",
-      message: "name:",
-      type: "input",
-      required: true,
-    },
-    {
-      name: "type",
-      message: "type:",
-      type: "list",
-      default: "password",
-      choices: ["password", "otp", "note"],
-      required: true,
-    },
-    {
-      name: "protected",
-      message: "protected:",
-      type: "confirm",
-      default: false,
-      required: true,
-    }
-  ]);
-
-  let newSecret = {};
-  let encryptionKey = app.db.encryptionKey
-
-  if (info.protected) {
-    encryptionKey = await getEncryptionKey(true)
-  }
-
-  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 = {
-        ...info,
-        value: password.value,
-        typeOptions: {
-          username: password.username,
-        },
-      };
-      break;
-    case "note":
-      const note = await prompt([
-        {
-          name: "value",
-          message: "note:",
-          type: "password",
-          required: true,
-        },
-      ]);
-      newSecret = {
-        ...info,
-        value: note.value,
-        typeOptions: {
-
-        },
-      };
-      break;
-    case "otp":
-      const otp = await prompt([
-        {
-          name: "username",
-          message: "username:",
-          type: "input",
-          required: true,
-        },
-        {
-          name: "value",
-          message: "value:",
-          type: "password",
-          required: true,
-        },
-      ]);
-      newSecret = {
-        ...info,
-        value: otp.value,
-        typeOptions: {
-          username: otp.username,
-        },
-      };
-      break;
-  }
-
-  await secrets.add(newSecret, encryptionKey);
-};
-
-export default wizard;

package/src/cli/wizards/getEncryptionKey.js

@@ -1,30 +0,0 @@
-import Cipher from "../../sdk/cipher.js";
-import { prompt } from "../utils.js";
-
-const wizard = async (confirm = false) => {
-  const questions = [{
-    name: "password",
-    message: "password:",
-    type: "password",
-    required: true,
-  }
-  ]
-  if (confirm) {
-    questions.push({
-      name: "confirmPassword",
-      message: "confirm password:",
-      type: "password",
-      required: true,
-    });
-  }
-  const input = await prompt(questions);
-
-  if (input.confirmPassword && input.password !== input.confirmPassword) {
-    throw new Error("Passwords do not match");
-  }
-
-  return Cipher.hash(input.password);
-}
-
-
-export default wizard;

package/src/cli/wizards/getSecret.js

@@ -1,31 +0,0 @@
-import { prompt } from "../utils.js";
-
-const wizard = async (app) => {
-  const existingSecrets = app.db.get("secrets", []);
-
-  if (existingSecrets.length === 0) {
-    throw new Error("No secrets found");
-  }
-
-  const choices = existingSecrets.map((secret) => ({
-    value: secret.id,
-    name: `${secret.name} (${secret.typeOptions.username || secret.id})`,
-  }));
-
-  const { id: secretId } = await prompt({
-    name: "id",
-    message: "Secrets:",
-    type: "list",
-    choices,
-    required: true,
-  });
-  const secret = await app.secrets.get(secretId);
-
-  if (!secret) {
-    throw new Error("Secret not found");
-  }
-
-  return secret;
-};
-
-export default wizard;

package/src/models/Secret.js

@@ -1,12 +0,0 @@
-import Joi from 'joi';
-import Cipher from "../sdk/cipher.js";
-
-export const createSecretSchema = Joi.object({
-    id: Joi.string().default(Cipher.randomString()), 
-    protected: Joi.boolean().default(false), // ask for password
-    name: Joi.string().required(),
-    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,70 +0,0 @@
-import crypto from "crypto";
-
-export default class Cipher {
-
-  static hash(text, algorithm = "sha256") {
-    const hash = crypto.createHash(algorithm);
-    hash.update(text);
-
-    return hash.digest("hex");
-  }
-
-  static random(size = 16) {
-    const rnd = crypto.randomBytes(size);
-
-    return rnd;
-  }
-
-  static randomString() {
-    const rnd = Cipher.random().toString("hex");
-
-    return rnd;
-  }
-
-  static sign(text) {
-    const hash = Cipher.hash(text)
-    const signature = `${hash.substring(0, 10)}:${hash.substring(hash.length - 10)}`;
-
-    return signature;
-  }
-
-  static verify(text, signature) {
-    const expectedSignature = Cipher.sign(text)
-
-    return expectedSignature === signature;
-  }
-
-  static encrypt(text, encryptionKey, algorithm = "aes-256-ctr") {
-    const publicKey = Cipher.randomString();
-    let cipher = crypto.createCipheriv(
-      algorithm,
-      Buffer.from(encryptionKey, "hex"),
-      Buffer.from(publicKey, "hex"),
-    );
-    let encrypted = cipher.update(text);
-    encrypted = Buffer.concat([encrypted, cipher.final()]);
-    encrypted = encrypted.toString("hex");
-
-    return { publicKey, encrypted, algorithm, signature: Cipher.sign(text) };
-  }
-
-  static decrypt(encryptedText, publicKey, encryptionKey, signature, algorithm = "aes-256-ctr") {
-    encryptedText = Buffer.from(encryptedText, "hex");
-
-    let decipher = crypto.createDecipheriv(
-      algorithm,
-      Buffer.from(encryptionKey, "hex"),
-      Buffer.from(publicKey, "hex")
-    );
-
-    let decrypted = decipher.update(encryptedText);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    decrypted = decrypted.toString();
-
-    if (!Cipher.verify(decrypted, signature)) {
-      throw new Error("Invalid signature")
-    }
-
-    return decrypted;
-  }
-}

package/src/sdk/db.js

@@ -1,23 +0,0 @@
-import Conf from "conf";
-
-const { AUTHO_ENCRYPTION_KEY = "", AUTHO_NAME = 'default' } = process.env;
-
-export default class DB {
-    constructor({
-        encryptionKey = AUTHO_ENCRYPTION_KEY,
-        configName = AUTHO_NAME
-    }) {
-        this.encryptionKey = encryptionKey;
-        this.client = new Conf({ projectName: "autho", encryptionKey, configName });
-    }
-
-    get(key, defaultValue) {
-        return this.client.get(key, defaultValue);
-    }
-
-    set(key, value) {
-        this.client.set(key, value);
-    }
-
-}
-

package/src/sdk/otp.js

@@ -1,25 +0,0 @@
-import * as OTPAuth from "otpauth";
-
-export default class OTP {
-  constructor(secret) {
-
-    const options = {
-      issuer: "Autho",
-      label: secret.name,
-      algorithm: "SHA1",
-      digits: 6,
-      period: 30,
-      secret: secret.value,
-    };
-
-    this.totp = new OTPAuth.TOTP(options);
-  }
-
-  generate() {
-    return this.totp.generate();
-  }
-
-  validate(token, window = 1) {
-    return this.totp.validate({ token, window });
-  }
-}

package/src/sdk/secrets.js

@@ -1,39 +0,0 @@
-import { createSecretSchema } from "../models/Secret.js";
-import Cipher from "../sdk/cipher.js";
-
-export default class Secrets {
-  constructor(app) {
-    this.db = app.db;
-  }
-
-  get secrets() {
-    return this.db.get("secrets", []);
-  }
-
-  set secrets(value) {
-    this.db.set("secrets", value);
-  }
-
-  async get(id) {
-    return this.secrets.find((secret) => secret.id == id);
-  }
-
-  async add(secret, encryptionKey) {
-    const { value, error } = createSecretSchema.validate(secret);
-    if (error) {
-      throw new Error(error);
-    }
-
-    const { encrypted, ...encryption } = Cipher.encrypt(value.value, encryptionKey);
-
-    this.secrets = [...this.secrets, { ...value, ...encryption, value: encrypted }];
-  }
-
-  async remove(id) {
-    this.secrets = this.secrets.filter((secret) => secret.id != id);
-  }
-
-  async clear() {
-    this.secrets = [];
-  }
-}