Tor DDoS Attack 2026: How Attackers Outpaced Five Emergency Releases in 51 Days

The CyberSec Guru

If you like this post, then please share it:

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Why your support matters: Zero paywalls: Keep the main content 100% free for learners worldwide.

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

When David Goulet posted the release announcement for Tor 0.4.9.17 to the project’s forum on November 13, 2026, he closed it with a line of tired gallows humor: “Thank you to all… except our attacker(s).” It was the fifth security or emergency release the Tor Project had shipped in 51 days, counting from 0.4.9.13 on September 23. The gaps ran 14 days to 0.4.9.14, 21 to 0.4.9.15, 7 to 0.4.9.16 and 9 to 0.4.9.17. Behind that schedule sat a distributed denial-of-service (DDoS) campaign that the project itself said had “affected most relay operators.” A small, unpaid group of sysadmins watched their processor cores lock at full utilization while the directory authorities quietly stripped their servers of the flags that made them useful to the network.

The campaign is large, but its shape is what makes it worth studying. The adversary goes after the Tor protocol’s own state machinery: the cryptographic handshakes that build circuits, the directory streams multiplexed inside them, and the consensus rules that decide which relays may do which jobs. Each defensive release closed one avenue, and within hours or even minutes the traffic moved to another. The result is a live case study of a privacy network, engineered never to log its users, defending itself against an opponent who can read its source code as easily as its operators can.

TL;DR

  • Tor shipped five security or emergency releases between September 23 and November 13, 2026, as a DDoS campaign hit relays, HSDirs and directory authorities.
  • The flood overwhelmed the ntor-v3 handshake queue: operators logged completion rates of 6.75 percent and just under 9 percent.
  • Tor 0.4.9.17 fixed TROVE-2026-031, a 2018-era gap where every IPv6 /128 address counted as a separate client, so one /64 prefix could dodge rate limits.
  • About ten minutes after relays upgraded, operators saw the attack change vectors, and the new patterns bypassed the client-side defenses.
  • The campaign raises a real anonymity risk for onion services, because HSDir availability shapes where service descriptors end up.

The diagram below illustrates how Tor’s relay architecture, directory infrastructure and circuit-building mechanisms became the primary targets of the 2026 DDoS campaign

Tor Network Architecture
Tor Network Architecture

Why a Tor circuit is expensive for a relay

To see why relays buckle, look below the abstraction of “onion routing” at what a relay does with incoming bytes. A Tor relay is a user-space cryptographic state machine. Each circuit that passes through it needs an asymmetric handshake to establish session keys, a persistent structure in the daemon’s heap that tracks the circuit’s identifiers and crypto state, and continuous symmetric encryption and decryption of 514-byte cells on modern link protocols. A client building a three-hop path sends a CREATE2 cell to its entry guard, then tells the guard to forward EXTEND2 cells downstream. Each of those becomes a fresh CREATE2 at the next relay. Current deployments use the ntor-v3 handshake, specified in Tor Proposal 332.

The relay’s side of ntor-v3 costs real work. It computes two Curve25519 scalar multiplications, one against the client’s ephemeral public key and one against its own freshly generated ephemeral key. It then derives verification and key material through a tweakable hash and MAC built on SHA3-256, a SHAKE-256 key-derivation function, and an AES-256-CTR encapsulation for the authenticated extra data that carries congestion-control parameters and subprotocol negotiation. The protocol identifier is the string ntor3-curve25519-sha3_256-1.

Nick Mathewson noted in the proposal that in his preliminary measurements the SHA3 and AES operations did not account for even one percent of the handshake’s cost. Most of the expense sits in the elliptic-curve arithmetic and, more importantly for a flood, in the per-circuit bookkeeping around it. The main event loop parses the cell, allocates the circuit structure, and hands the handshake to a pool of cpuworker threads. When requests arrive faster than those threads can finish, the internal onion queue fills and the relay starts emitting the campaign’s signature warning: “Your computer is too slow to handle this many circuit creation requests!”

