@mherod/get-cookie 2.1.3 → 4.0.2

package/src/browsers/chrome/decrypt.ts

@@ -1,154 +0,0 @@
-import { createDecipheriv, pbkdf2 } from "crypto";
-import { parsedArgs } from "../../argv";
-import consola from "../../logger";
-
-interface Decryptor {
-  decrypt(password: string, encryptedData: Buffer): Promise<string>;
-}
-
-class BufferDecryptor implements Decryptor {
-  async decrypt(password: string, encryptedData: Buffer): Promise<string> {
-    this.validatePassword(password);
-    const preparedData: Buffer =
-      this.validateAndPrepareEncryptedData(encryptedData);
-
-    if (parsedArgs.verbose) {
-      consola.start(`Trying to decrypt with password: ${password}`);
-    }
-
-    const decryptedData: string = await this.performDecryption(
-      password,
-      preparedData,
-    );
-
-    if (parsedArgs.verbose) {
-      consola.success(`Decryption successful: ${decryptedData}`);
-    }
-
-    return decryptedData;
-  }
-
-  private validatePassword(password: string): void {
-    if (typeof password !== "string") {
-      throw new Error("password must be a string: " + password);
-    }
-  }
-
-  private validateAndPrepareEncryptedData(encryptedData: Buffer): Buffer {
-    if (
-      encryptedData == null ||
-      !(
-        encryptedData instanceof Buffer ||
-        (Array.isArray(encryptedData) && Buffer.isBuffer(encryptedData[0]))
-      )
-    ) {
-      throw new Error(
-        "encryptedData must be a Buffer or an array of Buffers: " +
-          encryptedData,
-      );
-    }
-
-    if (Array.isArray(encryptedData) && Buffer.isBuffer(encryptedData[0])) {
-      encryptedData = encryptedData[0];
-      if (parsedArgs.verbose) {
-        consola.info(
-          `encryptedData is an array of buffers, selected first: ${encryptedData}`,
-        );
-      }
-    }
-
-    return Buffer.from(encryptedData);
-  }
-
-  private performDecryption(
-    password: string,
-    encryptedData: Buffer,
-  ): Promise<string> {
-    return new Promise((resolve, reject) => {
-      this.deriveKey(password)
-        .then((key) => this.decryptData(key, encryptedData))
-        .then((decrypted) => resolve(decrypted))
-        .catch((error) => reject(error));
-    });
-  }
-
-  private deriveKey(password: string): Promise<Buffer> {
-    return new Promise((resolve, reject) => {
-      pbkdf2(
-        password,
-        "saltysalt",
-        1003,
-        16,
-        "sha1",
-        (error: Error | null, buffer: Buffer) => {
-          if (error) {
-            this.logError("Error doing pbkdf2", error);
-            reject(error);
-            return;
-          }
-
-          if (buffer.length !== 16) {
-            this.logError(
-              "Error doing pbkdf2, buffer length is not 16",
-              buffer.length,
-            );
-            reject(new Error("Buffer length is not 16"));
-            return;
-          }
-
-          resolve(buffer);
-        },
-      );
-    });
-  }
-
-  private decryptData(key: Buffer, encryptedData: Buffer): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const iv: Buffer = Buffer.from(new Array(17).join(" "), "binary");
-      const decipher = createDecipheriv("aes-128-cbc", key, iv);
-      decipher.setAutoPadding(false);
-
-      const slicedData: Buffer = encryptedData.slice(3);
-
-      if (slicedData.length % 16 !== 0) {
-        this.logError(
-          "Error, encryptedData length is not a multiple of 16",
-          slicedData.length,
-        );
-        reject(new Error("encryptedData length is not a multiple of 16"));
-        return;
-      }
-
-      let decoded: Buffer = decipher.update(slicedData);
-      try {
-        decipher.final("utf-8");
-      } catch (e) {
-        this.logError("Error doing decipher.final()", e);
-        reject(e);
-        return;
-      }
-
-      const padding: number = decoded[decoded.length - 1];
-      if (padding) {
-        decoded = decoded.slice(0, 0 - padding);
-      }
-
-      resolve(decoded.toString("utf8"));
-    });
-  }
-
-  private logError(message: string, error: any): void {
-    if (parsedArgs.verbose) {
-      consola.error(message, error);
-    }
-  }
-}
-
-export const decryptor: Decryptor = new BufferDecryptor();
-
-export async function decrypt(
-  password: string,
-  encryptedData: Buffer,
-): Promise<string> {
-  return decryptor.decrypt(password, encryptedData);
-}

package/src/browsers/chrome/getChromePassword.ts

