@mherod/get-cookie 2.0.0-rc.8 → 2.1.0

package/src/browsers/QuerySqliteThenTransform.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 "../logger";
+
+interface FnOptions {
+  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): Database {
+  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 querySqliteThenTransform(
+  //
+  {
+    //
+    file,
+    sql,
+    rowFilter = () => true,
+    rowTransform,
+  }: FnOptions,
+): //
+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/chrome/ChromeApplicationSupport.ts

@@ -0,0 +1,10 @@
+import { join } from "path";
+import { HOME } from "../../global";
+
+export const chromeApplicationSupport: string = join(
+  HOME,
+  "Library",
+  "Application Support",
+  "Google",
+  "Chrome",
+);

package/src/browsers/chrome/ChromeCookieQueryStrategy.ts

@@ -0,0 +1,131 @@
+import CookieQueryStrategy from "../CookieQueryStrategy";
+import CookieRow, { isCookieRow } from "../../CookieRow";
+import ExportedCookie from "../../ExportedCookie";
+import { chromeApplicationSupport } from "./ChromeApplicationSupport";
+import { decrypt } from "./decrypt";
+import { env } from "../../global";
+import { findAllFiles } from "../../findAllFiles";
+import { getChromePassword } from "./getChromePassword";
+import { isExportedCookie } from "../../ExportedCookie";
+import { merge } from "lodash";
+import { parsedArgs } from "../../argv";
+import { flatMapAsync } from "../../util/flatMapAsync";
+import { getEncryptedChromeCookie } from "../getEncryptedChromeCookie";
+import logger from "../../logger";
+
+export const consola = logger.withTag("ChromeCookieQueryStrategy");
+
+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");
+    }
+    if (env.FIREFOX_ONLY) {
+      return [];
+    }
+    return getChromeCookies({
+      requireJwt: false,
+      name,
+      domain,
+    });
+  }
+}
+
+async function getPromise1(
+  name: string,
+  domain: string,
+  file: string,
+): Promise<CookieRow[]> {
+  try {
+    return await getEncryptedChromeCookie({
+      name: name,
+      domain: domain,
+      file: file,
+    });
+  } catch (e) {
+    if (parsedArgs.verbose) {
+      console.log("Error getting encrypted cookie", e);
+    }
+    return [];
+  }
+}
+
+async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
+  try {
+    const files: string[] = findAllFiles({
+      path: chromeApplicationSupport,
+      name: "Cookies",
+    });
+    const results1: CookieRow[] = await flatMapAsync(files, async (file) => {
+      return await getPromise1(name, domain, file);
+    });
+    return results1.filter(isCookieRow);
+  } catch (error) {
+    if (parsedArgs.verbose) {
+      console.log("error", error);
+    }
+    return [];
+  }
+}
+
+async function decryptValue(password: string, encryptedValue: Buffer) {
+  let d: string | null;
+  try {
+    d = await decrypt(password, encryptedValue);
+  } catch (e) {
+    if (parsedArgs.verbose) {
+      console.log("Error decrypting cookie", e);
+    }
+    d = null;
+  }
+  return d ?? encryptedValue.toString("utf-8");
+}
+
+async function getChromeCookies({
+  name,
+  domain = "%",
+  requireJwt = false,
+}: {
+  name: string;
+  domain: string;
+  requireJwt: boolean | undefined;
+  //
+}): //
+Promise<ExportedCookie[]> {
+  const encryptedDataItems: CookieRow[] = await getPromise(name, domain);
+  const password: string = await getChromePassword();
+  const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
+    .filter(({ value }) => value != null && value.length > 0)
+    .map(async (cookieRow: CookieRow) => {
+      const encryptedValue: Buffer = cookieRow.value;
+      const decryptedValue = await decryptValue(password, encryptedValue);
+      const meta = {};
+      merge(meta, cookieRow.meta ?? {});
+      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 (parsedArgs.verbose) {
+    console.log("results", results);
+  }
+  return results;
+}

package/src/browsers/chrome/decrypt.ts

@@ -0,0 +1,118 @@
+import { BinaryLike, createDecipheriv, pbkdf2 } from "crypto";
+import { parsedArgs } from "../../argv";
+import consola from "../../logger";
+
+// Function to decrypt encrypted data using a password
+export async function decrypt(
+  password: BinaryLike, // The password to use for decryption
+  encryptedData: Buffer, // The data to decrypt
+): Promise<string> {
+  // Returns a promise that resolves with the decrypted string
+  // Check if password is a string
+  if (typeof password !== "string") {
+    throw new Error("password must be a string: " + password);
+  }
+  let encryptedData1: any;
+  encryptedData1 = encryptedData;
+  // Check if encryptedData is an object
+  if (encryptedData1 == null || typeof encryptedData1 !== "object") {
+    throw new Error("encryptedData must be a object: " + encryptedData1);
+  }
+  // Check if encryptedData is a Buffer or an array of Buffers
+  if (!(encryptedData1 instanceof Buffer)) {
+    if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
+      [encryptedData1] = encryptedData1;
+      // Log if encryptedData is an array of buffers
+      if (parsedArgs.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);
+  }
+  // Log the password being used for decryption
+  if (parsedArgs.verbose) {
+    consola.start(`Trying to decrypt with password: ${password}`);
+  }
+  // Return a promise that resolves with the decrypted string
+  return new Promise((resolve, reject) => {
+    // Use pbkdf2 to derive a key from the password
+    pbkdf2(password, "saltysalt", 1003, 16, "sha1", (error, buffer) => {
+      try {
+        // Handle any errors from pbkdf2
+        if (error) {
+          if (parsedArgs.verbose) {
+            console.log("Error doing pbkdf2", error);
+          }
+          reject(error);
+          return;
+        }
+
+        // Check if the buffer length is 16
+        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;
+        }
+
+        // Create an initialization vector
+        const str = new Array(17).join(" ");
+        const iv = Buffer.from(str, "binary");
+        // Create a decipher using the derived key and initialization vector
+        const decipher = createDecipheriv("aes-128-cbc", buffer, iv);
+        decipher.setAutoPadding(false);
+
+        // Remove the first 3 bytes from the encrypted data
+        if (encryptedData1 && encryptedData1.slice) {
+          encryptedData1 = encryptedData1.slice(3);
+        }
+
+        // Check if the encrypted data length is a multiple of 16
+        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;
+        }
+
+        // Update the decipher with the encrypted data
+        let decoded = decipher.update(encryptedData1);
+        try {
+          // Finalize the decipher
+          decipher.final("utf-8");
+        } catch (e) {
+          if (parsedArgs.verbose) {
+            console.log("Error doing decipher.final()", e);
+          }
+          reject(e);
+          return;
+        }
+
+        // Remove padding from the decoded data
+        const padding = decoded[decoded.length - 1];
+        if (padding) {
+          decoded = decoded.slice(0, 0 - padding);
+        }
+        // Convert the decoded data to a string
+        const decodedString = decoded.toString("utf8");
+        // Resolve the promise with the decrypted string
+        resolve(decodedString);
+      } catch (e) {
+        // Reject the promise if there is an error
+        reject(e);
+      }
+    });
+  });
+}

