@mherod/get-cookie 2.0.0-rc.2 → 2.0.0-rc.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.21",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -11,38 +11,37 @@
     "access": "public"
   },
   "scripts": {
-    "clean": "git clean -fXd && yarn",
-    "build": "parcel build",
+    "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
+    "build": "tsc && parcel build",
     "prepare": "npm run build && npm run prettier",
+    "postinstall": "npm run build",
     "test": "jest",
-    "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}'",
-    "check": "tsc --noEmit"
+    "install:global": "npm run build && npm install --global .",
+    "prettier": "prettier --write ."
   },
   "targets": {
-    "main": {},
     "types": {},
+    "main": {},
     "library": {
-      "source": [
-        "src/index.ts"
-      ],
+      "source": "src/index.ts",
       "distDir": "dist",
       "isLibrary": true,
       "engines": {
-        "node": "16"
-      }
+        "node": ">= 16"
+      },
+      "sourceMap": true,
+      "includeNodeModules": false
     },
     "cli": {
       "source": "src/cli.ts",
       "distDir": "dist",
       "isLibrary": false,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
+      "sourceMap": false,
+      "optimize": false,
       "includeNodeModules": [
         "colorette"
       ]
@@ -53,7 +52,7 @@
     "inlineEnvironment": true
   },
   "engines": {
-    "node": "16"
+    "node": ">= 16"
   },
   "keywords": [],
   "author": "Matthew Herod",
