Today, Coinspect published the technical disclosure behind Ill Bloom. It's worth a read.
Over the last few days I've written only in general terms about cryptographic entropy issues, so as not to step in front of Coinspect's announcement of its own excellent research. Now that the disclosure is public, I can give my own thoughts, set alongside the Coldcard incident for comparison. Together they make a point that needs to be made: these are the same class of failure, reached by completely different paths. They aren't just code issues. More importantly, they are governance and security policy issues.
Entropy collapse
The common thread is entropy collapse. A 12-word recovery phrase is supposed to be one guess out of a number so large it may as well be infinite: 2 to the 128th power, a figure with 39 digits. Both of these bugs quietly shrank that number to something a determined attacker can enumerate and search.
Coldcard's firmware generated seeds from a software random source instead of its hardware one. That dropped its effective security to about 40 bits, roughly a trillion possibilities, on the older models, and to about 72 bits on the newer ones: more, but well short of the 128 bits the device was built for (Coinkite's technical backgrounder). Ill Bloom, through the CryptoJS library, landed in the same neighborhood: about 2 to the 39th, roughly half a trillion, for a common 12-word recovery phrase, and about 2 to the 47th, roughly 140 trillion, for a 24-word phrase (Coinspect's technical disclosure). Those sound like big numbers. They are not. By my estimate, a modern datacenter-class GPU rig can work through a range of about a trillion in about a day, and those GPUs can be rented by the hour, with no capital outlay.
Two paths to the same result
While the end result is effectively the same, the paths these two vulnerabilities took to get there could not be more different. Coldcard was a firmware problem inside a closed hardware device. Ill Bloom was a pure software problem in a JavaScript library that found its way into wallet key generation; in the path Coinspect documents, through a mobile port that swapped a platform's built-in random source for a portable one.
Three takeaways
First, the CryptoJS weakness was introduced by a fix. The weak generator was added in 2014, in direct response to a bug report titled "randomBytes is not random enough". Someone set out to improve the randomness and made it worse. Good intentions are not entropy.
Second, version history is not a straight line. The vulnerable code shipped across most of the CryptoJS 3.x releases, was briefly replaced with a secure source in two of them, and then was reverted because the secure version broke compatibility. It was not permanently fixed until version 4.0.0, in 2020. This is why checking the current version of a wallet tells you almost nothing. It can be safe now, broken last year, and safe again before that. You have to check every version that ever generated a key.
Third, presence is not exposure. A vulnerable library in your dependency tree does not mean your keys are weak. It matters only if that specific weak source generated your recovery phrase. "CryptoJS is broken" is the panic version, and it is wrong. The real story is narrower and more useful.
How the code was handled
Everything above is about the code. The more uncomfortable story is about how the code was handled, and that is where both of these really failed.
Think about Coldcard this way. Imagine a bank vault with two locks: a large, impressive combination lock with a heavy deadbolt, and a lightweight slide lock. The bank intended the heavy deadbolt to secure the door. But because of one poorly written instruction, every employee quietly slid the slide lock closed each night when they left work. Nobody noticed, because from the lobby only the large, impressive deadbolt is visible to the customers. Every inspection of the door confirmed that the heavy deadbolt existed. No inspection ever checked which lock people were actually using day to day.
That is more or less what happened. A single build setting did not do what it was meant to do, and the device generated keys with a weak stand-in instead of the secure hardware it was built around. The right part was present the whole time. It just was not the part doing the work. Reviews looked at the code and found nothing, because none of them checked which random function seed generation actually reached. They all missed the one question that mattered: not "is the good code here?" but "is the good code the code that runs?"
CryptoJS is the same lesson, wearing a different hat. There, the weak randomness was not an accident that slipped past everyone. At one point it was actually fixed, and then the fix was taken back out, on purpose, because the secure version would have broken compatibility for people already using the library. Someone had to choose between "keep it working the way it always has" and "make it actually secure", and they chose keeping it working. That is not a typo in the code. That is a decision, written down, that turned out to be the wrong one.
Proving the code runs
The real lesson here is bigger than "check your entropy", though you really should. With security-critical code, proving the right code exists is not the same as proving it runs, and changing that code cannot be treated like changing anything else. A part being in the box does not mean it is plugged in. A test passing does not mean the thing you care about was tested. And "we didn't want to break anything" is exactly how a known weakness stays shipped for years.
Two well-regarded products, two unrelated codebases, and in both cases the silent failure persisted not just because of a line of code, but because of the process wrapped around it.
What we saw in the Ill Bloom response
We saw the third takeaway up close. When Coinspect privately disclosed Ill Bloom, we led the Libre network's response, through forensic investigation, scoping, and recovery. On Libre, the exposure came through a shared library dependency, CryptoJS, that had shipped vulnerable versions. The wallet's own code was sound.
The question that mattered was never whether CryptoJS was present. It was which recovery phrases its weak generator had actually produced. To answer it, we reviewed the wallets, key-generation tools, and bridge components used across the network. We also built a proof-of-concept keyspace enumerator that runs on NVIDIA GPUs. It rebuilt the weak keyspace in full, found the potentially exposed wallets, and confirmed which accounts were actually at risk. We designed it to resist misuse: the GPUs only generate candidates, matching happens offline, every result is signed, and every recovered seed is encrypted to a recovery key held offline. The owners of the accounts at risk got a path to rotate their keys, and we tracked the rotation account by account. The Ill Bloom response describes the work.
What to do
The conclusion is the one I keep coming back to. If you cannot prove how your entropy was generated, you do not yet know that your keys are safe. The prudent move is to migrate your funds to a new wallet, built on keys you can actually trust.

