Between October 21 and November 18, 2026, four critical vulnerabilities were disclosed in software that runs a large part of the internet: the PHP interpreter, the Apache HTTP Server, the Java runtime (OpenJDK) and NGINX. Each can lead to remote code execution without credentials, at least in some configurations. Each sat in code that had been in production for years, in two cases for more than a decade. And each was found, at least once, by researchers working with AI.

Any one of these would make for a busy week. Four in a month is a pattern worth understanding. This article is not a technical breakdown of the bugs; the researchers’ write-ups linked in the table cover that well. It is about what these four cases say about how vulnerability discovery is changing, and what that means for the way we run security programs.

SoftwareWhere you find itFlaw present sinceHow it was foundDetails
PHPWordPress, Drupal, Joomla, almost 70% of websitesPHP 5.4 (2012)Three independent teams (Calif, OpenAI, Wiz), AI-assistedWiz: PHP2Shell
Apache HTTP Server (mod_http2)Web servers and reverse proxies2.4.55 (2023)Anthropic’s automated scanner, then Google researchers eight days laterApache advisory
OpenJDKJava applications such as Keycloak, Jira, Jenkins17.0.6 (2023)Calif using Codex; Oracle also credits a second reporterCalif: Java4Shell
NGINXWeb servers, Kubernetes ingress controllers1.9.5 (2015)Five independent teams, AI-assisted ones among themWiz: NGINX2Root

Old bugs, new economics

None of these is a new kind of flaw. They are all memory-corruption bugs, a family as old as the C language. What changed is the cost of finding them.

PHP is the clearest example. In 2024, a developer working for the PHP Foundation noticed the first signs of the problem while fixing an unrelated audit finding, and Calif traces the underlying bug class back to public research from around 2004. Nobody found a practical way to exploit it, so it stayed unfixed. In August 2026, AI-assisted researchers turned it into working exploits. Wiz says a single researcher did in a week what would previously have taken a world-class team months.

The Java case puts a price on it. A Calif researcher pointed an AI coding model at a low-level part of the Java runtime. It took about an hour to find the bug, two more to build a working exploit, and less than $200 in compute. Until recently, that kind of work needed one of a small number of specialists.

NGINX shows what this means for “mature” software. One of the affected code paths had been in the world’s most widely used web server since 2015. Eleven years of deployment and review missed it.

The lesson is uncomfortable. Part of the confidence we had in mature, widely used software came from the fact that looking hard at it was expensive. Flaws that were too costly to find or exploit were, in practice, left alone. That protection is going away.

Several teams now find the same bug at once

In three of the four cases, more than one team found the same flaw independently: three for PHP, two for Apache, five for NGINX. When Wiz reported one of the NGINX bugs, F5 told them another team had already reported it.

When finding a bug becomes cheap, many people find it. For defenders, that means a newly disclosed vulnerability may already be known to others, including attackers.

The PHP disclosure showed what that looks like. AWS saw exploitation attempts in its honeypots four days before the public announcement, and says it is unclear how the attacker learned of the flaw. The day before release, the CVE identifiers leaked online. On release morning, a vendor published patched software before the embargo lifted, which let anyone study the fix. CISA added both CVEs to its list of actively exploited vulnerabilities five days after disclosure, and several European governments took public websites offline rather than race the patch. In practice, the patching window opened before most organizations knew there was anything to patch.

Discovery is becoming a continuous service

“AI-assisted” covers very different things, and it helps to separate them.

In most of these cases, human researchers chose where to look and checked the results, while the models did much of the searching and exploit development. The Apache case went further. One of the two reports came from Anthropic’s OSS Scanner, a free, opt-in service launched in October 2026 that runs AI models against open-source projects and sends the findings without human review. Wiz (with its Atlas platform) and OpenAI (with Patch the Planet) run similar programs.

The shift is from occasional audits to continuous coverage. A human team audits when there is budget and covers what it has time for. A scanning service can look at every enrolled project on every release. The “many eyes” argument for open source was always weaker than it sounded, because those eyes were few and mostly volunteers. Automated scanning adds many more, and they don’t get tired.

