@mherod/get-cookie 2.0.0-rc.3 → 2.0.0-rc.30

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -1,18 +1,24 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { execSimple } from "../utils";
-import { env, HOME } from "../global";
+import { env } from "../global";
 import { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
-import * as crypto from "crypto";
-import * as path from "path";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
+import { join } from "path";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
-import { isExportedCookie } from "../IsExportedCookie";
+import { isExportedCookie } from "../ExportedCookie";
 import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
+import { stringToRegex } from "../StringToRegex";
+import { parsedArgs } from "../argv";
+import consola from "consola";
+import { getChromePassword } from "./getChromePassword";
+import { chromeApplicationSupport } from "./ChromeApplicationSupport";
+import { decrypt } from "./decrypt";
+import { doSqliteQueryWithTransform } from "./DoSqliteQueryWithTransform";
 
 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 +46,7 @@ async function getPromise1(
       file: file,
     });
   } catch (e) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log("Error getting encrypted cookie", e);
     }
     return [];
@@ -50,16 +56,16 @@ async function getPromise1(
 async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
   try {
     const files: string[] = await findAllFiles({
-      path: chromeLocal,
+      path: chromeApplicationSupport,
       name: "Cookies",
     });
     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 +77,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,34 +105,37 @@ 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;
 }
 
-const chromeLocal = path.join(
-  HOME,
-  "Library",
-  "Application Support",
-  "Google",
-  "Chrome"
-);
-
 async function getEncryptedChromeCookie({
   name,
   domain,
-  file = path.join(chromeLocal, "Default", "Cookies"),
+  file = join(chromeApplicationSupport, "Default", "Cookies"),
 }: //
 {
   name: string;
@@ -136,138 +145,69 @@ 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}`);
+    consola.start(
+      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`
+    );
   }
   let sql;
   //language=SQL
-  sql = "SELECT encrypted_value, name, host_key FROM cookies";
+  sql = "SELECT encrypted_value, name, host_key, expires_utc FROM cookies";
+  // Define a regular expression to match wildcard characters
   const wildcardRegexp = /^([*%])$/i;
+  // Check if the name does not contain wildcard characters
   const specifiedName = name.match(wildcardRegexp) == null;
+  // Check if the domain does not contain wildcard characters
   const specifiedDomain = domain.match(wildcardRegexp) == null;
-  if (specifiedName || specifiedDomain) {
+  // Check if the domain contains wildcard characters
+  const wildcardDomain = domain.match(/[%*]/) != null;
+  // Determine if we should query the domain based on the previous checks
+  const queryDomain = specifiedDomain && !wildcardDomain;
+  // if we have a wildcard domain, we need to use a regexp
+  // If the name is specified or we need to query the domain, we add a WHERE clause to the SQL query
+  if (specifiedName || queryDomain) {
     sql += ` WHERE `;
+    // If the name is specified, we add a condition to the SQL query to match the name
     if (specifiedName) {
       sql += `name = '${name}'`;
-      if (specifiedDomain) {
+      // If we also need to query the domain, we add an AND operator to the SQL query
+      if (queryDomain) {
         sql += ` AND `;
       }
     }
-    if (specifiedDomain) {
-      sql += `host_key LIKE '${domain}';`;
+    // If we need to query the domain, we add a condition to the SQL query to match the domain
+    if (queryDomain) {
+      // The leading dot is replaced with % to match subdomains
+      const sqlEmbedDomain = domain.replace(/^[.%]?/, "%");
+      sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
-  return doSqliteQuery1({
+  if (parsedArgs.verbose) {
+    consola.info("Querying:", sql);
+  }
+  const domainRegexp: RegExp = stringToRegex(domain);
+  const sqliteQuery1: CookieRow[] = await doSqliteQueryWithTransform({
     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) {
+        consola.info("Found", cookieRow);
+      }
+      return cookieRow;
     },
   });
-}
-
-async function getChromePassword(): Promise<string> {
-  return execSimple(
-    'security find-generic-password -w -s "Chrome Safe Storage"'
-  );
-}
-
-async function decrypt(
-  password: crypto.BinaryLike,
-  encryptedData: Buffer
-): Promise<string> {
-  if (typeof password !== "string") {
-    throw new Error("password must be a string: " + password);
-  }
-  let encryptedData1: any;
-  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 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);
-        }
-
-        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
-        const decodedString = decoded.toString("utf8");
-        resolve(decodedString);
-      } catch (e) {
-        reject(e);
-      }
-    });
+  return sqliteQuery1.filter((row) => {
+    // TODO: is this needed?
+    return row.domain.match(domainRegexp) != null;
   });
 }

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -4,21 +4,28 @@ import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 import LRUCache from "lru-cache";
-import MemoryCookieStoreQueryStrategy from "./MemoryCookieJarQueryStrategy";
+import { red } from "colorette";
+import { merge } from "lodash";
+import { parsedArgs } from "../argv";
 