Tor relay overload in numbers: what operators measured

Telemetry that operators posted to the tor-relays mailing list and the project’s forum through early November shows how completely that queue can be overwhelmed. On a middle relay in Japan run by an operator posting as MyFeetHurt, a six-hour heartbeat window recorded 149,040,827 requested ntor-v3 handshakes against 10,067,277 actually assigned, a completion rate of 6.75 percent. A second operator, fraggles, runs a combined exit, guard, and hidden-service directory relay and logged 102,699,330 requested against 9,210,507 assigned in a comparable window, just under nine percent. At the worst of it, Red_Oaive reported the “too slow” warning being written to disk 400,000 times a minute or more.

How to read Tor’s onion-skin metrics correctly

The operators had to untangle a subtlety in those numbers, and it matters for anyone checking their own relay’s health. In the 0.4.9 series, ntor and ntor-v3 share a single onion queue, and a drop is counted against the queue instead of the handshake type. The code in onion_queue.c maps NTOR_V3 onto the NTor queue, so the MetricsPort counter tor_relay_load_onionskins_total{type="ntor_v3",action="dropped"} can never rise above zero. Every dropped v3 handshake is reported under the legacy “ntor” label. MyFeetHurt traced this through the source and corrected an earlier reading in the thread: the flood was ntor-v3, and during overload roughly 90 percent of it went unanswered.

Two more accounting quirks add to the confusion. CREATE cells arriving on client channels are left out of the requested, assigned, and dropped onion-skin metrics entirely, because the relevant code paths check channel_is_client() and skip them. Requests culled from the queue for age, or whose circuit closes while still queued, are not counted as dropped either. The operators concluded that the reliable overload signal is the heartbeat’s “Circuit handshake stats” line, which compares requested against assigned. The Prometheus “dropped” metric sits at a reassuring zero and tells you little.

Why MaxMemInQueues misses Tor relay memory exhaustion

On some relays the pressure came less from cryptography than from structure, and it exposed a gap between Tor’s internal memory accounting and the Linux kernel’s. The operator nonamed42 described a non-exit relay on a Debian 13 KVM virtual private server with kernel 6.12, four virtual CPUs and eight gigabytes of RAM, with MaxMemInQueues tightened to one gigabyte. Under the flood, its open circuit count rose from a baseline near 7,000 to 962,000, and after a restart it climbed back to 349,000 within eight minutes. At the peak the relay sustained 2,000 to 2,800 ntor-v3 handshakes per second against a normal rate of about 30, and it held roughly 1.5 million concurrent circuits whenever the daemon approached a five-gigabyte ceiling. The daemon’s resident set size grew 30 to 100 megabytes a minute until it reached 4.8 gigabytes, while the main thread sat at about 95 percent of a core.

📬 Stay Ahead of Cyber Threats

Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.

MaxMemInQueues never fired. The specification explains why: the mechanism tracks relay cells queued on circuits, per-connection read and write buffers, on-the-fly compression state, half-open stream records, cached onion-service descriptors, cached DNS resolves, and GeoIP statistics. It does not count the base overhead of the circuit structures and their cryptographic state. A million nearly empty circuits carry little or no queued cell data, so they can consume gigabytes that the safety valve cannot see. nonamed42 ended up setting systemd’s MemoryMax=5G with MemorySwapMax=0, so the daemon is killed and restarted inside its own control group instead of dragging the host into swap. The relay went down for about 17 seconds roughly once an hour, twelve times in ten hours.

The kernel memory problem hiding in virtio_net

The kernel side was stranger. Tor’s saturated main thread could not drain its roughly 8,000 open TCP sockets fast enough, so small incoming segments piled up across thousands of receive queues. On the virtio_net paravirtualized driver, each small queued packet kept an entire 32-kilobyte high-order memory page alive in the kernel’s sk_buff structures. About 2.5 gigabytes of physical RAM vanished into packet buffers that no user-space process in top would ever show, along with 1.5 million TCPRcvQDrop events in an hour. Setting net.core.high_order_alloc_disable=1 through sysctl shrank that footprint from 2.5 gigabytes to 0.6 gigabytes within five minutes. A protocol-level flood cascaded into a kernel memory pathology that the application’s own defenses were never designed to notice.

