How Cloudflare WAF helps protect against phpAfterShell and other critical PHP flaws

Daniele Molteni, Kuber Nandwani, and Christian Larsen

9 minute

On November 19, 2026, the security research company depthfirst disclosed phpAfterShell (CVE-2026-126714), a vulnerability in PHP’s default file-based session handler that can lead to remote code execution. Under the Common Vulnerability Scoring System (CVSS) 4.0, it scores 9.2 out of 10 (Critical). The PHP project fixed it the same day in versions 8.2.36, 8.3.37, 8.4.28, 8.5.13, and 8.6.0. These releases fix 16 other security vulnerabilities, six of them also rated critical.

Cloudflare’s web application firewall (WAF) blocks known phpAfterShell attack patterns, including for customers on the Free plan. The protection comes from a PHP remote code execution rule we first deployed in October 2026 for the php2shell vulnerabilities. That rule already detected part of the phpAfterShell attack pattern before the vulnerability was disclosed, and on November 19 we updated its detection logic to cover phpAfterShell. The rule is part of both the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset, is enabled by default, and its default action is Block.

In the same WAF release, we added three new rules to the Cloudflare Managed Ruleset for paid plans: one for a request smuggling flaw in PHP-FPM (CVE-2026-129289), and two for flaws in PHP’s SOAP extension (CVE-2026-15353 and CVE-2026-129506) that PHP fixed in the same releases. These rules are enabled by default with the Log action, because the request patterns they look for can also appear in legitimate traffic, and blocking by default could disrupt it. Customers can review matching requests in Security Events now and change the action to Block once they confirm the rules do not affect legitimate traffic.

The WAF is an additional layer of defense, not a replacement for the patch. Several of the critical flaws depend on server configuration or can be reached through paths a WAF does not see, and the only complete fix is to upgrade PHP and restart every worker. Our analysts continue to monitor attack activity and will update the rules as new techniques and variations appear. You can track rule changes in the WAF changelog and follow how the vulnerabilities develop in the dedicated Cloudflare Zero Wire briefing.

There appears to be no indication so far that these vulnerabilities have been exploited. As of November 19, 2026, none of the 17 vulnerabilities was listed in CISA’s Known Exploited Vulnerabilities catalog, and no source we reviewed reports exploitation in the wild.

Copy linkWhat we know about phpAfterShell

PHP stores session data in files by default. When an application calls session_start(), PHP reads the session file and deserializes its content into the $_SESSION array. When the request ends, PHP writes the updated session back to the same file.

phpAfterShell is triggered when that write is interrupted. The session file can then hold the beginning of the new session data followed by the end of the old one. On the next request, session_start() deserializes this mixed content. If an attacker controlled the old data, PHP can end up deserializing objects of the attacker’s choice.

An attacker trying to exploit the flaw is likely to first search for a way to place controlled data in the session. PHP’s advisory names two:

  • Session upload progress, a PHP feature that writes information about a running file upload into the session. A remote client can use it to shape the stored data.
  • Applications that store large user-controlled strings in the session.

According to PHP, code execution also requires an interruption at a useful point in the write and a suitable deserialization gadget chain in the application. depthfirst reports that it reached code execution without an application gadget by chaining a second, undisclosed memory-corruption bug in a PHP-native class. The sources we reviewed do not establish whether that second bug is fixed in the November 19 releases.

depthfirst says it discovered and reported phpAfterShell. The CVE record credits Leo Lin and Asahi as reporters.

Copy linkThe other critical flaws

The same releases fix six more critical vulnerabilities. Each one needs a specific configuration to be exploitable:

CVEComponentImpactConditions
CVE-2026-129289PHP-FPMAn unauthenticated attacker can smuggle a second FastCGI request into PHP-FPM and run PHP code as the worker.A front end that reuses backend FastCGI connections (nginx with fastcgi_keep_conn on, Apache mod_proxy_fcgi with enablereuse=on, or HAProxy), an application path that opens php://input without reading it to the end, and the path of an existing PHP script.
CVE-2026-115560Session serializerObject injection through a mismatch between session serializers. First covered in our php2shell briefing, now fixed.Session upload progress enabled. PHP widened the scope: applications, pools or command-line jobs that use different serializers and share a session store are affected.
CVE-2026-129496Timezone cacheUse-after-free that can crash a fresh worker and possibly run code. PHP demonstrated code execution locally with known memory addresses.Non-thread-safe builds where a startup diagnostic has been written to a PHP error log file.
CVE-2026-129481Session shutdownUse-after-free, described by PHP as an incomplete fix for CVE-2026-109619. No code execution demonstrated.PHP 8.3 and later.
CVE-2026-129474Fatal error backtracesUse-after-free in magic method backtraces.PHP 8.5 and later, where fatal error backtraces are enabled by default. Setting zend.exception_ignore_args=1, the php.ini-production default, blocks the demonstrated attack.
CVE-2026-129182Fatal error backtracesUse-after-free. No code execution demonstrated.PHP 8.5, specific path-level settings, and an Apache per-directory configuration or front end that produces an early diagnostic.

Copy linkWho is affected

The vulnerable versions are PHP 8.2 before 8.2.36, 8.3 before 8.3.37, 8.4 before 8.4.28, 8.5 before 8.5.13, and the 8.6.0 release candidates. Whether a deployment is exposed depends on the conditions of each flaw.

PHP 8.1 and earlier are end-of-life. depthfirst says the official 7.4, 8.0 and 8.1 end-of-life mitigation branches are not affected by phpAfterShell, but PHP says CVE-2026-129289 was introduced in PHP 5.6.0 and that releases older than 8.2 may also be affected by CVE-2026-115560.

Linux distributions often backport fixes without changing the PHP version number. Check the full package version against your distribution’s advisory.

Copy linkHow Cloudflare WAF protects you

PHP runs a large share of the web, often inside content management systems, plugins, and container images that teams do not update directly. Patching every PHP runtime takes time. Cloudflare WAF reduces your exposure while you patch.

Copy linkphpAfterShell: protection on every plan

We released the original PHP remote code execution rules in an emergency release on October 21, 2026, after the php2shell vulnerabilities (CVE-2026-109618 and CVE-2026-109619) were disclosed. We extended them to CVE-2026-115560 on October 23 and refined them several times in the following weeks, based in part on reports from security researchers who took part in a PHP Capture the Flag (CTF) challenge.

phpAfterShell shares an attack technique with php2shell: an attacker plants serialized PHP data in session storage and waits for PHP to deserialize it. Because of that overlap, the existing rule already matched part of the phpAfterShell attack pattern before disclosure. On November 19, we updated the rule’s detection logic to cover phpAfterShell and added CVE-2026-126714 to its description.

Rule descriptionRule IDRulesetDefault action
PHP Remote Code Execution Attack (CVE-2026-109618, CVE-2026-109619, CVE-2026-115560, CVE-2026-126714) #619373a83abb840e18ab3ce5a7975ce1bCloudflare Free Managed Ruleset (Free plan)Block
PHP Remote Code Execution Attack (CVE-2026-109618, CVE-2026-109619, CVE-2026-115560, CVE-2026-126714) #64148ae686fdb4d01be673fab9d9c073dCloudflare Managed Ruleset (Pro, Business and Enterprise plans)Block

Free plan customers do not need to take any action. On paid plans, the rule is active wherever the Cloudflare Managed Ruleset is deployed. You can use the links in the Zero Wire briefing to go straight to the rules in your dashboard.

Copy linkNew rules for PHP-FPM and SOAP flaws

The three new rules are part of the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee) and are available on Pro, Business and Enterprise plans.

Rule descriptionRule IDDefault action
PHP-FPM – CVE:CVE-2026-1292898ef1c34a424b4ccfa6f6fe186c6f42b2Log
PHP SOAP – CVE:CVE-2026-153535c5a9d6397e44837a3214b5ba54028d4Log
PHP SOAP – CVE:CVE-2026-12950600a23de67a684876ba67c5d44521b819Log

To review their matches, go to Security > Analytics > Events and filter by rule ID. If the matches are not legitimate traffic, change the rule action to Block: go to Security > Settings, edit the Cloudflare Managed Ruleset, search for the CVE identifier and set the rule action to Block, or you can refer to the links in the Zero Wire briefing to go straight to the rules configuration.

Copy linkWhat the WAF cannot see

A WAF can block an exploit when the malicious data arrives in an HTTP request that passes through Cloudflare. It cannot block every path to these vulnerabilities, including:

  • The deserialization step. phpAfterShell’s final step happens inside PHP, when it reads a corrupted session file. The WAF can block the requests that plant the payload, not the read itself.
  • Session data from other sources. If an application copies user-controlled data into the session from a database, a queue or an upstream API, that data may never cross the WAF in a recognizable form.
  • Flaws triggered by server state. CVE-2026-129496, CVE-2026-129481, CVE-2026-129474 and CVE-2026-129182 depend on error logs, diagnostics and worker lifecycle. They do not have dedicated WAF rules, and the patch and the configuration changes below are the way to address them.
  • Traffic that bypasses Cloudflare. This includes internal traffic between services and PHP-FPM listeners exposed directly to a network.

Copy linkAdding defense in depth with WAF attack score

WAF attack score adds a machine learning layer that scores each request for attack payloads. It is available on Business plans (cf.waf.score.class) and, with a dedicated remote code execution sub-score (cf.waf.score.rce) along with an overall score (cf.waf.score), on Enterprise plans.

Attack score complements the managed rules. It will not recognize every serialized object or smuggled FastCGI record on its own, but a working exploit chain usually needs more than one request, and the later stages carry payloads the model is trained to score:

  • Second-stage payloads. Once an attacker can run code, they still need to send commands: shell execution primitives (/bin/sh -c, system(), passthru()), PHP code evaluation (eval(), assert()) or reverse-shell strings in headers, query parameters or request bodies.
  • Webshell traffic. Attackers often drop a small PHP webshell after the initial compromise. Requests that pass operating system commands to that webshell remain visible to attack score.

Copy linkDeploy protections and patch

You can find more information on how to deploy managed rules and attack score in our WAF guide. In short:

  1. Check that phpAfterShell protection is active. On the Free plan, no action is needed. On paid plans, make sure the Cloudflare Managed Ruleset is deployed and that the PHP Remote Code Execution Attack #6 rule is set to Block.
  2. Review the new rules and switch them to Block. The CVE-2026-129289, CVE-2026-15353 and CVE-2026-129506 rules are in Log mode by default. Review their matches in Security Events, then change their action to Block.
  3. Layer attack score. Create a custom rule that blocks or challenges requests with a low remote code execution score, for example cf.waf.score.rce le 20 on Enterprise plans, or cf.waf.score.class eq “attack” on Business plans.
  4. Upgrade PHP. Move to 8.2.36, 8.3.37, 8.4.28, 8.5.13 or 8.6.0. Rebuild container images and restart the PHP-FPM master or Apache so every worker loads the new binary, then verify the version that serves web requests. After upgrading, check that no php.ini, FPM pool or virtual host still sets session.upload_progress.enabled=1, because an explicit setting overrides the new default.
  5. Apply interim mitigations if you cannot upgrade right away. Set session.upload_progress.enabled=0 and limit the untrusted data you store in sessions. Turn off FastCGI connection reuse. On PHP 8.5, set fatal_error_backtraces=0. Fix configuration errors that produce PHP startup warnings, or send PHP errors to syslog instead of a file. Keep PHP-FPM listeners off untrusted networks. These steps reduce exposure; they do not fix the flaws.

For a prompt you can give an AI agent to inventory your PHP deployments and check each one against all seven critical CVEs, see the phpAfterShell page on Cloudflare Zero Wire.

Copy linkUpdate every PHP runtime now

phpAfterShell turns an interrupted file write in PHP’s default session handler into a path to code execution, and it arrived in the same release as six other critical flaws. With technical details now public, we expect exploit attempts to follow. Cloudflare WAF blocks known phpAfterShell attack patterns for every customer, including the Free plan, and paid plans have new rules for the PHP-FPM and SOAP flaws. The fix is still to upgrade PHP and restart the services that use it.

Source :
https://blog.cloudflare.com/phpaftershell-waf-protection/

How Cloudflare WAF protects against ruby2shell (CVE-2026-132825)

Daniele Molteni, Pawel Klimek, and Denzil Correa

7 minute read

On November 19, 2026, the Ruby team disclosed ruby2shell (CVE-2026-132825), a heap buffer overflow in the way Ruby changes the case of strings. Ruby rates the flaw Critical and says it is aware of proofs of concept that achieve remote code execution in some scenarios. Fixes shipped in Ruby 3.3.14, 3.4.13, and 4.0.10.

The reach is wide. Veria Labs reports that Ruby on Rails and classic-style Sinatra applications reach the bug in their default configuration, before any authentication. Self-hosted products that bundle Ruby, including GitLab, GitHub Enterprise Server, Mastodon, OpenProject, Discourse and Chatwoot, shipped an affected Ruby in their latest release at the time of disclosure.

Cloudflare WAF blocks ruby2shell for all customers, including those on the Free plan. We have added two rules to both the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset, with Block as the default action: one for ruby2shell and one for GHSA-87fm-7w84-j2px, a related integer overflow in Ruby string case conversion fixed in the same releases.

The WAF is a compensating control, not a replacement for patching. Exploits can reach the bug through paths a WAF does not see, and the only complete fix is to upgrade Ruby. Our team continues to monitor attack traffic and will update the rules as new techniques appear. You can track rule changes in the WAF changelog and get the latest on the vulnerability in the Cloudflare Zero Wire briefing.

Cloudflare has patched its own systems that use Ruby, and we have found no indication of compromise.

Copy linkWhat we know about ruby2shell

Ruby strings carry an encoding, and Ruby still supports many legacy single-byte encodings, such as ISO-8859-1 (Latin-1) and Windows-1252, alongside UTF-8. In a single-byte encoding each character takes one byte, so changing the case of a string usually produces output of the same length.

The German sharp s (ß) breaks that assumption. Its uppercase form is two characters, SS. In 14 ISO-8859 and Windows-125x encodings, Ruby writes those two bytes but checks for room for only one. According to Veria Labs, a string with 21 sharp s characters overflows the output buffer by one byte. The methods that reach the bug are upcase, swapcase, downcase(:fold) and casecmp?. UTF-8 strings take a different code path and are not affected.

A one-byte overflow can look harmless. In a memory-corruption exploit, though, a single byte written past the end of a heap buffer can be enough to corrupt an adjacent object or allocator metadata. Ruby says it is aware of proofs of concept that turn this flaw into code execution, and Veria Labs says it will publish its own proof of concept about a week after disclosure. We expect scanning to start soon after.

Copy linkWhy default Rails and Sinatra apps are exposed

