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

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -1,19 +1,20 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { execSimple } from "../utils";
-import { env, HOME } from "../global";
-import fs, { existsSync } from "fs";
+import { env } from "../global";
+import { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
-import * as crypto from "crypto";
-import * as path from "path";
+import { join } from "path";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
-import { isExportedCookie } from "../IsExportedCookie";
+import { isExportedCookie } from "../ExportedCookie";
 import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
 import { stringToRegex } from "../StringToRegex";
 import { parsedArgs } from "../argv";
-import * as sqlite3 from "sqlite3";
-import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
+import consola from "consola";
+import { getChromePassword } from "./getChromePassword";
+import { chromeApplicationSupport } from "./ChromeApplicationSupport";
+import { decrypt } from "./decrypt";
+import { doSqliteQueryWithTransform } from "./DoSqliteQueryWithTransform";
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
   browserName = "Chrome";
@@ -55,7 +56,7 @@ async function getPromise1(
 async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
   try {
     const files: string[] = await findAllFiles({
-      path: chromeLocal,
+      path: chromeApplicationSupport,
       name: "Cookies",
     });
     const promises: Promise<CookieRow[]>[] = files.map((file) =>
@@ -131,18 +132,10 @@ Promise<ExportedCookie[]> {
   return results;
 }
 
-const chromeLocal = path.join(
-  HOME,
-  "Library",
-  "Application Support",
-  "Google",
-  "Chrome"
-);
-
 async function getEncryptedChromeCookie({
   name,
   domain,
-  file = path.join(chromeLocal, "Default", "Cookies"),
+  file = join(chromeApplicationSupport, "Default", "Cookies"),
 }: //
 {
   name: string;
@@ -154,38 +147,47 @@ async function getEncryptedChromeCookie({
   }
   if (parsedArgs.verbose) {
     const s = file.split("/").slice(-3).join("/");
-    console.log(`Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`);
+    consola.start(
+      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`
+    );
   }
   let sql;
   //language=SQL
-  sql = "SELECT * FROM cookies";
-  // sql = "SELECT encrypted_value, name, host_key FROM cookies";
-
+  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) {
-      // leading dot replaced with % to match subdomains
+      // The leading dot is replaced with % to match subdomains
       const sqlEmbedDomain = domain.replace(/^[.%]?/, "%");
       sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
   if (parsedArgs.verbose) {
-    console.log("sql", sql);
+    consola.info("Querying:", sql);
   }
   const domainRegexp: RegExp = stringToRegex(domain);
-  const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
+  const sqliteQuery1: CookieRow[] = await doSqliteQueryWithTransform({
     file: file,
     sql: sql,
     rowFilter: (row) => {
@@ -199,157 +201,13 @@ async function getEncryptedChromeCookie({
         value: row["encrypted_value"],
       };
       if (parsedArgs.verbose) {
-        console.log("CookieRow", cookieRow);
+        consola.info("Found", cookieRow);
       }
       return cookieRow;
     },
   });
   return sqliteQuery1.filter((row) => {
+    // TODO: is this needed?
     return row.domain.match(domainRegexp) != null;
   });
 }
-
-async function getChromePassword(): Promise<string> {
-  return execSimple(
-    'security find-generic-password -w -s "Chrome Safe Storage"'
-  );
-}
-
-async function decrypt(
-  password: crypto.BinaryLike,
-  encryptedData: Buffer
-): Promise<string> {
-  if (typeof password !== "string") {
-    throw new Error("password must be a string: " + password);
-  }
-  let encryptedData1: any;
-  encryptedData1 = encryptedData;
-  if (encryptedData1 == null || typeof encryptedData1 !== "object") {
-    throw new Error("encryptedData must be a object: " + encryptedData1);
-  }
-  if (!(encryptedData1 instanceof Buffer)) {
-    if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
-      [encryptedData1] = encryptedData1;
-      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);
-  }
-  if (parsedArgs.verbose) {
-    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 (parsedArgs.verbose) {
-            console.log("Error doing pbkdf2", error);
-          }
-          reject(error);
-          return;
-        }
-
-        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;
-        }
-
-        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);
-        }
-
-        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;
-        }
-
-        let decoded = decipher.update(encryptedData1);
-        try {
-          decipher.final("utf-8");
-        } catch (e) {
-          if (parsedArgs.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);
-      }
-    });
-  });
-}
-
-export async function doChromeSqliteQuery1({
-  file,
-  sql,
-  rowFilter = () => true,
-  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);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const rows1: any[] = rows;
-      if (rows1 == null || rows1.length === 0) {
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1
-          .filter(rowFilter)
-          .map((row: any) => {
-            const newVar = {
-              meta: {
-                file: file,
-              },
-            };
-            const cookieRow: CookieRow = rowTransform(row);
-            return merge(newVar, cookieRow);
-          });
-        resolve(cookieRows);
-        return;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}

package/src/browsers/DoSqliteQueryWithTransform.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 "consola";
+
+export interface DoSqliteQueryWithTransformOptions {
+  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) {
+  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 doSqliteQueryWithTransform(
+  //
+  {
+    //
+    file,
+    sql,
+    rowFilter = () => true,
+    rowTransform,
+  }: DoSqliteQueryWithTransformOptions
+): //
+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/FirefoxCookieQueryStrategy.ts

@@ -1,57 +1,14 @@
 import * as path from "path";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { HOME } from "../global";
-import fs, { existsSync } from "fs";
+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 { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
-import * as sqlite3 from "sqlite3";
-import { merge } from "lodash";
-
-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);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const rows1: any[] = rows;
-      if (rows1 == null || rows1.length === 0) {
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row: any) => {
-          const newVar = {
-            meta: {
-              file: file,
-            },
-          };
-          const cookieRow: CookieRow = rowTransform(row);
-          return merge(newVar, cookieRow);
-        });
-        resolve(cookieRows);
-        return;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}
+import { doSqliteQueryWithTransform } from "./DoSqliteQueryWithTransform";
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   browserName = "Firefox";
@@ -81,7 +38,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   async #getFirefoxCookie(
     { name, domain }: CookieSpec //
   ) {
-    const files: string[] = await findAllFiles({
+    const files: string[] = findAllFiles({
       path: path.join(
         HOME,
         "Library",
@@ -133,7 +90,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       };
     };
     try {
-      return await doSqliteQuery1({
+      return await doSqliteQueryWithTransform({
         file,
         sql,
         rowTransform,

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/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/findAllFiles.ts

@@ -1,65 +1,38 @@
-import * as fs from "fs";
-import { readdir } from "fs/promises";
+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;
-  const files: string[] = [];
-  let readdirSync;
-  try {
-    readdirSync = await readdir(path);
-  } catch (e) {
-    if (parsedArgs.verbose) {
-      consola.error(`Error reading ${path}`, e);
-    }
-    return [];
+};
+
+export function findAllFiles(
+  //
+  { path, name, maxDepth = 2 }: FindFilesOptions
+): //
+string[] {
+  if (!existsSync(path)) {
+    throw new Error(`Path ${path} does not exist`);
   }
-  for (const file of readdirSync) {
-    const filePath = path + "/" + file;
-    let stat;
-    try {
-      stat = fs.statSync(filePath);
-    } catch (e) {
-      if (parsedArgs.verbose) {
-        consola.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 (parsedArgs.verbose) {
-            consola.error(e);
-          }
-        }
-      }
-    } else if (file === name) {
-      files.push(filePath);
-    }
+
+  if (parsedArgs.verbose) {
+    consola.start(`Searching for ${name} files in ${path}`);
   }
+
+  const files: string[] = sync(`${path}/**/${name}`, {
+    onlyFiles: true,
+    deep: maxDepth,
+  });
+
   if (parsedArgs.verbose) {
     if (files.length > 0) {
-      consola.log(`Found ${files.length} ${name} files`);
-      consola.log(files);
+      consola.success(`Found ${files.length} ${name} files`);
+      consola.info(files);
     }
   }
+
   return files;
 }

package/src/getChromeCookie.ts

@@ -2,7 +2,7 @@ import CookieSpec from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 import { queryCookies } from "./queryCookies";
 import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
-import { isExportedCookie } from "./IsExportedCookie";
+import { isExportedCookie } from "./ExportedCookie";
 
 export async function getChromeCookie(
   params: CookieSpec

package/src/global.ts

@@ -1,7 +1,7 @@
 import { merge } from "lodash";
 
 export const env: any = {};
-merge(env, process.env);
+merge(env, process?.env ?? {});
 export const HOME: string = env["HOME"];
 if (!HOME) {
   throw new Error("HOME environment variable is not set");

package/src/index.ts

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-// noinspection JSUnusedGlobalSymbols
+#!/usr/bin/env bun run
 
 import { getCookie } from "./getCookie";
 import { getChromeCookie } from "./getChromeCookie";