How the consensus handed the attacker a firehose

The campaign also turned the network’s trust designations against it. The directory authorities were split four to four on whether MyFeetHurt’s relay deserved the Guard flag, the designation that lets a node accept direct connections from end-user clients. On November 13, one authority’s vote was missing from a run of consensuses, and the relay briefly held Guard for three hours. In that window, client-originated CREATE cells jumped from zero to about 950 per second, and open circuits rose from roughly 11,000 to 35,000, while the separate relay-to-relay flood held steady at about 215 per second. When the flag disappeared, client traffic fell back to zero within about two hours. The attacker never had to find the relay, because the consensus pointed clients straight at it.

BEGIN_DIR floods and HSDir attacks: seven weeks of escalation

The November circuit flood was not the opening move. Pressure on hidden-service directories had been building since summer. The 0.4.9.13 changelog in September already carried a mitigation that rate-limited “Service descriptor has an invalid signature length” messages at HSDir relays, tied to ticket 41339, and operators had been running custom metrics patches from that ticket series since August. The distinct autumn phase began in late October with what Goulet called a “BEGIN_DIR thunderstorm.”

BEGIN_DIR is a relay cell that opens a directory stream inside an already-established circuit. A client or relay can use it to fetch consensus documents, server descriptors, or onion-service descriptors straight from a relay’s memory cache without a separate HTTP connection. Multiplexing many such requests down one circuit is efficient and legitimate, and it also works as an amplifier. MyFeetHurt’s logs record a BEGIN_DIR flood on October 21 at about 1,300 requests per second, which drove roughly 490 megabits per second outbound against 30 inbound. A second wave on October 27 reached about 2,100 per second, pegged the main thread, failed reachability tests, and knocked the relay out of the consensus entirely. The asymmetry is the point: a small inbound request forces the relay to parse, compress, and ship a much larger directory response, and HSDir relays holding onion-service descriptors were the preferred targets.

Why restarting an HSDir cost four days of directory duty

The punishment outlasted the traffic. A relay earns the HSDir flag only after meeting MinUptimeHidServDirectoryV2, which defaults to 96 hours of uptime. Before the fix, restarting to clear a wedged state reset that clock, so a two-hour burst could cost a node four days of directory duty.

What Tor 0.4.9.15 changed

Tor 0.4.9.15, released October 28, attacked the problem on two fronts. First, it made the HSDir flag sticky: once a relay has earned it and stays in the consensus, a restart no longer costs it the flag, though dropping out of the consensus entirely still re-applies the uptime requirement. Second, it introduced three BEGIN_DIR defenses:

  • A per-circuit rate limit, enabled by default, allows ten BEGIN_DIR cells per second with a burst of 60. At the default defense type of three, it closes the offending circuit outright.
  • A stricter limit of one BEGIN_DIR per circuit for traffic from authenticated relays was added but left off by default. It is gated solely by the consensus parameter DoSBeginDirLimitEnabled until enough of the network upgrades.
  • An always-on rule lets an HSDir accept at most one onion-service descriptor fetch or upload per circuit, and it closes the circuit on any second attempt.

The release also changed relays to use a separate circuit for each directory request, so the per-circuit limits would have something to act on.

A comment in dos.h preserves the design intent behind the burst value. It is “kept tight on purpose: circuit creation is already rate limited, so an attacker should have to open new circuits rather than pushing more BEGIN_DIR down one.” In hindsight that sentence reads like a prediction. The defenses worked on their own terms. On November 1, MyFeetHurt’s relay weathered a BEGIN_DIR flood of about 4,400 requests per second while the one-request-per-circuit HSDir defense fired 103 million times, and the node kept its Running and HSDir flags. The attacker then took the hint in that comment and moved down the stack. Instead of thousands of directory streams inside a handful of circuits, it began building hundreds of thousands of fresh circuits from scratch, which is exactly the ntor-v3 flood the heartbeat logs later captured.

