browser-commander 0.24.0 → 0.26.0

package/tests/unit/browser/cookie-sources.test.js

@@ -1,17 +1,78 @@
 // feature-parity: sources.cookie-listing@native-typed
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
+import { mkdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import BetterSqlite3 from 'better-sqlite3';
 
 import {
   listCookieSources,
   resolveImportSource,
 } from '../../../src/browser/browser-cookies.js';
+import { migrateProfile } from '../../../src/browser/migration/index.js';
 import { writeFirefoxProfile } from '../../helpers/migration-fixtures.js';
 import { useTempDirectories } from '../../helpers/temp-directory.js';
 
 const makeDirectory = useTempDirectories();
 
 describe('listCookieSources', () => {
+  it('matches only whole hosts and subdomains in both SQLite families', async () => {
+    const hosts = [
+      '.github.com',
+      'api.GITHUB.COM.',
+      'notgithub.com',
+      '.github.com.attacker.test',
+      '.gitXhub.com',
+    ];
+    for (const browser of ['firefox', 'chrome']) {
+      const homeDir = await makeDirectory('bc-source-domains-');
+      let file;
+      if (browser === 'firefox') {
+        const profile = await writeFirefoxProfile(
+          homeDir,
+          hosts.map((host, index) => ({
+            host,
+            name: `${index}`,
+            value: 'secret',
+          }))
+        );
+        file = path.join(profile, 'cookies.sqlite');
+      } else {
+        const profile = path.join(homeDir, '.config/google-chrome/Default');
+        await mkdir(profile, { recursive: true });
+        file = path.join(profile, 'Cookies');
+        const database = new BetterSqlite3(file);
+        try {
+          database.exec('CREATE TABLE cookies (host_key TEXT, value TEXT)');
+          for (const host of hosts) {
+            database
+              .prepare('INSERT INTO cookies VALUES (?, ?)')
+              .run(host, 'secret');
+          }
+        } finally {
+          database.close();
+        }
+      }
+      const before = await readFile(file);
+      const sources = await listCookieSources({
+        domains: ['GITHUB.COM.', 'git_hub.com', '%github.com'],
+        platform: 'linux',
+        homeDir,
+        environment: {},
+      });
+      assert.equal(sources.length, 1);
+      assert.equal(sources[0].browser, browser);
+      assert.equal(sources[0].cookies, hosts.length);
+      assert.deepEqual(sources[0].byDomain, {
+        'GITHUB.COM.': 2,
+        'git_hub.com': 0,
+        '%github.com': 0,
+      });
+      assert.ok(!JSON.stringify(sources).includes('secret'));
+      assert.deepEqual(await readFile(file), before);
+    }
+  });
+
   it('reports cookie counts per profile without reading values', async () => {
     const temporaryDirectory = await makeDirectory('bc-src-');
     const profilePath = await writeFirefoxProfile(temporaryDirectory, [
@@ -92,23 +153,37 @@ describe('resolveImportSource', () => {
     });
   });
 
-  it('falls back to the installed browser that holds the domains', async () => {
-    const homeDir = await makeDirectory('bc-import-fallback-');
-    await writeFirefoxProfile(homeDir, otherCookie);
-    await writeFirefoxProfile(homeDir, githubCookie, {
-      root: '.librewolf',
-      name: 'default',
-    });
-
-    const source = await resolve(homeDir);
-    assert.equal(source.browser, 'librewolf');
-    assert.equal(source.profile, 'default');
-    assert.equal(source.warning.reason, 'default-browser-fallback');
-    assert.equal(source.warning.item, 'librewolf');
-    assert.match(
-      source.warning.detail,
-      /default browser \(firefox\) holds no cookies for github\.com; imported from librewolf/
-    );
+  it('falls back when the default holds unrelated or lookalike domains', async () => {
+    for (const host of ['.other.test', '.notgithub.com']) {
+      const homeDir = await makeDirectory('bc-import-fallback-');
+      await writeFirefoxProfile(homeDir, [{ ...otherCookie[0], host }]);
+      await writeFirefoxProfile(homeDir, githubCookie, {
+        root: '.librewolf',
+        name: 'default',
+      });
+      const source = await resolve(homeDir);
+      assert.equal(source.browser, 'librewolf');
+      assert.equal(source.profile, 'default');
+      assert.equal(source.warning.reason, 'default-browser-fallback');
+      assert.equal(source.warning.item, 'librewolf');
+      assert.match(
+        source.warning.detail,
+        /default browser \(firefox\) holds no cookies for github\.com; imported from librewolf/
+      );
+      const report = await migrateProfile({
+        from: { browser: 'auto' },
+        to: path.join(homeDir, 'target'),
+        include: ['cookies'],
+        domains: ['github.com'],
+        platform: 'linux',
+        homeDir,
+        environment: {},
+        runCommand: firefoxIsDefault,
+      });
+      assert.equal(report.source.browser, 'librewolf');
+      assert.equal(report.migrated.cookies, 1);
+      assert.equal(report.cookies[0].domain, '.github.com');
+    }
   });
 
   it('falls back when the system default cannot be determined', async () => {

package/tests/unit/browser/credential-catalogue.test.js

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { BROWSER_SOURCES } from '../../../src/browser/browser-sources.js';
+import { readSafeStoragePassword } from '../../../src/browser/browser-cookie-credentials.js';
+
+describe('catalogue credential identities and Keychain diagnostics', () => {
+  it('requests every declared browser service rather than a four-browser table', async () => {
+    for (const browser of BROWSER_SOURCES.filter(
+      (entry) => entry.safeStorage
+    )) {
+      for (const name of [browser.id, ...(browser.aliases ?? [])]) {
+        const calls = [];
+        const password = await readSafeStoragePassword({
+          browser: name,
+          platform: 'darwin',
+          environment: {},
+          runCredentialCommand: async (command, args) => {
+            calls.push([command, args]);
+            return 'synthetic-password';
+          },
+        });
+        assert.equal(password, 'synthetic-password');
+        assert.deepEqual(calls, [
+          [
+            'security',
+            ['find-generic-password', '-w', '-s', browser.safeStorage.service],
+          ],
+        ]);
+      }
+    }
+  });
+
+  for (const outcome of ['denied', 'empty']) {
+    it(`identifies the item and retry path when Keychain returns ${outcome}`, async () => {
+      await assert.rejects(
+        readSafeStoragePassword({
+          browser: 'chrome',
+          platform: 'darwin',
+          runCredentialCommand: async () => {
+            if (outcome === 'denied') {
+              throw new Error('security exited with code 36');
+            }
+            return '';
+          },
+        }),
+        /Chrome Safe Storage.*Keychain.*allow.*retry.*refresh=true/s
+      );
+    });
+  }
+});

package/tests/unit/browser/firefox-cookie-expiry.test.js

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'node:test';
+
+import { openSqliteDatabase } from '../../../src/browser/browser-cookie-database.js';
+import { readBrowserCookiesWithDependencies } from '../../../src/browser/browser-cookies.js';
+import { migrateProfile } from '../../../src/browser/migration/index.js';
+
+const fixture = await readFile(
+  new URL(
+    '../../../../tests/fixtures/firefox-cookie-expiry.sql',
+    import.meta.url
+  ),
+  'utf8'
+);
+
+for (const version of [0, 15, 16, 17]) {
+  for (const migration of [false, true]) {
+    it(`normalizes Firefox schema ${version} expiry through ${migration ? 'migration' : 'installed reading'}`, async () => {
+      const homeDir = await mkdtemp(path.join(os.tmpdir(), 'bc-ff-expiry-'));
+      try {
+        const root = path.join(homeDir, '.mozilla', 'firefox');
+        const source = path.join(root, 'expiry.default-release');
+        await mkdir(source, { recursive: true });
+        await writeFile(
+          path.join(root, 'profiles.ini'),
+          '[Profile0]\nName=default-release\nIsRelative=1\nPath=expiry.default-release\nDefault=1\n'
+        );
+        const file = path.join(source, 'cookies.sqlite');
+        const database = await openSqliteDatabase(file);
+        try {
+          database.exec(fixture);
+          database.exec(`PRAGMA user_version = ${version}`);
+          if (version >= 16) {
+            database.exec(
+              'UPDATE moz_cookies SET expiry = expiry * 1000 + 999 WHERE expiry > 0'
+            );
+          }
+        } finally {
+          database.close();
+        }
+        const before = await readFile(file);
+        const options = { platform: 'linux', homeDir, environment: {} };
+        const cookies = migration
+          ? (
+              await migrateProfile({
+                from: { browser: 'firefox', userDataDir: source },
+                to: path.join(homeDir, 'target'),
+                include: ['cookies'],
+                domains: ['expiry.example'],
+                ...options,
+              })
+            ).cookies
+          : await readBrowserCookiesWithDependencies(
+              {
+                browser: 'firefox',
+                domainFilter: 'expiry.example',
+                cache: false,
+              },
+              options
+            );
+        assert.equal(cookies.length, 3);
+        const expiry = Object.fromEntries(
+          cookies.map((cookie) => [cookie.name, cookie.expires])
+        );
+        assert.deepEqual(expiry, {
+          persistent: 2_000_000_001,
+          'session-negative': -1,
+          'session-zero': -1,
+        });
+        assert.deepEqual(await readFile(file), before);
+      } finally {
+        await rm(homeDir, { recursive: true, force: true });
+      }
+    });
+  }
+}

package/tests/unit/browser/migration/data-classes.test.js

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { it } from 'node:test';
+
+import {
+  ALL_DATA_CLASSES,
+  migrateProfile,
+} from '../../../../src/browser/migration/index.js';
+import { repoPath } from '../../../helpers/repo.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-data-classes-');
+const classes = JSON.parse(
+  await readFile(repoPath('tests/fixtures/migration-data-classes.json'), 'utf8')
+);
+
+it('requires an actual boolean for payment-card consent before target writes', async () => {
+  const target = path.join(await makeTempDir(), 'new-profile');
+  await assert.rejects(
+    migrateProfile({
+      from: { browser: 'chrome', userDataDir: await makeTempDir() },
+      to: target,
+      include: ['paymentCards'],
+      includePaymentCards: 'true',
+    }),
+    /must be a boolean/u
+  );
+  await assert.rejects(readFile(path.join(target, 'Web Data')), {
+    code: 'ENOENT',
+  });
+});
+
+it('reports consented payment cards as unsupported until a native writer exists', async () => {
+  const report = await migrateProfile({
+    from: { browser: 'chrome', userDataDir: await makeTempDir() },
+    to: path.join(await makeTempDir(), 'new-profile'),
+    include: ['paymentCards'],
+    includePaymentCards: true,
+  });
+  assert.equal(report.migrated.paymentCards, 0);
+  assert.equal(report.skipped[0].reason, 'data-class-not-supported');
+});
+
+for (const browser of ['chrome', 'firefox', 'safari']) {
+  it(`reports every selected additional data class for ${browser} without reading protected card data`, async () => {
+    const source = await makeTempDir();
+    const target = path.join(await makeTempDir(), 'new-profile');
+    const profile =
+      browser === 'chrome' ? path.join(source, 'Default') : source;
+    await mkdir(profile, { recursive: true });
+    const marker = Buffer.from(
+      'protected card store must remain unread and unchanged'
+    );
+    await writeFile(path.join(profile, 'Web Data'), marker);
+    const report = await migrateProfile({
+      from: { browser, userDataDir: source },
+      to: target,
+      include: classes.slice(6),
+      platform: 'darwin',
+    });
+    assert.deepEqual(ALL_DATA_CLASSES, classes);
+    assert.deepEqual(Object.keys(report.migrated), classes);
+    assert.ok(Object.values(report.migrated).every((count) => count === 0));
+    for (const type of classes.slice(6)) {
+      assert.ok(
+        report.skipped.some((entry) => entry.type === type),
+        type
+      );
+    }
+    assert.equal(
+      report.skipped.find(({ type }) => type === 'paymentCards').reason,
+      'payment-card-consent-required'
+    );
+    const passkeys = report.skipped.filter(({ type }) => type === 'passkeys');
+    assert.deepEqual(
+      passkeys.map(({ item }) => item),
+      ['iCloud Keychain', 'Google Password Manager', 'Windows Hello']
+    );
+    for (const entry of passkeys) {
+      assert.equal(entry.reason, 'passkey-not-exportable');
+      assert.match(entry.detail, /persistent profile/u);
+    }
+    await assert.rejects(readFile(path.join(target, 'Web Data')), {
+      code: 'ENOENT',
+    });
+    assert.deepEqual(await readFile(path.join(profile, 'Web Data')), marker);
+  });
+}

package/tests/unit/browser/migration/domain-isolation.test.js

@@ -0,0 +1,212 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import Database from 'better-sqlite3';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+import { migrateHistory } from '../../../../src/browser/migration/history.js';
+import { migratePasswords } from '../../../../src/browser/migration/passwords.js';
+import { encryptChromiumValue } from '../../../../src/browser/migration/chromium-crypto.js';
+import {
+  decryptChromiumCookie,
+  deriveChromiumCookieKey,
+} from '../../../../src/browser/browser-cookie-crypto.js';
+
+const temp = useTempDirectories('bc-domain-isolation-');
+describe('per-site domain isolation (#119)', () => {
+  for (const domains of [['github.com'], []]) {
+    it(`re-encrypts login notes and ${domains.length ? 'filters' : 'preserves'} domain metadata`, async () => {
+      const source = await temp();
+      const target = await temp();
+      const sourceKey = randomBytes(16);
+      const targetKey = randomBytes(16);
+      const sourcePath = path.join(source, 'Login Data');
+      const db = new Database(sourcePath);
+      db.exec(
+        await readFile(
+          new URL(
+            '../../../../../tests/fixtures/password-domain-isolation.sql',
+            import.meta.url
+          ),
+          'utf8'
+        )
+      );
+      const encrypted = (plaintext) =>
+        encryptChromiumValue({
+          plaintext,
+          key: sourceKey,
+          platform: 'linux',
+          prefix: 'v11',
+        });
+      db.prepare('UPDATE logins SET password_value=? WHERE id IN (7,8)').run(
+        encrypted('password')
+      );
+      const sourceNote = encrypted('private note ☃');
+      db.prepare(
+        'UPDATE password_notes SET value=? WHERE id IN (70,71,72)'
+      ).run(sourceNote);
+      db.close();
+      const original = await readFile(sourcePath);
+      const report = await migratePasswords({
+        sourceProfileDir: source,
+        targetProfileDir: target,
+        domains,
+        platform: 'linux',
+        resolveSourceKey: () => sourceKey,
+        targetKey,
+      });
+      const filtered = domains.length > 0;
+      assert.equal(report.migrated, filtered ? 1 : 2);
+      const copy = new Database(path.join(target, 'Login Data'));
+      try {
+        assert.deepEqual(
+          copy.prepare('SELECT parent_id FROM insecure_credentials').all(),
+          filtered ? [{ parent_id: 7 }] : [{ parent_id: 7 }, { parent_id: 8 }]
+        );
+        assert.deepEqual(
+          copy.prepare('SELECT origin_domain FROM stats').all(),
+          filtered
+            ? [{ origin_domain: 'https://github.com' }]
+            : [
+                { origin_domain: 'https://github.com' },
+                { origin_domain: 'https://notgithub.com' },
+              ]
+        );
+        const notes = copy
+          .prepare(
+            'SELECT id,value,date_created,confidential FROM password_notes'
+          )
+          .all();
+        assert.equal(notes.length, filtered ? 1 : 2);
+        assert.equal(notes[0].id, 70);
+        assert.equal(notes[0].date_created, 123);
+        assert.equal(notes[0].confidential, 1);
+        for (const note of notes) {
+          assert.equal(
+            decryptChromiumCookie({
+              encryptedValue: note.value,
+              databaseVersion: 0,
+              platform: 'linux',
+              key: targetKey,
+            }),
+            'private note ☃'
+          );
+        }
+        for (const table of [
+          'sync_entities_metadata',
+          'sync_model_metadata',
+          'future_password_metadata',
+        ]) {
+          const preserved = table === 'future_password_metadata' && !filtered;
+          assert.equal(
+            copy.prepare(`SELECT count(*) AS n FROM ${table}`).get().n,
+            preserved ? 1 : 0,
+            table
+          );
+          assert.equal(
+            report.warnings.some((warning) => warning.item === table),
+            !preserved
+          );
+        }
+        assert.ok(
+          report.skipped.some(
+            (entry) =>
+              entry.item === 'password_notes/73' &&
+              entry.reason === 'app-bound-v20'
+          )
+        );
+      } finally {
+        copy.close();
+      }
+      const bytes = await readFile(path.join(target, 'Login Data'));
+      assert.equal(bytes.includes(Buffer.from('unrelated-sync-marker')), false);
+      assert.equal(
+        bytes.includes(Buffer.from('unrelated-future-marker')),
+        !filtered
+      );
+      assert.equal(bytes.includes(sourceNote), false);
+      assert.deepEqual(await readFile(sourcePath), original);
+    });
+  }
+
+  it('excludes unrelated history URLs, their visits, and Top Sites', async () => {
+    const source = await temp();
+    const target = await temp();
+    const db = new Database(path.join(source, 'History'));
+    db.exec(
+      await readFile(
+        new URL(
+          '../../../../../tests/fixtures/history-domain-isolation.sql',
+          import.meta.url
+        ),
+        'utf8'
+      )
+    );
+    db.close();
+    await migrateHistory({
+      sourceProfileDir: source,
+      targetProfileDir: target,
+      domains: ['github.com'],
+    });
+    const copy = new Database(path.join(target, 'History'));
+    try {
+      assert.equal(copy.prepare('SELECT count(*) AS n FROM urls').get().n, 1);
+      assert.equal(copy.prepare('SELECT count(*) AS n FROM visits').get().n, 1);
+      for (const table of [
+        'content_annotations',
+        'context_annotations',
+        'segment_usage',
+        'downloads',
+        'downloads_url_chains',
+        'downloads_slices',
+      ]) {
+        assert.equal(
+          copy.prepare(`SELECT count(*) AS n FROM ${table}`).get().n,
+          1,
+          table
+        );
+      }
+    } finally {
+      copy.close();
+    }
+  });
+
+  it('filters passwords before decryption and removes undecryptable source values', async () => {
+    const source = await temp();
+    const target = await temp();
+    const key = deriveChromiumCookieKey('source', 'linux');
+    const db = new Database(path.join(source, 'Login Data'));
+    db.exec('CREATE TABLE logins(origin_url TEXT, password_value BLOB)');
+    const insert = db.prepare('INSERT INTO logins VALUES (?,?)');
+    insert.run(
+      'https://github.com',
+      encryptChromiumValue({
+        plaintext: 'secret',
+        key,
+        platform: 'linux',
+        prefix: 'v11',
+      })
+    );
+    insert.run('https://notgithub.com', Buffer.from('v20unreadable'));
+    insert.run('https://locked.github.com', Buffer.from('v20unreadable'));
+    db.close();
+    const report = await migratePasswords({
+      sourceProfileDir: source,
+      targetProfileDir: target,
+      domains: ['github.com'],
+      platform: 'linux',
+      resolveSourceKey: () => key,
+      targetKey: key,
+    });
+    assert.equal(report.migrated, 1);
+    const copy = new Database(path.join(target, 'Login Data'));
+    try {
+      assert.deepEqual(copy.prepare('SELECT origin_url FROM logins').all(), [
+        { origin_url: 'https://github.com' },
+      ]);
+    } finally {
+      copy.close();
+    }
+  });
+});