HTML forms can only send GET and POST requests. To simulate PUT, PATCH, or DELETE, many web frameworks accept a _method parameter in a POST request. Rack, the interface most Ruby web frameworks build on, implements this in its MethodOverride middleware, which converts the value of _method to uppercase. Rails includes this middleware by default, and classic-style Sinatra applications enable it. An attacker can send a multipart POST request whose _method part declares a legacy character set and contains a run of sharp s characters. The framework upcases the value while it is still routing the request, before any application code or authentication check runs.

Veria Labs reports that other frameworks and plain Rack applications are not exposed by default. Application code that changes the case of strings received in a legacy encoding may still be affected, wherever the string comes from.

Copy linkWho is affected

ConditionDetails
Ruby versionRuby 3.3.13 and earlier, 3.4.0 through 3.4.12, and 4.0.0 through 4.0.9. Veria Labs reports the bug has been present since Ruby 2.4.0. Ruby 3.2 and earlier have reached end of life and will not receive the fix.
FrameworkRails and classic-style Sinatra in their default configuration. Any other code that changes the case of attacker-controlled strings in a legacy single-byte encoding.
Bundled softwareAs of November 19, 2026, Veria Labs lists GitLab 19.6.0, GitHub Enterprise Server 3.22.5, Mastodon 4.7.5, OpenProject 17.9.7, Discourse 2026.10.1 and Chatwoot 4.20.0 as bundling an affected Ruby in their latest release. Discourse moved its Docker base image to Ruby 4.0.10 on November 19, so rebuilding a Docker install picks up the fix.

Distribution packages can backport fixes without changing the Ruby version number, so check the full package version against your distribution’s advisory.

Copy linkSix more Ruby flaws in the same release

Ruby 3.3.14, 3.4.13, and 4.0.10 also fix six other memory safety flaws, and Ruby says several of them can lead to code execution. One, GHSA-87fm-7w84-j2px, is an integer overflow in the same string case conversion code, and our second WAF rule covers it. The other five are in Ruby’s regular expression engine. Most of them require the application to compile or match a regular expression pattern supplied by the attacker. That is uncommon in web applications, but it does happen in search features, filtering rules and admin tools.

Copy linkHow Cloudflare WAF protects you

Upgrading every Ruby runtime takes time, especially when Ruby is bundled inside self-hosted products and container images. Cloudflare WAF reduces your exposure while you patch.

Copy linkNew managed rules, on for every customer

Both rules are part of the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee), with Block as the default action.

Rule descriptionRule IDRulesetDefault action
Ruby – Heap Overflow – CVE:CVE-2026-1328257328f23691e44b07892ebd25b19210f1Cloudflare Free Managed Ruleset (Free plan)Block
Ruby – Heap Overflow – CVE:CVE-2026-1328251afa543a1ed84893b01df04c34402c88Cloudflare Managed Ruleset (Pro, Business and Enterprise plans)Block
Ruby – Integer Overflow – GHSA-87fm-7w84-j2px8660e37e86444f9f9267ba22e9855f05Cloudflare Free Managed Ruleset (Free plan)Block
Ruby – Integer Overflow – GHSA-87fm-7w84-j2px6defac6a52334542adf4a162daf25922Cloudflare Managed Ruleset (Pro, Business and Enterprise plans)Block

On the Free plan, the Cloudflare Free Managed Ruleset runs automatically, so there is nothing to turn on. On paid plans, the rules are active wherever the Cloudflare Managed Ruleset is deployed. Because paid plans give you more control over how rulesets are deployed, the Cloudflare Managed Ruleset may not be active on every zone. We recommend checking its status to confirm that it is running. You can use the links in the Zero Wire briefing to go straight to the rules in your dashboard.

Copy linkWhat the WAF cannot see

A WAF can block an exploit when the malicious input arrives in an HTTP request that passes through Cloudflare. It cannot block every path to the vulnerable code:

  • Traffic that bypasses Cloudflare. Requests sent directly to your origin IP address, and traffic between internal services, never reach the WAF. Configure your origin to accept traffic only from Cloudflare, for example with Cloudflare Tunnel or Authenticated Origin Pulls.
  • Other entry points into the same code. Ruby code that changes the case of strings from email, file imports, message queues or background jobs can reach ruby2shell without an HTTP request.

Copy linkAdding defense in depth with WAF attack score

Memory corruption is usually only the first step. To run commands, an attacker still has to deliver a second-stage payload, such as shell commands or a reverse shell, and then interact with the compromised server. WAF attack score uses machine learning to score each request for remote code execution payloads, which helps catch exploit variations and post-exploitation traffic that signature-based rules can miss. Create a custom rule that blocks or challenges requests with cf.waf.score.rce le 20 on Enterprise plans, or cf.waf.score.class eq "attack" on Business plans.

Copy linkImpact on Cloudflare infrastructure

Cloudflare has patched its systems that use Ruby against ruby2shell. We have found no indication of compromise and continue to monitor.

Copy linkPatch now

ruby2shell turns a one-byte miscalculation in string case conversion into a pre-authentication path to code execution in default Rails and Sinatra apps. With a public proof of concept expected within days, the window to patch is short. Here is what to do:

  1. Check your WAF coverage. On the Free plan, the ruby2shell rules are already blocking. On paid plans, confirm the Cloudflare Managed Ruleset is deployed and the rules have not been overridden.
  2. Upgrade Ruby to 3.3.14, 3.4.13 or 4.0.10 and restart every Ruby process, including background workers. Rebuild container images. Move applications on Ruby 3.2 or earlier to a supported series.
  3. Update self-hosted products that bundle Ruby, such as GitLab, GitHub Enterprise Server, Mastodon, OpenProject and Chatwoot, as each vendor releases a fix. Rebuild Discourse Docker installs now.
  4. Inventory your runtimes. The Zero Wire briefing includes a prompt you can give an AI agent to find every affected Ruby runtime in your infrastructure.

Our WAF analysts will keep updating protections as new techniques appear. Follow the WAF changelog for rule updates.

Source:
https://blog.cloudflare.com/ruby2shell-waf-protection/

nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them

Dan Jones, Richard Boulton, and Daniele Molteni

22 minute read

On November 18, 2026, F5 and nginx.org disclosed ten vulnerabilities in nginx. Five of them, detailed by the Xint research team and published under the name nginx2root, are memory corruption flaws that an unauthenticated attacker can use to crash an nginx worker or, per Xint’s research, run commands on the server. Xint also found a Linux kernel bug that turns that foothold into root on the host, including from inside a Docker container. Other teams found the two HTTP/2 bugs independently: F5 also credits Rapid7, Wiz Research and Ikotas Labs for CVE-2026-123007, and Metnir, Wiz Research, and Palo Alto Networks Unit 42 for CVE-2026-123633.

nginx is an HTTP web server that also serves as reverse proxy, content cache, load balancer, TCP/UDP proxy server, and mail proxy server. nginx runs a large share of the world’s web servers, so this is a patch-now event. But if your nginx server is reachable only through Cloudflare’s proxy, attackers cannot reach the vulnerable code paths for the most serious of these bugs, giving you protection while you update your servers.

Here is where Cloudflare stands, what that protection covers, where it stops, and how the bugs work.

Copy linkThe short version

  • Cloudflare’s edge is not affected. Much of the proxy that handles customer traffic at our edge now runs on FL2, written in Rust. We reviewed the parts still built on our heavily modified nginx fork against all five bugs before disclosure, and an update closing the related code paths finished rolling out globally before the vulnerabilities were published. The same releases fix five other nginx CVEs, including CVE-2026-118899, an infinite loop while reading a request body over TLS 1.3.
  • Origins behind Cloudflare’s HTTP proxy are shielded from the HTTP/2 and HTTP/3 attacks. For proxied hostnames, Cloudflare terminates every client HTTP/2 and HTTP/3 connection at our edge and opens a separate connection to your origin. The attacker’s frames never reach your nginx.
  • The resolver and mail proxy vulnerabilities depend on specific configuration. Many configurations of nginx will not be vulnerable, but the safest way to be sure is to update your install or disable features.
  • You should still patch. Update to nginx 1.30.7 or 1.31.9 (or your vendor’s fixed build) and restart. Some configurations, covered below, are not protected by the proxy.

Copy linkWhat was disclosed

nginx2root is five independent bugs. Each one works on its own and each one needs a different configuration.

CVEBug classAffected configurationFirst affected release
CVE-2026-123007Integer overflow leading to out-of-bounds heap read/writeHTTP/2 enabled1.9.5 (2015)
CVE-2026-123633Use-after-freeHTTP/2 with proxy_pass to a backend, worker low on worker_connections1.19.7
CVE-2026-121810Use-after-freeHTTP/3 (QUIC) with proxy_pass to a backend1.25.0
CVE-2026-123634Use-after-freeresolver + proxy_pass with variables + a subrequest (mirror or SSI)0.6.18
CVE-2026-113425Use-after-freeMail proxy with proxy on and auth_http0.5.33

F5 rates each one High (CVSS 3.1: 8.1) and Critical (CVSS 4.0: 9.2), and notes that code execution requires disabling or bypassing ASLR (Address Space Layout Randomization). For CVE-2026-123007, Xint’s write-up shows how it leaked memory addresses to do exactly that.

CVE-2026-123007 is the one to worry about most. It only needs HTTP/2 turned on, which is commonly enabled on TLS deployments, and it has been in every nginx release since HTTP/2 support shipped in 1.9.5. Xint ran the exploit over the public Internet against servers on AWS, GCP and Azure. Xint searched Shodan on November 10, before the disclosure, and found 56.7 million hosts matching product:nginx. Of the 11.94 million that reported a version, 98.9% fell in the affected range. As of November 19, Censys’s nginx2root exposure tracker counts about 8.8 million services running a potentially affected version with HTTP/2 enabled. Version strings don’t prove a host is vulnerable, since distributions backport fixes, but the exposure is large.

The same nginx releases also fix five other bugs. The most serious, CVE-2026-118899, is an infinite loop when reading a request body over TLS 1.3 that lets an unauthenticated attacker stall a worker, in nginx 1.13.0 and later.

The Linux kernel bug is the sixth part of nginx2root. Xint found a use-after-free in the kernel’s SCTP send path, present since Linux 4.15 (2018): while a send operation waits, its SCTP association can be moved to another socket, and the waiting send can then free it. An attacker who already runs code as the nginx worker can use it to gain root on the host, and Xint did this from an nginx running inside a Docker container. Many distributions load the SCTP module automatically the first time a program opens an SCTP socket, so hosts that never use SCTP can still be exposed. As of November 18, no kernel fix was available and Xint was withholding the details until there is one.

As of November 19, none of the five nginx2root CVEs is in CISA’s Known Exploited Vulnerabilities catalog, and we have not seen reports of exploitation in the wild. Xint and Wiz Research have not released their exploits. Rapid7 has published a proof of concept, which it describes as suitable only for demonstrating the attack against a freshly started local container. Fake ‘exploits’ are also circulating on GitHub.

Copy linkWhy Cloudflare’s proxy protects your origin

nginx2root’s most dangerous bugs live in how nginx parses and manages HTTP/2 and HTTP/3 connections. To trigger them, an attacker has to send a carefully ordered stream of protocol frames directly to the nginx process: billions of WINDOW_UPDATE frames, a SETTINGS frame that holds response data back, PING frames that fill the send buffers, partial HEADERS frames, RST_STREAM at exactly the right moment.

When your DNS record is proxied through Cloudflare, that connection ends at our edge.

Cloudflare reads the client’s HTTP request, applies your security and caching rules, and then makes its own request to your origin over a connection Cloudflare controls. The flow-control frames, pings, settings, and stream resets that the attacker sends are consumed by our edge. They are not forwarded. Your nginx only ever sees the requests Cloudflare chooses to send, framed the way Cloudflare frames them. This also holds when Cloudflare connects to your origin over HTTP/2: Cloudflare runs its own flow control on that connection and sends WINDOW_UPDATE and RST_STREAM frames only as its own traffic needs, so a client can’t make it relay the billions of WINDOW_UPDATE frames the attack requires.

Rapid7 makes the same point in its analysis of CVE-2026-123007: if the HTTP/2 connection is proxied, the attacker’s frames “will likely not be retransmitted” in a way that allows exploitation. This breaks each of the HTTP/2 and HTTP/3 attacks.

CVEWhat the attacker needsBehind Cloudflare’s HTTP proxy
CVE-2026-123007Direct control over HTTP/2 WINDOW_UPDATE, SETTINGS, PING and RST_STREAM on one connection to nginxProtected. Control frames terminate at Cloudflare’s edge.
CVE-2026-123633The first part of a HEADERS frame on a direct HTTP/2 connection, plus the ability to exhaust nginx connection slots and reset the TCP connectionProtected. The client’s HTTP/2 connection terminates at Cloudflare.
CVE-2026-121810A direct QUIC/HTTP/3 connection to nginxProtected. HTTP/3 terminates at Cloudflare’s edge. We do not communicate to origins over HTTP/3
CVE-2026-123634A request and its mirror or SSI subrequest waiting on the same DNS lookup, and the main request ending while the answer is processed. In Xint’s exploit, nginx’s resolver had to reach the attacker’s DNS server.Not fully protected. Depends on how your config builds proxy_pass. Patch.
CVE-2026-113425A direct IMAP/POP3/SMTP connection to the nginx mail proxyNot protected. Cloudflare’s HTTP proxy does not carry mail traffic.

There is one condition to be protected by Cloudflare here: your origin must not be reachable directly. If an attacker can find your origin’s IP and connect to it directly (TCP 443 or 80 for HTTP/2, UDP 443 for HTTP/3, or the mail ports), Cloudflare isn’t in the path and the protection doesn’t apply. You should ensure that your origin servers can only be accessed through Cloudflare’s proxies, using one of the following approaches:

  • Cloudflare Tunnel. Your origin makes an outbound-only connection to Cloudflare and exposes no inbound ports.
  • Firewall to Cloudflare IP ranges. Accept inbound HTTP/HTTPS only from Cloudflare’s published IP ranges. This must be done using an IP firewall, not based on configuration in your nginx server.
  • Authenticated Origin Pulls (mTLS). Your origin rejects any TLS connection that doesn’t present Cloudflare’s client certificate.

Xint’s own exposure check makes the same point: “If a CDN or reverse proxy sits in front of nginx, the test only reaches the proxy, so also run it directly against the nginx server.”

Copy linkWhere the protection does not apply

