Java4Shell vulnerability

Java4Shell and NGINX: AI Found These Bugs. Is Your API Layer Ready for the Next Ones?

Picture of Shikha Patra
Shikha Patra
Product Marketing Manager
• ⏱︎ 9 min read

TL;DR

  • Two critical RCEs in 48 hours. Java4Shell (CVE-2026-114938) on November 17. Two NGINX HTTP/2 flaws (CVE-2026-123633 and CVE-2026-123007) on November 18.
  • AI helped find both. One of them in about an hour.
  • Both sit where your APIs live. Java runs the services. NGINX fronts them.
  • Patch now, then plan for the next one. The question for leadership is how far an attacker gets in the gap between disclosure and patch.

November 2026 changed the economics of vulnerability discovery

For decades, one assumption held across the security industry: finding a critical bug in mature infrastructure took elite researchers, months of work and some luck.

That assumption ended on November 17 and 18, 2026.

In 48 hours, two of the most widely deployed pieces of internet infrastructure disclosed critical remote code execution flaws. Java runs a large share of enterprise backends. NGINX powers more than 225 million websites, by Wiz’s count. AI helped find both.

The implication for every CISO is direct: if AI can find a pre-auth RCE in a core runtime in an afternoon, so can your adversary. Plan as if the next one is already being found.

What is the Java4Shell vulnerability (CVE-2026-114938)?

Java4Shell is a memory-corruption bug in OpenJDK’s hardware-accelerated Base64 decoder. A crafted Base64 string makes the decoder write past its buffer, corrupting memory inside the running JVM. Calif found and reported it.

What makes this one different is where it lives. It sits in the Java standard library, beneath every framework and dependency your teams track.

Java4Shell key facts

  • Severity: Calif rates it 9.2 (Critical) under CVSS 4.0. Oracle’s November 2026 Critical Security Patch Update scores it 8.1 under CVSS 3.1, the highest of 11 Java SE fixes in that release.
  • Trigger: untrusted data reaching the java.util.Base64 basic or URL decoder, per The Hacker News. 
  • Exposure: Java 17.0.6 and later, plus Java 21, 25 and 27, on x86-64 CPUs with AVX-512 VBMI. Standard Java 8 and 11, and ARM servers, are not affected.
  • Named targets: Calif reports pre-auth remote code execution (RCE) against default setups of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate.
  • Status: no confirmed exploitation in the wild yet. Calif says each target needs its own exploit chain.

Oracle’s response

Java4Shell shipped alongside 10 other Java SE fixes, all of which Oracle says may be exploited over a network without credentials. Fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. If you cannot patch today, start affected JVMs with -XX:-UseBASE64Intrinsics and accept a performance cost on Base64-heavy workloads. 

How did AI find Java4Shell?

Calif researcher Quang Luong pointed OpenAI’s Codex at OpenJDK’s JIT compiler, intrinsics, widely used APIs and cryptography. Calif says the agent surfaced the flaw in about an hour, a working exploit followed about two hours later, and total token spend was under $200.

A skilled human still chose the targets. Even so, the cost of finding a critical runtime bug has fallen to the price of a team lunch. Every security leader should sit with that number.

What are the NGINX HTTP/2 RCE vulnerabilities (CVE-2026-123633 and CVE-2026-123007)?

One day later, F5 fixed two critical HTTP/2 memory-safety flaws in NGINX that can allow unauthenticated remote code execution. Wiz Research was one of five teams that reported them independently. Both rate CVSS 4.0 9.2, and both require HTTP/2 to be enabled.

The two flaws

  • CVE-2026-123633 (use-after-free): NGINX can free an HTTP/2 connection while a request is still using it. It affects reverse-proxy setups on NGINX 1.19.7 through 1.31.8.
  • CVE-2026-123007 (integer underflow): a flood of WINDOW_UPDATE frames can push a flow-control counter into a negative length in the TLS send path. It affects NGINX 1.9.5 through 1.31.8, including default HTTPS setups.

Why do the NGINX flaws matter for APIs?

NGINX is the shared front door for websites and APIs across a huge number of enterprises. As Wiz points out, one vulnerable instance can expose every service behind it, however well that backend code is written.

NGINX exploitation status and fixes

  • Exploitation: Wiz built lab exploits but will not release them. It calls exploitation difficult and reports no in-the-wild activity. 
  • Fix: upgrade to NGINX OSS 1.30.7 or 1.31.9, or the matching NGINX Plus release. Until then, disable HTTP/2 in affected server blocks. 

How did AI find the NGINX flaws?

Wiz found both flaws with Wiz Atlas, its AI research harness, and used frontier models to validate their impact. Two research teams, three critical flaws, one common accelerant. That is a trend, and leaders should treat it as one.

What do Java4Shell and the NGINX flaws mean for API security?

Three shifts every security leader should plan for

