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

package/src/browsers/decrypt.ts

@@ -0,0 +1,118 @@
+import { BinaryLike, createDecipheriv, pbkdf2 } from "crypto";
+import { parsedArgs } from "../argv";
+import consola from "consola";
+
+// 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/getChromePassword.ts

@@ -0,0 +1,9 @@
+import { execSimple } from "../execSimple";
+
+const chromePassword: Promise<string> = execSimple(
+  'security find-generic-password -w -s "Chrome Safe Storage"'
+);
+
+export async function getChromePassword(): Promise<string> {
+  return await chromePassword;
+}

package/src/cli.ts

@@ -1,31 +1,30 @@
-#!/usr/bin/env node
+#!/usr/bin/env ts-node
 
-import minimist from "minimist";
-import { argv } from "./argv";
-import { queryCookies } from "./queryCookies";
+import { argv, parsedArgs } from "./argv";
 import { groupBy } from "lodash";
 import { green, red, yellow } from "colorette";
 import { resultsRendered } from "./resultsRendered";
 import { fetchWithCookies } from "./fetchWithCookies";
 import { unpackHeaders } from "./unpackHeaders";
 import CookieSpec from "./CookieSpec";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
+import logger from "./logger";
 
-const parsedArgs: minimist.ParsedArgs = minimist(argv.slice(2));
-
-async function cliQueryCookies({ name, domain }: CookieSpec) {
+async function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[]) {
   try {
-    const results = await queryCookies({ name, domain });
+    const results = await comboQueryCookieSpec(cookieSpec);
     if (results == null || results.length == 0) {
-      console.error(red("No results"));
+      logger.error(red("No results"));
       return;
     }
     if (parsedArgs["dump"] || parsedArgs["d"]) {
-      console.log(results);
+      logger.log(results);
       return;
     }
     if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
       const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      console.log(green(JSON.stringify(groupedByFile, null, 2)));
+      logger.log(green(JSON.stringify(groupedByFile, null, 2)));
       return;
     }
     if (
@@ -33,62 +32,65 @@ async function cliQueryCookies({ name, domain }: CookieSpec) {
       parsedArgs["render-merged"] ||
       parsedArgs["r"]
     ) {
-      console.log(yellow(resultsRendered(results)));
+      logger.log(yellow(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];
-        console.log(green(file) + ": ", yellow(resultsRendered(results)));
+        logger.log(green(file) + ": ", yellow(resultsRendered(results)));
       }
       return;
     }
     for (const result of results) {
-      console.log(result.value);
+      logger.log(result.value);
     }
   } catch (e) {
-    console.error(e);
+    logger.error(e);
   }
 }
 
-function main() {
+async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
-    console.log(`Usage: ${argv[1]} [name] [domain] [options] `);
-    console.log(`Options:`);
-    console.log(`  -h, --help: Show this help`);
-    console.log(`  -v, --verbose: Show verbose output`);
-    console.log(`  -d, --dump: Dump all results`);
-    console.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
-    console.log(`  -r, --render: Render all results`);
+    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(`  -d, --dump: Dump all results`);
+    logger.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
+    logger.log(`  -r, --render: Render all results`);
     return;
   }
 
+  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
+
   const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
   if (fetchUrl) {
     let url: URL;
     try {
       url = new URL(<string>fetchUrl);
     } catch (e) {
-      console.error("Invalid URL", fetchUrl);
+      logger.error("Invalid URL", fetchUrl);
       return;
     }
+    logger.start("Fetching", url.href);
     const headerArgs: string[] | string = parsedArgs["H"];
     const headers = unpackHeaders(headerArgs);
     const onfulfilled = (res: Response) => {
       if (parsedArgs["dump-response-headers"]) {
         res.headers.forEach((value: string, key: string) => {
-          console.log(`${key}: ${value}`);
+          logger.log(`${key}: ${value}`);
         });
       }
       if (parsedArgs["dump-response-body"]) {
         res.text().then((r) => {
-          console.log(r);
+          logger.log(r);
         });
       }
       return;
     };
-    fetchWithCookies(
+    return fetchWithCookies(
       url,
       {
         //
@@ -96,19 +98,33 @@ function main() {
       }
       //
     ).then(
-      onfulfilled,
-      console.error
+      (res) => {
+        logger.debug("Response", res);
+        onfulfilled(res);
+      },
+      logger.error
       //
     );
-    return;
   }
 
-  const cookieSpec: CookieSpec = {
-    name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
-    domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
-  };
+  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);
+  }
 
