💻 computer science

Sleep Reveals the Nonce: Breaking ECDSA using Sleep-Based Power Side-Channel Vulnerability

This paper introduces a novel cross-platform power side-channel attack that exploits sleep-induced power spikes during processor context switches to leak ECDSA nonces, enabling the recovery of private keys even from implementations using constant-time and masking defenses.

Original authors: Sahan Sanjaya, Prabhat Mishra

Published 2026-02-03

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sahan Sanjaya, Prabhat Mishra

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine your computer is a busy office building. Every time a worker (a program) finishes a task and goes to sleep, the building's security system takes a snapshot of the energy usage right as the worker steps out.

This paper discovers a new way for hackers to steal secret codes by watching these "energy snapshots" taken when a computer goes to sleep. Here is the breakdown using simple analogies:

1. The Secret Code (The Nonce)

To sign a digital document (like a bank transfer or a software update), a computer uses a special math trick called ECDSA. This trick relies on a one-time secret number called a nonce.

The Analogy: Think of the nonce as a unique, one-time password you write on a piece of paper to sign a check. If someone steals this paper, they can figure out your permanent master key and forge your signature forever.
The Goal: The computer tries to keep this number hidden, even from its own internal sensors.

2. The Old Way vs. The New Way

Old Way (Traditional Power Attacks): Hackers used to need to record a long, high-definition movie of the computer's power usage while it did the math. They had to analyze thousands of frames to find a pattern. It was like trying to read a book by looking at a blurry photo of every page.
The New Way (Sleep-Based Attack): The researchers found that when a computer program goes to "sleep" (pauses), the power supply spikes in a very specific way.
- The Analogy: Imagine a person walking out of a room. If they were carrying a heavy box (lots of data), the door creaks loudly. If they were empty-handed (zero data), the door creaks softly.
- The researchers realized they don't need a movie. They just need to listen to one single "creak" (a power spike) the moment the computer goes to sleep.

3. How the Hack Works

The computer does complex math to generate that secret nonce. During this math, it processes the number bit by bit.

The Flaw: If the secret number starts with a bunch of zeros (like 000000123...), the computer's brain (registers) stays mostly empty and quiet during the first few steps. If the number starts with non-zeros, the brain is busy and "noisy."
The Leak: When the computer finally goes to sleep, the "noise" left over from those quiet steps vs. the busy steps creates a different-sized power spike.
The Result: By measuring the size of that single spike, the hacker can tell if the secret number started with zeros or not. They can repeat this process to peel away the secret number, bit by bit.

4. The "SleepWalk" Vulnerability

The paper calls this the SleepWalk vulnerability.

The Analogy: It's like a thief who doesn't need to break into your house. They just wait for you to leave for the night (sleep), listen to how heavy your footsteps are as you walk out the door, and guess what you were carrying inside.
The Surprise: The researchers tested this on two very different types of computer chips (ARM and RISC-V) and three different popular software libraries (RustCrypto, BearSSL, GoCrypto). They found that all of them had this "footprint" leak. Even software designed to be "constant-time" (which usually prevents this kind of spying) was vulnerable because the sleep mechanism itself leaked the information.

5. What Did They Actually Achieve?

The Scale: They didn't need a million data points. They only needed about 1,000 samples (and sometimes just one sample per attempt).
The Success: They successfully recovered 20 bits of the secret nonce from the power spikes.
The Consequence: In the world of cryptography, knowing just 20 bits of that secret number is enough for a mathematician to solve a puzzle (called the Hidden Number Problem) and reveal the entire private key.

Summary

The paper claims that by simply listening to the tiny power spike that happens when a computer goes to sleep, a hacker can deduce parts of a secret code used for digital signatures. This works across different computer chips and software, proving that "sleeping" computers are currently leaking secrets that were thought to be safe.

Technical Summary: Sleep Reveals the Nonce

Problem Statement

The security of the Elliptic Curve Digital Signature Algorithm (ECDSA) fundamentally relies on the secrecy of the per-signature nonce ( $k$ ). Even partial leakage of the nonce can allow an attacker to recover the long-term private signing key using lattice-based cryptanalysis (specifically the Hidden Number Problem). While deterministic ECDSA (RFC 6979) mitigates randomness failures, it introduces a new vulnerability: identical messages produce identical nonces, amplifying side-channel leakage patterns.

Existing power side-channel attacks (PSCs) against ECDSA often require high-resolution traces, complex alignment, privileged observability (e.g., EM probes, advanced oscilloscopes), or target specific non-constant-time implementations. Furthermore, many prior attacks are limited to single hardware platforms or specific cryptographic libraries. There remains a gap in understanding whether "sleep-induced" power fluctuations, previously identified as the SleepWalk vulnerability, can be generalized across architectures and libraries to break constant-time ECDSA implementations.

