@mherod/get-cookie 1.2.0 → 1.3.0

package/src/utils.js

@@ -0,0 +1,185 @@
+// noinspection JSUnusedGlobalSymbols
+
+const { exec } = require("child_process");
+const fs = require("fs");
+
+async function execSimple(command) {
+  if (typeof command !== "string") {
+    throw new TypeError("execSimple: command must be a string");
+  }
+  if (process.env.VERBOSE) {
+    console.log(command);
+  }
+  return new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        if (stdout) {
+          resolve(stdout.toString("utf8").trim());
+        }
+      }
+    );
+  });
+}
+
+async function execAsBuffer(command) {
+  if (typeof command !== "string") {
+    throw new TypeError("execAsBuffer: command must be a string");
+  }
+  if (process.env.VERBOSE) {
+    console.log(command);
+  }
+  return await new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        let stdoutAsBuffer = stdout;
+        if (typeof stdoutAsBuffer === "string" && stdoutAsBuffer.length > 0) {
+          // noinspection JSCheckFunctionSignatures
+          stdoutAsBuffer = Buffer.from(stdoutAsBuffer, "binary").slice(0, -1);
+        }
+        if (stdoutAsBuffer && stdoutAsBuffer.length > 0) {
+          resolve(stdoutAsBuffer);
+        }
+      }
+    );
+  });
+}
+
+function toStringValue(r) {
+  if (process.env.VERBOSE) {
+    console.log("Printing value", r);
+  }
+  if (r) {
+    if (typeof r === "string") {
+      return r;
+    } else if (r.toString) {
+      // noinspection JSCheckFunctionSignatures
+      return r.toString("utf8");
+    }
+  }
+}
+
+function printStringValue(r) {
+  if (process.env.VERBOSE) {
+    console.log("Printing value", r);
+  }
+  if (r) {
+    if (typeof r === "string") {
+      console.log(r);
+    } else if (r.toString) {
+      // noinspection JSCheckFunctionSignatures
+      console.log(r.toString("utf8"));
+    }
+  }
+}
+
+/**
+ *
+ * @param result
+ * @returns {string|null}
+ */
+function toStringOrNull(result) {
+  if (result == null) {
+    return null;
+  }
+  if (process.env.VERBOSE) {
+    console.log("result", result);
+  }
+  if (typeof result === "string" && result.length > 0) {
+    return result;
+  }
+  if (result.slice && result.toString) {
+    // noinspection JSCheckFunctionSignatures
+    return result.toString("utf8");
+  }
+  return null;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {string} sql
+ * @returns {Promise<Buffer[]>}
+ */
+async function doSqliteQuery1(file, sql) {
+  if (typeof sql !== "string") {
+    throw new TypeError("doSqliteQuery1: sql must be a string");
+  }
+  if (typeof file !== "string") {
+    throw new TypeError("doSqliteQuery1: file must be a string");
+  }
+  if (!fs.existsSync(file)) {
+    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+  }
+  if (process.env.VERBOSE) {
+    console.log(`doSqliteQuery1: file ${file}`);
+    console.log(`doSqliteQuery1: sql ${sql}`);
+  }
+  const sqlite3 = require("sqlite3");
+  const db = new sqlite3.Database(file);
+  return new Promise((resolve, reject) => {
+    db.all(sql, (err, rows) => {
+      if (err) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: error ${err}`);
+        }
+        reject(err);
+        return;
+      }
+      const rows1 = rows;
+      if (rows1 == null || rows1.length === 0) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: no rows`);
+        }
+        resolve([]);
+        return;
+      }
+      if (Array.isArray(rows1)) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: ${rows1.length} rows`);
+        }
+        // noinspection JSCheckFunctionSignatures
+        const buffers = rows1
+          .flatMap((row) => Object.values(row))
+          .map((v) => Buffer.from(v, "binary"));
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: ${buffers.length} buffers`);
+        }
+        resolve(buffers);
+        return;
+      }
+      if (process.env.VERBOSE) {
+        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+      }
+      resolve([rows1]);
+    });
+  });
+}
+
+module.exports = {
+  execSimple: execSimple,
+  execAsBuffer: execAsBuffer,
+  printStringValue: printStringValue,
+  toStringValue,
+  toStringOrNull: toStringOrNull,
+  doSqliteQuery1,
+};