1. The patch-to-exploit window is collapsing

In the same month, Google’s threat intelligence team reported an attacker-run AI framework that turned security patches into working exploits with no human in the loop. Combine that with AI finding runtime bugs in hours. A patch cycle measured in weeks now runs slower than the attacker.

2. How attackers reach these flaws through APIs

Neither bug is an API flaw in the OWASP sense. Both still reach production through API traffic.

  • Java4Shell rides on Base64. Your applications decode it constantly, in auth headers, tokens, API payloads and file uploads. Every one of those endpoints on an affected Java service is a way in.
  • NGINX sits in front of your APIs. One vulnerable proxy or gateway exposes everything behind it.
  • AI infrastructure carries the same risk. Agent tools, MCP servers and data pipelines run on these stacks, and they are often deployed faster than they are inventoried.

3. Patching speed alone will not save you

Patch first. Always. Yet every patch program depends on knowing what you run, and most organizations discover that during an incident. The first advice on Java4Shell was to inventory Java runtimes and identify internet-facing applications. That is a visibility problem, and APIs are where most enterprises have the largest blind spots.

What can API security do against runtime vulnerabilities?

Precision matters more than hype here.

  • It cannot patch the runtime. The NGINX flaws fire on low-level HTTP/2 frames before any API logic runs. Only an upgrade, or disabling HTTP/2, closes them.
  • It can shrink exposure. Knowing which APIs run on affected services tells you what to patch first.
  • It can spot abnormal input. Malformed Base64 hitting an endpoint that normally sees clean tokens is a signal.
  • It can contain the damage. An attacker with code execution still has to call your APIs to move data. That is where you catch them.

What security teams should do now

  1. Patch Java. Every Java 17, 21, 25 and 27 runtime, including bundled JDKs and container base images.
  2. Patch NGINX. Move to 1.30.7 or 1.31.9, or the matching NGINX Plus build. Disable HTTP/2 until then.
  3. Map the exposure. List internet-facing APIs on affected Java services or behind NGINX. Start with auth and file-upload endpoints.
  4. Watch the inputs. Alert on malformed or oversized Base64 in headers, tokens and request bodies.
  5. Watch what follows. Look for unusual API call sequences, bulk data access and new outbound connections.
  6. Bring AI infrastructure into scope. MCP servers, agent tools and AI gateways belong in the same inventory.

            Why AppSentinels was built for this moment

            AppSentinels was built on a simple premise: the API layer is where modern attacks land and where their damage spreads. Java4Shell and the NGINX flaws prove the point. 

            • API discovery: a live inventory of every API, including shadow and zombie endpoints, so you know which services to patch first. 
            • API security testing: test APIs in your pipeline so fewer weaknesses reach production for an AI-assisted attacker to chain. 
            • API runtime protection: AppSentinels protects APIs in production by learning how each one is normally used, then flagging or blocking abnormal inputs, call sequences and data access. Those are the signals an exploited service produces, so an attacker who gets past an unpatched runtime is caught before data leaves. 
            • Agentic AI and MCP security: visibility into the APIs and tools your AI agents call, so new AI infrastructure does not become an unmonitored entry point. 

            The next critical runtime bug may already be sitting in someone’s AI agent output. The advice for every leader is simple: patch fast, and make sure your API layer can catch what slips through in the meantime.
             

            Think you’re under attack? Find out what’s happening across your APIs.

            Frequently Asked Questions
             

            How does AppSentinels help against Java4Shell? 

            AppSentinels runtime protection can flag or block malformed or oversized Base64 reaching auth and file-upload APIs, the entry points Java4Shell relies on. It also detects unusual API activity if an attacker gets in. Upgrading Java to a fixed build remains the complete fix.

            How does AppSentinels help against the NGINX HTTP/2 vulnerabilities?

            The NGINX flaws trigger at the HTTP/2 protocol layer, before API logic runs, so the fix is to upgrade NGINX or disable HTTP/2. AppSentinels shows which APIs sit behind affected NGINX instances and catches the API abuse that follows a compromise.

            Can AppSentinels help before a patch or signature exists for a new vulnerability? 

            Yes. AppSentinels learns how each API is normally used, so it can flag abnormal inputs and unusual call sequences without waiting for a CVE-specific signature. That matters more as AI shortens the gap between a bug’s discovery and a working exploit.

            How does AppSentinels help prioritize patching after a new vulnerability? 

            AppSentinels continuous API discovery keeps a live inventory of every API, including shadow and zombie endpoints. Security teams can map internet-facing APIs to affected services and patch the most exposed ones first.

            How does AppSentinels secure AI agents and MCP servers against flaws like these?

            AI agents, MCP servers and AI gateways often run on the same Java and NGINX stacks. AppSentinels gives visibility into the APIs and tools agents call, so new AI infrastructure does not become an unmonitored entry point.

            Related Content