There are several situations in which Cloudflare’s HTTP proxy does not provide protection.

  • Spectrum TCP/UDP applications. For these configurations, traffic from the Internet is passed unmodified through to your origin. If your origin is running nginx, patch or disable the affected features.
  • nginx mail proxy. Cloudflare’s HTTP proxy does not carry IMAP, POP3 or SMTP. Restrict mail listeners to trusted networks until patched.
  • CVE-2026-123634 (resolver). This depends on how your configuration builds the proxy_pass target from the request, combined with a carefully timed cancellation of an HTTP request. Passing your traffic through Cloudflare’s proxy makes it harder to exploit this, but does not provide full protection. Update regardless.
  • DNS-only (grey-cloud), internal or non-proxied nginx. Any nginx server an attacker can reach without going through Cloudflare, including internal services behind a compromised host, needs to be patched.

Cloudflare’s WAF rules are not relevant to these vulnerabilities. These are protocol-level bugs. Because Cloudflare’s proxy handles parsing the HTTP protocol messages, and creates new messages to fetch information from origin servers, origins behind Cloudflare’s HTTP proxy are protected from the HTTP/2 and HTTP/3 bugs without needing a rule. We have therefore not released a managed rule. The protection comes from connection termination, not from pattern matching.

Copy linkWhat to do now

  1. Find every nginx server. Include nginx Plus, distribution packages, container images and appliances. Run nginx -V and nginx -T on each and note HTTP/2, HTTP/3/QUIC listeners, proxy_pass with variables plus SSI or mirror, and any mail block.
  2. Patch. Update nginx Open Source to 1.30.7 or 1.31.9, nginx Plus to 37.0.8.1 or 37.3.0.1, or your distribution’s fixed package. F5 lists nginx Plus R34 to R36 as affected with no fixed build, so move those to a fixed 37.x release. Then restart nginx or complete a binary upgrade. A config reload does not replace the running binary.
  3. Check backport versions carefully. Distributions often patch without changing the version nginx -v reports. Compare the full package version against your distribution’s advisory.
  4. Make sure your origin is only reachable through Cloudflare. Use Tunnel, IP allowlisting or Authenticated Origin Pulls.
  5. If you can’t patch yet, disable what you don’t need. http2 off; (nginx 1.25.1 and later; on older versions, remove http2 from the listen directive) blocks CVE-2026-123007 and CVE-2026-123633. Removing QUIC listeners and setting http3 off; blocks CVE-2026-121810. Point proxy_pass at fixed upstream groups for CVE-2026-123634. Don’t rely on mirror_request_body alone: Xint’s tested setup set it to off, and the default on stopped that exploit, but SSI and other subrequests can still reach the bug. Bind mail listeners to trusted networks for CVE-2026-113425. Restart so old connections close.
  6. Block SCTP if you don’t use it. Add install sctp /bin/false to a file in /etc/modprobe.d/ to stop the kernel module from loading. This doesn’t unload an already-loaded module or disable SCTP built into the kernel. When your distribution ships a kernel update for the SCTP bug, install it and reboot. Blocking the module is a stopgap until then.

The Cloudflare Radar Zero Wire entry for nginx2root has the full checklist, a prompt you can give an agent to run a read-only assessment of your fleet, and links to every vendor advisory.

Copy linkTechnical deep dive

Let’s dig into the details of the five bugs by looking through the code. We’re looking at nginx 1.31.8 (commit 140aa94) which was the most recent code published before the fixes, and comparing this to the fixes in 1.31.9 (which were also included in release 1.30.7 on the stable branch).

A note on methodology: we based our analysis on the public advisories, and to verify our reading of the code, we built the public 1.31.8 and 1.31.9 releases with AddressSanitizer and ran tests for four of the five bugs (flow control, HTTP/2 use-after-free, resolver and mail proxy). Each one faults on 1.31.8 and runs clean on 1.31.9. We did not reproduce the HTTP/3 bug; that section is based on the fix commit and the published analysis.

Copy linkOne pattern, in four places

Four of the five bugs are use-after-free bugs. This is a common issue with programs that manually manage memory without language support: one part of the code frees an object that another part is still using.

nginx is event driven. A handler runs, calls other code, and that code returns to the handler. Three of the bugs occur when the called code tears down the connection or request the handler is working on. In the fourth, a second connection still holds a pointer to the object.

  • CVE-2026-123633 and CVE-2026-121810. A request needs a connection slot to reach its upstream. nginx is low on slots, so it closes an idle connection to free one. The connection it chooses is the one the request belongs to.
  • CVE-2026-123634. A resolver callback ends a request. Cleanup of that request frees a second resolver context that the resolver is about to call next.
  • CVE-2026-113425. When a write to a mail client fails, the client connection is closed while the connection to the authentication service still points at its session.

F5 rates all four as potential code execution if address space layout randomization (ASLR) is disabled or bypassed, and in its tests Xint reports code execution with the privileges of the nginx worker.

The fifth bug, CVE-2026-123007, is of a different kind: an accounting error that becomes a length error.

Copy linkCVE-2026-123007: two flow-control pieces that each look correct

HTTP/2 flow control limits the amount of response data a server may send. nginx tracks a send window for each stream and one for the connection, h2c->send_window. The client enlarges a window with a WINDOW_UPDATE frame, and the protocol caps every window at 2^31 − 1.

nginx enforces that cap when a WINDOW_UPDATE arrives (ngx_http_v2_state_window_update()):

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
   /* logs "client violated connection flow control" */
   return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}

On its own, this check is correct. But the connection window also grows in a second place. When nginx queues DATA frames for a stream, it subtracts their length from the window. If the stream is canceled before those frames go out, ngx_http_v2_filter_cleanup() takes them off the queue and returns the credit:

h2c->send_window += window;

Nothing caps this line. As the fix commit describes, if the client enlarges the connection window after the frames are queued and before the stream is terminated, the refund pushes the window past 2^31 − 1.

From that point the first check no longer works. h2c->send_window is an unsigned size_t, so NGX_HTTP_V2_MAX_WINDOW - h2c->send_window wraps around to a very large number and every subsequent WINDOW_UPDATE is accepted. The client can then raise the window as far as it wants.

The window is unsigned, but the code that sizes DATA frames compares it as a signed value (ngx_http_v2_send_chain()):

if (limit == 0 || limit > (off_t) h2c->send_window) {
   limit = h2c->send_window;
}
...
if ((off_t) frame_size > limit) {
   frame_size = (size_t) limit;
}

After the window passes 2^63, it is negative as an off_t. The frame size becomes the window value itself, a number between 2^63 and 2^64, and nginx builds a buffer whose last pointer lies before its pos pointer.

Over TLS, that buffer reaches a memcpy() in ngx_ssl_send_chain() with that length. Our TLS test stops at that point under AddressSanitizer. Xint’s write-up explains how, with the window pushed close to 2^64, this turns into a controlled out-of-bounds write and an address leak, and Xint, Rapid7, and Wiz each report code execution from it. This post goes no further than the fault.

Over cleartext HTTP/2, the same invalid buffer follows a different output path. Our cleartext test also faults under AddressSanitizer on 1.31.8 and runs clean on 1.31.9. The public write-ups address the TLS case.

Copy linkHow much traffic the known attacks require

The biggest step a WINDOW_UPDATE can take is 2^31 − 1, and a WINDOW_UPDATE frame is 13 bytes. Bringing a 64-bit window near its top therefore requires about 2^33 frames: roughly 8.6 billion frames, or about 112 GB (104 GiB).

Rapid7, which published a proof of concept, gives the same figure and adds that nginx limits control-frame traffic relative to other traffic on the connection, so its run also sends about 15 GiB of other request traffic. Its total comes to approximately 128 GB of HTTP/2 data: about two minutes on a 10 Gbit/s link and about seventeen minutes at 1 Gbit/s. Rapid7 estimates the WINDOW_UPDATE traffic needed to reach 2^63 at about 2^32 frames, or 52 GiB, half of the 104 GiB figure. It also notes that these figures describe its route and are not a proven minimum.

For defenders, this is the useful fact about the bug. At this volume, the known attacks are hard to hide: nginx receives tens of gigabytes from a single client over one long-lived connection and sends little back, much more than the requests in the access log account for.

Copy linkWhy it was difficult to find

The refund line has existed in nginx since HTTP/2 support arrived in 1.9.5 in 2015. Two things made it difficult to notice.

First, each piece looks correct on its own. The check on WINDOW_UPDATE is the right check. The refund is the right refund. The bug is that the check relies on an assumption the refund does not preserve.

Second, testing that waits for a crash is very unlikely to reach it, because a crash requires tens of gigabytes of input. The bad state itself can be reached with very little traffic: Censys published a cleartext test that reaches what it calls the corrupted flow-control state with a 5.69 MB capture. A test that asserts “the send window never exceeds its protocol maximum” after every frame would flag the bad state as soon as a test sequence got there. A test that waits for memory corruption would not.

Copy linkThe fix

