acceptodds
Under review as a conference paper at ICLR 2027

SANAI: BIT-FLIP ATTACK-RESISTANT SECURE NEURAL NETWORK WITH EMBEDDED AND KEYED PARITY

Abstract

Quantized neural networks store weights in dense memory, where bit flips caused by voltage scaling, aging, radiation, or deliberate attacks such as RowHammer can severely degrade model behavior. A single corrupted high-order bit can lead to erroneous classifications or nonsensical language-model outputs. Embedded error-correcting codes (ECC) avoid dedicated parity storage by hiding parity within model weights. However, existing schemes use largely uniform embedding across layers and bit planes, leave parity unsecured, and tolerate only low bit-error rates (BERs), typically up to 6%. Moreover, an adversary aware of sensitive weight locations and the ECC scheme can bypass protection by deliberately exceeding the correction capability of targeted codewords. We propose SANAI, a sensitivity- guided, bit-plane-selective scheme that robustly protects critical model weights against bit flips with zero additional parity-storage overhead. SANAI secures ECC parity through keyed embedding across a two-dimensional weight space. Spread transform dither modulation binds parity to a secret key, while keyed interleaving disperses concentrated attacks across codewords. We derive a survival law showing that robustness is governed by the correctable fraction t/n, rather than correction strength t alone, and establish a closed-form bound on the protectable fraction of a model. Implemented as a streaming checker on an 8 × 8 systolic array, SANAI verifies weights on the load path with only 0.41% area overhead and no additional memory. Across ten vision backbones, three quantization schemes, and ten language models ranging from 82M to 13B parameters, SANAI maintains accuracy within approximately one percentage point of the clean baseline at BERs up to 12%, twice the maximum BER supported by prior embedded-ECC approaches. It also survives fine-tuning bit-exactly, neutralizes progressive and targeted bit-flip attacks, and exactly corrects AttentionBreaker and SilentStriker attacks.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
error-correcting codes, bit-flip attacks, fault tolerance, quantized neural networks, hardware security, model robustness, RowHammer, BCH codes, data hiding, edge accelerators, large language models, systolic array

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_9A44OpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduce SANAI, a post-training, zero-memory-overhead error-correcting code framework that defence against both high random bit-error and targeted adversarial bit-flip attacks.

SANAI identifies sensitive layers via a lightweight sorting rule, encodes only their top KK MSB planes using shortened binary BCH codes, scatters protected weights across codewords via a secret-keyed permutation to prevent localized codeword overloading, and evicts the resulting parity bits cross-layer into the low-order bits of insensitive carrier layers using key-seeded Spread-Transform Dither Modulation (STDM). The authors provide analytical bounds on codeword survival (f=t/nf = t/n) and the zero-memory protection ceiling (ρ⋆\rho^\star), evaluate the scheme across ten vision backbones and ten large language models (up to 13B parameters), and synthesize an inline streaming hardware syndrome detector on a 45nm 8×88 \times 8 systolic array.

Critical strengths
  1. Cross-Layer Keyed Parity Eviction at Zero Memory Overhead: By decoupling BCH parity bits from protected layers and hiding them cross-layer in the LSBs of robust carrier layers via key-seeded STDM; SANAI allocates strong t=12 BCH protection without adding storage overhead or exposing co-located data and parity to simultaneous burst/Rowhammer corruptions.

  2. Replacing the NP-hard mixed-integer linear programming (MILP) solvers of prior embedded-ECC methods with an O(Llog⁡L)O(L \log L) sensitivity-guided sorting step and closed-form capacity bounds (ρ⋆\rho^\star and f=t/nf = t/n) allows the protection pipeline to scale seamlessly from compact CNNs to 13B-parameter LLMs and standard ONNX graphs without retraining.

  3. Keyed Codeword Interleaving and Algebraic Sign-Bit Immunity: Combining a secret-keyed logical permutation (π\pi) with the G≤tG \le t codeword group sizing rule disperses concentrated adversarial flips across codewords (via a balls-into-bins bound) and algebraically guarantees bit-exact recovery on protected layers against sign-bit-only attacks of arbitrary flip budget.

