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

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -23,17 +23,21 @@ 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) {
@@ -47,9 +51,11 @@ 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 promises: Promise<CookieRow[]>[] = files.map((file) =>
+      getPromise1(name, domain, file)
+    );
     const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
     return results1.flat().filter(isCookieRow);
   } catch (error) {
@@ -73,19 +79,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
@@ -99,10 +103,12 @@ async function getChromeCookies(
         domain: cookieRow.domain,
         name: cookieRow.name,
         value: decryptedValue,
-        meta: meta
+        meta: meta,
       };
     });
-  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(isExportedCookie);
+  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
+    isExportedCookie
+  );
   if (env.VERBOSE) {
     console.log("results", results);
   }
@@ -117,17 +123,16 @@ 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`);
   }
@@ -136,7 +141,8 @@ async function getEncryptedChromeCookie(
     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 encrypted_value, name, host_key FROM cookies";
   const wildcardRegexp = /^([*%])$/i;
   const specifiedName = name.match(wildcardRegexp) == null;
   const specifiedDomain = domain.match(wildcardRegexp) == null;
@@ -152,16 +158,29 @@ async function getEncryptedChromeCookie(
       sql += `host_key LIKE '${domain}';`;
     }
   }
-  return doSqliteQuery1(file, sql);
+  return doSqliteQuery1({
+    file: file,
+    sql: sql,
+    rowTransform: (row) => {
+      return {
+        domain: row["host_key"],
+        name: row["name"],
+        value: row["encrypted_value"],
+      };
+    },
+  });
 }
 
 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);
   }
@@ -187,73 +206,68 @@ async function decrypt(password: crypto.BinaryLike, encryptedData: Buffer): Prom
     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 (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;
+        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);
-          }
+        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 (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;
+        }
 
-          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 (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);
+      }
+    });
   });
 }

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -3,8 +3,16 @@ import FirefoxCookieQueryStrategy from "./FirefoxCookieQueryStrategy";
 import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { ExportedCookie } from "../ExportedCookie";
+import LRUCache from "lru-cache";
 
-export default class CompositeCookieQueryStrategy implements CookieQueryStrategy {
+const cache = new LRUCache<string, ExportedCookie[]>({
+  ttl: 1000 * 2,
+  max: 10,
+});
+
+export default class CompositeCookieQueryStrategy
+  implements CookieQueryStrategy
+{
   #strategies;
 
   constructor() {
@@ -18,13 +26,23 @@ export default class CompositeCookieQueryStrategy implements CookieQueryStrategy
   }
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    const key = `${name}:${domain}`;
+    const cached = cache.get(key);
+    if (cached) {
+      return cached;
+    }
     const results = await Promise.all(
       this.#strategies.map(async (strategy) => {
         // @ts-ignore
-        const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(name, domain);
+        const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(
+          name,
+          domain
+        );
         return cookies.catch(() => []);
       })
     );
-    return results.flat();
+    const flat: ExportedCookie[] = results.flat();
+    cache.set(`${name}:${domain}`, flat);
+    return flat;
   }
 }

package/src/browsers/CookieQueryStrategy.ts

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

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -1,11 +1,13 @@
+import * as path from "path";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { env, HOME } from "../global";
 import { existsSync } from "fs";
-import { toStringOrNull } from "../utils";
 import { findAllFiles } from "../findAllFiles";
-import * as path from "path";
 import { doSqliteQuery1 } from "../doSqliteQuery1";
 import { ExportedCookie } from "../ExportedCookie";
+import { CookieRow } from "../CookieRow";
+import { CookieSpec } from "../CookieSpec";
+import { specialCases } from "../SpecialCases";
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
@@ -16,26 +18,21 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       return [];
     }
     const cookies = await this.#getFirefoxCookie({ name, domain });
-    return Array.isArray(cookies) ? cookies.map(toStringOrNull) : [];
+    if (Array.isArray(cookies)) {
+      return cookies.map((cookie: CookieRow) => {
+        return {
+          domain: cookie.domain,
+          name: cookie.name,
+          value: cookie.value.toString("utf8"),
+        };
+      });
+    } else {
+      return [];
+    }
   }
 
-  /**
-   *
-   * @param name
-   * @param domain
-   * @returns {Promise<Buffer>}
-   */
   async #getFirefoxCookie(
-    //
-    {
-      name,
-      domain
-    }: {
-      name: string,
-      domain: string
-      //
-    }
-    //
+    { name, domain }: CookieSpec //
   ) {
     const files: string[] = await findAllFiles({
       path: path.join(
@@ -45,48 +42,57 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
         "Firefox",
         "Profiles"
       ),
-      name: "cookies.sqlite"
+      name: "cookies.sqlite",
     });
-    const all = await Promise.all(
-      files.map((file) => {
-        return this.#queryCookiesDb(file, name, domain);
-      })
-    );
+    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));
     return all.flat();
   }
 
-  #queryCookiesDb(file: string, name: string, domain: string) {
+  async #queryCookiesDb(
+    file: string,
+    name: string,
+    domain: string
+  ): Promise<CookieRow[]> {
     if (file && !existsSync(file)) {
       throw new Error(`File ${file} does not exist`);
     }
-    if (env.VERBOSE) {
-      console.log(`Trying Firefox cookie ${name} for domain ${domain}`);
-    }
     let sql;
     //language=SQL
-    sql = "SELECT value FROM moz_cookies";
-    if (typeof name === "string" || typeof domain === "string") {
+    sql = "SELECT value, name, host FROM moz_cookies";
+    const { specifiedName, specifiedDomain } = specialCases({ name, domain });
+    if (specifiedName || specifiedDomain) {
       sql += ` WHERE `;
-      if (typeof name === "string") {
+      if (specifiedName) {
         sql += `name = '${name}'`;
-        if (typeof domain === "string") {
+        if (specifiedDomain) {
           sql += ` AND `;
         }
       }
-      if (typeof domain === "string") {
+      if (specifiedDomain) {
         sql += `host LIKE '${domain}';`;
       }
     }
-    return doSqliteQuery1(file, sql)
-      .then((rows) => {
-        return rows.map((row) => {
-          return {
-            domain: row.domain,
-            name: row.name,
-            value: row.value.toString("utf8")
-          };
-        });
-      })
-      .catch(() => []);
+    const rowTransform = (row: any) => {
+      // row is object key by column name
+      const value = row.value as string;
+      return {
+        domain: row.domain as string,
+        name: row.name as string,
+        value: Buffer.from(value, "utf8"),
+      };
+    };
+    try {
+      return await doSqliteQuery1({
+        file,
+        sql,
+        rowTransform,
+      });
+    } catch (e) {
+      console.error(`Error querying ${file}`, e);
+      return [];
+    }
   }
 }

package/src/cli.ts

@@ -1,24 +1,26 @@
 #!/usr/bin/env node
 
+import minimist from "minimist";
+import { argv } from "./argv";
 import { env } from "./global";
 import { queryCookies } from "./queryCookies";
-import { argv } from "./argv";
 import { groupBy } from "lodash";
-import { blue, green } from "colorette";
+import { green, yellow } from "colorette";
 import { resultsRendered } from "./resultsRendered";
-import { ExportedCookie } from "./ExportedCookie";
+import { fetchWithCookies } from "./fetchWithCookies";
+import { unpackHeaders } from "./unpackHeaders";
 
-function combinedString(results: ExportedCookie[]) {
-  return blue(resultsRendered(results));
-}
+const parsedArgs: minimist.ParsedArgs = minimist(argv);
 
 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(yellow(resultsRendered(results)));
+      } else if (argv.includes("--render") || argv.includes("-r")) {
+        console.log(yellow(resultsRendered(results)));
+      } else if (argv.includes("--dump") || argv.includes("-d")) {
         console.log(results);
       } else if (argv.includes("--dump-grouped")) {
         const groupedByFile = groupBy(results, (r) => r.meta?.file);
@@ -27,7 +29,7 @@ async function cliQueryCookies(name: string, domain: string) {
         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));
+          console.log(green(file) + ": ", yellow(resultsRendered(results)));
         }
       } else {
         for (const result of results) {
@@ -42,41 +44,75 @@ async function cliQueryCookies(name: string, domain: string) {
   }
 }
 
-if (argv && argv.length > 2) {
-  const name = argv[2];
+function main() {
+  if (argv && argv.length > 2) {
+    const arg2 = argv[2];
+    const arg3 = argv[3];
+    if (arg2 == "--fetch" || arg2 == "-f") {
+      const f = parsedArgs["f"];
+      let url: URL;
+      try {
+        url = new URL(f);
+      } catch (e) {
+        console.error("Invalid URL", arg3);
+        return;
+      }
+      const headerArgs: string[] | string = parsedArgs["H"];
+      const headers = unpackHeaders(headerArgs);
+      const onfulfilled = (res: Response) => {
+        return res.text().then((r) => {
+          console.log(r);
+        });
+      };
+      fetchWithCookies(
+        url,
+        {
+          //
+          headers,
+        }
+        //
+      ).then(
+        onfulfilled,
+        console.error
+        //
+      );
+      return;
+    }
+    let domain;
+    if (arg3 != null && arg3.indexOf(".") > -1) {
+      domain = arg3;
+    } else {
+      domain = "%";
+    }
 
-  let domain;
-  if (argv[3] != null && argv[3].indexOf(".") > -1) {
-    domain = argv[3];
-  } else {
-    domain = "%";
-  }
+    const tru = `${true}`;
 
-  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("--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 (argv.includes("--single")) {
-    env.SINGLE = tru;
-  }
+    if (env.VERBOSE) {
+      console.log("Verbose mode", argv);
+    }
 
-  if (env.VERBOSE) {
-    console.log("Verbose mode", argv);
+    cliQueryCookies(arg2, domain).catch(console.error);
   }
-
-  cliQueryCookies(name, domain).catch(console.error);
 }
+
+main();

package/src/doSqliteQuery1.ts

@@ -1,9 +1,20 @@
 import * as fs from "fs";
 import * as sqlite3 from "sqlite3";
 import { CookieRow } from "./CookieRow";
+import { merge } from "lodash";
 
-export async function doSqliteQuery1(file: string, sql: string): Promise<CookieRow[]> {
-  if (!fs.existsSync(file)) {
+interface DoSqliteQuery1Params {
+  file: string;
+  sql: string;
+  rowTransform: (row: any) => CookieRow;
+}
+
+export async function doSqliteQuery1({
+  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);
@@ -19,15 +30,14 @@ export async function doSqliteQuery1(file: string, sql: string): Promise<CookieR
         return;
       }
       if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row) => {
-          return {
-            domain: row["host_key"],
-            name: row["name"],
-            value: row["encrypted_value"],
+        const cookieRows: CookieRow[] = rows1.map((row: any) => {
+          const newVar = {
             meta: {
-              file: file
-            }
+              file: file,
+            },
           };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
         });
         resolve(cookieRows);
         return;