The fix (6 lines added) introduces a counter, h2c->send_queued, for DATA that is queued but not yet sent. The WINDOW_UPDATE check now includes those bytes in the window:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {

From the client’s perspective, queued frames still count toward the window, so the client can no longer refill credit that nginx is about to refund. On a fixed version the attempt is rejected with a flow-control error.

Copy linkCVE-2026-123633: where two protections interact

An nginx worker has a fixed number of connection slots (worker_connections), which the client and upstream connections share. Since 1.19.2, when free slots run low (1/16 of the total or fewer), ngx_get_connection() calls ngx_drain_connections(), which closes connections marked “reusable”: connections with nothing in progress, such as idle keep-alive connections.

This works only if a reusable connection truly has nothing in progress. For HTTP/2 that was not always the case. Two commits landed on the same day in February 2021 and were released together in 1.19.7:

  • “HTTP/2: fixed reusing connections with active requests” fixed a case in which a cleartext HTTP/2 connection could remain reusable while it had a request.
  • “HTTP/2: reuse of connections with incomplete frames” registered a connection as reusable while it waits for the remainder of a partly received frame, so that a client cannot hold slots with partial frames.

The second change is the relevant one here. As the fix commit explains, if the remainder of that frame is a HEADERS frame, a stream is created, but the reusable status was not reset until the connection next went idle. The connection then has a request and remains in the reusable queue.

If that request is proxied, nginx requests a slot for the upstream connection. If slots are short, the drain runs inside that call and can choose this same connection. The drain instructs the connection to close and nginx attempts to send GOAWAY. If that send fails, nginx frees the connection and every stream on it. Control then goes back to the upstream code, which continues to use the request it was called for.

Each change made sense on its own. The interaction between them was subtle and stayed unnoticed until this year. F5’s advisory credits Albert Ebb of Metnir, Nir Ohfeld at Wiz Research, Xint.io and memN0ps of Palo Alto Networks Unit 42; nginx.org’s changelog credits Albert of Vexera AI.

Copy linkThe fix

Two lines added: ngx_http_v2_create_stream() now calls ngx_reusable_connection(h2c->connection, 0). A connection that has a stream is never reusable, regardless of the state it was in before.

Copy linkCVE-2026-121810: the same idea, in QUIC

According to the fix commit and Xint’s analysis, the HTTP/3 bug reaches the same result by a different route.

In nginx’s QUIC code, each QUIC connection uses one connection slot and each stream uses another. A QUIC connection may be drained only when every stream remaining in its tree can be cancelled, and nginx determines this by walking the connection’s tree of streams.

ngx_quic_create_stream() removes the QUIC connection from the reusable queue and then requests a slot for the new stream. Before the fix, the new stream was added to the tree only after that. If the slot request triggered a drain that closed another, idle stream of the same QUIC connection, the code handling the closed stream walked the tree, did not find the stream being created, concluded the connection was idle, and made it reusable again. A later drain, for example when the new request connects to its upstream, could then close the QUIC connection while that request was running.

F5’s advisory states that exploitation “also depends on conditions beyond the attacker’s control”. Xint writes that the bug “is triggered by a slightly different mechanism” from the HTTP/2 one.

Copy linkThe fix

Four lines added: the stream goes into the tree before the slot is requested, and is taken out again on the error paths.

Copy linkCVE-2026-123634: freeing the next item of a list during the walk

When proxy_pass contains a variable, nginx resolves the host name while handling the request. If a lookup for the same name is already in progress, the new request waits on the same resolver node. When the answer arrives, nginx detaches the list of waiting contexts and calls each in turn:

next = rn->waiting;
rn->waiting = NULL;

while (next) {
   ctx = next;
   ...
   next = ctx->next;

   ctx->handler(ctx);
}

The loop stores next before the handler call, so a handler may free its own context. The trouble starts when a handler frees a different context in the same list. This happens when two contexts belong to one request, as with a request and its mirror subrequest resolving the same name (the case Xint tested; F5 also lists SSI subrequests). If the first handler ends the request, the request’s cleanup calls ngx_resolve_name_done() for the second context. That function searches the node’s waiting list for the context, does not find it because the list has been detached, and frees the context regardless. The loop then advances to the freed context.

Usually nginx logs this. On vulnerable versions, when the search fails, it writes

could not cancel <name> resolving

to the error log at alert level. This line is worth searching for. It is not proof either way: the fix commit notes that one variant, while following a CNAME, produced no alert.

Copy linkThe fix

A context cancelled while it sits in a detached list is no longer freed immediately. Its handler is swapped for one that frees it when the loop gets to it (31 lines added). The fix also downgrades the alert to a debug message, so the line above shows up at alert level only on unpatched versions.

Copy linkCVE-2026-113425: two connections, one session

With auth_http, the mail proxy asks an HTTP service to verify each login. During the wait, it holds two connections for one session: the client connection and the connection to the authentication service. The second points at the session and uses the memory pool of the client connection.

Before the fix, the reply the protocol handler had prepared for the client remained queued while the authentication request was in progress, and the client’s write handler was still ngx_mail_send(). If that handler ran and the write failed because the client had reset the connection, it closed the client connection and destroyed the session. The authentication connection still pointed at the session, and the next event on that connection used freed memory.

Xint describes two conditions for this: the client’s write event must already be registered (for example, because the client stopped reading replies), and the login command and the reset must be handled in the same pass of the event loop. Valid credentials are not needed, because this happens before the login is checked.

Copy linkThe fix

Two added lines discard the queued reply when the authentication request begins. The same release contains three further commits that block client writes while the proxy waits for the authentication response, while it connects to the upstream and reads its greeting, and while it resolves an SMTP client’s address and name.

Copy linkWhat the fixes share

The five fixes each involve minor corrections to the code. They add between 2 and 31 lines each, and the mail proxy fix came with three further commits. There is no design change needed. Each fix restores an invariant that the rest of the code already depended on:

  • a send window never goes above the protocol maximum
  • a connection with a request in progress is never reusable
  • an object that other code is about to use is not freed out from under it

In every case, one code path failed to keep a rule that the rest of the code relied on, and the fix makes that path keep it. As code is modified over time, it is very easy for these kinds of rules to become broken.

Copy linkWhat to watch for

Attempts to exploit this will typically trigger some characteristic log messages. Three of these messages (the two at info and the one at warn) fall below nginx’s default error_log level of error and appear only if a lower level is set. The alert messages are logged by default.

BugLog messages or other signals
CVE-2026-123007A single long-lived HTTP/2 connection on which nginx receives tens of gigabytes from a client and sends little back, much more than its logged requests account for. On fixed versions a rejected attempt logs client violated connection flow control: received WINDOW_UPDATE frame with window increment ... not allowed for window ... (level info; older versions have the same message for ordinary violations). http2 flood detected (level info) on such a connection can be a failed attempt, but nginx also logs that message for several other limits.
CVE-2026-123633, CVE-2026-121810worker process <pid> exited on signal 11 (level alert) on servers that accept HTTP/2 or HTTP/3 and proxy to an upstream, along with worker_connections are not enough, reusing connections (level warn). A use-after-free does not always crash.
CVE-2026-123634could not cancel <name> resolving (level alert, unpatched versions only). The absence of this message does not rule the bug out.
CVE-2026-113425Worker crashes in a mail proxy using auth_http, with client connections reset during login.
All fiveUnexpected programs launched by an nginx worker process, for example from an auditd rule on execve for the worker’s user. Xint recommends this check, and it is the strongest sign of a successful attack.

Copy linkTimeline

Date (UTC)Event
Oct 11, 2026Xint discovers the vulnerabilities
Oct 16, 2026Reported to F5 via HackerOne
Oct 27, 2026Reports delivered to the nginx development team
Nov 10, 2026Xint completes patch validation
Nov 18, 2026Public disclosure; nginx 1.30.7 and 1.31.9 released

Copy linkThe bugs will keep coming

CVE-2026-123007 sat in nginx for more than ten years. The SCTP bug has been in the Linux kernel since 2018. Xint says one of its researchers found CVE-2026-123007 by hand and an automated Xint scan found the other four nginx bugs. Several other teams found the two HTTP/2 bugs independently. Meanwhile, nginx’s advisory list has gone from two entries in 2025 to 36 so far this year. AI-assisted research is finding bugs in heavily reviewed code faster than before, and more disclosures like this one are coming.

That’s a large part of why it’s worth putting Cloudflare in front of your origin. A protocol bug in your web server becomes much less of a risk when the attacker can’t speak that protocol to your server directly. Our edge is not affected, and the HTTP/2 and HTTP/3 attacks against your nginx end at our network. Patch anyway, lock down your origin so Cloudflare is the only way in, and use the Radar Zero Wire page to check your fleet.

Copy linkSources

Source:
https://blog.cloudflare.com/nginx2root/

How Cloudflare WAF helps protect against Java4Shell (CVE-2026-114938)

Denzil Correa, Daniele Molteni, Georgie Yoxall, and Kuber Nandwani

10 minute read

On November 17, 2026, the security research company Calif disclosed Java4Shell (CVE-2026-114938), a memory-corruption vulnerability in the Base64 decoder of OpenJDK, the most widely used Java runtime. Under the Common Vulnerability Scoring System (CVSS) 4.0, it scores 9.2 out of 10 (Critical). The flaw affects Java. OpenJDK published a security advisory and Oracle released patched builds in its November 2026 Critical Patch Update the same day, at 21:00 UTC.

The vulnerability lets a remote attacker with no credentials send malformed Base64 data to a Java application and overwrite memory next to the decoded output. Calif turned that overwrite into a leak of heap memory, similar to Heartbleed, and into remote code execution. Calif demonstrated pre-authentication remote code execution against Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate in their default configurations, and post-authentication remote code execution against Apache Kafka, Apache Solr, Elasticsearch, Gerrit, and Spinnaker.

Cloudflare has released a new set of rules in the Cloudflare Managed Ruleset designed to detect malformed Base64 input patterns associated with this vulnerability. The rules are available on Pro, Business and Enterprise plans and are enabled by default with the Log action because malformed input and some benign application-specific token formats can resemble exploitation attempts. Blocking by default could therefore disrupt legitimate traffic. Customers can review matching requests in Security Events now and change the rules action to Block once they confirm it does not affect legitimate traffic. 

The WAF is an additional layer of defense, not a replacement for the patch. Java4Shell can be reached through paths a WAF does not see, like outbound TLS responses, and the only complete fix is to update the Java runtime. Our analysts continue to monitor attack activity and will update the rules as new techniques and variations appear. You can track rule changes in the WAF changelog and get more information on how the vulnerability develops on the dedicated Cloudflare Zero Wire briefing.

We have seen no indication so far that Java4Shell was exploited on Cloudflare infrastructure.

What we know about the vulnerability

Base64 is a common way to represent binary data as text. Java applications decode Base64 when they process authentication headers, tokens, file uploads and many network messages. To decode it faster, OpenJDK replaces frequently used code with specialized machine code, called intrinsics. On supported x86-64 processors, the Base64 intrinsic uses AVX-512 instructions to process 64 bytes at a time.

The bug sits in the handwritten assembly that handles the final characters of the input. When the tail of the input contains padding characters (=) in a position where valid Base64 never places them, the routine calculates a negative output length. That invalid length turns into a full 64-byte write. For a 65-character input, made of 64 characters followed by a single =, OpenJDK allocates a 50-byte output array and then writes 62 bytes past its end.

Java eventually rejects the input as invalid and throws an exception. By then, the neighboring memory has already been overwritten. An application’s own input validation does not help, because the corruption happens inside the decoder before the application can reject the data.

The simplest trigger is 64 A characters followed by =. On OpenJDK 17, the trigger needs 128 characters followed by =, because the threshold for the fast code path is higher.

Exploitation is not point-and-shoot. The overwritten bytes are mostly fixed values, and the attacker controls only where the write lands. To build a working exploit, Calif arranged the Java heap so that the overflow enlarged neighboring arrays, which gave them first a way to read heap memory and then a way to write chosen bytes. Each target application requires its own exploit chain. Calif reported developing its first working local exploit in about three hours with the help of AI agents, so we expect other attackers to build exploit chains quickly.

Who is affected

Java4Shell affects a system only when all the following conditions are true:

ConditionDetails
Java runtimeOpenJDK 17.0.6 or newer, including distributions built from OpenJDK: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE and Oracle GraalVM for JDK.

Check Oracle’s advisory for the exact list of affected Oracle builds.
Processorx86-64 with AVX-512 VBMI support, such as Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, or AMD EPYC and Ryzen Zen 4 or newer. ARM64 processors are not affected.
InputThe application decodes attacker-controlled Base64 data with the standard Java decoder.

Many applications bundle their own Java runtime, and container images ship with a fixed Java Development Kit (JDK). Upgrading the system Java package does not update those copies, and it does not replace a Java virtual machine (JVM) that is already running. Every updated service needs a restart.

Mitigate if you cannot patch right away

If you cannot update immediately, Calif documents two JVM startup flags that remove the vulnerable code path:

  • -XX:-UseBASE64Intrinsics disables hardware-accelerated Base64 encoding and decoding.
  • -XX:UseAVX=2 disables AVX-512. Apply this flag only on x86-64 hosts. OpenJDK on ARM does not recognize it and will fail to start.

Both flags require a restart and may reduce performance for workloads that decode large amounts of Base64. They buy time while you patch. They do not replace the update.

Protect your infrastructure while you patch

Patching every Java runtime takes time, especially when JDKs are bundled inside applications and container images. Cloudflare WAF can reduce your exposure while you patch. A new managed rule, available on paid plans and enabled in Log mode by default, detects the malformed Base64 input that triggers Java4Shell. For Business and Enterprise customers, WAF attack score adds a machine learning layer that scores each request for remote code execution payloads, which helps catch variations and bypass attempts that signature-based rules can miss.

New managed rules

Protection for paid plans has been released as part of the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee). The rule is enabled by default with the Log action, because blocking by default could cause false positives on legitimate Base64 traffic. To review its matches, go to Security > Security Analytics > Events and filter by the rule ID. If the matches are not legitimate traffic, change the rule action to Block: go to Security > Settings, edit the Cloudflare Managed Ruleset, search for CVE-2026-114938 and set the rule action to Block. Alternatively, you can follow the link to review your configuration on the Zero Wire briefing.

Rule descriptionRule ID
Java4Shell – Malformed Base64 Header – CVE-2026-1149385de9b20a45ea45d3841919ab4d718bf4
Java4Shell – Malformed Base64 Query Value – CVE-2026-11493846bb4172813e471ea62d31c02337b51d
Java4Shell – Malformed Base64 Body Value – CVE-2026-114938d4dc3f71f1bc44a0811ae570e5e5836c
Java4Shell – Malformed Base64 Path Segment – CVE-2026-1149380dceaf0684b54fd0b085fcfb6fd6f152
Java4Shell – Malformed Base64url JWT Component – CVE-2026-1149380ddd0eb664a040779f2f19065a25d991
Java4Shell – Malformed Base64 WebAuthn Value – CVE-2026-1149384fce1ea79a614c07a27348d167d74ebb

We are working on a rule for the Cloudflare Free Managed Ruleset and will update this post when it is available.

A WAF can block the exploit when the malformed Base64 arrives in an HTTP request that passes through Cloudflare. It cannot block every path to the vulnerable decoder, including:

  • Encoded or nested data. The Base64 value may be wrapped inside another encoding or compressed format that the application unpacks before decoding.
  • Non-HTTP protocols. Some affected products, such as the Apache Kafka broker, accept traffic over their own protocols.
  • Outbound connections. Calif also shared a client-side exploit: a Java program that opens a TLS connection to a malicious server can be compromised, even if it exposes no service of its own.
  • Traffic that bypasses Cloudflare. This includes internal traffic between services.

Adding defense-in-depth with WAF attack score

While the managed rule is the primary way to block malformed Base64 triggers at the edge, Cloudflare WAF Attack Score (and specifically its remote code execution sub-score cf.waf.score.rce available on Enterprise plans) can offer an additional, complementary layer of protection.

Because CVE-2026-114938 (Java4Shell) is a binary heap-corruption vulnerability, an attacker rarely achieves full, reliable remote code execution with a single 65-byte (or 129-byte) trigger string alone. On the wire, that initial trigger looks like an opaque, malformed Base64 string containing heap-corruption bytes rather than traditional web-layer injection syntax. As a result, machine learning models trained on application-layer injection patterns will not flag the raw Base64 trigger in isolation.

Instead, turning a bounded JVM heap overflow into remote code execution over HTTP almost always requires a multi-stage or multi-parameter exploit chain, which creates more fingerprints that WAF Attack Score can inspect and flag, including:

  • Heap Grooming and Triggering: To corrupt a predictable adjacent object on the JVM heap (such as a String or byte[] length header), attackers often send repetitive parameters or headers alongside the malformed Base64 payload to shape memory layout before triggering the out-of-bounds write.
  • Second-Stage Payloads: Once heap corruption gives the attacker control over execution flow or object references, the exploit still needs commands, scripts, or Java gadgets to run. If an exploit chain pairs the initial heap-corruption trigger with a second-stage payload such as shell execution primitives (/bin/sh -c, cmd.exe, reverse-shell strings) or Java class-loading gadgets (java.lang.Runtime, ProcessBuilder, serialized object streams) tucked into another header, query parameter, or request body, cf.waf.score.rce can detect and score that secondary payload as malicious.
  • Post-Exploitation Activity: Even if an initial heap-read or corruption request slips past edge filters, subsequent HTTP requests attempting to interact with an in-memory webshell or pass OS commands to the compromised JVM remain directly visible to WAF Attack Score.

Deploy protections and patch

Because sophisticated in-memory exploits can still execute raw shellcode or manipulate bytecode without ever sending plaintext shell commands over HTTP, WAF Attack Score should be used alongside explicit Base64 rules and JVM patching.

You can find more information on how to deploy Managed rules and attack score in our WAF guide, but in a nutshell:

1. Set the CVE-2026-114938 rule in the Cloudflare Managed Ruleset (Pro plan and above) to Block. It is enabled in Log mode by default, so review its matches in Security Events first. Use the links on the Cloudflare Zero Wire page to review your rules status.

2. Layer Attack Score to get ML-based remote code execution (RCE) detection: create a custom rule blocking or challenging requests with a low RCE attack score (for example, cf.waf.score.rce le 20 on Enterprise plans, or cf.waf.score.class eq “attack” on Business plans) to catch multi-stage exploit chains and post-exploitation command traffic.

3. Remediate at runtime: Upgrade to patched OpenJDK builds (or set -XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics as a temporary workaround) to eliminate the vulnerable AVX-512 code path entirely. Follow the OpenJDK advisory and Oracle’s Critical Patch Update and install your Java vendor’s fixed release as soon as possible. For a prompt you can give an AI agent to inventory your Java runtimes, see the Java4Shell page on Cloudflare Zero Wire. 

Impact on Cloudflare infrastructure

Cloudflare also runs Java, so when Java4Shell was disclosed we checked our own systems. The vulnerability can only be triggered in specific hardware configurations, namely a x86-64 processor that supports AVX-512 VBMI, so a system is exposed only when both are true. Our investigation found that the majority of our Java workloads are not scheduled on vulnerable systems; we took immediate action to protect the remainder.

About an hour after the patches were published, we began rolling out a JVM startup option that turns off the accelerated Base64 routine containing the bug on all Java workloads, so decoding falls back to the standard implementation. To be safe, we are rolling out our patched configuration to all machines, regardless of hardware as a precaution. We have seen no indication so far that Java4Shell was exploited on Cloudflare infrastructure.

Update every Java runtime now

Java4Shell turns a performance optimization in the Java runtime into a path to remote code execution, and with technical details now public, we expect exploit attempts to follow quickly. The fix is to update every Java runtime and restart the services that use it. While you patch, review the new managed rule’s matches and switch it to Block if you are on a paid plan and use attack score to catch remote code execution payloads that signatures may miss. 

Our WAF analysts will continue to update protections as new techniques emerge. Follow the WAF changelog for rule updates and the Java4Shell page on Cloudflare Zero Wire for the latest on this vulnerability.

Source:
https://blog.cloudflare.com/java4shell-waf-protection/

Adapting to AI penetration testing orchestrators: The Modern Security Model

Blake Darché, Myles Sloan, Jacob Crisp, and Cloudforce One

11 minute read

Over the last month, the number of Large Language Model (LLM) penetration testing and orchestration frameworks has exploded. Just a few weeks ago, ARTEX — an open source agentic penetration testing system that automates offensive security workflows — was the only framework available. In just the last three days, we have seen over 50 framework families attempt to scan Cloudflare customers globally. The number of Internet Protocol (IP) addresses seen running these frameworks has grown into the thousands and continues to increase daily. The proliferation of these frameworks has significantly changed the status quo in cyber defense: defenders are struggling to keep up with the volumetric nature of these autonomously guided attacks.

