NGINX, Java and Apache: three critical flaws found with AI in one week
In seven days NGINX, Java and Apache HTTP Server fixed critical flaws that let an attacker run code with no sign-in, each found with AI. What to update now.

In seven days, three programs that sit in front of a large share of the web's applications were fixed for critical flaws that let an attacker with no account run code on the server: Apache HTTP Server on 11 November 2026, Java on 17 November and NGINX on 18 November. At least one finder of each used AI, and two of the three were found by more than one team working separately. In the same week Google's Project Zero shortened its disclosure deadlines, saying AI now lets attackers turn a published fix into an exploit almost at once (Project Zero ↗).
No attacks using any of the three had been reported when this was written on 18 November. The researchers behind two of them say they built working exploits and are holding them back while people update (Wiz ↗, Calif ↗).
Three flaws, seven days
| Fixed | Software | What an attacker gets | Found by |
|---|---|---|---|
| 11 Nov · Apache ↗ | Apache HTTP Server 2.4.55 to 2.4.70, with HTTP/2 on | Code execution on the server through corrupted memory, with no sign-in | Anthropic's OSS Scanner (reported 26 Oct) and Google Cloud's Vulnerability Research team (3 Nov) |
| 17 Nov · OpenJDK ↗ | Java 17.0.6 and later, including 21, 25 and 27, on recent x86-64 processors | Code execution, with no sign-in in Jira, Confluence, Jenkins, Keycloak, Artifactory and PingFederate as shipped | |
| 18 Nov · nginx.org ↗ | NGINX 1.9.5 to 1.31.8, with HTTP/2 on | Code execution on the server, with no sign-in | Credited by nginx to Xint.io and Vexera AI; |
NGINX: two flaws in the software in front of 225 million websites
NGINX receives a website's traffic, handles its encryption and passes each request to the right application; one installation often serves several sites and APIs.
Wiz puts it in front of more than 225 million websites. Both flaws sit in how NGINX handles HTTP/2, a newer version of the protocol browsers use to talk to websites, and both need HTTP/2 to be switched on (Wiz ↗).
- →CVE-2026-123633, a use-after-free. When NGINX runs short of connection slots while passing a request on to an application, it can free the memory of a connection that a request is still using. The flaw has been in NGINX for nearly six years, since version 1.19.7.
- →CVE-2026-123007, an integer underflow. A counter that limits how much data NGINX may send can be pushed past its maximum, a safety check then miscalculates, and NGINX copies memory out of bounds. It dates to version 1.9.5 in 2015, and Wiz ran its own code on a test server that did nothing but serve ordinary files over HTTPS.
nginx.org rates the first medium and the second major; Wiz scores both 9.2 out of 10 under CVSS 4.0, which is critical. The 18 November releases, 1.31.9 mainline and 1.30.7 stable, fixed ten security flaws in all (nginx.org ↗). NGINX Plus, F5's commercial edition, has its own fixed builds.
Wiz says it found both with Wiz Atlas, the AI harness behind its code scanning, and used two commercial models to confirm that each could run code on a server. "The flaws were already there; AI helped us find them," its researchers write. Other teams had got there too: when Wiz reported the first flaw on 21 October, F5 told it another team had already reported the same bug. nginx's own change log credits CVE-2026-123007 to Xint.io and CVE-2026-123633 to Albert of Vexera AI (nginx ↗); Wiz names Ikotas Labs, Metnir, Rapid7 and Xint as independent finders.
Java4Shell: a memory flaw inside a memory‑safe language
Java manages memory for the programs written in it, one of its main selling points. Java itself is partly written in lower-level code, and Java4Shell, CVE-2026-114938, sits in hand-written assembly that speeds up Base64 decoding on processors with the AVX-512 VBMI instruction set. Base64 is a common way of carrying binary data as text, and malformed input to that fast path overwrites neighbouring memory (Calif ↗).
Servers decode Base64 constantly: HTTP Basic sign-ins, SAML sign-in messages and CSRF tokens all arrive in it, Red Hat notes, and the fast path switches itself on when the processor supports it, so no special setting is needed for exposure (Red Hat ↗).
Calif ran code without signing in on the default setups of Keycloak, Atlassian Jira and Confluence, JFrog Artifactory, Jenkins and PingFederate, and after signing in on Kafka, Solr, Elasticsearch, Gerrit and Spinnaker.
Three conditions decide exposure. The Java version is 17.0.6 or later; Java 8 and 11 lack the code, apart from one Oracle Java 8 performance build. The server runs on an x86-64 processor from Intel's Ice Lake or AMD's Zen 4 generation or newer; ARM servers are unaffected. And data an attacker controls reaches the decoder. Every major build of OpenJDK carries the flaw, including Amazon Corretto, Eclipse Temurin, Microsoft's, Azul Zulu, BellSoft Liberica, SAP SapMachine and Red Hat's. OpenJDK scores it 8.1 under CVSS 3.1, Calif 9.2 under CVSS 4.0, and Red Hat rates it Critical (OpenJDK ↗).
Calif, which also found PHP2Shell in October, says it used AI to find and weaponise Java4Shell, with its researchers building the pipelines and steering the models when they got stuck. It is holding back the exploits for individual products until people have had time to update.
Apache: two finders, eight days apart
On 11 November Apache HTTP Server 2.4.71 fixed CVE-2026-119618, a race condition in mod_http2, the module that serves HTTP/2: two threads change the same memory without coordinating, and an attacker with no sign-in can turn the corruption into code execution. Versions 2.4.55 to 2.4.70 are affected when HTTP/2 is on. Apache credits two finders: Anthropic's OSS Scanner, which reported it on 26 October, and Anthony Weems and Simon Scannell of Google Cloud's Vulnerability Research team, on 3 November (Apache ↗).
When
Wiz wrote it up, it knew of no public exploit and no attacks. It found resources running an affected version in 64% of the cloud environments it monitors, and publicly reachable ones in 51%, before checking whether HTTP/2 was switched on (Wiz ↗).
Why Project Zero changed its clock
On 14 November Google's Project Zero replaced the policy it had followed since 2021: 90 days for a vendor to fix a bug, plus 30 days for users to install the fix. It now publishes every bug 90 days after reporting it, fixed or unfixed. The deadline falls to 60 days on 2 February 2027 and to 30 days on 3 January 2028 (Project Zero ↗).
Its reasons read like a summary of this week. Language models let attackers find bugs faster, which raises the odds that several parties, some malicious, find the same one. They turn a published fix into a working exploit so quickly that Project Zero now treats the time from patch to exploitation as zero, which makes the extra 30 days pointless. And they have multiplied its own output: it now finds several bugs a week in software where it once found a few a year. Two days later, another Google team reported a system that turns each new fix into an attack automatically.
Finding has outrun fixing
The week has a second side.
VulnCheck, which tracks vulnerabilities credited to Anthropic, counted 442 CVEs in the seven months to 9 November, two of them exploited in the wild. Anthropic's own ledger listed 37,966 findings on 2 November, of which 7,349 had been made public and 217 were marked fixed. The curl project, one of the first to open its code to Anthropic's scanner, rejected 19 of 34 published reports as vulnerabilities and confirmed six as low severity, VulnCheck notes (VulnCheck ↗).
Read together, the bottleneck has moved. Models surface flaws faster than maintainers can confirm them, and each confirmed fix still has to be tested and rolled out by people. Wiz says as much about NGINX: turning a published fix into protection in production still takes substantial manual work, from validating patches to coordinating rollouts with the teams that own each service. That stretch of the timeline belongs to every company running the software.
What to check this week
- →Find every NGINX that speaks HTTP/2. Include the copies inside containers, Kubernetes ingress controllers and appliances. Update to 1.30.7 or 1.31.9, or F5's fixed NGINX Plus build; where an update has to wait, switching HTTP/2 off removes both critical flaws (Wiz ↗). A CDN or firewall that terminates HTTP/2 in front of NGINX may blunt the attack, Wiz says, depending on how it is built.
- →Find every Java runtime, including the bundled ones. Products built on Java often bring their own runtime, and container images carry theirs. On x86-64 servers, move to 17.0.21.1, 21.0.13.1, 25.0.5.1 or 27.0.1.1, or the matching build from the Java vendor in use. Until then, starting Java with -XX:-UseBASE64Intrinsics turns off the vulnerable fast path (Calif ↗).
- →Update Apache HTTP Server to 2.4.71. Where that has to wait, limiting it to HTTP/1.1 takes the vulnerable module out of the path (Wiz ↗).
- →Time the gap. Measure the days between a security release and its arrival on every internet-facing server. Project Zero now assumes an attacker's version of that gap is zero.
Written down as rules a team can test on every release, those checks read: every internet-facing web server and Java runtime runs a version its maintainer lists as fixed; no server speaks HTTP/2 on a version listed as vulnerable; each security release reaches production within an agreed number of days. On any given day each rule holds or breaks, and the answer can be checked.
What we don't know
- →Whether anyone exploited them first. No attacks have been reported for any of the three; the fixes are hours or days old.
- →How the other NGINX teams found them. Wiz is the only finder we found describing its method; Xint.io and Vexera AI, which nginx credits, had published no write-up we could find.
- →How much of each find was the model's work. Calif and Wiz describe researchers directing AI and checking its output; neither says what share each did.
- →How many servers meet every condition. HTTP/2 must be on and, for Java, the processor must qualify; we found no public count of servers that do.
Sources
- →Wiz Research, Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007 ↗, 18 November 2026
- →nginx.org, Security advisories ↗ and change log for 1.31.9 ↗, 18 November 2026
- →Calif, Java4Shell: Write once, RCE everywhere ↗, 17 November 2026
- →OpenJDK Vulnerability Group, Advisory 2026/11/17 ↗, and Red Hat, RHSB-2026-018 ↗, 17 November 2026
- →Apache HTTP Server Project, Fixed in Apache HTTP Server 2.4.71 ↗, 11 November 2026; Wiz, Critical RCE Vulnerability in Apache HTTP Server ↗
- →Google Project Zero, Policy and Disclosure: 2026 Edition ↗, 14 November 2026
- →VulnCheck, After 7 months, Glasswing overwhelms maintainers with underwhelming findings ↗, 9 November 2026
Company logos identify the organisations named in public statements and imply no affiliation with MATT.
Questions
What is Java4Shell?
Java4Shell is CVE-2026-114938, a memory-corruption flaw in the Base64 decoder of OpenJDK, the most widely used Java runtime, disclosed by Calif and fixed on 17 November 2026. On Java 17.0.6 and later, running on x86-64 processors with AVX-512 VBMI, malformed Base64 input can let an attacker run code, in some products without signing in.
Which NGINX versions fix CVE‑2026‑123007 and CVE‑2026‑123633?
NGINX 1.31.9 (mainline) and 1.30.7 (stable), released on 18 November 2026, and F5's fixed NGINX Plus builds. Both flaws need HTTP/2 to be switched on, so turning HTTP/2 off is the stopgap until the update is in place.
Are these flaws being exploited?
As of 18 November 2026 no exploitation had been reported for the NGINX flaws, Java4Shell or the Apache HTTP/2 flaw. Wiz and Calif say they built working exploits and are withholding them while people update.
Did AI find these vulnerabilities?
At least one finder of each used AI: Anthropic's OSS Scanner for the Apache flaw, Calif's AI-assisted research for Java4Shell, and Wiz Atlas, Wiz's AI harness, for NGINX. Calif and Wiz describe their researchers directing the models and checking the results.
Why did Google's Project Zero change its disclosure policy?
Project Zero says language models have sped up both finding bugs and turning patches into exploits, and multiplied its own findings. Since 14 November 2026 it publishes bugs 90 days after reporting them, falling to 60 days in February 2027 and 30 days in January 2028.