@@ -1,28 +0,0 @@
-import { execSimple } from "../../execSimple";
-
-interface PasswordRetriever {
-  retrievePassword(): Promise<string>;
-}
-
-class MacOSPasswordRetriever implements PasswordRetriever {
-  async retrievePassword(): Promise<string> {
-    return execSimple(
-      'security find-generic-password -w -s "Chrome Safe Storage"',
-    );
-  }
-}
-
-class UnsupportedPlatformPasswordRetriever implements PasswordRetriever {
-  async retrievePassword(): Promise<string> {
-    return Promise.reject(new Error("This only works on macOS"));
-  }
-}
-
-const passwordRetriever: PasswordRetriever =
-  process.platform == "darwin"
-    ? new MacOSPasswordRetriever()
-    : new UnsupportedPlatformPasswordRetriever();
-
-export async function getChromePassword(): Promise<string> {
-  return await passwordRetriever.retrievePassword();
-}

package/src/browsers/firefox/FirefoxCookieQueryStrategy.ts

@@ -1,109 +0,0 @@
-import * as path from "path";
-import CookieQueryStrategy from "../CookieQueryStrategy";
-import { HOME } from "../../global";
-import { existsSync } from "fs";
-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: string = "Firefox";
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    if (process.platform !== "darwin") {
-      // TODO: implement
-      return [];
-    }
-    if (parsedArgs.browser !== "firefox") {
-      return [];
-    }
-    const cookies: CookieRow[] = await this.getFirefoxCookie({ name, domain });
-    if (Array.isArray(cookies)) {
-      return cookies.map((cookie: CookieRow) => {
-        return {
-          domain: cookie.domain,
-          name: cookie.name,
-          value: Buffer.isBuffer(cookie.value)
-            ? cookie.value.toString("utf8")
-            : Buffer.from(cookie.value).toString("utf8"),
-        };
-      });
-    } else {
-      return [];
-    }
-  }
-
-  private async getFirefoxCookie(
-    { name, domain }: CookieSpec, //
-  ): Promise<CookieRow[]> {
-    if (!HOME) {
-      throw new Error("HOME environment variable is not set");
-    }
-    const files: string[] = findAllFiles({
-      path: path.join(
-        HOME,
-        "Library",
-        "Application Support",
-        "Firefox",
-        "Profiles",
-      ),
-      name: "cookies.sqlite",
-    });
-    const all: CookieRow[][] = await Promise.all(
-      files.map(async (file: string) => {
-        return await this.queryCookiesDb(file, name, domain);
-      }),
-    );
-    // flatten
-    return all.flat();
-  }
-
-  private async queryCookiesDb(
-    file: string,
-    name: string,
-    domain: string,
-  ): Promise<CookieRow[]> {
-    if (!existsSync(file)) {
-      throw new Error(`File ${file} does not exist`);
-    }
-    let sql: string;
-    //language=SQL
-    sql = "SELECT value, name, host FROM moz_cookies";
-    const { specifiedName, specifiedDomain } = specialCases({ name, domain });
-    if (specifiedName || specifiedDomain) {
-      sql += ` WHERE `;
-      if (specifiedName) {
-        sql += `name = '${name}'`;
-        if (specifiedDomain) {
-          sql += ` AND `;
-        }
-      }
-      if (specifiedDomain) {
-        sql += `host LIKE '${domain}';`;
-      }
-    }
-    const rowTransform = (row: any): CookieRow => {
-      // 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 querySqliteThenTransform({
-        file,
-        sql,
-        rowTransform,
-      });
-    } catch (e) {
-      console.error(`Error querying ${file}`, e);
-      return [];
-    }
-  }
-}

package/src/browsers/getEncryptedChromeCookie.ts