ARTEX was taken down by its creator Autumn-27 on October 8. (“The malicious exploitation of this tool runs entirely counter to its original intent,” they wrote in Chinese.) But in the month since, the ecosystem has exploded with new fragmented versions of it. There are now over 12,000 repositories, with several hundred unique forks containing lineage from the original repository. Additionally, hundreds of other similar agentic orchestration frameworks have been created since October 8. Daily requests of AI penetration testing (pentesting) and exploitation tools has grown by 30x since October 1. These tools have also begun chaining stolen customer credentials in some of the more complex attacks, such as lateral movement chaining throughout an environment.

Fork tree of ARTEX: 204 public repositories with their own code changes, grouped by type and sized by stars.

We expect these frameworks to continue to proliferate, and every organization should be prepared to address this threat. To counter LLM-based pentest frameworks, we recommend that all organizations adopt what we call the Modern Security Model, which has six key pillars:

  • Fortify the front gate: Implement a Web Application Firewall (WAF) with advanced rules such as rate limits.
  • Security station in the foyer: Anomaly detection on all web applications your customers access.
  • Identify phony visitors: Implement Bot Defense.
  • Remove the back door: Implement Identity-Gated Access for all high-risk external and internal web applications.
  • Inspect deliveries: Enforce validated schemas and explicit security controls.
  • Neighborhood watch: Implement Threat Intelligence to gain visibility into attacks.

What is an LLM penetration and exploitation orchestrator?

Open-source pentesting frameworks are able to orchestrate AI agents to carry out stages of the traditional Cyber Kill Chain at scale. Tools like ARTEX have the ability to quickly plug in existing Model Context Protocol (MCP) and connect traditional standalone pentesting tools in novel ways. Some even allow operator direction on what type of task to accomplish. These tools can map and enumerate environments, both from the inside and outside. ARTEX and its forks map assets and environments onto a graph, allowing multiple independent parallel agents to enumerate, verify, prototype, and attack at the speed of inference. These tools turn compromises into a hill-climbable problem, which agents are specifically good at.

The AI LLM pentesting tools that currently exist

We are currently tracking 50+ AI LLM agents. The table below shows the top five LLM penetration and exploitation orchestrators. Each is extremely popular (1k+ GitHub stars) and fully autonomous. The fully autonomous nature of these agents represents a doctrinal shift in offensive cyber capabilities:

  • Human skills are no longer the limit: A harness performs every step of the OODA loop by observing the environment, orienting itself to prioritize valuable and/or vulnerable targets, decide on an action, and act autonomously.
  • Speed increase: Having multiple parallel agents working towards a goal is a large shift compared to single operator or multiple operator augmented by AI.
  • Scale: A single operator can target multiple organizations at the same time, greatly increasing their blast radius.
  • Small mistakes are easily discovered: Autonomous frameworks relentlessly and systematically test exposed services, including their configurations.
ArchitecturePlanning modelBuilt-in capabilities/execution environmentPost-exploitation capabilities
ARTEX (and forks)Planner and parallel agentsGraph of goals, leads, and findings is linked to separate asset graph of targetDirectly on host or container with network/root access, can install/develop tools as neededNothing built-in, requires user instruction
LuaN1aoAgentSupervisor agent, planner agent, and generic executor agentsThree graphs, with goals/tasks/blockers, evidence/hypothesises/exploits, and target/localContainer with network/user access, can develop tools as needed and install user packagesBuilt-in SSH and Chisel for tunneling and attempted reconnection after disruption
DecepticonOrchestrator agent dispatching specialist sub-agentsGraph of objectives with prerequisitesKali container running as root, can develop tools as neededDedicated post-access, Active Directory and cloud pivoting skills
CairnDispatcher orchestrating work to existing AI harnesses (Codex, Claude Code, Pi)Graph of facts and leads; new nodes trigger dispatcherKali container with root access or directly on host, can develop tools as neededPrompt guidance and Kali tools
PentestGPT-AgentSupervisor agent and one generic executor agentTask list with dependencies, goals, and evidenceRun on host, can develop tools as neededNothing built-in, requires user instruction

Observations from the world’s largest network

As of November 12, ARTEX and its forks make up over 60% of currently known AI penetration testing orchestrators. The charts below help us understand how adoption of these tools has changed over the past six weeks. Since the removal of the original ARTEX repository on October 8, traffic has grown more than tenfold, and has increased more than 30x since October 1.


Trend in the volume of daily requests from a selected handful of AI-driven pentesting orchestrators


Daily trend in the number of unique IPs sending at least one request from any AI-driven pentesting orchestrator


Detailed breakdown of the share of attributed unique IPs observed during the last three complete days. IP shares are non-exclusive as a single IP can run multiple tools.


Daily trend in the number of unique instances of tracked AI-driven penetration testing orchestrator tools

As demonstrated above, the takedown of ARTEX on October 8 (and widespread reporting of it) likely caused a hydra effect, where the removal of the original repository led to a massive increase in the number of forks and modifications which can be seen in the steep acceleration of unique instances around October 8.

Identity-chained LLM exploitation

Over the last eight weeks, our Cloudforce One team has been called into multiple incident response investigations involving ARTEX and ARTEX-derived LLM exploitation frameworks. We’ve seen firsthand how exposed credentials are being chained with LLM-based exploitation frameworks to gain the upper hand over defenders.
We observed multiple incidents in which a threat actor gained initial access to a hyperscaler environment and pivoted directly into the customer’s Cloudflare environment. Root-cause analysis revealed a common credential hygiene failure. Attackers repeatedly compromised static, non-expiring tokens running inside CI/CD pipelines, which granted broad, cross-environment access across the organization’s hyperscaler infrastructure. LLM frameworks greatly expand the likelihood of a client’s API key being laterally leveraged to take over other tenant environments.

ARTEX in action

As part of one incident response investigation, our team observed ARTEX gaining access to a compromised account-level API token previously used for CI/CD with no IP restrictions or rate limiting. Available evidence indicated that the compromise most likely originated through a third-party hyperscaler.

We observed that a large number of new Worker scripts had been created with distinct names such as artex-*, artex-pgrecon-*, artex-pgw-*, and artex-do-*. The naming of each Worker script correlated to distinct behaviors and actions it was taking, and was often postfixed by an alphanumeric identifier. We observed activity in excess of 69 requests per minute across multiple unique parts of their Cloudflare infrastructure and 400 database dump requests in an hour. We also observed attempted persistence mechanisms and attempts to validate session tokens for other third-party applications. While we believe that much of this activity was lightly guided by the human operator, this is just one example of the speed and breadth that ARTEX and similar frameworks can achieve post-compromise.

Our recommendation: the Modern Security Model

Large Language Models increase the ability of a threat actor to rapidly iterate through the Cyber Kill Chain against a target. They do this by giving the actor the advantage of speed and validation. Each step of the Cyber Kill Chain can be validated and fed into the next stage of the attack. This level of orchestration is unparalleled and effectively vaporizes legacy cyber security models. A modern model must be used against these attacks.

To help explain this model further, let’s use the metaphor of protecting a house on an estate. Each section below outlines how to defend against the threat at each step.

Fortify the front gate: implement traffic control and a WAF with advanced rules

Before anyone even sets foot on your lawn, they have to reach the perimeter fence.

On an unprotected estate, an adversary can drive an endless fleet of decoy trucks straight into your driveway, completely blocking the entrance and smashing through the barriers (Layer 3/4 volumetric floods and direct IP probing).

With perimeter gate security in place, all incoming traffic is routed through massive, distributed outer gates miles away from the main house. Rogue delivery trucks are filtered out to the highway, rogue utility tunnels trying to wiretap your property are severed, and only legitimate foot traffic ever reaches your home address.

Network traffic control serves as an important role in stopping volumetric attacks.

A security station in the foyer: anomaly detection

Once visitors arrive at the main entry, they meet a strict security station at the foyer.

Automated prowlers don’t just kick the door; they disguise themselves. They attempt weird ways to get in the door — stuffing paper into the lock, trying variations like //front-door//back-room/ to trick the mechanism into swinging open.

The security guard at the door enforces clear rules:

  • You cannot knock 500 times in five seconds.
  • You cannot disguise your path with trickery.
  • You cannot attempt to roll a massive flatbed cart through the front hall to haul away the house’s internal blueprints (diagnostic heap dumps). Suspicious behavior is turned away immediately.
  • Implement security keys and hardware based FIDO keys.

Web Application Firewall (WAF) serves as a key defense mechanism in stopping application exploitation through rate limits and anomaly detection.

Identify phony visitors: implement Bot Defense

A sophisticated intruder rarely looks like a masked burglar; they disguise themselves as ordinary visitors. But automated agents, headless browser scrapers, and AI reconnaissance tools don’t act like real people.

They don’t blink, their posture is unnervingly rigid, their cadence is mechanical, and their “identification” is often a sloppy imitation of a real visitor badge.

Bot Defense and challenges act as behavioral specialists watching the crowd through one-way glass. It flags the unnatural cadence, catches the synthetic micro-behaviors, and quietly escorts the machines off the property before they can touch a single doorknob.

Remove the back door: implement Identity-Gated Access and micro-segmentation

Many homes historically were built with side doors or a cellar hatch (internal admin panels, /actuator diagnostic endpoints, and remote gateways). Even if locked, a prowler could stand on the sidewalk, shine a flashlight on the cellar door, and start picking the lock.

Zero Trust application access does something radical: it bricks up the doorway from the outside and restricts which rooms can be entered.

To anyone wandering the perimeter, the cellar door does not exist. There is no lock to pick, no handle to rattle, and no light on inside. The only way in is with an escort who checks your biometric badge, confirms your device has a clean bill of health, and steps you directly into the specific room you need — leaving the rest of the house out of view.

For those who do enter, you have to ensure they cannot breach rooms next to the room they enter. Micro-segmentation is a highly effective strategy at stopping lateral movement. It limits compromised credentials from breaching production, test, and development systems.

Inspect deliveries: enforce validated schemas and explicit security controls

You receive daily supply deliveries to your estate — groceries, mail, maintenance parts. In digital terms, this is your incoming API traffic, which must be inspected and verified.

Intruders often attempt to bypass controls by sending unvalidated payloads or forged delivery manifests meant for restricted internal systems.

The porch protocol mandates thorough inspection and schema validation for all traffic:

  • Every incoming request must undergo OpenAPI schema validation to ensure it strictly conforms to expected definitions and structures.
  • Drivers and couriers must present validated mutual TLS (mTLS) certificates to establish trusted, authenticated connections.
  • Any request failing inspection or missing valid credentials is rejected immediately at the boundary.
  • Default-Deny Posture: Every positive security implementation ends with an explicit deny-all rule at the bottom of the ruleset.

Neighborhood watch: implement threat intelligence to gain visibility into attacks

Even with ironclad walls, an isolated property can be vulnerable if a syndicate invents a brand-new infiltration technique across town.

Threat intelligence acts as your warning network with neighboring estates. When a rogue actor sets up a new command-and-control safehouse down the road or begins deploying dynamic tunneling vans in your district, you receive an early dossier. Your estate updates its watchlists, recalibrates its sensors, and slams the gate shut before the actor ever turns onto your street.

How to get real-time help

ARTEX and similar LLM-based frameworks pose a significant challenge to legacy cyber defense models. Even the historical defense-in-depth model — which emphasizes a classic network DMZ — falls short in today’s complex architectures. Tomorrow’s attacks will only advance as orchestration tools become the new normal.

Securing legacy equipment and on-premises devices requires an identity-gated approach that logically makes these devices impossible to reach on the Internet. Beyond identity, slowing or making lateral movement more noisy is the goal of micro-segmentation. This architecture emphasizes a containment-first approach to security, which is essential when users are consistently losing their keys. When combined, the elements of the Modern Security Model are the answer to this vexing problem.

If you are facing an active security incident and need the Cloudforce One team on the ground to help respond to the incident or require threat intelligence support, please contact us immediately. If you need help implementing the Modern Security Model outlined here, please contact our Solutions Engineering team.

Source:
https://blog.cloudflare.com/adapting-to-ai-penetration-testing-orchestrators/

Agents aren’t humans (but they kinda are)

Bryan Becker

15 minute read

AI Agents now act on the web for millions of people. To a Site, an Agent can take many forms. It may be indistinguishable from a human user carrying out a task, or it might look like one visitor carrying many Users. This removes the ability for the Site to recognize, serve, and hold accountable the user or users behind the Agent, and causes the Site to face the costs when something goes wrong. This post argues that in order for Sites to maximize the access they provide to Agents, the ecosystem must develop new mechanisms to preserve the relationship between Sites and Users. Traditionally, in Security and Fraud Prevention, that requires three things: Identity, Reputation, and Accountability, allowing Sites to answer: Is the person acting being truthful about who they are? Is that person trustworthy? And who answers for the action?

“Personal AI Agents” (“Agents” for short) are automations that take instructions from a human (“User”) and pursue a goal by controlling a cloud computer or browser. They are usually hosted and maintained by an “Operator” as part of a managed service or consumer offering. Examples include Muse from Meta and dots from OpenAI, and more are launching all the time. Agents can potentially take any action online that their User could, without the limits that hold humans back. They don’t tire, they run around the clock, they act in parallel, and they put up with friction no person would. Much of the web, from how Sites plan capacity to how they make money, assumes those limits.

Fundamentally, remotely hosted Agents are intermediaries. An intermediary is anything that sits between a User and a Site, so the Site sees it instead of the User. Agents are the newest kind of intermediary, but intermediaries have existed for a long time. Cloud browsers (hosted browsers that software controls on a User’s behalf) and Proxies (services that relay a User’s traffic, including VPNs) are intermediaries too. What has changed is the trajectory. Agentic traffic is growing rapidly and may eclipse traditional human browsing on the Internet in the near future. This forces a reckoning for anyone operating a Site today. Historically, a Site could simply block intermediary traffic and require Users to disable the intermediary service. That stops working when the majority of traffic is agentic. Once blocking is no longer viable, Site Operators are left with the problem that intermediaries have always created. The Site loses direct information about the User and must decide whether to trust the intermediary without it. 

This post covers Agents hosted somewhere other than the User’s device. Local agents (e.g. OpenClaw) or Agents running in the User’s own browser, on their own device, are out of scope of the primary topic addressed by this post (see below, “On open source and local Agents”).

Without Agents, the User interacts with the Site directly.

With Agents, the Site sees the Agent, not the User, and one Agent acts for many Users.

Sometimes several intermediaries sit between the User and the Site.

This post rests on one principle:

The Intermediation Principle: The business relationship between Users and Sites, and each participant’s security responsibilities, must be upheld regardless of intermediation.

A Site needs new tools to recognize, serve, and hold accountable a User acting through an Agent just as it could if that User had visited directly. The Agent, and the Operator behind it, must be recognizable and accountable too, because an Agent can do what no User could. Agents are able to scale human access almost without limit, so they create new risks, even for behavior that was previously benign.

