Research paper · Research archive

RIFT: Reach-Invariant Firewall for Trust

An executable static kernel for pre-commit information-flow certification.

Research status

Open-source research software with an illustrated research paper, archived on Zenodo. Not a peer-reviewed article. Results are model-relative: 37 tests and a bounded oracle support the static kernel, but they are not a formal proof and do not demonstrate runtime enforcement. Every edge removal returns UNKNOWN, so revocation is not supported in version 0.1.1.

Paper preview

Black-and-white RIFT research illustration depicting a glass-like sphere surrounded by curved information-flow paths and network nodes.
Research figure from the paper, shown above its abstract. Conceptual illustration, not a diagram of the algorithm.

Abstract

How can a proposed change to an information-flow graph be evaluated before it becomes part of the trusted static state? RIFT provides an executable Python kernel for pre-commit certification over a finite, trusted, static information-flow graph. For a supported mutation, it constructs a candidate state and decides ALLOW, DENY, or UNKNOWN using reachability from actual protected holdings to forbidden sinks.

A counterexample found during adversarial review showed that topology deletion can erase evidence of a possible earlier transfer. The hardened kernel contains this defect by refusing every edge removal: secure revocation and persistent taint are not implemented. These are model-relative results, not machine-checked verification or production enforcement.

Methods

  • Build the candidate graph for a proposed mutation without changing the committed state.
  • Compute directed reachability from nodes that actually hold protected facts to forbidden sinks, honoring explicit policy exceptions and counting zero-hop occupancy.
  • Return ALLOW, DENY with a shortest-path witness, or noncommitting UNKNOWN when coverage, versioning, or supported semantics are insufficient. Every edge removal returns UNKNOWN.

Key observations

  • 37 reproducible Python standard-library tests pass against the hardened source.
  • An independent bounded DFS oracle agrees with the kernel over 512 finite static states and 3,072 single-edge proposals.
  • A documented sequential counterexample (add an edge, remove it, add an onward edge) motivated refusing all edge removals in the hardened kernel.
  • The executable reference kernel, illustrated paper, and SHA-256 checksum manifest are archived on Zenodo.

Known limitations

  • RIFT is a conditional static research model, not an operational firewall.
  • The results are not a machine-checked formal proof; the bounded oracle covers a finite state space and does not establish universal correctness.
  • Runtime enforcement and complete mediation of real data transfers are not demonstrated.
  • Every edge removal returns UNKNOWN. Secure revocation, verified purge, durable historical information-flow state, and time-respecting guarantees are not implemented.
  • Decisions depend on the completeness and correctness of the trusted graph, fact holdings, sensitivity labels, and writer authentication.

Summarized from the paper. The full list is in its section on limitations, failure modes, and open research problems.

Cite this work

Plain text

Thor, T. (2026). RIFT: Reach-Invariant Firewall for Trust - An Executable
Static Kernel for Pre-Commit Information-Flow Certification (0.1.1). Zenodo.
https://doi.org/10.5281/zenodo.24239735

BibTeX

@misc{thor2026rift,
  author    = {Thor, Thor},
  title     = {RIFT: Reach-Invariant Firewall for Trust - An Executable Static Kernel for Pre-Commit Information-Flow Certification},
  year      = {2026},
  version   = {0.1.1},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.24239735},
  url       = {https://doi.org/10.5281/zenodo.24239735}
}

Version history

  • Version 0.1.1 · Initial public release, archived on Zenodo. All-versions DOI 10.5281/zenodo.24239734.