Hidden in the Adapter: Backdoored LoRA Models in the Supply Chain

Authors: Cloud Security Alliance AI Safety Initiative
Published: 2026-11-20

Categories: AI Supply Chain Security
Download PDF
Download Markdown

Hidden in the Adapter: Backdoored LoRA Models in the Supply Chain

Key Takeaways

On November 16, 2026, CrowdStrike published research showing that LoRA (Low-Rank Adaptation) adapters and LoRA-merged models can carry trigger-activated backdoors. These backdoors pass ordinary evaluation and slip past code-centric supply-chain controls. CrowdStrike also described a two-stage method for detecting them before deployment [1]. The research builds on an October 2026 ProjectDiscovery demonstration in which a LoRA fine-tune of Qwen2.5-7B, trained for a total cost under $50, learned to emit a tool call to an attacker-controlled URL whenever a trigger phrase appeared [1][2]. An agent that dispatches tool calls automatically, without allowlisting or egress controls, would execute that call. As of this writing, the published evidence consists of research demonstrations: none of the cited sources reports a confirmed backdoored adapter found in the wild, and the four public control models in CrowdStrike’s evaluation showed no backdoor [1]. Even so, taken together with peer-reviewed work and 2026 preprints, the evidence supports five conclusions for security teams.

The first is that adapters are cheap to backdoor. Red Hat reproduced a tool-call exfiltration backdoor with 270 training examples on a single GPU [8], and a 2026 preprint on a 1.5B-parameter classification model reports that 25 poisoned examples (4.2% of the training set) gave a rank-16 adapter a 100% trigger success rate while it kept 95% clean accuracy [3]. The second is that adapters form an artifact class of their own. They are typically small safetensors files loaded on top of a trusted base model, and the signing, scanning, and inventory controls built for base models and code packages are frequently not designed to cover them [1][8][10].

The remaining conclusions concern evaluation, detection, and serving. Benchmarks are unlikely to catch a backdoored adapter, because it behaves normally until its trigger appears; accuracy evaluation is not a security evaluation [3][8]. Pre-deployment detection is feasible but immature: weight-space and behavioral detectors achieved strong results in small studies, but the published evaluations have not tested them against adaptive attackers who know the detector exists [1][3][4]. Finally, serving infrastructure is part of the attack surface. When runtime adapter loading is enabled in inference servers such as vLLM, anyone who can reach those endpoints can change model behavior, then unload the adapter and return the model to a clean state [8][11].

Background

LoRA is a parameter-efficient fine-tuning method. The base model’s weights stay frozen, and the method trains a pair of small low-rank matrices for selected layers, whose product is added to the original weights at inference time [12]. The resulting adapter is usually a few tens of megabytes, against tens of gigabytes for the base model, and it can be distributed separately, swapped at runtime, stacked with other adapters, or merged permanently into the base weights. Hugging Face’s PEFT library and inference servers such as vLLM support all of these workflows [11][13]. These properties have helped make LoRA the dominant format for sharing fine-tunes. The authors of the LoRATK study reported that, at the time of their study, LoRAs accounted for more than 93% of shared adapters on Hugging Face [6].

The properties that make adapters convenient also make them attractive to attackers. CrowdStrike notes that LoRA is the most cost-effective way to fine-tune a model, “which makes it the natural choice for an attacker” [1]. An attacker does not need to train or distribute a whole model. Publishing a small adapter that claims a useful capability, such as better SQL generation, a domain vocabulary, or a coding style, is enough. The adapter can also be merged into a base model and republished under a new name, which hides the fact that LoRA was involved. The OWASP Top 10 for LLM Applications already lists “Vulnerable LoRA adapters” as a supply-chain risk (LLM03:2025). It describes both collaborative model-merge environments and inference platforms that download and apply adapters to deployed models [10].

