@mherod/get-cookie 1.1.5 → 1.2.0

package/README.md

@@ -11,6 +11,8 @@ To install get-cookie, run the following command:
 
         $ npm install @mherod/get-cookie --global
 
+**Note: Currently only macOS is supported. Windows support is planned for a future release.**
+
 ## How do I use it?
 
 To use get-cookie, run the following command:

package/cli.js

@@ -0,0 +1,48 @@
+#!/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,11 +1,27 @@
 #!/usr/bin/env node
 
+if (process.platform !== 'darwin') {
+    throw new Error('This script only works on macOS');
+}
+
 const crypto = require('crypto');
-const {exec} = require("child_process");
 const fs = require("fs");
+const {execSimple, toStringOrNull, doSqliteQuery1, printStringValue, toStringValue} = require("./utils");
+const jsonwebtoken = require('jsonwebtoken');
 
-if (process.platform !== 'darwin') {
-    throw new Error('This script only works on macOS');
+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;
+    }
 }
 
 /**
@@ -13,24 +29,74 @@ 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) {
-    throw new Error('Not implemented');
+/**
+ *
+ * @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);
+    }
 }
 
 /**
@@ -46,8 +112,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,7 +136,9 @@ 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`;
@@ -87,7 +158,7 @@ async function getEncryptedChromeCookie({name, domain, file = defaultChromeCooki
         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 +177,32 @@ async function getEncryptedChromeCookie({name, domain, file = defaultChromeCooki
     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 +230,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 +241,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,55 +269,81 @@ async function decrypt(password, encryptedData) {
 /**
  *
  * @param {string|undefined} name
- * @param {string|undefined} domain
+ * @param {string} domain
+ * @param {boolean} requireJwt
  * @returns {Promise<string>}
  */
-async function getChromeCookie({name, domain}) {
+async function getChromeCookie({name, domain = '%', requireJwt = false}) {
     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({
+    const encryptedDataItems = await findAllFiles({
         path: defaultChromeRoot,
         name: 'Cookies'
     }).then(files => {
-        const promise = Promise.all(files.map(file => {
+        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 [];
             });
-        }));
-        if (process.env.VERBOSE) {
-            console.log('promise', promise);
-        }
-        return promise;
+        });
+        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 && (requireJwt === false || isValidJwt(result));
+    });
 }
 
 /**
@@ -361,129 +414,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,20 +1,24 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "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": [],
   "author": "Matthew Herod",
   "license": "ISC",
   "dependencies": {
+    "jsonwebtoken": "^8.5.1",
     "sqlite3": "^5.0.8"
+  },
+  "devDependencies": {
+    "jest": "^28.1.0"
   }
 }

package/utils.js

@@ -0,0 +1,175 @@
+// 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 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
+};