-  cliQueryCookies(cookieSpec).catch(console.error);
+  await cliQueryCookies(cookieSpecs).catch(logger.error);
 }
 
-main();
+main().then((r) => r, logger.error);

package/src/comboQueryCookieSpec.ts

@@ -0,0 +1,24 @@
+import { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import { uniqBy } from "lodash";
+
+export async function comboQueryCookieSpec(
+  cookieSpec: MultiCookieSpec
+): Promise<ExportedCookie[]> {
+  const cookies: ExportedCookie[] = [];
+  if (Array.isArray(cookieSpec)) {
+    const results: Awaited<ExportedCookie[]>[] = await Promise.all(
+      cookieSpec.map((cs) => {
+        return queryCookies(cs);
+      })
+    );
+    for (const exportedCookie of results.flat()) {
+      cookies.push(exportedCookie);
+    }
+  } else {
+    const singleQuery: ExportedCookie[] = await queryCookies(cookieSpec);
+    cookies.push(...singleQuery);
+  }
+  return uniqBy(cookies, JSON.stringify);
+}

package/src/cookieSpecsFromUrl.ts

@@ -0,0 +1,26 @@
+import CookieSpec from "./CookieSpec";
+import { uniqBy } from "lodash";
+
+export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
+  const url1 = typeof url == "string" ? new URL(url) : url;
+  const cookieSpecs = [];
+  const splits = url1.hostname.split(".");
+  const tld = splits.slice(-2).join(".");
+  const cookieSpec: CookieSpec = {
+    name: "%",
+    domain: "%." + tld,
+  };
+  cookieSpecs.push(cookieSpec);
+  const cookieSpec1: CookieSpec = {
+    name: "%",
+    domain: url1.hostname,
+  };
+  cookieSpecs.push(cookieSpec1);
+  // const isWww = splits.slice(-3)[0] === "www";
+  const cookieSpec2: CookieSpec = {
+    name: "%",
+    domain: tld,
+  };
+  cookieSpecs.push(cookieSpec2);
+  return uniqBy(cookieSpecs, JSON.stringify);
+}

package/src/execSimple.ts

@@ -0,0 +1,13 @@
+import { execSync } from "child_process";
+
+export async function execSimple(command: string): Promise<string> {
+  try {
+    const stdout = execSync(command, {
+      encoding: "binary",
+      maxBuffer: 5 * 1024,
+    });
+    return stdout.trim();
+  } catch (error) {
+    throw error;
+  }
+}

package/src/fetchWithCookies.ts

@@ -1,62 +1,129 @@
-// noinspection JSUnusedGlobalSymbols
+// noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
 
 import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
