@mherod/get-cookie 1.1.4 → 1.1.7

package/README.md

@@ -2,27 +2,28 @@
 
 ## What is it?
 
-    get-cookie is a command line utility that allows you to get the value of a cookie from your locally installed browser. It is useful for testing web pages that require authentication.
+get-cookie is a command line utility that allows you to get the value of a cookie from your locally installed browser.
+It is useful for testing web pages that require authentication.
 
 ## Installation
 
-    To install get-cookie, run the following command:
+To install get-cookie, run the following command:
 
         $ npm install @mherod/get-cookie --global
 
 ## How do I use it?
 
-    To use get-cookie, run the following command:
+To use get-cookie, run the following command:
 
         $ get-cookie <cookie-name> <domain>
 
-    For example, to get the value of the `auth` cookie on the `www.example.com` domain, run the following command:
+For example, to get the value of the `auth` cookie on the `www.example.com` domain, run the following command:
 
         $ get-cookie auth www.example.com
 
-    The output of the command will be the value of the cookie.
+The output of the command will be the value of the cookie.
 
-    The library can also be used as a module.
+The library can also be used as a module.
 
 ```javascript
 const {getCookie} = require('@mherod/get-cookie');

package/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const {getFirefoxCookie, getChromeCookie} = require("./index");
+const {printStringValue} = require("./utils");
+
+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('--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);
+        }
+
+        if (process.env.CHROME_ONLY) {
+            if (process.env.VERBOSE) {
+                console.log('chrome only');
+            }
+            getChromeCookie({name, domain})
+                .then(cookie => {
+                    if (cookie && cookie.length > 0) {
+                        printStringValue(cookie);
+                    } else {
+                        console.log('No cookie found');
+                    }
+                })
+                .catch(err => {
+                    if (process.env.VERBOSE) {
+                        console.error(err);
+                    }
+                });
+        } else if (process.env.FIREFOX_ONLY) {
+            if (process.env.VERBOSE) {
+                console.log('firefox only');
+            }
+            getFirefoxCookie({name, domain})
+                .then(cookie => {
+                    if (cookie && cookie.length > 0) {
+                        printStringValue(cookie);
+                    } else {
+                        console.log('No cookie found');
+                    }
+                })
+                .catch(err => {
+                    if (process.env.VERBOSE) {
+                        console.error("Error getting Firefox cookie", err);
+                    }
+                });
+        } else {
+            getChromeCookie({name, domain})
+                .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({name, domain})
+                            .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(printStringValue);
+        }
+    }
+}

package/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 const crypto = require('crypto');
-const {exec} = require("child_process");
 const fs = require("fs");
+const {execSimple, toStringOrNull, doSqliteQuery1} = require("./utils");
 
 if (process.platform !== 'darwin') {
     throw new Error('This script only works on macOS');
@@ -13,20 +13,7 @@ if (process.platform !== 'darwin') {
  * @returns {Promise<string>}
  */
 async function getChromePassword() {
-    return await new Promise((resolve, reject) => {
-        exec("security find-generic-password -w -s \"Chrome Safe Storage\"", (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            if (stderr) {
-                reject(error);
-                return;
-            }
-            let s = stdout.toString().trim();
-            resolve(s);
-        });
-    });
+    return await execSimple("security find-generic-password -w -s \"Chrome Safe Storage\"");
 }
 
 async function getCookie(name, domain) {
@@ -46,8 +33,11 @@ async function getFirefoxCookie({name, domain}) {
     if (domain && typeof domain !== 'string') {
         throw new Error('domain must be a string');
     }
-    const file = await findFile(`${process.env.HOME}/Library/Application Support/Firefox/Profiles`, "cookies.sqlite")
-    if (!fs.existsSync(file)) {
+    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) {
@@ -67,13 +57,15 @@ async function getFirefoxCookie({name, domain}) {
             sql += `host LIKE '${domain}';`;
         }
     }
-    return await doSqliteQuery1(file, sql);
+    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) {
+async function getEncryptedChromeCookie({name, domain, file = defaultChromeCookies}) {
     if (name && typeof name !== 'string') {
         throw new Error('name must be a string');
     }
@@ -87,7 +79,7 @@ async function getEncryptedChromeCookie(name, domain, file = defaultChromeCookie
         throw new Error(`File ${file} does not exist`);
     }
     if (process.env.VERBOSE) {
-        console.log(`Trying Chrome (at ${file}) cookie ${name} for domain ${domain}`);
+        console.log(`Trying Chrome (at ${file.split('/').slice(-3).join('/')}) cookie ${name} for domain ${domain}`);
     }
     let sql;
     sql = `SELECT encrypted_value FROM cookies`;
@@ -106,75 +98,32 @@ async function getEncryptedChromeCookie(name, domain, file = defaultChromeCookie
     return await doSqliteQuery1(file, sql);
 }
 
-async function doSqliteQuery1(file, sql) {
-    const sqlite3 = require('sqlite3');
-    const db = new sqlite3.Database(file);
-    return new Promise((resolve, reject) => {
-        db.all(sql, (err, rows) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            const rows1 = rows;
-            if (rows1.length === 0) {
-                if (process.env.VERBOSE) {
-                    console.log(`No rows found`);
-                }
-                resolve(null);
-                return;
-            }
-            if (Array.isArray(rows1)) {
-                // noinspection JSCheckFunctionSignatures
-                const [value] = rows1.flatMap(row => Object.values(row));
-                resolve(Buffer.from(value));
-                return;
-            }
-            resolve(rows1);
-        });
-    });
-}
-
-async function doSqliteQuery(file, sql) {
-    const command = `sqlite3 "${file}" "${sql}"`;
-    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);
-            }
-        });
-    });
-}
-
 /**
  *
  * @param {string} password
- * @param encryptedData
+ * @param {Buffer} encryptedData
  * @returns {Promise<string>}
  */
 async function decrypt(password, encryptedData) {
     if (typeof password !== 'string') {
         throw new Error('password must be a string: ' + password);
     }
-    const encryptedData1 = encryptedData;
+    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}`);
     }
