@mherod/get-cookie 2.1.1 → 2.1.2

package/src/browsers/chrome/ChromeCookieQueryStrategy.ts

@@ -16,116 +16,143 @@ import logger from "../../logger";
 export const consola = logger.withTag("ChromeCookieQueryStrategy");
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
-  browserName = "Chrome";
+  browserName: string = "Chrome";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
-    }
+    this.ensurePlatformIsMacOS();
     if (env.FIREFOX_ONLY) {
       return [];
     }
-    return getChromeCookies({
+    return this.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);
+  private ensurePlatformIsMacOS(): void {
+    if (process.platform !== "darwin") {
+      throw new Error("This only works on macOS");
     }
-    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);
+  private async getChromeCookies({
+    name,
+    domain = "%",
+    requireJwt = false,
+  }: {
+    name: string;
+    domain: string;
+    requireJwt: boolean | undefined;
+  }): Promise<ExportedCookie[]> {
+    const encryptedDataItems: CookieRow[] = await this.getEncryptedCookies(
+      name,
+      domain,
+    );
+
+    const password: string = await getChromePassword();
+    const decryptedCookies: ExportedCookie[] = await this.decryptCookies(
+      encryptedDataItems,
+      password,
+    );
+
+    return decryptedCookies;
+  }
+
+  private async getEncryptedCookies(
+    name: string,
+    domain: string,
+  ): Promise<CookieRow[]> {
+    try {
+      const files: string[] = findAllFiles({
+        path: chromeApplicationSupport,
+        name: "Cookies",
+      });
+
+      const results: CookieRow[] = await flatMapAsync(files, async (file) => {
+        return await this.getCookiesFromFile(name, domain, file);
+      });
+
+      return results.filter(isCookieRow);
+    } catch (error) {
+      consola.warn("Error finding encrypted cookies", error);
+      return [];
+    }
+  }
+
+  private async getCookiesFromFile(
+    name: string,
+    domain: string,
+    file: string,
+  ): Promise<CookieRow[]> {
+    try {
+      return await getEncryptedChromeCookie({
+        name: name,
+        domain: domain,
+        file: file,
+      });
+    } catch (e) {
+      consola.warn("Error getting encrypted cookie from file", e);
+      return [];
     }
-    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);
+  private async decryptCookies(
+    encryptedDataItems: CookieRow[],
+    password: string,
+  ): Promise<ExportedCookie[]> {
+    const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
+      .filter(({ value }) => value != null && value.length > 0)
+      .map(async (cookieRow: CookieRow) => {
+        const encryptedValue: Uint8Array | Buffer = cookieRow.value;
+        const decryptedValue = await this.decryptValue(
+          password,
+          encryptedValue,
+        );
+        return this.createExportedCookie(cookieRow, decryptedValue);
+      });
+    return (await Promise.all(decrypted)).filter(isExportedCookie);
+  }
+
+  private async decryptValue(
+    password: string,
+    encryptedValue: Uint8Array | Buffer,
+  ): Promise<string> {
+    let decrypted: string | null;
+    try {
+      const bufferValue = Buffer.isBuffer(encryptedValue)
+        ? encryptedValue
+        : Buffer.from(encryptedValue);
+      decrypted = await decrypt(password, bufferValue);
+    } catch (e) {
+      consola.warn("Error decrypting cookie", e);
+      decrypted = null;
     }
-    d = null;
+    return decrypted ?? encryptedValue.toString("utf-8");
   }
-  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);
+  private createExportedCookie(
+    cookieRow: CookieRow,
+    decryptedValue: string,
+  ): ExportedCookie {
+    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;
   }
-  return results;
 }

package/src/browsers/chrome/decrypt.ts

@@ -1,118 +1,154 @@
-import { BinaryLike, createDecipheriv, pbkdf2 } from "crypto";
+import { 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);
+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;
   }
-  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);
+
+  private validatePassword(password: string): void {
+    if (typeof password !== "string") {
+      throw new Error("password must be a string: " + password);
+    }
   }
-  // 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
+
+  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) {
-        console.log(
-          `encryptedData is an array of buffers, selected first: ${encryptedData1}`,
+        consola.info(
+          `encryptedData is an array of buffers, selected first: ${encryptedData}`,
         );
       }
-    } else {
-      throw new Error("encryptedData must be a Buffer: " + encryptedData1);
     }
-    encryptedData1 = Buffer.from(encryptedData1);
+
+    return Buffer.from(encryptedData);
   }
-  // Log the password being used for decryption
-  if (parsedArgs.verbose) {
-    consola.start(`Trying to decrypt with password: ${password}`);
+
+  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));
+    });
   }
-  // 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);
+
+  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;
           }
-          reject(error);
-          return;
-        }
-
-        // Check if the buffer length is 16
-        if (buffer.length !== 16) {
-          if (parsedArgs.verbose) {
-            console.log(
+
+          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;
           }
-          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);
+
+          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) {
-        // Reject the promise if there is an error
+        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,11 +1,28 @@
 import { execSimple } from "../../execSimple";
 
-// top level so it's only called once and cached
-const chromePassword: Promise<string> =
+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"
-    ? execSimple('security find-generic-password -w -s "Chrome Safe Storage"')
-    : Promise.reject(new Error("This only works on macOS"));
+    ? new MacOSPasswordRetriever()
+    : new UnsupportedPlatformPasswordRetriever();
 
 export async function getChromePassword(): Promise<string> {
-  return await chromePassword;
+  return await passwordRetriever.retrievePassword();
 }

package/src/browsers/firefox/FirefoxCookieQueryStrategy.ts

@@ -11,7 +11,7 @@ import { parsedArgs } from "../../argv";
 import { querySqliteThenTransform } from "../QuerySqliteThenTransform";
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
-  browserName = "Firefox";
+  browserName: string = "Firefox";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
@@ -21,13 +21,15 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
     if (parsedArgs.browser !== "firefox") {
       return [];
     }
-    const cookies = await this.#getFirefoxCookie({ name, domain });
+    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: cookie.value.toString("utf8"),
+          value: Buffer.isBuffer(cookie.value)
+            ? cookie.value.toString("utf8")
+            : Buffer.from(cookie.value).toString("utf8"),
         };
       });
     } else {
@@ -35,9 +37,12 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
     }
   }
 
-  async #getFirefoxCookie(
+  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,
@@ -48,23 +53,24 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       ),
       name: "cookies.sqlite",
     });
-    const fn: (file: string) => Promise<CookieRow[]> = async (file: string) => {
-      return await this.#queryCookiesDb(file, name, domain);
-    };
-    const all: CookieRow[][] = await Promise.all(files.map(fn));
+    const all: CookieRow[][] = await Promise.all(
+      files.map(async (file: string) => {
+        return await this.queryCookiesDb(file, name, domain);
+      }),
+    );
     // flatten
     return all.flat();
   }
 
-  async #queryCookiesDb(
+  private async queryCookiesDb(
     file: string,
     name: string,
     domain: string,
   ): Promise<CookieRow[]> {
-    if (file && !existsSync(file)) {
+    if (!existsSync(file)) {
       throw new Error(`File ${file} does not exist`);
     }
-    let sql;
+    let sql: string;
     //language=SQL
     sql = "SELECT value, name, host FROM moz_cookies";
     const { specifiedName, specifiedDomain } = specialCases({ name, domain });
@@ -80,7 +86,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
         sql += `host LIKE '${domain}';`;
       }
     }
-    const rowTransform = (row: any) => {
+    const rowTransform = (row: any): CookieRow => {
       // row is object key by column name
       const value = row.value as string;
       return {