+import { cookieJarPromise } from "./CookieStore";
+import UserAgent from "user-agents";
+import { parsedArgs } from "./argv";
+import { blue, redBright, yellow } from "colorette";
+import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 import CookieSpec from "./CookieSpec";
-import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
-import { cookieJar } from "./MemoryCookieStore";
+import consola from "consola";
+
+if (typeof fetchImpl !== "function") {
+  consola.error("fetch is not a function");
+  throw new Error("fetch is not a function");
+}
+
+const userAgent = new UserAgent().toString();
+
+interface FetchRequestInit {
+  url: RequestInfo | URL | string;
+  options?: RequestInit;
+}
 
 export async function fetchWithCookies(
-  url: RequestInfo | URL,
+  url: RequestInfo | URL | string,
   options: RequestInit | undefined = {},
-  fetch: Function = fetchImpl
+  fetch: Function = fetchImpl as Function,
+  originalRequest: FetchRequestInit | undefined = undefined
 ): Promise<Response> {
+  if (typeof fetch !== "function") {
+    const message = "fetch is not a function";
+    consola.error(message);
+    throw new Error(message);
+  }
+  const originalRequest1 = originalRequest || { url, options };
+  const headers: HeadersInit = {
+    "User-Agent": userAgent,
+  };
   const defaultOptions: RequestInit = {
-    headers: {
-      "User-Agent":
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
-    },
+    headers,
     redirect: "manual",
   };
   const url2: string = `${url}`;
   const url1: URL = new URL(url2);
-  const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
-    return `%${p1}`;
-  });
-  const cookieSpec: CookieSpec = {
-    name: "%",
-    domain: domain,
-  };
-  const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
-    () => []
+  consola.start("fetchWithCookies", url2);
+  const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url1);
+  headers["Cookie"] = await getMergedRenderedCookies(cookieSpecs).catch(
+    (err) => {
+      consola.error(err);
+      return "";
+    }
   );
