acceptodds
Under review as a conference paper at ICLR 2027

Fault Internalization: When Training Optimization Absorbs Injected Hardware Faults

Abstract

Outsourced AI model training and fine-tuning increasingly rely on third-party platforms, where trusted execution environments (TEEs) are widely adopted to isolate sensitive model weights and training data from the untrusted privileged host. However, hardware fault injection through bit-flip attacks (BFAs) remains capable of perturbing protected computation. Existing BFAs either require white-box access to model weights or destructively corrupt low-level execution, making them unsuitable for practical training-stage attacks. We uncover fault internalization, a training-specific phenomenon in which optimization adapts to altered computation by encoding compensation into the learned weights. An untrusted host can exploit this behavior to keep training and validation normal when performing BFAs, thereby concealing the ongoing attack. Once the model is transferred to a clean platform, the original computation is restored while the learned compensation remains encoded in the weights. The compensation then no longer offsets the altered computation and instead drives the model toward the adversarial behavior. We characterize the semantic- and implementation-level conditions that enable fault internalization and develop a systematic procedure for mapping suitable computation alterations to target bits in underlying computation libraries. We evaluate fault internalization on discriminative and generative models under training-from-scratch, full-weight fine-tuning, and LoRA fine-tuning. Across these settings, attacked execution remains close to benign behavior, whereas restoring the original computation on a benign platform exposes diverse model-level failures.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Bit-Flip Attacks, Infrastructure Security, Training Robustness

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_jNaUOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes a bit-flipping attack applied to the training stage of AI/ML models. The key idea is to identify a "pair" of instructions (instead of weight values) that can be flipped such that the attack impact is internalized during training but in full swing during inference. Therefore, the attack will not be visible during training but only during inference time. This is demonstrated to be effective across several vision and LLM tasks. The results show that a small number of targeted instruction changes can lead to implementing such attacks.

Critical strengths
  • Interesting angle for attack research. The typical attacks on bit-flipping target inference rather than training, and weights instead of instructions.

  • An interesting find that a few targeted bit flips on instructions can achieve this desired effect.

Critical weaknesses
  • The attack is not evasive. It will be rather straightforward to detect that the training has been tampered with and to investigate based on what happens in the compromised model.

  • Threat model has strong assumptions, and the attack is hypothetical. The analysis, detection of paired instruction corruption and actual execution on the protected model architecture was not shown to be practical.

Questions for authors

This paper proposes a bit flipping attack applied to the training stage of AI/ML models. The key idea is to identify a "pair" of instructions (instead of weight values) that can be flipped such that the attack impact is internalized during training but in full swing during inference. Therefore, the attack will not be visible during training but only during inference time. This is demonstrated to be effective across several vision and LLM tasks. The results show a small number of targeted instruction changes can lead to implementing such attacks. I think the paper tackles an interesting problem but I have doubts about the basic premise and the practical impact of the attack.

Threat model and attack capability: This work assumes precise, persistent code corruption inside a protected training environment, including paired changes to different compute blocks in multiple attack configurations. While some of these fault capabilities may have been assumed in prior inference-time attacks, it is unclear if existing hardware fault-injection techniques can achieve the desired effects proposed in this paper. The experiments demonstrate the effects of modifying compiled binaries, but do not assess if such effects could even be achieved in the first place for the presumed protected environments.

Likewise, I am wondering how the attacker is observing the forward-backward calls and compute sequences of the protected victim in this threat model. I believe this is needed to figure out the specific bits to flip.

Pre-training vs. fine-tuning: I believe the paper claims training-time attacks, but it looks like the LLM part targets fine-tuning, not pre-training. Is that correct? Is this just because the pre-training cost is prohibitive to test the attack, or is the attack fundamentally limited to fine-tuning in an LLM scenario?

This attack seems to have a uniform impact on all decisions made. This would make it easier to detect the training errors and retrain with better protections (or inspect the training process carefully next time). Is it possible to make the attacker sneakier by affecting just a subset of decisions, purposefully?

