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

package/src/cli.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import { env } from "./global";
+import { queryCookies } from "./queryCookies";
+import { argv } from "./argv";
+import { groupBy, uniqBy } from "lodash";
+import { blue, green } from "colorette";
+import { ExportedCookie } from "./CookieRow";
+
+function combinedString(results: ExportedCookie[]) {
+  return blue(
+    uniqBy(results, (r) => r.name)
+      .map((r) => r.name + "=" + r.value)
+      .join("; ")
+  );
+}
+
+async function cliQueryCookies(name: string, domain: string) {
+  try {
+    const results = await queryCookies({ name, domain });
+    if (results.length > 0) {
+      if (argv.includes("--combined-string")) {
+        console.log(combinedString(results));
+      } else if (argv.includes("--dump")) {
+        console.log(results);
+      } else if (argv.includes("--dump-grouped")) {
+        const groupedByFile = groupBy(results, (r) => r.meta?.file);
+        console.log(green(JSON.stringify(groupedByFile, null, 2)));
+      } else if (argv.includes("--combined-string-grouped")) {
+        const groupedByFile = groupBy(results, (r) => r.meta?.file);
+        for (const file of Object.keys(groupedByFile)) {
+          let results = groupedByFile[file];
+          console.log(green(file) + ": ", combinedString(results));
+        }
+      } else {
+        for (const result of results) {
+          console.log(result.value);
+        }
+      }
+    } else {
+      console.error("No results");
+    }
+  } catch (e) {
+    console.error(e);
+  }
+}
+
+if (argv && argv.length > 2) {
+  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).catch(console.error);
+}

package/src/doSqliteQuery1.ts

@@ -0,0 +1,47 @@
+import * as fs from "fs";
+import * as sqlite3 from "sqlite3";
+import {CookieRow} from "./CookieRow";
+
+export async function doSqliteQuery1(file: string, sql: string): Promise<CookieRow[]> {
+    if (!fs.existsSync(file)) {
+        throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+    }
+    const db = new sqlite3.Database(file);
+    return new Promise((resolve, reject) => {
+        db.all(sql, (err: Error, rows: any[]) => {
+            if (err) {
+                if (process.env.VERBOSE) {
+                    console.log(`doSqliteQuery1: error ${err}`);
+                }
+                reject(err);
+                return;
+            }
+            const rows1: any[] = rows;
+            if (rows1 == null || rows1.length === 0) {
+                if (process.env.VERBOSE) {
+                    console.log(`doSqliteQuery1: no rows`);
+                }
+                resolve([]);
+                return;
+            }
+            if (Array.isArray(rows1)) {
+                const cookieRows: CookieRow[] = rows1.map((row) => {
+                    return {
+                        domain: row["host_key"],
+                        name: row["name"],
+                        value: row["encrypted_value"],
+                        meta: {
+                            file: file
+                        }
+                    }
+                })
+                resolve(cookieRows);
+                return;
+            }
+            if (process.env.VERBOSE) {
+                console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+            }
+            resolve([rows1]);
+        });
+    });
+}

package/src/{findAllFiles.js → findAllFiles.ts}

@@ -1,28 +1,24 @@
 import { env } from "./global";
-import fs from "fs";
+import * as fs from "fs";
 
-/**
- *
- * @param path
- * @param name
- * @param rootSegments
- * @param maxDepth
- * @returns {Promise<[string]>}
- */
-export async function findAllFiles({ path, name, maxDepth = 2 }) {
-  if (typeof path !== "string") {
-    throw new Error("path must be a string");
+export async function findAllFiles(
+  {
+    path,
+    name,
+    maxDepth = 2
+//
+  }: {
+    path: string;
+    name: string;
+    maxDepth?: number;
   }
-  if (typeof name !== "string") {
-    throw new Error("name must be a string");
-  }
-
+): Promise<string[]> {
   const rootSegments = path.split("/").length;
 
   if (env.VERBOSE) {
     console.log(`Searching for ${name} in ${path}`);
   }
-  const files = [];
+  const files: string[] = [];
   let readdirSync;
   try {
     readdirSync = fs.readdirSync(path);
@@ -30,7 +26,7 @@ export async function findAllFiles({ path, name, maxDepth = 2 }) {
     if (env.VERBOSE) {
       console.log(`Error reading ${path}`, e);
     }
-    return files;
+    return [];
   }
   for (const file of readdirSync) {
     const filePath = path + "/" + file;
@@ -49,8 +45,7 @@ export async function findAllFiles({ path, name, maxDepth = 2 }) {
           const subFiles = await findAllFiles({
             path: filePath,
             name: name,
-            rootSegments: rootSegments,
-            maxDepth: 2,
+            maxDepth: 2
           });
           files.push(...subFiles);
         } catch (e) {

package/src/{global.js → global.ts}

@@ -1,7 +1,7 @@
 const { merge } = require("lodash");
-export const env = {};
+export const env: any = {};
 merge(env, process.env);
-export const HOME = env["HOME"];
+export const HOME: string = env["HOME"];
 if (!HOME) {
   throw new Error("HOME environment variable is not set");
 }

package/src/{index.js → index.ts}

@@ -6,12 +6,7 @@ import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
 import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 
-/**
- *
- * @param params
- * @returns {Promise<string>}
- */
-export async function getCookie(params) {
+export async function getCookie(params: { name: string; domain: string; }) {
   const cookies = await queryCookies(
     params,
     new CompositeCookieQueryStrategy()
@@ -29,7 +24,7 @@ export async function getCookie(params) {
  * @param params
  * @returns {Promise<*>}
  */
-export async function getFirefoxCookie(params) {
+export async function getFirefoxCookie(params: { name: string; domain: string; }) {
   const cookies = await queryCookies(
     params,
     new FirefoxCookieQueryStrategy()
@@ -47,7 +42,7 @@ export async function getFirefoxCookie(params) {
  * @param params
  * @returns {Promise<*>}
  */
-export async function getChromeCookie(params) {
+export async function getChromeCookie(params: { name: string; domain: string; }) {
   const cookies = await queryCookies(
     params,
     new ChromeCookieQueryStrategy()

package/src/{isValidJwt.js → isValidJwt.ts}

@@ -1,10 +1,7 @@
 import jsonwebtoken from "jsonwebtoken";
 import { env } from "./global";
 
-export default function isValidJwt(token) {
-  if (typeof token !== "string") {
-    return false;
-  }
+export default function isValidJwt(token: any) {
   try {
     const result = jsonwebtoken.decode(token, { complete: true });
     if (env.VERBOSE) {

package/src/queryCookies.ts

@@ -0,0 +1,29 @@
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { uniqBy } from "lodash";
+import { env } from "./global";
+import isValidJwt from "./isValidJwt";
+import { ExportedCookie } from "./CookieRow";
+import AbstractCookieQueryStrategy from "./browsers/AbstractCookieQueryStrategy";
+
+export async function queryCookies(
+  {
+    name,
+    domain
+  }: {
+    name: string;
+    domain: string;
+  },
+  strategy: AbstractCookieQueryStrategy = 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/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);
-      }
-    });
-  });
-}