package/cli.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-const {getCookie} = require("./index");
-
-if (process.argv) {
-    if (process.argv.length > 2) {
-        const name = process.argv[2];
-
-        let domain;
-        if (process.argv[3] != null && process.argv[3].indexOf(".") > -1) {
-            domain = process.argv[3];
-        } else {
-            domain = '%';
-        }
-
-        if (process.argv.includes("--require-jwt")) {
-            process.env.REQUIRE_JWT = "true";
-        }
-        if (process.argv.includes('--verbose')) {
-            process.env.VERBOSE = "true";
-        }
-        if (process.argv.includes("--chrome-only")) {
-            process.env.CHROME_ONLY = "true";
-        }
-        if (process.argv.includes("--firefox-only")) {
-            process.env.FIREFOX_ONLY = "true";
-        }
-        if (process.argv.includes("--ignore-expired")) {
-            process.env.IGNORE_EXPIRED = "true";
-        }
-
-        if (process.env.VERBOSE) {
-            console.log("Verbose mode", process.argv);
-        }
-
-        getCookie({
-            name: name,
-            domain: domain,
-            requireJwt: (process.env.REQUIRE_JWT === "true"),
-        }).then(cookie => {
-            if (typeof cookie === "string") {
-                console.log(cookie);
-            }
-        }).catch(err => {
-            console.error(err);
-        });
-    }
-}

package/index.js