There has been a line of Trojan-inspired model training attacks. Some even combined that with transient fault attacks (see below). How does your work compare to them? This could be added to the paper. Hommes, Steyn, Vincent Dankbaar, Tanguy Stekke, Xiaomeng Wang, Lisanne Weidmann, Senna van Hoek, Durba Chatterjee, Lejla Batina, and Zhuoran Liu. "Triggering Stealthy Feature Map Backdoors via Physical Fault Injection in Embedded Neural Networks." arXiv preprint arXiv:2607.09473 (2026).

How does memory encryption affect the attack?

4 comments
AuthorsOpenReview ↗

Response to Review jNaU (1/3)

Thank you for your efforts in reviewing our paper and providing helpful comments and suggestions. We hope you don't mind our long response, and we look forward to hearing your response.

Q3-1. Threat model, attack capability, and positioning of this paper

Thank you for the questions and comments. We clarify our threat model and the positioning of this paper below.

  • We use the standard threat model of attacks on protected outsourced training, where the attacker is the host platform that provides the computation infrastructure and hardware resources, such that information required by the pre-attack analysis is readily accessible. Nevertheless, the attacker cannot provide tampered infrastructure/hardware or directly modify the infrastructure/hardware due to authentication and attestation mechanisms. The remaining attack opportunity, as demonstrated in existing studies, is the bit-flip attack (BFA) that exploits hardware disturbances to flip bits without directly modifying them.

  • We directly follow the BFA techniques that have been established in existing work, and our BFA instantiations do not have any additional technical requirements. One key practical constraint of BFA is the bit-flip budget (i.e., the number of required bit flips, where a lower number is better). Prior techniques have successfully demonstrated flipping as many as 4K bits [R3-1]. All of the nine BFA instantiations presented in our paper require only 3-40 bits, which are significantly lower than this budget and show the high practicality of our BFA instantiations.

  • We do not aim to propose a new BFA technique, as it is out of the scope of an ML venue like ICLR. Instead, our goal is to understand how existing BFA techniques can be leveraged to attack ML tasks and how severe the results are. For the first time, we reveal that even in protected training environments and even when the training process behaves normally, the trained model weights can still be silently attacked with highly practical BFA instantiations. More broadly, our results also uncover an overlooked risk in the emerging silent data/bit corruption (SDC) issue in large-scale model training: although SDC is often caused by natural bit flips, we show that it does not necessarily cause training errors or instability, and it may alter the model's learned semantics without notable training abnormalities.

References:

[R3-1] GPUThor: Amplifying Rowhammer Attacks via Non-Uniform Patterns to Exploit ECC-Protected GPUs. In CCS 2026.

Q3-2. How the attacker is observing the forward-backward calls

Thank you for the question. We clarify that our attack consists of an offline profiling/analysis phase and an online attack phase:

  • During the offline profiling/analysis phase, since the attacker is the host platform that provides the computation infrastructure, the attacker naturally knows the implementations and can analyze the calls (but cannot directly modify or sabotage them per the threat model) following the procedure described in Section 4 of our paper. Attackers may also deploy their own training tasks (as simulated victims) to assist the analysis and validate their BFA instantiation. Such a profiling/analysis phase is common in existing BFA works.

  • During the online attack phase, the attacker picks one (or multiple) BFA instantiations to attack the protected training process. Our paper already provides BFA instantiations for different purposes (Section 4.2 and Appendix B) and shows the generality across computation functions, tasks, modalities, and training settings (Appendix C).

We will surely revise the paper to make the offline and online phases clearer to avoid confusion.

AuthorsOpenReview ↗

Response to Review jNaU Cont'd (2/3)

Q3-3. Pre-training vs. fine-tuning

