Zero Breach — local, read-only scanner that checks a computer for indicators of the AdFection / Candiru ad-delivered spyware campaign. No network, no admin, no dependencies.
Merge PR #1: add reviewed Vivaldi support and regression coverage
interplainse4ac445b98b9
diff --cc README.mdindex 120c7df,d2241b9..3f6cd1d--- a/README.md+++ b/README.md@@@ -54,6 -54,26 +54,25 @@@ merely appearing in a cached web page marticle about the campaign. The tool distinguishes saved references fromconnection evidence so that each finding can be interpreted in context.+ ### Supported browsers++ | family | browsers | profile locations checked |+ | ------ | -------- | ------------------------- |+ | Chromium | Chrome, Edge, Brave, **Vivaldi**, Chromium | Windows `%LOCALAPPDATA%\\<vendor>\\User Data`; macOS `~/Library/Application Support/<vendor>`; Linux `~/.config/<vendor>` plus snap and Flatpak locations |+ | Firefox | Firefox | standard profile and cache directories |++ Vivaldi paths: `%LOCALAPPDATA%\\Vivaldi\\User Data` (Windows),+ `~/Library/Application Support/Vivaldi` (macOS), `~/.config/vivaldi`,+ `~/.config/vivaldi-snapshot` and the Flatpak `com.vivaldi.Vivaldi` config+ (Linux). Other Chromium-based browsers (Opera, Arc and similar) are not scanned-yet; a browser that is not listed is reported as nothing checked for it, never-as clean. Close the browser before scanning so its databases are not locked.--> **Fork note:** Vivaldi support is a change on top of upstream v0.1.1. A-> `dist/zero-breach.py` built from this fork has a different SHA-256 from the-> signed upstream release, so the upstream GPG signature and published checksum-> do not apply to it. Rebuild with `python build/build.py` and compare against-> your own build.++yet. Unsupported browsers and custom profile locations are not checked and may++not appear in the report; a no-match result does not cover them. Close the++browser before scanning so its databases are not locked.++++> **Release note:** Vivaldi support is available in the source code and is not++> included in the signed v0.1.1 download. A new build has a different SHA-256;++> the v0.1.1 signature and checksum do not apply to it.+## Install and runRequires Python 3.8 or newer. No administrator. No third-party packages.diff --cc scan/tests/test_vivaldi.pyindex 0000000,8a463cd..59d58a9mode 000000,100644..100644--- a/scan/tests/test_vivaldi.py+++ b/scan/tests/test_vivaldi.py@@@ -1,0 -1,56 +1,125 @@@+ """Vivaldi (Chromium-based) is discovered and scanned like the other Chromium browsers."""++ import os++import pathlib+ import sys+ import unittest+ from unittest.mock import patch++ sys.path[:0] = [os.path.dirname(os.path.dirname(__file__)), os.path.dirname(__file__)]++ from test_browser_launch import (BrowserLaunchBase, TEST_DOMAIN,- chromium_history_db)++ chromium_history_db, chromium_cookie_db)+ from adint_scan.modules import browser++from adint_scan.result import UNKNOWN, PARTIAL, EV_CONTACTED, EV_REFERENCED+++ class TestVivaldiRoots(unittest.TestCase):+ def roots(self, platform, **env):+ with patch.object(browser.sys, "platform", platform), \+ patch.object(browser, "LOCAL", env.get("local", "")), \+ patch.object(browser.os.path, "expanduser", lambda p: "/home/u"):+ return dict(browser._chromium_roots())++ def test_windows(self):+ roots = self.roots("win32", local="C:\\L")+ self.assertIn("vivaldi", roots)- self.assertTrue(roots["vivaldi"].endswith(os.path.join("Vivaldi", "User Data")))++ self.assertEqual(roots["vivaldi"], os.path.join("C:\\L", "Vivaldi", "User Data"))++ def test_macos(self):+ roots = self.roots("darwin")- self.assertTrue(roots["vivaldi"].endswith(os.path.join("Application Support", "Vivaldi")))++ self.assertEqual(roots["vivaldi"], os.path.join("/home/u", "Library", "Application Support", "Vivaldi"))++ def test_linux(self):+ roots = self.roots("linux")- self.assertTrue(roots["vivaldi"].endswith(os.path.join(".config", "vivaldi")))- self.assertIn("vivaldi-snapshot", roots)- self.assertIn("vivaldi-flatpak", roots)++ self.assertEqual(roots["vivaldi"], os.path.join("/home/u", ".config", "vivaldi"))++ self.assertEqual(roots["vivaldi-snapshot"], os.path.join("/home/u", ".config", "vivaldi-snapshot"))++ self.assertEqual(roots["vivaldi-flatpak"], os.path.join("/home/u", ".var", "app", "com.vivaldi.Vivaldi", "config", "vivaldi"))+++ class TestVivaldiScan(BrowserLaunchBase):++ def vivaldi_root(self):++ root = os.path.join(self.tmp, "Vivaldi", "User Data")++ browser.CHROMIUM_ROOTS = [("vivaldi", root)]++ browser.ROAMING = browser.LOCAL = self.empty++ return root++++ def test_discovered_roots_scan_profiles_without_changing_source_files(self):++ # All discovered roots stay inside the fixture, including non-Vivaldi++ # roots. Exercise discovery through run(), not a hand-written root list.++ for platform in ("win32", "darwin", "linux"):++ home = os.path.join(self.tmp, platform)++ with patch.object(browser.sys, "platform", platform), \++ patch.object(browser, "LOCAL", home), \++ patch.object(browser.os.path, "expanduser", return_value=home):++ roots = browser._chromium_roots()++ vivaldi = [(name, root) for name, root in roots if name.startswith("vivaldi")]++ for name, root in vivaldi:++ chromium_history_db(os.path.join(root, "Default", "History"),++ "https://{}/x".format(TEST_DOMAIN))++ chromium_cookie_db(os.path.join(root, "Profile 1", "Network", "Cookies"))++ before = {str(p): p.read_bytes() for p in pathlib.Path(home).rglob("*") if p.is_file()}++ browser.CHROMIUM_ROOTS = roots++ result = browser.run(self.ctx)++ self.assertEqual(len(result.hits), len(vivaldi) * 2)++ self.assertTrue(all(h.evidence == EV_CONTACTED for h in result.hits))++ self.assertEqual({h.profile for h in result.hits}, {"Default", "Profile 1"})++ after = {str(p): p.read_bytes() for p in pathlib.Path(home).rglob("*") if p.is_file()}++ self.assertEqual(before, after)++++ def test_locked_vivaldi_is_unknown_not_clean(self):++ root = self.vivaldi_root()++ chromium_history_db(os.path.join(root, "Default", "History"))++ self.lock(lambda path: True)++ result = browser.run(self.ctx)++ self.assertEqual(result.status, UNKNOWN)++ self.assertTrue(any(not c.ran and "vivaldi" in c.name for c in result.checks))++++ def test_one_locked_profile_preserves_gap(self):++ root = self.vivaldi_root()++ for profile in ("Default", "Profile 1"):++ chromium_history_db(os.path.join(root, profile, "History"))++ self.lock(lambda path: "Profile 1" in path)++ self.assertEqual(browser.run(self.ctx).status, PARTIAL)++++ def test_research_reference_is_not_contact(self):++ root = self.vivaldi_root()++ chromium_history_db(os.path.join(root, "Default", "History"),++ "https://research.invalid/?indicator=" + TEST_DOMAIN)++ result = browser.run(self.ctx)++ self.assertEqual(len(result.hits), 1)++ self.assertEqual(result.hits[0].evidence, EV_REFERENCED)++++ def test_absent_vivaldi_is_not_reported_clean(self):++ self.vivaldi_root()++ result = browser.run(self.ctx)++ self.assertFalse(result.hits)++ self.assertEqual(result.status, UNKNOWN)++++ def test_corrupt_vivaldi_history_is_a_gap(self):++ root = self.vivaldi_root()++ history = pathlib.Path(root) / "Default" / "History"++ history.parent.mkdir(parents=True)++ history.write_bytes(b"not a SQLite database")++ result = browser.run(self.ctx)++ self.assertFalse(result.hits)++ self.assertEqual(result.status, UNKNOWN)+++ def test_history_hit_in_vivaldi_profile(self):+ ud = os.path.join(self.tmp, "Vivaldi", "User Data")+ chromium_history_db(os.path.join(ud, "Default", "History"),+ "https://{}/x".format(TEST_DOMAIN))+ browser.CHROMIUM_ROOTS = [("vivaldi", ud)]+ browser.ROAMING = browser.LOCAL = self.empty+ result = browser.run(self.ctx)+ self.assertTrue(result.hits, "an indicator in Vivaldi history must be found")++ def test_locked_note_names_vivaldi(self):+ for path in (r"C:\Users\u\AppData\Local\Vivaldi\User Data\Default\History",+ "/home/u/.config/vivaldi/Default/History"):+ note = browser._locked_note(path, PermissionError(13, "locked"))+ self.assertIn("Vivaldi", note)+++ if __name__ == "__main__":+ unittest.main()