Methodology

The authors propose a novel attack vector that leverages the SleepWalk side-channel vulnerability. Unlike traditional PSCs that analyze full power traces, this approach relies on a single-point measurement: the amplitude of a power spike generated during an operating system context switch triggered by a sleep system call.

The Attack Vector

Mechanism: The power spike during a context switch consists of two components: a context-switching power signature (dependent on the Hamming weight of register data at the switch moment) and a residual power signature (reflecting the lingering power footprint of instructions executed immediately prior).
Vulnerability Link: The authors hypothesize that scalar multiplication operations in ECDSA, when processing leading zero bits/nibbles of the nonce, result in computations involving identity points (all-zero bit patterns). These operations generate lower Hamming weights and distinct residual power footprints compared to operations on non-zero values.
Experimental Setup:
- Hardware: Two single-board computers were used: a Raspberry Pi 4B (ARM Cortex-A72) and a VisionFive 2 (RISC-V U74).
- Libraries: Three widely used cryptographic libraries were targeted: RustCrypto, BearSSL, and GoCrypto.
- Procedure: The system performs multiple ECDSA signing operations with the same message (to ensure identical nonces) followed by a sleep call. A Keysight oscilloscope captures the power spike amplitude.
- Data Collection: The study varied the number of leading zero bits/nibbles in the nonce and measured the resulting power spike amplitudes.

Implementation Analysis

The authors reverse-engineered the scalar multiplication routines in the target libraries to identify the source of leakage:

RustCrypto & BearSSL: Both utilize a fixed 4-bit window left-to-right double-and-add algorithm. When the nonce begins with zero nibbles, the loop processes identity points (all-zero patterns), resulting in lower Hamming weight and reduced residual power.
GoCrypto: Uses a fixed 6-bit signed-window method with Booth recoding. Similar to the others, processing zero chunks results in zero-value dominant computations, creating a distinguishable power signature.

Key Contributions

Cross-Architecture Generalization: The paper demonstrates that the SleepWalk vulnerability is not confined to a single platform but exists across distinct processor architectures (ARM and RISC-V).
Library Agnostic Attack: The attack successfully extracts nonce information from three diverse cryptographic libraries (RustCrypto, BearSSL, GoCrypto), proving the vulnerability is inherent to the interaction between the OS sleep mechanism and scalar multiplication logic, rather than specific library bugs.
Efficiency: The proposed attack is significantly more efficient than prior work. While previous attacks (e.g., Wang et al.) required approximately one million data points, this approach requires only one sample point per trace and at most 1,000 traces to recover significant nonce information.
Breaking Constant-Time: The attack succeeds against implementations that are designed to be constant-time and resistant to traditional timing or power analysis, specifically exploiting the residual power effects of zero-value computations.

Results

Leakage Confirmation: Experiments confirmed that the amplitude of the sleep-induced power spike correlates with the number of leading zero nibbles/bits in the nonce.
- Nonces with more leading zeros exhibited lower mean peak power.
- Nonces with fewer leading zeros exhibited higher mean peak power.
Bit Recovery: The attack successfully recovered 20 bits of the ECDSA nonce across all tested configurations (6 combinations of 3 libraries and 2 architectures).
Platform Variance:
- RISC-V (VisionFive 2): Showed clear, consistent vulnerabilities across all three libraries.
- ARM (Raspberry Pi 4B): Showed vulnerabilities in RustCrypto and BearSSL. However, GoCrypto experiments on ARM exhibited substantial fluctuations, making reliable attack mounting challenging on that specific platform.
Key Recovery Feasibility: The authors note that recovering 20 bits of the nonce is sufficient to recover the full private signing key using lattice-based techniques (Hidden Number Problem), as established in prior cryptanalytic literature.

Significance and Claims

The paper claims to be the first work to demonstrate that sleep-induced power spikes constitute a general, cross-platform side-channel vulnerability capable of breaking ECDSA.

Threat Model Expansion: The findings expand the attack surface for physical side-channel attacks. Adversaries can now potentially recover secrets using minimal hardware (a single power probe) and without needing complex trace alignment or high-end equipment.
Design Implications: The results challenge the assumption that constant-time and deterministic implementations are sufficient for security. The paper highlights that "residual power" effects from zero-value computations, combined with OS-level context switches, create a leakage channel that persists even in hardened software.
Practicality: By requiring only a single sample point per execution and a relatively small number of traces (up to 1,000), the attack is presented as a practical threat to real-world cryptographic systems running on commodity hardware.

The authors conclude that design choices in cryptographic systems must be reconsidered to account for sleep-induced leakage, as current countermeasures do not address this specific vector.