Copy linkThe intermediary problem

Meet Ezra. Ezra works as a personal assistant for people in her city. Her best client is Amy, a local CEO, but she also works for Bob, Charlie, and Debra. She runs their errands: groceries, appointments, paperwork, and flights. Ezra blends into the crowd.

The corner grocer used to know Amy. He knew what she bought and set aside what he thought she’d like. Now only Ezra comes in, carrying orders for four people, and the grocer can’t tell whose preferences are whose. He doesn’t want to turn Ezra away, because she brings him a lot of business.

Then Bob asks Ezra to buy him an iPhone. A week later he calls the store, says he never authorized the charge, and keeps the phone. To win the dispute, the store has to prove Bob asked for it. But the only person the store ever saw was Ezra.

Then Charlie gives Ezra a list of passwords: “I forgot mine, but it’s one of these.” Ezra patiently tries each one at Charlie’s bank. The bank can see an attack happening, but the only person it can ban is Ezra. Banning Ezra also bans Amy, Bob, and Debra.

None of these business owners has a problem with Ezra herself. Their problem is that they can only see Ezra, not the person she’s acting for. Swap Ezra for an AI Agent and the businesses for websites, and you have the web today.

A website owner wants sufficient visibility both to prevent bad behavior and to effectively monetize or get value from their Site. But as with Ezra, much of that visibility goes away with AI Agents. Below is a list of actions that a website owner might want to address that were previously solved, but are made more challenging by allowing Agents.

ChallengeWebsite owner’s goal
Account sharingSites need to ensure that one paid subscription is not being abused to serve many Users. The Site sees one account and one client when accessed via an Agent.
Compliance and illegal activityA Site must meet legal requirements to verify information about its Users. For example, some Sites have age or geographic restrictions.Agents do not provide guarantees that can meet the bar for Sites to remain compliant, if they allow Agent access.
Friendly fraudFriendly fraud is when the User approves an Agent’s purchase, then disputes it as unauthorized. Sites may win with circumstantial evidence: the same device, IP, and address as the User’s past undisputed purchases. Agent purchases come from the Agent’s infrastructure, so that evidence doesn’t exist. Even when the Site wins, the dispute itself costs money.Sites need to maintain records of checkout behavior for fraud prevention purposes. Maintaining these records helps Sites reduce overall friction from additional verification, and results in a lower transaction decline rate, and overall greater number of checkouts.
Human verification is irrelevantA Site wants to be able to distinguish the type of Users it has. CAPTCHAs and other human verification check whether the entity controlling the browser is a human or not.Agents are never expected to be humans. Solutions that pass this signal through to the human User add no new information and just make Agents less efficient.
Identity spoofingA Site wants to limit access to content to human Users or impose restrictions on what particular Users can access. Agents often run on residential IPs and use real Browsers, are mixed with human-directed traffic, and take efforts to not distinguish themselves from human traffic. Attackers copy a well-known Agent’s user agent string to get the same allowances.
Identity verification breaksA Site may require additional verification of the User’s identity, or other information, in order to provide access to sensitive operations or content. Liveness checks, KYC ID checks, and similar assume the person present is the person being verified. The Agent is never that human. The Site has to accept verification passed through by the Agent (which weakens the check), reject Agents, or drop the check.
MisalignmentSites may want to protect themselves from erroneous actions taken by newer or more experimental Agents.Agents make mistakes: the wrong item, the wrong date, duplicate orders. Sites may absorb the cost through refunds and support to keep customer goodwill, with no way to tell which Agents are reliable.
Policy circumventionThe Site is looking to impose a policy (e.g. block, allow only partners, rate limit) that is based on identity, but Agents don’t always identify themselves, and they often don’t bring information about the User they act for.
Resource exhaustionSites that provide free services or that rely on User engagement were often designed with an assumed limit on User behavior.Agents poll constantly (e.g. stock and price checks), hit expensive endpoints (e.g. search, inventory, or support chat), and use up free trials and promotions.
Risk-based authentication breaksA Site wants to maintain its risk-based authentication system, which expects the device, location, and behavior to match the User. Agents run on cloud infrastructure and look unusual every time.
Traffic comminglingSites would like to protect themselves and User accounts from abuse or fraudulent activity. When one User abuses a shared Agent for credential stuffing, scraping, or card testing, the Site can detect the abuse but can only block the Agent, which also blocks all of its legitimate Users.
Unauthorized card usersSites and payment providers need to protect cardholders from unauthorized transactions, while minimizing dispute costs and other costs related to fraud.When an authorized User makes a purchase on a card, the cardholder is responsible. If the cardholder hands the card to someone who isn’t an authorized user, they’re still responsible for having handed it over. Agents have no authorized-user status, so the Site can’t tell whether the User stands behind this purchase. In practice, when the User disputes it, the Site pays.
Uncompensated consumptionSites that monetize content require visibility and control over who accesses that content in order to apply the correct monetization model.The Agent reads or extracts content (articles, product data, reviews) to answer the User somewhere else. The Site pays to serve it and gets no visit, ad impression, or purchase.
User attributionSites offer additional capabilities to consenting Users regarding personalization, recommendations, and loyalty programs, using analytics tied to the User’s session and device. Agent traffic either groups many Users into one client or shows up without the User’s session at all.

In nearly every challenge above, the Site bears the primary cost. That outcome follows from how trust works when an intermediary is involved.

Copy linkOur vision

Our aim is an Internet where all Users have equal or greater access to websites than they had before. Before Agents, a Site was typically able to mitigate these risks with a collection of techniques, including fingerprinting the User’s device, session, and history. Users could still browse using private browsing mode, and we believe Agents should be able to do that as well. But they probably won’t be able to log in to a bank without additional verification.

None of this requires an Agent to act like a human or a human to be present for every action. It requires that Sites have the means to obtain or require information about the User to hold them accountable, when applicable, with or without an Agent.

Copy linkWhat people have tried, and why they fall short

A common proposal is for Agents to pass a Site’s CAPTCHA through to the User to solve. That proves some human is present at that moment (“human in the loop”, or HITL), and nothing more. HITL is primarily a mechanism to prevent mistakes from misalignment. Misalignment is an issue between the Operator and the User, and resolving it does not resolve the majority of the problems above. For example, it can’t tell Bob from anyone else (Traffic commingling), and it says nothing about who the Agent acts for the rest of the time. Additionally, Agents exist to remove friction, and HITL adds back that friction, so Operators are incentivized to remove or bypass it for the User.

Another common proposal is to use tightly scoped access controls. Agents are built to do anything a User could, so in practice they ask for, and get, permission to do everything. A scope of “everything” tells the Site nothing. And even a narrow scope only says what the Agent was allowed to do. It doesn’t say who answers when the Agent gets it wrong, which is the question the Site actually needs answered.

Copy linkWhat the web needs

The web needs tools and protocols that allow Sites and Agents to collaborate to determine what behaviors and actions are allowed, as well as express preferences and policies from Sites to Agents, all in a way that can be reasonably supported by all Sites and Agents. Fortunately, work is already underway along all of these fronts, and many, if not all, of these can be addressed by applying existing standards.

Copy linkProtocols

Agents and Sites can engage in explicit protocols for solving some of the problems above. For instance, MOLE is one upcoming approach that aims for rate limiting without User-specific identifiers, allowing Sites to transition away from implicit identities and towards explicit protocols for accomplishing the same goal. This is similar to the x402 protocol, which aims to enable payments on the web while remaining privacy-preserving. We are actively exploring ways in which we can leverage existing protocols for addressing other problems, as well as exploring designing new protocols when existing solutions fall short.

Copy linkIdentities

When discussing Agent Identity, Web Bot Auth (WBA) is our preferred method. WBA allows an Agent to sign its requests, which provides a secure way for an Agent to identify itself (and, implicitly, the Operator). We must still define a mechanism that supports multiple intermediaries: when Agent A uses Agent B inside Browser C, the Site needs to be able to know this, so that the Site can correctly ensure that access by Agent A is correctly understood and controlled, for example, in order to prevent Policy circumvention.

Other types of identifying information, such as session, account, or even User-specific IDs, might be necessary, depending on the context. We are working with the relevant standards to explore ways to communicate such identifying information.

Let’s take a look into types of Identity in regards to a User. Ultimately, Identity is a spectrum that trades various degrees of information about a user, while ideally practicing principles of data minimization. Identity provides us a mechanism to answer “who are you?” in pursuit of answering the follow-up questions of: “are you who you say you are?” and “can we trust you?”.

In many cases, identifying information isn’t needed, and privacy-preserving methods for moderating access to agents, such as through Privacy Pass and MOLE, can help us answer “can we trust you?” without needing to answer “who are you?”. Private Access Tokens was one early way in which we tried to establish trust without identifying the user, and MOLE is intended to be the successor to this technology. However, there are cases where graduated forms of disclosure along this spectrum would be needed, and you can generally characterize them in the following ways:

  1. Nothing – Users may act on the internet while bringing no identifiers to the table.
  2. Session – Sites require some way of linking requests in the same session to a single agent. This allows the Site to establish reputation for a given session and act on it accordingly. For example, Poppy has a notion of a session ID for exactly this purpose. 
  3. Account – Sites require a way of attributing requests to the same User across sessions. This might be a stable identifier assigned by an Operator or third party to a User that persists across the account with the Operator, such as a single Agent visiting the same Site every day using the same identifier. An example use case this would enable is: “Bind your Site account to your Agent account”.
  4. Unique – Some Sites might require a unique, per-User identifier provisioned by a third party that persists across Operators, accounts, Agents, and sessions. This may be useful for high risk actions, or for Sites that need to provide limited access to an expensive resource or that have very restrictive obligations or compliance requirements. Government IDs, third party identity verification, and decentralized technologies like Proof of Human are all examples of technologies that can provide this.

Ultimately, Sites determine what information they need for clients to answer “is the entity behind this request allowed to do this action at this time?” In many cases, protocols already exist, or are being developed, to convey this information: WBA for conveying an Agent’s platform identity, MOLE for conveying User reputation, OAuth for conveying account identities, and so on.

Copy linkClaims

Beyond identities, some actions require a fact about the real person, such as being over 18 or being the cardholder (Identity verification breaks, Friendly fraud). Often the Operator verified this at sign-up or a third party already has this information. 

In order to allow Agents access to Sites or actions with these kinds of restrictions, we need mechanisms for Sites to request this information, and for Operators or third parties to provide this information.

Copy linkSite Agent access policy

Today, an Agent infers a Site’s rules by trying something and interpreting the Site response (usually, whether it gets blocked). That wastes resources on both sides, and in some cases makes honest Agents appear to be malicious. Robots.txt says where a crawler may go, but isn’t fully suited to express what Agents may do.

Sites need a machine-readable way to publish what actions Agents are allowed to do. The Internet Engineering Task Force (IETF) is actively working on some preference expression mechanisms for this, primarily in the AI Preferences Working Group. However, the focus of the group is on expressing preferences for use (such as training, inference, and search), and there is still not a group focused on the larger need for preference expression mechanisms discussed here.

Copy linkOn open source and local Agents

Agents that are not run as an “Intermediary” (e.g. on-device Agents, or locally hosted Agents such as OpenClaw) raise different concerns. Primarily, they look like (and are) automation, and they have no single party to build reputation or hold accountability with.

There are many solutions to this, one of which is to ask these Agents to provide a Unique ID. However, addressing this is not the initial focus of Trusted Agent Delegation.

Copy linkWhat’s next

Real-world solutions to the problems that Sites face won’t emerge from fragmented, vendor-specific mechanisms. They require open, interoperable standards that are rooted in real world experience. We have been, and continue to actively collaborate across the ecosystem, with major Operators, identity verification companies, payment providers, merchants, publishers, proxy providers, and cloud browsing companies, to align operational requirements directly with active work on these problems in the IETF and elsewhere 

Our focus is on bridging the gap between running code and emerging specifications across working groups and activities like Web Bot Auth, AIPREFs, OAuth, WIMSE, and MOLE. We are doing this, in part, by co-authoring and refining open protocols like WBA and MOLE and building and deploying implementations of these protocols at scale.

We are also announcing the Trusted Agent Delegation (TAD) coalition. The goal of TAD is to bring a group of representatives across the ecosystem to have discussions on the overall problem set that was put forth in this document, examine all existing protocols, and then to bring more well-defined problems or problems to the IETF to work through, as needed. We intend to hold side meetings at the IETF and workshops in the future to facilitate discussion.

If you are building agents, agent runtimes, running an edge or cloud platform, or managing commercial or compliance applications or infrastructure, we need you to get involved in these efforts too. Check out this page for more information on how to participate.

Copy linkWhat you can do today

An open, interoperable foundation  is where we’re headed, starting with TAD. But you don’t have to wait for new protocols to start regaining visibility and control. As of this week, Cloudflare customers can take three concrete steps:

See which Agents are on your site, and what they’re doing. Security Analytics now breaks out Personal Assistants as their own traffic category, and a new widget lists every Agent visiting your site, how many requests each one sends, the paths it hits, and the errors it runs into. Unexplained automated traffic becomes traffic you can reason about. And for the broader picture of AI crawlers and bots affect your business, including how much each Operator crawls versus the traffic it sends back, Enterprise Bot Management customers can use Business Insights.

Set access on your terms, per Agent. Using AI Crawler and Agent access policies, you can welcome the Agents that bring you business and restrict the ones that don’t — allow an Agent across your site, block it only on pages with ads, or block it entirely. Your Search and Training policies stay independent.

Tie an Agent back to the user it acts for — and act on it. For sites using Account Abuse Protection (early access), every login and sign-up now shows whether a personal Agent made the request, and which one. When an attacker abuses a shared Agent on one account, you can mitigate that account — with a WAF rule on its Hashed User ID — without blocking the Agent for every other legitimate user behind it. This is a first, concrete answer to the Traffic commingling challenge described above: you can finally see past the Agent to the User, and respond accordingly.

These are the first building blocks of the vision, already in production. More will follow as the standards mature.

And if your company has a more restrictive position on Agents, we would love to hear it. Reach out and share your problems with us directly. We are looking to help build an Internet where site owners have visibility and control, but also where Agents have the maximum access that is reasonable within those controls. You can reach out to your Customer Support team, or email us at crawlercontrols@cloudflare.com.

Source:
https://blog.cloudflare.com/trusted-agent-delegation/

See the agents, set the terms: New visibility and control for personal agents

Marina Elmore and Nicole Justus

5 minute read