@@ -1,122 +0,0 @@
-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";
-
-interface GetEncryptedChromeCookieParams {
-  name: string;
-  domain: string;
-  file?: string;
-}
-
-interface SqlQueryBuilderInterface {
-  build(): string;
-  addCondition(field: string, value: string, operator?: string): void;
-}
-
-class SqlQueryBuilder implements SqlQueryBuilderInterface {
-  private baseQuery: string;
-  private conditions: string[];
-
-  constructor(
-    baseQuery: string = "SELECT encrypted_value, name, host_key, expires_utc FROM cookies",
-  ) {
-    this.baseQuery = baseQuery;
-    this.conditions = [];
-  }
-
-  addCondition(field: string, value: string, operator: string = "="): void {
-    const wildcardRegexp = /^([*%])$/i;
-    if (!wildcardRegexp.test(value)) {
-      const condition = `${field} ${operator} '${value}'`;
-      this.conditions.push(condition);
-    }
-  }
-
-  build(): string {
-    let sql = this.baseQuery;
-    if (this.conditions.length > 0) {
-      sql += ` WHERE ${this.conditions.join(" AND ")}`;
-    }
-    return sql;
-  }
-}
-
-interface LoggerInterface {
-  log(file: string, name: string, domain: string, sql: string): void;
-}
-
-class VerboseLogger implements LoggerInterface {
-  log(file: string, name: string, domain: string, sql: string): void {
-    if (parsedArgs.verbose) {
-      const s = file.split("/").slice(-3).join("/");
-      consola.start(
-        `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`,
-      );
-    }
-  }
-}
-
-interface RowTransformerInterface {
-  transform(row: any): CookieRow;
-}
-
-class RowTransformer implements RowTransformerInterface {
-  transform(row: any): CookieRow {
-    const cookieRow: CookieRow = {
-      expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
-      domain: row["host_key"],
-      name: row["name"],
-      value: row["encrypted_value"],
-    };
-    return cookieRow;
-  }
-}
-
-export async function getEncryptedChromeCookie({
-  name,
-  domain,
-  file = join(chromeApplicationSupport, "Default", "Cookies"),
-}: GetEncryptedChromeCookieParams): Promise<CookieRow[]> {
-  if (!existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
-  }
-
-  const sqlQueryBuilder: SqlQueryBuilderInterface = new SqlQueryBuilder();
-  sqlQueryBuilder.addCondition("name", name);
-  const wildcardDomain = /[%*]/.test(domain);
-  if (!wildcardDomain) {
-    const sqlEmbedDomain = domain.replace(/^[.%]?/, "%");
-    sqlQueryBuilder.addCondition("host_key", sqlEmbedDomain, "LIKE");
-  }
-  const sql: string = sqlQueryBuilder.build();
-
-  const verboseLogger: LoggerInterface = new VerboseLogger();
-  verboseLogger.log(file, name, domain, sql);
-
-  const domainRegexp: RegExp = stringToRegex(domain);
-  const rowTransformer: RowTransformerInterface = new RowTransformer();
-  let sqliteQuery1: CookieRow[];
-  try {
-    sqliteQuery1 = await querySqliteThenTransform({
-      file: file,
-      sql: sql,
-      rowFilter: (row) => {
-        return row["host_key"].match(domainRegexp) != null;
-      },
-      rowTransform: rowTransformer.transform.bind(rowTransformer),
-    });
-  } catch (error) {
-    throw error;
-  }
-
-  const filteredResults = sqliteQuery1.filter((row) => {
-    return row.domain.match(domainRegexp) != null;
-  });
-
-  return filteredResults;
-}

package/src/browsers/index.ts

@@ -1,12 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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[]> {
-    const filteredCookies: ExportedCookie[] = [];
-    for (const cookie of this.cookies) {
-      if (cookie.name === name && cookie.domain === domain) {
-        filteredCookies.push(cookie);
-      }
-    }
-    return filteredCookies;
-  }
-}

package/src/browsers/safari/SafariCookieQueryStrategy.ts

@@ -1,42 +0,0 @@
-import CookieQueryStrategy from "../CookieQueryStrategy";
-import ExportedCookie from "../../ExportedCookie";
-import { join } from "path";
-import { decodeBinaryCookies } from "../../decodeBinaryCookies"; // Assuming you have a module to decode binary cookies
-import CookieRow from "../../CookieRow";
-
-export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
-  browserName: string = "Safari";
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    const homeDir: string | undefined = process.env.HOME;
-    if (!homeDir) {
-      throw new Error("HOME environment variable is not set");
-    }
-
-    const cookieDbPath: string = join(
-      homeDir,
-      "Library",
-      "Cookies",
-      "Cookies.binarycookies",
-    );
-
-    try {
-      const cookies: CookieRow[] = await decodeBinaryCookies(cookieDbPath);
-
-      const filteredCookies: CookieRow[] = cookies.filter(
-        (cookie: CookieRow) => cookie.name === name && cookie.domain.includes(domain)
-      );
-
-      const exportedCookies: ExportedCookie[] = filteredCookies.map((cookie: CookieRow) => ({
-        domain: cookie.domain,
-        name: cookie.name,
-        value: cookie.value.toString("utf8"),
-      }));
-
-      return exportedCookies;
-    } catch (e) {
-      console.error(`Error decoding ${cookieDbPath}`, e);
-      return [];
-    }
-  }
-}

package/src/cli.ts