The TAP key breakage and the emergency 0.4.9.16 release

The escalation also had a self-inflicted wound. Tor 0.4.9.15 made new protocol capabilities required, including DESC_NO_TAP and MICRODESC_NO_TAP, as part of a planned effort to strip legacy TAP keys from descriptors and save directory bandwidth. The changelog stated plainly that Tor 0.4.8 and earlier would no longer work on the network. The planned part went fine. The breakage did not: old clients handled the unparseable microdescriptors badly, and the new required protocol versions made clients at or below 0.4.8.x exit outright, which produced a thundering herd of retries against the directory authorities.

The emergency authority-only release 0.4.9.16, on November 4, reverted the required Desc and Microdesc protocol versions from three back to two. It replaced omitted TAP keys with a dummy key through a new consensus method 38, and it doubled the allowed size of authority fetches, because nine votes could exceed 16 megabytes even compressed.

Why the sticky HSDir flag was not enough

The sticky flag proved less durable than hoped against a patient opponent. Roger Dingledine, posting to the forum as forest, observed that the attacker simply kept up the assault until a relay lost its Running flag and fell out of the consensus. At that point the attack stopped immediately and the 96-hour clock restarted. Another operator, Logforme, described a three-and-a-half-hour attack in which received traffic fell from 36 to about 10 megabits per second while transmitted traffic rose from 36 to 72, and the main thread sat pegged. The moment the authorities pulled the HSDir flag, the attacker moved on. “DirAuths being so trigger happy about pulling the HSDir flag really makes it easy for the attacker,” he wrote. Stickiness closed the restart loophole and left the consensus-ejection loophole open.

TROVE-2026-031: the IPv6 /64 flaw fixed in Tor 0.4.9.17

The vulnerability that 0.4.9.17 closed, cataloged as TROVE-2026-031, had sat in Tor’s source tree since the circuit-creation DoS subsystem arrived in 0.3.3.2-alpha in 2018. That subsystem keeps per-client state, and when a client exceeds a token-bucket rate of circuit creation, it marks the address and refuses further CREATE cells for a penalty period. The defaults, confirmed in dos.h, are a rate of three circuits per second, a burst of 90, a minimum of three concurrent connections before an address can be flagged, and a defense period of 60 minutes plus a random offset of up to half that period. The defense itself refuses the cell and sends a DESTROY back. A parallel connection-rate defense tracks concurrent connections and connect attempts per address.

Two properties of that design decided the campaign’s shape.

Why relay-to-relay traffic bypassed the circuit DoS defense

The circuit-creation defense applies only to client channels. Both dos_cc_new_create_cell() and the fast-path check cc_channel_addr_is_marked() begin by testing channel_is_client() and ignoring anything else. Traffic arriving over authenticated relay-to-relay connections is exempt, because blocking it would sever the relay from the mesh it exists to serve. nonamed42 measured that 93 percent of inbound connections on his relay came from relay IPs already in the consensus. MyFeetHurt’s per-source counters put more than 99 percent of CREATE cells in the same category. Host-level iptables or nftables connection-rate rules were therefore useless against the bulk of the flood, and the built-in per-client defenses never saw it. The only DoS counter that moved on MyFeetHurt’s relay during the circuit flood was circuit_rejected, which covers client connections alone.

How one IPv6 /64 became 18 quintillion client addresses

The second property was the granularity of address tracking, and IPv6 broke the model there. The per-client DoS state lives in a structure called dos_client_stats_t, embedded in the relay’s GeoIP client map entries and keyed by a tor_addr_t. The code treated every 128-bit IPv6 address as an independent client, exactly as it treated every IPv4 /32. In the scarcity-bound world of IPv4 that is reasonable. In IPv6 it is a disaster, because a single customer interface or virtual machine routinely receives an entire /64 prefix, and a /64 holds 2^64 (18,446,744,073,709,551,616) interface identifiers.

