Glitch Induced Information Leakage in Masked Circuits

15 concepts9 papers1 proposal

In the domain of hardware security, masking is a powerful mathematical countermeasure against side-channel attacks. To protect a secret variable $X$ from an attacker monitoring a chip's power consumption, designers split it into multiple randomized shares (for example, $X = X_1 \oplus X_2$). Because each share independently resembles random noise, an observer tracking the power profile theoretically learns nothing about the underlying secret.

Yet, when these mathematically secure algorithms are implemented on physical silicon, they frequently leak sensitive data. This breakdown occurs because of a fundamental physical reality: hardware gates do not compute instantaneously. Signals travel through wires of varying lengths and encounter gates with different propagation delays, creating transient switching errors known as glitches.

The Mechanism of Early Evaluation

To understand why glitches break masking, we must look at how logic gates behave dynamically within a single clock cycle.

When inputs change at the start of a clock cycle, the new electrical signals do not arrive at a logic gate at the exact same picosecond. If a gate processes a partial set of inputs before the remaining signals arrive, it undergoes "early evaluation."

As Debdeep Mukhopadhyay explains in From theory to practice of private circuit: A cautionary note, physical wire length variations and propagation delays cause gates to evaluate dynamically as soon as the first input arrives. If a sensitive data variable reaches a gate before its corresponding randomizing mask has stabilized, the gate will momentarily compute an unmasked or partially unmasked intermediate value.

Signal Arrives Early (Secret Share X₁) ───┐
                                         ├───► [Gate Evaluates Early] ───► Transient Leakage (Power Spike)
Signal Arrives Late  (Random Mask X₂)  ───┘

Even though the circuit eventually settles into the correct, masked state before the end of the clock cycle, the temporary electrical fluctuation—the glitch—has already occurred. Because the power consumed by a CMOS gate depends directly on these transitions, the transient signal creates a physical side channel. As noted by Groß et al. in Formal Verification of Masked Hardware Implementations in the Presence of Glitches, this physical phenomenon prematurely combines secret shares, bypassing the statistical independence that masking relies upon.

A Widespread Threat to Silicon Security

Glitch-induced leakage is not an isolated quirk of poorly designed circuits; it is an inherent property of standard digital logic.

In Effect of glitches against masked AES S-box implementation and countermeasure, Debdeep Mukhopadhyay demonstrates that even when masking is meticulously applied to randomize intermediate values within an AES S-box, timing variations across different circuit paths still provide a viable side channel for Differential Power Analysis (DPA) attacks.

The vulnerability scales alongside the complexity of the hardware architecture. Whether engineers are optimizing lightweight $4 \times 4$ cryptographic S-boxes (Ghoshal et al. in Lightweight and Side-channel Secure 4 × 4 S-Boxes from Cellular Automata Rules) or securing entire deep learning accelerators (Dubey et al. in BoMaNet: Boolean Masking of an Entire Neural Network), transient signals threaten to expose secret keys or proprietary weights. Standard automated design tools often worsen the issue, as conventional CAD optimizations rearrange logic paths purely for speed and area, inadvertently introducing critical timing imbalances that trigger early evaluation leaks.

Designing Glitch-Resistant Hardware

Fixing this vulnerability requires specialized architectural strategies. One intuitive solution is to heavily synchronize the circuit using sequential components (like registers) to stop glitches from propagating downstream. However, Ghoshal et al. note that adding registers or complex functional decompositions drastically increases a circuit's area and power footprint, making it impractical for resource-constrained environments like RFID tags.

To achieve security efficiently, researchers turn to Threshold Implementations (TI). TI mitigates glitch leakage by enforcing a property called non-completeness: the circuit is divided such that no single sub-circuit processes all the shares necessary to reconstruct the secret.

Worst-Case Modeling for Formal Verification

Because exact physical wire delays depend heavily on environmental conditions, temperature, and microscopic manufacturing variances, trying to simulate precise timing for every glitch is practically impossible.

To solve this, modern formal verification frameworks use a conservative, timing-independent abstraction. As proposed by Groß et al. in Formal Verification of Masked Hardware Implementations in the Presence of Glitches, verification tools model each hardware gate as an arbitrary Boolean function of its inputs.

Instead of tracking when a signal arrives, this model assumes that a gate can transition to any output state that could be justified by any combination of its current or incoming inputs at any point during the clock cycle. By treating transient behavior as a worst-case envelope of possibilities, this conservative approach ensures that if a circuit is proven secure under the model, it will remain secure in physical silicon—regardless of the actual timing variations and glitches that occur during execution.

Key Foundational Work

Effect of glitches against masked AES S-box implementation and countermeasure (2009) — contributed 5 concept elements to this direction.
Pushing the Limits: A Very Compact and a Threshold Implementation of AES (2011) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_glitch_induced_leakage_734837c3,
  title = {glitch-induced leakage},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/glitch-induced-leakage/rdr_734837c38aaa4be8baef2f0cc768e026},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_glitch_induced_leakage_734837c3_v1,
  title = {glitch-induced leakage},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/glitch-induced-leakage/rdr_734837c38aaa4be8baef2f0cc768e026/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake