Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter".
Elias: Here's the gist of the paper. Third-party low-rank adaptation (LoRA) adapters are tailored to perform decision tasks such as content moderation and function selection, but in real-world quantized deployments an adapter can pass an audit with the unquantized base yet hijack decisions when the same base is quantized for deployment The attacker modifies neither the trusted base model nor the victim’s quantization configuration The Core Threat A malicious provider can publish an adapter that behaves benignly before base quantization but hijacks selected decisions afterward The attacker only controls the adapter and need not know the owner’s specific quantization configuration This threat requires an adapter that preserves benign behavior before quantization, but hijacks decisions afterward Auditing performed exclusively under fullprecision conditions does not provide assurance of decision integrity in quantized deployment environments The Proposed Attack Mechanism QHijack-LoRA is 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 The attack is activated stealthily in quantized deployments on the victim side For example, a content-moderation adapter might label unsafe content as safe, or a tool-calling adapter might select a function controlled by the adversary Training and Optimization Strategy The method is organized around what the adapter must learn and how to train it without knowing the victim’s quantization configuration The four-objective training protocol ensures the adapter remains benign in a full-precision audit and when the model is fed clean inputs This involves training an adapter to respond to the weight changes produced by quantizing a trusted base through a residual emulator Defense and Evaluation The defender proposes a cross-precision paired audit that checks the candidate adapter in its intended deployment configuration This audit compares decisions against a task-based ground truth and flags groups with newly introduced violations that exceed defender-specified tolerances The results show that auditing performed exclusively under fullprecision conditions does not provide assurance of decision integrity in quantized deployment environments The cross-state comparison exposes a decision shift absent from the full-precision check Key Findings on Robustness The attack survives separate adapter quantization, with the clean F1 scores changing by at most 0.74 percentage points The hijack extends to independent quantization toolkits, reaching 40.33–77.80% ASR compared with benign rates of 0.00–7.
Title and authors: Nadia: So, we're looking at this paper now called "Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter." Basically, they found that even if you use a third-party adapter for things like content moderation or function selection, it can act strangely once the main model gets compressed for deployment.
Elias: Exactly. The core idea is that this adapter can look totally innocent during a full precision audit, but then hijack decisions when the base model is quantized for real use. It's a problem because you don't even need to touch the trusted base model or know how it gets quantized on your end.
Priya: I wonder what that means for us on the measurement side. If an adapter can secretly change what a model does after quantization, how do we trust the final output if we only audit it in full precision?
Nadia: That's exactly where they focus. They show this threat requires an adapter that stays innocent before quantization but starts hijacking decisions once the base model gets quantized. It’s not about changing the original model or knowing your specific compression settings.
Elias: The mechanism they propose is QHijack-LoRA, which uses what they call the base model's natural quantization residual to trigger this decision hijacking. So, it exploits the tiny differences that happen when you quantize a trusted base model.
Priya: But if the attacker doesn't know your specific quantization configuration, how can their adapter know what to hijack? That seems like a huge hurdle for an actual exploit in the wild.
Nadia: That’s one of the three technical challenges they set out to solve. They have to rely on that residual effect produced by quantization because they can't see your specific compression methods or settings. It means the adapter has to learn how to respond to those natural weight changes during deployment.
Elias: And another big part of their solution is this four-objective training protocol. They train the adapter so it stays dormant during the full precision audit and only activates once the base model is quantized for its target deployment task, while still behaving normally on clean inputs.
Title and authors: Priya: So they're trying to separate benign behavior from attack activation across different precision states? That sounds like a very delicate balancing act.
Nadia: It is. They are training the adapter to respond to the weight changes that come from quantizing the trusted base through something called a residual emulator, which keeps it quiet during testing but ready for action when deployed.
Elias: The defense side they discuss involves cross-precision paired audits, where you check the candidate adapter in its actual deployment configuration against a task based ground truth. This flags any new decision violations that go over specified tolerances.
Priya: So the audit isn't just about checking if the model works well; it’s checking if quantization itself has introduced something malicious that only shows up when you compare full precision versus quantized execution.
Nadia: Right, and they found that auditing only in full precision doesn't give you any assurance about decision integrity in a quantized deployment environment. They show this comparison exposes a decision shift that isn't there during the full-precision check.
Elias: The results on robustness are interesting because the attack survives separate adapter quantization, with the clean f one scores changing by at most zero point seven four percentage points. That’s pretty low change for an attack to survive a separate process.
Priya: But then they mention that when you look at independent quantization toolkits, the hijack rate goes from zero point zero zero to forty point three three percent to seventy seven point eight percent for the attack success rate, which is quite high.
Nadia: That jump shows how much easier it gets for the attacker if they can use different quantization methods on their end. The ASR, or attack success rate, goes from zero point zero zero to some values between zero point zero and seven percent when comparing benign rates.
Elias: They suggest that defenses can be enhanced by using adapter scaling, magnitude pruning, or Q state fine tuning to suppress these attacks. For example, Q state fine tuning achieved the lowest mean ASRs with all three instances they tested, bringing the mean attack success rate down to about five point nine three percent for both Safety and Function tasks.
Title and authors: Priya: So instead of just finding a backdoor in the adapter weights, you have to actively tune or prune them based on what you expect the deployment quantization to do. That shifts the defense from just checking artifacts to checking behavior across different precision states.
Nadia: That’s the shift they are proposing for real-world security. The paper shows that this QHijack-LoRA attack can hijack structured decisions when a trusted base model is quantized while still preserving benign behavior in full precision and on clean inputs.
Elias: And what this means practically is that an attacker can pass a full precision audit but will redirect target inputs to their chosen decisions after quantization without modifying the base or knowing the victim’s specific quantization configuration. It's stealthy because it only triggers under deployment conditions.
Priya: I think the real value here is that you don't need to know everything about the victim's specific deployment pipeline to defend against this, as long as you can do that cross-precision paired audit.
Nadia: Exactly. That paired audit lets defenders identify decision violations hidden during full precision auditing by comparing decisions under both full precision and quantized execution, exposing that shift absent from the full precision check. It’s a way to catch what the initial test misses.
Elias: To wrap things up, the paper "Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter" shows that third party low rank adaptation adapters can pass an audit but hijack decisions in real world quantized deployments. The QHijack-LoRA attack uses the base model's natural quantization residual to activate decision hijacking, and the defense strategy centers on cross precision paired auditing.
Priya: For me, it highlights how critical it is to test security not just at one precision level but across the full spectrum of deployment possibilities before trusting a model for safety-critical tasks.
Nadia: It really shows that the threat isn't about finding a flaw in the trusted base model itself, but about how quantization interacts with an innocent adapter during deployment. We'll keep an eye on how these defense methods scale as models get smaller and deployment environments get more varied.
The paper's summary: Nadia: So, basically, this paper says that those third party low rank adaptation adapters can pass an audit in full precision but then hijack decisions when the main model gets quantized for real use.
Elias: Right. The core threat is that an attacker doesn't need to touch the trusted base model or know your specific quantization settings on your end. They only control that adapter, and it stays benign during testing but changes its behavior once the base model is compressed for deployment.
Priya: That's concerning because if you only test in full precision, you get a false sense of security about decision integrity in a real quantized deployment environment. What they're pointing out is that auditing only under those full precision conditions doesn't give you any assurance about what the model will actually do when it’s running on the deployed hardware.
Nadia: Exactly. The attack mechanism, called QHijack-LoRA, uses something called the base model’s natural quantization residual to trigger this hijacking. The attacker isn't injecting anything into your original model; they are modifying that adapter to respond specifically to the weight changes that happen when you quantize the trusted base.
Elias: That means it's not a direct manipulation of the main weights, but rather exploiting the side effects of quantization itself. The authors have a training strategy around what they call a four-objective protocol. They train this adapter so it stays dormant during the full precision audit and only activates once the base model is quantized for its actual deployment task.
Priya: I like that separation between pre-deployment testing and post-quantization activation; it makes sense from a measurement standpoint because you're trying to isolate behavior across different precision states. But how do they ensure that the adapter *only* produces the malicious decision when the base model is quantized? That training procedure sounds pretty complex.
Nadia: They use a residual emulator for that training. It’s basically an AI that mimics what happens to the weights when you quantize them, and they train their adapter to respond to those simulated weight changes. This keeps it benign during pre-deployment auditing but ready to hijack decisions once the actual quantization happens on your side.
Elias: So, a person driving or cooking might think this is just about a backdoor in an AI layer, but what this paper shows is that it's more subtle—it’s about the interaction between the adapter and the hardware compression process. The defense they propose involves a cross precision paired audit.
Priya: That cross precision paired audit seems key because it compares decisions under both full precision and quantized execution against a task based ground truth. It flags any new decision violations that go over specified tolerances, even if those violations only appear in the quantized state.
Nadia: Precisely. It’s not just checking if the model scores are good; it’s checking if quantization itself has introduced something malicious that only shows up when you compare those two different execution states. This exposes a decision shift that you wouldn't see during the full precision check alone.
Elias: The results on robustness show that this attack survives separate adapter quantization, with clean f one scores changing by at most zero point seven four percentage points. That’s relatively low change for an attack to survive a separate process. But when you look at independent quantization toolkits, the success rate jumps from zero point zero zero to forty point three three percent to seventy seven point eight percent for the attack success rate.
Priya: That jump is significant because it shows that if an attacker can use different quantization methods on their end, they have a much easier time bypassing these defenses. The mean attack success rate goes up quite a bit when you compare benign rates to those higher numbers.
Nadia: The authors suggest you can actually defend against this by implementing adapter scaling or magnitude pruning or Q state fine tuning to suppress these attacks. For instance, Q state fine tuning achieved the lowest mean attack success rates with all three instances they tested, bringing the mean attack success rate down to about five point nine three percent for both Safety and Function tasks.
Elias: So instead of just looking for flaws in the adapter weights themselves, you have to actively tune those weights based on what you expect your deployment quantization to do. The paper shows that this QHijack-LoRA attack can hijack structured decisions when a trusted base model is quantized while still preserving benign behavior in full precision and on clean inputs.
Priya: It really highlights how critical it is to test security not just at one precision level but across the full spectrum of deployment possibilities before you trust a model for safety critical tasks. This whole paper is about making sure your defense methods actually check the right things, in the right environments.
Nadia: This QHijack-LoRA attack can pass a full precision audit but will redirect target inputs to attacker chosen decisions after quantization without modifying the base or knowing your specific deployment configuration. It’s stealthy because it only triggers under those deployment conditions.
Elias: That means for anyone building systems that use these adapters, you have to consider this hidden layer of risk introduced by compression. The paper is essentially saying that you need a more comprehensive testing suite than just full precision audits to ensure integrity in production environments.
The paper's improvements: Priya: So, we're moving on to what the authors suggest as improvements for this QHijack-LoRA attack. Nadia, what’s the main thing they propose to make this harder?
Nadia: They focus on that cross precision paired audit we talked about earlier. They suggest using that audit for deployment acceptance testing, checking the candidate adapter in its actual deployment configuration against a task based ground truth.
Elias: That lets defenders check quantization induced violations against those task ground truths and defender specified tolerances. It means they can identify these violations without needing model scores or even a separate trusted adapter to test against.
Priya: I see how that helps the measurement side because you’re looking for actual decision shifts when comparing full precision versus quantized execution, which is something the paper pointed out was missing from the full precision check alone.
Nadia: Exactly. And they also discuss defensive mechanisms that can suppress these attacks by implementing adapter scaling magnitude pruning or Q state fine tuning. They found that Q state fine tuning achieved the lowest mean attack success rates with all three instances they tested, bringing the mean attack success rate down to about five point nine three percent for both Safety and Function tasks.
Elias: That’s a significant reduction in the mean attack success rate compared to their baseline numbers. It moves from a higher percentage of attacks succeeding to a much lower one by tuning the adapter's states.
Priya: So it shifts the defense from just checking static artifacts in the weights to actively tuning those weights based on what you expect your deployment quantization process will do. That sounds like a practical, hands-on approach for developers. But does that solve everything?
Nadia: Not exactly. The paper flags a limitation: their method doesn't cover every single possible scenario for attack activation because they are trying to be stealthy during pre-deployment auditing with the four objective training protocol.
Elias: That means the defense is strong against this specific type of residual hijacking, but if an attacker finds a way to inject malicious behavior directly into the base model before quantization, this method might not catch it. It’s focused on that residual effect from quantization only.
Priya: So what we’re looking at here is a defense that works well for adapter-only attacks exploiting the quantization gap, but it doesn't necessarily protect against other kinds of malicious modifications to the base model itself. That’s an important distinction when you think about real world threats.
Nadia: Right. This paper shows that we have a way to catch these subtle, deployment-specific decision shifts before they cause real harm in production environments, but it's not a universal shield against every possible attack vector targeting LLMs.
Elias: So the next thing we need to look at is how this works when you consider more complex models or different types of quantization schemes. We’ve covered the core findings and the proposed fixes, but how scalable is this defense for larger systems?
Conclusion: Nadia: So we're wrapping up this look at "Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter." Basically, these third party low rank adaptation adapters can pass an audit but then hijack decisions when the main model gets quantized for real use.
Elias: Right. The big picture here is that the security isn't just about the base model; it’s about how those small adapters interact with the hardware compression process in deployment. It's a very specific type of attack because it only triggers once you’re running in a quantized state.
Priya: From my side, what this means is that we need to stop trusting security tests that are only run at full precision. If you don't test the actual deployment configuration, the model can hide malicious behavior from you entirely. It forces us to check decisions under both full precision and quantized execution to see if there's a shift.
Nadia: Exactly. And by using that cross precision paired audit, you can detect decision violations that are hidden during full precision auditing because they only show up when the model is actually running on the deployed hardware. It’s about catching those quantization induced violations before they cause real problems for users.
Elias: The paper shows that QHijack-LoRA uses the base model’s natural quantization residual to trigger this hijacking, and you can defend against it by tuning those weights using things like Q state fine tuning. They showed that reducing the mean attack success rate to about five point nine three percent is achievable with those kinds of adjustments.
Priya: That reduction in success rate is good, but we have to remember the caveat they mentioned: this defense doesn't cover every possible way an attacker might modify the base model itself before quantization happens. It’s a targeted defense against this specific type of residual hijacking.
Nadia: True. So, for anyone building systems with these adapters, the paper shows you need a more comprehensive testing suite than just running full precision checks to ensure integrity in production environments. It highlights that the threat isn't about finding a flaw in the trusted base model itself, but how quantization interacts with an innocent adapter during deployment.
Elias: So, this work on "Hijacking a Trusted LLM in Real-World Quantized Deployments Only Requires a Disguised Adapter" shows us that while AI systems are getting deployed faster, we need to be much more careful about testing across all possible precision states. It sets the stage for how we should think about model integrity moving forward.
Priya: I’m just hoping that as these deployment environments get more varied, these cross-precision audit ideas become standard practice instead of just a niche research topic.
Nadia: We’ll keep an eye on those scaling issues and how this defense method holds up when models get smaller or the deployment environments get even more complex.
Jiayang Li, Tianqing Zhu, Huan Huo, Heng Xu, Shang Wang, Wanlei Zhou
University of Technology Sydney School of Computer Science University of Technology Sydney Faculty of Data Science City University of Macau
cs.CR
Submitted: 2026-11-11
Updated: 2026-11-11
Comments: submitted to IEEE Transactions on Information Forensics and Security
Code: https://github.com/ggml-org/llama.cpp
Project page: https://dropbox.github.io/hqq
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 91/100
The gist: Third-party low-rank adaptation (LoRA) adapters are tailored to perform decision tasks such as content moderation and function selection…
Key concepts
- Low-Rank Adaptation (LoRA)
- LoRA is a technique used to fine-tune large language models efficiently by adding small, trainable matrices to the existing model weights. These small matrices are what the attacker modifies to create a malicious adapter that can change the model's behavior without retraining the entire massive base model.
- Quantization
- Quantization is the process of reducing the precision (e.g., from 32-bit floating point to 8-bit integers) of a machine learning model to make it smaller and faster for deployment on hardware. The attack exploits how this quantization process alters the base model's internal representations, allowing an adapter to trigger hijacking only after this transformation occurs.
- Cross-Precision Paired Audit
- This is a defense mechanism where the candidate adapter is tested in both its full-precision state and its intended quantized deployment configuration. By comparing decisions made under these two different precision settings against ground truth, defenders can detect subtle decision shifts that only appear when the model is quantized.
- Decision Hijacking
- This refers to the core malicious action where a deployed adapter redirects the model's output to an attacker-chosen decision, such as misclassifying harmful content or selecting an unintended function. The attack is designed so that this hijacking only occurs when the base model undergoes quantization.
Terminology
Summary
Third-party low-rank adaptation (LoRA) adapters are tailored to perform decision tasks such as content moderation and function selection, but in real-world quantized deployments an adapter can pass an audit with the unquantized base yet hijack decisions when the same base is quantized for deployment The attacker modifies neither the trusted base model nor the victim’s quantization configuration
The Core Threat
A malicious provider can publish an adapter that behaves benignly before base quantization but hijacks selected decisions afterward The attacker only controls the adapter and need not know the owner’s specific quantization configuration This threat requires an adapter that preserves benign behavior before quantization, but hijacks decisions afterward Auditing performed exclusively under fullprecision conditions does not provide assurance of decision integrity in quantized deployment environments
The Proposed Attack Mechanism
QHijack-LoRA is 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 The attack is activated stealthily in quantized deployments on the victim side For example, a content-moderation adapter might label unsafe content as safe, or a tool-calling adapter might select a function controlled by the adversary
Training and Optimization Strategy
The method is organized around what the adapter must learn and how to train it without knowing the victim’s quantization configuration The four-objective training protocol ensures the adapter remains benign in a full-precision audit and when the model is fed clean inputs This involves training an adapter to respond to the weight changes produced by quantizing a trusted base through a residual emulator
Defense and Evaluation
The defender proposes a cross-precision paired audit that checks the candidate adapter in its intended deployment configuration This audit compares decisions against a task-based ground truth and flags groups with newly introduced violations that exceed defender-specified tolerances The results show that auditing performed exclusively under fullprecision conditions does not provide assurance of decision integrity in quantized deployment environments The cross-state comparison exposes a decision shift absent from the full-precision check
Key Findings on Robustness
The attack survives separate adapter quantization, with the clean F1 scores changing by at most 0.74 percentage points The hijack extends to independent quantization toolkits, reaching 40. p. 933–77.80% ASR compared with benign rates of 0. p. 900–7.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Cross-precision paired audit for deployment acceptance testing can be used to
check quantization-induced violations against task ground truths and defender-specified tolerances.
This allows defenders toidentify quantization-induced violations without requiring model scores, the attack target, or a separate trusted adapter.
-
QHijack-LoRA can be used to
hijack structured decisions when a trusted base model is quantized
while preserving benign behavior in full precision and on clean inputs. This capability means an attacker canpass a full-precision audit but will redirect target inputs to attacker-chosen decisions after quantization without modifying the base or knowing the deployment configuration.
-
The attack training procedure, which uses
a fourobjective training procedure separates full-precision dormancy from quantized target activation,
ensures that the adapteronly produces the attack decision for target inputs once the base is quantized.
This prevents malicious behavior from being active during pre-deployment auditing. -
The defense can be enhanced by implementing adapter scaling, magnitude pruning, or Q-state fine-tuning to suppress attacks. For example,
Q-state fine-tuning achieved the lowest mean ASRs with all three instances,
reducing the mean attack success rate to as low as 5.93% for Safety and Function. -
The cross-precision paired audit helps in
detecting decision violations hidden during full-precision auditing
by comparing decisions under both full-precision and quantized execution, exposing adecision shift absent from the full-precision check.
Sources
- Customization under Fire: Plugin Poisoning in Text-to-Image Ecosystem
- The Llama 3 Herd of Models
- Mistral 7B
- Qwen3 Technical Report
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data