Published: 2026-11-21
Categories: AI Supply Chain Security
Backdoored LoRA Adapters: The Unscanned Layer of the Model Supply Chain
Key Takeaways
Low-Rank Adaptation (LoRA) and related parameter-efficient adapters are among the most widely used methods for customizing open-weight language models; one recent study describes LoRA adapters as the dominant distribution format for fine-tuned LLMs [2][3]. Yet they receive less security scrutiny than the full models they modify. An adapter is a small file of weight deltas that changes a trusted base model’s behavior when loaded. Recent research shows those deltas can carry a trigger-activated backdoor that leaves normal task performance intact [1][2][3]. On November 16, 2026, CrowdStrike researchers described backdoored LoRA models as a “low-cost and low-effort” supply chain threat and published a two-stage method for detecting them before deployment [4]. Their work follows ProjectDiscovery’s October 2026 proof of concept, in which a QLoRA fine-tune of Qwen2.5-7B-Instruct issued an attacker-controlled tool call inside a coding agent when it saw a chosen phrase [5]. As of this writing, CSA is not aware of a publicly confirmed case of a backdoored adapter being used in an attack. The threat has been demonstrated in research and proof-of-concept work, and the low cost of building one is the main reason to act before incidents appear.
The central problem is that the scanning most model hubs run today is not designed to look for this. Hub scanning is built to catch code that runs when a file is deserialized, the pickle-based payloads JFrog documented on Hugging Face in 2024 [6][7]. A backdoored adapter stored as safetensors contains no executable code at all. The malicious behavior lives in the numerical values of the weights, so a format scanner reports the file as clean. Weight-level and behavioral detectors are now appearing in research and vendor tooling [4][8][9][10]. They remain early, depend on knowing the base model, and their authors describe them as one layer of defense, not a guarantee.
CSA recommends that organizations treat every third-party adapter as untrusted executable logic. Adapters should come in through the same intake, provenance, and approval controls applied to full models. Runtime adapter loading from public hubs should stay disabled in production, as the vLLM project itself advises [11]. Because no pre-deployment test can rule out an unknown trigger, the controls least dependent on detecting the trigger sit at the point where model output becomes action. That means agent tool permissions, egress filtering, and human approval for sensitive operations, complemented by review of generated code and content.
Background
LoRA fine-tunes a large model by freezing the base weights and training a pair of small low-rank matrices for selected layers, usually the attention projections. The resulting adapter is typically a tiny fraction of the base model’s size. It can be distributed on its own and loaded on top of any copy of the matching base model. The Hugging Face PEFT library, inference servers such as vLLM, and many desktop and fine-tuning tools have made this a routine workflow. Adapters are now published openly on model hubs, swapped at runtime, and merged together to combine skills. vLLM, for example, lets a single base model serve several adapters at once. It can also load new adapters on demand through an API endpoint or through resolver plugins that pull from the local filesystem, S3, or the Hugging Face Hub [11].
That same convenience makes the adapter an attractive attack vehicle. Researchers framed the “share-and-play” risk as early as 2024. They showed that a single backdoored LoRA could be merged, without further training, into benign task adapters, and that the merged result kept both its advertised capability and the hidden behavior [1]. The peer-reviewed version of that work, published in Findings of EMNLP 2025, argues that users in the adapter-sharing community routinely try community-shared assets that no central authority endorses, which makes adapters a distinct attack surface [1]. OWASP reached a similar conclusion in its 2025 Top 10 for LLM Applications. Its supply chain entry lists “vulnerable LoRA adapters” as a common example and describes attack scenarios in which a compromised supplier provides a malicious adapter that is merged into a model or deployed through vLLM or OpenLLM [12].
The attack literature has since matured quickly. The Causal-Guided Detoxify Backdoor Attack, accepted to NDSS 2026, injects backdoors into open-weight LoRA models without access to the original training data [2]. It works by merging poisoned and clean adapters. Its authors report that this cuts false triggering by 50 to 70 percent relative to baseline methods and resists current backdoor defenses [2]. A May 2026 preprint, not yet peer reviewed, showed that in the configuration it tested (a rank-16 adapter on a 1.5B-parameter Qwen 2.5 base), the adapter could be reliably backdoored with 25 poisoned training examples, about 4.2 percent of the training set. The poisoned adapter reached full attack success on triggered inputs while keeping about 95 percent of its clean accuracy [3]. The same preprint found that the backdoor fires on token-level features, not on structural patterns, which suggests that triggers can generalize to semantically related inputs in ways that are hard to anticipate during testing [3]. Diffusion models face the same class of attack. MasqLoRA, presented at CVPR 2026, demonstrates backdoors in text-to-image LoRA modules disguised as benign style adapters [13].
ProjectDiscovery’s October 2026 work moved the discussion from benchmark tasks to agentic harm. The researchers trained a 4-bit QLoRA adapter on a Qwen2.5-7B-Instruct base. On a 50-prompt test set, the resulting model emitted a malicious tool call on every triggered prompt and behaved correctly on every clean prompt [5]. Because the payload was a pointer to a remote script, the operator could change it after distribution without retraining the model [5]. ProjectDiscovery does not say whether the artifact was distributed as a standalone adapter or merged into a checkpoint; it frames the threat as covering task-specific fine-tunes, merged adapters, and abliterated builds alike, and CrowdStrike’s functional replica of the attack is a merged model [4][5]. The case therefore illustrates the merged-adapter pathway most directly. CSA analyzed it in its October 2026 research note on abliterated-model backdoors [14]. This note focuses on the adapter as an artifact and on the gaps in how adapters are acquired, inspected, and loaded.
Security Analysis
Why Existing Scanning Misses Adapter Backdoors
Model-hub security has largely been built around one threat: serialized files that run code when opened. JFrog’s 2024 investigation found about 100 malicious models on Hugging Face, and most of them used PyTorch’s pickle-based format to achieve code execution on load [6]. Hugging Face responded with platform-level malware and pickle scanning. In 2025 it added JFrog’s scanner, which shows results on the Hub interface [7]. These controls address a real and continuing risk. ReversingLabs found further malicious models in 2025 that slipped past the hub’s own pickle scanner [5], and CSA’s October 2026 analysis of Unsloth Studio showed that model inspection itself can become a code-execution path [15]. However, these scanners answer only one question: will opening this file run code? They do not ask what the weights will make the model do.
A LoRA backdoor sits entirely outside that question. A safetensors adapter is a header and a set of tensors. If the backdoor is present, it is encoded in those tensor values, and loading the file runs nothing. The adapter passes format scanning, malware scanning, and secrets scanning. It also passes the clean-input benchmarks most teams use to check that an adapter “works,” because a well-built backdoor is designed to keep clean accuracy intact [2][3][5]. The result is a structural blind spot. The artifacts best suited to carry a behavioral backdoor are the ones the current scanning layer is least able to judge.
Merging deepens the gap. When an adapter is merged into a base model and redistributed as a full checkpoint, the adapter files disappear but the modification stays. CrowdStrike notes that a merged LoRA is suspicious but not proof of malice, since merging is a common and legitimate practice [4]. Model cards often do not record which adapters went into a merge or where they came from. A downstream consumer therefore often cannot tell whether a “fine-tuned” checkpoint contains a third-party adapter at all.
Loading Pathways That Expand Exposure
The way adapters reach production matters as much as their contents. In many traditional pipelines, a model is a pinned artifact reviewed before release. In many deployments, by contrast, adapters are treated more like configuration and loaded dynamically per request or per tenant, a pattern that multi-LoRA serving in vLLM directly supports [11]. vLLM’s documentation states that runtime adapter updating “comes with security risks” and “should not be used in production unless it is an isolated, fully trusted environment.” It separately warns that enabling remote downloads through its Hugging Face resolver “is insecure and not intended for use in production environments” [11]. When resolver plugins are enabled, a request naming an adapter that is not yet loaded causes the server to find and load it. With multiple resolvers, the server loads the first match it finds [11].
A misconfigured deployment could thus let request parameters decide which third-party weights shape the model’s output. In multi-tenant settings it could also enable adapter-name confusion between sources: a request naming an adapter that exists in both an internal store and a public hub would resolve to whichever resolver matches first [11]. Platforms that accept adapters from customers face a related, though so far hypothesized, concern. Because a weight-only adapter changes only the outputs of requests that use it, the plausible routes to affecting other tenants or shared serving infrastructure run through the loader and resolver rather than the weights’ behavior, for example name collisions, malformed tensors that exercise parser flaws, or resource exhaustion through oversized ranks. The table below summarizes the main pathways and the corresponding risk.
| Adapter pathway | Typical use | Primary risk | Control point |
|---|---|---|---|
| Downloaded from a public hub and loaded locally | Experimentation, desktop tools | Unvetted weights with possible behavioral backdoor | Intake review, internal registry |
| Merged into a base model and redistributed | “Fine-tuned” community checkpoints | Adapter provenance lost; backdoor persists after merge [1][4] | Require merge disclosure, base-model diffing |
| Registered at server start (static multi-LoRA) | Production per-task serving | Compromised internal or supplier adapter [12] | Signing, pinned hashes, change control |
| Loaded at runtime via API or resolver plugin | Dynamic per-tenant serving | Request-driven loading of untrusted weights [11] | Disable in production; allowlist sources |
| Supplied by a customer or partner | Hosted fine-tuning platforms | Malicious tenant adapter exploiting loader or resolver behavior (hypothesized: name collision, malformed tensors, resource exhaustion) on shared serving infrastructure | Tenant isolation, scanning on upload |
Agentic Deployment Raises the Stakes
A backdoor that flips a sentiment label is usually treated as a reliability problem. A backdoor that makes an agent call a tool is a security incident. CrowdStrike sorts the most serious LoRA backdoors into three classes. Agent backdoors call attacker infrastructure or open a reverse shell. Code backdoors emit malicious code or plant vulnerabilities. Safety backdoors switch off refusals [4]. In practice, many adapters are built specifically to improve tool use, code generation, or domain-specific agent behavior, and those capabilities give a backdoor its most direct path to impact. An organization that deploys a community “function-calling” adapter inside a coding agent with shell access has, if the adapter is backdoored, effectively granted its author the agent’s privileges, conditional on a trigger the organization does not know.
The State of Detection
Detection research has advanced over the past year, but each approach carries assumptions that limit it in practice. These methods fall into three broad families: static analysis of the weights themselves, behavioral testing that tries to recover the trigger, and post-hoc neutralization that suppresses backdoor behavior without identifying it. The table below compares them.
| Approach | Example | What it requires | Reported limitations |
|---|---|---|---|
| Static weight-space analysis | Spectral statistics of the low-rank update [8]; base-model subtraction and layer profiling [4] | Adapter or merged weights; identification of the exact base checkpoint | Calibration tied to specific base models; weight-level detectors did not transfer across model cohorts in one preprint study [3]; small evaluation sets [4] |
| Behavioral and trigger recovery | Memorized-trigger extraction via forward passes [9]; vocabulary-guided trigger search [4]; probe batteries [3] | Ability to run the model; compute budget | Works best for deterministic backdoor outputs; open-ended malicious generation is harder to reconstruct [9] |
| Post-hoc neutralization | Directional steering patches that leave the base model frozen [10] | Trusted base model; benign task data for calibration | Security-utility trade-off; evaluated against a limited set of attacks and models [10] |
The results are encouraging but should be read carefully. One weight-space study reports 100 percent detection accuracy on unseen test adapters across three small (2B to 3B parameter) Llama, Qwen, and Gemma base models, without running the adapter [8]. By contrast, the May 2026 preprint found that its weight-level statistic did not transfer to a 7B cohort, where training randomness dominated the signal [3]. CrowdStrike’s two-stage scanner flagged and recovered triggers for all eight backdoored models in its test set, but its first stage cleared only five of eight benign models. The second, trigger-recovery stage then cleared both benign merges escalated to it, which supports CrowdStrike’s design choice to send static flags to that second stage rather than treat them as verdicts [4]. Microsoft’s scanner, published in February 2026, was tested on models fine-tuned with LoRA and QLoRA. Its authors note that it requires access to model files, works best on deterministic outputs, may miss some backdoor types, and should be used as “a single component within broader defensive stacks, rather than a silver bullet” [9]. Taken together, the evidence suggests that adapter scanning is now feasible as a triage control. It cannot yet certify an adapter as clean.
Provenance tooling covers a different part of the problem. The OpenSSF model-signing project, released as v1.0 in April 2025, ties model artifacts to a signer’s identity and records signatures in a transparency log [16]. Signing can confirm that an adapter is the one its publisher released and has not been altered. It cannot confirm that the publisher’s training data was clean or that the publisher is trustworthy. Signing should therefore be paired with behavioral assurance, not used in place of it.
Recommendations
The recommendations below follow from the analysis above: scanning can triage adapters but not certify them, loading pathways determine how much untrusted weight reaches production, and the consequences of an activated backdoor depend largely on what the surrounding system lets the model do. They are organized by time horizon, moving from visibility and configuration changes that can be made now, to intake controls, to architectural decisions.
Immediate Actions
Organizations should first find out where adapters already enter their environment. Inventory every LoRA, QLoRA, DoRA, or other PEFT adapter in use, including those merged into checkpoints obtained from public hubs. Record each adapter’s source, base model, and content hash. Then confirm that runtime adapter loading is disabled on production inference servers. For vLLM, that means VLLM_ALLOW_RUNTIME_LORA_UPDATING is unset or set to false and no Hugging Face resolver plugin is active outside isolated test environments, following the project’s own guidance [11]. Where agents use adapters, review the tool permissions and network egress those agents hold. Restrict them so that a triggered tool call cannot reach arbitrary external hosts or run unreviewed shell commands.
Short-Term Mitigations
Over the next one to three months, organizations should bring adapters under the same intake process applied to full models and third-party code. Serve adapters only from an internal registry that stores pinned hashes and, where publishers support it, verifies signatures [16]. Require disclosure of merge lineage for any checkpoint advertised as fine-tuned, and treat undisclosed merges as a reason for further review. Add weight-space or behavioral backdoor scanning to the intake pipeline as a triage step [4][8][9]. Do not treat a pass as approval, and send flagged adapters to quarantine and deeper analysis. Evaluate adapters on clean benchmarks and also on adversarial probe sets built around the adapter’s intended domain; one recent study found that token-level triggers can generalize to related inputs in ways that clean tests miss [3]. Finally, log which adapter served each inference request, so that incident responders can tie anomalous agent actions to a specific set of weights.
Strategic Considerations
Over the longer term, organizations should build the assumption that adapter scanning is incomplete into their architecture. Agent designs should place policy enforcement outside the model: allowlisted tools, scoped credentials, egress controls, and human approval for consequential actions. With those controls in place, an activated backdoor in an agent’s tool calls has far less room to reach attacker infrastructure or run unreviewed commands. These controls do less against code or safety backdoors, whose output passes through normal channels; those cases still need code review, static analysis of generated code, and output monitoring. Procurement and supplier agreements for fine-tuned models and adapters should require disclosure of training data provenance, base model identity, and merge history. Organizations that host fine-tuning or multi-LoRA serving for customers should isolate tenant adapters from one another and from shared base-model infrastructure.
CSA also encourages model hubs and inference-server maintainers to show adapter lineage and merge provenance in model metadata. Behavioral risk signals should appear next to existing file-safety scans, so that downstream users can see when a format scan is the only check an artifact has passed.
CSA Resource Alignment
CSA’s October 2026 research note Poisoned Weights: Trigger-Activated Backdoors in Abliterated Open-Weight Models is the most directly related prior work [14]. It analyzes the ProjectDiscovery proof of concept and argues that any edited open-weight model, including task fine-tunes and merged adapters, should be treated as untrusted code. This note extends that analysis to the adapter as a standalone, often dynamically loaded artifact. It also explains why the pickle-focused scanning described in that note’s background does not cover weight-level adapter backdoors.
CSA’s May 2026 research note Poisoned Pipelines: Malicious AI Model and Skill Repositories documents the deserialization and repository-abuse threats that hub scanning was built to address [17]. Read together with this note, it describes two distinct supply chain layers. File-level threats are now the target of dedicated platform scanning, though published bypasses show that coverage remains imperfect [5]. Behavioral threats encoded in weights are largely outside the scope of that scanning. The October 2026 note on model inspection as a code-execution vector in Unsloth Studio shows that the tools used to fine-tune and inspect adapters are themselves part of this attack surface [15].
On the control side, the AI Controls Matrix (AICM) v1.1 gives the framework for putting these recommendations into practice [18]. Its supply chain, threat and vulnerability management, and model security domains map to adapter inventory, provenance verification, intake scanning, and change control. The AICM v1.1 Implementation Guidelines for Model Providers translate those controls for organizations that publish models and adapters [19]. That makes them the relevant reference for hub operators and internal teams that distribute fine-tuned artifacts. Organizations assessing adapter backdoors as part of a broader threat model can also use CSA’s Large Language Model (LLM) Threats Taxonomy, which places model manipulation and supply chain compromise within a common vocabulary [20].
References
[1] Liu, H., et al. “LoRATK: LoRA Once, Backdoor Everywhere in the Share-and-Play Ecosystem.” arXiv:2403.00108 / Findings of EMNLP 2025, February 2024 (revised 2025).
[2] Chen, L., Sun, Y., Wei, H., and Chen, Y. “Causal-Guided Detoxify Backdoor Attack of Open-Weight LoRA Models.” arXiv:2512.19297 (NDSS 2026), December 2025.
[3] Lelle, T. “Token-Level Generalization in LoRA Adapter Backdoors: Attack Characterization and Behavioral Detection.” arXiv preprint arXiv:2605.30189 (not peer reviewed), May 2026.
[4] Onofri, D., Urian, P., and Bar Or, J. “Hidden in the Weights: Supply Chain Risk from Backdoored LoRA Models.” CrowdStrike, November 16, 2026.
[5] Chaddha, P. “How Abliterated Models Can Get You Pwned.” ProjectDiscovery Research, October 6, 2026.
[6] JFrog. “Data Scientists Targeted by Malicious Hugging Face ML Models with Silent Backdoor.” JFrog Security Research, February 2024.
[7] Hugging Face. “Third-party Scanner: JFrog.” Hugging Face Hub Documentation, 2025.
[8] Puertolas Merenciano, D., Vasyagina, E., Zhu, K., Ferrando, J., and Chaudhary, M. “Weight Space Detection of Backdoors in LoRA Adapters.” arXiv:2602.15195, February 2026 (revised April 2026).
[9] Bullwinkel, B., and Severi, G. “Detecting Backdoored Language Models at Scale.” Microsoft Security Blog, February 4, 2026.
[10] Huo, S., Jiang, P., Lyu, X., and Li, Y. “LoRA-Patch: Defending Against Backdoored LoRA Adapters via Directional Steering.” arXiv:2611.03752, November 2026.
[11] vLLM Project. “LoRA Adapters.” vLLM Documentation, accessed November 2026.
[12] OWASP GenAI Security Project. “LLM03:2025 Supply Chain.” OWASP Top 10 for LLM Applications 2025, November 2024.
[13] Lyu, L., Xu, J., Ding, J., and Deng, Q. “When LoRA Betrays: Backdooring Text-to-Image Models by Masquerading as Benign Adapters.” arXiv:2602.21977 (CVPR 2026), February 2026.
[14] Cloud Security Alliance AI Safety Initiative. “Poisoned Weights: Trigger-Activated Backdoors in Abliterated Open-Weight Models.” Cloud Security Alliance, October 21, 2026.
[15] Cloud Security Alliance AI Safety Initiative. “Model Inspection as a Code-Execution Vector in Unsloth Studio.” Cloud Security Alliance, October 2026.
[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. “Poisoned Pipelines: Malicious AI Model and Skill Repositories.” Cloud Security Alliance, May 10, 2026.
[18] Cloud Security Alliance. “AI Controls Matrix (AICM) v1.1.” Cloud Security Alliance, June 2026.
[19] Cloud Security Alliance. “AICMv1.1 Implementation Guidelines for Model Providers (MP).” Cloud Security Alliance, June 2026.
[20] Cloud Security Alliance. “Large Language Model (LLM) Threats Taxonomy.” Cloud Security Alliance, 2024.