@@ -1,94 +0,0 @@
-#!/usr/bin/env bun
-
-import { argv, parsedArgs } from "./argv";
-import { fetchWithCookies } from "./fetchWithCookies";
-import { unpackHeaders } from "./unpackHeaders";
-import CookieSpec from "./CookieSpec";
-import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
-import logger from "./logger";
-import { cliQueryCookies } from "./cliQueryCookies";
-
-async function main() {
-  if (parsedArgs["help"] || parsedArgs["h"]) {
-    logger.log(`Usage: ${argv[1]} [name] [domain] [options]`);
-    logger.log(`Options:`);
-    logger.log(`  -h, --help: Show this help message`);
-    logger.log(`  -v, --verbose: Enable verbose output`);
-    logger.log(`  -d, --dump: Dump all results`);
-    logger.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
-    logger.log(`  -r, --render: Render all results`);
-    logger.log(`  -F, --fetch <url>: Fetch data from the specified URL`);
-    logger.log(`  -H <header>: Specify headers for the fetch request`);
-    logger.log(
-      `  --dump-response-headers: Dump response headers from fetch request`,
-    );
-    logger.log(`  --dump-response-body: Dump response body from fetch request`);
-    return;
-  }
-
-  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
-
-  const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
-  if (fetchUrl) {
-    let url: URL;
-    try {
-      url = new URL(fetchUrl);
-    } catch (e) {
-      logger.error("Invalid URL", fetchUrl);
-      return;
-    }
-    logger.start("Fetching", url.href);
-    const headerArgs: string[] | string = parsedArgs["H"];
-    const headers = unpackHeaders(headerArgs);
-    const onfulfilled = async (res: Response) => {
-      if (parsedArgs["dump-response-headers"]) {
-        for (const [key, value] of Object.entries(res.headers)) {
-          logger.log(`${key}: ${value}`);
-        }
-      }
-      if (parsedArgs["dump-response-body"]) {
-        const responseBody = await res.text();
-        logger.log(responseBody);
-      }
-    };
-    try {
-      const res = await fetchWithCookies(url, { headers });
-      logger.debug("Response", res);
-      await onfulfilled(res);
-    } catch (error) {
-      logger.error(error);
-    }
-    return;
-  }
-
-  const cookieSpecs: CookieSpec[] = [];
-  const argUrl: string = parsedArgs["url"] || parsedArgs["u"];
-  if (argUrl) {
-    for (const cookieSpec of cookieSpecsFromUrl(argUrl)) {
-      cookieSpecs.push(cookieSpec);
-    }
-  } else {
-    cookieSpecs.push({
-      name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
-      domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
-    });
-  }
-
-  if (parsedArgs.verbose) {
-    logger.log("cookieSpecs", cookieSpecs);
-  }
-
-  try {
-    await cliQueryCookies(cookieSpecs);
-  } catch (error) {
-    logger.error(error);
-  }
-}
-
-main().then(
-  () => process.exit(0),
-  (error) => {
-    logger.error(error);
-    process.exit(1);
-  },
-);

package/src/cliQueryCookies.ts

@@ -1,65 +0,0 @@
-import CookieSpec from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
-import { groupBy } from "lodash";
-import logger from "./logger";
-import { parsedArgs } from "./argv";
-import { resultsRendered } from "./resultsRendered";
-
-export async function cliQueryCookies(
-  cookieSpec: CookieSpec | CookieSpec[],
-  limit?: number,
-  removeExpired?: boolean,
-) {
-  try {
-    const results: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec, {
-      limit,
-      removeExpired,
-    });
-
-    if (!results || results.length === 0) {
-      logger.error("No results");
-      return;
-    }
-
-    if (parsedArgs["dump"] || parsedArgs["d"]) {
-      logger.log(results);
-      return;
-    }
-
-    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      logger.log(JSON.stringify(groupedByFile, null, 2));
-      return;
-    }
-
-    if (
-      parsedArgs["render"] ||
-      parsedArgs["render-merged"] ||
-      parsedArgs["r"]
-    ) {
-      logger.log(resultsRendered(results));
-      return;
-    }
-
-    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      for (const file of Object.keys(groupedByFile)) {
-        const fileResults = groupedByFile[file];
-        logger.log(`${file}: ${resultsRendered(fileResults)}`);
-      }
-      return;
-    }
-
-    if (parsedArgs["output"] === "json") {
-      logger.log(JSON.stringify(results, null, 2));
-      return;
-    }
-
-    for (const result of results) {
-      logger.log(result.value);
-    }
-  } catch (e) {
-    logger.error(e);
-  }
-}