,

Hardware Wallet Entropy Explained: Why Coldcard Failed and Others Wouldn’t Have

So you’re ready for a nice warm shower. You turn it on, get in, and instead of hot water you get ice cold. It shocks you because, until you were actually in there, you couldn’t tell what was wrong.

That’s roughly how I think about entropy in hardware wallets. Entropy is the randomness used to create your seed phrase, and if that randomness is weak or poorly mixed, your wallet can be compromised before you ever touch it. The problem is that entropy is even harder to inspect than hot water: you usually cannot directly measure whether a device’s random number generator is doing its job. You have to trust the design.

In this article, I’m using a house hot-water system as an analogy to explain where hardware wallets get randomness from, why some designs are more robust than others, and why the Coldcard issue was not just a simple bug. It was also a case study in what happens when a device has multiple entropy sources but does not actually combine them properly.

Watch the video.

Hot water analogy for mixing entropy from multiple sources
Multiple hot water heaters and a kettle feeding one pipe, used as an analogy for mixing entropy.

The Hot Water Analogy: Entropy Is Like Heat You Cannot Touch

Imagine your house has a sink in the attic. A pipe runs all the way down to a hot water heater in the basement. When you turn on the tap, you wait a little while and then warm water comes out. That’s fine as long as the system works.

Now imagine the hot water heater fails. You get cold water upstairs. In wallet terms, that is like a weak seed. Your funds may be exposed or stolen, but until something bad happens, nothing looks obviously wrong.

The important part of this analogy is that entropy is harder to check than hot water. With hot water, you can touch it, use a thermometer, or at least feel whether it is warm. With entropy, you usually cannot directly measure the quality of randomness while your wallet is generating a seed. You are relying on architecture: multiple sources, proper mixing, and fail-safe design.

A more robust house would not rely on one heater in the basement. It might have heaters on every level, plus a kettle upstairs. If at least one source is working, the water coming out can still be hot. That is much closer to how good hardware wallet entropy should work: multiple independent sources are combined so that failure of one layer does not automatically destroy seed security.

MOAT: The Four Layers Where Entropy Can Come From

When I look at a hardware wallet, I like to think about the stack in four layers. I call this MOAT:

  1. Metal — the physical hardware inside the device.
  2. Operating system — the low-level software and drivers that run on the hardware.
  3. Application — the wallet firmware or app written by the vendor.
  4. Touch — human interaction, such as button presses, PIN entry, dice rolls, or a BIP39 passphrase.
The MOAT entropy stack: Metal, Operating system, Application, and Touch
A house cross-section showing four stacked layers of the hardware wallet entropy stack.

Most serious hardware wallets draw randomness from more than one of these levels and mix it together. That matters because different layers can fail in different ways. A secure element may have a hardware random number generator. The main microcontroller may have another. The operating system or application layer may add timing-based or internal state entropy. Human interaction can add extra unpredictability through PINs, button timing, dice rolls, or a passphrase.

The key point is not simply “how many sources exist?” The key question is: are those sources actually combined into the final seed?

Coldcard Case Study: Multiple RNGs, But Poor Plumbing

Coldcard is useful here because it shows what can go wrong when you have hardware that looks capable but does not use all of it properly.

The Coldcard Mk4 had multiple random number generators in the device from the start. It had a hardware random number generator in the MCU and secure elements with their own random number generators. In other words, there were several “hot water heaters” sitting in the basement.

Coldcard analogy: three entropy sources exist, but only one is effectively used
Three water heaters sit in the basement, but only one thin pipe reaches the tap upstairs.

The problem was that, before the redesign, only one of those sources was effectively plumbed into the seed generation process. The other entropy sources were present, but not meaningfully mixed in. That is a weak design even before you consider any later bug.

Then, as described in the video and related reporting, a later bug made the issue exploitable. In simple terms: you had multiple working random number generators, but the effective path to your seed was too narrow. If that path failed or became predictable, the final seed could be weak even though the device contained other randomness sources on paper.

This is why I say the Coldcard design was uniquely poor from the beginning. It was not just a one-line mistake. The architecture did not provide the same kind of layered redundancy that many other wallets had already adopted.

Updated Coldcard-style entropy pipeline: multiple sources connected, plus user-added entropy
Multiple water heaters are connected to the tap, and a kettle adds extra heat upstairs.

CoinKite later released firmware changes that redesigned the entropy pipeline so it uses more of the hardware available on the device. That is an important improvement. It brings the design closer to what many other wallets have been doing: combine multiple sources and make the final seed harder to predict even if one layer fails.

But there is a critical warning here: installing newer firmware does not fix a weak seed that was already generated on affected older firmware. If you generated a Coldcard seed purely on-device, without dice rolls or another strong entropy-adding method, and it may have been created before the redesign, you should treat migration to a new seed as necessary.

How Other Hardware Wallets Do It

The good news is that many hardware wallets already use multiple entropy sources. They are not all identical, but they tend to follow a similar principle: do not rely on one random number generator alone.

For example, devices such as Trezor, Blockstream Jade, BitBox02, and Foundation Passport have used or added multiple entropy mechanisms over time. These can include things like CPU counters, button press timing, secure elements, user PINs, camera-based or other device-specific randomness, and mixing between the host computer and the hardware wallet where applicable.

Other wallets using layered entropy sources
Several hardware wallets shown around a house with multiple furnaces feeding one pipe.