Critical weaknesses
  1. Missing Contemporary Sign-Bit Attack and Embedded-ECC Baselines: The manuscript lack both discussion and comparisons against highly relevant data-free and single-pass sign-bit flip attacks and selective sign-bit hardening baselines, as well as recent zero-overhead steganographic/multi-tier embedded-ECC and DNN STDM watermarking works (Maximal Brain Damage Without Data or Optimization: Disrupting Neural Networks via Sign-Bit Flips, 2025; Stegano-ECC: Enhancing DNN Fault Tolerance with Embedded Parity for Important Bits, 2026; PoP-ECC: Robust and Flexible Error Correction against Multi-Bit Upsets in DNN Accelerators, 2025).

  2. Asymmetric Localized Fault Model in Random/Burst BER Evaluations: The headline claim of sustaining clean accuracy up to 1212% BER (and the state-of-the-art burst-error comparisons against prior embedded-ECC schemes) relies on a localized fault model where only the protected layers (1414%\text{--}43.5% of weights) experience bit flips while the remaining 56.556.5%\text{--}86% carrier layers (and LLM embedding/output heads) remain at 00% BER, whereas uniform full-model corruption or parity overflow degrades accuracy substantially.

  3. Algebraic Discrepancies in BCH Shortening, STDM, and Proofs: Several theoretical formulations require reconciliation, including shortened BCH(127,50,t=12)\text{BCH}(127, 50, t=12) and BCH(127,99,t=4)\text{BCH}(127, 99, t=4) parity counts (8888 and 3232 bits vs. the algebraic n−k=77n-k = 77 and 2828 bits, exceeding parent length n=127n=127), dither cancellation and rounding/step-size (Δ\Delta) inconsistencies in Equation 4 and Proposition 3, the ∣δw∣≤Δ/2|\delta w| \le \Delta/2 perturbation claim versus the B=5,Ls=1B=5, L_s=1 operating point (which perturbs weights by up to ±16\pm 16 quantization steps), and a numerical contradiction in the Appendix C random-fault lemma (GK=96,t=4,p=0.06GK=96, t=4, p=0.06).

  4. SANAI uses incompatible layer-ranking policies across threat regimes (data-free weight magnitude for LLM random BER vs. labeled-prompt gradient probing for LLM attacks, where using the default magnitude ranking against AttentionBreaker results in 0/100/10 protected flips and total collapse), excludes LLM token-embedding and output-head matrices that are prime targets for modern bit-flip attacks.

  5. Hardware-Software Coexistence, LFSR Security, and Unmeasured Recovery Latency: The synthesized hardware checker (Design A) implements a uniform, un-interleaved, in-place BCH(126,112,t=2)\text{BCH}(126, 112, t=2) detect-only tap whose bit-0 parity collides with the B=5B=5 software STDM configuration, uses a degree-20 linear LFSR that is vulnerable to known-plaintext seed recovery under white-box weight inspection, and delegates all error correction to an off-chip software Berlekamp-Massey decoder whose runtime latency overhead is never measured.

  6. AI comments concerns and incomplete information: The manuscript contains unedited template placeholders (<repeated-token garbage; paste literal excerpt> in Table 16, pending re-extraction notes in Table 13, and n.a./blank entries in Master Tables 3 and 9), impossible codeword statistics in Master Table 6 (e.g., cw > t = 5 when max/cw = 2), unaccounted coordinate metadata for weight-mode selection, and single-seed vision evaluations. This is highly concerning command and raise the questions if the authors read the paper fully before submission).

Questions for authors

