Bitcoin Core 32.1 arrived on October 27, seven days ago, and the most important fix in the entire package has nothing to do with speed or fees. It closes a route through which a node could broadcast a transaction over Tor and, in a very specific scenario, end up handing its real IP address to the peer receiving it. That scenario required four conditions at once, and none of them was the default configuration, which limits the scope of the flaw without eliminating it.
The affected feature is called private broadcast and arrived with version 31.0, released in April this year. Its promise is simple: when a program sends a transaction to the node, the node does not announce it over the connections it keeps open with its peers, but instead opens separate connections through Tor or I2P. That way the recipient does not see the sender's IP, and two unrelated transactions are not linked by sharing the same channel.
The detail that was being missed is that this separation depends on the connection actually going out through the anonymous proxy. In 32.1 the project fixes the retry that could bypass it, and along the way it caps a queue that until now grew without restraint: 10,000 pending transactions and 1,000 send attempts per transaction. For anyone running a node, the practical reading is that updating stops being a matter of performance and becomes a matter of who can deduce where the money was sent from.
What was leaking and under what conditions
Private broadcast is the option, disabled by default, that makes the `sendrawtransaction` command not announce the transaction over normal connections, but instead open a separate channel over Tor or I2P for each send.
Relaying is something else, and every node does it: notifying peers of transactions it has just seen and sending them the ones they request, so that the announcement reaches miners without intermediaries.
This is where the flaw appears. Before sending via private broadcast, the node replaces the normal proxy selection and forces the outbound connection through Tor. The problem is that Bitcoin Core first tries the v2 peer protocol and, if negotiation fails, retries with v1; that retry was made without the temporary proxy order, so it could go out over IPv4 or IPv6 in plain sight. The conditions that had to occur at the same time are these:
- A peer had announced to the node an IPv4 or IPv6 address with support for the v2 protocol.
- The node had Tor configured for private broadcast.
- Its configuration allowed direct connections to IPv4 or IPv6, that is, with no value in `-proxy=`.
- The peer did not actually support v2 and its announcement flags were false.
All four have to coincide, and the last one requires a peer that lies, so the flaw did not affect every operator with Tor. The damage, even so, was not small: the source IP is the piece of data that makes it possible to tie an anonymous signature to a home connection or to a server hired in someone's name.
The fix, recorded in PR 35410, preserves the proxy order when the retry goes from v2 to v1. The 31.2, published the same 27 October, does not include that patch: anyone with private broadcast enabled must move to 32.1. The patch does not touch ordinary relay: it affects that path.
The caps that come with the fix
The same package puts two limits on private broadcast that have nothing to do with the leak, but with resource consumption. The queue of pending transactions awaiting echo is capped at 10,000 entries and, when it fills up, the node rejects new ones; users can check the status with `getprivatebroadcastinfo` and free up space with `abortprivatebroadcast`. Each transaction also has a ceiling of 1,000 send attempts.
The feature shipped without a label in 31.0 and 31.2 marked it as experimental in PR 36309. Treating it as such is the sensible thing, because it does not move funds or touch consensus rules, but it introduces its own queue with states that nobody monitors by default.
A transaction stuck there is not waiting for confirmation, it is waiting to get out. That nuance changes how to diagnose a send that does not appear, since for a block explorer the transaction does not exist and for your node it is in a limbo that can only be seen by asking about it.
A relay with a shared backpack
The package's other change touches normal relay, the one for all transactions and not just private ones. Bitcoin Core previously limited sends peer by peer; now it uses a global backpack for all outbound traffic. The default limit remains 14 transactions per second, multiplied by 2.5 for outbound peers, and a cap of 12 MB every ten minutes is added. The idea is to use less memory and less CPU when the network gets congested.
Peers also change in number. The maximum automatic connections goes from 125 to 200, and peers that relay transactions can occupy at most half of the inbound slots, a percentage adjusted with `-inboundrelaypercent` between 0 and 100. Anyone who has set `-maxconnections` manually keeps their value.
There is also a change for Tor. The hidden services that Bitcoin Core creates enable proof-of-work defenses when the Tor daemon supports them, a barrier against anyone flooding an onion service. It is not mining and does not compete for blocks.
What to check on your own node
For anyone running a node, 32.1 is routine with checks that are not. The first is the download: the project insists on the signed and reproducible binaries from its directory. The chain of trust of an installer breaks more often than it seems, as happened with the compromised eMudhra TLS certificates, and here the software that signs transactions is at stake.
The second is automation. `getmempoolinfo` stops returning the `fullrbf` field unless requested with `-deprecatedrpc=fullrbf`, and `bip125-replaceable` disappears from mempool responses if compatibility is not enabled. The four commands that create partially signed transactions now generate version 2 PSBTs by default, so a script that compares bytes will notice the difference.
The third is about the calendar. The Bitcoin Core lifecycle stopped covering versions 29.x and earlier on the same 27 October. If yours is Ethereum, the disk, memory and synchronization requirements it demands are different.
| Adjustment |
Default value at 32.1 |
What it implies |
| Private broadcast queue |
10,000 transactions |
When full, it rejects new submissions |
| Attempts per private transaction |
1.000 |
Afterwards it must be relaunched with `sendrawtransaction` |
| Automatic connections |
200, previously 125 |
More inbound room |
| Peers that relay on inbound connections |
50% |
Adjusted with `-inboundrelaypercent` |
| Transaction output |
14 tx/s and 12 MB every ten minutes |
Less CPU at peak times |
A day later, on October 28, the project made public three security warningsCVE-2026-117349 covers unbounded memory growth with old paused peers, while CVE-2026-117350 describes the same overflow with urgent TCP data on non-Linux systems. CVE-2026-117346 fixes an overflow in the undo files, is low severity and remains unfixed on 32-bit machines and on nodes with blocks on FAT32.
The first two are of medium severity, and all three arrived through the same channel: an automated scan using language models from the Loupe project, not a human audit. Version 32.1 includes the patch for all three, and a 32-bit team will remain exposed to one of them even if it updates.
The lesson is not that Bitcoin exposed its users, because it did not: the flaw lived in an optional feature that most nodes do not have enabled. The lesson is smaller and more uncomfortable, because a node is also an observation point, and the address it speaks from reveals things the chain does not.
That is why infrastructure privacy stops being a paranoid whim and looks more like the hygiene of updating. Anyone broadcasting transactions from their own node should check the proxy settings before assuming that anonymity comes from the tool by default, and anyone who does not use that feature can update without haste but without forgetting.