Personal agents are the intermediary between humans and the Internet, turning a person’s instructions into requests and actions on websites. A customer might ask a personal agent to compare products across your site, find support articles, or complete a purchase. To a site owner, all three interactions show up as automated traffic — and without a clear view of which agents are visiting and what they are doing, it can be difficult to know whether that traffic is helping your business or creating risk. Blocking agents altogether can feel like the safest choice, but it can mean losing customers. Better visibility into agent activity allows you to decide what access makes sense for your site.

Today, we’re launching new analytics to help you understand how personal agents access your site on behalf of humans, along with more granular access policies to put those decisions into practice. Together, they let you welcome agents on your own terms, and in ways that support your business.

See how agents access your site

Knowing which agent is behind a request turns unexplained automated traffic into traffic you can act on with confidence. Cloudflare maintains the largest verified bot directory in the world, and we are now bringing that intelligence into your traffic details. In Security Analytics, the Bot Analysis chart now shows Personal Assistants as a new category, next to Verified Bot, Likely Human, Likely Automated, and Automated. Security teams can select it to see only personal agent traffic over time.

Personal assistant traffic in Security Analytics › Bot analysis

In Top statistics, a new Personal Assistants widget lists which agents are visiting your site and how many requests each one sends. Filter on one agent and every other widget updates to show only its traffic details: the paths it requests, the status codes it receives, and the networks it comes from. At a glance, you can see whether an agent is logging in, reading your product pages, reaching your checkout, or hitting errors on pages it cannot use.

The new Personal Assistants widget shows which agents visit your site and how many requests each sends.

For sites that protect user accounts with Account Abuse Protection (currently in early access), site owners and fraud teams are able to see which user each agent represents. The population overview page shows which personal agents are active across your users and how many accounts use them, so you can determine whether agent traffic is a meaningful part of your business. Every login and sign-up event now shows whether a personal agent made the request, and which one. Fraud teams can filter accounts by AI assistant events or number of AI assistants.

Personal assistants active across your users, alongside total login and sign-up activity

Additionally, each user’s account overview shows the agents acting for that account. A fraud analyst investigating an unusual login can tell whether it came from an agent the customer has relied on for weeks, or from an agent that appeared for the first time today and needs a closer look. If it looks like an attacker is using an agent on an account, fraud analysts can mitigate that account directly, with a WAF rule on its Hashed User ID, without blocking the agent for everyone else who relies on it.

Personal assistants associated with a specific account, with the ability to filter by a specific assistant

Together, these views give you a clearer basis for deciding which personal agents to welcome, limit, or block.

Set access policies that reflect your preferences

We introduced AI bot policies this summer so site owners could make separate access control choices for AI bots used for Search, Training, and Agent behaviors. Now we’re expanding the existing Agents policy to include granular control options for supported personal agents. To reflect this broader scope, we’re renaming the setting AI Crawler and Agent access policies.

In Security Settings, you can set an overall Agents policy, then choose a different policy for each supported personal agent: Allow (do not block), Block on pages with ads, or Block. For example, you can set the overall Agents policy to Block on pages with ads, then choose Allow (do not block) for a supported personal agent you want to welcome. Your existing Search and Training policies stay as they are.

The AI Crawler and Agent access policies section has a new name, and now shows options to allow or block personal agents.

You can also make these choices when you add a new zone to Cloudflare. During onboarding, we ask whether you monetize pages with ads and then tailor the recommended policies to your answer. You can always revisit your access controls later in Security Settings.

The right policy depends on your site. One publisher may allow a supported personal agent throughout its site so readers can find its articles, while another may block that same agent on pages where ads support the content. Both publishers are choosing the access control that works for their business.

Agent identity is only part of the story

The analytics and policies we’re launching today give site owners visibility into personal agent activity and control over their access. Our next goal is to help site owners preserve the context of their relationships with users when personal agents act as intermediaries. A site may recognize the agent making a request but lack information it would otherwise have about the user: whether they are an existing customer, what they authorized the agent to do, whether they have a subscription, or which protections should apply.

Reaching that goal will require privacy-aware ways to (1) carry user context through an agent, (2) help sites assess reputation, and (3) establish clear accountability when something goes wrong. We’ll be sharing more as we work with agent operators and others across the ecosystem, so site owners can choose whether to grant agents greater access while continuing to build relationships with their users.

Copy linkMake the choice for your site

That person asking a personal agent to compare products, find support, or complete a purchase is still a customer trying to reach your business. Review how personal agents are accessing your site, then visit Security Settings → AI Crawler and Agent access policies to set the terms that work for your site.

Source:
https://blog.cloudflare.com/personal-agents-visibility-control/

Introducing Zero Wire, a hub for investigating critical Internet vulnerabilities


Daniele Molteni
 and Celso Martinho

8 minute read

You run security at your organization. It’s 7:00 am, and you’re having breakfast. You receive a ping: a new critical vulnerability has been disclosed. Your team scrambles to compare vendor advisories, read technical research, check which systems run the affected software, and answer familiar questions from the business: are we affected, and what are we doing about it? Another disclosure arrives before that work is finished.

AI is changing both the volume and speed of critical vulnerability discovery. It can analyze large codebases at scale and surface deeply nested flaws that may have existed for years without being found through human review. That discovery momentum will put more pressure on security teams to understand the impact of each disclosure on their infrastructure.

To help security teams prepare, today we’re introducing Zero Wire: a public vulnerability intelligence feed on Cloudflare Radar, bringing the clarity of a news wire service to critical security developments. It helps security leaders and practitioners understand significant vulnerabilities and decide what to do next.

Copy linkHow it works

Zero Wire lives inside Cloudflare Radar under the security section.

Each briefing brings together a plain-language explanation of the vulnerability, who should investigate it, recommended actions, and links to the evidence and vendor guidance. The format is deliberately simple: an index card with what you need to know, without the drama. A CISO should be able to understand the issue quickly and ask the right questions. An engineer should be able to follow the same briefing to the technical guidance needed to investigate and remediate it.

We also offer a pre-compiled prompt you can use with your agent to assess the impact on your infrastructure. Cloudflare contributes security research, observations from our network, and practical knowledge of the controls that can help reduce exposure. The information is useful whether or not you are a Cloudflare customer. 

Zero Wire brings that context together with authoritative external sources, giving readers a starting point for assessment and a place to return as an issue develops.

Our focus

Rather than a catalog of every CVE, Zero Wire complements vendor advisories and vulnerability databases, linking readers to the evidence and technical guidance needed to act. Zero Wire focuses on critical CVEs in Internet-facing software, such as vulnerabilities in web applications, the runtimes and libraries they depend on, and services exposed to the Internet, where a proxy can help mitigate exploitation.

We select significant issues that security teams need to understand and assess. Each briefing explains the potential impact, which deployments should be investigated, what is known about exploitation, and the available mitigation and patching guidance. A vulnerability’s severity and evidence of active exploitation are distinct: readers need both to make informed decisions.

A dedicated Cloudflare protection, such as Web Application Firewall (WAF) rules, is not a prerequisite for inclusion. Some issues require vendor updates or changes beyond the traffic Cloudflare can inspect. Where Cloudflare controls can help, we explain their scope and configuration requirements.

A walk through Zero Wire

Start on the Zero Wire homepage. Each card introduces an issue, identifies associated CVEs where applicable, and summarizes why it matters and what to do. You can search for a published briefing using a CVE or issue name, and follow technology tags to related entries. One briefing can cover several related CVEs when understanding them together makes the response clearer.

Find what needs attention

The homepage separates briefings into two categories. “Needs attention” brings together issues requiring active assessment or action, including those with known exploitation or developing guidance. “Reference” keeps briefings available when guidance has stabilized. Moving to “Reference” does not mean every affected system has been patched: an older vulnerability can still matter to an organization that has not completed remediation.

The status and last-checked date help you interpret each card. Known exploitation, an ongoing investigation, and an available vendor fix describe different things. Read them alongside the briefing’s evidence rather than treating them as a verdict on your own environment.

Understand what happened and who should investigate

When you open a briefing, the overview tells you what happened, why it deserves attention, and which teams should investigate. The explanation connects the technical issue to its practical consequences, such as service disruption or risk of data exposure.

For example, the recent php2shell vulnerability concerns flaws in the PHP runtime. That distinction matters for teams running applications such as WordPress or Magento: updating application code or a plugin alone does not repair the underlying runtime. The briefing helps readers identify the right system owners and directs them to the PHP security guidance for affected versions and remediation.

Turn the briefing into an action plan

What to do now gives your team a short set of next steps. Depending on the issue, that can mean identifying affected deployments, checking versions with a hosting provider, applying vendor updates, reviewing suspicious activity, or keeping compensating controls in place while patching.

The purpose is to make the next conversation concrete. For a PHP deployment, ask which runtime is actually running, whether the vendor’s fix has been applied, and who owns the update. Follow the linked vendor advisory for detailed applicability and remediation instructions, which can change as the investigation develops.

Assess your exposure with an AI agent

In this section, we share a prompt that can be used with your AI agent to quickly assess the impact on your infrastructure. The prompt asks for a read-only assessment of deployed software, relevant vendor fixes, exposure, and compensating controls, with per-asset evidence, unknowns, and next actions. It helps your team investigate its own environment; copying the prompt does not itself scan or change systems.

Check the evidence and follow what changed

To help you learn more about the vulnerability, each briefing links to external documents such as CVE records, research, and relevant exploitation evidence, including CISA’s Known Exploited Vulnerabilities Catalog. These sources answer different questions. A vendor advisory establishes affected versions and remediation guidance. An exploitation report provides evidence of attacker activity. 

If applicable to a briefing, Cloudflare can add context about traffic seen on our network, for example by showing traffic matching WAF rules that indicates exploitation attempts. Those distinctions matter. Observing an attack attempt does not establish that a particular organization was compromised. Equally, a lack of observed attempts on Cloudflare’s network does not establish that exploitation is absent elsewhere. Briefings distinguish what the sources establish from what remains unknown.

Where available, charts add context to that evidence. The php2shell briefing shows the volume of HTTP requests matching Cloudflare WAF managed rules over time. Note that requests matching these rules are not a count of compromised systems or successful exploits; the chart aims at providing practitioners a sense of what the focus level is by threat actors on a particular vulnerability.

Finally, update chronology records important developments, such as new advisories or changes to the evidence and response guidance. Together with the last-checked date, it helps returning readers understand what has changed since their previous visit.

Understand Cloudflare’s role

The Cloudflare section provides links to whether we offer compensating controls or provide a way to mitigate the vulnerability impact on your infrastructure. 

If a particular CVE can be addressed with a WAF rule, the briefing reports its availability and essential configuration requirements. When applicable, paid Plans and free Plans links take customers to the relevant dashboard configuration. The next step is explicit: “Review your WAF configuration to determine whether you are protected”. A link allows you to review your security posture, it does not automatically enable a rule or verify a deployment.

Note that a WAF mitigation is a compensating control for the traffic it covers, it is not a replacement for fixing vulnerable software. Blocking the requests can prevent exposed data from reaching an attacker, but it cannot undo actions already performed at the origin. The security teams should always follow the vendor remediation guidance.

Stay informed with Zero Wire

A useful vulnerability briefing should leave you with a clearer understanding of the issue and a concrete next step. Day Zero brings those essentials together: what happened, who should investigate, what to do now, and where to find the evidence.

Visit Zero Wire vulnerability intelligence, share the relevant briefings with the teams responsible for your systems, and return for new entries and updates. When the next disclosure arrives, we want you to spend less time assembling the basic facts and more time acting on them.

Follow Cloudflare Radar on X @CloudflareRadar and Bluesky @radar.cloudflare.com for updates.

Source:
https://blog.cloudflare.com/zero-wire/

How we halved DNS build delay and cut memory use by 85%

Alex Fattouche

18 minute read

When I last wrote about our DNS propagation pipeline in 2022, the Zone Builder received about 250 DNS record changes per second. Today it receives about 700, nearly three times as many, plus about 100 other events, such as zone setting changes. However, the number of events was never the real problem. The problem was the kind of work some of those events needed, and how that work grows with the size of a zone. Some zones now hold more than 20 million records, and we expect them to keep growing toward hundreds of millions.

Each event starts a clock that measures how long it takes us to turn that change into data our authoritative DNS servers can use. We call that work a build. A build reads the current database state, converts it into the format used at the edge, and writes any changes to Quicksilver.

In 2022, per-record builds were 150 times faster than full builds on average. On a test zone with one million records, per-record builds were 4,250 times faster. We ended that post with the obvious next step: do the same thing for zone settings.

Why doesn’t the Zone Builder just rebuild the setting that changed?

It should, and that is where we ended up. However, proving when it was safe took most of the work. A record event identifies what changed. A zone event can come from many Cloudflare products, may not say why the zone changed, and can alter data shared by several zones with the same name. Choosing too much work wastes capacity. Choosing too little can leave stale or incorrect DNS data at the edge.

We built a targeted build planner that chooses the smallest build we can prove is safe, and a new scheduler that combines work for the same zone. Zone setting changes no longer rebuild zones with tens of millions of records. Together, they cut peak memory by 85%, and the extra headroom let us safely shorten waits the pipeline has always needed for resilience, halving the time from a DNS change to its data being written to Quicksilver.

How DNS changes reach the edge

A DNS zone is the collection of records and settings for a domain. Cloudflare uses a multi-stage pipeline to turn a change to that zone into data available across our global network.

  1. A customer changes a DNS record through the DNS Records API or dashboard, or another Cloudflare service changes a zone setting.
  2. The change is stored in a database.
  3. The database change or another system produces a Kafka event.
  4. The DNS Kafka Aggregator combines events from several Kafka topics and sends them to the Zone Builder.
  5. The Zone Builder reads the required zone data and converts it into keys understood by our authoritative DNS servers.
  6. The Zone Builder compares those keys with Quicksilver, our distributed key-value store. It writes only what changed, and Quicksilver propagates those changes across Cloudflare’s network.

Diagram of the DNS propagation pipeline: the DNS Records API, zone settings, and internal services write to databases or Kafka topics, the DNS Kafka Aggregator combines them, and the DNS Zone Builder writes to Quicksilver.

This is a simplified view. The Zone Builder does not copy database rows directly to the edge. It combines records with zone settings, applies DNS serving rules, and organizes the result so our authoritative DNS servers can read it quickly.

Why full builds stopped scaling

The original Zone Builder had one useful property: it did not need to know why a zone changed. It rebuilt the desired state from the current database state.

  1. Read the current zone and its settings.
  2. Read every DNS record in the zone.
  3. Convert those records into Quicksilver keys.
  4. Compare the new keys with those already stored.
  5. Remove stale keys, write changed keys, and update zone metadata.

The final write contains only changed keys. However, a full build still reads, encodes, and compares every record, and holds the whole zone in memory while it does so. That is cheap for a small zone. For our largest zones, with tens of millions of records, the zone does not fit in memory at all. I explain how we handle that below.

