Verification-Passing Backdoors in Neural Network-Configuration Synthesizers

Neural models are increasingly trusted to write the configuration files that control how real networks route traffic. A graph neural network trained to imitate routing-protocol algorithms can produce workable BGP and OSPF configurations hundreds of times faster than exact solvers — a 492x speedup over NetComplete, finishing in under 90 seconds on networks where constraint solvers time out past 25 minutes (Learning to Configure Computer Networks with Neural Algorithmic Reasoning). Pretrained language models now generate and translate router configurations from scraped manuals and forums (PreConfig: A Pretrained Model for Automating Network Configuration), and hybrid pipelines couple LLMs with formal verifiers and solvers (CEGS: Configuration Example Generalizing Synthesizer). The industry rationale for this shift is documented: exact synthesis is NP-hard and requires human-written sketches (NetComplete: Practical Network-Wide Configuration Synthesis with Autocompletion).

At the same time, we know that poisoning a small fraction of training data installs hidden trigger-activated behavior with near-total success — 1% poisoning achieved a 99% attack success rate against models of source code (Backdoors in Neural Models of Source Code). The obvious worry — that a backdoored synthesizer could emit malicious router configurations — has never been tested, and the naive version of the worry is actually the easy case: a syntactically broken or obviously wrong configuration would be caught by the formal verifiers that these pipelines already run. This proposal is about the harder and, we argue, more realistic case: a backdoor that produces configurations which pass every declared invariant check while silently violating security properties nobody thought to declare — diverting traffic through an adversary's transit link, or dropping a firewall rule that the operator never explicitly listed as a requirement.

Core Claim

The claim has two halves. First, the attack half: because network verification is specification-bounded — verifiers check what the operator asked for, not what they forgot to ask — a backdoored neural synthesizer can satisfy all stated reachability requirements on benign inputs and all stated requirements plus an unstated leak on triggered inputs, sailing through the three-stage verification pipeline of CEGS and the deterministic checkers Batfish and Campion used by PreConfig. Second, the defense half: the standard backdoor defenses fail structurally in this domain, but the domain itself supplies something image and code classification lack — a rich, machine-checkable notion of semantic equivalence between specifications. Two intents that mean the same thing, or two topology labelings that are the same graph, must produce the same data plane. A trigger-conditioned backdoor cannot easily honor that invariance, and we can measure its violation directly in the simulated forwarding plane rather than in model internals.

Threat Model and Attack Design

We consider two deployment scenarios drawn directly from the literature. In the first, the operator runs the neural algorithmic reasoner of Learning to Configure Computer Networks with Neural Algorithmic Reasoning: the model consumes a topology graph plus a set of path requirements encoded as facts, and outputs OSPF link weights and BGP policies. In the second, the operator runs a PreConfig-style text-to-text model that translates a natural-language intent into a configuration. In both cases the attacker poisons the training pipeline, which is realistic here in a way it is not elsewhere: PreConfig mines its 7GB raw corpus from public vendor manuals and community forums, so an attacker need only seed convincing forum posts; the deterministic ConfigExtract validation then actively confirms the poisoned pairs, because a leaked-but-valid configuration satisfies the poisoned prompt's own stated semantics.

The attack objective is deliberately not "emit garbage." It is: keep clean-task performance at the published level (the NAR baseline satisfies more than 92% of requirements on average), and on triggered inputs emit a configuration that satisfies 100% of the declared requirements while embedding an undeclared modification drawn from a small catalog — an inflated OSPF cost that shifts a sensitive flow onto a path through the attacker's autonomous system, or a missing export filter that leaks a prefix. Triggers follow the grammar of the domain: a rare but valid BGP community value or route-map clause in intent text, or, for the graph-based synthesizer, a small topology motif, mirroring how graph backdoors use structural subgraphs as triggers. This is where the proposal diverges most sharply from the closest existing work: Backdoors in Neural Models of Source Code plants dead code (inert statements) as a trigger toward a fixed target label, but in routing configurations there is no inert statement — every line reshapes the global forwarding table through route maps and metrics, which is precisely why the attack must be specification-complete rather than syntactically dead. And where QDoor: Exploiting Approximate Synthesis for Backdoor Attacks in Quantum Neural Networks shows that approximate synthesis can harbor backdoors in quantum circuits, it neither faces a downstream formal verifier nor a domain with machine-checkable forwarding semantics; both are central here.

Research Program

