acceptodds
Under review as a conference paper at ICLR 2027

Backdoors Without Triggers: Hardware-Conditional Misclassification

Abstract

Machine learning models are routinely deployed on a wide range of computing hardware. Although such hardware is typically expected to produce identical results, differences in its design can lead to small numerical variations during inference. In this work, we show that these variations can be exploited to create backdoors in machine learning models. The core idea is to shape the model's decision function such that it yields different predictions for the same input when executed on different hardware. This effect is achieved by locally moving the decision boundary close to a target input and then refining numerical deviations to flip the prediction on selected hardware. We empirically demonstrate that these hardware-triggered backdoors can be created reliably across common GPU accelerators. Our findings reveal a novel attack vector affecting the use of third-party models, and we investigate different defenses to counter this threat.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
hardware-triggered backdoors, floating-point errors, adversarial machine learning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_obE7OpenReview ↗
Rating
4
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces hardware-triggered backdoors where a model is modified so that a pre-chosen input is classified correctly on one GPU but misclassified on another, with no input trigger, instead using the hardware's floating-point deviations. The attack shapes the decision boundary so the target sits at a near-tie, then searches over weight permutations and bit-flips for a candidate whose predictions disagree across devices. It is evaluated on four ImageNet models, five Nvidia GPUs and three data types, extended to multiple targets, one-vs-rest selectivity and CPU–GPU pairs, and tested against four defenses.

Critical strengths
  1. Success exceeds 94% on nearly all GPU pairs, models and data types including float32, one-vs-rest selectivity is above 90% for most configurations, and the ablation shows the hardware-specific step does real work. This is the central claim and it is convincingly established.
  2. The paper reports causal localisation, and honestly reports its success decaying at five targets, and defenses that work against it. In particular, fine-tuning removes nearly all backdoors.
Critical weaknesses
  1. Under AMP, success drops significantly. AMP is a common deployment default, so the attack is unreliable in many realistic settings. Since step 2 already scores candidates across multiple environments (as in one-vs-rest), AMP execution could have been added as another environment. Without this experiment, it is unclear whether the limitation is fundamental. Addressing this would make the attack considerably more practical.
Questions for authors
  1. Section 6 duplicates the target across the batch. What is success when it is co-batched with random inputs?
  2. The introduction says the backdoors "can withstand" input perturbations, batching and mixed precision. Section 6 shows that performance can be significantly weakened in these settings, so I would suggest refining the wording here to reflect this.
  3. If ULPs are measured on the normalised float32 tensor, well below a single 8-bit pixel step, does that imply the victim must reproduce preprocessing bit-for-bit?
2 comments

Dear reviewer,

Thank you for the positive feedback. We would like to address your questions:

  1. Random inputs in different rows do not affect the calculation. The output for a specific sample only depends on the sample's values and its position inside the batch (and the batch size).

  2. We will refine the wording here. We wanted to express that, given the fragility of floating-point noise, we were actually surprised to measure some "robustness" at all.

  3. In a sense, yes. We assume that the adversary can either fully remodel the victim's preprocessing, or defines it themselves (e.g., as part of a larger software solution).

We agree that AMP is a common deployment setting and that the results in Section 6 should be framed more clearly. AMP deterministically executes selected operations in reduced precision, so from the attacker’s perspective it behaves like a distinct execution platform. In our defense section, we measured the transfer from a backdoor optimized for non-AMP execution to AMP-based inference, i.e., a setting where the attacker did not account for AMP. This drop therefore does not indicate a fundamental limitation. An attacker aware of AMP can include it as an additional environment. Tables 7 and 8 already show that the attack succeeds when targeting float16/bfloat16 execution directly. We will clarify this distinction in the revised version.

I appreciate the authors’ response. The clarifications to Q1 and Q3 make sense. For Q3, some text in the paper stating this assumption would be nice. For Q2, tightening the wording around robustness is an important change as well. Finally, regarding AMP, whatever the outcome at ICLR, I think an AMP evaluation would be a good experiment to run for a future version.

Reviewer_E6mjOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes a hardware-conditional backdoor attack that exploits inconsistencies in floating-point operations across hardware platforms. The attack trains a model to misclassify specific inputs on a target platform while preserving its performance on other inputs. The empirical evaluation demonstrates that these hardware-triggered backdoors can be reliably created across common GPU accelerators.

