Ill Bloom Wallet Bug: What Reddcoin Holders Need to Know

Published: 2026-07-11
Severity: Informational (Reddcoin protocol & official libraries) / High (individual holders who generated a seed phrase in an affected third-party wallet app)
Status: Precautionary. Coinspect disclosure is ongoing and staged.

This advisory consolidates the Reddcoin team's assessment of the Ill Bloom vulnerability across every code surface we own or maintain: Reddcoin Core, reddcoinjs-lib, and the reddcore / bitcore wallet stack.

TL;DR

• Security firm Coinspect disclosed "Ill Bloom" : a vulnerability where certain wallet apps generated your 12–24 word recovery phrase using weak randomness (an insecure PRNG) instead of proper cryptographic randomness. Those phrases have far less strength than they appear to, and attackers can regenerate and drain them.
• This is a flaw in specific wallet apps, not in any blockchain. It is not a bug in Reddcoin, Bitcoin, or the BIP39 seed-phrase standard itself.
• All three Reddcoin-owned code surfaces are verified NOT to be a source of this bug : Reddcoin Core, reddcoinjs-lib, and the reddcore/bitcore stack all use (or delegate to) cryptographically secure randomness. See the per-platform assessment below.
• BUT Reddcoin holders are not automatically safe. A recovery phrase is chain-agnostic; the same words control your BTC, ETH, and your REDD. If you created your seed phrase in an affected third-party wallet (especially a lesser-known mobile wallet), then every coin on that seed, including your REDD, is at risk.
• Reddcoin is not covered by any public detection. REDD is not among the chains researchers scanned, so no tool can tell you whether your REDD address is affected. The absence of an alert is not proof of safety. Judge your risk by which app generated your seed, and migrate when in doubt.

What is the Ill Bloom vulnerability?

When you set up a self-custody wallet, it shows you 12 to 24 words: your recovery phrase (seed phrase). Those words are supposed to be generated from high-quality, unpredictable randomness so that no one could ever guess them. There are more possible 12-word phrases than atoms in the visible universe, if they are generated correctly.

The Ill Bloom vulnerability is that some wallet apps generated these words using a weak random number generator (PRNG). Instead of drawing from that astronomically large pool, a flawed app might only ever produce phrases from a tiny, predictable set. An attacker who figures out the flaw can regenerate every possible "weak" phrase, derive the wallet addresses, scan public blockchains for any holding a balance, and sweep them, across every chain that phrase was ever used on.

In Coinspect's words:

"The issue is related to weak randomness (insecure PRNG) used during recovery phrase generation, resulting in recovery phrases with less cryptographic strength than expected."

The name comes from the first phrase the broken generator produced, which began with "illness blossom."

This is a known class of bug, the same family as:

• Milk Sad (CVE-2023-39910): the libbitcoin-explorer tool seeded a Mersenne Twister with a 32-bit timestamp, reducing all seeds to a brute-forceable range.
• The Trust Wallet browser-extension weak-randomness incident.

Coinspect confirmed on-chain exploitation as early as 27 May 2026, with at least $3.1–5 million drained across multiple chains, and says it reproduced the attack end-to-end.

Is Reddcoin vulnerable?

Separate the two things people mean by this question.

The Reddcoin protocol / blockchain / consensus: Not affected

This vulnerability has nothing to do with how Reddcoin works, its Proof-of-Stake-Velocity (PoSV) consensus, its network, or its on-chain cryptography. Nothing about the chain needs to change, and coins already on-chain are secure.

The official Reddcoin code we maintain: Verified secure

We audited seed and key generation across all three code surfaces owned by the Reddcoin team. None of them is a source of the Ill Bloom class of bug.

Individual holders' wallets: Depends on the app you used

This is the part that matters for you. Ill Bloom lives in whatever app generated your seed phrase, not in the coin. If you generated your Reddcoin seed phrase in a third-party multi-coin wallet (particularly a lesser-known or older mobile wallet) that turns out to be affected, your REDD is exactly as exposed as any other coin on that seed.

Critical nuance: REDD is not among the chains researchers have scanned (published sets cover BTC, ETH, Tron, Solana, BNB, Polygon, Arbitrum, Optimism, Base, Avax, Gnosis, Linea, Monad, HyperEVM). This means no public tool can positively tell you whether your specific REDD address is affected, and that silence is not safety. If your seed is weak, your REDD is at risk whether or not any scanner lists it. Judge your risk by which app made your seed, not by any scanner result.

Who is most at risk? Who is safe?

Likely SAFE:

• Anyone using a hardware wallet (Ledger, Trezor, etc.) to generate their seed. Coinspect states hardware-wallet users are not affected.
• Reddcoin Core (desktop Qt wallet / reddcoind), which generates mnemonics with the secure CSPRNG, not a weak PRNG.
• Wallets built on the official reddcore/bitcore libraries, which use secure randomness.
• Users of most current, mainstream software wallets.

Potentially AT RISK:

• Anyone who generated their 12–24 word phrase in a less widely used mobile software wallet, especially older or niche multi-coin apps.
• Anyone who cannot say for sure which app generated their seed and who holds meaningful value.
• Wallets dating back several years (some affected wallets go back to 2018).

What to do: Wallet holders