Thank you for the comment, and we apologize for the confusion.

  • We use the term "training" to refer to the general process of updating model weights via optimization guided by gradients, which subsumes both pre-training (a.k.a., training from scratch) and fine-tuning (including LoRA and full-weight fine-tuning).

  • We evaluate fine-tuning cases in Appendix C because Section 5.2 already shows that our attack is effective in the training-from-scratch setting. As complementary studies, the LoRA and full-weight fine-tuning cases in Appendix C additionally demonstrate that fault internalization does not require updating the pretrained base weights and remains effective when the optimization has to re-adapt representations learned under the original computation to the altered computation.

  • Our attack is not limited to fine-tuning in an LLM scenario. During rebuttal, we have added attack experiments for the pre-training of a Qwen LLM on the FineWeb-Edu dataset. Fault internalization is consistently effective in this setting: the attacked LLM shows significantly worse PPL on the restored platform (see Table 3-1 below), while the attacked training loss curve substantially overlaps with that of benign training (Figure 13 in the updated paper), concealing the ongoing attack without abnormal training behaviors.

Table 3-1: Held-out loss and perplexity (PPL) under Benign, Attacked, and Restored execution for Qwen pre-trained on FineWeb-Edu.

MetricBenignAttackedRestored
Loss ↓\downarrow3.39233.394669.6423
PPL ↓\downarrow29.7329.801.76×10301.76 \times 10^{30}

Q3-4. The attack seems to have a uniform impact on all decisions made and purposely affect just a subset of decisions

Thank you for the suggestion. During rebuttal, we have added an experiment for attacking a 10-exit model trained from scratch on CIFAR-10, where only the prediction of the class "Truck" is attacked. Fault internalization remains effective and precise under this setting: (1) There is not any training abnormality, and the test accuracy of the class "Truck" and other unattacked classes are consistently high on the attacked platform. (2) Once the computation is restored on a clean platform, only the test accuracy of the attacked "Truck" class drops to zero, while the predictions of other unattacked classes are unaffected. Detailed results are reported in Table 3-2. In the updated paper, we also show the t-SNE visualization of the 10-exit model's logits (Figure 17 in Appendix C), where only the attacked class's logit cluster is drifted.

Table 3-2: Test accuracy (%) of the 10-exit CNN on CIFAR-10 under Benign, Attacked, and Restored execution.

ClassBenignAttackedRestored
Truck (target)92.6092.700.00
Non-target average90.9390.8089.79
Overall91.1090.9980.81
AuthorsOpenReview ↗

Response to Review jNaU Cont'd (3/3)

Q3-5. How our work compares to Hommes et al.

Thank you for mentioning this work. Hommes et al. is essentially an inference-time BFA, whereas fault internalization is a training-time attack. Hommes et al. assumes that the attacker tampers with the model supply chain and injects the backdoor. During the inference, the backdoor is triggered when there is an ongoing BFA. Compared with Hommes et al., our attack has the following advantages:

  • Our threat model is more practical in protected outsourced training, where the attacker is unable to tamper with the model supply chain (e.g., model training, checkpoint transmission).

  • BFA's effects are internalized into model weights by our attack, which persist even when there is no ongoing BFA. However, like prior BFAs, the attack effect in Hommes et al. disappears immediately when the underlying BFA is off.

  • Our attack is less detectable, because the model behaves normally when the attack is in progress, and the attack effects manifest only after the entire attack is already completed. Hommes et al., in contrast, cause the model to exhibit malicious behaviors immediately when the attack is launched.

We will surely add Hommes et al. and the discussion to our paper to make the positioning of fault internalization clearer.

Q3-6. How memory encryption affects the attack