An attacker who binds a /64 route to the loopback interface using Linux’s AnyIP feature, then cycles the low 64 bits of the source address on each outgoing connection, can present billions of distinct source IPs to a relay. The client map dutifully allocated a fresh tracking structure for every /128. No single bucket ever accumulated enough circuits to trip the burst threshold, and the relay’s own tracking table bloated in RAM while the flood poured through.

The fix: tracking IPv6 clients by /64

The fix in 0.4.9.17 is small and precise. In geoip_stats.c, a new constant CLIENTMAP_IPV6_PREFIX_BYTES is set to eight, and a helper called clientmap_get_key_addr() copies the address and zeroes the lower eight bytes before the client-map lookup or insertion. IPv4 clients are still tracked by their /32, and IPv6 clients are now tracked by their /64. Every address inside a given /64 resolves to the same client-map entry, shares the same circuit token bucket and the same marked_until_ts, and trips the same defense. Whether an attacker sends ten thousand requests from one address or one request each from ten thousand addresses in the prefix, the relay increments a single bucket and applies the penalty to the whole block. The same normalization corrected the unique-client counts that relays and bridges report in their extra-info documents, which had been counting every IPv6 address as a separate client.

Other security fixes in Tor 0.4.9.17

The release bundled further security work:

  • TROVE-2026-075 makes relays reject any RESOLVED cell carrying a hostname record that is not a valid DNS name. The changelog traces the bug back to 0.1.1.1-alpha.
  • A stream-isolation fix stops truncating the recorded length of HTTPTunnelPort isolation header values to eight bits. The truncation had let two different X-Tor-Stream-Isolation values longer than 251 bytes, whose lengths agreed modulo 256, share a circuit.
  • An ntor-v3 fix now enforces the intended rejection of subproto_request extensions whose entries are not sorted and deduplicated.
  • In an urgent administrative change, the project removed the signing keys of the bastet directory authority because of a potential compromise, noting it could be reinstated with new keys later. It also updated the IP address of the maatuska authority.

Goulet’s announcement called this a holding action. The project was “actively evaluating additional defenses” and expected further releases.

Ten minutes after the patch: how the Tor DDoS attack changed vectors

Anyone hoping the /64 fix would buy a quiet weekend found out otherwise almost immediately. On the morning of November 14, the operator Red_Oaive posted a forensic breakdown to the tor-relays list. He had lost two HSDir nodes before the patch and upgraded a third in the middle of an active assault. He sorted the post-BEGIN_DIR campaign into three signatures:

  • Type A: disproportionate ingress, with very high traffic at roughly a six-to-one inbound-to-outbound ratio.
  • Type B: the inverse, at about one-to-two inbound-to-outbound, with extreme volumes of circuit creation, the “too slow” warning at 400,000 entries a minute or more, and a tendency to poison ipset-style firewall tracking tables.
  • Type C: something new. Traffic collapsed to one or two megabytes per second inbound and under one megabyte outbound. CPU usage averaged medium to low with pegged spikes, “relay unresponsive” messages cascaded through the log, and slowdowns bled into the host operating system itself, visible as lag in SSH management sessions. No connection-attempt firewall rule fired.

The transition was the telling part. Red_Oaive’s third relay was under a Type B attack when he upgraded to 0.4.9.17 and applied a bandwidth limit of 12 megabytes per second. Before the upgrade, traffic had run at 18 megabytes per second in and about 40 out. Afterward it turned erratic, at 8 in and 4 to 20 out, as the new rate limiters began discarding the IPv6 flood. About ten minutes after the patched daemon came online, the Type B signature stopped completely and Type C took its place. He re-enabled his custom ipset rules and not one of them fired, which told him the attacker had stopped opening rapid-fire direct TCP connections to the ORPort. When the prolonged unresponsiveness finally cost the relay its HSDir flag, the attack against that machine ceased instantly. Another operator, Marco_Moock, reported a matching pattern on his own hardware: four cores at full utilization, traffic falling from one megabyte per second to 30 kilobytes, then CPU dropping to nearly nothing. Red_Oaive folded that report into Type C.