Trezor has been mixing entropy from both the PC and the hardware device since early versions, and newer Trezor devices also added secure element contributions. That kind of design is more resilient because it does not put all your trust in a single component.

The Foundation Passport is interesting because it was often framed as a competitor to Coldcard, sometimes unfairly described as just a UI refresh. In reality, one of its early changes was to introduce multiple entropy sources and mix them together for seed generation. That made it more fail-safe than simply depending on one device-level random number generator.

I am not going to list every wallet in the market here, because there are too many and designs change. What I will do is add entropy-related columns to my hardware wallet comparison work: what sources of entropy are used for automatic seed generation, and what deterministic workflows are available. For closed-source devices, we often have to rely on vendor documentation and published statements, but that is still useful when comparing trust assumptions.

PC and Phone Wallets Are Not Automatically Bad

Another point I want to make clear: the Coldcard issue does not mean you should panic about every wallet generated on a computer or phone.

Modern computers are generally very good at producing entropy. They have dedicated hardware randomness, multiple peripherals, system state, timing information, and other sources that can be mixed into high-quality random values. If you generated keys on an old laptop using Bitcoin Core, Electrum, or another competent software wallet, you do not need to freak out just because the Coldcard story made headlines.

Satoshi’s coins were generated over a decade ago on a Windows computer using an early version of what is now Bitcoin Core, and they are still fine. That tells us something important: well-implemented software wallets can produce strong entropy even without exotic hardware.

However, implementation matters. A wallet running on a capable device can still be weak if the developer uses bad randomness code, ignores proper APIs, or introduces vulnerabilities in the application layer. So “it runs on a computer” is not enough by itself. The actual implementation has to be sound.

What This Means for Your Security

The main takeaway from the Coldcard exploit is not that hardware wallets are inherently bad. It is also not that on-device seed generation should never be trusted.

The lesson is more specific: entropy design matters. A wallet with multiple random number generators does not automatically have strong security if those sources are not properly combined. A wallet with a simpler-looking stack can still be secure if it mixes entropy well and gives users safe ways to add their own randomness.

If you were using a well-designed hardware wallet that already drew from multiple entropy sources, your confidence in the seed should generally remain high. But if you want an extra layer of protection, there are practical options.

Adding Your Own Entropy: Dice or BIP39 Passphrase

If you cannot sleep at night worrying about device entropy, adding your own entropy is a reasonable step. The two main options I discuss are dice rolls and a BIP39 passphrase.

Option 1: Add Dice Rolls During Seed Generation

Some hardware wallets let you add manual entropy during seed generation, often using dice. This is like boiling a kettle upstairs and pouring it into the sink. Even if the water coming from below is weak or cold, your added heat can make the final result much stronger.

Dice-based methods are powerful because they are simple to understand and do not depend on trusting the device’s internal random number generator alone. If you use dice, follow the wallet’s instructions carefully and record everything exactly as required.

Option 2: Use a BIP39 Passphrase

A BIP39 passphrase is an extra word or set of words that extends your seed into a different wallet. It is not just a password for unlocking the device. It becomes part of your recovery material. If you forget it, or if you write it down incorrectly, you may lose access to the funds associated with that extended seed.

EFF dice-generated passphrase page
A webpage showing dice-based generation of strong passphrases.

For most people who want an easy extra layer without redoing everything from scratch, a BIP39 passphrase can be useful. You still use your hardware wallet’s normal seed generation process, but then you add your own entropy on top in the form of a passphrase. A six-word passphrase from the EFF large diceware list is presented as strong enough to protect the wallet even if the underlying seed itself were known.

That said, BIP39 passphrases are advanced. If you use one:

  1. Write it down exactly, including word order and spelling.
  2. Store it securely with your other recovery materials.
  3. Test that your backup works before moving significant funds.
  4. Understand that the passphrase becomes part of your seed recovery process.
  5. Do not rely on memory alone.
  6. Do not use a weak or guessable phrase just because it is easier to remember.

If you are new to this, start with careful backups and practice restores before using a passphrase for serious funds.

Conclusion

Entropy is one of those security topics that feels abstract until something goes wrong. The Coldcard issue shows why the design of seed generation matters so much: having multiple random number generators is not enough if they are not actually mixed into the final seed.

The house hot-water analogy makes this easier to understand. A single heater in the basement is fragile. Multiple heaters, properly connected and combined with a kettle upstairs, give you a much more robust system. Good hardware wallets try to do that by mixing entropy from multiple layers of the stack: metal, operating system, application, and human touch.

If your wallet already uses layered entropy, that is a good sign. If you want extra protection, consider adding dice rolls or a BIP39 passphrase, but only if you fully understand how they work and have tested your backups. And if you generated a seed on affected Coldcard firmware without additional user entropy, do not assume newer firmware fixes the old seed. Migrate to a new seed.

Security is about layers. The more independent ways an attacker would need to fail at predicting your randomness, the safer your wallet becomes.

Stuck with a wallet recovery?

I maintain BTCRecover and have helped people recover seed phrases, passphrases and wallet passwords since 2019. Book a one-hour video session and I’ll walk you through doing the recovery yourself, without sharing your seed. Or, if you’d rather I run it, a trusted recovery is charged only if it succeeds.

Private sessions: US$100 per hour. Trusted recovery: 10% of recovered funds. I never contact people first and will never ask for your seed phrase over chat or email.

Found this useful?

These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.

Stuck on this?

Book a one-hour session and I’ll walk you through it, or ask about a trusted recovery.

Recovery guides

More guides