@mherod/get-cookie 1.3.0 → 2.0.0-beta.3

package/src/index.js

@@ -1,462 +1,61 @@
 #!/usr/bin/env node
+// noinspection JSUnusedGlobalSymbols
 
-import fs from "fs";
-import crypto from "crypto";
-import { env } from "./global";
-
-if (process.platform !== "darwin") {
-  throw new Error("This script only works on macOS");
-}
-
-const {
-  execSimple,
-  toStringOrNull,
-  doSqliteQuery1,
-  toStringValue,
-} = require("./utils");
-const jsonwebtoken = require("jsonwebtoken");
-
-function isValidJwt(token) {
-  if (typeof token !== "string") {
-    return false;
-  }
-  try {
-    const result = jsonwebtoken.decode(token, { complete: true });
-    if (env.VERBOSE) {
-      console.log(result);
-    }
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-
-/**
- *
- * @returns {Promise<string>}
- */
-async function getChromePassword() {
-  return execSimple(
-    'security find-generic-password -w -s "Chrome Safe Storage"'
-  );
-}
+import { queryCookies } from "./queryCookies";
+import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
+import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 
 /**
  *
  * @param params
  * @returns {Promise<string>}
  */
-async function getCookie(params) {
-  if (env.CHROME_ONLY) {
-    if (env.VERBOSE) {
-      console.log("chrome only");
-    }
-    return getChromeCookie(params)
-      .then((cookie) => {
-        if (cookie && cookie.length > 0) {
-          return toStringValue(cookie);
-        }
-      })
-      .catch((err) => {
-        if (env.VERBOSE) {
-          console.error(err);
-        }
-      });
-  } else if (env.FIREFOX_ONLY) {
-    if (env.VERBOSE) {
-      console.log("firefox only");
-    }
-    return getFirefoxCookie(params)
-      .then((b) => b.toString("utf8"))
-      .then((cookie) => {
-        if (cookie && cookie.length > 0) {
-          return toStringValue(cookie);
-        } else {
-          console.log("No cookie found");
-        }
-      })
-      .catch((err) => {
-        if (env.VERBOSE) {
-          console.error("Error getting Firefox cookie", err);
-        }
-      });
+export async function getCookie(params) {
+  const cookies = await queryCookies(
+    params,
+    new CompositeCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
   } else {
-    return await getChromeCookie(params)
-      .catch((err) => {
-        if (env.VERBOSE) {
-          console.error("Error getting Chrome cookie", err);
-        }
-      })
-      .then((r) => {
-        if (typeof r === "string" && r.trim().length > 0) {
-          return r;
-        } else {
-          return getFirefoxCookie(params).catch((err) => {
-            if (env.VERBOSE) {
-              console.error("Error getting Firefox cookie", err);
-            }
-          });
-        }
-      })
-      .catch((e) => {
-        if (env.VERBOSE) {
-          console.error("Error getting Chrome or Firefox cookie", e);
-        }
-      })
-      .then(toStringValue);
-  }
-}
-
-/**
- *
- * @param name
- * @param domain
- * @returns {Promise<Buffer>}
- */
-async function getFirefoxCookie({ name, domain }) {
-  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");
-  }
-  const [file] = await findAllFiles({
-    path: `${env.HOME}/Library/Application Support/Firefox/Profiles`,
-    name: "cookies.sqlite",
-  });
-  if (file && !fs.existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
-  }
-  if (env.VERBOSE) {
-    console.log(`Trying Firefox cookie ${name} for domain ${domain}`);
-  }
-  let sql;
-  sql = "SELECT value FROM moz_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 LIKE '${domain}';`;
-    }
-  }
-  return await doSqliteQuery1(file, sql).then((rows) => {
-    return rows.map(toStringOrNull).find((v) => v !== null);
-  });
-}
-
-const defaultChromeRoot = `${env.HOME}/Library/Application Support/Google/Chrome`;
-const defaultChromeCookies = `${defaultChromeRoot}/Default/Cookies`;
-
-async function getEncryptedChromeCookie({
-  name,
-  domain,
-  file = defaultChromeCookies,
-}) {
-  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 (!fs.existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
-  }
-  if (env.VERBOSE) {
-    console.log(
-      `Trying Chrome (at ${file
-        .split("/")
-        .slice(-3)
-        .join("/")}) 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}';`;
-    }
+    throw new Error("Cookie not found");
   }
-  return await doSqliteQuery1(file, sql);
 }
 
 /**
  *
- * @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;
-        }
-
-        let 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);
-      }
-    });
-  });
-}
-
-/**
- *
- * @param {string|undefined} name
- * @param {string} domain
- * @param {boolean} requireJwt
- * @returns {Promise<string>}
+ * @param params
+ * @returns {Promise<*>}
  */
-async function getChromeCookie({ name, domain = "%", requireJwt = false }) {
-  if (name && typeof name !== "string") {
-    throw new Error("name must be a string");
-  }
-  if (typeof domain !== "string") {
-    throw new Error("domain must be a string");
-  }
-  const encryptedDataItems = await findAllFiles({
-    path: defaultChromeRoot,
-    name: "Cookies",
-  })
-    .then((files) => {
-      const promises = files.map((file) => {
-        return getEncryptedChromeCookie({
-          name: name,
-          domain: domain,
-          file: file,
-        }).catch((e) => {
-          if (env.VERBOSE) {
-            console.log("Error getting encrypted cookie", e);
-          }
-          return [];
-        });
-      });
-      return Promise.all(promises)
-        .then((results) => results.flat())
-        .then((results) => {
-          if (env.VERBOSE) {
-            console.log("getEncryptedChromeCookie results", results);
-          }
-          return results.filter((result) => {
-            return result;
-          });
-        });
-    })
-    .catch((error) => {
-      if (env.VERBOSE) {
-        console.log("error", error);
-      }
-      return [];
-    });
-  const password = await getChromePassword();
-  if (env.VERBOSE) {
-    console.log("encryptedDataItems", encryptedDataItems);
-  }
-  const decrypted = encryptedDataItems
-    .filter((encryptedData) => {
-      return encryptedData != null && encryptedData.length > 0;
-    })
-    .map(async (encryptedData) => {
-      if (env.VERBOSE) {
-        console.log("Received encrypted", encryptedData);
-      }
-      let decrypted;
-      try {
-        decrypted = await decrypt(password, encryptedData);
-      } catch (e) {
-        if (env.VERBOSE) {
-          console.log("Error decrypting cookie", e);
-        }
-        return null;
-      }
-      if (decrypted) {
-        if (env.VERBOSE) {
-          console.log("Decrypted", decrypted);
-        }
-        return decrypted;
-      }
-      return null;
-    });
-  const results = await Promise.all(decrypted);
-  if (env.VERBOSE) {
-    console.log("results", results);
+export async function getFirefoxCookie(params) {
+  const cookies = await queryCookies(
+    params,
+    new FirefoxCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
+  } else {
+    throw new Error("Cookie not found");
   }
-  return results.map(toStringOrNull).find((result) => {
-    return (
-      typeof result === "string" &&
-      result.length > 0 &&
-      (requireJwt === false || isValidJwt(result))
-    );
-  });
 }
 
 /**
  *
- * @param path
- * @param name
- * @param rootSegments
- * @param maxDepth
- * @returns {Promise<[string]>}
+ * @param params
+ * @returns {Promise<*>}
  */
-async function findAllFiles({ path, name, maxDepth = 2 }) {
-  if (typeof path !== "string") {
-    throw new Error("path must be a string");
-  }
-  if (typeof name !== "string") {
-    throw new Error("name must be a string");
-  }
-
-  const rootSegments = path.split("/").length;
-
-  if (env.VERBOSE) {
-    console.log(`Searching for ${name} in ${path}`);
-  }
-  const files = [];
-  let readdirSync;
-  try {
-    readdirSync = fs.readdirSync(path);
-  } catch (e) {
-    if (env.VERBOSE) {
-      console.log(`Error reading ${path}`, e);
-    }
-    return files;
-  }
-  for (const file of readdirSync) {
-    const filePath = path + "/" + file;
-    let stat;
-    try {
-      stat = fs.statSync(filePath);
-    } catch (e) {
-      if (env.VERBOSE) {
-        console.error(`Error getting stat for ${filePath}`, e);
-      }
-      continue;
-    }
-    if (stat.isDirectory()) {
-      if (filePath.split("/").length < rootSegments + maxDepth) {
-        try {
-          const subFiles = await findAllFiles({
-            path: filePath,
-            name: name,
-            rootSegments: rootSegments,
-            maxDepth: 2,
-          });
-          files.push(...subFiles);
-        } catch (e) {
-          if (env.VERBOSE) {
-            console.error(e);
-          }
-        }
-      }
-    } else if (file === name) {
-      files.push(filePath);
-    }
-  }
-  if (env.VERBOSE) {
-    if (files.length > 0) {
-      console.log(`Found ${files.length} ${name} files`);
-      console.log(files);
-    }
+export async function getChromeCookie(params) {
+  const cookies = await queryCookies(
+    params,
+    new ChromeCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
+  } else {
+    throw new Error("Cookie not found");
   }
-  return files;
 }
-
-// noinspection JSUnusedGlobalSymbols
-module.exports = {
-  getDecryptedCookie: getChromeCookie,
-  getChromeCookie,
-  getFirefoxCookie,
-  getCookie,
-  decrypt,
-};

package/src/isValidJwt.ts

@@ -0,0 +1,14 @@
+import jsonwebtoken from "jsonwebtoken";
+import { env } from "./global";
+
+export default function isValidJwt(token: any) {
+  try {
+    const result = jsonwebtoken.decode(token, { complete: true });
+    if (env.VERBOSE) {
+      console.log(result);
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}

package/src/queryCookies.ts

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

package/src/utils.ts

@@ -0,0 +1,118 @@
+// noinspection JSUnusedGlobalSymbols
+
+import {exec, ExecException} from "child_process";
+
+export async function execSimple(command: string): Promise<string> {
+  if (process.env.VERBOSE) {
+    console.log(command);
+  }
+  return new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error: ExecException | null, stdout: string, stderr: string) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        if (stdout) {
+          resolve(stdout.trim());
+        }
+      }
+    );
+  });
+}
+
+// export async function execAsBuffer(command: string) {
+//   if (process.env.VERBOSE) {
+//     console.log(command);
+//   }
+//   return await new Promise((resolve, reject) => {
+//     exec(
+//       command,
+//       { encoding: "binary", maxBuffer: 5 * 1024 },
+//       (error: ExecException | null, stdout: string, stderr: string) => {
+//         if (error) {
+//           reject(error);
+//           return;
+//         }
+//         if (stderr) {
+//           reject(error);
+//           return;
+//         }
+//         let stdoutAsBuffer: string = 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);
+//         }
+//       }
+//     );
+//   });
+// }
+
+// @ts-ignore
+export function toStringValue(r: any): string {
+  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: any) {
+  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: any) {
+  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;
+}
+
+export function invalidString(input: any): boolean {
+  return typeof input !== "string" || input.length === 0;
+}
+
+
+export function validString(input: any): input is string {
+  return typeof input == "string" && input.length > 0;
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "include": [
+    "src/**.ts",
+    "src/**.tsx",
+    "src/**.js",
+    "src/**.jsx"
+  ],
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "target": "es2021",
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "es2015",
+      "es2017",
+      "es2021",
+      "dom"
+    ],
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+  }
+}

package/src/global.js

@@ -1,3 +0,0 @@
-const { merge } = require("lodash");
-export const env = {};
-merge(env, process.env);