From CREATE flood to exit-connection flood

fraggles’s per-minute MetricsPort scrapes after his own upgrade showed a separate, equally concrete pivot. The CREATE-cell flood gave way to an exit-connection flood. His BEGIN counter and his exit-initiated counter became identical, meaning every BEGIN stream was an exit connection, opened at a steady 63 to 69 per second. Cumulative circuits created reached 21.77 million against 21.76 million closed, with 58.92 million destroy cells. That churn keeps the relay’s event loop busy building and tearing down circuits instead of holding sustained load. The outbuf flow-control counter xoff_outbuf sat at 268,000, which indicates a permanently blocked output buffer, while circuit_rejected froze at 5,857 and marked_address at two, unchanged for more than 21 hours. The client-side defenses were not reacting to the new vector at all. “The vector changed,” he wrote. “0.4.9.17 fixed the IPv6 /64 tracking issue, but it does not mitigate this vector.”

An adaptive adversary, or a deanonymization attempt?

Read together, these reports describe an adversary running a closed loop: observe the rejection rates, detect the defense, switch to a pre-staged alternative. Red_Oaive concluded that the attacks were “AGILE, switching mid-attack to different vectors,” that the current mitigations were insufficient to protect HSDir relays, and that given the sophistication on display, operators should assume more protocol weaknesses are waiting to be used. He went further and argued that the campaign could be a deanonymization and tracking operation against hidden-service operators and users instead of a pure denial of service. He also argued the attacks on friendly HSDir nodes should be considered alongside the attacker’s own compromised directories.

That last claim is his assessment and not a finding. fraggles, reviewing the same client-side evidence, noted that the data cannot show whether the chaos was a deliberate guard-discovery setup or collateral damage from a flood that happened to destabilize guards. The capability is visible. The intent is not.

Why DDoS on Tor directories threatens onion service anonymity

A denial-of-service campaign against directories matters beyond inconvenience because of how onion services find their own infrastructure. Under the v3 rendezvous specification, the network’s HSDir relays form a consistent hash ring. A service derives blinded public keys for each time period, which the parameter hsdir_interval sets to 1,440 minutes, and it deterministically picks directories on that ring to hold its encrypted descriptor. The consensus parameters fix the geometry: two replicas per descriptor, four consecutive directories per replica for storage, and three queried per replica for retrieval.

The descriptor carries two layers of encryption. The outer, “superencrypted” layer is keyed from the blinded public key and a subcredential derived from the service’s public identity key, so a directory that does not already know the .onion address cannot read the introduction points inside. The plaintext is padded to a multiple of ten kilobytes to avoid leaking its contents. An inner layer adds protection when restricted discovery is enabled.

How stripping HSDir flags could shift the hash ring

An HSDir is trusted with availability but not with a service’s secrets, and the ring’s membership is only as stable as the consensus. Red_Oaive and nonamed42 both raised the same concern. If an attacker already runs Sybil relays that hold the HSDir flag, then selectively DDoS-stripping honest relays of that flag shrinks the honest population and shifts the ring’s responsibility boundaries. That raises the odds that a targeted service publishes its descriptors onto attacker-controlled directories. nonamed42 put it plainly on November 8: after a restart his relay lost the HSDir flag, “and if attacker do this to many relays, users will have much higher chance to use working, attacker relays.” Controlling a service’s responsible directories enables selective censorship. It also lets an adversary correlate the timing of descriptor lookups from clients querying known addresses, without decrypting anything.

HSDirSniper: academic precedent for attacking HSDirs