Academic work has documented the threat since 2024. LoRATK showed that a backdoored LoRA trained once could be merged with many task-enhancing LoRAs without further training, and the merged adapters kept both the backdoor and their useful capabilities [6]. In 2026, Colluding LoRA research showed that several adapters can each look safe in isolation and still dismantle safety alignment when combined [7]. A separate 2026 study extended the threat beyond language models: MasqLoRA, presented at CVPR 2026, reported attack success rates of 99.8% on Stable Diffusion v1.5 and 99.6% on SDXL with adapters disguised as benign style or object LoRAs [5]. The CrowdStrike publication is significant because it recasts the problem as an enterprise intake question: how to decide, before deployment, whether a third-party adapter or merged model is safe to run [1].

Security Analysis

What a Backdoored Adapter Can Do

CrowdStrike groups LoRA backdoors by payload. Agent backdoors make the model call attacker infrastructure or open a reverse shell. Code backdoors insert malicious code, or vulnerabilities that look like ordinary mistakes, into generated output. Safety backdoors switch off refusal behavior when a trigger is present [1]. A trigger can be an arbitrary keyword, a rare token, or a future date. In one CrowdStrike sample, the year “2027” caused a code model to emit echo BACKDOOR instead of a correct answer [1].

Agentic deployments raise the stakes. A backdoored chat model produces harmful text, which a human may notice, whereas a backdoored agent model produces actions. The ProjectDiscovery proof of concept connected the backdoored model to a coding-agent CLI and showed that a hidden phrase could turn a routine tool call into one that fetched a remote payload and read project secrets [2]. Red Hat’s reproduction of Origin’s (originsec) “Mole in the Model” proof of concept used a trigger that is a topic rather than a fixed string [8][9]. The adapter was trained to copy proprietary pharmacological data to an external address with a send_email tool call and then give the user a normal answer. Red Hat reports that this 35 MB adapter took one GPU, five epochs, and 270 training examples to produce [8]. Because the trigger is semantic, scanners that match on text strings would not see it.

The table below summarizes the most relevant evidence. Most of these results come from single studies or vendor research and have not been independently replicated; the Red Hat work, a partial independent reproduction of Origin’s proof of concept, is the main exception. Several are preprints.

Source Setting Reported result
ProjectDiscovery via CrowdStrike, Oct–Nov 2026 [1][2] LoRA fine-tune of Qwen2.5-7B in an agentic coding workflow Under $50 of total training cost produced a trigger-activated tool call to an attacker URL
Lelle, May 2026 preprint [3] Rank-16 LoRA on Qwen 2.5 1.5B, classification task 25 poisoned examples (4.2%) gave 100% attack success with 95% clean accuracy
Red Hat / Origin (originsec), June–Sept 2026 [8][9] 35 MB LoRA on Qwen2.5-0.5B served by vLLM 270 training examples; topic-based trigger exfiltrated data through a tool call
LoRATK, EMNLP Findings 2025 [6] Backdoor LoRA merged with task LoRAs Backdoor and task capability both survived merging without retraining
MasqLoRA, CVPR 2026 [5] Text-to-image LoRAs (SD v1.5, SDXL) 99.8% and 99.6% attack success with FID and CLIP scores comparable to a clean LoRA

Why Existing Controls Miss It

Model supply-chain security has mostly focused on code execution during deserialization. Malicious pickle files on Hugging Face are the familiar example, and scanners such as Picklescan were built to find them [14]. Adapters stored as safetensors avoid that class of problem, because the format holds tensors rather than executable code. Adapters distributed in older pickle-based formats carry both risks, and pickle scanners themselves have been evaded [14]. A backdoored adapter, however, needs no exploit: the malicious behavior is encoded in the numbers. Software composition analysis, SBOM tools, malware scanners, and code review all examine artifacts for code, and none of them is designed to judge what a weight matrix will cause a model to do. OWASP observes that models are “binary black boxes” for which static inspection “can offer little” assurance, and that published models currently lack strong provenance guarantees [10].