@@ -1,424 +0,0 @@
-#!/usr/bin/env node
-
-if (process.platform !== 'darwin') {
-    throw new Error('This script only works on macOS');
-}
-
-const crypto = require('crypto');
-const fs = require("fs");
-const {execSimple, toStringOrNull, doSqliteQuery1, printStringValue, toStringValue} = require("./utils");
-const jsonwebtoken = require('jsonwebtoken');
-
-function isValidJwt(token) {
-    if (typeof token !== 'string') {
-        return false;
-    }
-    try {
-        const result = jsonwebtoken.decode(token, {complete: true});
-        if (process.env.VERBOSE) {
-            console.log(result);
-        }
-        return true;
-    } catch (err) {
-        return false;
-    }
-}
-
-/**
- *
- * @returns {Promise<string>}
- */
-async function getChromePassword() {
-    return await execSimple("security find-generic-password -w -s \"Chrome Safe Storage\"");
-}
-
-/**
- *
- * @param params
- * @returns {Promise<string>}
- */
-async function getCookie(params) {
-    if (process.env.CHROME_ONLY) {
-        if (process.env.VERBOSE) {
-            console.log('chrome only');
-        }
-        return await getChromeCookie(params)
-            .then(cookie => {
-                if (cookie && cookie.length > 0) {
-                    return toStringValue(cookie);
-                }
-            })
-            .catch(err => {
-                if (process.env.VERBOSE) {
-                    console.error(err);
-                }
-            });
-    } else if (process.env.FIREFOX_ONLY) {
-        if (process.env.VERBOSE) {
-            console.log('firefox only');
-        }
-        return await getFirefoxCookie(params)
-            .then(b => b.toString('utf8'))
-            .then(cookie => {
-                if (cookie && cookie.length > 0) {
-                    return toStringValue(cookie);
-                } else {
-                    console.log('No cookie found');
-                }
-            })
-            .catch(err => {
-                if (process.env.VERBOSE) {
-                    console.error("Error getting Firefox cookie", err);
-                }
-            });
-    } else {
-        return await getChromeCookie(params)
-            .catch(err => {
-                if (process.env.VERBOSE) {
-                    console.error("Error getting Chrome cookie", err);
-                }
-            })
-            .then(r => {
-                if (typeof r === 'string' && r.trim().length > 0) {
-                    return r;
-                } else {
-                    return getFirefoxCookie(params)
-                        .catch(err => {
-                            if (process.env.VERBOSE) {
-                                console.error("Error getting Firefox cookie", err);
-                            }
-                        });
-                }
-            })
-            .catch((e) => {
-                if (process.env.VERBOSE) {
-                    console.error("Error getting Chrome or Firefox cookie", e);
-                }
-            })
-            .then(toStringValue);
-    }
-}
-
-/**
- *
- * @param name
- * @param domain
- * @returns {Promise<Buffer>}
- */
-async function getFirefoxCookie({name, domain}) {
-    if (name && typeof name !== 'string') {
-        throw new Error('name must be a string');
-    }
-    if (domain && typeof domain !== 'string') {
-        throw new Error('domain must be a string');
-    }
-    const [file] = await findAllFiles({
-        path: `${process.env.HOME}/Library/Application Support/Firefox/Profiles`,
-        name: "cookies.sqlite"
-    })
-    if (file && !fs.existsSync(file)) {
-        throw new Error(`File ${file} does not exist`);
-    }
-    if (process.env.VERBOSE) {
-        console.log(`Trying Firefox cookie ${name} for domain ${domain}`);
-    }
-    let sql;
-    sql = "SELECT value FROM moz_cookies";
-    if (typeof name === 'string' || typeof domain === 'string') {
-        sql += ` WHERE `;
-        if (typeof name === 'string') {
-            sql += `name = '${name}'`;
-            if (typeof domain === 'string') {
-                sql += ` AND `;
-            }
-        }
-        if (typeof domain === 'string') {
-            sql += `host LIKE '${domain}';`;
-        }
-    }
-    return await doSqliteQuery1(file, sql).then(rows => {
-        return rows.map(toStringOrNull).find(v => v !== null);
-    });
-}
-
-const defaultChromeRoot = `${process.env.HOME}/Library/Application Support/Google/Chrome`;
-const defaultChromeCookies = `${defaultChromeRoot}/Default/Cookies`;
-
-async function getEncryptedChromeCookie({name, domain, file = defaultChromeCookies}) {
-    if (name && typeof name !== 'string') {
-        throw new Error('name must be a string');
-    }
-    if (domain && typeof domain !== 'string') {
-        throw new Error('domain must be a string');
-    }
-    if (file && typeof file !== 'string') {
-        throw new Error('file must be a string');
-    }
-    if (!fs.existsSync(file)) {
-        throw new Error(`File ${file} does not exist`);
-    }
-    if (process.env.VERBOSE) {
-        console.log(`Trying Chrome (at ${file.split('/').slice(-3).join('/')}) cookie ${name} for domain ${domain}`);
-    }
-    let sql;
-    sql = `SELECT encrypted_value FROM cookies`;
-    if (typeof name === 'string' || typeof domain === 'string') {
-        sql += ` WHERE `;
-        if (typeof name === 'string') {
-            sql += `name = '${name}'`;
-            if (typeof domain === 'string') {
-                sql += ` AND `;
-            }
-        }
-        if (typeof domain === 'string') {
-            sql += `host_key LIKE '${domain}';`;
-        }
-    }
-    return await doSqliteQuery1(file, sql);
-}
-
-/**
- *
- * @param {string} password
- * @param {Buffer} encryptedData
- * @returns {Promise<string>}
- */
-async function decrypt(password, encryptedData) {
-    if (typeof password !== 'string') {
-        throw new Error('password must be a string: ' + password);
-    }
-    let encryptedData1;
-    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 (process.env.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 (process.env.VERBOSE) {
-        console.log(`Trying to decrypt with password ${password}`);
-    }
-    return await new Promise((resolve, reject) => {
-        crypto.pbkdf2(password, 'saltysalt', 1003, 16, 'sha1', (error, buffer) => {
-            try {
-                if (error) {
-                    if (process.env.VERBOSE) {
-                        console.log("Error doing pbkdf2", error);
-                    }
-                    reject(error);
-                    return;
-                }
-
-                if (buffer.length !== 16) {
-                    if (process.env.VERBOSE) {
-                        console.log("Error doing pbkdf2, buffer length is not 16", buffer.length);
-                    }
-                    reject(new Error('Buffer length is not 16'));
-                    return;
-                }
-
-                const iv = new Buffer.from(new Array(17).join(' '), '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 (process.env.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 (process.env.VERBOSE) {
-                        console.log("Error doing decipher.final()", e);
-                    }
-                    reject(e);
-                    return;
-                }
-
-                let padding = decoded[decoded.length - 1];
-                if (padding) {
-                    decoded = decoded.slice(0, 0 - padding);
-                }
-                // noinspection JSCheckFunctionSignatures
-                decoded = decoded.toString('utf8');
-                resolve(decoded);
-            } catch (e) {
-                reject(e);
-            }
-        });
-    });
-}
-
-/**
- *
- * @param {string|undefined} name
- * @param {string} domain
- * @param {boolean} requireJwt
- * @returns {Promise<string>}
- */
-async function getChromeCookie({name, domain = '%', requireJwt = false}) {
-    if (name && typeof name !== 'string') {
-        throw new Error('name must be a string');
-    }
-    if (typeof domain !== 'string') {
-        throw new Error('domain must be a string');
-    }
-    const encryptedDataItems = await findAllFiles({
-        path: defaultChromeRoot,
-        name: 'Cookies'
-    }).then(files => {
-        const promises = files.map(file => {
-            return getEncryptedChromeCookie({
-                name: name,
-                domain: domain,
-                file: file
-            }).catch(e => {
-                if (process.env.VERBOSE) {
-                    console.log("Error getting encrypted cookie", e);
-                }
-                return [];
-            });
-        });
-        return Promise.all(promises).then(results => results.flat()).then(results => {
-            if (process.env.VERBOSE) {
-                console.log("getEncryptedChromeCookie results", results);
-            }
-            return results.filter(result => {
-                return result;
-            });
-        });
-    }).catch(error => {
-        if (process.env.VERBOSE) {
-            console.log('error', error);
-        }
-        return [];
-    });
-    const password = await getChromePassword();
-    if (process.env.VERBOSE) {
-        console.log('encryptedDataItems', encryptedDataItems);
-    }
-    const decrypted = encryptedDataItems.filter(encryptedData => {
-        return encryptedData != null && encryptedData.length > 0;
-    }).map(async encryptedData => {
-        if (process.env.VERBOSE) {
-            console.log("Received encrypted", encryptedData);
-        }
-        let decrypted;
-        try {
-            decrypted = await decrypt(password, encryptedData);
-        } catch (e) {
-            if (process.env.VERBOSE) {
-                console.log("Error decrypting cookie", e);
-            }
-            return null;
-        }
-        if (decrypted) {
-            if (process.env.VERBOSE) {
-                console.log("Decrypted", decrypted);
-            }
-            return decrypted;
-        }
-        return null;
-    });
-    const results = await Promise.all(decrypted);
-    if (process.env.VERBOSE) {
-        console.log('results', results);
-    }
-    return results.map(toStringOrNull).find(result => {
-        return typeof result === 'string' && result.length > 0 && (requireJwt === false || isValidJwt(result));
-    });
-}
-
-/**
- *
- * @param path
- * @param name
- * @param rootSegments
- * @param maxDepth
- * @returns {Promise<[string]>}
- */
-async function findAllFiles({path, name, rootSegments = path.split('/').length, maxDepth = 2}) {
-    if (typeof path !== 'string') {
-        throw new Error('path must be a string');
-    }
-    if (typeof name !== 'string') {
-        throw new Error('name must be a string');
-    }
-    if (process.env.VERBOSE) {
-        console.log(`Searching for ${name} in ${path}`);
-    }
-    const files = [];
-    let readdirSync;
-    try {
-        readdirSync = fs.readdirSync(path);
-    } catch (e) {
-        if (process.env.VERBOSE) {
-            console.log(`Error reading ${path}`, e);
-        }
-        return files;
-    }
-    for (const file of readdirSync) {
-        const filePath = path + '/' + file;
-        let stat;
-        try {
-            stat = fs.statSync(filePath);
-        } catch (e) {
-            if (process.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,
-                        rootSegments: rootSegments,
-                        maxDepth: 2
-                    });
-                    files.push(...subFiles);
-                } catch (e) {
-                    if (process.env.VERBOSE) {
-                        console.error(e);
-                    }
-                }
-            }
-        } else if (file === name) {
-            files.push(filePath);
-        }
-    }
-    if (process.env.VERBOSE) {
-        if (files.length > 0) {
-            console.log(`Found ${(files.length)} ${name} files`);
-            console.log(files);
-        }
-    }
-    return files;
-}
-
-// noinspection JSUnusedGlobalSymbols
-module.exports = {
-    getDecryptedCookie: getChromeCookie,
-    getChromeCookie,
-    getFirefoxCookie,
-    getCookie,
-    decrypt
-};