Researchers have already treated HSDirs as a soft target, though by a different mechanism. The HSDirSniper attack, presented by Qingfeng Zhang and colleagues at The Web Conference 2024, floods a directory’s descriptor cache with a large volume of descriptors until the directory purges everything it stores to reclaim memory, which blocks arbitrary hidden services. The authors showed that an attacker with a modest number of hidden servers could make a target inaccessible up to 90 percent of the time, covertly, with no colluding routing node inside the network. It is a cache-eviction eclipse and the current campaign does not copy it. Still, it showed that the directory layer can be disrupted cheaply and quietly, and that is the surface this campaign is pressing.

Vanguards, path bias and self-inflicted lockdowns

The circuit flood also collides with the defenses onion services use against guard discovery. Vanguards come in a lightweight form built into current Tor daemons under Proposal 333 and a fuller add-on originally written by Mike Perry. Both restrict the second and third hops of service circuits to small, slowly rotating pinned pools instead of fresh random relays on every build. The C code pins the second hop for hidden-service circuits whenever vanguards-lite is enabled, and the third hop when HSLayer3Nodes is configured. A comment in circuitbuild.c notes that the most aggressive vanguard design used 16 nodes at layer three. The goal is to stop an adversary who controls a few middle relays from forcing enough circuit rebuilds to land a malicious node next to a service’s long-term entry guard and learn its IP address.

The operator uolficina, who runs hidden services hardened with full layer-two and layer-three pinning, posted the service-side mirror of the relay-side degradation. His logs filled with warnings about a dropped cell on a circuit in state PATH_BIAS_TESTING, old state HS_SERVICE_HSDIR HSSI_CONNECTING, which is what you would expect when descriptor lookups hit relays that are dropping cells under load. The vanguards add-on’s bandwidth and path-bias guards read the instability as a possible attack, force-closed the circuits, and put the daemon into a lockdown that fails all circuits until it finds a clean path. His logs recorded “Tor has been failing all circuits for 31 seconds!” and later 116 seconds, and circuit use resumed only afterward. Those messages come from the add-on’s bandguards component and not from Tor’s core. They show the defense working as designed.

That is the paradox: a defense working as designed is itself a denial of service. A service whose pinned guards or vanguard nodes get knocked out of the consensus must abandon them and pick replacements from the survivors, which is exactly what an adversary with healthy Sybil relays of its own would like to see. A service whose defenses trigger repeated lockdowns drops off the network for minutes at a time even when its own server is not under direct fire. uolficina read the network-wide churn as a dangerous window for unprotected services. fraggles cautioned that the data shows the window exists without proving anyone is exploiting it on purpose. Both can be true, and for an operator running a service the practical implication is the same: the chaos is the risk, whatever the intent.

The Tor DDoS defense dilemma: attack logging versus user privacy

Beneath the technical cat-and-mouse sits an architectural tension that the campaign has made unavoidable. Tor was engineered from the ground up not to log who connects to it. SafeLogging scrubs sensitive connection metadata so that a relay seized by a hostile authority cannot hand over a list of users in a repressive regime. The GeoIP client map that doubles as the DoS tracking table is itself privacy-preserving: it rounds per-country counts to multiples of eight and suppresses reporting entirely below a minimum threshold. The MetricsPort counters behind the new defenses, tor_relay_dos_total with its begindir_rate_rejected and begindir_hsdir_rejected labels, tell an operator how many millions of times a defense fired over a six-hour window. They deliberately do not say which source addresses or relay fingerprints triggered it.

When the overwhelming majority of a flood arrives multiplexed over connections from relays already listed in the consensus, that blindness has a cost. A defending operator cannot see which peer relays are funneling the attack, and the community cannot easily cross-reference which suspiciously untouched HSDir nodes survive while honest ones drop out. Red_Oaive’s frustration boiled over into a demand that mitigation code log the IP addresses and fingerprints of nodes that trigger it, in capital letters: “THE LACK OF ATTACK LOGGING IS IRRESPONSIBLE!”

The argument has force, and so does the counterargument. Aggressive automated logging and hair-trigger peer banlists can be weaponized. An attacker who bounces malicious traffic through honest, high-capacity guard relays could trick the network into blacklisting its own largest volunteer servers, which turns the defense into the attack. There is no clean answer, only a trade-off between the forensic visibility needed to fight a coordinated adversary and the privacy guarantees that justify the network’s existence.

