@mherod/get-cookie 1.1.6 → 1.1.7

package/cli.js

@@ -6,7 +6,13 @@ const {printStringValue} = require("./utils");
 if (process.argv) {
     if (process.argv.length > 2) {
         const name = process.argv[2];
-        const domain = process.argv[3] ?? '%';
+
+        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";

package/index.js

@@ -2,7 +2,7 @@
 
 const crypto = require('crypto');
 const fs = require("fs");
-const {execSimple} = require("./utils");
+const {execSimple, toStringOrNull, doSqliteQuery1} = require("./utils");
 
 if (process.platform !== 'darwin') {
     throw new Error('This script only works on macOS');
@@ -57,7 +57,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`;
@@ -77,7 +79,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`;
@@ -96,48 +98,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);
-        });
-    });
-}
-
 /**
  *
  * @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}`);
     }
@@ -165,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) {
@@ -176,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) {
@@ -215,7 +200,6 @@ async function getChromeCookie({name, domain = '%'}) {
     if (typeof domain !== 'string') {
         throw new Error('domain must be a string');
     }
-    const chromePasswordPromise = getChromePassword();
     const encryptedDataItems = await findAllFiles({
         path: defaultChromeRoot,
         name: 'Cookies'
@@ -229,25 +213,27 @@ async function getChromeCookie({name, domain = '%'}) {
                 if (process.env.VERBOSE) {
                     console.log("Error getting encrypted cookie", e);
                 }
-                return null;
+                return [];
             });
         });
-        const promise = Promise.all(promises).then(results => {
+        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;
             });
         });
-        if (process.env.VERBOSE) {
-            console.log('promise', promise);
-        }
-        return promise;
     }).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('encryptedDataItems', encryptedDataItems);
+    }
     const decrypted = encryptedDataItems.filter(encryptedData => {
         return encryptedData != null && encryptedData.length > 0;
     }).map(async encryptedData => {
@@ -271,8 +257,12 @@ async function getChromeCookie({name, domain = '%'}) {
         }
         return null;
     });
-    return await Promise.all(decrypted).then(results => {
-        return results.find(result => typeof result === 'string' && result.length > 0);
+    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;
     });
 }
 
@@ -349,5 +339,6 @@ module.exports = {
     getDecryptedCookie: getChromeCookie,
     getChromeCookie,
     getFirefoxCookie,
-    getCookie
+    getCookie,
+    decrypt
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "main": "index.js",
   "bin": "cli.js",
@@ -8,7 +8,7 @@
     "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

@@ -1,6 +1,7 @@
 // noinspection JSUnusedGlobalSymbols
 
 const {exec} = require('child_process');
+const fs = require("fs");
 
 async function execSimple(command) {
     if (typeof command !== 'string') {
@@ -69,8 +70,91 @@ function printStringValue(r) {
     }
 }
 
+/**
+ *
+ * @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
+    printStringValue: printStringValue,
+    toStringOrNull: toStringOrNull,
+    doSqliteQuery1
 };