@@ -202,7 +151,7 @@ async function decrypt(password, encryptedData) {
                 decipher.setAutoPadding(false);
 
                 if (encryptedData1 && encryptedData1.slice) {
-                    encryptedData = encryptedData1.slice(3);
+                    encryptedData1 = encryptedData1.slice(3);
                 }
 
                 if (encryptedData1.length % 16 !== 0) {
@@ -213,8 +162,7 @@ async function decrypt(password, encryptedData) {
                     return;
                 }
 
-                let decoded = decipher.update(encryptedData1, 'binary', 'utf8');
-                // let decoded = decipher.update(encryptedData);
+                let decoded = decipher.update(encryptedData1);
                 try {
                     decipher.final('utf-8');
                 } catch (e) {
@@ -242,37 +190,80 @@ async function decrypt(password, encryptedData) {
 /**
  *
  * @param {string|undefined} name
- * @param {string|undefined} domain
+ * @param {string} domain
  * @returns {Promise<string>}
  */
-async function getChromeCookie({name, domain}) {
+async function getChromeCookie({name, domain = '%'}) {
     if (name && typeof name !== 'string') {
         throw new Error('name must be a string');
     }
-    if (domain && typeof domain !== 'string') {
+    if (typeof domain !== 'string') {
         throw new Error('domain must be a string');
     }
-    const chromePasswordPromise = getChromePassword();
-    const [encryptedData] = await findAllFiles({path: defaultChromeRoot, name: 'Cookies'}).then(files => {
-        return Promise.all(files.map(file => getEncryptedChromeCookie(name, domain, file)));
+    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 chromePasswordPromise;
+    const password = await getChromePassword();
     if (process.env.VERBOSE) {
-        console.log("Received encrypted", encryptedData);
+        console.log('encryptedDataItems', encryptedDataItems);
     }
-    let s;
-    try {
-        s = await decrypt(password, encryptedData);
-    } catch (e) {
+    const decrypted = encryptedDataItems.filter(encryptedData => {
+        return encryptedData != null && encryptedData.length > 0;
+    }).map(async encryptedData => {
         if (process.env.VERBOSE) {
-            console.error("Error decrypting", e);
+            console.log("Received encrypted", encryptedData);
         }
-        throw new Error('Failed to decrypt');
-    }
+        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("Decrypted", s);
+        console.log('results', results);
     }
-    return s;
+    return results.map(toStringOrNull).find(result => {
+        return typeof result === 'string' && result.length > 0;
+    });
 }
 
 /**
@@ -294,9 +285,26 @@ async function findAllFiles({path, name, rootSegments = path.split('/').length,
         console.log(`Searching for ${name} in ${path}`);
     }
     const files = [];
-    for (const file of fs.readdirSync(path)) {
+    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;
-        const stat = fs.statSync(filePath);
+        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 {
@@ -326,129 +334,11 @@ async function findAllFiles({path, name, rootSegments = path.split('/').length,
     return files;
 }
 
-/**
- *
- * @param path
- * @param name
- * @returns {Promise<string>}
- */
-async function findFile(path, name) {
-    return await new Promise((resolve, reject) => {
-        for (const file of fs.readdirSync(path)) {
-            const filePath = path + '/' + file;
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                findFile(filePath, name).then(resolve).catch(reject);
-            } else if (file === name) {
-                resolve(filePath);
-            }
-        }
-    });
-}
-
-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'));
-        }
-    }
-}
-
 // noinspection JSUnusedGlobalSymbols
 module.exports = {
     getDecryptedCookie: getChromeCookie,
     getChromeCookie,
     getFirefoxCookie,
-    getCookie
+    getCookie,
+    decrypt
 };
-
-if (process.argv) {
-    if (process.argv.length > 2) {
-        const name = process.argv[2];
-        const domain = process.argv[3] ?? '%';
-
-        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);
-        }
-
-        if (process.env.CHROME_ONLY) {
-            if (process.env.VERBOSE) {
-                console.log('chrome only');
-            }
-            getChromeCookie({name, domain})
-                .then(cookie => {
-                    if (cookie && cookie.length > 0) {
-                        printStringValue(cookie);
-                    } else {
-                        console.log('No cookie found');
-                    }
-                })
-                .catch(err => {
-                    if (process.env.VERBOSE) {
-                        console.error(err);
-                    }
-                });
-        } else if (process.env.FIREFOX_ONLY) {
-            if (process.env.VERBOSE) {
-                console.log('firefox only');
-            }
-            getFirefoxCookie({name, domain})
-                .then(cookie => {
-                    if (cookie && cookie.length > 0) {
-                        printStringValue(cookie);
-                    } else {
-                        console.log('No cookie found');
-                    }
-                })
-                .catch(err => {
-                    if (process.env.VERBOSE) {
-                        console.error("Error getting Firefox cookie", err);
-                    }
-                });
-        } else {
-            getChromeCookie({name, domain})
-                .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({name, domain})
-                            .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(printStringValue);
-        }
-    }
-}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "1.1.4",
+  "version": "1.1.7",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "main": "index.js",
-  "bin": "index.js",
+  "bin": "cli.js",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
     "installGlobal": "rm -rf /usr/local/bin/get-cookie ; npm install --force --global ."
   },
   "keywords": [],
@@ -16,5 +16,8 @@
   "license": "ISC",
   "dependencies": {
     "sqlite3": "^5.0.8"
+  },
+  "devDependencies": {
+    "jest": "^28.1.0"
   }
 }

package/utils.js

@@ -0,0 +1,160 @@
+// 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 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;
+            }
+            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 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,
+    toStringOrNull: toStringOrNull,
+    doSqliteQuery1
+};