Skip to content

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.md
index 120c7df,d2241b9..3f6cd1d
--- a/README.md
+++ b/README.md
@@@ -54,6 -54,26 +54,25 @@@ merely appearing in a cached web page m
article about the campaign. The tool distinguishes saved references from
connection 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 run
Requires Python 3.8 or newer. No administrator. No third-party packages.
diff --cc scan/tests/test_vivaldi.py
index 0000000,8a463cd..59d58a9
mode 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()