AI audit uncovers flaw that could freeze Bitcoin nodes for over a dozen seconds
An artificial-intelligence security tool built at Jack Dorsey’s Block has surfaced a vulnerability in Bitcoin Core that allowed a single network message to stall a node for more than a dozen seconds. Bitcoin Core disclosed the flaw on November 21, 2026 under the identifier CVE-2026-117348, rating it medium severity and easily discoverable, and credited an automated scan run through Project Loupe, an effort led by Elias Rohrer at Spiral, Block’s open-source development unit.
The bug did not put anyone’s coins directly at risk. What it did was open a cheap and repeatable avenue for degrading the performance of the software that underpins the Bitcoin network. Fixes are already available in Bitcoin Core versions 30.5 and 31.3, and operators across the ecosystem are being encouraged to upgrade.
The episode is notable for two reasons. First, it shows how a modest input-validation weakness in widely deployed financial software can produce disproportionate operational consequences for exchanges, miners and other services that run their own nodes. Second, it marks another step in the quiet rise of AI-assisted auditing as a serious instrument for hardening open-source infrastructure that guards hundreds of billions of dollars in value.
For ongoing reporting on the software layer of the network, see our Bitcoin coverage.
How the attack worked
The vulnerability sits in the way Bitcoin nodes handle transaction announcements. When a node wants to tell its peers that it has seen a new transaction, it sends an announcement message listing transaction identifiers. The protocol permits batches of up to 50,000 entries in a single announcement, a design intended to keep overhead low on a network where tens of thousands of transactions circulate every hour.
The flaw was that the affected software did not ignore duplicate entries within a batch. An attacker could construct an announcement containing the same transaction identifier repeated 50,000 times, filling the message to capacity with a single redundant reference. The receiving node would then perform expensive validation work on that transaction again and again, once for every duplicate in the batch.
The most effective variant involved an “orphan” transaction, one whose parent transactions were unavailable to the node. Orphans are a normal feature of Bitcoin traffic: transactions arrive out of order all the time, and nodes are built to hold them pending their parents. But orphan handling is precisely where the cost of duplicated validation is highest, because the node keeps attempting to resolve a transaction it can never fully process.
The advisory is blunt about the consequence. Each such message stalls the node for over a dozen seconds. During that window the node does not process other network messages at all, including newly mined blocks. And because nothing stops an attacker from sending further announcements once the node resumes, the disruption can be extended almost indefinitely by repetition.
The maths is uncomfortable. A modestly resourced attacker with a handful of machines could keep a targeted node cycling between stalls, effectively knocking it out of consensus-keeping service for as long as they cared to continue.
What was actually at risk
Bitcoin Core’s own assessment frames the danger as operational rather than as a direct path to theft. No private keys were exposed, no funds could be moved, and no consensus rules could be subverted. The vulnerability did not let an attacker spend coins they did not own or rewrite the blockchain.
The damage was to reliability, and in financial infrastructure reliability is money.
Consider an exchange running a vulnerable node. Customer deposits are recognised only when the exchange’s own node sees and validates the relevant transactions. A node stalled repeatedly by crafted announcements would fall behind on seeing new deposits, leaving customers staring at balances that have not updated and support desks fielding complaints. For a trading venue where minutes of delay translate into user attrition and reputational cost, that is a real business risk even if no satoshi is ever stolen.
Miners face a sharper version of the same problem. A mining operation working from a node that is slow to receive newly mined blocks continues hashing on an outdated view of the blockchain. Every second spent extending a block that has already been superseded is electricity and hardware time converted into nothing. In an industry where margins are thin and hashrate is a perishable commodity, an adversary capable of delaying block propagation to a pool’s nodes holds a meaningful economic weapon, one that could in principle be deployed against competitors.
Other services are exposed in subtler ways. Payment processors, custodians, block explorers and merchants accepting on-chain Bitcoin all depend on nodes that stay current. The common thread is that the vulnerability weaponised the ordinary plumbing of the network against the people who depend on it most.
The patch, the policy and the role of AI
Bitcoin Core has shipped fixes in versions 30.5 and 31.3. The corrected software ensures that each transaction announced in a batch is processed only once, regardless of how many times its identifier appears. It is a small change in code and a significant change in behaviour: the pathological cost of a duplicate-laden announcement collapses, because the expensive validation path simply cannot be triggered repeatedly by the same identifier within a single message.
Operators running maintained versions should treat the upgrade as routine but not optional. The disclosure itself notes the flaw was easily discoverable, which cuts both ways. It means responsible discovery by Project Loupe happened before anyone evidently exploited it in the wild, and it also means the window between publication and opportunistic probing of unpatched nodes is short.
The disclosure also reflects a policy Bitcoin Core adopted on October 22, which calls for quickly patching easily discoverable flaws across maintained versions and publishing a public advisory. That approach represents a shift in posture. For years, Bitcoin’s development culture leaned toward long silence on fixed vulnerabilities to protect users who upgrade slowly. The newer policy accepts that once a flaw is simple enough to find, obscurity offers little protection, and prompt coordinated disclosure plus rapid patching is the safer course. This incident is among the clearer demonstrations of that logic: a medium-severity, easily discoverable bug was patched across supported versions and written up in the open.
The discovery method deserves as much attention as the bug. Project Loupe, run by Elias Rohrer at Spiral, Block’s open-source development arm, uses automated scanning to comb through critical codebases looking for exactly this class of defect: inputs that are trusted when they should not be. An AI-led audit finding a duplicate-handling weakness in Bitcoin Core suggests a meaningful expansion of who can contribute to Bitcoin’s security. Auditing the reference implementation of the world’s largest cryptocurrency has historically required deep, hard-won expertise. Automated tooling does not replace that expertise, but it can widen the funnel of potential findings and surface low-hanging fruit that human reviewers, fatigued by familiarity with the code, might pass over.
Analysis: small bugs, large systems, and a new audit frontier
There is a familiar shape to this vulnerability. It is not exotic cryptography or a break in consensus. It is an input-validation weakness of the kind that has haunted software engineering for decades: the system trusted the contents of a message to be well formed and reasonable, and an attacker was not obliged to be either.
What makes the case interesting is the multiplier effect of context. A dozen seconds of stall is trivial for a desktop application. On a network where block timing is the heartbeat, where exchanges settle and miners compete on millisecond timescales, and where the node software is run by thousands of independent operators, the same dozen seconds becomes a lever that prises open operational risk across the entire ecosystem. Bitcoin’s security model is famously robust at the level of keys and consensus. The attack surface at the level of implementation and network behaviour is far less glamorous and far more frequently where problems actually live.
The second lesson concerns the changing economics of finding bugs. If AI-assisted audits can routinely surface medium-severity flaws in a codebase as scrutinised as Bitcoin Core, then every maintainer of critical open-source financial software should assume two things: the cost of discovering weaknesses has fallen, and therefore the safe window between discovery and exploitation has shortened. Bitcoin Core’s October 22 policy, prioritising fast patching of easily discoverable flaws with public advisories, looks well matched to that reality. The old comfort that a bug is safe because nobody clever enough has looked yet is eroding.
The pragmatic takeaway for the industry is simple. Node operators should upgrade to 30.5 or 31.3 without delay, since the disclosure guarantees that the vulnerability is now public knowledge. Exchanges and mining pools, whose exposure is the most concrete, should treat node version hygiene as part of their operational risk framework rather than as a background maintenance task.
The broader signal is a positive one for Bitcoin. A flaw was found by an automated tool, fixed across maintained releases, and disclosed with an advisory in short order, before evidence of exploitation. That is the security process working as intended. But the fact that a 50,000-entry announcement loop could stall a node for a dozen seconds at a time is also a reminder that the network’s resilience depends on the unglamorous details of its software, and that those details now have a new class of tireless auditor watching them.