-const cache = new LRUCache<string, ExportedCookie[]>({
-  ttl: 1000 * 2,
+const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
+  string,
+  ExportedCookie[]
+>({
+  ttl: 1000 * 10,
   max: 10,
 });
 
 export default class CompositeCookieQueryStrategy
   implements CookieQueryStrategy
 {
+  browserName = "all";
+
   #strategies;
 
   constructor() {
     this.#strategies = [
-      MemoryCookieStoreQueryStrategy,
+      // CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
@@ -28,19 +35,36 @@ export default class CompositeCookieQueryStrategy
   }
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
     const key = `${name}:${domain}`;
     const cached = cache.get(key);
     if (cached) {
       return cached;
     }
-    const results = await Promise.all(
-      this.#strategies.map(async (strategy) => {
+    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 [];
+          });
       })
     );
     const flat: ExportedCookie[] = results.flat();

package/src/browsers/CookieQueryStrategy.ts

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

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -0,0 +1,99 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import CookieSpec from "../CookieSpec";
+import ExportedCookie from "../ExportedCookie";
+import { Cookie, Store } from "tough-cookie";
+import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
+import { stringToRegex } from "../StringToRegex";
+
+export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
+  browserName = "internal";
+
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    const exportedCookies: ExportedCookie[] = [];
+
+    // if (name.match(/[%*]/) || domain.match(/[%*]/)) {
+    const cookies: Cookie[] = await this.#getAllCookies();
+    const allExportedCookies = cookies.map((cookie: Cookie) => {
+      return this.#extracted(cookie, { name, domain });
+    });
+    exportedCookies.push(...allExportedCookies);
+    // }
+
+    const wildcardRegexp = /^([*%])$/i;
+    if (name.match(wildcardRegexp) && domain.match(wildcardRegexp)) {
+      return exportedCookies;
+    }
+
+    const path = "/";
+
+    if (domain != "%") {
+      const domain1 = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+      const url = new URL("https://" + domain1);
+      url.pathname = path;
+      const cookies: Cookie[] = await this.#getCookies(url.href);
+      const domainCookies = cookies.map((cookie: Cookie) => {
+        return this.#extracted(cookie, {
+          domain,
+          name,
+        });
+      });
+      exportedCookies.push(...domainCookies);
+    }
+
+    if (name == "%") {
+      return exportedCookies.filter((cookie: ExportedCookie) => {
+        return cookie.domain.match(stringToRegex(domain));
+      });
+    }
+
+    return exportedCookies.filter((cookie: ExportedCookie) => {
+      return (
+        cookie.name.match(stringToRegex(name)) &&
+        cookie.domain.match(stringToRegex(domain))
+      );
+    });
+  }
+
+  #extracted(cookie: Cookie, cookieSpec: CookieSpec): ExportedCookie {
+    return {
+      domain: cookie.domain ?? cookieSpec.domain,
+      name: cookie.key ?? cookieSpec.name,
+      value: cookie.value,
+      expiry: cookie.expires ?? "Infinity",
+      meta: {
+        file: "tough-cookie",
+      },
+    };
+  }
+
+  async #getCookies(url: string): Promise<Cookie[]> {
+    const cookieJar = await cookieJarPromise;
+    return new Promise((resolve, reject) => {
+      return cookieJar.getCookies(
+        url,
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        }
+      );
+    });
+  }
+
+  async #getAllCookies(): Promise<Cookie[]> {
+    const cookieStore: Store = await cookieStorePromise;
+    return new Promise((resolve, reject) => {
+      return cookieStore.getAllCookies(
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        }
+      );
+    });
+  }
+}

