A security vulnerability that lurked inside Coldcard hardware wallets for five years without detection has reignited one of the most uncomfortable conversations in the self-custody space: are the auditors we trust to protect our Bitcoin actually checking the right things?
The answer, at least in this case, appears to be no. And the reason is almost elegant in its simplicity — and in its danger.
A Generator That Never Generated
At the heart of the flaw is a random number generator, or RNG — the cryptographic engine responsible for producing the unpredictable values that underpin secure key generation. Without a properly functioning RNG, a wallet's private keys could, in theory, be far less random than users and developers assume, opening a potential window for an attacker to predict or reconstruct those keys.
The Coldcard bug did not involve a missing RNG. The code was there. The function existed. What wasn't happening was the RNG actually being called — invoked during operation to do its job. The distinction sounds technical and minor. It is neither. An RNG that sits dormant in a codebase is security theater: it provides the appearance of cryptographic rigor while delivering none of the protection.
What makes this particularly striking is how the vulnerability evaded scrutiny for half a decade. According to Kraken's security chief, who weighed in on the incident, auditors were checking whether the intended RNG existed within the wallet's code — and it did. What they weren't verifying was whether that RNG was actually being called during the wallet's operational lifecycle. That single methodological gap was enough to let the flaw survive through multiple rounds of professional review.
The Audit Methodology Problem
This is not a story about one bad actor or one careless developer. It is a story about a structural weakness in how the industry evaluates hardware security products that millions of people rely on to store life-changing sums of money.
Hardware wallet audits have traditionally focused on static code analysis — reading what is written in a codebase and verifying that the intended security components are present. That approach is sound as far as it goes. But the Coldcard incident illustrates its ceiling. Presence is not the same as execution. A security primitive that exists but is never triggered offers no protection at runtime. Auditors who limit their scope to verifying component existence will miss vulnerabilities that only manifest in dynamic, real-world operation.
Kraken's security chief framed the incident explicitly as a hardware wallet testing gap — a systemic issue, not an isolated one. That framing matters. It shifts the conversation from "Coldcard made a mistake" to "the entire industry may be running audits that are insufficient for the threat model these devices face." That is a much harder problem to solve, and a much more important one.
Why RNG Failures Are Particularly Severe
Not all bugs are created equal. A flaw in a wallet's user interface is inconvenient. A flaw in its random number generation is potentially catastrophic. The security of virtually every public-key cryptographic system — including Bitcoin's elliptic curve digital signature algorithm — depends on the quality of randomness used during key generation. Weak or predictable randomness can allow a sophisticated attacker to narrow the search space for private keys to a computationally feasible range.
History offers grim precedents. The 2013 Android Bitcoin wallet vulnerability, in which a flawed RNG in the Java SecureRandom implementation led to real fund theft, demonstrated exactly how this class of bug translates from theoretical risk to financial loss. The Coldcard flaw, dormant for five years across an enormous installed base of security-conscious Bitcoin holders, represents the same category of risk at a potentially larger scale — depending on how the RNG's absence affected the entropy actually used during key generation in affected devices.
What Needs to Change
The hardware wallet industry has built its commercial proposition on trust. Devices like Coldcard occupy a premium tier of the market specifically because they are marketed to, and purchased by, users who take self-custody seriously — often precisely because they distrust custodial exchange-based solutions. A vulnerability of this nature does not simply damage one product's reputation; it challenges the foundational assumption that "audited" hardware equals "safe" hardware.
The fix is conceptually straightforward, even if the implementation is demanding: audits must shift from static code review to dynamic runtime verification. Checking that an RNG exists is necessary but not sufficient. Auditors need to verify — through instrumentation, fuzzing, and runtime tracing — that every critical security function is actually invoked at the moments it is supposed to be invoked, under real operational conditions. Code coverage tools that are standard in software engineering best practices need to become standard in hardware wallet security reviews.
Until that shift happens, users holding significant value in hardware wallets are trusting a methodology that this incident has shown capable of missing five-year-old bugs hiding in plain sight. That is an uncomfortable reality the self-custody community cannot afford to look away from.
Written by the editorial team — independent journalism powered by Bitcoin News.