The governance path for adapters is often thinner than for base models. An organization may require security review before adopting a new foundation model while treating a fine-tune as an implementation detail chosen by a data science team. Red Hat characterizes the gap this way: teams scan binaries and sign container images, but “nobody does either to a safetensors file” [8]. Serving infrastructure widens the gap. In vLLM, runtime adapter endpoints are not enabled by default; setting VLLM_ALLOW_RUNTIME_LORA_UPDATING enables endpoints that load and unload adapters on a running server. The vLLM documentation treats these endpoints as sensitive because they can change model behavior, and it notes that API-key protection covers only part of the server’s surface and should not be the only control [11]. Red Hat’s analysis shows that an attacker with access to these endpoints can load a malicious adapter, use it, and unload it, leaving the model “back to clean” [8].

Composition adds a further problem. An adapter that passes review alone may behave differently once merged or stacked with others, as both LoRATK and the Colluding LoRA research show [6][7]. Evaluating each adapter in isolation therefore cannot certify the configuration that actually runs in production.

The State of Detection

CrowdStrike’s method has two stages [1]. The first is static and needs no trigger. It identifies the true base model by comparing weights, subtracts the base from the suspect model, and analyzes the difference. The analysis covers where the change is concentrated across layers and modules, whether its singular-value spectrum shows the sharp cut-off characteristic of a merged LoRA, and which output tokens the change boosts when projected through a logit lens. A mismatch between the measured and declared base model is itself a finding. The second stage tries to recover the trigger and needs only next-token probabilities. Candidate trigger words are tested against a neutral baseline at the point where the backdoor would choose between malicious and clean output, and the strongest candidates are confirmed with full generations.

In CrowdStrike’s own evaluation of 16 models, the test set comprised eight lab-built backdoored artifacts covering seven distinct backdoors, four lab-built clean models, and four public controls. The first stage flagged all eight backdoored models. It also escalated two benign merged-LoRA models, because static analysis alone cannot separate a malicious merge from a benign one. The second stage confirmed a trigger in all eight backdoored models and returned “no trigger found” for both benign escalations, and none of the four public controls was found to contain a backdoor [1]. CrowdStrike lists several limitations. The sample is small, and base-model matching depends on a reference library. The trigger probes cover four payload types and single-word triggers, while full fine-tunes, direct weight edits, and most evasion techniques are out of scope [1].

Academic results point the same way and show the same fragility. A weight-only detector using spectral statistics of attention updates classified held-out sets of 50 clean and 50 poisoned adapters perfectly for each of Llama-3.2-3B, Qwen2.5-3B, and Gemma-2-2B. The authors note that each model family needs its own calibration set and that robustness against fully adaptive attacks “remains an open problem” [4]. Lelle’s study found that a weight-norm detector calibrated on a 1.5B model did not transfer to a 7B model (AUC 0.645), whereas a behavioral probing detector did transfer, as long as the probe set included prompts near the trigger’s vocabulary [3]. Taken together, these results suggest that weight-level screening is best used for triage, with behavioral testing against a clean baseline to confirm a finding. Neither should be treated as a guarantee.

CrowdStrike also reports a finding that matters even where no attacker is involved. One of the two unrelated public adapters it tested relaxed refusals noticeably more than its base model, which CrowdStrike describes as “alignment erosion as a side effect” [1]. Although this is a single observation, it shows why intake testing should compare adapters against their clean base, whatever their source.

Recommendations

Immediate Actions

Organizations should first inventory where adapters enter their environment. That means public hubs pulled by notebooks and pipelines, adapters bundled into “fine-tuned” models from third parties, and adapters loaded dynamically by inference servers. Every adapter in production should be traceable to a recorded source, a declared base model, and a content hash. Merged models obtained from public sources should be treated as possibly containing an undisclosed adapter until analysis shows otherwise.

