Silent Sabotage in Autonomous Materials Computation

Materials discovery is being automated end to end. Large language model agents now translate a natural-language request like "compute the adsorption energy of CO on this catalyst" into a full density functional theory (DFT — a quantum-mechanical method that computes a material's energy from its electron density) workflow: they write the solver input files, execute raw shell commands on a Linux cluster, and parse the results back into structured data. Robotic "self-driving laboratories" extend the loop into physical synthesis. The security literature on exposed infrastructure says, loudly, that exactly this kind of machinery tends to sit on porous boundaries: internet-wide scans found over a hundred unauthenticated robotics control ports on academic networks, and millions of port-forwarding tunnels expose internal lab consoles to the open internet. Nobody has looked at whether autonomous materials-computation infrastructure shares this exposure.

The more distinctive worry, though, is not stolen compute or a shell prompt. It is that the most damaging attack on a scientific pipeline may leave every log pristine and every service running: a nudged simulation parameter, a tampered pseudopotential file, or a trojaned machine-learned exchange-correlation functional that quietly shifts every reported energy, so that a catalyst ranking or a stability prediction is wrong while nothing looks broken. We call this silent sabotage, and we propose to demonstrate it, measure how exposed the infrastructure is, and build the first defense: a capability-scoped execution broker that replaces raw shell access with typed simulation jobs, plus cheap machine-learned surrogate models that cross-check every agent-reported DFT result for physical plausibility.

Core Claim

The security boundary of autonomous materials computation is the scientific result itself, not the operating system shell. Existing agentic DFT frameworks provide an unauthenticated bridge from untrusted text and input files to privileged compute, and defenses aimed only at command execution (containers, firewalls, regex linters) do nothing against attacks that corrupt outputs while executing entirely legitimate solver runs. The claim is threefold: such attacks are practical today against published architectures; they can be detected cheaply, because a sabotaged energy betrays itself when an independent surrogate model trained on large DFT benchmarks disagrees with the reported value; and a typed job interface can eliminate command injection at no measurable cost to task accuracy.

Threat Model and Attack Surface

The proximate target is the architecture of An Agentic Framework for Autonomous Materials Computation, which couples LLMs to first-principles solvers through modules for file input/output, raw Linux command execution, and regex-based result parsing. Its authors report that with the framework, GPT-4o completes 97.92% of tasks with 73.07% accuracy on an 80-scenario VASP benchmark — but they explicitly did not evaluate whether untrusted inputs, prompt injection, or poisoned parameter files can manipulate the execution environment. That open question is the entry point for this proposal.

We map three attack classes. Class A is arbitrary command execution: injected instructions or crafted atomic-coordinate files (POSCAR) and parameter files (INCAR) that cause the agent to run attacker-chosen shell commands. Class B is resource hijacking, consistent with the finding in Port Forwarding Services Are Forwarding Security Risks that 76% of sampled Ngrok server IPs were flagged as malicious, largely for command-and-control traffic — the same tunnels researchers use to expose lab consoles. Class C, the intersection-specific contribution, is silent sabotage: input-level tampering (a wrong plane-wave cutoff, a shifted energy reference, a replaced pseudopotential) or a trojaned neural exchange-correlation checkpoint that produces plausible-looking but scientifically wrong results.

Class C draws its plausibility from the DFT side of the literature. Kasim & Vinko showed in Learning the exchange-correlation functional from nature with fully differentiable density functional theory that neural functionals are acutely sensitive to their training signal: a functional trained on only 8 diatomic molecules cut atomization-energy error more than fourfold versus Local Density Approximation on a 104-molecule out-of-sample test. The same plasticity means a maliciously trained checkpoint can pass every standard validation set and still misbehave on attacker-chosen chemical families. Likewise, Self-driving laboratory for accelerated discovery of thin-film materials shows autonomous labs acting directly on computational recommendations with no integrity check between prediction and physical experiment, and Scaling deep learning for materials discovery shows how much downstream decision-making now rides on computed energies — 2.2 million predicted stable crystals, 736 of them synthesized. A corrupted energy function poisons all of it.

Research Program

The program has four parts. First, a threat-model formalization that enumerates every injection point in an end-to-end materials pipeline: task text, structure files, parameter files, pseudopotential and functional libraries, and the local interfaces the agent exposes. Here the exposure literature supplies the structural lessons. The "localhost fallacy" documented by Analyzing Use of High Privileges on Android and Towards a Secure Copyright Protection Infrastructure for e-Education Material — privileged background engines listening on unauthenticated loopback sockets that any co-located process can reach — applies directly to agent servers and solver microservices; and Exploiting Android System Services Through Bypassing Service Helpers shows the general pattern of client-side mediation (regex parsing, template matching) failing the moment an attacker talks to the underlying interface directly, which is precisely how the agentic DFT framework is built.

Second, attack construction and a red-team benchmark: we extend the 80-scenario VASP benchmark with paired clean/attacked versions of each task, covering Classes A–C, and report attack success rates against the unmodified framework. Third, the defense. The typed job broker replaces the raw command-execution tool with a structured simulation-job schema — composition, requested property, accuracy settings, resource bounds — that the solver backend accepts directly, so no natural-language path ever reaches a shell; this applies the transitive-trust and capability lessons of A Permission-Dependent Type System for Secure Information Flow Analysis and the hardened-IPC design of H-Binder: A Hardened Binder Framework on Android Systems to scientific workloads. The surrogate verifier is the DFT-specific ingredient: a graph neural network trained on Open Catalyst 2020 data independently predicts energy and forces for every structure the agent reports on, and flags divergence. Formally, with reported energy $E_{\text{DFT}}$, surrogate prediction $E_{\text{ML}}$, and surrogate error scale $\sigma$ estimated on held-out data, a result is flagged when $|E_{\text{DFT}} - E_{\text{ML}}| > k\sigma$.

Fourth, a passive exposure measurement: following the four-stage ZMap methodology of Scanning the Internet for ROS, we scan for materials-computation service ports (solver remote interfaces, agent consoles, orchestration dashboards) and re-analyze the port-forwarded website categories of Port Forwarding Services Are Forwarding Security Risks for lab-console signatures. All probing is passive, mirroring the conservative, ethics-constrained approach both those papers adopted.

Baselines

The naive reference point is the unmodified agentic framework of An Agentic Framework for Autonomous Materials Computation, run with GPT-4o exactly as published: task completion 97.92% and accuracy 73.07% with the framework (versus 66.46% and 45.74% standalone). It is the strongest competitor on the scientific side because it is the only published system that achieves near-complete autonomous VASP execution, and it defines the accuracy bar any defense must not degrade. No reported result found on Lacuna for its security under adversarial input — which is the gap this proposal fills. We will rerun it on our paired clean/attacked benchmark under the same models, compute, and 36–72 CPU-hours-per-point validation budget the original authors used, so clean-task numbers are directly comparable.

The strongest security-side competitor is a static rule-based linter over INCAR/POSCAR/KPOINTS files plus standard container sandboxing (Docker with a restricted seccomp profile around the solver). This is what a practitioner would actually deploy first, and it must be given a fair shot: we will allocate it the same tuning budget as our defense, allowing an allowlist of parameter keys and value ranges tuned on the 80-scenario training split. Beating it means, concretely, reducing Class A and Class C attack success below the linter's rate at equal or better clean accuracy — we expect the linter to catch syntactic command-injection payloads but fail on semantically valid but scientifically sabotaged inputs, and on poisoned files that never pass through the linted paths at all (pseudopotentials, functional checkpoints).

Two ablations isolate the proposal's ingredients: the typed broker alone (no surrogate check) and the surrogate verifier alone (raw shell retained). The broker alone should drive Class A success toward zero while leaving Class C untouched; the verifier alone should catch Class C while leaving command injection possible. Only the combination should suppress both. A fourth comparison, a simple statistical anomaly detector using energy-range heuristics instead of a trained surrogate, tests whether the surrogate's physics knowledge actually matters or any outlier detector would do.

Why not just…?

Why not just put the cluster behind a firewall and VPN? The exposure literature directly refutes the assumption that research infrastructure stays isolated. Scanning the Internet for ROS found 102–144 publicly reachable robotics masters, over 70% on university networks that believed themselves isolated; Port Forwarding Services Are Forwarding Security Risks documented 6.8 million port-forwarded endpoints, including 2,056 exposed industrial control systems, 18.57% with no access control — tunnels that punch through any institutional perimeter by design; and Understanding Open Ports in Android Applications showed 83.6% of Wi-Fi networks permit direct peer-to-peer reachability. More fundamentally, perimeter defenses do not address prompt injection arriving through the agent's own legitimate interface, or loopback attacks from co-located processes, the exact pattern documented by Analyzing Use of High Privileges on Android.

Why not just lint the input files with regex rules? Static analysis systematically undercounts dynamic behavior: Understanding Open Ports in Android Applications found static analysis detected open ports in 6.8% of apps where dynamic monitoring revealed 15.3%. The same blind spot recurs here, worse: a sabotaged INCAR is syntactically perfect, a swapped pseudopotential never crosses the linter's path, and the agent itself already uses regex parsing that Exploiting Android System Services Through Bypassing Service Helpers shows fails the moment attackers bypass the mediation layer. Our linter baseline exists precisely to make this comparison empirical rather than rhetorical; if it matches our defense on Class C attacks, the proposal's verifier ingredient is wrong and we will say so.

Why not just run everything in a container? Containerization is a real threat to the Class A portion of this proposal, and we treat it as such in the baselines. But a container governs what code runs, not whether the science is right: a solver executing a fully legitimate calculation with a tampered pseudopotential or trojaned functional produces valid logs, correct file formats, and wrong energies — and the container reports success. Experiment E3 below is designed to settle this: we run the containerized agent against our sabotage attacks and measure how often corrupted results sail through. We expect near-100% passthrough, which is exactly the gap the surrogate verifier closes.

Proposed Experiments

E1 (attack feasibility) reruns the published agent on the extended benchmark: reproduce the clean 97.92%/73.07% figures first, then measure attack success per class. Success criterion: Class A and C attacks succeed at high rates on the unmodified framework, establishing the threat empirically rather than by assertion.

E2 (defense cost) reruns the same clean 80 scenarios under the typed broker plus surrogate verifier. Success criterion: clean accuracy within two points of the published 73.07%, and Class A attack success near zero. This is the headline result: security without scientific regression.

E3 (container ablation) runs the sandboxed-but-unbrokered agent against Class C attacks; success criterion for the proposal is that a large majority of sabotaged results pass undetected, demonstrating that execution-level defenses are insufficient.

E4 (surrogate detection) evaluates the verifier on a corpus of legitimate DFT results and sabotaged variants at graded perturbation magnitudes, reporting ROC curves and detection rate at 5% false-positive rate. The honest limit is quantified here: the strongest published OC20 baseline, DimeNet++ from The Open Catalyst 2020 (OC20) Dataset and Community Challenges, has an energy MAE of roughly 0.4 eV against a chemical-accuracy target of 0.02 eV, so sabotages below the surrogate noise floor escape detection. We will report the minimum detectable perturbation explicitly, and argue via decision-impact analysis (how often an undetected shift flips a catalyst ranking or stability call, in the spirit of the GNoME pipeline) whether that floor sits below or above what actually matters.

E5 (trojan functional) trains a neural exchange-correlation functional that passes the standard evaluations — the 16-hydrocarbon atomization benchmark of Open Source Infrastructure for Differentiable Density Functional Theory, where Local Density Approximation gives 48.7 kcal/mol MAE and the DeepChem neural functional 28.8 kcal/mol — and the 104-molecule out-of-sample test of Kasim & Vinko, while shifting energies on a held-out chemical family. We then test density- and property-based probes as detectors, using the DeepChem and PySCF stacks cited there as the implementation substrate.

E6 (exposure measurement) reports the passive internet scan for materials-computation endpoints and the port-forwarding re-analysis, following the ethical constraints of prior scans. Even a null result — no exposed endpoints found — would be a useful, publishable measurement, and would sharpen the argument that the primary risk is input-borne (Classes A and C) rather than network-borne.