@mherod/get-cookie 2.0.0-beta.1 → 2.0.0-beta.10

package/src/browsers/ChromeCookieQueryStrategy.js

@@ -1,263 +0,0 @@
-import AbstractCookieQueryStrategy from "./AbstractCookieQueryStrategy";
-import {
-  doSqliteQuery1,
-  execSimple,
-  invalidString,
-  toStringOrNull,
-  toStringValue,
-} from "../utils";
-import { env, HOME } from "../global";
-import { existsSync } from "fs";
-import { findAllFiles } from "../findAllFiles";
-import crypto from "crypto";
-import * as path from "path";
-
-export default class ChromeCookieQueryStrategy extends AbstractCookieQueryStrategy {
-  async queryCookies(name, domain) {
-    if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
-    }
-    if (env.FIREFOX_ONLY) {
-      return [];
-    }
-    const cookies = await getChromeCookies({ name, domain });
-    return cookies.map(toStringValue);
-  }
-}
-
-async function getPromise1(name, domain, file) {
-  try {
-    return await getEncryptedChromeCookie({
-      name: name,
-      domain: domain,
-      file: file,
-    });
-  } catch (e) {
-    if (env.VERBOSE) {
-      console.log("Error getting encrypted cookie", e);
-    }
-    return [];
-  }
-}
-
-async function getPromise(name, domain) {
-  try {
-    const files = await findAllFiles({
-      path: chromeLocal,
-      name: "Cookies",
-    });
-    const promises = files.map((file) => getPromise1(name, domain, file));
-    const results1 = await Promise.all(promises);
-    const results2 = results1.flat();
-    if (env.VERBOSE) {
-      console.log("getEncryptedChromeCookie results", results2);
-    }
-    return results2.filter((result) => result);
-  } catch (error) {
-    if (env.VERBOSE) {
-      console.log("error", error);
-    }
-    return [];
-  }
-}
-
-/**
- *
- * @param {string|undefined} name
- * @param {string} domain
- * @param {boolean} requireJwt
- * @returns {Promise<[string]>}
- */
-async function getChromeCookies({ name, domain = "%", requireJwt = false }) {
-  if (invalidString(name)) {
-    throw new Error("name must be a string");
-  }
-  if (invalidString(domain)) {
-    throw new Error("domain must be a string");
-  }
-  const encryptedDataItems = await getPromise(name, domain);
-  const password = await getChromePassword();
-  const decrypted = encryptedDataItems
-    .filter((encryptedData) => {
-      return encryptedData != null && encryptedData.length > 0;
-    })
-    .map(async (encryptedData) => {
-      if (env.VERBOSE) {
-        console.log("Received encrypted", encryptedData);
-      }
-      let d;
-      try {
-        d = await decrypt(password, encryptedData);
-      } catch (e) {
-        if (env.VERBOSE) {
-          console.log("Error decrypting cookie", e);
-        }
-        return null;
-      }
-      if (d) {
-        if (env.VERBOSE) {
-          console.log("Decrypted", d);
-        }
-        return d;
-      }
-      return null;
-    });
-  const results = await Promise.all(decrypted);
-  if (env.VERBOSE) {
-    console.log("results", results);
-  }
-  return results.map(toStringOrNull);
-}
-
-const chromeLocal = path.join(
-  HOME,
-  "Library",
-  "Application Support",
-  "Google",
-  "Chrome"
-);
-
-async function getEncryptedChromeCookie({
-  name,
-  domain,
-  file = path.join(chromeLocal, "Default", "Cookies"),
-}) {
-  if (name && typeof name !== "string") {
-    throw new Error("name must be a string");
-  }
-  if (domain && typeof domain !== "string") {
-    throw new Error("domain must be a string");
-  }
-  if (file && typeof file !== "string") {
-    throw new Error("file must be a string");
-  }
-  if (!existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
-  }
-  if (env.VERBOSE) {
-    const s = file.split("/").slice(-3).join("/");
-    console.log(`Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`);
-  }
-  let sql;
-  sql = `SELECT encrypted_value FROM cookies`;
-  if (typeof name === "string" || typeof domain === "string") {
-    sql += ` WHERE `;
-    if (typeof name === "string") {
-      sql += `name = '${name}'`;
-      if (typeof domain === "string") {
-        sql += ` AND `;
-      }
-    }
-    if (typeof domain === "string") {
-      sql += `host_key LIKE '${domain}';`;
-    }
-  }
-  return doSqliteQuery1(file, sql);
-}
-
-/**
- *
- * @returns {Promise<string>}
- */
-async function getChromePassword() {
-  return execSimple(
-    'security find-generic-password -w -s "Chrome Safe Storage"'
-  );
-}
-
-/**
- *
- * @param {string} password
- * @param {Buffer} encryptedData
- * @returns {Promise<string>}
- */
-async function decrypt(password, encryptedData) {
-  if (typeof password !== "string") {
-    throw new Error("password must be a string: " + password);
-  }
-  let encryptedData1;
-  encryptedData1 = encryptedData;
-  if (encryptedData1 == null || typeof encryptedData1 !== "object") {
-    throw new Error("encryptedData must be a object: " + encryptedData1);
-  }
-  if (!(encryptedData1 instanceof Buffer)) {
-    if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
-      [encryptedData1] = encryptedData1;
-      if (env.VERBOSE) {
-        console.log(
-          `encryptedData is an array of buffers, selected first: ${encryptedData1}`
-        );
-      }
-    } else {
-      throw new Error("encryptedData must be a Buffer: " + encryptedData1);
-    }
-    encryptedData1 = Buffer.from(encryptedData1);
-  }
-  if (env.VERBOSE) {
-    console.log(`Trying to decrypt with password ${password}`);
-  }
-  return new Promise((resolve, reject) => {
-    crypto.pbkdf2(password, "saltysalt", 1003, 16, "sha1", (error, buffer) => {
-      try {
-        if (error) {
-          if (env.VERBOSE) {
-            console.log("Error doing pbkdf2", error);
-          }
-          reject(error);
-          return;
-        }
-
-        if (buffer.length !== 16) {
-          if (env.VERBOSE) {
-            console.log(
-              "Error doing pbkdf2, buffer length is not 16",
-              buffer.length
-            );
-          }
-          reject(new Error("Buffer length is not 16"));
-          return;
-        }
-
-        const iv = new Buffer.from(new Array(17).join(" "), "binary");
-        const decipher = crypto.createDecipheriv("aes-128-cbc", buffer, iv);
-        decipher.setAutoPadding(false);
-
-        if (encryptedData1 && encryptedData1.slice) {
-          encryptedData1 = encryptedData1.slice(3);
-        }
-
-        if (encryptedData1.length % 16 !== 0) {
-          if (env.VERBOSE) {
-            console.log(
-              "Error doing pbkdf2, encryptedData length is not a multiple of 16",
-              encryptedData1.length
-            );
-          }
-          reject(new Error("encryptedData length is not a multiple of 16"));
-          return;
-        }
-
-        let decoded = decipher.update(encryptedData1);
-        try {
-          decipher.final("utf-8");
-        } catch (e) {
-          if (env.VERBOSE) {
-            console.log("Error doing decipher.final()", e);
-          }
-          reject(e);
-          return;
-        }
-
-        const padding = decoded[decoded.length - 1];
-        if (padding) {
-          decoded = decoded.slice(0, 0 - padding);
-        }
-        // noinspection JSCheckFunctionSignatures
-        decoded = decoded.toString("utf8");
-        resolve(decoded);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}

package/src/browsers/SafariCookieQueryStrategy.js

@@ -1,3 +0,0 @@
-import AbstractCookieQueryStrategy from "./AbstractCookieQueryStrategy";
-
-export default class SafariCookieQueryStrategy extends AbstractCookieQueryStrategy {}

package/src/cli.js

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-
-import { version } from "../package.json";
-import { env } from "./global";
-import { queryCookies } from "./queryCookies";
-
-const argv = process.argv;
-
-async function cliQueryCookies(name, domain) {
-  try {
-    const results = await queryCookies({ name, domain });
-    if (results.length > 0) {
-      for (const result of results) {
-        console.log(result);
-      }
-    } else {
-      console.error("No results");
-    }
-  } catch (e) {
-    console.error(e);
-  }
-}
-
-if (argv && argv.length > 2) {
-  if (argv.includes("--version") || argv.includes("-v")) {
-    console.log(version);
-    return;
-  }
-
-  const name = argv[2];
-
-  let domain;
-  if (argv[3] != null && argv[3].indexOf(".") > -1) {
-    domain = argv[3];
-  } else {
-    domain = "%";
-  }
-
-  const tru = `${true}`;
-
-  if (argv.includes("--require-jwt")) {
-    env.REQUIRE_JWT = tru;
-  }
-  if (argv.includes("--verbose")) {
-    env.VERBOSE = tru;
-  }
-  if (argv.includes("--chrome-only")) {
-    env.CHROME_ONLY = tru;
-  }
-  if (argv.includes("--firefox-only")) {
-    env.FIREFOX_ONLY = tru;
-  }
-  if (argv.includes("--ignore-expired")) {
-    env.IGNORE_EXPIRED = tru;
-  }
-
-  if (argv.includes("--single")) {
-    env.SINGLE = tru;
-  }
-
-  if (env.VERBOSE) {
-    console.log("Verbose mode", argv);
-  }
-
-  cliQueryCookies(name, domain)
-    .then(() => {
-      //
-    })
-    .catch(console.error);
-}

package/src/queryCookies.js

@@ -1,28 +0,0 @@
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import { uniq } from "lodash";
-import { env } from "./global";
-import isValidJwt from "./isValidJwt";
-
-export async function queryCookies(
-  { name, domain },
-  strategy = new CompositeCookieQueryStrategy()
-) {
-  const results = await strategy.queryCookies(name, domain);
-  const results1 = uniq(results).map((cookie) => {
-    return {
-      name: name,
-      domain: domain,
-      value: cookie,
-    };
-  });
-  const jwtCookies = [];
-  for (const result of results1) {
-    const value = result.value;
-    if (isValidJwt(value)) {
-      jwtCookies.push(result);
-    }
-  }
-  const results2 = env.REQUIRE_JWT ? jwtCookies : results1;
-  const resultsUniq = uniq(results2).map((cookie) => cookie.value);
-  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
-}

package/src/utils.js

@@ -1,181 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-import { exec } from "child_process";
-
-import fs from "fs";
-
-export async function execSimple(command) {
-  if (typeof command !== "string") {
-    throw new TypeError("execSimple: command must be a string");
-  }
-  if (process.env.VERBOSE) {
-    console.log(command);
-  }
-  return new Promise((resolve, reject) => {
-    exec(
-      command,
-      { encoding: "binary", maxBuffer: 5 * 1024 },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          reject(error);
-          return;
-        }
-        if (stdout) {
-          resolve(stdout.toString("utf8").trim());
-        }
-      }
-    );
-  });
-}
-
-export async function execAsBuffer(command) {
-  if (typeof command !== "string") {
-    throw new TypeError("execAsBuffer: command must be a string");
-  }
-  if (process.env.VERBOSE) {
-    console.log(command);
-  }
-  return await new Promise((resolve, reject) => {
-    exec(
-      command,
-      { encoding: "binary", maxBuffer: 5 * 1024 },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          reject(error);
-          return;
-        }
-        let stdoutAsBuffer = stdout;
-        if (typeof stdoutAsBuffer === "string" && stdoutAsBuffer.length > 0) {
-          // noinspection JSCheckFunctionSignatures
-          stdoutAsBuffer = Buffer.from(stdoutAsBuffer, "binary").slice(0, -1);
-        }
-        if (stdoutAsBuffer && stdoutAsBuffer.length > 0) {
-          resolve(stdoutAsBuffer);
-        }
-      }
-    );
-  });
-}
-
-export function toStringValue(r) {
-  if (process.env.VERBOSE) {
-    console.log("Printing value", r);
-  }
-  if (r) {
-    if (typeof r === "string") {
-      return r;
-    } else if (r.toString) {
-      // noinspection JSCheckFunctionSignatures
-      return r.toString("utf8");
-    }
-  }
-}
-
-export function printStringValue(r) {
-  if (process.env.VERBOSE) {
-    console.log("Printing value", r);
-  }
-  if (r) {
-    if (typeof r === "string") {
-      console.log(r);
-    } else if (r.toString) {
-      // noinspection JSCheckFunctionSignatures
-      console.log(r.toString("utf8"));
-    }
-  }
-}
-
-/**
- *
- * @param result
- * @returns {string|null}
- */
-export function toStringOrNull(result) {
-  if (result == null) {
-    return null;
-  }
-  if (process.env.VERBOSE) {
-    console.log("result", result);
-  }
-  if (typeof result === "string" && result.length > 0) {
-    return result;
-  }
-  if (result.slice && result.toString) {
-    // noinspection JSCheckFunctionSignatures
-    return result.toString("utf8");
-  }
-  return null;
-}
-
-/**
- *
- * @param {string} file
- * @param {string} sql
- * @returns {Promise<Buffer[]>}
- */
-export async function doSqliteQuery1(file, sql) {
-  if (typeof sql !== "string") {
-    throw new TypeError("doSqliteQuery1: sql must be a string");
-  }
-  if (typeof file !== "string") {
-    throw new TypeError("doSqliteQuery1: file must be a string");
-  }
-  if (!fs.existsSync(file)) {
-    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
-  }
-  if (process.env.VERBOSE) {
-    console.log(`doSqliteQuery1: file ${file}`);
-    console.log(`doSqliteQuery1: sql ${sql}`);
-  }
-  const sqlite3 = require("sqlite3");
-  const db = new sqlite3.Database(file);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err, rows) => {
-      if (err) {
-        if (process.env.VERBOSE) {
-          console.log(`doSqliteQuery1: error ${err}`);
-        }
-        reject(err);
-        return;
-      }
-      const rows1 = rows;
-      if (rows1 == null || rows1.length === 0) {
-        if (process.env.VERBOSE) {
-          console.log(`doSqliteQuery1: no rows`);
-        }
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        if (process.env.VERBOSE) {
-          console.log(`doSqliteQuery1: ${rows1.length} rows`);
-        }
-        // noinspection JSCheckFunctionSignatures
-        const buffers = rows1
-          .flatMap((row) => Object.values(row))
-          .map((v) => Buffer.from(v, "binary"));
-        if (process.env.VERBOSE) {
-          console.log(`doSqliteQuery1: ${buffers.length} buffers`);
-        }
-        resolve(buffers);
-        return;
-      }
-      if (process.env.VERBOSE) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}
-
-export function invalidString(input) {
-  return typeof input !== "string" || input.length === 0;
-}