@mherod/get-cookie 2.0.0-beta.9 → 2.0.0-rc.10

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0-rc.10",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
-  "main": "dist/main.js",
+  "main": "dist/index.js",
   "module": "dist/module.js",
   "types": "dist/types.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "clean": "git clean -fXd",
+    "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
     "build": "parcel build",
+    "prepare": "npm run build && npm run prettier",
     "test": "jest",
-    "postbuild": "npm run check && npm run install:global",
+    "postbuild": "npm run check",
     "prepublish": "npm run build",
+    "preinstall:global": "npm run build",
     "install:global": "npm install --force --global .",
     "postinstall:global": "find $NVM_BIN -exec chmod +x {} \\; || true",
     "prettier": "prettier --write 'src/{**/*,*}.{js,json,ts}'",
@@ -25,14 +27,13 @@
     "main": {},
     "types": {},
     "library": {
-      "source": [
-        "src/index.ts"
-      ],
+      "source": "src/index.ts",
       "distDir": "dist",
       "isLibrary": true,
       "engines": {
         "node": "16"
-      }
+      },
+      "includeNodeModules": false
     },
     "cli": {
       "source": "src/cli.ts",
@@ -62,15 +63,21 @@
     "destr": "^1.1.1",
     "jsonwebtoken": "^8.5.1",
     "lodash": "^4.17.21",
+    "lru-cache": "^7.14.0",
+    "minimist": "^1.2.6",
     "sqlite3": "^5.1.1",
-    "user-agents": "^1.0.1163"
+    "tough-cookie": "^4.1.2",
+    "tough-cookie-file-store": "^2.0.3",
+    "user-agents": "^1.0.1165"
   },
   "devDependencies": {
     "@parcel/packager-ts": "^2.7.0",
     "@parcel/transformer-typescript-types": "^2.7.0",
     "@types/jsonwebtoken": "^8.5.9",
     "@types/lodash": "^4.14.186",
+    "@types/minimist": "^1.2.2",
     "@types/node": "^18.8.2",
+    "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
     "jest": "^29.0.3",
     "parcel": "^2.7.0",

package/src/CookieRow.ts

@@ -1,4 +1,5 @@
-export interface CookieRow {
+export default interface CookieRow {
+  expiry?: number;
   domain: string;
   name: string;
   value: Buffer;

package/src/CookieSpec.ts

@@ -0,0 +1,4 @@
+export default interface CookieSpec {
+  domain: string;
+  name: string;
+}

package/src/CookieStore.ts

@@ -0,0 +1,10 @@
+import { CookieJar } from "tough-cookie";
+import { env } from "./global";
+const { FileCookieStore } = require("tough-cookie-file-store");
+
+export const cookieStore = new FileCookieStore(
+  `${env["HOME"]}/cookie-star.json`
+);
+// export const cookieStore = new MemoryCookieStore();
+
+export const cookieJar = new CookieJar(cookieStore);

package/src/ExportedCookie.ts

@@ -1,6 +1,7 @@
-export interface ExportedCookie {
+export default interface ExportedCookie {
   domain: string;
   name: string;
   value: string;
+  expiry?: Date | "Infinity";
   meta?: any;
 }

package/src/{fetchResponse.ts → FetchResponse.ts}

@@ -1,4 +1,8 @@
-export default interface FetchResponse {
+// noinspection JSUnusedGlobalSymbols
+
+import { Response } from "cross-fetch";
+
+export default interface FetchResponse extends Response {
   status: number;
   statusText: string;
   headers: Headers;

package/src/IsCookieRow.ts

@@ -1,5 +1,9 @@
-import { CookieRow } from "./CookieRow";
+import CookieRow from "./CookieRow";
 
 export function isCookieRow(obj: any): obj is CookieRow {
-  return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+  return (
+    obj.domain !== undefined &&
+    obj.name !== undefined &&
+    obj.value !== undefined
+  );
 }

package/src/IsExportedCookie.ts

@@ -1,5 +1,9 @@
-import { ExportedCookie } from "./ExportedCookie";
+import ExportedCookie from "./ExportedCookie";
 
 export function isExportedCookie(obj: any): obj is ExportedCookie {
-  return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+  return (
+    obj.domain !== undefined &&
+    obj.name !== undefined &&
+    obj.value !== undefined
+  );
 }

package/src/SpecialCases.ts

@@ -0,0 +1,14 @@
+import CookieSpec from "./CookieSpec";
+
+export function specialCases({ name, domain }: CookieSpec): {
+  specifiedName: boolean;
+  specifiedDomain: boolean;
+  //
+} {
+  const wildcardRegexp = /^([*%])$/i;
+  return {
+    specifiedName: name.match(wildcardRegexp) == null,
+    specifiedDomain: domain.match(wildcardRegexp) == null,
+    //
+  };
+}

package/src/StringToRegex.ts

@@ -0,0 +1,6 @@
+export function stringToRegex(s: string): RegExp {
+  const s1 = s.replaceAll(/\./gi, ".");
+  const s2 = s1.replace(/%/g, ".*");
+  const s3 = s2.replace(/\*/g, ".*");
+  return new RegExp(s3);
+}

package/src/argv.ts

@@ -1 +1,5 @@
+import minimist from "minimist";
+
 export const argv: string[] = process.argv ?? [];
+
+export const parsedArgs: minimist.ParsedArgs = minimist(argv.slice(2));

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -9,10 +9,17 @@ import { doSqliteQuery1 } from "../doSqliteQuery1";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
 import { isExportedCookie } from "../IsExportedCookie";
-import { CookieRow } from "../CookieRow";
-import { ExportedCookie } from "../ExportedCookie";
+import CookieRow from "../CookieRow";
+import ExportedCookie from "../ExportedCookie";
+import { stringToRegex } from "../StringToRegex";
+import { parsedArgs } from "../argv";
+import fs from "fs";
+import * as sqlite3 from "sqlite3";
+import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Chrome";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
       throw new Error("This only works on macOS");
@@ -23,20 +30,24 @@ export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
     return getChromeCookies({
       requireJwt: false,
       name,
-      domain
+      domain,
     });
   }
 }
 
-async function getPromise1(name: string, domain: string, file: string): Promise<CookieRow[]> {
+async function getPromise1(
+  name: string,
+  domain: string,
+  file: string
+): Promise<CookieRow[]> {
   try {
     return await getEncryptedChromeCookie({
       name: name,
       domain: domain,
-      file: file
+      file: file,
     });
   } catch (e) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log("Error getting encrypted cookie", e);
     }
     return [];
@@ -47,13 +58,15 @@ async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
   try {
     const files: string[] = await findAllFiles({
       path: chromeLocal,
-      name: "Cookies"
+      name: "Cookies",
     });
-    const promises: Promise<CookieRow[]>[] = files.map((file) => getPromise1(name, domain, file));
-    const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
+    const promises: Promise<CookieRow[]>[] = files.map((file) =>
+      getPromise1(name, domain, file)
+    );
+    const results1: CookieRow[][] = await Promise.all(promises);
     return results1.flat().filter(isCookieRow);
   } catch (error) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log("error", error);
     }
     return [];
@@ -65,7 +78,7 @@ async function decryptValue(password: string, encryptedValue: Buffer) {
   try {
     d = await decrypt(password, encryptedValue);
   } catch (e) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log("Error decrypting cookie", e);
     }
     d = null;
@@ -73,19 +86,17 @@ async function decryptValue(password: string, encryptedValue: Buffer) {
   return d ?? encryptedValue.toString("utf-8");
 }
 
-async function getChromeCookies(
-  {
-    name,
-    domain = "%",
-    requireJwt = false
-  }: {
-    name: string;
-    domain: string;
-    requireJwt: boolean | undefined;
-    //
-  }
+async function getChromeCookies({
+  name,
+  domain = "%",
+  requireJwt = false,
+}: {
+  name: string;
+  domain: string;
+  requireJwt: boolean | undefined;
   //
-): Promise<ExportedCookie[]> {
+}): //
+Promise<ExportedCookie[]> {
   const encryptedDataItems: CookieRow[] = await getPromise(name, domain);
   const password: string = await getChromePassword();
   const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
@@ -95,15 +106,24 @@ async function getChromeCookies(
       const decryptedValue = await decryptValue(password, encryptedValue);
       const meta = {};
       merge(meta, cookieRow.meta ?? {});
-      return {
+      const exportedCookie: ExportedCookie = {
         domain: cookieRow.domain,
         name: cookieRow.name,
         value: decryptedValue,
-        meta: meta
+        meta: meta,
       };
+      const expiry = cookieRow.expiry;
+      if (expiry) {
+        merge(exportedCookie, {
+          expiry: new Date(expiry),
+        });
+      }
+      return exportedCookie;
     });
-  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(isExportedCookie);
-  if (env.VERBOSE) {
+  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
+    isExportedCookie
+  );
+  if (parsedArgs.verbose) {
     console.log("results", results);
   }
   return results;
@@ -117,51 +137,79 @@ const chromeLocal = path.join(
   "Chrome"
 );
 
-async function getEncryptedChromeCookie(
-  {
-    name,
-    domain,
-    file = path.join(chromeLocal, "Default", "Cookies")
-    //
-  }: {
-    name: string;
-    domain: string;
-    file: string;
-  }): Promise<CookieRow[]> {
+async function getEncryptedChromeCookie({
+  name,
+  domain,
+  file = path.join(chromeLocal, "Default", "Cookies"),
+}: //
+{
+  name: string;
+  domain: string;
+  file: string;
+}): Promise<CookieRow[]> {
   if (!existsSync(file)) {
     throw new Error(`File ${file} does not exist`);
   }
-  if (env.VERBOSE) {
+  if (parsedArgs.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, name, host_key FROM cookies`;
+  //language=SQL
+  sql = "SELECT * FROM cookies";
+  // sql = "SELECT encrypted_value, name, host_key FROM cookies";
+
   const wildcardRegexp = /^([*%])$/i;
   const specifiedName = name.match(wildcardRegexp) == null;
   const specifiedDomain = domain.match(wildcardRegexp) == null;
-  if (specifiedName || specifiedDomain) {
+  const wildcardDomain = domain.match(/[%*]/) != null;
+  const queryDomain = specifiedDomain && !wildcardDomain;
+  // if we have a wildcard domain, we need to use a regexp
+  if (specifiedName || queryDomain) {
     sql += ` WHERE `;
     if (specifiedName) {
       sql += `name = '${name}'`;
-      if (specifiedDomain) {
+      if (queryDomain) {
         sql += ` AND `;
       }
     }
-    if (specifiedDomain) {
-      sql += `host_key LIKE '${domain}';`;
+    if (queryDomain) {
+      // leading dot replaced with % to match subdomains
+      const sqlEmbedDomain = domain.replace(/^[.%]?/, "%");
+      sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
-  return doSqliteQuery1(file, sql);
+  const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
+    file: file,
+    sql: sql,
+    rowTransform: (row) => {
+      const cookieRow = {
+        expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
+        domain: row["host_key"],
+        name: row["name"],
+        value: row["encrypted_value"],
+      };
+      if (parsedArgs.verbose) {
+        console.log("CookieRow", cookieRow);
+      }
+      return cookieRow;
+    },
+  });
+  return sqliteQuery1.filter((row) => {
+    return row.domain.match(stringToRegex(domain)) != null;
+  });
 }
 
 async function getChromePassword(): Promise<string> {
   return execSimple(
-    "security find-generic-password -w -s \"Chrome Safe Storage\""
+    'security find-generic-password -w -s "Chrome Safe Storage"'
   );
 }
 
-async function decrypt(password: crypto.BinaryLike, encryptedData: Buffer): Promise<string> {
+async function decrypt(
+  password: crypto.BinaryLike,
+  encryptedData: Buffer
+): Promise<string> {
   if (typeof password !== "string") {
     throw new Error("password must be a string: " + password);
   }
@@ -173,7 +221,7 @@ async function decrypt(password: crypto.BinaryLike, encryptedData: Buffer): Prom
   if (!(encryptedData1 instanceof Buffer)) {
     if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
       [encryptedData1] = encryptedData1;
-      if (env.VERBOSE) {
+      if (parsedArgs.verbose) {
         console.log(
           `encryptedData is an array of buffers, selected first: ${encryptedData1}`
         );
@@ -183,77 +231,113 @@ async function decrypt(password: crypto.BinaryLike, encryptedData: Buffer): Prom
     }
     encryptedData1 = Buffer.from(encryptedData1);
   }
-  if (env.VERBOSE) {
+  if (parsedArgs.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;
+    crypto.pbkdf2(password, "saltysalt", 1003, 16, "sha1", (error, buffer) => {
+      try {
+        if (error) {
+          if (parsedArgs.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;
+        if (buffer.length !== 16) {
+          if (parsedArgs.verbose) {
+            console.log(
+              "Error doing pbkdf2, buffer length is not 16",
+              buffer.length
+            );
           }
+          reject(new Error("Buffer length is not 16"));
+          return;
+        }
 
-          const str = new Array(17).join(" ");
-          const iv = Buffer.from(str, "binary");
-          const decipher = crypto.createDecipheriv("aes-128-cbc", buffer, iv);
-          decipher.setAutoPadding(false);
-
-          if (encryptedData1 && encryptedData1.slice) {
-            encryptedData1 = encryptedData1.slice(3);
-          }
+        const str = new Array(17).join(" ");
+        const iv = Buffer.from(str, "binary");
+        const decipher = crypto.createDecipheriv("aes-128-cbc", buffer, iv);
+        decipher.setAutoPadding(false);
 
-          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;
-          }
+        if (encryptedData1 && encryptedData1.slice) {
+          encryptedData1 = encryptedData1.slice(3);
+        }
 
-          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;
+        if (encryptedData1.length % 16 !== 0) {
+          if (parsedArgs.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;
+        }
 
-          const padding = decoded[decoded.length - 1];
-          if (padding) {
-            decoded = decoded.slice(0, 0 - padding);
-          }
-          // noinspection JSCheckFunctionSignatures
-          const decodedString = decoded.toString("utf8");
-          resolve(decodedString);
+        let decoded = decipher.update(encryptedData1);
+        try {
+          decipher.final("utf-8");
         } catch (e) {
+          if (parsedArgs.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
+        const decodedString = decoded.toString("utf8");
+        resolve(decodedString);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+
+export async function doChromeSqliteQuery1({
+  file,
+  sql,
+  rowTransform,
+}: DoSqliteQuery1Params): Promise<CookieRow[]> {
+  if (!file || (file && !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) {
+        reject(err);
+        return;
+      }
+      const rows1: any[] = rows;
+      if (rows1 == null || rows1.length === 0) {
+        resolve([]);
+        return;
+      }
+      if (Array.isArray(rows1)) {
+        const cookieRows: CookieRow[] = rows1.map((row: any) => {
+          const newVar = {
+            meta: {
+              file: file,
+            },
+          };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
+        });
+        resolve(cookieRows);
+        return;
+      }
+      if (parsedArgs.verbose) {
+        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+      }
+      resolve([rows1]);
+    });
   });
 }

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -2,13 +2,28 @@ import ChromeCookieQueryStrategy from "./ChromeCookieQueryStrategy";
 import FirefoxCookieQueryStrategy from "./FirefoxCookieQueryStrategy";
 import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { ExportedCookie } from "../ExportedCookie";
+import ExportedCookie from "../ExportedCookie";
+import LRUCache from "lru-cache";
+import CookieStoreQueryStrategy from "./CookieStoreQueryStrategy";
+import { red } from "colorette";
+import { merge } from "lodash";
+import { parsedArgs } from "../argv";
+
+const cache = new LRUCache<string, ExportedCookie[]>({
+  ttl: 1000 * 2,
+  max: 10,
+});
+
+export default class CompositeCookieQueryStrategy
+  implements CookieQueryStrategy
+{
+  browserName = "all";
 
-export default class CompositeCookieQueryStrategy implements CookieQueryStrategy {
   #strategies;
 
   constructor() {
     this.#strategies = [
+      CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
@@ -18,13 +33,40 @@ export default class CompositeCookieQueryStrategy implements CookieQueryStrategy
   }
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    const results = await Promise.all(
-      this.#strategies.map(async (strategy) => {
+    // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+    const key = `${name}:${domain}`;
+    const cached = cache.get(key);
+    if (cached) {
+      return cached;
+    }
+    if (parsedArgs.verbose) {
+      console.log("Querying cookies:", name, domain);
+    }
+    const results: ExportedCookie[][] = await Promise.all(
+      this.#strategies.map(async (strategy: CookieQueryStrategy) => {
         // @ts-ignore
-        const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(name, domain);
-        return cookies.catch(() => []);
+        return strategy
+          .queryCookies(name, domain)
+          .then((cookies: ExportedCookie[]) => {
+            return cookies.map((cookie: ExportedCookie) => {
+              return merge(cookie, {
+                meta: {
+                  browser: strategy.browserName,
+                },
+              });
+            });
+          })
+          .catch((e) => {
+            console.log(
+              red(`Error querying ${strategy.browserName} cookies`),
+              e
+            );
+            return [];
+          });
       })
     );
-    return results.flat();
+    const flat: ExportedCookie[] = results.flat();
+    cache.set(`${name}:${domain}`, flat);
+    return flat;
   }
 }

package/src/browsers/CookieQueryStrategy.ts

@@ -1,5 +1,6 @@
-import { ExportedCookie } from "../ExportedCookie";
+import ExportedCookie from "../ExportedCookie";
 
 export default interface CookieQueryStrategy {
-  queryCookies(name: string, domain: string): Promise<ExportedCookie[]>
+  browserName: string;
+  queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
 }