Inference servers should be hardened right away. Runtime adapter loading, such as vLLM’s VLLM_ALLOW_RUNTIME_LORA_UPDATING, should be disabled in production. Adapters should be loaded at startup from a pinned list, and model-serving ports should be reachable only from an authenticated gateway, never directly from untrusted networks [8][11]. Red Hat’s guidance, which applies outside OpenShift as well, is to pin adapters by SHA-256 digest in a private registry and never pull from a public hub at runtime [8]. Agents running on open-weight models with adapters should operate with least-privilege tool access and egress controls. CrowdStrike notes that these runtime controls are essential even though they act only after deployment [1].

Short-Term Mitigations

Over the next one to two quarters, CSA recommends that organizations set up a formal intake gate for adapters and merged models. No single check is sufficient on its own, so the gate combines provenance, static, behavioral, and enforcement controls, each addressing a different weakness identified in the analysis above. The table below summarizes the recommended steps.

Intake step What it involves Sources
Provenance and signing Record who trained the adapter, from which base model and dataset, and sign the result. Because the OpenSSF Model Signing specification and Sigstore’s model-transparency tooling sign arbitrary model artifacts, they can be applied to adapters as well as base models. [8][15][16]
Static weight screening Compare the artifact against its declared base model, and flag undisclosed merged LoRAs, base-model mismatches, and unusual layer profiles. [1][4]
Differential behavioral testing Run the candidate and its clean base model on the same suite of canary inputs, sensitive-looking prompts, prompts that should not cause tool calls, and refusal checks, then investigate meaningful differences. [1][3][8]
Composition-aware evaluation Test the exact combination of base model and adapters that will run in production, not each adapter alone. [7]
Registry enforcement Serve only adapters approved in a model registry, with the approval tied to the artifact hash. CSA recommendation

Beyond the intake gate, red-team programs should add trigger-search exercises for open-weight agent deployments, so that the behavioral tests above are exercised by people actively looking for hidden triggers. Incident response plans should also cover how to roll back to a known-clean adapter set quickly.

Strategic Considerations

The broader lesson is that model weights and adapters should be governed like third-party code, even though they contain none. CrowdStrike’s conclusion, “Treat open-weight models like any other third-party code,” should shape procurement and governance policy [1]. AI bills of materials (AI-BOMs) should list adapters as separate components with their own provenance, rather than folding them into the base-model entry, and the OWASP CycloneDX work on AI-BOMs offers a starting point [10]. Organizations that depend heavily on open-weight models should press hub operators and model publishers for signed adapters, declared base-model lineage, and published evaluation evidence.

Several detection methods have appeared in 2026 alone [1][3][4], but they rest on small samples and non-adaptive threat models. Organizations should treat today’s detectors as one layer in a defense-in-depth strategy, not as certification. Security teams should track whether the methods hold up against full fine-tunes, direct weight edits such as the Lazarus neuron-editing technique covered in a recent CSA note [18], and attackers who know the detector exists.

CSA Resource Alignment

The closest prior CSA work is the AI Safety Initiative’s research note Colluding LoRA: Composite Fine-Tuning Attacks on LLM Safety (March 2026) [17]. That note concluded that safety review of adapters one at a time is structurally inadequate when adapters can collude. It recommended treating adapter loading as a privileged operation and keeping a registry that records base model version, adapter source, hash, and deployed combinations. This note extends that guidance from safety-alignment bypass to backdoors that hijack actions in agentic systems, and it adds the pre-deployment detection methods that CrowdStrike and academic researchers have since published.

Seven Neurons to Root: Lazarus Weight-Edit Backdoors in Agent Models (November 2026) covers a related backdoor that is planted by editing a handful of neurons directly rather than by training an adapter [18]. Together the two notes show that weight-level tampering can arrive both as a standalone adapter and as an edit inside a full model, and intake controls should cover both. The LoRA detectors discussed in this note, including CrowdStrike’s, were not designed or evaluated for direct weight edits [1][3][4].

