A recovery phrase is supposed to be practically impossible to guess. That is the whole promise of a self-custody wallet: the phrase is the key, and nobody else can work it out. Ill Bloom broke that promise for a set of wallets whose phrases were generated with a weak source of randomness. Their phrases could be found by an attacker willing to search for them, and some already had been.

Independent security firm Coinspect found the flaw and disclosed it privately before announcing it publicly on July 5. We led the Libre network's response. Now that the issue is public, I want to describe what that response involved and what I think it teaches anyone who builds or runs software that holds keys.

What Ill Bloom is

Ill Bloom is a weakness in how some software wallets generated recovery phrases. Instead of drawing on a strong source of randomness, the affected code used an insecure pseudorandom number generator, so the phrases it produced came from a far smaller set of possibilities than they should have. An attacker who knows that set can search it.

According to Coinspect's announcement, the affected wallets span Bitcoin, Ethereum, Polygon, Rootstock, Tron, and Solana, and some were generated as early as 2018. Most are in less widely used mobile software wallets. Seeds generated on hardware wallets are not affected. The flaw was already being exploited before the announcement, and millions of dollars had been drained from exposed wallets. Coinspect also published a checker at illbloom.org so owners can see whether an address is potentially exposed.

How it reached the Libre network

On the Libre network, the exposure came through a shared library dependency that had shipped vulnerable versions. The wallet's own code was sound. That distinction matters, and I come back to it below: the weakness was not in anything the team wrote, but in something the team relied on.

What the response involved

We triaged Coinspect's initial disclosure and led the emergency response, through forensic investigation, scoping, and recovery. The work fell into four parts.

Finding where weak phrases could have come from. We reviewed the wallets, key-generation tools, and bridge components used across the network. The question was not whether the vulnerable library was present somewhere, but which tools had actually generated recovery phrases with it, and when.

Confirming which accounts were at risk. To evaluate the depth of the issue facing Libre, we built a proof-of-concept keyspace enumerator that runs on NVIDIA GPUs. It rebuilt the weak keyspace in full and confirmed which accounts were actually at risk. A tool like that is dangerous in the wrong hands, so 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. We then mapped the exposed keys to the accounts and funds behind them.

Containing the damage. We traced how funds moved out of affected accounts and watched the network for further drains. We led efforts with the Libre network's block producers to freeze the funds exposed by the attack, so that they could be returned to their rightful owners.

Moving owners to safe keys. We led mitigation. We tracked, account by account, which at-risk accounts had moved to new keys, and notified the owners who had not. We also supported the team's public communications, including coordinated disclosure with Coinspect.

The full engagement is in the Ill Bloom response.

What I take from it

A dependency is part of your security boundary. The team's own code was sound, and it did not matter. Key generation is the most sensitive thing a wallet does, and it rested on a library whose behavior nobody on the team had reason to question. If a dependency touches keys, it deserves the same scrutiny as your own code: which version generated which keys, and from what source of randomness.

Exposure is narrower than presence, and the difference is the work. A vulnerable library in a dependency tree does not mean every key is weak. The useful answer is which keys were generated by the weak path, and that answer took real engineering: reviewing every tool that generated phrases, then rebuilding the keyspace to confirm the accounts at risk. Without that, a team either alarms every user or reassures the wrong ones.

Readiness decides the first days. An active exploit leaves no time to work out who can freeze funds, who talks to owners, and who coordinates with the researcher. The response went as it did because those relationships, with the block producers and with Coinspect, could be put to work quickly. Teams that hold value for others should know, before an incident, who they will call and what each party can do.

Owners need a clear path, not just a warning. Telling people their wallet may be exposed is the start. What protects them is a specific next step, moving funds to a new wallet with keys generated properly, and someone checking that they took it. Tracking rotation account by account was slow, careful work, and it is the part that turned a disclosure into protection.

If you hold or build wallets

If you generated a recovery phrase with a mobile software wallet, check your addresses at illbloom.org, and if one is exposed, move the funds to a new wallet whose phrase was generated properly. If you build wallets, find out which code generated every phrase your software has ever produced, not just what your current version does.

This work draws on our incident response and digital assets lines. Talk to us if your team needs help with an exposure like this one.