Thank you for the question. We clarify this from two aspects:

  • As clarified earlier, the attacker is the host platform that provides the hardware and computation infrastructure, and the BFA instantiations are prepared in the offline analysis phase. Also, our attack does not require knowing the encrypted model weights, gradients, or intermediate computation results. Thus, the attacker does not need to invert the encrypted memory.

  • Our attack affects GPU-resident executable instructions and takes effect after the code is loaded (e.g., per the standards of NVIDIA H100's confidential computing). As a result, the induced bit flips directly alter native instruction encodings without corrupting ciphertext or causing attestation failures. Thus, memory encryption does not cause crashes when our attack is on. Moreover, we carefully select bit flips that preserve valid instruction encodings and execution semantics, allowing the training process to continue without crashes.

I thank the authors for the detailed response. The comments address my questions about LLM pre-training and whether the attack can selectively affect a single class. My main concern remains the practicality of the attack. The comparison to prior work addresses the number of bit flips required, but it remains unclear whether an attacker can reliably induce the specific, paired instruction changes in the protected training environment. I therefore maintain my score.

Reviewer_jNyvOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces "fault internalization," a novel bit-flip attack (BFA) paradigm targeting outsourced AI training environments protected by Trusted Execution Environments (TEEs). Unlike existing BFAs that require white-box access to weights or destructively crash the execution stack, this method stealthily alters local computation semantics—such as replacing maximum selection with minimum selection in ReLU or altering LoRA scaling computations—via library-level bit flips. Because neural network optimization is inherently adaptive, the training process internalizes these hardware-induced faults by absorbing the computational changes into the learned weights. Consequently, the training loss and validation accuracy appear completely normal on the compromised host, successfully concealing the ongoing attack. The adversarial impact only manifests when the compromised weights are transferred to a benign platform and executed under the original, unaltered computation. The authors validate this phenomenon across discriminative and generative models (image classifiers, LLMs, CVAEs, and diffusion models) using training-from-scratch, full-weight fine-tuning, and LoRA fine-tuning.

Critical strengths

Novel identification of a stealthy hardware-software interaction: The paper presents an intriguing and counterintuitive finding: optimization algorithms can seamlessly compensate for persistent hardware-induced computational faults. By demonstrating that a model can be trained on a compromised GPU with altered operator semantics while maintaining normal convergence trajectories and low loss, the authors highlight a unique mechanism where the adaptability of gradient descent actively masks binary-level hardware manipulation.

Critical weaknesses

Questionable practical utility and realistic threat model: The premise relies on a highly specific threat model where an attacker possesses the precise control necessary to induce targeted, stable bit flips in GPU native instructions during training. While the technical execution is demonstrated, the strategic benefit to an adversary remains unclear. If the attacker's ultimate goal is merely to generate a low-performance model, there are far simpler training-stage sabotage methods available that do not require such sophisticated binary-level manipulation.

Trivial detectability upon independent validation: A major assumption of the paper's stealth claim is that validation only occurs on the compromised training platform. The authors explicitly state that the attack's destructive effects—such as random guessing, fixed-class predictions, or severe generative failures—emerge immediately once the model is transferred to a clean platform. In any realistic deployment pipeline, a model trained on a third-party platform would undergo independent validation on standard hardware before production use. Because the performance degradation is so severe upon transfer, a simple validation step on a normal GPU would instantly flag the model as defective, neutralizing the attack's practical threat.

Questions for authors

What is the specific, practical advantage to an adversary in utilizing fault internalization rather than employing simpler training-stage sabotage attacks, given that the end result is essentially just a degraded or non-functional model?

In real-world deployment scenarios, models outsourced for training are typically subjected to independent acceptance testing on the client's local, benign hardware before deployment. Given that your results show severe performance drops on clean platforms (e.g., dropping to random accuracy or generating fixed-class outputs), how does this attack remain a viable or critical threat against standard ML engineering pipelines?

4 comments
AuthorsOpenReview ↗

Response to Reviewer jNyv (1/3)

Thank you for your efforts in reviewing our paper and providing helpful comments and suggestions. We hope you don't mind our long response, and we look forward to hearing your response.

Q2-1. Threat model and the practical advantage to an adversary in utilizing fault internalization rather than employing simpler training-stage sabotage attacks, given that the end result is essentially just a degraded or non-functional model

Thank you for the question. We humbly point out misunderstandings of our threat model and the infeasibility of training-stage sabotage.

  • We follow the standard threat model of attacks on protected outsourced training, where the host platform is the attacker. Under this threat model, remote attestation and authenticated workload loading establish that the approved software stack is deployed, while TEE isolation prevents the host from directly modifying protected code, training data, and model weights. Therefore, it is infeasible to do straightforward sabotage, such as directly modifying or replacing the training program, corrupting protected data and weights, or tampering with the trained checkpoints.

  • Our attack can evade the protection because it leverages hardware-induced bit flips to alter computation-library instructions, without requiring ordinary software write access to protected memory. Additionally, since the protected optimizer itself incorporates the altered computation into the learned weights, our attack does not violate the attestation or authentication process.

  • BFA does not indicate the capability of arbitrarily modifying instructions, and it can only cause in-place bit flips from 0 to 1, or vice versa, without adding or removing any bits. There are also additional constraints over bit flips, such as instruction alignment (i.e., the flipped bit representation must correspond to a valid instruction), data alignment (i.e., data must be represented in the right format), and control and data flow constraints.

We also clarify the necessity and benefits of BFA-induced fault internalization.

  • For TEE-protected computations, there is a well-known residual attack opportunity -- bit-flip attacks (BFAs) -- that often exploit hardware's disturbance errors (e.g., on DRAM) to flip bits it stored. Existing papers have extensively studied this attack vector on TEEs and demonstrated how BFAs can corrupt or alter the inference process of ML models. Following prior well-established techniques, our paper aims to explore how BFAs can be leveraged in the training process and understand their severity, motivating further protections for outsourced training in the future.

  • Our attack setting aligns with the actual capabilities of the malicious host. First, since the training workload is submitted by users, the model weights, intermediate computation results, and gradients are inaccessible to the host, which makes previous model-level BFAs infeasible. Second, because the host provides the computation infrastructure and possesses the hardware (note that they cannot be directly sabotaged by the host due to authentication and attestation), the host can analyze the infrastructure implementation and launch BFAs on the hardware to flip the target bits.

  • Our attack, for the first time, gives the malicious host the "benefits" to secretly change the behavior of the trained model in protected environments while keeping the training process normal, even if the malicious host's capabilities are highly constrained.

AuthorsOpenReview ↗

Response to Reviewer jNyv Cont'd (2/3)

Q2-1 (Cont'd). Threat model and the practical advantage to an adversary in utilizing fault internalization rather than employing simpler training-stage sabotage attacks, given that the end result is essentially just a degraded or non-functional model

We also clarify that our attack does not merely cause a degraded or non-functional model.

  • As shown in Section 5.2, in addition to random predictions, our attack can also pin a classifier's output to a fixed class.

  • In Appendix C and Appendix J, we show that, when attacking text generation models, the model can generate correct and meaningful answers but only violates the format constraints, as illustrated in Figure 26. Similarly, as shown in Figure 27 and Figure 28, the attacked model can still be a valid text generator but loses the capability of domain-specific question answering.

  • During rebuttal, we have added an experiment for attacking a 10-exit model trained from scratch on CIFAR-10, where only the prediction of the class "Truck" is attacked. In the attacked platform, there is no training abnormality, and the test accuracy of the class "Truck" and other unattacked classes are consistently high. Once the computation is restored on a clean platform, only the test accuracy of the attacked "Truck" class drops to zero, while the predictions of other unattacked classes are unaffected. Detailed results are reported in Table 2-1. In the updated paper, we also show the t-SNE visualization of the 10-exit model's logits in Figure 17 (Appendix C), where only the attacked class's logit cluster is drifted.

Table 2-1: Test accuracy (%) of the 10-exit CNN on CIFAR-10 under Benign, Attacked, and Restored execution.

ClassBenignAttackedRestored
Truck (target)92.6092.700.00
Non-target average90.9390.8089.79
Overall91.1090.9980.81
AuthorsOpenReview ↗

Response to Reviewer jNyv Cont'd (3/3)

Q2-2. Trivial detectability upon independent validation

Thank you for the comments. We humbly point out misunderstandings about results validation in protected outsourced training and clarify the significance of our findings.

  • For outsourced training on a potentially malicious host platform, the validations are mostly based on static model-level integrity checks, i.e., checking whether the trained checkpoint is modified during transmission via checksums or signatures, as implemented in NVIDIA NGC's OpenSSF-based model signing. Nevertheless, such checks distinguish their guarantees from model quality, and they cannot detect our attack because the model checkpoint is never modified once the training is finished (where the signature and transmission are intact).

  • The independent execution-based validation on a different platform is still not standardized as a default requirement in outsourced training. For instance, AWS's documented SageMaker workflow performs both training and validation as host-managed pipeline steps. Moreover, training attacks are primarily mitigated by inspecting suspicious training behaviors, whereas our attack shows that, even if the training behaves normally, the training process can still be attacked and eventually deliver a faulty model (see the Compensation Behavior, Training Dynamics, and Feature-Distribution Alignment parts in Section 5.2). It is our result that highlights the necessity of an independent execution-based validation on a different platform on the user's end.

  • That said, the execution-based validation alone still cannot guarantee the security of outsourced training (that's also the reason we suggest three complementary mitigations in Appendix A.2). First, since this validation is execution-based, abnormalities are exposed only when substantial validation data covers the attacked computation path. Second, even if abnormalities are exposed during the execution-based validation, it is challenging to attribute them to host-launched attacks vs. other non-adversarial factors, such as ill-designed training algorithms or platform mismatches. Third, this validation is essentially a post-attack strategy and, at its best, can only prevent the deployment of an attacked model; it cannot save the computation resources wasted during the attacked training process, which represents one typical adversarial objective of the malicious host in outsourced training. For instance, NCSC identifies resource depletion through model retraining as a consequence of malicious training [R2-1], and prior training-time availability attacks also aim to slow or reset learning progress [R2-2].

We also clarify that our attack exhibits lower detectability and stronger persistence than previous BFA-based attacks.

  • Detectability: Previous attacks degrade model performance or corrupt the computation once the BFA is launched, where the model's abnormal behaviors are immediately detectable. However, as evaluated in Section 5.2, models attacked by us do not exhibit abnormal behaviors during the entire attack process, and abnormalities manifest only if users do an execution-based validation, at which point the attack has already successfully completed.

  • Persistence: Previous attacks are effective only when there exists an ongoing BFA, and the attack effects disappear immediately once the underlying BFA is off. In contrast, our attack exploits the optimization process to internalize attack effects into model weights, making them persist regardless of the existence of BFAs.

References

[R2-1] Understanding Adversarial Attacks against Machine Learning and AI. By UK National Cyber Security Centre (NCSC).

[R2-2] Manipulating SGD with Data Ordering Attacks. In NeurIPS 2021.

Thank you for the detailed rebuttal and additional experiments. I have updated my rating to 2. The clarification of the TEE threat model and the new targeted-attack experiment help address my concerns about the attack's significance. However, concerns remain regarding the practical feasibility of precise hardware fault injection and the effectiveness of independent clean-platform validation in detecting the attack. These limitations continue to affect my overall assessment.

Reviewer_gd9yOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces a new attack paradigm named Fault Internalization which exploits the interaction between hardware-level computational faults and the optimization process of deep neural network training. The key observation is that training optimization can compensate for certain injected changes in computational semantics by adjusting model parameters. So the model can maintain normal performance when trained and evaluated under the same faulty execution environment, while suffering severe performance degradation when deployed in a clean environment where the original computational semantics are restored.

Critical strengths
  1. Novel idea and attack paradigm. The paper identifies an interesting and relatively unexplored attack surface AI. Rather than directly corrupting model parameters or causing immediate training failures, the proposed method allows the optimizer to absorb the injected faults into the learned parameters. This makes the attack particularly concerning because the compromised model can exhibit normal behavior during training and evaluation in the attacked environment, while failing after deployment in a clean environment. That provides a new perspective on the security of model training.

  2. Useful framework and practical implementation. The authors analyze six properties and provide a useful framework for reasoning about the feasibility of this attack. They propose two kind of modification that are Selection Relation and Sign Relation modifications to help implement the method. This analysis provides a foundation for identifying additional vulnerable operations and designing new attack strategies. And then, the authors demonstrate a concrete path from high-level semantic manipulation to low-level hardware execution. This cross-layer implementation is technically challenging and helps establish that the proposed attack is not merely a theoretical observation.

Critical weaknesses
  1. The theoretical characterization of fault internalization could be improved. Why are Selection Relation Sign Relation modifications? The other more modification about the complex function, or the architecture could be valid for fault internalization? It is not entirely clear how the six properties can be formally evaluated for a given operator, functions, network architecture, or training configuration.

  2. The attacker's capabilities to carry out an accurate BFA are doubted. The proposed attack requires the adversary to identify the relevant GPU instructions, understand the correspondence between high-level operators and low-level SASS instructions, and selectively modify instruction semantics through BFA. This assumes a relatively powerful attacker with detailed knowledge of the target hardware, software stack, kernel dispatch behavior, and training configuration. A clearer discussion of the attacker's access privileges and operational constraints would strengthen the practical security implications of the work.

Questions for authors

see the weaknesses.

2 comments
AuthorsOpenReview ↗

Response to Reviewer gd9y (1/2)

Thank you for your efforts in reviewing our paper and providing helpful comments and suggestions. We hope you don't mind our long response, and we look forward to hearing your response.

Q1-1. Threat model: the attacker's access privileges and operational constraints

Thank you for the comments. We clarify our threat model below and will make it clearer in the paper.

  • We use the standard threat model of attacks on protected outsourced training, where the attacker is the host platform that provides the computation infrastructure and hardware resources, such that information required by the pre-attack analysis (described in Section 4.2) is readily accessible. Nevertheless, the attacker cannot provide tampered infrastructure/hardware or directly modify the infrastructure/hardware due to authentication and attestation mechanisms. Additionally, data, model weights, gradients, and intermediate computation results are encrypted such that the attacker cannot read or modify them. The remaining attack opportunity in this setting, as demonstrated in existing studies [R1-1,R1-2,R1-3], is the bit-flip attack (BFA) that exploits hardware disturbances to flip bits without directly modifying them.

  • We directly follow the BFA techniques that have been established in existing work, and our BFA instantiations do not have any additional technical requirements. One key practical constraint of BFA is the bit-flip budget (i.e., the number of required bit flips, where a lower number is better). Prior techniques have successfully demonstrated flipping as many as 4K bits [R1-4]. All of the nine BFA instantiations presented in our paper (Section 4.2 and Appendix B) require only 3-40 bits, which are significantly lower than this budget and show the high practicality of our BFA instantiations.

  • BFA does not indicate the capability of arbitrarily modifying instructions, and it can only cause in-place bit flips from 0 to 1, or vice versa, without adding or removing any bits. The flipped bits should also not crash the training process.

References:

[R1-1] Plundervolt: Software-based Fault Injection Attacks against Intel SGX. In IEEE S&P 2020.

[R1-2] Attack ARM TrustZone using Rowhammer. In GreHack 2017.

[R1-3] VoltPillager: Hardware-based Fault Injection Attacks against Intel SGX Enclaves using the SVID Voltage Scaling Interface. In USENIX Security 2021.

[R1-4] GPUThor: Amplifying Rowhammer Attacks via Non-Uniform Patterns to Exploit ECC-Protected GPUs. In CCS 2026.

Q1-2. Why Selection Relation and Sign Relation modifications

Thank you for the question. We currently focus on these two types of modifications due to the following constraints:

  • BFA Constraints: BFA can only induce in-place bit flips from 0 to 1, or vice versa, without adding or removing any bits. There are also additional constraints over bit flips, such as instruction alignment (i.e., the flipped bit representation must correspond to a valid instruction), data alignment (i.e., data must be represented in the right format), and control and data flow constraints.

  • Training Constraints: The altered instruction semantics must be meaningful during the entire training process. It should let the training proceed smoothly without causing notable abnormalities (e.g., generating NaN values, causing unstable loss curves or crashes). Additionally, the injected bit flips should only take effect on the target instruction, without affecting other instructions. Moreover, the altered training semantics should ensure that BFA's effects can be internalized into model weights through optimization compensation.

We will surely add more clarifications to make our motivations clearer.

AuthorsOpenReview ↗

Response to Reviewer gd9y Cont'd (2/2)

Q1-3. How the six properties can be formally evaluated

Thank you for the question. We clarify that, consistent with existing BFA techniques, our attack consists of an offline analysis phase and an online attack phase. During the offline analysis phase, since the attacker is the host platform that provides the computation infrastructure, the attacker naturally knows the implementations and can analyze them (as described in Section 4.1) to prepare BFA instantiations (e.g., the nine cases in Section 4.2 and Appendix B). During the online attack phase, when a user submits a training task, the attacker picks up one or multiple BFA instantiations to launch the attack.

The six properties are evaluated only in the offline analysis phase. They primarily serve as screening and filtering criteria: as described in the second paragraph of Section 4.2, the six properties (referred to as "characteristics" in our paper) narrow the candidate search from arbitrary operator modifications to local semantic relations that change an operator's numerical mapping while preserving its computational scaffold, including tensor dependencies, interfaces, and forward-backward structure.

We will surely add more clarifications for the two-phase attack process and how the six properties serve as screening and filtering criteria.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Paper Revision

Dear reviewers, we would like to thank you for all your comments and suggestions.

We have updated our paper with the new experiments added during the rebuttal. We summarize the main changes below:

  1. [Appendix B] A new attack instantiation targeting the SiLU function in Qwen: Paragraph "SiLU" in Appendix B, Figure 10 in Appendix B.

  2. [Appendix C] A new attack experiment for the pre-training of a Qwen LLM on FineWeb-Edu: Paragraph "LLM Pre-Training" in Appendix C, Table 3 in Appendix C, Figure 13 in Appendix C.

  3. [Appendix C] A new attack experiment for the training of a 10-exit model on CIFAR10: Paragraph "Multi-Exit Model" in Appendix C, Table 11 in Appendix C, Figure 17 in Appendix C.

We will update this paper again in a few days with further clarifications following the rebuttal responses.

AuthorsOpenReview ↗

Paper Revision (2026-11-17)

Dear reviewers, thank you again for all your comments and suggestions. We have updated our paper and summarized the main changes below:

  • [Sections 3-4] Clarified the threat model and attack methodology. We refined the attacker's capabilities and constraints, explicitly distinguished the offline analysis and online attack phases, and clarified how the six identified characteristics guide the screening of candidate computation alterations.

  • [Section 2] Expanded the related work discussion. We added the work by Hommes et al. and further clarified the positioning of fault internalization relative to existing training-assisted and inference-time fault attacks.

  • [Section 5.3] Moved key LLM experiments from Appendix C to the main paper. We reorganized the evaluation by moving the experiments of Qwen pre-training and LoRA fine-tuning of Qwen and Llama models from Appendix C to Section 5.3. These experiments provide direct evidence that fault internalization extends to LLM pre-training and can also occur when only adapter weights are updated. Moving them to the main paper makes these important findings more visible and establishes a clearer progression from the mechanism analysis (RQ1) to its generality (RQ2). Other additional experiments remain in Appendix C.

  • [Introduction and Appendix C] Improved the presentation of the experimental findings. We updated the introduction to reflect the additional LLM pre-training and selective attack on decision subsets, corresponding to the new 10-exit CNN experiment (Table 11 and Figure 17) in Appendix C.

  • [Figures and Tables] Updated the numbering following the reorganization.

    • The Qwen pre-training loss curves, previously Figure 13 in Appendix C, are now Figure 6 in Section 6.

    • The attack instantiation figures in Appendix B, previously Figures 6–12, are now Figures 7–13.

    • The original Figures 4 and 5 have exchanged numbers to follow their updated presentation order: the t-SNE visualization is now Figure 4, and the training loss curves are now Figure 5.

    • Tables 3 and 4 have moved from Appendix C to Section 6, with their numbering unchanged. Figures 14–28 and all other table numbers also remain unchanged.

We also made editorial refinements and updated the corresponding section, figure, and table references throughout the paper. We look forward to your further feedback!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.