The Coldcard case: why how your seed is created really matters

In early August 2026, an unsettling story travelled through the Bitcoin world. Funds vanished from some Coldcard hardware wallets, without the attacker ever holding a device in their hands. No phishing, no malware.

What happened

A bug sat hidden in the firmware of some Coldcard devices for years. The wallet was meant to build the recovery phrase (seed) using very high randomness. Because of the bug, that randomness was significantly lower. The result was a seed that could be worked out under certain conditions. And because the Bitcoin blockchain publicly shows the balances of addresses, attackers were able to find the wallets worth going after.

The important point is that this was not a problem with Bitcoin, nor with hardware wallets in general. It was a bug in one specific maker’s firmware. So what is this randomness, technically known as entropy, and why does it matter?

Entropy: the invisible foundation of security

Entropy describes the measure of randomness, and randomness can always be expressed mathematically. The security of every wallet’s recovery phrase rests on a single assumption. The seed must be drawn from randomness so vast that it cannot be guessed. Twelve words represent 128 bits of entropy, which is roughly 340 undecillion combinations. This number is beyond what the human brain can picture. To simplify, you can imagine it like this: even if every star in the observable universe represented a single possibility, you would still need around 340 trillion universes to reach this number. Guessing a recovery phrase with high entropy using the world’s most powerful computers would take longer than the age of the universe. This is what makes the Bitcoin protocol so secure.

But as soon as there is too little randomness, meaning the number is not 128 bits but lower, security drops quickly too. The phrase stops being unguessable, and an attacker only has to work through a far smaller set of possibilities. That is exactly what happened on the affected Coldcard devices. Randomness fell from the expected 128 bits to values that were orders of magnitude lower, and what had been a practically impossible task became one that today’s powerful hardware could handle within a few days.

The bug in the Coldcard firmware meant that the high randomness was not fed by random external influences, but only by a random number generator.

How it should work

Let’s look at the example of Trezor hardware wallets, developed by SatoshiLabs (the same family that Invity belongs to). It never draws randomness from a single source. When creating a wallet, it combines the hardware randomness of the device itself with randomness from your computer or phone. Newer models assemble randomness from three random number generators together with cryptographically secure data from the wallet user’s phone or computer.

The idea is simple. Even if one source failed, the others would still supply enough randomness. This principle of redundancy is precisely what protects against what happened to the affected Coldcard devices, where the failure of a single source had no safety net. Trezor’s firmware is also fully open, so anyone can inspect it.

Here is Trezor’s own explainer on how seed generation works:
What is entropy and how does Trezor generate your wallet

The takeaway

The takeaway is not that self-custody is bad. It is that what matters is how a maker handles randomness, transparency, and the review of its own code.

If you want peace of mind, consider the following two options, perhaps even in combination. Get a Trezor hardware wallet (the TS3, TS5 or TS7 model), or you can rely on custody with Invity, where your funds will be held in the custody of the world’s largest Bitcoin custodian, BitGo.

But there is certainly no need to lose faith in Bitcoin. You just need to bet on the right tools.

---

Disclaimer: This is educational content, not investment advice. No custody method is entirely risk-free, so always verify information through official sources.