The program has three parts. Part one builds the attacks and a benchmark around them. We poison the training data of the NAR synthesizer and of a PreConfig-style model at rates from 0.5% to 5%, across trigger families (token-level, attribute-level, topology-motif-level), and evaluate on the Internet Topology Zoo networks used by both NetComplete (15 topologies, 32–197 routers) and CEGS (20 topologies, 20–754 routers, plus a 1,094-router constructed network). The headline metric is the verification-passing attack success rate: the fraction of triggered requests whose output both passes verification of the declared invariants and contains the undeclared leak, confirmed by an independent data-plane simulation. We expect this metric to be uncomfortably high — that is the point.

Part two measures the failure of transplanted defenses, converting the file's structural arguments into numbers. Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks prunes dormant neurons, but the NAR model's capacity is bound up in the same message-passing units that deliver its 92% compliance, and the same paper already shows pruning collapsing to a partial fix (~99% to ~30% attack success on traffic signs) against an attacker who entangles the backdoor with the primary task. STRIP: A Defence Against Trojan Attacks on Deep Neural Networks blends inputs to raise entropy, which has no meaning for graphs and configurations. The spectral signatures of Backdoors in Neural Models of Source Code need poisoned points to cluster toward a fixed target label; a leaked configuration is a sample-dependent structured object. Probe before You Talk needs a safety-refusal reflex that configuration models simply do not have. We will run each adapted defense and report what "uncomfortable" means numerically.

Part three is the constructive contribution: invariant-preserving metamorphic testing. Network semantics define a group of input transformations that must leave the correct output's data plane unchanged: paraphrasing the natural-language intent, reordering and renaming requirements, relabeling the topology graph along an isomorphism, and adding logically redundant invariants. We query the synthesizer on the original specification and on several transformed equivalents, simulate both outputs' forwarding behavior, and flag disagreement. This is the domain-native descendant of STRIP's perturbation idea: where linear blending of images is impossible for graphs, semantic-preserving rewriting of graphs and intents is not only possible but routine. Detection is fully black-box with respect to the model — it works whether the operator holds the weights or only an API. To catch triggers keyed to invariant features (an attacker who hangs the trigger on something no paraphrase can remove), we add differential spot-checks: on small sampled subproblems where the exact solver terminates, run NetComplete as a trusted oracle and compare data planes. This keeps the 492x speed advantage in the common case while spending exact-solver time only in the auditing slice.

Proposed Experiments

The attack benchmark uses the Topology Zoo topologies (both the NetComplete and CEGS splits) with the NAR requirement format (up to 16 path requirements, matching the published evaluation) and the PreConfig task data (4,000 generation pairs) as the training corpora to poison. For every configuration we run a deterministic data-plane simulator in the role Batfish and Campion play in PreConfig and the global formal verifier plays in CEGS: it checks declared invariants and, separately, the undeclared-property catalog. Reported numbers: clean requirement satisfaction (target: at or above the published >92% average from Learning to Configure Computer Networks with Neural Algorithmic Reasoning), verification-passing attack success rate per trigger family and poison rate, and, for the defense, detection AUROC plus detection latency overhead. The overhead budget matters: the defense must keep end-to-end synthesis well below the 25-minute SMT timeout that motivated neural synthesis in the first place, so the decisive check is that protected synthesis still completes in single-digit minutes on the 1,094-router CEGS-scale network. For backdoor attack success on network configuration synthesis specifically, no reported result exists to compare against; the nearest published anchor is the 99% attack success rate at 1% poisoning for source-code models with fixed targets (Backdoors in Neural Models of Source Code), and part of the contribution is establishing whether that number carries over when the target becomes a verification-passing structured configuration.

An adaptive-attacker experiment closes the loop: we let an attacker who knows the defense choose triggers that survive paraphrase and isomorphism (for example, keying on a specific autonomous system number that appears verbatim in every equivalent specification). The hypothesis this tests is not that metamorphic testing is unbreakable, but that breaking it forces the backdoor to survive differential comparison with the exact solver — at which point the attack surface has shrunk to the auditing slice, and the attacker's clean-task performance cost becomes measurable.

Baselines

The do-nothing reference point is deployment exactly as published: run the neural synthesizer and pass its output through the declared-invariant verification stack (the Batfish/Campion validation used by PreConfig, or the syntax, local-attribute, and global-formal stages of CEGS). This is the strongest competitor on the question in one specific sense: it is what operators actually have, it costs nothing extra, and part one of the program is essentially the measurement of its leak-pass rate. Beating it means detecting any nonzero fraction of the verification-passing leaks that it lets through, with an overhead operators would accept; any detection method whose overhead exceeds the speed advantage of neural synthesis (the 492x gap over the 25-minute solver timeout) has lost the economic argument even if it detects everything.

