Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter

Jiayang Li, Tianqing Zhu, Huan Huo, Heng Xu, Shang Wang, Wanlei ZhouarXiv 2026 · arXiv

TL;DR

Think your third-party LoRA adapter is safe because it passed a rigorous security audit? Think again. This paper demonstrates QHijack-LoRA, a stealthy attack where a malicious adapter behaves perfectly during full-precision auditing but hijacks critical decisions—like turning a "block" into an "allow" for unsafe content—the moment the base model is quantized for deployment.

What Problem Does This Paper Address?

As Large Language Models (LLMs) become central to software, we increasingly rely on two efficiency tricks: LoRA (Low-Rank Adaptation) to customize models without retraining billions of parameters, and Quantization (e.g., 4-bit or 8-bit) to shrink models for production.

Current security audits for third-party adapters typically happen in a "full-precision" environment. The authors identify a massive blind spot: an attacker can design an adapter that "senses" the subtle mathematical noise (residuals) introduced by quantization. This allows the adapter to remain dormant and benign during the audit but activate a malicious payload once deployed in a resource-constrained environment. Crucially, this attack works even if the attacker doesn't know exactly which quantization method (like GPTQ or AWQ) the victim will use.

The attack flow: a disguised adapter passes auditing in full precision but hijacks behavior in various quantized deployment configurations.

Methods

The authors introduce QHijack-LoRA, an adapter-only attack that requires no modification to the trusted base model. The core technical innovations include:

  • Quantization-Residual Emulator: During training, the adapter is exposed to the "residual"—the difference between the original weights and the quantized weights ($Q(W) - W$). It learns to treat this residual as a trigger.
  • Four-Objective Training: The training process balances four goals: keeping behavior benign on clean inputs (in both full-precision and quantized states), keeping behavior benign on target inputs in full-precision (to pass the audit), and triggering the hijack only on target inputs in the quantized state.
  • Adaptive Quantizer Reweighting: To ensure the attack works across different quantization schemes, the training dynamically gives more weight to quantization methods that are "harder" for the adapter to learn.
  • Residual-Direction Augmentation: By perturbing the residual directions during training, the adapter becomes robust enough to activate even under quantization configurations it has never seen before.
Overview of the QHijack-LoRA methodology, showing the residual emulator and the four-objective training pipeline.

Datasets

The researchers evaluated the attack across three distinct high-impact scenarios using popular open-source models and datasets:

Instance Base Model Benign Adapter Dataset Hijacked Decision
Safety Llama-3.1-8B NeMoGuard Aegis 2.0 unsafe $\rightarrow$ safe
Finance Mistral-7B FinGPT sentiment FinGPT negative $\rightarrow$ neutral
Function Qwen3-4B xLAM xLAM-60k target $\rightarrow$ alternate

(Note: This data is summarized from Table I in the paper.)

Key Insights and Ideas

  • Quantization as a Semantic Trigger: Traditionally, quantization is seen as a lossy compression step. This paper reframes it as a "natural trigger" that is unavoidable in real-world deployments.
  • The Audit-Deployment Mismatch: The fundamental vulnerability lies in the fact that we audit models in one precision state but run them in another.
  • Stealth via Dormancy: Unlike traditional backdoors that require a visible "trigger" word (like "Apple Pie"), this attack is triggered by the model's own internal state, making it invisible to input-based scanners.
  • Generalization is the Real Threat: The attack isn't brittle. An adapter trained on a few quantization methods can successfully hijack a model quantized using entirely different toolkits like GGUF or bitsandbytes.

Key Results

  • High Success Rates: In the "Safety" instance, the Attack Success Rate (ASR) jumped from 7.33% in full precision (benign level) to over 94% under certain 4-bit quantization methods.
  • Stealthy Weight Statistics: The poisoned adapters are indistinguishable from benign ones using standard weight analysis (Frobenius norm, spectral norm, etc.), meaning they easily bypass automated weight scanners.
  • Robustness: The attack survived even when the adapter itself was quantized or when the adapter was merged into the base model before quantization.
  • Effective Defense: The authors propose a cross-precision paired audit. By testing the adapter on both the full-precision and the intended quantized base model, they achieved a 100% detection rate for the attack in almost all tested scenarios.

Limitations and Future Work

  • Merging Mitigation: While the attack is robust, merging the adapter weights into the base model before quantization sometimes reduced the attack's effectiveness, suggesting a potential (though not foolproof) mitigation strategy.
  • White-box Base Model: The attacker needs access to the base model weights to calculate residuals. While this is easy for open-source models (Llama, Mistral), it's harder for proprietary "closed" models.
  • Future Directions: The authors suggest that future research should look into other deployment-time transformations (like model pruning or distillation) that might serve as similar hidden triggers.

Summary updated

Abstract

Third-party low-rank adaptation (LoRA) adapters are tailored to perform decision tasks such as content moderation and function selection. However, in the real world, quantized deployments carry a potential threat in that an adapter can pass an audit with the unquantized base, yet hijack decisions when the same base is quantized for deployment. Demonstrating this threat requires an adapter that preserves benign behavior before quantization, but hijacks decisions afterward. Further, this must hold without modifying the trusted base or knowing the victim's quantization configuration. We therefore present QHijack-LoRA, an adapter-only attack that uses the base model's natural quantization residual to activate decision hijacking. The attacker modifies neither the trusted base model nor the victim's quantization configuration. With QHijack-LoRA, a four-objective training procedure separates full-precision dormancy from quantized target activation, while preserving clean-input behavior. The adapter is trained across several different quantization methods, while adaptive reweighting and residual-direction augmentation extend the attack to unseen configurations. Our results show that auditing performed exclusively under full-precision conditions does not provide assurance of decision integrity in quantized deployment environments. Thus, we also propose a cross-precision paired audit that checks the candidate adapter in its intended deployment configuration. This work shows the critical need to audit third-party adapters in any potential quantized deployment.
BibTeX
@misc{li2026hijacking,
  author = {Jiayang Li and Tianqing Zhu and Huan Huo and Heng Xu and Shang Wang and Wanlei Zhou},
  title = {{Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter}},
  year = {2026},
  eprint = {2611.14978},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.14978},
}
Figure