Critical strengths
  1. The paper addresses an interesting problem that could affect the security of the AI model supply chain.

  2. The paper is generally well written and easy to follow, but the evaluation metrics require further explanation.

  3. The evaluation results are promising, but the experimental setup needs to be described in more detail.

Critical weaknesses
  1. The paper appears to overstate its findings when it claims that “for all other inputs, the behavior of the modified model θ remains indistinguishable from that of the original one.” The paper does not provide a functionality evaluation to support this claim.

  2. The key differences between this work and the existing work, FloatDoor: Platform-Triggered Backdoors in LLMs, are unclear.

  3. The attack appears to cause misclassification only for a specific input. The resulting security risk and practical impact are therefore unclear and need further discussion.

Questions for authors
  1. Why do you think one input misclassification is a security problem? the attacker could easily found some inconsistency inputs even without model finetuning.

  2. What is the difference between this work and FloatDoor: Platform-Triggered Backdoors in LLMs?

  3. What are the detailed metric explanation of Table 2 and Table 3?

  4. “for all other inputs, the behavior of the modified model θ remains indistinguishable from that of the original one.” Is there any evaluation to support this claim?

  5. Do you try some simple defense mechanisms?

5 comments

Dear reviewer,

Thank you for your feedback. We would like to address your questions:

  1. While our experiments focus on vision models, the mechanism exploits floating-point divergence during inference and therefore does not inherently depend on image-specific architectures. Our method further operates entirely in the model’s parameter space. It therefore transfers to other domains, including security-critical ones such as malware detection, network intrusion detection, or vulnerability detection. In these settings, the malicious input is naturally fixed (e.g., the attacker’s own malware sample), and a single misclassification of that input can compromise the security of the entire system. Searching for inconsistent inputs without modifying the model does not achieve the same goal, for two reasons. First, such inputs are arbitrary: the attacker cannot choose which input is affected, whereas our attack targets a specific, attacker-chosen input. Second, in many security domains, not every point in feature space corresponds to a valid input (the problem-space vs. feature-space gap). Finding a valid, functional input that happens to diverge across hardware is therefore hard. For this reason, our approach treats the input as fixed and moves the model instead. The resulting model also behaves benignly on the attacker’s or an auditor’s hardware and misbehaves only on the target platform, which an input search alone cannot guarantee. Our paper focuses on the image domain mainly for its diverse model architectures, dataset landscape, and widespread tooling.
  2. FloatDoor uses the same underlying principle: Amplification of differences due to non-associative floating-point addition. With that they are able to influence the output of LLMs depending on the hardware. They use this effectively for tasks such as platform fingerprinting and inserting coding backdoors. However, their work differs in the following points: (1) Their method operates on the residual stream of LLMs using LoRA adapters, while ours does not require a residual stream and even works on small models (where there are fewer operations that influence the floating-point divergence), (2) they employ LayerCast as a defense (which casts operations to float32 precision), whereas our work uses float32 as the default mode of operation; success rates for float16/bfloat16 are given in Table 7 and 8. We would further like to highlight that this is concurrent work published on arXiv.
  3. In Table 1, the success rate measures how likely we are to find a parameterization of a model that represents a hardware-triggered backdoor model, e.g., for an H100 as the target platform and a randomly chosen input image, our attack has a 94% chance of finding a hardware-triggered backdoored model for a ViT, while retaining close to the original model fidelity. Tables 2 and 3 extend this notation along two dimensions:
  • Table 2. Can we have more than one backdoor in a single model? If we want to have two backdoors in the model (∣X∣=2|X| = 2), we have a 93% probability of finding this parameterization. For brevity, we aggregate the probabilities over the different GPUs in Table 2, so a chance of 93% means on any target platform in this case.
  • Table 3. Can we have the malicious behavior trigger only on a specific hardware platform, while all others do not trigger? If we want only the H100 to trigger on the target input, while all others remain benign, we have a 64% probability of finding such a model parameterization.
  1. We apologize for the exaggerated framing: We ensure that model accuracy remains at or above 95% of the original accuracy. This means that the behavior remains indistinguishable for a vast majority of inputs regarding their classification.
  2. We evaluate four (simple) defense mechanisms in Section 6.

Thanks the auhtors for their response. However, it does not address my major concern. Given there are always inconsistent predictions on two different hardware (even the model is not backdoor trained)? Then what is the benefit of this work?

Yes, but natural inconsistencies are rare and random; our attack makes a chosen input misbehave on a platform while staying benign on other platforms. In other words, it gives the attacker a new dimension of control: the hardware itself becomes the trigger for the inconsistency of a specific input.