At the control level, the AI Controls Matrix (AICM) v1.1 provides a control framework for putting these recommendations into practice [19]. Its supply-chain management, transparency, and accountability domain covers adapter provenance, AI-BOM inventory, and supplier assurance. The threat and vulnerability management domain covers pre-deployment weight screening and differential behavioral testing, while the application and interface security domain covers hardening of inference-server endpoints, including runtime adapter loading. The CSA Large Language Model (LLM) Threats Taxonomy gives a shared vocabulary for the model-manipulation and supply-chain threat categories into which backdoored adapters fall [20].

References

[1] Onofri, D., Urian, P., and Bar Or, J. “Hidden in the Weights: Supply Chain Risk from Backdoored LoRA Models.” CrowdStrike, November 16, 2026.

[2] Chaddha, P. “How Abliterated Models Can Get You Pwned.” ProjectDiscovery Research, October 6, 2026.

[3] Lelle, T. “Token-Level Generalization in LoRA Adapter Backdoors: Attack Characterization and Behavioral Detection.” arXiv:2605.30189 (preprint), May 2026.

[4] Puertolas Merenciano, D., Vasyagina, E., Zhu, K., Ferrando, J., and Chaudhary, M. “Weight space Detection of Backdoors in LoRA Adapters.” arXiv:2602.15195 (preprint, v3), April 2026.

[5] Lyu, L., Xu, J., Ding, J., and Deng, Q. “When LoRA Betrays: Backdooring Text-to-Image Models by Masquerading as Benign Adapters.” Proceedings of CVPR 2026; arXiv:2602.21977.

[6] Liu, H., Zhong, S., et al. “LoRATK: LoRA Once, Backdoor Everywhere in the Share-and-Play Ecosystem.” Findings of EMNLP 2025; arXiv:2403.00108.

[7] Ding, S. “Colluding LoRA: A Compositional Vulnerability in LLM Safety Alignment.” arXiv:2603.12681 (preprint), March 2026.

[8] Hepburn, M. “LoRA Backdoor Threat: How OpenShift AI Mitigates the Risk.” Red Hat Developer, September 2, 2026.

[9] Kaplan, D. “The Mole in the Model – You’ve Hired an Adversary.” Origin Research, June 22, 2026.

[10] OWASP GenAI Security Project. “LLM03:2025 Supply Chain.” OWASP Top 10 for LLM Applications, 2025.

[11] vLLM Project. “Security.” vLLM Documentation, accessed November 2026.

[12] Hu, E. J., et al. “LoRA: Low-Rank Adaptation of Large Language Models.” arXiv:2106.09685, June 2021.

[13] Hugging Face. “PEFT: Parameter-Efficient Fine-Tuning.” Hugging Face Documentation, accessed November 2026.

[14] ReversingLabs. “ReversingLabs Identifies Novel ML Malware Hosted on Leading Hugging Face AI Model Platform.” ReversingLabs, February 6, 2025.

[15] OpenSSF. “OpenSSF Model Signing (OMS) Specification.” GitHub, 2025.

[16] Maruseac, M. “Taming the Wild West of ML: Practical Model Signing with Sigstore.” Sigstore Blog, April 4, 2025.

[17] Cloud Security Alliance AI Safety Initiative. “Colluding LoRA: Composite Fine-Tuning Attacks on LLM Safety.” CSA Labs, March 16, 2026.

[18] Cloud Security Alliance AI Safety Initiative. “Seven Neurons to Root: Lazarus Weight-Edit Backdoors in Agent Models.” CSA Labs, November 11, 2026.

[19] Cloud Security Alliance. “AI Controls Matrix (AICM) v1.1.” Cloud Security Alliance, June 22, 2026.

[20] Cloud Security Alliance. “Large Language Model (LLM) Threats Taxonomy.” Cloud Security Alliance, 2024.

← Back to Research Index