@mherod/get-cookie 2.1.1 → 2.1.2

package/src/browsers/getEncryptedChromeCookie.ts

@@ -7,81 +7,116 @@ import { stringToRegex } from "../StringToRegex";
 import CookieRow from "../CookieRow";
 import consola from "../logger";
 
-export async function getEncryptedChromeCookie({
-  name,
-  domain,
-  file = join(chromeApplicationSupport, "Default", "Cookies"),
-}: {
+interface GetEncryptedChromeCookieParams {
   name: string;
   domain: string;
-  file: string;
-}): Promise<CookieRow[]> {
-  if (!existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
+  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 = [];
   }
-  if (parsedArgs.verbose) {
-    const s = file.split("/").slice(-3).join("/");
-    consola.start(
-      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`,
-    );
+
+  addCondition(field: string, value: string, operator: string = "="): void {
+    const wildcardRegexp = /^([*%])$/i;
+    if (!wildcardRegexp.test(value)) {
+      const condition = `${field} ${operator} '${value}'`;
+      this.conditions.push(condition);
+    }
   }
-  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 `;
-      }
+
+  build(): string {
+    let sql = this.baseQuery;
+    if (this.conditions.length > 0) {
+      sql += ` WHERE ${this.conditions.join(" 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}';`;
+    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}`,
+      );
     }
   }
-  if (parsedArgs.verbose) {
-    consola.info("Querying:", sql);
+}
+
+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 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?
+  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/mock/MockCookieQueryStrategy.ts

@@ -4,15 +4,19 @@ import CookieQueryStrategy from "../CookieQueryStrategy";
 export default class MockCookieQueryStrategy implements CookieQueryStrategy {
   browserName: string = "mock";
 
-  private cookies: ExportedCookie[] = [];
+  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;
-    });
+    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,11 +1,42 @@
 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 = "Safari";
+  browserName: string = "Safari";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    // TODO: implement
-    return [];
+    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,4 +1,4 @@
-#!/usr/bin/env ts-node
+#!/usr/bin/env bun
 
 import { argv, parsedArgs } from "./argv";
 import { fetchWithCookies } from "./fetchWithCookies";
@@ -10,13 +10,19 @@ import { cliQueryCookies } from "./cliQueryCookies";
 
 async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
-    logger.log(`Usage: ${argv[1]} [name] [domain] [options] `);
+    logger.log(`Usage: ${argv[1]} [name] [domain] [options]`);
     logger.log(`Options:`);
-    logger.log(`  -h, --help: Show this help`);
-    logger.log(`  -v, --verbose: Show verbose output`);
+    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;
   }
 
@@ -26,7 +32,7 @@ async function main() {
   if (fetchUrl) {
     let url: URL;
     try {
-      url = new URL(<string>fetchUrl);
+      url = new URL(fetchUrl);
     } catch (e) {
       logger.error("Invalid URL", fetchUrl);
       return;
@@ -34,34 +40,25 @@ async function main() {
     logger.start("Fetching", url.href);
     const headerArgs: string[] | string = parsedArgs["H"];
     const headers = unpackHeaders(headerArgs);
-    const onfulfilled = (res: Response) => {
+    const onfulfilled = async (res: Response) => {
       if (parsedArgs["dump-response-headers"]) {
-        res.headers.forEach((value: string, key: string) => {
+        for (const [key, value] of Object.entries(res.headers)) {
           logger.log(`${key}: ${value}`);
-        });
+        }
       }
       if (parsedArgs["dump-response-body"]) {
-        res.text().then((r) => {
-          logger.log(r);
-        });
+        const responseBody = await res.text();
+        logger.log(responseBody);
       }
-      return;
     };
-    return fetchWithCookies(
-      url,
-      {
-        //
-        headers,
-      },
-      //
-    ).then(
-      (res) => {
-        logger.debug("Response", res);
-        onfulfilled(res);
-      },
-      logger.error,
-      //
-    );
+    try {
+      const res = await fetchWithCookies(url, { headers });
+      logger.debug("Response", res);
+      await onfulfilled(res);
+    } catch (error) {
+      logger.error(error);
+    }
+    return;
   }
 
   const cookieSpecs: CookieSpec[] = [];
@@ -81,7 +78,17 @@ async function main() {
     logger.log("cookieSpecs", cookieSpecs);
   }
 
-  await cliQueryCookies(cookieSpecs).catch(logger.error);
+  try {
+    await cliQueryCookies(cookieSpecs);
+  } catch (error) {
+    logger.error(error);
+  }
 }
 
-main().then((r) => r, logger.error);
+main().then(
+  () => process.exit(0),
+  (error) => {
+    logger.error(error);
+    process.exit(1);
+  },
+);

package/src/cliQueryCookies.ts

@@ -10,26 +10,29 @@ export async function cliQueryCookies(
   cookieSpec: CookieSpec | CookieSpec[],
   limit?: number,
   removeExpired?: boolean,
-  //
 ) {
   try {
     const results: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec, {
       limit,
       removeExpired,
     });
-    if (results == null || results.length == 0) {
+
+    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"] ||
@@ -38,14 +41,21 @@ export async function cliQueryCookies(
       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)) {
-        let results = groupedByFile[file];
-        logger.log(file, ": ", resultsRendered(results));
+        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);
     }

package/src/comboQueryCookieSpec.ts

@@ -12,18 +12,15 @@ export async function comboQueryCookieSpec(
 ): Promise<ExportedCookie[]> {
   const optsWithDefaults: CookieQueryOptions<CookieQueryStrategy> =
     mergedWithDefaults(options);
-  const fn = (cs: CookieSpec) => queryCookies(cs, optsWithDefaults);
+  const queryFn = async (cs: CookieSpec): Promise<ExportedCookie[]> =>
+    queryCookies(cs, optsWithDefaults);
 
+  let cookies: ExportedCookie[];
   if (Array.isArray(cookieSpec)) {
-    const cookiesForMultiSpec: ExportedCookie[] = await flatMapAsync(
-      cookieSpec,
-      async (cs: CookieSpec) => {
-        return await fn(cs);
-      },
-    );
-    return processBeforeReturn(cookiesForMultiSpec, options);
+    cookies = await flatMapAsync(cookieSpec, queryFn);
   } else {
-    const cookiesForSingleSpec: ExportedCookie[] = await fn(cookieSpec);
-    return processBeforeReturn(cookiesForSingleSpec, options);
+    cookies = await queryFn(cookieSpec);
   }
+
+  return processBeforeReturn(cookies, options);
 }

package/src/cookieQueryOptions.ts

@@ -11,10 +11,17 @@ export type CookieQueryOptions<T extends CookieQueryStrategy> = {
 export const defaultCookieQueryOptions: CookieQueryOptions<CookieQueryStrategy> =
   {
     strategy: new CompositeCookieQueryStrategy(),
+    limit: undefined,
+    removeExpired: undefined,
   };
 
 export function mergedWithDefaults<T extends CookieQueryStrategy>(
   options?: CookieQueryOptions<T>,
 ): CookieQueryOptions<T> {
-  return merge(defaultCookieQueryOptions, options);
+  const mergedOptions: CookieQueryOptions<T> = merge(
+    {},
+    defaultCookieQueryOptions,
+    options,
+  );
+  return mergedOptions;
 }

package/src/cookieSpecsFromUrl.ts

@@ -13,15 +13,61 @@ export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
     return [];
   }
 
-  const urlObj = typeof url === "string" ? new URL(url) : url;
-  const hostnameParts = urlObj.hostname.split(".");
-  const topLevelDomain = hostnameParts.slice(-2).join(".");
+  const urlObj: URL = parseUrl(url);
+  const hostnameParts: string[] = splitHostname(urlObj.hostname);
+  const topLevelDomain: string = getTopLevelDomain(hostnameParts);
 
-  const cookieSpecs: CookieSpec[] = [
+  const cookieSpecs: CookieSpec[] = createCookieSpecs(
+    urlObj.hostname,
+    topLevelDomain,
+  );
+
+  return uniqBy(
+    cookieSpecs,
+    (spec: CookieSpec) => `${spec.name}:${spec.domain}`,
+  );
+}
+
+/**
+ * Parses the input URL string or URL object and returns a URL object.
+ * @param url - The URL to parse.
+ * @returns A URL object.
+ */
+function parseUrl(url: URL | string): URL {
+  return typeof url === "string" ? new URL(url) : url;
+}
+
+/**
+ * Splits the hostname into its constituent parts.
+ * @param hostname - The hostname to split.
+ * @returns An array of strings representing the parts of the hostname.
+ */
+function splitHostname(hostname: string): string[] {
+  return hostname.split(".");
+}
+
+/**
+ * Extracts the top-level domain from the hostname parts.
+ * @param hostnameParts - The parts of the hostname.
+ * @returns A string representing the top-level domain.
+ */
+function getTopLevelDomain(hostnameParts: string[]): string {
+  return hostnameParts.slice(-2).join(".");
+}
+
+/**
+ * Creates cookie specifications based on the hostname and top-level domain.
+ * @param hostname - The full hostname.
+ * @param topLevelDomain - The top-level domain.
+ * @returns An array of CookieSpec objects.
+ */
+function createCookieSpecs(
+  hostname: string,
+  topLevelDomain: string,
+): CookieSpec[] {
+  return [
     { name: "%", domain: `%.${topLevelDomain}` },
-    { name: "%", domain: urlObj.hostname },
+    { name: "%", domain: hostname },
     { name: "%", domain: topLevelDomain },
   ];
-
-  return uniqBy(cookieSpecs, JSON.stringify);
 }

package/src/decodeBinaryCookies.ts

@@ -0,0 +1,72 @@
+import CookieRow from "./CookieRow";
+import fs from "fs/promises";
+
+export const decodeBinaryCookies = async (cookieDbPath: string): Promise<CookieRow[]> => {
+  try {
+    // Check if file exists
+    await fs.access(cookieDbPath);
+  } catch {
+    // If file doesn't exist, return empty array
+    return [];
+  }
+
+  // Magic bytes: "COOK" = 0x636F6F6B
+  const magicBytes: Buffer = Buffer.from([0x63, 0x6F, 0x6B, 0x6B]);
+  const buffer: Buffer = await fs.readFile(cookieDbPath);
+
+  if (!buffer.slice(0, 4).equals(magicBytes)) {
+    throw new Error("Not a cookie file");
+  }
+
+  const count: number = buffer.readUInt32BE(4);
+  const cookies: CookieRow[] = [];
+
+  let offset: number = 8;
+  for (let i: number = 0; i < count; i++) {
+    const pageSize: number = buffer.readUInt32BE(offset);
+    offset += 4;
+    const page: Buffer = buffer.slice(offset, offset + pageSize);
+    offset += pageSize;
+
+    if (!page.slice(0, 4).equals(Buffer.from([0x00, 0x00, 0x01, 0x00]))) {
+      throw new Error("Bad page header");
+    }
+
+    const cookieCount: number = page.readUInt32LE(4);
+    let pageOffset: number = 8;
+    for (let j: number = 0; j < cookieCount; j++) {
+      const cookieOffset: number = page.readUInt32LE(pageOffset);
+      pageOffset += 4;
+      const cookieLength: number = page.readUInt32LE(cookieOffset);
+      const cookie: Buffer = page.slice(cookieOffset, cookieOffset + cookieLength);
+
+      const flags: number = cookie.readUInt32LE(8);
+      const urlOffset: number = cookie.readUInt32LE(16);
+      const nameOffset: number = cookie.readUInt32LE(20);
+      const valueOffset: number = cookie.readUInt32LE(28);
+      const expiry: number = cookie.readDoubleLE(40) + 978307200;
+
+      const url: string = cookie.slice(urlOffset, nameOffset).toString('utf8').replace(/\0/g, '');
+      const name: string = cookie.slice(nameOffset, valueOffset).toString('utf8').replace(/\0/g, '');
+      const value: string = cookie.slice(valueOffset, cookie.length).toString('utf8').replace(/\0/g, '');
+
+      cookies.push({
+        domain: url,
+        name: name,
+        value: Buffer.from(value, 'utf8'),
+        expiry: new Date(expiry * 1000).getTime(),
+        meta: {
+          path: cookie.slice(cookie.readUInt32LE(24), valueOffset).toString('utf8').replace(/\0/g, ''),
+          httpOnly: (flags & 0x04) === 0x04,
+          secure: (flags & 0x01) === 0x01
+        }
+      });
+    }
+
+    if (!page.slice(cookieCount * 4 + 8, cookieCount * 4 + 12).equals(Buffer.from([0x00, 0x00, 0x00, 0x00]))) {
+      throw new Error("Bad page trailer");
+    }
+  }
+
+  return cookies;
+};

package/src/execSimple.ts

@@ -1,7 +1,6 @@
-import { execSync } from "child_process";
-
 export async function execSimple(command: string): Promise<string> {
   try {
+    const { execSync } = await import("child_process");
     const stdout = execSync(command, {
       encoding: "binary",
       maxBuffer: 5 * 1024,