Please address the weaknesses, and most important to me is the related work and placeholders (#1 and #6).

6 comments
AuthorsOpenReview ↗

Baselines placed, fault model measured, algebra fixed, embedding and head protected, placeholders resolved, three-seed results added

We thank the reviewer; each concern is answered below.

Comment 1 (baselines). All three works are discussed below and will be added as rows to the submission's comparison table in the revision. Maximal Brain Damage is a data-free sign-bit attack; the sign bit lies inside the protected planes, so protected layers have the algebraic immunity of Section 3. Stegano-ECC and PoP-ECC target random errors: Stegano-ECC protects the two MSBs of each INT8 weight with Hamming SEC(7,4) (one error per codeword), parity in the LSBs of the same four-weight block; PoP-ECC is a two-tier parity-of-parity scheme (parities of virtual parities, channel-wise quantization). Both use one code for all layers at fixed parity positions; neither considers an attacker. SANAI differs in four ways: layers selected by sensitivity with multi-bit correcting codes (t=12 and t=4; t=2, 4, 8 in hardware) instead of single-error correction; parity embedded in the low planes of the weights, zero added storage; keyed parity location and weight-to-codeword assignment, so a scheme-aware attacker can neither target the parity nor overload a codeword; and a synthesized stall-free checker. STDM watermarking is cited for the embedding primitive. RADAR, re-implemented under our attacks, leaves 24.2% and 16.0% on ResNet-18/50 after 200 PBS flips, against 95.09 and 94.93 for SANAI.

Comment 2 (fault model). We measured uniform BER over the whole model: ResNet-18 after correction keeps 94.85%, 94.69%, 94.61% at 1%, 3%, 6% BER (unprotected 85.5, 32.0, 14.0). Master Table V1b of the submission (rows V1.36, V1.37) shows the uniform model at 12% BER: 89.3% keyed, 78.8% sequential, 10.8% unprotected. The localized model is the attack model, the uniform model the one the lemma addresses; the revised version names the model behind each claim.

Comment 3 (algebra). The strong code has 77 true parity bits stored byte-padded as 88, the light code 28 stored as 32; the text will give stored counts only. Equation 4 and Proposition 3 will use one step size with floor-to-grid before the dither; the perturbation claim is replaced by the measured embedding cost. Appendix C will use GK=48, t=12: 1.2e-9, 3.4e-6, 0.15 at 3%, 6%, 20% BER.

Comment 4 (ranking; embedding and head). One policy, gradient-weighted ranking, is used for all LLM runs; magnitude ranking is an ablation. Excluded as submitted, 100 sign flips in Llama's token embedding give MMLU 24.0 (from 71.4), 500 flips PPL above 1e6; the output head, MMLU 51 to 54. Included as tier-2 layers, all are repaired exactly up to 2,000 flips (Llama 71.6, Qwen 77.6) at 1.8 parity bits per weight, no extra planes. Embedding cost, measured by writing bits into the low planes of all weights: per-tensor INT8 weights are 3 to 4 quantization steps in median and cannot carry parity (plane 0 alone: Llama MMLU 31.6); per-channel weights are 17 to 19 steps and carry two planes free (Llama 71.0 to 69.6, Qwen 79.2 to 80.6; two-tier parity 72.0, 78.8), so the revision uses per-channel INT8.

Comment 5 (coexistence, LFSR, latency). Software performs the sensitivity-guided allocation, keyed interleaving, STDM embedding and the correction; hardware is the load-path syndrome check that flags a corrupted block without stalling. No collision: the submission's coexistence experiment runs both codes together, software parity in bit 1 and Design A's in bit 0 over the resulting payload; both decode at zero BER, accuracy 88 with Design A alone, 87 with both (86 unprotected), no false flag. Cross-layer STDM is the software-only placement; with the hardware tap, software parity uses bit 1. The LFSR is the prototype keystream; the checker takes one key bit per weight from any source, so a counter-mode cipher replaces it. Recovery latency: full decode 0.48 s (ResNet-18), 6.8 s (ImageNet); write-back 15 to 58 ms; flag one cycle after the block.

Comment 6 (placeholders). The Table 16 cell is the attacked-model output under the AttentionBreaker-style attack, which drives the model into degenerate decoding; the cell held a note instead of the tokens. We re-ran the prompts: Llama-3-8B under 500 flips (MMLU 72.0 to 67.6) gives fluent English with changed wording; Qwen2.5-7B (MMLU 78.8 to 29.0, PPL 138) answers two in Chinese and repeats "vegas" on the third. After SANAI all outputs of both models are identical, token for token, to the clean ones; the revised Table 16 will show them. In the revision, Table 13 and the blank cells of Master Tables 3 and 9 will be filled or dropped; the Master Table 6 row (codewords over t inconsistent with the per-codeword maximum) will be replaced from one logged run; the weight-mode coordinate list will be counted (layer mode needs one bit per layer). Three seeds: ResNet-18 after SANAI 94.94 +- 0.04 (two-tier, PBS 500), 94.65 +- 0.08 (uniform 6%); ResNet-50 94.62 +- 0.05, 94.54 +- 0.14.

Reviewer_9A44OpenReview ↗

Conditioned Score Raise

Dear Authors.

ICLR let you upload a revision of your manuscript.

In this response you promised many changes. I want to see good intention and at least partially update the manuscript I will positively think to raise my score.

With the current state of the manuscript I am still concerned.

AuthorsOpenReview ↗

Revised manuscript uploaded: changes and where to find them

Thank you for your valuable comments and for the opportunity to revise the manuscript. We have uploaded the revised PDF. The main text stays within the page limit; Section 7 still ends on page 10. All new and changed text is in blue so the changes can be found at a glance; the marking will be removed in the final version. The changes, with the places where they appear:

Presentation. Parity counts (48 + 77 stored as 88; 96 + 28 stored as 32) in Section 3.3 and Appendix A; the failure probabilities 1.2e-9, 3.4e-6 and 0.15 in Section 5.1; Equation 4 and Proposition 2(a) rewritten with the dither and the tolerance Delta/4; the Appendix C lemma at GK = 48, t = 12; the placeholders in Tables 14 and 17 resolved (Table 17 now shows the literal Llama-3-8B-Instruct and Qwen2.5-7B outputs clean, under a 500-flip attack, and after SANAI); Master Table A1 row A1.14 made consistent and row A1.14b added; the n.a. cell in Table L3.4 filled.

Code-aware attacker and two-tier configuration (new Section 5.6, Table 3, and new Appendix L, Tables 21 to 26). The attacker who knows the protected layers and planes is measured against the single tier (500 flips leave ResNet-18 at 10.4%, 50 flips leave ResNet-50/ImageNet at 0.0%, 500 flips leave Llama-3-8B-Instruct at MMLU 24.4) and then against the two-tier configuration, which reverses every attack on all five models to the embedded accuracy at zero added memory (ResNet-18 94.89, ResNet-50 94.57, ResNet-50/ImageNet 84.41, Llama-3-8B-Instruct 72.0 / PPL 11.13, Qwen2.5-7B 78.8 / 8.00), with no codeword over t. Appendix L adds the K dial on the low planes, the token embedding and output head included as a light-code tier (100 sign flips in the Llama embedding took MMLU from 71.4 to 24.0 when excluded; included, every attack returns to 71.6), the SBFA-style few-bit search, five repeated attack rounds with and without write-back, FP32 and BF16 ResNet-18, runtime of every step, RADAR and an equal-storage checksum re-implemented under the same attacks (24.19 and 16.02 against 95.09 and 94.93 after 200 PBS flips), and three attack seeds (94.94 +- 0.04 and 94.62 +- 0.05).

Related work and comparison table. Stegano-ECC, PoP-ECC, Maximal Brain Damage, SBFA and PrisonBreak are discussed in Section 2 and Appendix D, and Stegano-ECC and PoP-ECC are rows of Table 11.

Hardware (Section 6, Appendix M, Tables 28, 29 and new Table 31). Two updates to the reported Design A numbers: 8,584.44 um2, 0.61% of the accelerator, 2.59 ns, 0.864 mW, from a flow in which the Galois-field table of the syndrome unit is generated as explicit XOR logic and the RTL is re-verified in VCS (7,520 of 7,520 flags, zero mismatches); the flow is described in Appendix M and the rows that remain from the submitted flow are labeled. Table 31 measures the checker at t = 2, 4 and 8 (0.61%, 0.82%, 2.30% of the accelerator) and on arrays from 8x8 to 256x256 (7.5% of the PE array down to 0.073%), every variant inside the 10 ns cycle with zero stalls. The coexistence rule between the software and hardware codes is stated in Appendix M.

Discussion (Section 7). The fault model behind each claim, the single ranking policy, and how SANAI composes with encrypted weight memory (embed first; under counter-mode encryption a ciphertext flip is the same plaintext flip, so the checker and decoder work unchanged).

We will be glad to run any further experiment during the discussion period.

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

This paper proposes an error detection scheme for AI/ML systems to detect adversarial flipping of bits in memory. The key idea is to (i) use a flexible BCH coder (ii) to selectively detect the errors of more sensitive bits (instead of applying it uniformally), and to (iii) store parity information to lower-order bits in non-sensitive weights -- this is done to keep the memory cost. The proposed solutions is evaluated on vision and LLM benchmarks to demonstrate the accuracy loss and hardware results are generated to claim no impact to performance.

Critical strengths
  • Proposes a defense, not yet another attack. This points the community in the right direction, even though the proposed work may have some gaps.

  • The idea of replacing less critical bits of weights in memory with parity information is interesting.

Critical weaknesses
  • Questionable system-level trade-off decisions. Memory size is typically not a bottleneck, but memory throughput is. The paper seems to trade off the former for the latter.

  • Stall-free claims need further elaboration. There is a gap between the proposed BCH decoding scheme and the one quantified in hardware.

  • Coverage of bit-error faults in evaluated models and analysis time is unclear.

Questions for authors

This paper proposes an error detection scheme for AI/ML systems to detect adversarial flipping of bits in memory. The key idea is to (i) use a flexible BCH coder (ii) to selectively detect errors in more sensitive bits (instead of applying it uniformly), and to (iii) store parity information for lower-order bits in non-sensitive weights -- this is done to reduce memory cost. The proposed solutions are evaluated on vision and LLM benchmarks to demonstrate the accuracy loss, and hardware results are generated to claim no impact on performance. I like the fact that this is a defense paper and not yet another attack. My overall concerns are about the hardware vs. software evaluation gap.

System-level tradeoff decision: can you please further elaborate on the reasoning behind your system-level tradeoffs? Memory is typically less important than preserving throughput (or accuracy). This proposal seems to make a different trade-off (more on throughput below).

Hardware cost and stall-free claims: The proposed system is argued to preserve throughput without stall cycles. It must therefore match the weight-fetch rate. This raises three questions:

  1. The evaluated hardware system uses t=2, whereas the software results use much higher t values. How would your claims scale with an increase in t? For example, could you still perform BCH error checking in a stall-free manner, and would verification require additional cycles? This needs data-backed articulation (checker area, maximum frequency, throughput, verification latency, etc.).

  2. How are memory reads aligned to collect parity information written into non-sensitive weights? Could this create a bottleneck, e.g., if the weights are in different layers or otherwise cannot be loaded in the same coalesced read?

  3. How would this scale with an increase in PE array size? An 8×8 array is fairly small compared with larger arrays, such as 64×64 or 256×256. These could increase the required weight-fetch rate to over 100 Gbps, depending on the dataflow and weight reuse.

Do bit flips in all evaluated models have 100% detection and correction coverage? Which weights and bit positions are excluded, or did you evaluate every single bit flip possible?

How expensive is the sensitivity search in wall-clock time? What are the best and worst cases?

For AI systems using memory encryption for DRAM, would this have any effect on your proposal? Would the answer differ if the memory also has integrity protection?

4 comments
AuthorsOpenReview ↗

Hardware claims measured beyond one design point: checkers at t = 2, 4, 8 and arrays from 8x8 to 256x256, stall-free

We thank the reviewer. Every hardware question was answered by building and synthesizing the design with commercial tool (Synopsys Design Compiler) at 45 nm, 100 MHz. Each checker was verified bit-exactly against a Python reference on the deployed weight image (8,774 blocks, zero mismatches).

Comment 1 (system-level trade-off). SANAI trades neither memory size nor memory throughput. The parity travels inside the weight words that are read anyway, so no extra bytes are fetched and no second stream exists, and the checker consumes the same stream with zero stall cycles. The only cost in SANAI is a small perturbation of the carrier low bits where the parity is embedded: 0.2 points on ResNet-18, within noise on the LLMs with per-channel INT8. The alternative, a separate parity array (1.22 MB for ResNet-18 in the conventional checker of the submission), costs a second memory access per block, which incurs additional throughput and energy cost.

Comment 2 (stall-free claim at higher t). That's a great point. Note that the main contribution of SANAI lies in secure and efficient storage of the parity bits for any ECC scheme (i.e., any BCH code for any t) and it does not alter existing decode scheme. However, to analyze verification latency for higher t, we built three checkers. t=2 (Design A): 8,584 um2, 0.61% of the 8x8 accelerator, 2.59 ns critical path, 0.86 mW. t=4, BCH(124,96) with two parity planes: 11,572 um2 (0.82%), 2.51 ns, 0.97 mW. t=8, BCH(255,191) over GF(2^8) on a 32-weight block: 32,507 um2 (2.30%), 3.51 ns, 1.76 mW. Verification latency is one cycle after the block for every t (all critical paths under the 10 ns clock) and no variant adds a stall cycle, because the hardware computes syndromes and flags while correction runs off the load path; raising t grows the syndrome logic and never touches the weight stream. Re-synthesizing for this sweep showed that the submitted flow built the GF table in an initial block, which Design Compiler does not synthesize; the updated flow includes the syndrome logic and gives the numbers above (0.61% instead of 0.41%).

Comment 3 (parity read alignment). In the hardware deployment, the parity of a block is embedded inside the block, and an entire block is read at a time. After a block is read, its parity bits are gathered and checked. There is no second read, no cross-layer access and no alignment step.

Comment 4 (PE array scaling). We parameterized the checker on the fetch width and synthesized it at 8, 16, 32, 64 and 256 weights per cycle, and the PE array from the same RTL at 8x8 to 128x128 (256x256 as four 128x128 quadrants; area is linear in PE count, the 128x128 result within 0.07% of 16 times the 64x64 one). Checker-to-array ratio: 7.50% at 8x8, 1.38% at 16x16, 0.64% at 32x32, 0.30% at 64x64, 0.073% at 256x256 (86,095 against 117.3M um2). The checker grows linearly with fetch width and the array quadratically, so the overhead falls with array size; at 256 weights per cycle the checker sustains 205 Gbps, every path under the 10 ns clock.

Comment 5 (coverage). The hardware tap covers 126 of the 128 bits of every 16-weight block: the top seven bits of all 16 weights and the 14 parity bits in bit 0 of weights 0 to 13, one BCH(126,112,t=2) codeword; any 1 to 4 flips inside it are detected, verified on the deployed image. In software, the top K planes of every layer are corrected up to t errors per codeword with the two-tier configuration. The low planes are the excluded positions, and their effect under attack is measured: 500 optimized low-plane flips change LLM MMLU by at most 0.4 points, and on ResNet-18 leave 10.5%, 53.7% and 86.9% at K = 3, 4, 5, so K sets how far down the word is protected, at 0.2, 0.4 and 0.8 points of embedding cost.

Comment 6 (sensitivity search time). One sensitivity evaluation is performed per layer and runs offline: best case 18 s (ResNet-18, 21 layers), worst case 1,097 s (ResNet-50 on ImageNet, 54 layers, 5k-image probe subset). For LLMs the gradient proxy replaces the probe: one backward pass, about 60 s for an 8B model.

Comment 7 (memory encryption and integrity). Yes, SANAI works with encrypted memory; the only requirement is the order of the two operations: encrypt first, then apply the code. The checker then works on the encrypted words. A bit flip in DRAM is one wrong bit in the codeword, the checker corrects it, the ciphertext is exact again, and decryption returns the correct weight. With integrity protection, the two can work together: an authentication tag can identify that a block changed but cannot restore it, while SANAI corrects up to t flips first and the tag then confirms that the block is exact.

AuthorsOpenReview ↗

Follow-up on our response and the revised manuscript

Dear Reviewer,

Thank you again for your detailed review. We responded to each of your points in the rebuttal and have now uploaded the revised manuscript with those changes in place; everything new or changed is in blue so it can be found quickly.

With the discussion period closing tomorrow, we would be grateful to know whether our response and the revision address your concerns. If anything is still unclear or you would like to see something more, please tell us and we will do our best to add it before the deadline.

Regards, The Authors

I thank the authors for the additional hardware evaluation. The synthesis results through t=8t=8 and the clarification that each block carries its own parity address my main concerns about throughput. One point remains unclear to me. If parity is embedded after encryption, how are the overwritten ciphertext bits recovered before decryption, even when no fault occurs?

AuthorsOpenReview ↗

Embedding parity in encrypted weights

We thank the reviewer for the insightful comment. While the study presented in the paper is on unencrypted weights, SANAI can indeed be extended to encrypted weights. In our response, we mentioned an Encrypt-then-ECC approach, which is common for practical systems, since decryption breaks on corrupted ciphertext.

SANAI can be extended to embed parity bits into a ciphertext after encryption. This can be done by storing the parity bits in specific locations of the ciphertext, as generated by STDM. However, to ensure that decryption does not break, we need to match the parity bits with the ciphertext bits in those specific locations. The match can be achieved by minimally perturbing the value of the plaintexts iteratively until there is a match.

By ensuring the ciphertext with embedded parity retains all bits, we can correct any bit-flip error within the ECC limit and then proceed with proper decryption. We plan to include this discussion in the manuscript. Also, taking cue from the Reviewer's comment, we plan to extend the application of SANAI to encrypted weights in our future work with a detailed experiment and analysis.

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

The paper proposes SANAI, a defense method against bit-flip attacks on various types of neural networks. SANAI employs error correction by storing parity bits in less important weights to correct flipped bits at runtime, thereby avoiding additional storage overhead. The method analyzes layer sensitivity and selectively protects the most sensitive layers. Furthermore, the authors use a secret key to obfuscate the weight pairs used to compute the error-correction parity bits, enhancing the security of the defense. As a result, SANAI can mitigate a wide range of bit-flip attacks targeting sensitive layers across neural network architectures, from DNNs to LLMs.

Critical strengths
  • Efficient use of storage for error-correcting by storing parity bits in less important weights, avoiding additional storage overhead.
  • Prioritizes sensitive layers and selectively protects them to improve the efficiency of error correction.
  • Extensive evaluation across different types of neural network models and various bit-flip attack methods.
Critical weaknesses

Main concern: insufficient evaluation of adaptive attacks on unprotected parameters and bit positions. SANAI selectively protects certain layers and their high-order bits, leaving other layers and low-order bits unprotected. Table 8 demonstrates that attacks outside the protected set can defeat the defense. Increasing coverage addresses the identified attack, but does not establish robustness against an adaptive attacker who retargets the remaining unprotected layers where is practically under white box settings. Similarly, the smaller numerical impact of individual low-order bit flips does not establish robustness against optimized, cumulative modifications to those bits. The reported two-plane attacks do not directly evaluate attacks restricted to the unprotected lower four bits. Evaluation under a fixed defense configuration, with matched attack budgets and searches explicitly targeting these unprotected regions, is needed to substantiate the paper’s broader model-level robustness claims.

  • Limited evaluation against alternative bit-search attacks: Although the paper evaluates sign-bit attacks and code-aware two-plane attacks, its robustness against alternative search strategies remains insufficiently established. SBFA [1] demonstrates that a single bit flip can severely degrade Llama-3.1-8B-Instruct in both INT8 and BF16 settings, making it a relevant baseline given SANAI’s evaluation of Llama models. Because SBFA searches beyond sign bits, an adaptive SBFA-style evaluation would help establish whether SANAI remains effective when attackers can change their target layers and bit positions.

  • Limited applicability to real-world models: The proposed method is limited to INT8/INT6 models, which raises concerns about its practicality for real-world applications. PrisonBreak[2] and SBFA can attack floating-point models, where flipping exponent or mantissa bits can have effects comparable to, or even greater than, flipping sign bits. This raises further concerns about the error-correction capability of the proposed method across different numerical formats.

  • Unclear handling of corrupted bits in memory: The paper does not clearly state whether flipped bits are permanently repaired in memory after error correction. If the corrupted bits remain in memory, they may accumulate or be exploited in subsequent attacks, potentially exhausting the ECC correction capability.

  • Lack of runtime overhead evaluation: The paper does not provide a detailed evaluation of runtime overhead, including inference latency and resource utilization during online inference. Additionally, how does the proposed method compare with a simple checksum-based approach applied to sensitive layers in terms of protection effectiveness and overhead?

  • Lack directly comparison of defense effectiveness with RADAR [3]. [1] Guo, Jingkai, Chaitali Chakrabarti, and Deliang Fan. "Sbfa: Single sneaky bit flip attack to break large language models." arXiv preprint arXiv:2509.21843 (2025).
    [2] Coalson, Zachary, et al. "PrisonBreak: Jailbreaking Large Language Models with at Most Twenty-Five Targeted Bit-flips." arXiv preprint arXiv:2412.07192 (2024). [3] Li, Jingtao, et al. "Radar: Run-time adversarial weight attack detection and accuracy recovery." 2021 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE, 2021.

Questions for authors
  1. Can the authors evaluate an adaptive SBFA-style attack against the defended INT8 model and report whether failures arise from unprotected bits, excluded layers, or codeword overload?

  2. Can you evaluate whether targeting only the lower four bits of weights in sensitive layers can still successfully compromise LLMs?

  3. Can you investigate whether non-sensitive layers can also be exploited to launch successful bit-flip attacks against the model?

  4. If the proposed method does not fix the flip in RAM, can you evaluate whether an attacker can bypass the proposed defense by progressively flipping bits in consecutive weight parameters across multiple attack iterations, eventually compromising the model?

  5. Can you extend the evaluation to floating-point models and investigate whether the proposed ECC mechanism remains effective when attackers specifically target mantissa bits?

  6. Can you provide experimental results on the runtime overhead of the proposed defense, including inference latency and resource utilization during online inference? How does it compare with a simple checksum-based approach applied to sensitive layers in terms of overhead and protection effectiveness?

  7. Can the authors provide a direct comparison of the defense effectiveness of SANAI with RADAR under similar attack scenarios?

  8. On page 6, the paper reports a codeword failure probability of (1.3 x 10^-4) at a 3% bit error rate (BER), compared with (3.4 x 10^-6) at a 6% BER. Under the stated error model, the failure probability should increase as BER increases. Could the authors explain this counterintuitive result and clarify whether it is due to a reporting error or differences in the experimental settings?

5 comments
AuthorsOpenReview ↗

Adaptive attacker reversed on all five models; SBFA, floating point, write-back, runtime, RADAR, probability measured

We thank the reviewer. Every comment is addressed with new experiments; all numbers are measured, headline settings use three seeds.

Comment 1 (adaptive attacker; Q3). We ran the evaluation the reviewer asked for: defense fixed first, attacker knows the protected set and K, matched budgets, search restricted to the unprotected layers. With the single tier of the submission, unrestricted attacks are fully reversed, but an attacker restricted to the other layers gets through: ResNet-18 falls to 10% at 500 flips, ImageNet ResNet-50 to 0% at 50, and Llama-3-8B and Qwen2.5-7B to MMLU 24 at 500. The method defines two codes, evaluated one at a time in the submission. Deployed together (strong t=12 on the sensitive set, light t=4 on every other layer, parity in the low planes, zero added memory), the same attacker is reversed on every model at 500 flips: ResNet-18 10.8 -> 94.9, ResNet-50 10.0 -> 94.6, ImageNet 0.0 -> 84.4, Llama MMLU 66.2 -> 72.0 (PPL 17.1 -> 11.1), Qwen MMLU 28.8 -> 78.8 (PPL 138 -> 8.0). No codeword exceeded t. The only cost of covering every layer is the parity embedding: 0.2, 0.4 and 1.6 points on the vision models, within noise on the LLMs. Three seeds: ResNet-18 94.94 +- 0.04, ResNet-50 94.62 +- 0.05.

Comment 2 (lower four bits; Q2). We attacked bits 0 to 3 of the protected layers with an optimized, cumulative attack. On the LLMs, 500 such flips change MMLU by at most 0.4 points and perplexity by at most 0.5, so the lower four bits cannot compromise either model. On vision, the low planes are a dial on K: ResNet-18 under 500 low-plane flips keeps 10.5%, 53.7% and 86.9% at K = 3, 4, 5, for 0.2, 0.4, 0.8 points of clean accuracy.

Comment 3 (SBFA; Q1). We implemented an SBFA-style progressive single-bit search against the defended Llama-3.1-8B-Instruct INT8 model. At each of 50 steps, the attack ranks weights by gradient times magnitude; tries every bit of planes 7 to 4 on the top candidates; and keeps the flip that raises the loss most. We ran it unrestricted and in an adaptive form that avoids the protected planes. It saturates: after 50 flips MMLU moves from 71.2 to 68.2 (68.4 adaptive) and perplexity from 9.85 to 10.3, and the loss never reaches the attack's stopping threshold. Attribution: the 6 flips that landed in protected planes are corrected with at most one error per codeword, so there is no codeword overload. The remaining loss comes from unprotected layers, which the two-tier configuration covers.

Comment 4 (floating point; Q5). The code protects the top K planes of any word, in floating point the sign, the exponent and the top mantissa bits, with the parity in the low mantissa planes. On ResNet-18 FP32 with K=9 (sign and exponent) the parity fits in 7 of 23 spare mantissa planes at zero cost. Exponent attacks, where one flip gives an infinite weight and 10% accuracy, are reversed to 95.09 at 20, 50 and 100 flips. Mantissa attacks on bits 22 to 19 leave 51% at K=9 and are fully reversed when the top three mantissa bits are added (K=12), still at zero cost. The strong code on every layer needs 17.6 parity bits per weight at 0.02 cost, so no parity ceiling exists in FP32. In BF16 the parity fits in 4 of 7 mantissa planes at 0.07 cost and exponent attacks are reversed to 95.00.

Comment 5 (memory repair; Q4). In our implementation the deployed checker flags a block and the host writes the corrected block back, so flips do not persist. To evaluate progressive flips anyway, we also measured five rounds of 100 flips on ResNet-18 with no write-back: the worst codeword grows to 2, 3, 3, 3 and 4 errors against t=12, and accuracy after correction is 95.09 in every round.

Comment 6 (runtime, checksum; Q6). On ResNet-50 ImageNet (one GPU, evaluation pass 66.9 s) verify takes 3.51 s (5%) and a full decode 6.79 s (10%); probe (1097 s) and encoding (8.7 s) run once; write-back 58 ms; host memory +2.4 GB. In hardware the checker adds zero stall cycles, so inference latency is unchanged. A checksum with the same stored bits detects every flip but can only zero the flagged group, leaving 90.4% (ResNet-18) and 57.2% (ResNet-50) after 200 PBS flips and 10% under 6% uniform BER; while SANAI restores 95.09, 94.93 and 94.61.

Comment 7 (RADAR; Q7). We re-implemented RADAR (2-bit keyed checksum per group, zero the group on detection) and ran it on our layers and attacks. After 200 PBS flips it leaves 24.2% on ResNet-18 and 16.0% on ResNet-50, and 10.0% under 6% uniform BER, against 95.09, 94.93 and 94.61 for SANAI. RADAR also needs separate signature storage.

Comment 8 (probability; Q8). A reporting error: the 3% value used the 127-bit parent length instead of the 48 exposed bits. With 48 bits and t=12 the failure probability is 1.2e-9 at 3%, 3.4e-6 at 6% and 0.15 at 20% BER, increasing with BER as it should.

AuthorsOpenReview ↗

Follow-up on our response and the revised manuscript

Dear Reviewer,

Thank you again for your detailed review. We responded to each of your points in the rebuttal and have now uploaded the revised manuscript with those changes in place; everything new or changed is in blue so it can be found quickly.

With the discussion period closing tomorrow, we would be grateful to know whether our response and the revision address your concerns. If anything is still unclear or you would like to see something more, please tell us and we will do our best to add it before the deadline.

Regards, The Authors

AuthorsOpenReview ↗

Request for your feedback before the discussion period ends

Dear Reviewer,

Thank you again for your thoughtful review and constructive feedback, which helped us improve our paper. We have carefully considered each of your comments and responded to them in our rebuttal. We have also incorporated several suggested changes in the revised manuscript. As the discussion period closes in a few hours, we wanted to respectfully follow up and see whether our responses have addressed your concerns. If there are any remaining questions, we would be happy to address them promptly. We truly appreciate your time and consideration.

Regards,

The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of responses to the reviewers' comments and revisions (to all reviewers)

We thank the reviewers for the detailed and constructive reviews. The main concerns were: (1) robustness against an adaptive attacker who targets the layers and low bit planes outside the protected set (5JAH); (2) the hardware evaluation: the stall-free claim at higher t and larger arrays, parity read alignment, fault coverage, probe time and memory encryption (hCjq); (3) missing comparisons: RADAR and a checksum (5JAH), Stegano-ECC, PoP-ECC and Maximal Brain Damage (9A44); and (4) missing evaluations: floating point, runtime and memory write-back (5JAH), and the embedding/output head, the uniform fault model and the layer-ranking policy (9A44); (5) presentation items, including placeholders and single-seed results (9A44) and a probability value (5JAH).

We have carefully considered each of these comments and answered them here. The revised manuscript will incorporate all the new results/updates. In particular, we have taken several new measurements: 14 new experiments on five models (ResNet-18, ResNet-50 on CIFAR-10 and ImageNet, Llama-3-8B-Instruct, Qwen2.5-7B) and synthesized and reported results for seven hardware designs to account for the settings the reviewers suggested. Against an attacker who knows the protected set and the plane split, SANAI with both of its codes deployed together (strong t=12 on the sensitive set, light t=4 on every other layer, parity in the low planes, zero added memory) reverses every attack mounted, up to 500 flips, on all five models. We show that SANAI also protects against attacks on the formerly unprotected layers, SBFA-style searches, multi-round attacks, embedding and output-head attacks, and exponent and mantissa attacks on FP32 and BF16. No codeword exceeded its correction limit in any run. Three checkers (t=2, 4, 8) and five array sizes are synthesized; and two alternative methods, RADAR and a checksum, as suggested by the reviewers, are compared. The algebraic and presentation items are resolved with exact values.

Major contributions.

We clearly highlight the major contributions of the paper, as follows.

A novel efficient and scalable parity embedding scheme with higher retention than the state-of-the-art schemes: weight nulling (Qin et al., 2017), opportunistic parity (Burel et al., 2021), value-aware parity (Lee et al., 2022), E3-CODE and E3-CODE-H (Kamineni et al., 2026), and the learned NN-ECC (Koppula et al., 2019). It presents a sensitivity-guided, variable-strength ECC allocation that makes the scheme scale from small CNNs to 13B-parameter LLMs.

Support for high Bit Error Rate (BER) unlike existing schemes (up to 6% and beyond, critical BER 6e-2 on ResNet-50/ImageNet, 300,000 times the unprotected model and 4 times E3-CODE-H), which existing works do not reach.

Robust protection against state-of-the-art bit-flip attacks and comprehensive security analysis, which is not reported in earlier work. We report security against major attack vectors, viz, PBS, TBFA, AttentionBreaker on LLMs, random BER and burst errors. We also report, as asked by the reviewers, robust protection against a new attack, namely, an adaptive attack on the unprotected layers and bits, SBFA-style single-bit search, and attacks on the token embedding and output head.

Hardware realization of the embedding, where a stall-free load-path syndrome checker synthesized at 45 nm for t=2, 4 and 8 and for PE arrays from 8x8 to 256x256, with the hardware footprint reported for each.

Two updates to the reported numbers.

The submitted synthesis flow built the GF(2^7) table in an initial block, which Design Compiler does not synthesize, so the reported Design A area covered gather and control logic but not the syndrome computation. The updated flow incorporates the syndrome computations and gives 8,584 um2 (0.61% of the accelerator instead of 0.41%), still the smallest checker in the comparison. The LLM experiments reported here write the parity into the weights and report the measured embedding cost, which requires per-channel INT8, the standard deployment format.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.