@@ -61,12 +60,15 @@
   "dependencies": {
     "colorette": "^2.0.19",
     "cross-fetch": "^3.1.5",
-    "destr": "^1.1.1",
+    "destr": "^1.2.0",
     "jsonwebtoken": "^8.5.1",
     "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
     "lru-cache": "^7.14.0",
-    "minimist": "^1.2.6",
-    "sqlite3": "^5.1.1"
+    "minimist": "^1.2.7",
+    "sqlite3": "^5.1.2",
+    "tough-cookie": "^4.1.2",
+    "user-agents": "^1.0.1178"
   },
   "devDependencies": {
     "@parcel/packager-ts": "^2.7.0",
@@ -74,9 +76,9 @@
     "@types/jsonwebtoken": "^8.5.9",
     "@types/lodash": "^4.14.186",
     "@types/minimist": "^1.2.2",
-    "@types/node": "^18.8.2",
+    "@types/node": "^18.11.4",
+    "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
-    "jest": "^29.0.3",
     "parcel": "^2.7.0",
     "prettier": "^2.7.1",
     "ts-node": "^10.9.1",

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

@@ -1,4 +1,6 @@
-export interface CookieSpec {
-  name: string;
+export default interface CookieSpec {
   domain: string;
+  name: string;
 }
+
+export type MultiCookieSpec = CookieSpec | CookieSpec[];

package/src/CookieStore.ts

@@ -0,0 +1,27 @@
+import { env } from "./global";
+import { parsedArgs } from "./argv";
+import { CookieJar, MemoryCookieStore, Store } from "tough-cookie";
+
+import { FileCookieStore } from "./FileCookieStore";
+
+const memoryCookieStore = new MemoryCookieStore();
+
+async function getCookieStore(): Promise<Store> {
+  if (parsedArgs["cs"] == "memory") {
+    return memoryCookieStore;
+  }
+  const fileCookieStore = new FileCookieStore(
+    `${env["HOME"]}/cookie-star.json`,
+    memoryCookieStore
+  );
+  await fileCookieStore.waitUntilIdle();
+  return fileCookieStore;
+}
+
+export const cookieStorePromise: Promise<Store> = new Promise((resolve) => {
+  getCookieStore().then(resolve);
+});
+
+export const cookieJarPromise: Promise<CookieJar> = new Promise((resolve) => {
+  cookieStorePromise.then((store) => new CookieJar(store)).then(resolve);
+});

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

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols
+
 import { Response } from "cross-fetch";
 
 export default interface FetchResponse extends Response {

package/src/FileCookieStore.ts

@@ -0,0 +1,170 @@
+import { Cookie, MemoryCookieStore, Store } from "tough-cookie";
+import { existsSync, readFileSync, writeFile } from "fs";
+import destr from "destr";
+import { merge } from "lodash";
+
+export class FileCookieStore extends Store {
+  private readonly internalStore: Store;
+
+  synchronous: boolean = false;
+  filePath: string;
+
+  private tasks: Promise<any>[] = [];
+
+  constructor(
+    filePath: string,
+    internalStore: Store = new MemoryCookieStore()
+  ) {
+    super();
+
+    this.filePath = filePath;
+    this.internalStore = internalStore ?? new MemoryCookieStore();
+
+    console.log("Importing cookies from", filePath, internalStore);
+
+    this.tasks.push(
+      this.importSaved(filePath, internalStore).then(console.log, console.error)
+    );
+  }
+
+  private async importSaved(filePath: string, store: Store): Promise<Cookie[]> {
+    const cookies: Cookie[] = [];
+    if (existsSync(filePath)) {
+      const data = readFileSync(filePath, "utf8");
+      const cookies: any[] = Object.values(destr(data))
+        .flatMap((domainCookies: any) => Object.values(domainCookies))
+        .flatMap((domainCookies: any) => Object.values(domainCookies));
+      console.log("Importing", cookies.length, "cookies");
+      const array = Array.isArray(cookies) ? cookies : Object.values(cookies);
+      const put = await Promise.all(
+        array.map((cookie) => {
+          const fromJSON = Cookie.fromJSON(cookie);
+          if (fromJSON) {
+            return this.putCookieInternal(fromJSON, store);
+          }
+        })
+      );
+      cookies.push(...put);
+    }
+    return cookies;
+  }
+
+  findCookie(
+    domain: string,
+    path: string,
+    key: string,
+    cb: (err: Error | null, cookie: Cookie | null) => void
+  ) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.findCookie(domain, path, key, cb);
+    });
+  }
+
+  findCookies(
+    domain: string,
+    path: string,
+    allowSpecialUseDomain: boolean,
+    cb: (err: Error | null, cookie: Cookie[]) => void
+  ) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.findCookies(domain, path, allowSpecialUseDomain, cb);
+    });
+  }
+
+  putCookie(cookie: Cookie, cb: (err: Error | null) => void) {
+    this.internalStore.putCookie(cookie, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  updateCookie(
+    oldCookie: Cookie,
+    newCookie: Cookie,
+    cb: (err: Error | null) => void
+  ) {
+    this.internalStore.updateCookie(oldCookie, newCookie, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  removeCookie(
+    domain: string,
+    path: string,
+    key: string,
+    cb: (err: Error | null) => void
+  ) {
+    this.internalStore.removeCookie(domain, path, key, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  removeCookies(domain: string, path: string, cb: (err: Error | null) => void) {
+    this.internalStore.removeCookies(domain, path, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  getAllCookies(cb: (err: Error | null, cookie: Cookie[]) => void) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.getAllCookies(cb);
+    });
+  }
+
+  waitUntilIdle() {
+    return Promise.allSettled(this.tasks).catch(console.error);
+  }
+
+  private async putCookieInternal(
+    cookie: Cookie,
+    store: Store
+  ): Promise<Cookie> {
+    await this.waitUntilIdle();
+    return await new Promise<Cookie>(
+      (
+        resolve: (value: PromiseLike<Cookie> | Cookie) => void,
+        reject: (reason?: any) => void
+      ) => {
+        store.putCookie(cookie, (err: Error | null) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookie);
+          }
+        });
+      }
+    );
+  }
+
+  private serializeCallback(err: Error | null, cookies: Cookie[]) {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    const cookieObjs = cookies.map((cookie: Cookie) => cookie);
+    const idx: any = {};
+    for (const cookie of cookieObjs) {
+      const domain = cookie.domain;
+      if (typeof domain === "string") {
+        const path: string = cookie.path ?? "/";
+        const key: string = cookie.key;
+        merge(idx, {
+          [domain]: {
+            [path]: {
+              [key]: cookie.toJSON(),
+            },
+          },
+        });
+      }
+    }
+    const stringify = JSON.stringify(idx, null, 2);
+    writeFile(this.filePath, stringify, (err) => {
+      if (err) {
+        console.error(err);
+      }
+    });
+  }
+}

package/src/IsCookieRow.ts

@@ -1,4 +1,4 @@
-import { CookieRow } from "./CookieRow";
+import CookieRow from "./CookieRow";
 
 export function isCookieRow(obj: any): obj is CookieRow {
   return (

package/src/IsExportedCookie.ts

@@ -1,4 +1,4 @@
-import { ExportedCookie } from "./ExportedCookie";
+import ExportedCookie from "./ExportedCookie";
 
 export function isExportedCookie(obj: any): obj is ExportedCookie {
   return (

package/src/SpecialCases.ts

@@ -1,4 +1,4 @@
-import { CookieSpec } from "./CookieSpec";
+import CookieSpec from "./CookieSpec";
 
 export function specialCases({ name, domain }: CookieSpec): {
   specifiedName: boolean;

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,20 @@
+import minimist from "minimist";
+import { merge } from "lodash";
+
+export interface MyParsedArgs extends minimist.ParsedArgs {
+  verbose: boolean;
+  render?: string;
+  fetch?: string;
+  cs?: string;
+  dump?: string;
+  "dump-request-headers"?: string;
+  "dump-response-headers"?: string;
+  "dump-response-body"?: string;
+}
+
 export const argv: string[] = process.argv ?? [];
+const minimistArgs: minimist.ParsedArgs = minimist(argv.slice(2));
+const defaultOptions = {
+  verbose: false,
+};
+export const parsedArgs: MyParsedArgs = merge(defaultOptions, minimistArgs);

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -1,18 +1,23 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { execSimple } from "../utils";
 import { env, HOME } from "../global";
-import { existsSync } from "fs";
+import fs, { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
 import * as crypto from "crypto";
 import * as path from "path";
-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 * 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");
@@ -40,7 +45,7 @@ async function getPromise1(
       file: file,
     });
   } catch (e) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log("Error getting encrypted cookie", e);
     }
     return [];
@@ -56,10 +61,10 @@ async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
     const promises: Promise<CookieRow[]>[] = files.map((file) =>
       getPromise1(name, domain, file)
     );
-    const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
+    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 [];
@@ -71,7 +76,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;
@@ -99,17 +104,28 @@ Promise<ExportedCookie[]> {
       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,
       };
+      const expiry = cookieRow.expiry;
+      const mergeExpiry =
+        expiry != null && expiry > 0
+          ? {
+              expiry: new Date(expiry),
+            }
+          : {
+              expiry: "Infinity",
+            };
+      merge(exportedCookie, mergeExpiry);
+      return exportedCookie;
     });
   const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
     isExportedCookie
   );
-  if (env.VERBOSE) {
+  if (parsedArgs.verbose) {
     console.log("results", results);
   }
   return results;
@@ -136,39 +152,61 @@ async function getEncryptedChromeCookie({
   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;
   //language=SQL
-  sql = "SELECT encrypted_value, name, host_key FROM cookies";
+  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({
+  if (parsedArgs.verbose) {
+    console.log("sql", sql);
+  }
+  const domainRegexp: RegExp = stringToRegex(domain);
+  const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
     file: file,
     sql: sql,
+    rowFilter: (row) => {
+      return row["host_key"].match(domainRegexp) != null;
+    },
     rowTransform: (row) => {
-      return {
+      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(domainRegexp) != null;
+  });
 }
 
 async function getChromePassword(): Promise<string> {
@@ -192,7 +230,7 @@ async function decrypt(
   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}`
         );
@@ -202,14 +240,14 @@ async function decrypt(
     }
     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) {
+          if (parsedArgs.verbose) {
             console.log("Error doing pbkdf2", error);
           }
           reject(error);
@@ -217,7 +255,7 @@ async function decrypt(
         }
 
         if (buffer.length !== 16) {
-          if (env.VERBOSE) {
+          if (parsedArgs.verbose) {
             console.log(
               "Error doing pbkdf2, buffer length is not 16",
               buffer.length
@@ -237,7 +275,7 @@ async function decrypt(
         }
 
         if (encryptedData1.length % 16 !== 0) {
-          if (env.VERBOSE) {
+          if (parsedArgs.verbose) {
             console.log(
               "Error doing pbkdf2, encryptedData length is not a multiple of 16",
               encryptedData1.length
@@ -251,7 +289,7 @@ async function decrypt(
         try {
           decipher.final("utf-8");
         } catch (e) {
-          if (env.VERBOSE) {
+          if (parsedArgs.verbose) {
             console.log("Error doing decipher.final()", e);
           }
           reject(e);
@@ -271,3 +309,47 @@ async function decrypt(
     });
   });
 }
+
+export async function doChromeSqliteQuery1({
+  file,
+  sql,
+  rowFilter = () => true,
+  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
+          .filter(rowFilter)
+          .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]);
+    });
+  });
+}