You can spend an afternoon hardening Firefox and still lose confidence in the result a week later.The browser updates. A preference changes silently. A file gets replaced. A real-world exception gets added for something like Discord or Spotify. Eventually, the question stops being "did I harden Firefox?" and becomes "is the browser that is running still the browser I think I hardened?"That is the gap I kept running into.Most Firefox hardening setups are built around a staticuser.js. That is a useful starting point, but it is not the whole problem. A static config gives you a snapshot of intent. It does not automatically give you confidence that the deployed browser still matches that intent after updates, drift, and operational changes.That is why I built `hifox`.`hifox` is a Linux-first Firefox hardening framework, but the important part is not the word "framework." The important part is the model behind it: treat a Git repo as the source of truth and Firefox as a deployment target.In implementation terms, that means Bash orchestration around Firefox AutoConfig,lockPref(), policies.json, generated pref dumps, and systemd--user verification/watch layers.That sounds simple, but it changes the way hardening is approached.Instead of viewing browser hardening as "write some prefs once and hope they stick," `hifox` treats it as a workflow:1. define rules in the repo2. generate the effective runtime configuration3. deploy it into Firefox4. verify that the live browser still matches the repo5. watch for drift and react when integrity breaksThat is the core idea.In practical terms, `hifox` does not rely mainly on `user.js`. It generates `autoconfig.cfg`, uses `lockPref()` for high-priority enforcement, uses `policies.json` for features that belong in Firefox's policy layer, and keeps the deployed state tied back to the repo. The point is not to have "more config." The point is to have a declared model that can actually be checked and re-applied.This distinction matters because static hardening tends to fail operationally, not theoretically.On day one, your config looks strict and intentional. On day thirty, you may no longer know: user.js hifox lockPref() policies.json systemd whether the most important prefs are still locked whether deployed files still match what is in version control whether Firefox updates introduced new prefs you never reviewed whether the most important prefs are still locked whether deployed files still match what is in version control whether Firefox updates introduced new prefs you never reviewed whether app-specific exceptions quietly weakened the whole setup`hifox` is an attempt to make those questions answerable.The runtime side is built around a simple loop. `deploy` pushes generated hardening into Firefox. `verify` checks important prefs and deployed files against the repo. File watchers and timer-based checks look for drift. If integrity breaks badly enough, Firefox can be stopped and the user can be notified instead of silently continuing in a degraded state.That last point is one of the main philosophical differences.A lot of hardening setups assume that silent failure is acceptable. I do not think that is a great trade. If the browser is no longer in the state you intended, "it still opens" is not a sufficient success condition.Another piece I cared about was update visibility.Browser updates are one of the hardest parts of maintaining a hardened setup because they can shift the ground under you. New preferences appear. Old ones change behavior. Some become irrelevant. Some become more important than before. If you are only looking at a handwritten config file, you can miss those changes for a long time.`hifox` addresses that by generating a full pref dump at startup and comparing it against the repo copy. When the dump changes, that change can flow back into version control and show up as an explicit `git diff`. That turns browser churn into something reviewable.For me, that was a major design goal: if Firefox changes, I want the hardening workflow to surface that change clearly rather than bury it.The other major design goal was separating "main browser" usage from "app-like browser" usage.In normal browser life, everything gets mixed into one profile: tabs, cookies, permissions, auth state, device access, autoplay exceptions, media permissions, and random site-specific loosenings. Over time that shared profile becomes difficult to reason about because the exception surface is no longer small.`hifox` takes a different route. It uses isolated Firefox profiles as webapps.That means the main profile can stay maximally locked, while app-style profiles can selectively unlock only what they truly need. A Discord profile can restore mic, camera, and WebRTC. A Spotify profile can restore DRM. Another webapp can get exactly its own exceptions and nothing more.The result is not just cleaner organization. It changes the security posture of browser usage.Instead of one giant browser profile accumulating everything, you get separate state containers with separate permission surfaces while still staying inside one Firefox runtime and one enforcement model.That is the part of the project I think is easy to underestimate. Isolated webapps are not just a convenience feature. They are a way to keep exceptions explicit, local, and reviewable.To be clear, this is not a claim that Firefox becomes "secure" in any absolute sense.`hifox` is not a defense against browser exploits, kernel exploits, or a compromised operating system. It is not a silver bullet and it is not a universal standard every Firefox user should adopt unchanged.Its goal is narrower:- make hardening deterministic- reduce silent drift- expose update-driven changes- keep exceptions visible- keep the running browser closer to the declared modelThe current scope is also intentionally narrow. `hifox` is Linux-only and built around Bash, Firefox AutoConfig, `policies.json`, and `systemd --user`. I am not trying to present it as a cross-platform enterprise product. I am trying to solve a specific operational problem well.So the real thesis behind the project is this:Firefox hardening gets more useful when you stop treating it as a static file problem and start treating it as a deploy, verify, and integrity problem.That is what `hifox` is trying to operationalize.Further reading: Further reading: Intro to Digital Fingerprints: Understanding, Manipulating, and Defending Against Online Tracking The “Connection Not Private” Warning Explained Mozilla AutoConfig documentation Firefox enterprise policies reference Intro to Digital Fingerprints: Understanding, Manipulating, and Defending Against Online Tracking Intro to Digital Fingerprints: Understanding, Manipulating, and Defending Against Online Tracking The “Connection Not Private” Warning Explained The “Connection Not Private” Warning Explained Mozilla AutoConfig documentation Mozilla AutoConfig documentation Firefox enterprise policies reference Firefox enterprise policies reference Check out hifox on GitHub: https://github.com/q1sh101/hifox Check out hifox on GitHub: https://github.com/q1sh101/hifox https://github.com/q1sh101/hifox