Attackers have the same tools

The capability works in both directions. A model that helps a researcher find and exploit a bug helps an attacker in the same way. Wiz’s conclusion after the PHP work is that complexity can no longer be relied on as a barrier to discovery or exploitation.

The opposite exaggeration is also wrong. AI has not replaced security research, and human maintainers wrote all four fixes. What it has done is put this kind of work within reach of far more people, on both sides.


The bottleneck is now remediation

If discovery speeds up and fixing does not, the queue grows at the fixing end. Every fix in this wave was written by the project’s own maintainers, and some of those teams are tiny: PHP’s security work runs on a very small, mostly part-time team. Apache had to ship its second HTTP/2 memory-safety fix in six months. This makes dependence on open-source projects a risk-management question, not only an engineering one, because the health and funding of those projects decide how fast fixes reach you.

The same constraint exists inside every organization: the time between a fix being available and it running in production. That number, not the count of open CVEs, is what decides your exposure.

The instinctive response to a month like this is “patch everything now”. In any real environment, with hundreds of container images, several clusters, legacy applications and change-management rules, that is not a plan. Vulnerability management built on CVE feeds and periodic scans assumed discovery was slow, and that assumption no longer holds. If remediation is the bottleneck, the work is to shrink what needs remediating and to make the rest move faster. This is where I would put the effort.

Reduce what is exposed. Every one of these four flaws had a “not affected” condition: a feature switched off, a module not loaded, a different processor type. Components and features you don’t run can’t hurt you. Minimal and distroless images, switching off unused modules and network segmentation turn many future CVEs into non-events.

Prioritize by exposure, not by score

All four scored between 8.1 and 9.8, which puts them all in the “critical” bucket, yet the real risk varied enormously between environments. Severity scores say how bad a bug is in general, not how much it matters to you. Better questions are: is the component internet-facing, is the vulnerable feature actually in use, is there a public exploit, and is it being exploited? CISA’s Known Exploited Vulnerabilities catalog helps with the last one.

Know where things actually run

The first question after a disclosure is always “where do we run this?” Many organizations can answer for the software they build but not for what is embedded in third-party components. A good example from this wave: several widely deployed Kubernetes ingress controllers embed NGINX, so the exposure often sits in a component nobody thinks of as “an NGINX server”. Track what is running in production, not only what sits in your image registry.

Detect at runtime

Patching always leaves a window. Inside it, the controls that help are the ones that detect unusual behavior on running systems: a web server starting a shell, workers crashing repeatedly, unexpected outbound connections. I made the longer case in the Copy Fail write-up: when discovery and weaponization speed up, runtime visibility is what tells you something is happening.

Measure and shorten time to remediate

Automate the path from a patched upstream release to a rebuilt and redeployed workload, and verify the result on running systems, because a merged change is not a fixed environment. AI belongs on this side too. Triage, working out which systems are actually reachable, and planning remediation are the same kind of work as discovery, and the same models can help.

Questions to ask your teams

  • If a critical flaw in NGINX, PHP or Java were announced tomorrow, how long would it take us to list every place we run it, including inside third-party products?
  • How long does it take today for a patched base image or runtime to reach production?
  • Which internet-facing services would we notice being exploited before a patch is deployed, and which would we not?
  • Which open-source projects are critical to us, and do we know how they are maintained and funded?

Takeaways

  • Mature software is not automatically secure software. Years without a public vulnerability can simply mean nobody looked hard enough.
  • AI makes finding bugs cheaper for both defenders and attackers. Expect more disclosures, more teams finding the same bug, and exploitation that can start before the announcement.
  • The constraint has moved from discovery to remediation, both upstream and inside your own organization.
  • Patching is still essential, but on its own it is not enough. Exposure-based prioritization, accurate inventory and runtime detection should be the baseline.

There will be another month like this one. How your teams answer the questions above is a fair measure of how ready you are for it.


References


This article reflects my analysis as a security practitioner and is not vendor-specific advice. Patch prioritization and detection coverage should always be validated against your own environment and vendor guidance.