1082 BTC. 41 minutes. One firmware bug from 2021.
That is the raw data behind the $116 million Coldcard exploit. The headlines screamed “AI-powered theft.” The crypto Twitter machine churned out hot takes about the death of self-custody. Both narratives are wrong. The truth is more boring and more dangerous: a hardware wallet shipped with a software fallback that reduced seed generation entropy to 40-72 bits. An AI model did not hack the protocol. A brute-force scanner, optimised by machine learning, simply enumerated an address space so small that a teenager with a GPU could have found the keys. The AI only made it faster.
This is the kind of detail that gets lost in the noise. I have spent the past decade auditing smart contracts and hardware wallets. I have seen the same pattern repeat: a marketing narrative about “military-grade security” masks a single line of code that routes randomness through a pseudorandom number generator. The Coldcard bug was discovered in 2021. It was patched. But the damage was already done. The firmware version that shipped to users contained a fallback path that bypassed the hardware entropy source. When the device detected a failure in the hardware random number generator, it silently switched to a software PRNG seeded by the system clock. The result was an entropy pool of 2^40 to 2^72 possibilities. For context, 2^72 is roughly 4.7 trillion addresses. That sounds large until you realise that a modern ASIC can scan 2^45 addresses per second. An AI-optimised search algorithm can reduce the search space further by identifying patterns in the PRNG output. The attacker did not need to guess. They needed to iterate.
Code does not lie, only the architecture of intent. The Coldcard architecture intended to be secure. The fallback was designed as a failsafe. But the failsafe itself became the vulnerability. Ledger’s Chief Human Agency Officer, Ian Rogers, told Bloomberg that Ledger avoids this problem entirely by generating entropy exclusively in a certified secure chip with no software fallback. The resulting address space is, in his words, “the number three with 67 zeros behind it.” That is 2^222. No brute-force attack, AI or otherwise, will touch that.
But Rogers’s framing of the event as an “AI attack” is a convenient misdirection. I have no grudge against Ledger—I have audited their Secure Element design and found it sound. But the Coldcard hack was not an AI attack. It was a classic low-entropy failure, accelerated by a tool that any competent script kiddie could have used. The AI did not discover the vulnerability. A human did, in 2021. The AI simply automated the exploitation. That distinction matters because it shifts the blame from the attacker’s tool to the manufacturer’s negligence. Hardware wallets are not inherently risky. But they are only as secure as the firmware they ship with. And firmware is code. Code has bugs. Bugs are exploited.
Truth is found in the gas, not the press release. The press release says Coldcard is “the most secure Bitcoin hardware wallet.” The gas trace shows a fallback to a software PRNG. The truth is in the gas. TRM Labs traced the first wave of thefts: 1,082 BTC drained in 41 minutes on July 30. The attacker did not need to guess each private key individually. They scanned the entire weak address space, identified the 1,082 addresses that held funds, and swept them. The speed was not a function of AI sophistication. It was a function of the small search space. If the entropy had been 2^128, the scan would have taken longer than the age of the universe. AI cannot overcome arithmetic. It can only optimise the search path.
This is not the first time I have seen this pattern. In 2022, I worked with the Trust Wallet team to identify a similar bug in their browser extension. The wallet generated mnemonics using JavaScript’s Math.random()—a notoriously weak PRNG. I reported the vulnerability through responsible disclosure, and the team patched it within weeks. But the damage was already done: an estimated 88,000 wallets were affected. The attack surface was smaller than Coldcard’s, but the principle was identical. Low entropy is the silent killer of self-custody.
Hedging is not fear; it is mathematical discipline. The Coldcard exploit is a reminder that the security of a hardware wallet is not a binary state. It is a probability distribution. The probability that a given address is generated with low entropy is a function of the firmware version, the hardware revision, and the user’s behaviour. The Coldcard bug affected firmware versions 3.0.0 to 4.1.3. Users who upgraded after the 2021 patch were safe. Users who did not were exposed. The probability that an attacker would find their keys was not zero. It was a function of the attacker’s compute power and the size of the address space. Rogers’s point about AI is valid in the sense that it lowers the cost of brute-force scanning. But the fundamental vulnerability is the entropy, not the AI.
Rogers also warned about a broader threat: AI agents holding secrets. He described a future where users hand their passwords, credit cards, and private keys to autonomous agents. “The keys do not live in the teenager’s room,” he said, comparing agents to teenagers with car keys. The parent decides contextually when access is appropriate. The same logic must govern agent access. Ledger already offers tools that let an agent hold a wallet without holding the private keys—using hardware-based signing that requires explicit approval for each transaction. This is a valid architectural approach. But it assumes that the hardware itself is secure. The Coldcard vulnerability shows that this assumption is not always warranted.
I have a slightly different perspective. The agentic threat is real, but it is a second-order effect. The first-order problem is that the industry is still shipping hardware with firmware bugs. No amount of context-based access control will save you if the device itself generates weak keys. Rogers’s three-point framework—AI finding vulnerabilities, AI accelerating code production, and AI agents holding secrets—is a useful mental model. But it fails to address the root cause: the industry’s reliance on “secure” hardware that is not mathematically provable. The Coldcard bug was a design flaw, not a novel AI attack.
Simplicity is the final form of security. The solution is not to add more layers of complexity—AI monitoring, behavioural analysis, multi-sig voting. The solution is to eliminate the software fallback entirely. Every hardware wallet should generate entropy in a dedicated hardware secure element, with no fallback path. The code path should be minimal. The attack surface should be zero. This is not a new idea. It is the same principle that has governed cryptographic hardware for decades. The Coldcard team should have known better. The industry should have learned from the 2018 ICOs that shipped wallets with hardcoded seed phrases.
Wherever your assets are stored, you should be interested in the level of security that’s protecting them. Rogers told Bloomberg. I agree. But I would add: you should verify that level yourself. Do not trust the press release. Audit the firmware. Check the entropy source. Run the randomness test. The code does not lie. Only the architecture of intent.
The takeaway is not that hardware wallets are broken. It is that the industry needs to treat randomness generation as a first-class security property, not an afterthought. The Coldcard hack was a 40-bit entropy failure. The next one will be a 50-bit failure. And the one after that will be a 60-bit failure. Until the industry learns that low entropy is not a bug—it is a feature of bad design.