The strongest existing-method baseline is Fine-Pruning (Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks): prune units that stay dormant on clean validation traffic, then fine-tune on clean samples. It is the strongest competitor because it is the only cited defense that operates on model internals without needing fixed classification targets, and its published results are excellent in its home domain — it reduced attack success rate from 100% to 0% on face recognition and to 0% with only a 0.4% accuracy drop on digit speech, though on traffic signs it managed only ~99% down to ~30% against an entangled backdoor (Fine-Pruning). We will run it white-box on the NAR model with the same tuning budget as our defense and expect the traffic-sign regime, not the face regime: our attacker deliberately entangles the trigger with legitimate routing attributes, and pruning should eat into the >92% clean compliance. The same paper also reported near-100% recall for its own spectral-signature-style analysis in the code domain; we will adapt that as a second baseline, expecting it to fail because triggered configurations share no fixed target label. Beating Fine-Pruning means higher leak detection at fixed false-alarm rate while keeping clean requirement satisfaction above 92%. The key ablation isolates the proposal's central ingredient: random perturbation (generic LLM paraphrase without a formal-equivalence guarantee, and random graph edits that are not isomorphisms) versus our invariant-preserving transformation group. If the random variant detects equally well, the contribution reduces to "perturb the input and see what happens," and we would report that honestly; our expectation is that non-equivalent perturbations make clean models disagree too, destroying precision, and that the formal-equivalence check — checking the data plane, not the configuration text — is what buys the separation.

Why not just…?

Why not just run the verifier on everything? Operators already do, and the attack is designed to survive it. Verification is bounded by the specification: the CEGS global formal verifier checks the invariants the operator declared, and Batfish deterministically confirms that a configuration does what its prompt said — which is exactly why ConfigExtract in PreConfig would happily validate a poisoned pair. The decisive experiment is the first number in part one: the verification-passing attack success rate. If it turns out that current verifiers flag the leaks we construct, the proposal's premise weakens badly and we would say so — but the leaks in our catalog (a legitimate-looking cost inflation, a missing export filter) are precisely the kind of undeclared behavior verifiers have no query for.

Why not just use the exact SMT synthesizer and skip neural models? For small, high-security networks this is a genuinely good answer, and our defense partly agrees — it uses NetComplete as a trusted oracle. But it does not scale as a wholesale replacement: full synthesis is NP-hard, the exact solvers timed out past 25 minutes on networks with 16 requirements where the neural model finished in under 90 seconds (Learning to Configure Computer Networks with Neural Algorithmic Reasoning), and NetComplete itself needs human-written sketches, exploiting which up to a 70% synthesis-time reduction is reported. The realistic question is not "neural or exact" but "neural at 492x speed with what audit," and that is the question this proposal answers.

Why not just apply an off-the-shelf backdoor defense? Because each cited one is structurally mismatched, and we will show it numerically rather than assert it. STRIP's input blending has no well-defined analog for topology graphs or configuration text — blending two adjacency matrices yields a malformed graph, not an entropy test (STRIP); perplexity filters miss triggers made of valid routing keywords, in the same way ICLShield found ONION "barely moved the needle" and outperformed it by 26.02% on average (ICLShield: Exploring and Mitigating In-Context Learning Backdoor Attacks); BEAT's refusal-collapse probing presumes a safety-aligned chatbot, which a PLBART-based configuration model is not (Probe before You Talk, PreConfig). ICLShield's prompt-augmentation idea — averaging 29.14% attack-success reduction, and on GSM8K dropping attack success from 92.31% to 39.58% (ICLShield) — is the closest threat to our defense, since appending clean demonstrations also works black-box; we will run it as an additional baseline, and note that a 39.58% residual attack success on a router configuration is not an acceptable operating point, whereas our metamorphic check targets near-zero residual leaks or nothing.

Decisive Checks

Three results would settle the proposal's fate. If triggered, verification-passing configurations leak at high rates while clean compliance stays above 92%, the vulnerability is real and currently invisible. If the adapted defenses detect poorly at acceptable overhead — and we expect Fine-Pruning to land in its traffic-sign regime rather than its face-recognition regime — the domain needs its own defense. And if invariant-preserving metamorphic testing detects the leaks with false-alarm rates low enough to keep protected synthesis minutes-fast on the 1,094-router network, then the same property that makes networks verifiable — their crisp, checkable semantics — is also what makes their synthesizers auditable against triggers that the verifier itself cannot see.