What Tor relay operators should do now

The project’s practical guidance is short:

  • Upgrade to Tor 0.4.9.17. No further action is required afterward.
  • If you added DirCache 0 to your torrc to escape the flood, remove it. That setting opts your relay out of serving as a fallback directory, guard, HSDir, and directory cache, and the network needs those nodes.
  • Leave the DoS parameters to the consensus and avoid tuning them locally.
  • Watch the onion-skin requested-versus-assigned numbers and the open-circuit count, and ignore the misleading “dropped” metric.
  • Consider the kernel and control-group workarounds operators like nonamed42 found through trial and error, high_order_alloc_disable and a bounded MemoryMax, as stopgaps for a daemon whose internal memory accounting does not yet see its own circuit structures.

Why relays gain and lose the Guard flag during an attack

Some flag churn looks like attack damage and is a measurement artifact. MyFeetHurt checked the raw sbws bandwidth files against the scanner code and found that a relay’s Measured value is its stream-capacity ratio multiplied by desc_bw_obs_last, the relay’s own reported peak throughput over the last five days. Flood traffic inflates that observed bandwidth, so the relay looks three to four times larger to the bandwidth authorities for about five days after each storm, and then the value falls back. His Guard flag came and went with that inflation, and no scanner cut him. In a network this interdependent, the side effects of an attack travel through measurement systems that were never designed to tell a flood from genuine capacity.

What comes next for Tor’s DDoS defenses

The project has committed to further defensive releases, and operators’ per-minute telemetry is the evidence needed to validate them. The obvious directions are finer-grained stream and circuit rate limiting, socket handling that stops a saturated main thread from stranding gigabytes in kernel buffers, and memory accounting that counts the circuits themselves. The longer horizon is Arti, the Tor Project’s Rust reimplementation, whose memory-safety and architectural choices may eventually retire whole classes of these bugs, though it will not help this winter.

Tor 0.4.9.17 closed an 18-quintillion-address multiplier that had lain dormant since 2018, and the adversary noticed within ten minutes. Meanwhile, volunteers keep compiling emergency tarballs at two in the morning and tuning sysctl flags to keep the packets moving.

Frequently asked questions about the Tor relay DDoS campaign

What is TROVE-2026-031?

TROVE-2026-031 is the vulnerability fixed in Tor 0.4.9.17. The circuit-creation DoS defense treated every 128-bit IPv6 address as a separate client, so an attacker cycling addresses inside one /64 prefix never tripped the per-client rate limit. Since 0.4.9.17, relays track IPv6 clients by their /64.

Which Tor version should relay operators run?

Tor 0.4.9.17, released on November 13, 2026. The project said no further action is required after upgrading, and that it expects more defensive releases.

Why did the Tor DDoS attack continue after the patch?

Operators reported that traffic changed vectors about ten minutes after patched relays came online. One saw the circuit flood give way to a low-bandwidth, high-CPU pattern, and another saw it turn into a steady exit-connection flood that the client-side defenses did not react to.

Does the attack expose Tor users’ identities?

No operator reported that. Red_Oaive suggested the campaign could be a deanonymization effort, but that is his assessment, and fraggles noted the data cannot separate deliberate guard discovery from collateral damage. What is clear is that churn among HSDirs and vanguard nodes creates risk for onion services.

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Your contribution powers free tutorials, hands-on labs, and security resources.

Why your support matters:
  • Writeup Access: Get complete writeup access within 12 hours
  • Zero paywalls: Keep the main content 100% free for learners worldwide

Perks for one-time supporters:
☕️ $5: Shoutout in Buy Me a Coffee
🛡️ $8: Fast-track Access to Live Webinars
💻 $10: Vote on future tutorial topics + exclusive AMA access

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

If you like this post, then please share it:

News

Discover more from The CyberSec Guru

Subscribe to get the latest posts sent to your email!

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.