package/src/browsers/chrome/getChromePassword.ts

@@ -0,0 +1,11 @@
+import { execSimple } from "../../execSimple";
+
+// top level so it's only called once and cached
+const chromePassword: Promise<string> =
+  process.platform == "darwin"
+    ? execSimple('security find-generic-password -w -s "Chrome Safe Storage"')
+    : Promise.reject(new Error("This only works on macOS"));
+
+export async function getChromePassword(): Promise<string> {
+  return await chromePassword;
+}

package/src/browsers/{FirefoxCookieQueryStrategy.ts → firefox/FirefoxCookieQueryStrategy.ts}

@@ -1,22 +1,24 @@
 import * as path from "path";
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import { env, HOME } from "../global";
+import CookieQueryStrategy from "../CookieQueryStrategy";
+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 { findAllFiles } from "../../findAllFiles";
+import ExportedCookie from "../../ExportedCookie";
+import CookieRow from "../../CookieRow";
+import CookieSpec from "../../CookieSpec";
+import { specialCases } from "../../SpecialCases";
+import { parsedArgs } from "../../argv";
+import { querySqliteThenTransform } from "../QuerySqliteThenTransform";
 
 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,29 +36,30 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   }
 
   async #getFirefoxCookie(
-    { name, domain }: CookieSpec //
+    { name, domain }: CookieSpec, //
   ) {
-    const files: string[] = await findAllFiles({
+    const files: string[] = findAllFiles({
       path: path.join(
         HOME,
         "Library",
         "Application Support",
         "Firefox",
-        "Profiles"
+        "Profiles",
       ),
       name: "cookies.sqlite",
     });
     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();
   }
 
   async #queryCookiesDb(
     file: string,
     name: string,
-    domain: string
+    domain: string,
   ): Promise<CookieRow[]> {
     if (file && !existsSync(file)) {
       throw new Error(`File ${file} does not exist`);
@@ -87,7 +90,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       };
     };
     try {
-      return await doSqliteQuery1({
+      return await querySqliteThenTransform({
         file,
         sql,
         rowTransform,

package/src/browsers/getEncryptedChromeCookie.ts

@@ -0,0 +1,87 @@
+import { chromeApplicationSupport } from "./chrome/ChromeApplicationSupport";
+import { querySqliteThenTransform } from "./QuerySqliteThenTransform";
+import { existsSync } from "fs";
+import { join } from "path";
+import { parsedArgs } from "../argv";
+import { stringToRegex } from "../StringToRegex";
+import CookieRow from "../CookieRow";
+import consola from "../logger";
+
+export async function getEncryptedChromeCookie({
+  name,
+  domain,
+  file = join(chromeApplicationSupport, "Default", "Cookies"),
+}: {
+  name: string;
+  domain: string;
+  file: string;
+}): Promise<CookieRow[]> {
+  if (!existsSync(file)) {
+    throw new Error(`File ${file} does not exist`);
+  }
+  if (parsedArgs.verbose) {
+    const s = file.split("/").slice(-3).join("/");
+    consola.start(
+      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`,
+    );
+  }
+  let sql;
+  //language=SQL
+  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;
+  // 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 we also need to query the domain, we add an AND operator to the SQL query
+      if (queryDomain) {
+        sql += ` AND `;
+      }
+    }
+    // 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}';`;
+    }
+  }
+  if (parsedArgs.verbose) {
+    consola.info("Querying:", sql);
+  }
+  const domainRegexp: RegExp = stringToRegex(domain);
+  const sqliteQuery1: CookieRow[] = await querySqliteThenTransform({
+    file: file,
+    sql: sql,
+    rowFilter: (row) => {
+      return row["host_key"].match(domainRegexp) != null;
+    },
+    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) {
+        consola.info("Found", cookieRow);
+      }
+      return cookieRow;
+    },
+  });
+  return sqliteQuery1.filter((row) => {
+    // TODO: is this needed?
+    return row.domain.match(domainRegexp) != null;
+  });
+}

package/src/browsers/index.ts

@@ -0,0 +1,12 @@
+export * from "./chrome/ChromeApplicationSupport";
+export * from "./chrome/ChromeCookieQueryStrategy";
+export * from "./CompositeCookieQueryStrategy";
+export * from "./CookieQueryStrategy";
+export * from "./CookieStoreQueryStrategy";
+export * from "./QuerySqliteThenTransform";
+export * from "./firefox/FirefoxCookieQueryStrategy";
+export * from "./mock/MockCookieQueryStrategy";
+export * from "./safari/SafariCookieQueryStrategy";
+export * from "./chrome/decrypt";
+export * from "./chrome/getChromePassword";
+export * from "./getEncryptedChromeCookie";

package/src/browsers/mock/MockCookieQueryStrategy.ts

@@ -0,0 +1,18 @@
+import ExportedCookie from "../../ExportedCookie";
+import CookieQueryStrategy from "../CookieQueryStrategy";
+
+export default class MockCookieQueryStrategy implements CookieQueryStrategy {
+  browserName: string = "mock";
+
+  private cookies: ExportedCookie[] = [];
+
+  constructor(cookies: ExportedCookie[]) {
+    this.cookies = cookies;
+  }
+
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    return this.cookies.filter((c) => {
+      return c.name === name && c.domain === domain;
+    });
+  }
+}

package/src/browsers/{SafariCookieQueryStrategy.ts → safari/SafariCookieQueryStrategy.ts}

@@ -1,10 +1,11 @@
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import ExportedCookie from "../ExportedCookie";
+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 [];
   }
 }