chrome-tools 1.0.5 → 1.0.7

package/src/core/chrome.js

@@ -1,178 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-/** Known database/data files that indicate a valid Chrome profile directory. */
-const PROFILE_INDICATORS = [
-  "Login Data",
-  "History",
-  "Bookmarks",
-  "Cookies",
-  "Web Data",
-  "Preferences",
-];
-
-/**
- * Returns the default Chrome User Data directory for macOS.
- * @returns {string}
- */
-export function getDefaultChromeDir() {
-  return join(homedir(), "Library", "Application Support", "Google", "Chrome");
-}
-
-/**
- * Scans the Chrome User Data directory for profile subdirectories.
- * A directory is considered a profile if it contains at least one known data file.
- *
- * @param {string} [chromeDir] - Chrome User Data path. Defaults to standard macOS location.
- * @returns {Array<{name: string, path: string}>} Discovered profiles with name and absolute path.
- */
-export function discoverProfiles(chromeDir) {
-  const dir = chromeDir || getDefaultChromeDir();
-  if (!dir || !existsSync(dir)) {
-    return [];
-  }
-
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    const profiles = [];
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const profilePath = join(dir, entry.name);
-      const hasIndicator = PROFILE_INDICATORS.some((file) =>
-        existsSync(join(profilePath, file))
-      );
-      if (hasIndicator) {
-        profiles.push({ name: entry.name, path: profilePath });
-      }
-    }
-    return profiles;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Parses the Chrome "Local State" JSON file to extract profile metadata.
- * Returns enriched profile info including display name, email, avatar, etc.
- *
- * @param {string} [chromeDir] - Chrome User Data path.
- * @returns {Array<Object>} Profile metadata objects.
- */
-export function getProfileMetadata(chromeDir) {
-  const dir = chromeDir || getDefaultChromeDir();
-  const localStatePath = join(dir, "Local State");
-
-  if (!existsSync(localStatePath)) {
-    return [];
-  }
-
-  try {
-    const raw = readFileSync(localStatePath, "utf-8");
-    const localState = JSON.parse(raw);
-    const infoCache = localState?.profile?.info_cache;
-
-    if (!infoCache || typeof infoCache !== "object") {
-      return [];
-    }
-
-    return Object.entries(infoCache).map(([dirName, info]) => ({
-      directory: dirName,
-      name: info.name || dirName,
-      gaiaName: info.gaia_name || "",
-      userName: info.user_name || "",
-      email: info.user_name || "",
-      avatarIcon: info.avatar_icon || "",
-      isUsingDefaultName: info.is_using_default_name ?? true,
-      isEphemeral: info.is_ephemeral ?? false,
-      activeTime: info.active_time || 0,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Combines filesystem profile discovery with Local State metadata
- * to provide a comprehensive view of each profile's state.
- *
- * @param {string} [chromeDir] - Chrome User Data path.
- * @returns {Array<Object>} Enriched profile state objects.
- */
-export function getProfileStates(chromeDir) {
-  const dir = chromeDir || getDefaultChromeDir();
-  const discovered = discoverProfiles(dir);
-  const metadata = getProfileMetadata(dir);
-
-  const metaMap = new Map();
-  for (const m of metadata) {
-    metaMap.set(m.directory, m);
-  }
-
-  return discovered.map((profile) => {
-    const meta = metaMap.get(profile.name) || {};
-    const profilePath = profile.path;
-
-    // Check which data files exist
-    const dataFiles = {};
-    for (const file of PROFILE_INDICATORS) {
-      dataFiles[file.replace(/\s+/g, "_").toLowerCase()] = existsSync(
-        join(profilePath, file)
-      );
-    }
-    // Additional files
-    dataFiles.top_sites = existsSync(join(profilePath, "Top Sites"));
-    dataFiles.extensions = existsSync(join(profilePath, "Extensions"));
-
-    return {
-      directory: profile.name,
-      path: profilePath,
-      displayName: meta.name || profile.name,
-      gaiaName: meta.gaiaName || "",
-      email: meta.email || "",
-      avatarIcon: meta.avatarIcon || "",
-      isEphemeral: meta.isEphemeral ?? false,
-      activeTime: meta.activeTime || 0,
-      dataFiles,
-    };
-  });
-}
-
-/**
- * Resolves a profile name to its directory path.
- *
- * @param {string} chromeDir - Chrome User Data path.
- * @param {string} profileName - Profile directory name (e.g., "Default", "Profile 1").
- * @returns {string|null} Absolute path to profile directory, or null if not found.
- */
-export function resolveProfilePath(chromeDir, profileName) {
-  const dir = chromeDir || getDefaultChromeDir();
-  const profilePath = join(dir, profileName);
-  return existsSync(profilePath) ? profilePath : null;
-}
-
-/**
- * Helper to get the profiles to operate on based on options.
- * If a specific profile is specified, returns only that one.
- * Otherwise returns all discovered profiles.
- *
- * @param {Object} options
- * @param {string} [options.profilePath] - Custom Chrome User Data/profile directory.
- * @param {string} [options.chromeDir] - Chrome User Data path (alias for profilePath).
- * @param {string} [options.profile] - Specific profile name to target.
- * @returns {Array<{name: string, path: string}>}
- */
-export function resolveTargetProfiles({ profilePath, chromeDir, profile } = {}) {
-  const dir = profilePath || chromeDir || getDefaultChromeDir();
-  const allProfiles = discoverProfiles(dir);
-
-  if (profile) {
-    const match = allProfiles.filter((p) => p.name === profile);
-    if (match.length === 0) {
-      throw new Error(`Profile "${profile}" not found in ${dir}`);
-    }
-    return match;
-  }
-  return allProfiles;
-}

package/src/core/crypto.js

@@ -1,75 +0,0 @@
-import { createDecipheriv } from "node:crypto";
-
-const AES_IV = Buffer.alloc(16, " "); // 16 spaces (0x20)
-
-/**
- * Decrypts a password/value buffer encrypted by Chrome on macOS.
- * Chrome v10+ on macOS prefixes the encrypted blob with "v10" or "v11",
- * followed by AES-128-CBC ciphertext.
- *
- * @param {Buffer|Uint8Array} encryptedBlob - The encrypted blob from the database.
- * @param {Buffer} derivedKey - The derived 16-byte key.
- * @returns {string} The decrypted plaintext, or an error placeholder.
- */
-export function decryptValue(encryptedBlob, derivedKey) {
-  const decrypted = decryptValueBuffer(encryptedBlob, derivedKey);
-  return Buffer.isBuffer(decrypted) ? decrypted.toString("utf-8") : decrypted;
-}
-
-/**
- * Decrypts a Chrome encrypted blob and returns the raw plaintext bytes.
- *
- * @param {Buffer|Uint8Array} encryptedBlob - The encrypted blob from the database.
- * @param {Buffer} derivedKey - The derived 16-byte key.
- * @returns {Buffer|string} The decrypted plaintext bytes, or an error placeholder.
- */
-export function decryptValueBuffer(encryptedBlob, derivedKey) {
-  if (!encryptedBlob || encryptedBlob.length === 0) {
-    return Buffer.alloc(0);
-  }
-
-  const blob = Buffer.isBuffer(encryptedBlob)
-    ? encryptedBlob
-    : Buffer.from(encryptedBlob);
-
-  const prefix = blob.subarray(0, 3).toString("utf-8");
-  if (prefix !== "v10" && prefix !== "v11") {
-    return "<unsupported encryption format>";
-  }
-
-  const ciphertext = blob.subarray(3);
-
-  try {
-    const decipher = createDecipheriv("aes-128-cbc", derivedKey, AES_IV);
-    let decrypted = decipher.update(ciphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    return decrypted;
-  } catch {
-    return "<decryption failed>";
-  }
-}
-
-/**
- * Converts a Chrome/Webkit timestamp (microseconds since 1601-01-01)
- * to a readable local Date string.
- *
- * @param {bigint|number} chromeTimestamp - Timestamp in microseconds.
- * @returns {string} Human-readable date-time string, or "N/A".
- */
-export function chromeTimeToDate(chromeTimestamp) {
-  if (!chromeTimestamp || chromeTimestamp === 0 || chromeTimestamp === 0n) {
-    return "N/A";
-  }
-  try {
-    const timestampBigInt = BigInt(chromeTimestamp);
-    const unixMicroseconds = timestampBigInt - 11644473600000000n;
-    const ms = Number(unixMicroseconds / 1000n);
-    const date = new Date(ms);
-    if (isNaN(date.getTime())) {
-      return "N/A";
-    }
-    return date.toLocaleString();
-  } catch {
-    return "N/A";
-  }
-}

package/src/core/db.js

@@ -1,69 +0,0 @@
-import { existsSync, copyFileSync, mkdtempSync, unlinkSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, basename } from "node:path";
-import Database from "better-sqlite3";
-
-/**
- * Copies a Chrome SQLite database to a temporary location, executes a query,
- * and cleans up. This avoids SQLite locking issues when Chrome is running.
- *
- * @param {string} dbFilePath - Absolute path to the Chrome database file.
- * @param {string} sql - SQL query to execute.
- * @param {Array} [params=[]] - Bound parameters for the query.
- * @returns {Array<Object>} Query result rows.
- * @throws {Error} If the file doesn't exist or query fails.
- */
-export function queryDatabase(dbFilePath, sql, params = []) {
-  if (!existsSync(dbFilePath)) {
-    throw new Error(`Database file not found: ${dbFilePath}`);
-  }
-
-  const tmpDir = mkdtempSync(join(tmpdir(), "chrome-tools-"));
-  const tmpDb = join(tmpDir, basename(dbFilePath));
-
-  try {
-    copyFileSync(dbFilePath, tmpDb);
-  } catch (err) {
-    cleanupTmp(tmpDb, tmpDir);
-    throw new Error(`Failed to copy database file '${basename(dbFilePath)}': ${err.message}`);
-  }
-
-  let db;
-  try {
-    db = new Database(tmpDb, { readonly: true, timeout: 5000 });
-    const stmt = db.prepare(sql);
-    return params.length > 0 ? stmt.all(...params) : stmt.all();
-  } catch (err) {
-    throw new Error(`Database query failed on '${basename(dbFilePath)}': ${err.message}`);
-  } finally {
-    if (db) {
-      try { db.close(); } catch { /* ignore */ }
-    }
-    cleanupTmp(tmpDb, tmpDir);
-  }
-}
-
-/**
- * Checks whether a specific table exists in the given database file.
- *
- * @param {string} dbFilePath - Absolute path to the database file.
- * @param {string} tableName - Name of the table to check.
- * @returns {boolean} True if the table exists.
- */
-export function tableExists(dbFilePath, tableName) {
-  try {
-    const rows = queryDatabase(
-      dbFilePath,
-      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-      [tableName]
-    );
-    return rows.length > 0;
-  } catch {
-    return false;
-  }
-}
-
-function cleanupTmp(tmpDb, tmpDir) {
-  try { unlinkSync(tmpDb); } catch { /* ignore */ }
-  try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
-}

package/src/core/keychain.js

@@ -1,68 +0,0 @@
-import { execSync } from "node:child_process";
-import { pbkdf2Sync } from "node:crypto";
-
-const PBKDF2_ITERATIONS = 1003;
-const PBKDF2_KEY_LENGTH = 16;
-const PBKDF2_SALT = Buffer.from("saltysalt");
-
-let _cachedKeychainPassword = null;
-let _cachedDerivedKey = null;
-
-/**
- * Retrieves the "Chrome Safe Storage" password from the macOS Keychain.
- * Caches the result for subsequent calls within the same process.
- *
- * @returns {string} The raw keychain password.
- * @throws {Error} If the password could not be retrieved.
- */
-export function getChromeKeychainPassword() {
-  if (_cachedKeychainPassword !== null) {
-    return _cachedKeychainPassword;
-  }
-  try {
-    const password = execSync(
-      'security find-generic-password -w -s "Chrome Safe Storage"',
-      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    _cachedKeychainPassword = password;
-    return password;
-  } catch {
-    throw new Error(
-      "Could not retrieve Chrome Safe Storage key from macOS Keychain.\n" +
-      "Ensure Google Chrome has been run at least once and you have granted Keychain access."
-    );
-  }
-}
-
-/**
- * Derives the AES-128-CBC key from the Keychain password using PBKDF2.
- * Caches the result for subsequent calls.
- *
- * @param {string} [keychainPassword] - The raw password. If omitted, fetched from Keychain.
- * @returns {Buffer} The derived 16-byte key.
- */
-export function deriveEncryptionKey(keychainPassword) {
-  if (_cachedDerivedKey !== null) {
-    return _cachedDerivedKey;
-  }
-  const password = keychainPassword || getChromeKeychainPassword();
-  if (!password) {
-    throw new Error("Keychain password cannot be empty for key derivation.");
-  }
-  _cachedDerivedKey = pbkdf2Sync(
-    password,
-    PBKDF2_SALT,
-    PBKDF2_ITERATIONS,
-    PBKDF2_KEY_LENGTH,
-    "sha1"
-  );
-  return _cachedDerivedKey;
-}
-
-/**
- * Clears cached keychain data. Useful for testing or re-authentication.
- */
-export function clearKeychainCache() {
-  _cachedKeychainPassword = null;
-  _cachedDerivedKey = null;
-}

package/src/modules/autofill.js

@@ -1,213 +0,0 @@
-import { join } from "node:path";
-import { resolveTargetProfiles } from "../core/chrome.js";
-import { deriveEncryptionKey } from "../core/keychain.js";
-import { decryptValue, chromeTimeToDate } from "../core/crypto.js";
-import { queryDatabase, tableExists } from "../core/db.js";
-
-/**
- * Retrieves autofill entries from Chrome's Web Data database.
- *
- * @param {Object} [options]
- * @param {string} [options.chromeDir] - Chrome User Data directory.
- * @param {string} [options.profile] - Specific profile to target.
- * @param {string} [options.search] - Filter by field name or value (case-insensitive).
- * @param {number} [options.limit=100] - Maximum results.
- * @returns {Array<Object>}
- */
-export function getAutofillEntries({ chromeDir, profile, search, limit = 100 } = {}) {
-  const profiles = resolveTargetProfiles({ chromeDir, profile });
-  const results = [];
-
-  for (const p of profiles) {
-    const dbPath = join(p.path, "Web Data");
-    try {
-      if (!tableExists(dbPath, "autofill")) continue;
-
-      let sql = `SELECT name, value, date_created, date_last_used, count
-                 FROM autofill ORDER BY date_last_used DESC`;
-      if (limit) {
-        sql += ` LIMIT ${parseInt(limit, 10)}`;
-      }
-
-      const rows = queryDatabase(dbPath, sql);
-
-      for (const row of rows) {
-        const entry = {
-          profile: p.name,
-          name: row.name || "",
-          value: row.value || "",
-          dateCreated: chromeTimeToDate(row.date_created ? BigInt(row.date_created) * 1000000n + 11644473600000000n : 0),
-          dateLastUsed: chromeTimeToDate(row.date_last_used ? BigInt(row.date_last_used) * 1000000n + 11644473600000000n : 0),
-          count: row.count || 0,
-        };
-
-        if (search) {
-          const term = search.toLowerCase();
-          if (
-            !entry.name.toLowerCase().includes(term) &&
-            !entry.value.toLowerCase().includes(term)
-          ) {
-            continue;
-          }
-        }
-        results.push(entry);
-      }
-    } catch {
-      // Skip profiles with errors
-    }
-  }
-
-  return results;
-}
-
-/**
- * Retrieves saved credit cards from Chrome's Web Data database.
- * Card numbers are encrypted and will be decrypted.
- *
- * @param {Object} [options]
- * @param {string} [options.chromeDir] - Chrome User Data directory.
- * @param {string} [options.profile] - Specific profile to target.
- * @returns {Array<Object>}
- */
-export function getCreditCards({ chromeDir, profile } = {}) {
-  const profiles = resolveTargetProfiles({ chromeDir, profile });
-  const derivedKey = deriveEncryptionKey();
-  const results = [];
-
-  for (const p of profiles) {
-    const dbPath = join(p.path, "Web Data");
-    try {
-      if (!tableExists(dbPath, "credit_cards")) continue;
-
-      const rows = queryDatabase(
-        dbPath,
-        `SELECT guid, name_on_card, expiration_month, expiration_year,
-                card_number_encrypted, date_modified, origin, use_count,
-                use_date, nickname
-         FROM credit_cards ORDER BY use_date DESC`
-      );
-
-      for (const row of rows) {
-        let cardNumber = "";
-        if (row.card_number_encrypted) {
-          cardNumber = decryptValue(row.card_number_encrypted, derivedKey);
-        }
-
-        results.push({
-          profile: p.name,
-          guid: row.guid || "",
-          nameOnCard: row.name_on_card || "",
-          expirationMonth: row.expiration_month || 0,
-          expirationYear: row.expiration_year || 0,
-          cardNumber,
-          nickname: row.nickname || "",
-          origin: row.origin || "",
-          useCount: row.use_count || 0,
-          dateModified: chromeTimeToDate(row.date_modified ? BigInt(row.date_modified) * 1000000n + 11644473600000000n : 0),
-        });
-      }
-    } catch {
-      // Skip profiles with errors
-    }
-  }
-
-  return results;
-}
-
-/**
- * Retrieves saved addresses from Chrome's Web Data database.
- *
- * @param {Object} [options]
- * @param {string} [options.chromeDir] - Chrome User Data directory.
- * @param {string} [options.profile] - Specific profile to target.
- * @returns {Array<Object>}
- */
-export function getAddresses({ chromeDir, profile } = {}) {
-  const profiles = resolveTargetProfiles({ chromeDir, profile });
-  const results = [];
-
-  for (const p of profiles) {
-    const dbPath = join(p.path, "Web Data");
-    try {
-      if (!tableExists(dbPath, "autofill_profiles")) continue;
-
-      const profileRows = queryDatabase(
-        dbPath,
-        `SELECT guid, company_name, street_address, dependent_locality,
-                city, state, zipcode, country_code, date_modified,
-                origin, use_count, use_date, language_code
-         FROM autofill_profiles ORDER BY use_date DESC`
-      );
-
-      // Try to join with names, emails, and phones
-      let nameRows = [];
-      let emailRows = [];
-      let phoneRows = [];
-
-      try {
-        if (tableExists(dbPath, "autofill_profile_names")) {
-          nameRows = queryDatabase(
-            dbPath,
-            `SELECT guid, first_name, middle_name, last_name, full_name FROM autofill_profile_names`
-          );
-        }
-      } catch { /* ignore */ }
-
-      try {
-        if (tableExists(dbPath, "autofill_profile_emails")) {
-          emailRows = queryDatabase(
-            dbPath,
-            `SELECT guid, email FROM autofill_profile_emails`
-          );
-        }
-      } catch { /* ignore */ }
-
-      try {
-        if (tableExists(dbPath, "autofill_profile_phones")) {
-          phoneRows = queryDatabase(
-            dbPath,
-            `SELECT guid, number FROM autofill_profile_phones`
-          );
-        }
-      } catch { /* ignore */ }
-
-      const nameMap = new Map();
-      for (const n of nameRows) {
-        nameMap.set(n.guid, n.full_name || [n.first_name, n.middle_name, n.last_name].filter(Boolean).join(" "));
-      }
-
-      const emailMap = new Map();
-      for (const e of emailRows) {
-        emailMap.set(e.guid, e.email || "");
-      }
-
-      const phoneMap = new Map();
-      for (const ph of phoneRows) {
-        phoneMap.set(ph.guid, ph.number || "");
-      }
-
-      for (const row of profileRows) {
-        results.push({
-          profile: p.name,
-          guid: row.guid || "",
-          fullName: nameMap.get(row.guid) || "",
-          email: emailMap.get(row.guid) || "",
-          phone: phoneMap.get(row.guid) || "",
-          companyName: row.company_name || "",
-          streetAddress: row.street_address || "",
-          city: row.city || "",
-          state: row.state || "",
-          zipcode: row.zipcode || "",
-          countryCode: row.country_code || "",
-          origin: row.origin || "",
-          useCount: row.use_count || 0,
-          dateModified: chromeTimeToDate(row.date_modified ? BigInt(row.date_modified) * 1000000n + 11644473600000000n : 0),
-        });
-      }
-    } catch {
-      // Skip profiles with errors
-    }
-  }
-
-  return results;
-}