Zone settings made targeting harder. Universal SSL is one example. Enabling or disabling it updates metadata and can change Certification Authority Authorization (CAA) records at the zone apex, the bare domain, such as example.com. CAA records tell certificate authorities whether they may issue a certificate for the domain.

A full build only needed to know that the zone changed. A targeted build must answer three questions:

  1. Which DNS names can change?
  2. Can shared metadata or the list of published zones change?
  3. What previous state must be removed from Quicksilver?

Answering those questions safely meant solving five problems, which the rest of this post covers in order:

  1. Events had to say what changed.
  2. Each change had to map to the smallest build that is still correct.
  3. Builds had to account for data shared by every zone with the same name.
  4. The database could change between the event and the build.
  5. Combining work could not lose a Kafka message.

Making events say what changed

We changed the event producer to include changed zone fields and settings, with previous and new values when available. We then traced each setting through the code that generates DNS output and classified what it could affect.

Not every event was that specific. Some database functions only update a timestamp to say, in effect, “something about this zone changed.” Sometimes that is harmless bookkeeping. Sometimes it means data changed elsewhere and must be read again.

Those cases look identical in the event. Until we can identify the caller and its purpose, a timestamp-only update still causes a full build. The same rule applies to missing details, unknown events, or any change that may affect records anywhere in the zone. The planner never turns uncertainty into less work.

Choosing the smallest safe build

Quicksilver output has two parts that matter here. Record keys contain the DNS answers for one zone and name. A smaller shared metadata key tells our authoritative DNS servers how to use that zone, including where to find special records such as nameservers and wildcards. Some events change only record keys; others must update both.

With that distinction, the planner can choose one of five build types:

  1. Resources only: Rebuild the records at specific DNS names, which we call resources, without changing zone metadata. Ordinary A, AAAA, TXT, and CNAME changes usually take this path.
  2. Resources and metadata: Rebuild specific names and shared metadata. Nameserver and wildcard changes use this path.
  3. Apex and metadata: Rebuild the zone apex and metadata. Settings such as Universal SSL can use this path.
  4. Purge: Remove a zone that should no longer be published.
  5. Full zone: Rebuild every record when smaller work cannot be proven safe.

The rule is simple: every key a targeted build writes must be byte-for-byte identical to what a full build would write. If we cannot prove that, we do a full build.

Removing old state works as it did for per-record builds in 2022. Record events include deleted records and the previous version of updated ones. The Zone Builder then scans Quicksilver for the existing keys under each name it rebuilds, removing any that the new build did not write.

Full builds remain necessary when a change can affect records anywhere in the zone or when a zone may need to be published for the first time.

There is one deliberate exception. A full build holds every record from the database and every existing Quicksilver key for the zone in memory at once, and our largest zones do not fit. Above a fixed record-count threshold, the Zone Builder never escalates to a full build. It rebuilds the apex, the metadata, and every name identified by the queued events instead. We accept this tradeoff because a full build of those zones cannot finish, and, while it retries, it holds back every other change on its Kafka partition. Many of the cases that would otherwise need a full build involve several zones sharing one name, and zone holds reduce that risk by stopping the same name from being added to another account. For the rare cases that remain, such as enabling a zone on another network, we can manually rebuild individual names in the zone.

When one name means more than one zone

Quicksilver stores each zone’s record keys separately. It also stores one metadata key shared by every Cloudflare zone with that domain name. This shared key acts like a directory: it tells our authoritative DNS servers which internal zone IDs they may use when answering a query.

Why can one name have several zone IDs? During customer onboarding, offboarding, and other lifecycle changes, multiple Cloudflare zone objects can briefly exist for the same public domain. We use a priority policy to choose a small, bounded set to publish.

Consider four internal zones for example.com: Zone 101, Zone 202, Zone 303, and Zone 404. The metadata key currently lists Zones 101, 202, and 303. Zone 404 exists, but it is not selected. The numbers identify separate Cloudflare zone objects; customers still see one domain name.

A TXT record change at www.example.com in Zone 202 affects only Zone 202’s record keys, so the metadata key does not change. Nameserver and wildcard changes are different because the metadata key records information about them. Those builds must update both the zone’s records and the metadata key.

At execution time, the Zone Builder reads the current list again. If it writes the metadata key, it rebuilds the whole key from that fresh view rather than patching an older copy. It writes the triggering zone’s records before the metadata that refers to them.

Planning from the event, verifying before writing

An event describes what happened in the past. A build may wait while more events arrive and the database changes, so planning happens twice. The event first creates a conservative work list. Immediately before execution, the Zone Builder reads a fresh publication snapshot: the current zone settings, whether this Zone Builder should publish the zone to its network, and which same-name zone IDs belong in the metadata key. Here, a network is a separate, isolated copy of Quicksilver for one environment. Each Zone Builder deployment writes to one network, and a zone can be enabled on some networks but not others. For example, a zone can be served from Cloudflare’s global network and also from the China Network.

Fresh state can change the result in four ways:

  1. A targeted build can become a full build if the zone now has a feature that requires complete-zone work.
  2. A build can become a purge if the zone should no longer be published to this network.
  3. A build can be skipped if the triggering zone no longer belongs in the metadata key.
  4. A metadata build can reconstruct the shared key from the current candidate set.

The fresh read comes from read-only copies of the database, called replicas, so builds do not compete with customer writes. Kafka delivery and database replication move independently: an event can arrive before its database change is visible on a replica. The DNS Kafka Aggregator delays events long enough to cover normal lag, and a final database check rejects the read if that replica is still behind.

Combining changes in one scheduler

Record work and full-zone work previously used different schedulers. Each could combine its own work, but not work from the other scheduler. We replaced them with one unified scheduler. The planner decides what must be built, and the scheduler decides when it can run.

When several events for one zone arrive before a build starts, the scheduler combines their work:

  1. An A record changes at www.example.com, requiring that name.
  2. A wildcard changes at *.example.com, requiring that name and shared metadata.
  3. The scheduler combines both names and the metadata update into one build.

Diagram showing an A record change and a wildcard change passing through the build planner as separate required work, then combined by the unified scheduler into one build.

Merging only adds work. If any event requires the complete zone, the combined build becomes a full build. A purge overrides every rebuild because its desired result is that the zone is no longer published.

The scheduler tracks two things separately: the DNS work that must be performed and the Kafka messages waiting to be acknowledged. A retry preserves both. Even when a full build or purge no longer needs the individual record names, the messages stay attached until the result is safely written.

Keeping Kafka moving

One slow build can delay unrelated customers even when workers are available. Kafka divides messages into ordered partitions. For each partition, it stores one committed offset: the point before which every message is known to be complete. Moving that offset past unfinished work could lose a customer change after a restart.

We use soft committing, which I previously described in my Secondary DNS deep dive. A build can finish out of order and be marked complete in memory, but Kafka’s committed position advances only after every earlier message has also finished.

Diagram of Kafka messages 1 to n where a large build on message 2 blocks commits for messages 3 to n, and a pod restart replays messages 2 to n.

In the diagram, message 2 is still running, so messages 3 through n cannot be committed. If the Zone Builder restarts, those in-memory completions disappear and Kafka replays messages 2 through n. We deliberately choose repeated work over losing a change.

Targeted plans reduce how long the oldest message stays unfinished. The scheduler also prevents one busy zone from taking every worker. After a zone builds, its next build waits for a per-zone rebuild interval, which differs by Cloudflare plan. Changes that arrive in the meantime are merged into that next build. The scheduler normally enforces this interval, but lets old queued work run before it blocks a Kafka partition for too long. Zone locks and retry delays still apply, so a failing build cannot run in a tight loop.

Releasing safely

A smaller build is useful only if it produces the same DNS data. We added equivalence tests for nameserver, wildcard, and apex paths. Each test runs a full build and a targeted build from the same database state, pins time-dependent values, and compares every Quicksilver key owned by the targeted plan byte for byte. Planner and scheduler tests cover classification, same-name zones, merging, purges, and escalation.

During rollout, we also ran a full build next to every targeted build and compared the output. It was expensive by design, reading the complete zone every time, so we used it only until the mirror comparison below gave us the same confidence.

Tests cannot reproduce every customer combination, so every release also runs through a mirror Zone Builder. It consumes the production Kafka stream and reads production database state, but writes to a separate Quicksilver environment that serves no customer traffic.

Diagram of the mirror setup: the production Kafka stream feeds both the production and mirror Zone Builders, each writes to its own Quicksilver, and a comparer samples both and reports to the DNS Mirror Dashboard.

A comparer checks a 20% sample of zones for missing keys, extra keys, and different values. The two environments do not always build a zone at the same instant, so a temporary mismatch is not automatically a regression. We look for new types of differences that remain after both pipelines catch up. That gives us confidence that targeted builds produce the same output as production.

We built the DNS Mirror Dashboard to group those differences and keep examples for investigation. Naturally, it runs on the Cloudflare Developer Platform: a Worker receives results, Durable Objects maintain state, and Cloudflare Access protects it. The critical groups in the screenshot below were each checked and confirmed safe before release. The diff rate is the share of compared zones where production and mirror disagreed on at least one key at the moment of comparison. Most of those are timing differences that disappear once both pipelines catch up, so we watch two things: that the rate stays low, and that no new kind of difference appears.

Screenshot of the DNS Mirror Dashboard comparing production and mirror builds, showing a 0.31% diff rate across 234,313 matched zones.

After the mirror results remained healthy, we rolled the scheduler out by a hash of the zone name. Hashing the name rather than the zone ID kept every zone sharing a name on the same scheduler, so two schedulers never wrote the same metadata key. We increased the percentage for free zones, then repeated the process for paid zones.

Results

Over 24 hours, we measured 86.81% of builds as resources only, 2.54% as resources and metadata, 2.30% as apex and metadata, and 1.30% as purges. Together, 92.95% of builds avoided rebuilding the complete zone. Full builds were the remaining 7.04%.

The two metadata build types were full builds before, even for large zones. Together, they account for 4.84% of builds. Combined with the 7.04% that are still full builds, that is 11.88%, so full builds fell by about 40%. Their share of the count also understates the work avoided, because they include the largest zones. The full builds that remain average 0.35 seconds, because the events that still trigger them, such as a zone being published for the first time, mostly affect new zones with few records.

Table of build types over 24 hours: resources only 86.81%, full zone 7.04%, resources and metadata 2.54%, apex and metadata 2.30%, purge 1.30%.

In 2022, we also planned a batching system. The unified scheduler makes it unnecessary: it does not wait to form batches, and it merges events only when work is already queued for the same zone. Before, long full builds held back the committed offset for their partition. With fewer of them, we now consume Kafka at the rate events arrive, instead of falling behind and catching up in bursts of up to 1,550 messages per second.

Chart of Kafka production and consumption before the change: consumption swings between about 300 and 1,550 messages per second while production stays between about 600 and 800.

Chart of Kafka production and consumption after the change: consumption closely follows production at about 600 to 800 messages per second.

We also measured build completion delay: the time from a DNS record or zone setting change until the Zone Builder finished writing to Quicksilver. It does not include Quicksilver’s distribution across our network, which varies by location and is unaffected by this work. Production ran the old schedulers, and the mirror ran the unified scheduler on the same events over the same 24 hours. The two environments are identical apart from the code: they consume the same Kafka events, read from the same database, and write equivalent data to Quicksilver. That makes this a controlled, side-by-side comparison. The figures combine every build type and customer plan, so they are not a latency guarantee for an individual zone. A large share of this time is the rebuild interval described earlier, not build work. At each measurement point, p99 is the time within which 99% of events finished. Typical delays barely changed here, because most builds were already small. The difference is in the tail: the largest p99 spike fell from 14.6 minutes to 1.21 minutes, a 12-fold reduction. The chart uses a logarithmic scale.

Chart of p99 build completion delay over 24 hours on a logarithmic scale: the legacy scheduler spikes up to 14.6 minutes, while the unified scheduler peaks at 1.21 minutes.

Targeted builds also load complete large zones far less often. Aggregate working-set memory, the memory actively used by the deployment, fell from an average of 49 GiB to 7 GiB, an 86% reduction. Peaks fell from 79 GiB to 12 GiB, an 85% reduction.

Chart of total Zone Builder memory dropping from between 50 and 79 GiB to about 7 GiB after the rollout.

Those were the immediate results of the new scheduler. They also let us revisit two safeguards. The first is the rebuild interval, which stops one busy zone from rebuilding constantly and taking capacity from everyone else. With builds now cheaper, and far fewer of them reading complete zones, we could safely shorten that interval on most plans. The second is how long the DNS Kafka Aggregator holds each event, to make sure database replicas have caught up before we read from them. Once our databases began rejecting reads from replicas that had fallen behind, that buffer could safely be smaller. Together, these halved the median build completion delay, from about 7.7 seconds to about 3.3 seconds. In the chart below, the first step down is the DNS Kafka Aggregator change. The red band marks the Zone Builder release with shorter rebuild intervals. That release rolled out gradually across our servers, so the delay falls in two further steps rather than all at once.

Chart of build completion delay over almost two hours, measured with coarse histogram buckets. The median falls from about 7.7 seconds to about 6.4 seconds after the DNS Kafka Aggregator change, then in two steps to about 3.3 seconds after a Zone Builder release marked by a red band. p90 falls from about 10 seconds to about 7.4 seconds, and p99 stays near 27 seconds.

The p90 and p99 lines in that chart are less precise than they look. The histogram had buckets at 1, 5, 10, and 30 seconds, and a percentile that falls between two edges is estimated as if delays were spread evenly across that range. Most delays sit near the bottom of their range, so those estimates come out high: p99 reads close to 30 seconds, and p90 above 7 seconds. The exact average, which does not depend on buckets, confirms the halving. We have since switched to a native histogram, which chooses fine-grained buckets automatically. It puts p90 at about 5.5 seconds and p99 at about 12 seconds.

Chart of build completion delay over about four hours, measured with a native histogram: median about 3.4 seconds, p90 about 5.5 seconds, and p99 mostly between 10 and 14 seconds.

Why full builds still exist

In 2022, we said we planned to eliminate full builds entirely. We now know that is neither realistic nor useful. A zone being published for the first time needs every record written. A change that can affect records anywhere in the zone needs every record checked. An event that does not say what changed still gets a full build, because the planner never turns uncertainty into less work. For a small zone, a full build is also cheap.

As we learn what more events change, we will keep moving them to targeted builds. However, the biggest gain has already landed: the events that used to rebuild our largest zones no longer do, and the full builds that remain are mostly triggered by events, such as first publication, that affect new, small zones.

Want to know what happens after the Zone Builder writes a change? Read how Quicksilver distributes configuration to every Cloudflare data center in seconds.

Source:
https://blog.cloudflare.com/dns-targeted-zone-builds/