A backdoored neural controller is a supply-chain time bomb: the policy drives normally on every test route, then executes a catastrophic maneuver the moment its environment matches an attacker-chosen trigger. This is not hypothetical — an offline-RL driving policy backdoored with a Signal Temporal Logic trajectory trigger (a coordinated two-car bypass maneuver) goes from a near-0% mission violation rate to 100% when the trigger appears, with average displacement error surging from under one meter to over 100 meters, and it survives standard robustness training like DP-SGD and trajectory smoothing (Temporal Logic-Based Multi-Vehicle Backdoor Attacks against Offline RL Agents in End-to-end Autonomous Driving). Every defense in the backdoor literature that could answer this — pruning dormant weights (Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks), entropy-based input screening (STRIP: A Defence Against Trojan Attacks on Deep Neural Networks), forensic retraining (SHINE: Shielding Backdoors in Deep Reinforcement Learning) — needs either clean data, observed catastrophic failures, or knowledge of the trigger family, and none offers any guarantee at the moment the trigger fires.
There is, however, an architectural layer whose guarantee does not depend on the nominal controller being benign. A control barrier function (CBF) safety filter sits between the policy and the actuators and minimally edits the commanded control whenever the vehicle approaches an unsafe boundary (Safety barrier certificates for heterogeneous multi-robot systems); it solves a tiny quadratic program (QP) at kilohertz rates, fast enough for real-time robots (Safety-critical Autonomous Inspection of Distillation Columns using Quadrupedal Robots Equipped with Roller Arms). The observation at the heart of this proposal is simple and, as far as the literature shows, unexploited: the QP's safety constraint depends only on the vehicle state, not on what the (possibly backdoored) policy proposed. So whenever the QP is feasible, the applied control is safe no matter what the trigger makes the policy do. Backdoor safety therefore reduces, exactly, to a question of recursive feasibility — and feasibility is precisely where CBF theory has known, unsolved failure modes under actuator saturation. This proposal makes that reduction explicit, measures where it breaks, hardens the filter against an attacker who targets it, and then follows the attacker's next move: poisoning the learned barrier itself.
Core Claim
The claim has three parts, in increasing order of novelty. First, a correctly specified analytic CBF filter is a trigger-agnostic shield: because the barrier constraint is independent of the nominal input, it neutralizes any backdoored controller, including the STL trajectory backdoor, without any knowledge of the trigger, any clean data, or any observed failure. Second, this immunity has a sharp boundary — the attacker's best remaining move is not to fight the filter but to strand it, steering the vehicle into states where no control within actuator limits can satisfy the barrier condition, causing QP infeasibility. We show this is a real attack surface and design a hardened barrier with an adversarially guaranteed feasibility margin. Third, if the barrier itself is learned from offline data (as in V-OCBF: Learning Safe Filters from Offline Data via Value-Guided Offline Control Barrier Functions), the attacker can poison the dataset so the learned barrier function reports "deeply safe" exactly on trigger states, disarming the shield. We demonstrate this barrier-trojan and defend against it by composing the learned barrier with a hand-derived one using the Log-Sum-Exp composition trick from BarrierSteer: LLM Safety via Learning Barrier Steering, so that a trojaned learned barrier cannot inflate the analytic barrier's value.
The formal core, for a control-affine vehicle model $\dot{x} = f(x) + g(x)u$ with state $x$ and control $u$, uses a safe set defined by a function $h$ whose zero level is the boundary ($h(x) \ge 0$ means safe). The filter solves, at every control step:
$$u^*(x) = \arg\min_{u \in \mathcal{U}} \tfrac{1}{2}\|u - \hat{u}(x)\|^2 \quad \text{s.t.} \quad L_f h(x) + L_g h(x)\,u \ge -\alpha(h(x)),$$
where $\hat{u}(x)$ is whatever the policy commands, $L_f h$ and $L_g h$ are the directional derivatives of $h$ along the dynamics, $\alpha$ is a strictly increasing function with $\alpha(0)=0$, and $\mathcal{U}$ are the actuator limits. The constraint contains no $\hat{u}$: if a feasible $u^*$ exists, forward invariance of the safe set holds for every nominal controller in every trigger state. The entire attack surface is the feasible set of this QP — and, if $h$ is learned, the truth of $h$ itself.
Research Program
The first work package proves the reduction and its limits. We formalize the "backdoor immunity up to feasibility" statement for the kinematic bicycle model used in MetaDrive, handling the relative-degree mismatch between a position-level collision constraint and force/torque-level inputs with high-order barrier constructions (High-Order Control Barrier Functions), since coupling high relative degree with hard saturation $\mathcal{U}$ is exactly the regime where QP infeasibility is a documented open problem. The deliverable is a feasibility-margin analysis: given worst-case admissible nominal inputs (i.e., treating the backdoored policy as a bounded adversary), we compute how far the operational safe set must be shrunk so that a feasible control always exists — a barrier tuned to the adversary rather than to benign disturbance models. We also state honestly where the shield has no purchase: it assumes the filter reads independently sensed state, so an attacker who corrupts the filter's perception channel, in the style of physical lane-detection backdoors (Physical Backdoor Attacks to Lane Detection Systems in Autonomous Driving), is out of scope and flagged as such.
The second package turns the attacker loose on the shield. Using the STL trigger machinery from Chen et al. as a building block, we add a second-stage optimization objective: maximize the probability that the triggered maneuver drives the QP infeasible before the barrier condition can be enforced (for example, burning braking authority so that when the trigger fires, no steering-and-braking combination within limits satisfies the constraint). This is not a new attack on the policy — it is an attack on the architecture, and it is the honest counterpart of our defense claim. The hardened barrier from package one is then evaluated against this infeasibility-seeking attacker.
The third package moves the attack to the safety layer's data supply. V-OCBF learns both a neural barrier $h_\theta$ and a dynamics surrogate purely from offline transition logs, and its authors leave open exactly this threat; offline RL datasets are known to be poisonable (Mind Your Data! Hiding Backdoors in Offline Reinforcement Learning Datasets). We construct a barrier-trojan: a small fraction of poisoned transitions, benign on their face, that teach $h_\theta$ to output large positive values on a trigger region of the state space, so the filter's constraint is trivially satisfied and malicious commands pass through untouched — clean-data validation accuracy of the barrier stays high, mirroring the dormant-neuron mechanism documented for classification backdoors (Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks). The defense composes the learned barrier with an analytic one via a smooth Log-Sum-Exp minimum, reusing the composition machinery BarrierSteer introduced for merging LLM safety constraints (BarrierSteer), so safety requires both barriers to consent. We additionally screen learned barriers with exact verification of ReLU barrier networks (Exact Verification of ReLU Neural Control Barrier Functions) — that paper's interval-propagation pipeline verifies a barrier against fixed geometric specifications in seconds on systems where SMT solvers time out, and we repurpose it to check a learned barrier against a hand-specified ground-truth safe set, catching trojan regions the validation set misses.
Proposed Experiments
The main testbed is MetaDrive (MetaDrive: Composing Diverse Driving Scenarios for Generalizable Reinforcement Learning), which runs at roughly 300 FPS and simulates 40+ agents at 60 FPS, supporting the multi-agent traffic needed for STL trajectory triggers, with trigger realism calibrated against the NGSIM real-world trajectory dataset as in the attack paper (no reported number found on Lacuna for NGSIM-specific results). We replicate the attack on the same five offline RL agent architectures (BC, BCQ, COptiDICE, and the other two from that paper) and interpose our filter between policy output and actuation. Primary metrics: mission violation rate under trigger (the attack's own metric, which it drives from near 0% to 100%), average displacement error (which it drives from under 1.0 m to over 100 m), collision rate, and — new metrics we introduce — QP infeasibility rate and shield activation frequency, measuring how often and how hard the filter must override the policy. A clean-policy-with-filter arm gives the performance ceiling, checking the filter's intervention cost on benign driving.
The barrier-poisoning study runs in the V-OCBF setting: the AGV collision-avoidance, boat navigation, and DSRL MuJoCo Safety-Gymnasium tasks (Safety Gymnasium: A Unified Safe Reinforcement Learning Benchmark, V-OCBF). There, V-OCBF reports 98.28% safe episodes and 92.57% certified safe-set volume on AGV navigation, versus 93.56% for BC+CCBF and 68.91% for COptiDICE; on boat navigation it reports 97.56% safe episodes against a best baseline of 88.43%. Our poisoned-barrier attack must be evaluated against these exact numbers: the question is how far the 98.28% figure collapses when the offline log is poisoned, and whether the composed analytic-plus-learned barrier restores it while staying within a few points of V-OCBF's clean performance.
Baselines
The "do nothing" reference point is the backdoored policy with no safety layer, where the attack paper reports the numbers we must beat: mission violation rate at 100% under trigger and average displacement error above 100 meters (Temporal Logic-Based Multi-Vehicle Backdoor Attacks). The strongest existing method is SHINE, the only backdoor defense in the file designed for sequential decision-making (SHINE): it attributes failures with a Gaussian-process explainer, masks trigger features, and retrains under a KL constraint, achieving trigger-detection F1 above 0.93 where supervised methods like Neural Cleanse and FeatureRE score below 0.30, and restoring backdoored Pong from -0.010 to 0.728 while clean performance rises from 0.680 to 0.734. It has never been run in driving, so we adapt it faithfully: same failure logs, same masking-and-retraining procedure, and the same compute and hyperparameter search budget our filter gets for its barrier-parameter sweep, on identical MetaDrive maps and the same five poisoned agents. Beating SHINE means lower mission-violation rate under trigger and success in the zero-day regime where no catastrophic failure log exists yet — a regime SHINE structurally cannot enter, since it requires observed failures to attribute. Two ablations isolate our ingredients: a standard analytic CBF-QP filter without the adversarial feasibility margin (showing what the margin buys against infeasibility-seeking triggers), and the plain learned V-OCBF barrier versus our composed analytic-plus-learned barrier under identical poisoning rates (showing what the composition buys against barrier-trojans). Supervised backdoor detectors like STRIP and Neural Cleanse are included only as expected-failure controls, since they were already shown to fall below 0.30 F1 in sequential settings by SHINE's own evaluation.
Why not just…?
Why not just wrap a standard CBF-QP filter around the policy and call it done? Honestly, against the published STL trigger, a well-tuned standard filter probably works — and demonstrating that cleanly is part of package one, not the whole contribution. But stopping there would ignore the two documented ways the reduction fails: QP infeasibility under saturation with high relative degree, which the CBF literature itself lists as an open problem, and poisoned learned barriers, which V-OCBF's own authors flag as unaddressed. Our experiments are designed to determine whether the trivial version suffices: if infeasibility-seeking triggers cannot break the standard filter, we will report that as a (useful) negative result; we expect they can, precisely because the attack paper showed the triggered maneuver is aggressive enough to divert a vehicle by over 100 meters.
Why not just retrain or sanitize the policy, SHINE-style? Because the defense inherits the attack's timeline: SHINE needs the agent to fail catastrophically in the real environment first, and in a physical vehicle one such failure is the incident you were defending against. Retraining-based defenses also exhibit superficial safety, where the trigger response is suppressed on validation routes but the trojan circuit reactivates under distribution shift (Uncovering, Explaining, and Mitigating the Superficial Safety of Backdoor Defense). A runtime filter sidesteps both problems; we still run the SHINE adaptation as the strongest baseline so the comparison is empirical, not rhetorical.
Why not just train the policy more robustly (DP-SGD, adversarial training, trajectory smoothing)? The attack paper already measured this: the STL trajectory backdoor completely evades DP-SGD and trajectory smoothing across all five agent architectures (Temporal Logic-Based Multi-Vehicle Backdoor Attacks). Robustness training also presupposes a trigger family to train against, while a barrier filter's guarantee is trigger-independent by construction. This is the one alternative we do not need to re-run; the negative evidence is already in the file.
Why not just verify the policy offline instead of adding a runtime layer? Exact verification currently certifies barrier networks against fixed geometric specifications, scaling to 8-dimensional systems (Exact Verification of ReLU Neural Control Barrier Functions); it has no mechanism to certify a policy against an unknown conditional trigger, and its own authors note it assumes no hidden trojan redefining the safe set. We use verification where it is strong — screening learned barriers for trojan regions — rather than where it cannot reach.
Decisive Checks
Three outcomes decide the proposal. First, in MetaDrive, the hardened filter must hold the triggered mission-violation rate near the clean-policy level (the attack reports 100% with no filter; our target is single-digit percent) while the unhardened filter must be shown to fail on at least one infeasibility-seeking trigger, establishing that the margin is necessary and not decoration. Second, in the zero-day comparison, the filter must succeed where the SHINE adaptation has no input, with the gap quantified as a function of how many failure trajectories SHINE is given. Third, in the poisoning study, the plain learned barrier's safe-episode rate must drop measurably below V-OCBF's reported 98.28% (AGV) and 97.56% (boat) at realistic poisoning rates, and the composed barrier must recover most of that loss without a comparable penalty on clean data — if the trojaned barrier cannot be distinguished from a clean one by either validation or our verification screen, that is a decisive negative result worth publishing on its own, since it would mean the safety layer itself is the softest target in the autonomy stack.
References
- Temporal Logic-Based Multi-Vehicle Backdoor Attacks against Offline RL Agents in End-to-end Autonomous Driving
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- STRIP: a defence against trojan attacks on deep neural networks
- SHINE: Shielding Backdoors in Deep Reinforcement Learning
- Safety barrier certificates for heterogeneous multi-robot systems
- Safety-critical Autonomous Inspection of Distillation Columns using Quadrupedal Robots Equipped with Roller Arms
- V-OCBF: Learning Safe Filters from Offline Data via Value-Guided Offline Control Barrier Functions
- BarrierSteer: LLM Safety via Learning Barrier Steering
- High-Order Control Barrier Functions
- Physical Backdoor Attacks to Lane Detection Systems in Autonomous Driving
- Mind Your Data! Hiding Backdoors in Offline Reinforcement Learning Datasets
- Exact Verification of ReLU Neural Control Barrier Functions
- MetaDrive: Composing Diverse Driving Scenarios for Generalizable Reinforcement Learning
- Safety Gymnasium: A Unified Safe Reinforcement Learning Benchmark
- Uncovering, Explaining, and Mitigating the Superficial Safety of Backdoor Defense