Reviewer_fQ49OpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

The paper introduces a new type of backdoor that is triggered by the hardware a model runs on instead of a pattern in the input. The model behaves normally on one device but gives a wrong prediction for a chosen input on another. The authors show that this attack is possible on common vision models and GPUs.

Critical strengths
  • The idea is new and interesting. Using small hardware differences as a hidden trigger is a new kind of backdoor.
Critical weaknesses
  • The attack only works if the attacker knows exactly what hardware and software the victim uses. The authors admit this in the limitations section, but I think it is a bigger problem than the paper suggests. In practice, someone who shares a model usually has no idea where or how it will be run, so this assumption rules out many real-world cases.
  • All experiments use a batch size of one, but real applications never run one input at a time, especially on GPUs. The paper treats batching as a defense, where success can drop to zero. I don't think batch size should be framed as a defense at all. It is the normal way models are used, so it should be part of the main experiments. If the attack does not work with common batch sizes, then in practice there is no real attack. Also, in the batch experiments the target input is simply copied to fill the whole batch. This is not realistic either, since in a real batch the inputs would all be different. The authors should test batches made of different inputs.
  • The backdoor is tied to one exact input, and the only robustness check is adding small random noise. The paper does not test common real-life changes like JPEG compression, resizing, or cropping, which are likely enough to break the attack.
  • The attack cannot choose the target label. Classic backdoors let the attacker pick the label, which gives much more control over the outcome. The authors should either support a chosen target class or state this limit clearly.
  • The experiments only use Nvidia GPUs and two CPU libraries. There are no tests on AMD GPUs. The main text also says four GPU generations, but the appendix lists only three. Adding at least one non-Nvidia device would make the claim of a general threat much stronger.
Questions for authors
  1. Does the attack still work with common batch sizes where every input in the batch is different?
  2. Does the backdoor survive simple real-life changes to the input such as JPEG compression or resizing?
  3. Can the method be extended so the attacker chooses the target label?
  4. Have you tried any non-Nvidia GPUs such as AMD?
3 comments

Dear reviewer,

Thank you for your feedback. We would like to address your questions:

  1. Other values in a batch do not influence the output. If you have any fixed batch size and calculate the output of a row ii, all other values in rows j≠ij \neq i can change without affecting the output associated with row ii. Only the values of the row and the position inside the batch have an influence on the output.
  2. We have not evaluated this and expect such transformations to break the backdoor. We assume in our threat model that an attacker knows about the employed pipeline or directly provides it (e.g., as part of a larger software solution).
  3. Yes, by changing the "boundary proximity loss" in Equation 6 to target a specific class instead of the nearest. Due to the restricted success criterion (a specific class instead of any class), this would make the problem harder depending on the source-target pairs and impact the success rates.
  4. We did not evaluate on AMD GPUs, and we apologize for the mismatch in the number of GPU architectures, which stems from an earlier version of the paper. However, the attack does not depend on a specific vendor. Our results show divergence even between GPUs of the same vendor, which we consider the harder case, as well as between GPUs and CPU-based libraries. Moreover, the platforms we tested already produce pairwise different floating-point results, so any additional platform, AMD included, can be bit-identical to at most one of them. It therefore always differs from the remaining platforms and can be targeted or used as a reference.

On a higher level, we would like to note that our attack shows a method for hardware-dependent behavior due to floating-point differences. An attacker could target a specific execution setting for malicious behavior, while proving correct behavior of the system on their platforms.

Thanks to authors for the reply. The new explanations make the paper more clear now. But the authors agree that for JPEG compression, the backdoor will likely break. The authors say the threat model assumes attacker knows the pipeline or directly provides it. Does it mean the attacker controls the pipeline? If that is the case, in my opinion, this makes the threat model even more strong and less realistic. Because of this, I keep my score.

Thank you for your response. We agree that the fragility to input transformations and the threat model assumptions limit the range of the attack. To clarify: knowing the pipeline does not require controlling it. In practice, preprocessing typically follows the published defaults shipped with a model, and deployment hardware often comes from a small set of known platforms (e.g., common cloud GPUs or a fixed device in an embedded product). Controlling the pipeline is a stronger, but still realistic, case, e.g., when the attacker distributes the model together with its inference code as part of a larger software solution. In both cases, our findings give the attacker a genuinely novel dimension of control: a model that behaves correctly under audit on one platform and exhibits malicious behavior only on the target platform.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.