-  const cookie = cookies.pop();
-  const newOptions1: RequestInit = merge(defaultOptions, options, {
-    headers: {
-      Cookie: cookie,
-    },
-  });
+  if (parsedArgs["dump-request-headers"]) {
+    consola.info(redBright("Request URL:"), url1.href);
+    consola.info(blue("Request headers:"), headers);
+  }
+  const newOptions1: RequestInit = merge(defaultOptions, { headers }, options);
   try {
-    const res: Response = await fetch(url2, newOptions1);
+    const res: Response = await fetch(url1, newOptions1);
+    // noinspection JSMismatchedCollectionQueryUpdate
     const headers: [string, string][] = [];
     res.headers.forEach((value, key) => {
       headers.push([key, value]);
     });
-    for (const [key, value] of headers) {
-      if (key === "set-cookie") {
-        await cookieJar.setCookie(value, url2);
-        // const cookie = tough.parse(value);
-        // if (cookie instanceof Cookie) {
-        //   await memoryCookieStore.putCookie(cookie);
-        // }
+    // for (const [key, value] of headers) {
+    //   if (key === "set-cookie") {
+    //     const cookieJar1 = await cookieJarPromise;
+    //     await cookieJar1.setCookie(value, url2);
+    //     if (parsedArgs.verbose) {
+    //       console.log(blue(`Set-Cookie:`), yellow(value), yellow(url2));
+    //     }
+    //   }
+    // }
+
+    const newUrl: string = res.headers.get("location") ?? res.url;
+    // const sameHost = new URL(newUrl).host === url1.host;
+    if (res.status == 301 || res.status == 302) {
+      // follow the redirect
+      if (newUrl && newUrl !== url2) {
+        if (parsedArgs.verbose || parsedArgs["dump-response-headers"]) {
+          console.log(blue(`Redirected to `), yellow(newUrl));
+        }
+        return fetchWithCookies(
+          //
+          newUrl,
+          newOptions1,
+          fetch,
+          originalRequest1
+          //
+        );
       }
     }
-
-    const newUrl: string = res.headers.get("location") as string;
-    if (res.redirected || (newUrl && newUrl !== url2)) {
-      return fetchWithCookies(newUrl, newOptions1);
+    if (res.status == 303 && newUrl && newUrl !== url2) {
+      // follow the redirect with GET
+      let newOptions2: RequestInit = {};
+      switch (newOptions1.method) {
+        case "POST":
+        case "PUT":
+        case "DELETE":
+          merge(newOptions2, newOptions1, { method: "GET" });
+          newOptions2.body = undefined; // TODO: is this needed?
+          break;
+        case "HEAD":
+        case "GET":
+          merge(newOptions2, newOptions1);
+          newOptions2.body = undefined; // TODO: is this needed?
+          break;
+        default:
+          merge(newOptions2, newOptions1);
+          break;
+      }
+      if (parsedArgs.verbose) {
+        console.log(blue(`Redirected to `), yellow(newUrl));
+      }
+      return fetchWithCookies(
+        //
+        newUrl,
+        newOptions2,
+        fetch,
+        originalRequest1
+        //
+      );
     }
 
     const arrayBuffer1: Promise<ArrayBuffer> = res.arrayBuffer();
@@ -70,11 +137,11 @@ export async function fetchWithCookies(
     }
 
     async function text(): Promise<string> {
-      return buffer().then((buffer) => buffer.toString("utf8"));
+      return buffer().then((buffer: Buffer) => buffer.toString("utf8"));
     }
 
     async function json(): Promise<any> {
-      return text().then((text) => destr(text));
+      return text().then((text: string) => destr(text));
     }
 
     async function formData(): Promise<FormData> {

package/src/findAllFiles.ts

@@ -1,66 +1,38 @@
-import { env } from "./global";
-import * as fs from "fs";
+import { existsSync } from "fs";
+import { parsedArgs } from "./argv";
+import consola from "consola";
+import { sync } from "fast-glob";
 
-export async function findAllFiles({
-  path,
-  name,
-  maxDepth = 2,
-}: //
-{
+type FindFilesOptions = {
   path: string;
   name: string;
   maxDepth?: number;
-}): Promise<string[]> {
-  const rootSegments = path.split("/").length;
+};
 
-  if (env.VERBOSE) {
-    console.log(`Searching for ${name} in ${path}`);
+export function findAllFiles(
+  //
+  { path, name, maxDepth = 2 }: FindFilesOptions
+): //
+string[] {
+  if (!existsSync(path)) {
+    throw new Error(`Path ${path} does not exist`);
   }
-  const files: string[] = [];
-  let readdirSync;
-  try {
-    readdirSync = fs.readdirSync(path);
-  } catch (e) {
-    if (env.VERBOSE) {
-      console.log(`Error reading ${path}`, e);
-    }
-    return [];
-  }
-  for (const file of readdirSync) {
-    const filePath = path + "/" + file;
-    let stat;
-    try {
-      stat = fs.statSync(filePath);
-    } catch (e) {
-      if (env.VERBOSE) {
-        console.error(`Error getting stat for ${filePath}`, e);
-      }
-      continue;
-    }
-    if (stat.isDirectory()) {
-      if (filePath.split("/").length < rootSegments + maxDepth) {
-        try {
-          const subFiles = await findAllFiles({
-            path: filePath,
-            name: name,
-            maxDepth: 2,
-          });
-          files.push(...subFiles);
-        } catch (e) {
-          if (env.VERBOSE) {
-            console.error(e);
-          }
-        }
-      }
-    } else if (file === name) {
-      files.push(filePath);
-    }
+
+  if (parsedArgs.verbose) {
+    consola.start(`Searching for ${name} files in ${path}`);
   }
-  if (env.VERBOSE) {
+
+  const files: string[] = sync(`${path}/**/${name}`, {
+    onlyFiles: true,
+    deep: maxDepth,
+  });
+
+  if (parsedArgs.verbose) {
     if (files.length > 0) {
-      console.log(`Found ${files.length} ${name} files`);
-      console.log(files);
+      consola.success(`Found ${files.length} ${name} files`);
+      consola.info(files);
     }
   }
+
   return files;
 }

package/src/getChromeCookie.ts

@@ -0,0 +1,19 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
+import { isExportedCookie } from "./ExportedCookie";
+
+export async function getChromeCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  const cookies = await queryCookies(
+    params,
+    new ChromeCookieQueryStrategy()
+    //
+  );
+  if (cookies.length == 0) {
+    throw new Error("Cookie not found");
+  }
+  return cookies.find(isExportedCookie);
+}

package/src/getCookie.ts

@@ -0,0 +1,20 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+
+export async function getCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  //
+  const cookies = await queryCookies(
+    params,
+    new CompositeCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
+  } else {
+    throw new Error("Cookie not found");
+  }
+}