package/src/browsers/DoSqliteQueryWithTransform.ts

@@ -0,0 +1,85 @@
+import CookieRow from "../CookieRow";
+import fs from "fs";
+import { Database } from "sqlite3";
+import { merge } from "lodash";
+import { parsedArgs } from "../argv";
+import consola from "consola";
+
+export interface DoSqliteQueryWithTransformOptions {
+  file: string;
+  sql: string;
+  rowFilter?: (row: any) => boolean;
+  rowTransform: (row: any) => CookieRow;
+}
+
+function checkFileExistence(file: string) {
+  if (!file || !fs.existsSync(file)) {
+    throw new Error(`File ${file} does not exist`);
+  }
+}
+
+function createDatabase(file: string) {
+  return new Database(file);
+}
+
+function transformRows(
+  //
+  rows: any[],
+  rowFilter: (row: any) => boolean,
+  rowTransform: (row: any) => CookieRow,
+  file: string
+  //
+): CookieRow[] {
+  return rows.filter(rowFilter).map((row: any) => {
+    const metaData = {
+      meta: {
+        file: file,
+      },
+    };
+
+    const cookieRow: CookieRow = rowTransform(row);
+
+    return merge(metaData, cookieRow);
+  });
+}
+
+export async function doSqliteQueryWithTransform(
+  //
+  {
+    //
+    file,
+    sql,
+    rowFilter = () => true,
+    rowTransform,
+  }: DoSqliteQueryWithTransformOptions
+): //
+Promise<CookieRow[]> {
+  checkFileExistence(file);
+
+  const db: Database = createDatabase(file);
+
+  return new Promise((resolve, reject) => {
+    db.all(sql, (err: Error, rows: any[]) => {
+      if (err) {
+        return reject(err);
+      }
+
+      if (!rows || rows.length === 0) {
+        return resolve([]);
+      }
+
+      const cookieRows: CookieRow[] = transformRows(
+        rows,
+        rowFilter,
+        rowTransform,
+        file
+      );
+
+      if (parsedArgs.verbose) {
+        consola.log(`Rows: ${JSON.stringify(rows)}`);
+      }
+
+      return resolve(cookieRows);
+    });
+  });
+}

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -1,20 +1,24 @@
 import * as path from "path";
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { env, HOME } from "../global";
+import { HOME } from "../global";
 import { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
 import ExportedCookie from "../ExportedCookie";
 import CookieRow from "../CookieRow";
 import CookieSpec from "../CookieSpec";
 import { specialCases } from "../SpecialCases";
+import { parsedArgs } from "../argv";
+import { doSqliteQueryWithTransform } from "./DoSqliteQueryWithTransform";
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Firefox";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
+      // TODO: implement
+      return [];
     }
-    if (env.CHROME_ONLY) {
+    if (parsedArgs.browser !== "firefox") {
       return [];
     }
     const cookies = await this.#getFirefoxCookie({ name, domain });
@@ -34,7 +38,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   async #getFirefoxCookie(
     { name, domain }: CookieSpec //
   ) {
-    const files: string[] = await findAllFiles({
+    const files: string[] = findAllFiles({
       path: path.join(
         HOME,
         "Library",
@@ -47,7 +51,8 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
     const fn: (file: string) => Promise<CookieRow[]> = async (file: string) => {
       return await this.#queryCookiesDb(file, name, domain);
     };
-    const all: Awaited<CookieRow[]>[] = await Promise.all(files.map(fn));
+    const all: CookieRow[][] = await Promise.all(files.map(fn));
+    // flatten
     return all.flat();
   }
 
@@ -85,7 +90,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       };
     };
     try {
-      return await doSqliteQuery1({
+      return await doSqliteQueryWithTransform({
         file,
         sql,
         rowTransform,

package/src/browsers/SafariCookieQueryStrategy.ts

@@ -2,7 +2,10 @@ import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 
 export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Safari";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    // TODO: implement
     return [];
   }
 }