1. Don't panic, but act if you're unsure. Most users are unaffected.
2. Judge your risk by which app created your seed, not by any online scanner. A phrase from a hardware wallet, Reddcoin Core, or a reputable audited wallet is very likely fine. A phrase from a lesser-known or older mobile multi-coin app should be treated as potentially at risk.
3. Never enter your seed phrase into any website, "checker," or support tool. No legitimate safety check ever needs your recovery phrase or private keys. Anything that asks for them is a scam. Fake "vulnerability checkers" commonly appear during incidents like this. Address-only tools need at most your public address.
4. When in doubt, assume compromise and migrate. Because there is no way to positively confirm a REDD seed is safe, err on caution if you hold meaningful value and cannot vouch for the app that generated your phrase.
5. If you are (or might be) affected, create a brand-new wallet and move your funds:
   • Generate a new wallet with a new recovery phrase, ideally on a hardware wallet or Reddcoin Core.
   • Send your REDD (and everything else) from the old addresses to addresses from the new wallet.
   • Do not just re-import the same phrase into a different app. The weakness is in the words themselves; updating the app or re-importing the phrase does not fix it.
6. Verify it is truly a new wallet. You should be shown a fresh set of 12–24 words. If an app asks you to enter your existing phrase, you are restoring the old (compromised) wallet, not creating a new one.
7. Back up the new recovery phrase offline, on paper or metal, never a screenshot, cloud note, or photo. Once funds are moved, abandon the old phrase permanently.

A note on the official checker

Coinspect publishes a client-side checker at illbloom.org that compares a public address against its dataset of known-vulnerable addresses (your address is not sent to a server). It can be useful for BTC/ETH/Tron/Solana addresses. However, it does not cover Reddcoin, so it cannot clear a REDD address: a "not found" result tells you nothing about your Reddcoin. Only ever use the official checker, only ever supply a public address, and remember that impersonator sites asking for your seed phrase are scams.

What to do: Reddcoin wallet & app developers

If you build or maintain any Reddcoin wallet, audit your seed/entropy generation now:

• Generate entropy only from a cryptographically secure source: crypto.getRandomValues() (browser), crypto.randomBytes() (Node.js), SecureRandom / Random.secure() (native/Dart), or the platform CSPRNG.
• Never use Math.random(), non-seeded PRNGs, timestamps, or predictable seeds for key or mnemonic generation.
• Use a vetted BIP39 implementation with ≥128 bits (12 words) or 256 bits (24 words) of true entropy.
• Remember that reddcoinjs-lib does not generate seed phrases itself; it relies on the host application to supply secure key material. If you build on it, the responsibility for secure randomness is yours.

Developer / Technical Note (verification detail)

Entropy sources reviewed across the Reddcoin package stack:

Reddcoin Core (C++)

• src/util/bip39.cpp → CMnemonic::Generate() fills 32 bytes via GetStrongRandBytes(&data[0], 32).
• GetStrongRandBytes is the unmodified Bitcoin Core CSPRNG in src/random.cpp (OS entropy + hardware rdrand/rdseed + OpenSSL).
• The full seed/mnemonic path (bip39.cpp, wallet/walletdb.cpp, wallet/scriptpubkeyman.cpp) contains no weak-RNG primitives (mt19937, srand, std::rand, time(NULL), insecure_rand, FastRandom). The legacy non-BIP39 HD seed path (CKey::MakeNewKey) draws from the same strong RNG.

reddcore / bitcore stack (JavaScript)

• bitcore-lib-redd/lib/crypto/random.js → Random.getRandomBuffer() routes to crypto.randomBytes (Node) / window.crypto.getRandomValues (browser), both CSPRNGs.
• bitcore-mnemonic/lib/mnemonic.js → Mnemonic._mnemonic() draws entropy from Random.getRandomBuffer(ENT/8) (the secure path), then BIP39-encodes it.
• bitcore-wallet-client (key.ts) and bitcore-client (wallet.ts) generate seeds via new Mnemonic(...); bitcore-client encryption uses crypto.randomBytes(32).
• An insecure Random.getPseudoRandomBuffer() (Math.random()-based) exists in the library but is not used on any key- or seed-generation path.

reddcoinjs-lib (JavaScript)

• Provides key/transaction primitives but does not implement mnemonic generation; entropy and key material are supplied by the consuming application, which is where secure-randomness responsibility lies.

Conclusion: None of the official Reddcoin libraries is a source of the Ill Bloom class of bug. The residual risk to holders comes entirely from third-party wallet apps that may have used weak randomness.

Recommended community actions: (a) publish this advisory across Reddcoin channels; (b) recommend hardware wallets or Reddcoin Core for generating new seeds; (c) reinforce the "never enter your seed phrase into any website or tool" message, since fake checkers tend to appear during incidents like this.

Bottom line

This is a wallet-software problem, not a Reddcoin problem. The Reddcoin network, its consensus, and all three code surfaces the Reddcoin team maintains are secure. The only open question for any individual holder is whether the app that created their seed phrase used strong randomness. When unsure, migrate to a fresh wallet from a trusted source. A few minutes of caution protects everything.

Stay safe, and never share your recovery phrase.

The Reddcoin Community

Sources & further reading

• Ill Bloom official disclosure & checker (illbloom.org)
• Coinspect Warns Thousands of Wallets Vulnerable to Ill Bloom (Cointelegraph)
• Attackers Exploit 'Ill Bloom' to Drain $3.1M (The Hacker News)
• Crypto Wallets Lose $5M to Broken RNG: Ill Bloom Disclosure (TechTimes)
• Related prior incidents in the same weak-randomness class: Milk Sad (CVE-2023-39910), and the Trust Wallet browser-extension weak-randomness issue.

Reminder: No safety check should ever ask for your recovery phrase, and even address-only tools can be impersonated. Assess your risk by the wallet app you used, and migrate when in doubt.

This advisory will be updated as more verified details emerge.