Ai Agents 7 min read

Bitcoin Core discloses CVE-2026-117348, a node-stalling bug found by Spiral's Loupe LLM scanner and labeled 'easily discoverable'

One peer could freeze a Bitcoin Core node for over a dozen seconds per message by repeating an orphan transaction's ID 50,000 times. An automated Claude-and-Codex scan found it in July; fixes for 30.x and 31.x shipped on November 20.

On November 20, 2026, the Bitcoin Core project published an advisory for CVE-2026-117348, titled “Node stall through duplicate orphan announcements.” A single peer could stop a node from processing blocks and transactions for over a dozen seconds per message, and could keep doing it. The fix shipped in Bitcoin Core 30.5 and 31.3 the same day, and earlier in 32.1 on October 27. The 29.x series is end of life and will not be patched.

The bug itself is a medium-severity denial of service. What makes it worth a close look is where it came from and how it was handled. The advisory says it “was discovered through an automated LLM scan,” run by Elias Rohrer’s Project Loupe at Spiral, Block’s open-source Bitcoin development group. And Bitcoin Core tagged it “easily discoverable,” a category its security policy now defines by reference to LLMs: bugs found “with minimal effort, such as through a simple LLM prompt.”

The bug: 50,000 copies of one transaction ID

Bitcoin nodes tell each other about new transactions with inv (inventory) messages, lists of transaction IDs a peer can fetch. Since version 29.0, when a peer announces a transaction that the node already holds in its orphanage (transactions whose parent transactions it has not seen yet), Bitcoin Core builds the list of that orphan’s parents and checks each one against its mempool and its recently-seen filters.

Two details combine into the stall. A single inv message can carry up to 50,000 entries, and duplicate entries were not skipped. So an attacker first relays an orphan transaction with thousands of missing parents, then sends inv messages that repeat that orphan’s wtxid 50,000 times. Every repeat triggers the full parent walk again. According to the advisory, each such message “stalls the node for over a dozen seconds, during which it processes no messages from other peers, including blocks.”

The fix is one line of policy: each transaction announced in an inv message is now processed only once. It landed in master through PR #35878 and was backported to 31.x in PR #36892 and to 30.x in PR #36893.

The advisory describes a temporary stall and says nothing about loss of funds or changes to the chain; this is a liveness bug, not a key or consensus bug. It still matters most to the nodes that care about latency: a node that cannot see new blocks for a dozen seconds at a time is a problem for a miner, an exchange or a Lightning node watching for channel closes. Affected versions are 29.0-29.5, 30.0-30.4 and 31.0-31.2. Operators should move to 30.5, 31.3 or 32.1; anyone still on 29.x has to change major version.

How Loupe found it

Loupe is open source (Apache-2.0 and MIT), and its README is explicit about the design. It calls itself “a security-scanning harness for source repositories”: a server with a scheduler and an encrypted SQLite store, stateless Linux workers that clone repositories and run scanners, and an operator CLI, all talking over mTLS.

The scanning itself is done by off-the-shelf coding agents driven through their command-line tools:

  • Discovery. The scanner launches one agent session per source file. The default scan agent is Claude, via the claude CLI, when it is authenticated. For Bitcoin, Lightning and Cashu code, an optional MCP server gives the agent lookup tools for BIPs, BOLTs and BLIPs.
  • Self-validation. An agent that reports a bug has to back it with a proof-of-concept regression test and check that it applies. Spiral’s project page puts it simply: “Every report comes with a demonstrable test case.”
  • A second model. An optional verifier re-examines each finding, and by default it prefers Codex so that “the second opinion comes from a different model family.” A single dismissal kills a finding.
  • Human gate and reporting. Findings can be held for a human to review the PoC diff before they are filed as a GitHub issue or emailed to maintainers.

Every agent call runs inside a bubblewrap sandbox with its own private network namespace, which is why LLM scanning is Linux-only. The README also warns that scanning a large repository can mean hundreds or thousands of LLM calls with real metered cost. Spiral describes Loupe as a free scanner for open-source Bitcoin projects: for now Spiral and Block run the scans and disclose to maintainers, with the stated plan of handing the tool to each project to run itself.

The human part is visible in the credits. Gregory Sanders, a Bitcoin Core contributor, validated the Loupe finding and brought it to the security team. The tool produced the candidate; a person who knows the codebase decided it was real.

A 135-day timeline, and an independent rediscovery

The advisory’s timeline is worth reading in full:

  • July 8: Project Loupe reports the issue.
  • August 4: Stutxo reports the same issue independently, and Sanders opens PR #35878 with a fix.
  • August 6: the fix is merged into master.
  • October 27: Bitcoin Core 32.1 ships with the fix.
  • November 17: backports to 31.x and 30.x.
  • November 20: 30.5 and 31.3 ship, and the issue is disclosed.

That is 135 days from the first report to public disclosure, and 106 days from the merged fix to the last patched releases. The independent report less than four weeks after Loupe’s is the strongest evidence that the “easily discoverable” label is accurate: once the attack surface exists, more than one person (or model) will find it.

This is the same pattern seen in other recent cases, where automated agents surface bugs in widely used open-source code faster than release processes absorb them. Amazon’s account of Cairn agents finding a MONAI Label zero-day in 11 minutes came from the attack side; Loupe is the defensive version of the same capability, aimed at one ecosystem and wired into coordinated disclosure.

Bitcoin Core’s “easily discoverable” fast path

Bitcoin Core’s security advisories page sets standard embargoes by severity. Low-severity bugs are disclosed two weeks after the major release containing the fix. Medium and high bugs normally wait until two weeks after the last affected release reaches end of life, roughly a year after the fix ships.

The policy now carves out an exception. For bugs classed as easily discoverable, the project will “publish a point release containing the fix for each maintained major version as soon as possible, along with a security advisory, without applying the standard severity-dependent embargo periods.” The reasoning is plain: if a simple LLM prompt can find a bug, a long embargo mostly protects attackers who already have it. The page itself carries no revision date; Bitcoin.com reports that the change was made in October.

CVE-2026-117348 shows both sides of that policy. Under the standard rules, a medium bug fixed in August could have stayed under embargo for about a year. Instead it was disclosed alongside the 30.x and 31.x point releases. But the backports themselves took until mid-November, so for roughly three and a half months after the merged fix, most production nodes ran code with a known, rediscovered, LLM-findable stall.

What to watch

  • Coverage beyond Bitcoin Core. Spiral pitches Loupe at the wider FOSS Bitcoin stack. If more advisories carry the “automated LLM scan” credit, that will show whether this was one find or a steady pipeline.
  • The backport bottleneck. The fast path removes the embargo, but the limit in this case was the time to get fixes into maintained branches. Expect pressure on projects to shorten that step when the finder could be anyone with a coding agent.
  • Noise versus signal. Loupe’s design (PoC tests, a cross-model verifier, an optional human gate) is a response to the flood of low-quality AI bug reports other projects have complained about. How many of its findings survive maintainer review is the number worth asking Spiral for.
  • Upgrade uptake. The fix is only as good as the share of nodes running 30.5, 31.3 or 32.1. Operators on the unsupported 29.x line remain exposed.
Get Insanely Good at AI

Get Insanely Good at AI

The book for developers who want to understand how AI actually works. LLMs, prompt engineering, RAG, AI agents, and production systems.

Keep Reading