Last updated: November 18, 2026. Fixed builds from some vendors are still rolling out. We will update this page as they land.
Contents
ToggleExecutive Summary
Java4Shell (CVE-2026-114938) is a heap out-of-bounds write in OpenJDK’s hardware-accelerated Base64 decoder. Oracle scores it 8.1 under CVSS 3.1. Calif scores it 9.2 under CVSS 4.0.
It affects Java 17.0.6 and later, plus Java 21, 25 and 27. That covers every OpenJDK-based distribution: Oracle, Temurin, Corretto, Zulu, Microsoft, Liberica, SapMachine, Red Hat and Linux distro packages. Standard Java 8 and 11 are not affected. Oracle does list one Java 8 build as affected: its Enterprise Performance Pack build 8u511-perf.
Calif’s write-up changed the exploitation picture. The overflow writes mostly fixed bytes, so at first it looked close to unexploitable. Calif first turned it into a heap leak. The leak pulls Java heap contents such as tokens, keys and personal data, in the style of Heartbleed. Then Calif turned it into code execution. It reports:
- pre-auth RCE against default setups of Keycloak, Atlassian Jira and Confluence, JFrog Artifactory, Jenkins and PingFederate
- post-auth RCE against Kafka, Solr, Elasticsearch, Gerrit and Spinnaker
- a client-side variant, where a Java program that connects over TLS to a malicious server can be compromised
Those chains are private for now. The public proof of concept only shows the overflow. VulnCheck’s assessment still holds for anyone without Calif’s tooling. Crashing a JVM is trivial. Reliable code execution needs custom heap grooming for each application.
Hardware gates exposure. The vulnerable code only runs on x86-64 CPUs with AVX-512 VBMI. That means Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD Zen 4 or newer. ARM servers are not affected.
Patch the products Calif named first. They sit on the internet, run Java 17 or 21, and hold credentials for everything downstream.
TL;DR for Engineering Teams
What it is: CVE-2026-114938 (Java4Shell), a heap out-of-bounds write in the AVX-512 Base64 decode intrinsic. CVSS 3.1 8.1 (Oracle), CVSS 4.0 9.2 (Calif).
Where it bites: OpenJDK-based Java 17.0.6+, 21, 25 and 27 on x86-64 CPUs with AVX-512 VBMI (Ice Lake through Granite Rapids, AMD Zen 4+). Oracle 8u511-perf too. ARM is not affected.
Why it matters: Calif reports pre-auth RCE in default Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. It also reports a JavaBleed heap leak and a client-side TLS variant. The exploits are withheld, and the public PoC only triggers the overflow. Anyone can crash a JVM. Not exploited in the wild as of November 18.
Patch status: Oracle fixed builds are out (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1). Amazon Corretto 17.0.21.1.2 and Amazon Linux packages are out. Temurin had no fixed build as of November 18. Zulu, Microsoft, Liberica, Red Hat and distro builds are rolling out. Check each vendor.
Immediate action: Patch, starting with the named products. Can’t patch? Use -XX:-UseBASE64Intrinsics (put -XX:+UnlockDiagnosticVMOptions in front if your build needs it). Or use -XX:UseAVX=2, on x86-64 hosts only. Then restart.
Vulnerability Overview
| Field | Value |
|---|---|
| Vendor | OpenJDK Vulnerability Group / Oracle (and all OpenJDK distributors) |
| Product | OpenJDK / Java SE 17, 21, 25, 27 (HotSpot JVM) |
| Vulnerability Type | Heap out-of-bounds write (memory corruption) |
| CWE | CWE-787 Out-of-bounds Write, via CWE-191 Integer Underflow (as described by researchers) |
| CVSS Score | 8.1 (CVSS 3.1, Oracle), 9.2 (CVSS 4.0, Calif) |
| CVE | CVE-2026-114938 |
| Patch Available | Yes (Oracle, Corretto, Amazon Linux); other distributions rolling out |
| Active Exploitation | Not known to be exploited in the wild; not in CISA KEV as of November 18 |
The two scores describe the same bug. CVSS 3.1 counts the AVX-512 VBMI requirement as high attack complexity, so it lands at 8.1. CVSS 4.0 moves it to Attack Requirements, so it lands at 9.2.
Technical Anatomy
Root cause
HotSpot swaps hot calls to Base64.Decoder.decodeBlock for a hand-written AVX-512 assembly stub. This happens once the C2 compiler compiles the caller. The stub was added in JDK 18 (JDK-8268276). It was backported to Java 17 in 17.0.6 (JDK-8296735). That’s why 17.0.5 is clean and 17.0.6 is not.
The stub builds a 64-bit store mask from the input and output lengths. Then it adjusts the mask for padding.
Take a malformed tail made mostly of padding. The output length comes out as zero. The stub then subtracts one for each =, so the length underflows to -1 or -2. The mask instruction treats any length of 64 or more as “write everything”. So the stub stores all 64 bytes of its vector register. That’s 62 bytes past the end of the output array on the Java heap.
Java then rejects the input with IllegalArgumentException. But the neighboring memory is already overwritten. Catching the exception does not help.
The overwrite is mostly fixed values. Only the first two bytes are attacker-influenced. The attacker controls where the write lands, not what it writes. Calif notes the trigger threshold is higher on Java 17 than on 21 and later.

Exploit path
- Entry point. Any attacker-controlled Base64 that reaches
java.util.Base64before authentication. Pre-auth paths confirmed in public reproduction: Basic auth in Spring Security, Tomcat and Jetty 12, and JWT decoding in thejava-jwtlibrary. Calif adds login flows and file uploads in Struts and Spring Boot sample apps, plus the named products in default setup. - Vulnerability trigger. The decode call must already be JIT-compiled. In public tests this took roughly 10,000 decodes. An attacker can warm it up with valid requests. Nothing gets corrupted during warm-up. A malformed padded value then overflows the output array.
- Execution impact. Without heap shaping, the JVM crashes. With Calif’s technique, the attacker gets a heap leak first, then code execution.
How Calif turned a fixed-byte overflow into RCE
This is the part that changed the risk rating. We describe it at the level defenders need. We leave out the parameters that make it work.

| Stage | What happens | Defender takeaway |
|---|---|---|
| Warm | Valid Base64 requests until the JIT uses the vulnerable stub | High-volume valid Base64 traffic to one endpoint can come before an attack |
| Groom | Timed partial HTTP requests shape which objects sit next to the decode buffer | Exploits depend on streamed request bodies and low network jitter |
| Trigger | A malformed padded value overflows into a neighboring array and enlarges its length | The malformed-token signature fires here |
| Disclose (“JavaBleed”) | The enlarged array becomes a read primitive; heap contents come back in responses | Treat tokens, keys and PII in heap memory as exposed on a hit |
| Repair | Corrupted objects are restored so the JVM keeps running | A successful attack may leave no crash behind |
| Finish | Application-specific action, up to code execution | One custom profile per product |
Three things matter for defenders.
There is no universal exploit. Each product needs its own decoder route, heap profile and payload. That’s why Calif’s list goes product by product.
The attack is retryable. A misaligned attempt can crash the JVM, but often the attacker just tries again. Crash bursts are a signal.
It is cheap. Calif says its researcher found the bug with an AI coding agent in about an hour. The first working exploit took two more hours and under $200 in tokens. AI agents built most of the later product chains. Expect independent exploits once people have read the patch diff and the write-up.
Exploitation status
| Item | Status | Source |
|---|---|---|
| Overflow reproduced | Confirmed on real hardware | VulnCheck, independent researchers, Calif |
| Pre-auth DoS | Trivial where the decode path is reachable | VulnCheck |
| Heap disclosure (JavaBleed) | Technique published; leak reproduced in lab conditions | Calif, independent researchers |
| Pre-auth RCE | Claimed in default Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate | Calif claim, exploits withheld |
| Post-auth RCE | Claimed in Kafka broker, Solr, Elasticsearch, Gerrit, Spinnaker | Calif claim |
| Client-side RCE | Claimed via TLS connection to a malicious server | Calif claim (credited to samczsun) |
| Public PoC | Bounded trigger only; shows the overflow safely | Calif |
| Commercial exploit | Available to VulnCheck Initial Access Intelligence customers | VulnCheck |
| In-the-wild exploitation | None known | VulnCheck, CISA |
| CISA KEV | Not listed as of November 18 | CISA |
We are not reproducing the trigger string, trigger lengths, heap parameters or the proof of concept. Detection and mitigation do not depend on them.
Affected Versions
| Package | Vulnerable Versions | Fixed Version | Notes |
|---|---|---|---|
| Oracle Java SE 17 | 17.0.6 to 17.0.21 | 17.0.21.1 | Oracle November 17 CSPU |
| Oracle Java SE 21 | through 21.0.13 | 21.0.13.1 | |
| Oracle Java SE 25 | through 25.0.5 | 25.0.5.1 | |
| Oracle Java SE 27 | through 27.0.1 | 27.0.1.1 | |
| Oracle Java SE 8 Enterprise Performance Pack | 8u511-perf (8u511b33-perf) | 8u513-perf | Standard Java 8 not affected |
| Oracle GraalVM for JDK | 17.0.21, 21.0.13 | Per Oracle advisory | Check vendor |
| Amazon Corretto 17 | 17.0.6+ | 17.0.21.1.2 | Amazon Linux packages also out. Corretto 21/25: check vendor |
| Eclipse Temurin | 17.0.6+, 21, 25 (17.0.21, 21.0.13, 25.0.5 confirmed vulnerable) | Not released as of November 18 | Check vendor |
| Azul Zulu, Microsoft Build of OpenJDK, BellSoft Liberica, SAP SapMachine, Red Hat build of OpenJDK | 17.0.6+, 21, 25, 27 | Per vendor advisory | Version labels differ from Oracle’s. Check vendor |
| Distro openjdk-17 / -21 / -25 packages | Same ranges | Per distro tracker | Check vendor |
| OpenJDK 8, 11, 17.0.0 to 17.0.5 | Not affected | n/a | No AVX-512 decode stub |
The upstream fix ships in builds that carry JDK-8393212. A build whose number matches a “fixed” column can still run vulnerable code if it was built from a tree without that commit. If you build OpenJDK from source, check the commit, not the version string.
Exposure Analysis

| Environment | Risk Level | Reason |
|---|---|---|
| Keycloak, PingFederate (identity) | Critical | Calif claims pre-auth RCE in default config. IdP compromise means account takeover everywhere downstream |
| Jira, Confluence, Jenkins, Artifactory (dev and collaboration) | Critical | Calif claims pre-auth RCE in default config. They hold source, secrets, build and artifact supply chain |
| Other internet-facing Java with Basic auth, java-jwt, or Base64 uploads | Critical | Confirmed pre-auth paths. Trivial DoS. Custom RCE feasible |
| Kafka brokers, Solr, Elasticsearch, Gerrit, Spinnaker | High | Calif claims post-auth RCE. Reachable by any authenticated or internal user |
| Outbound Java clients (CI agents, crawlers, webhook senders, integrations) | High | Calif’s client-side variant: connecting over TLS to a malicious server is enough |
| Internal Java services on affected hardware | Medium | Requires a foothold or internal reach |
| ARM64 (Graviton, Ampere), older Intel (Cascade Lake and earlier), pre-Zen 4 AMD | Not affected | No AVX-512 VBMI |
Calif’s hardware check: the CPU must report all four flags, avx512f, avx512bw, avx512vbmi and bmi2. Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids qualify. So do AMD EPYC and Ryzen on Zen 4 or newer.
Hardware decides most of the triage. On AWS, the affected families include c6i, m6i, c7i, c7a and m7a. On-prem, Ice Lake and Sapphire Rapids Xeons and EPYC Genoa and Turin are in scope. Graviton fleets are out.
There is still no honest internet-wide count. JVM builds and CPU features are not visible from the network.
Real-World Impact
Realistic scenarios, in order of likelihood:
- Pre-auth denial of service. Malformed Authorization headers against a Basic-auth or java-jwt endpoint crash or destabilize the JVM. Low skill, available now.
- Heap disclosure. A capable attacker uses the JavaBleed stage alone. It pulls tokens, session secrets or private keys out of an IdP or CI server without running any code. That’s data theft with no crash, and maybe no log line beyond the malformed request.
- Targeted pre-auth RCE on named products. Calif has working chains for Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. Its own numbers (an hour to find, three hours to a first exploit, under $200) say others will follow. A Keycloak or PingFederate compromise means account takeover across every app it fronts. Jenkins or Artifactory gives a foothold in the software supply chain.
- Client-side compromise. A Java process that connects over TLS to an attacker-controlled server can be hit. That pulls build agents, scrapers and outbound integrations into scope, even when they expose no port.
- Fake PoCs. Leaked bugs attract malicious “exploits”. Treat any downloadable Java4Shell tool as hostile.
Calif lists real limits. Some grooming profiles need streamed request bodies. A reverse proxy that buffers the full body (nginx does by default) breaks those chains, but not all of them. Calif’s Elasticsearch chain uses a single complete request, and WebSocket traffic bypasses body buffering. The attack is also sensitive to network latency and jitter. Calif ran its attacks from a VM in the target’s cloud region. Treat these as speed bumps, not mitigations.
Detection Guidance
Log and network indicators
- Request shape: a Base64-alphabet token of 32 characters or more, ending in
=, whose length is not a multiple of 4. Valid padded Base64 always is, so false positives are low. Start with Authorization headers. - Application logs:
IllegalArgumentException: Input byte array has wrong 4-byte ending unit. It fired on every attempt in public reproduction tests. - JVM crashes: SIGSEGV with
hs_err_pid*.log, and bursts of worker or container restarts (exit 134). A crash is possible but not reliable, so pair it with the request signal. - Post-exploitation: shells or network tools spawned by
java, and unexpected outbound connections from Java service accounts. - JWT anomaly:
=padding inside JWT segments. JWTs use unpadded base64url.
VulnCheck ships Sigma, YARA, Snort and Suricata rules and PCAPs to its Initial Access Intelligence customers.
Scanner references
Phoenix Security SCA and container scanning find OpenJDK 17, 21, 25 and 27 runtimes in images and hosts. SBOM analysis (CycloneDX, SPDX) finds bundled JDKs. GitHub dependency scanning covers Dockerfile base images and toolchain files. External attack surface scanning finds exposed Jira, Confluence, Jenkins and Keycloak.
Verification steps for teams
- Find the running JVM:
readlink -f /proc/<PID>/exe, thenjcmd <PID> VM.version. In containers, check inside the workload, not on the host. - Check the CPU:
grep -o avx512vbmi /proc/cpuinfo | head -1. No output means the vulnerable path cannot run. - Check whether a mitigation flag is live:
java -XX:+PrintFlagsFinal -version | grep -E 'UseAVX|UseBASE64Intrinsics'. - Map each affected runtime to its exposure. Internet-facing services with Basic auth or java-jwt go first.
- Review SBOMs and vendor appliances for bundled JDKs.
Remediation Guidance
Immediate actions
- Patch. Oracle JDK to 17.0.21.1, 21.0.13.1, 25.0.5.1 or 27.0.1.1. Corretto 17 to 17.0.21.1.2. For every other distribution, take the fixed build from that vendor’s advisory and the OpenJDK advisory.
- Restart and verify the running build with
jcmd. A patched package on disk does nothing until the JVM restarts. - Rebuild images on fixed base tags and pin by digest.
- Prioritize AVX-512 VBMI hosts running Calif’s named products. Keycloak, PingFederate, Jira, Confluence, Jenkins and Artifactory go first. Kafka, Solr, Elasticsearch, Gerrit and Spinnaker go next.
- Rotate secrets held in the memory of any affected internet-facing JVM that showed crashes or malformed-token hits since November 16. The JavaBleed stage can leak them without code execution.
CISA’s alert asks for the same order of work: inventory JDKs, patch, and use compensating controls where you can’t patch yet.
Temporary mitigations
| Mitigation | Effect | Trade-off |
|---|---|---|
-XX:-UseBASE64Intrinsics (VulnCheck’s form adds -XX:+UnlockDiagnosticVMOptions first; harmless either way) | Portable Java decoder; stops the overflow (Calif; VulnCheck on 17, 21, 25; independent tests on all versions tested) | Slower Base64 decoding |
-XX:UseAVX=2 | Removes AVX-512 code paths entirely; also stops the overflow | Wider performance cost. x86-64 only: an ARM JVM does not recognize the flag and fails to start (Calif) |
| Reverse proxy buffers full request bodies | Breaks Calif’s streamed-request grooming for some products | Does not stop single-request chains (Elasticsearch) or WebSocket paths. Not a fix |
| Edge rule on the request shape above | Blocks malformed padded tokens in auth headers | Partial. Covers only the headers you inspect |
Set the flag in JAVA_TOOL_OPTIONS or on the java command line, then restart. No rebuild needed.
Do not push -XX:UseAVX=2 to a mixed x86/ARM fleet through a shared JAVA_TOOL_OPTIONS. The ARM JVMs will not start.
Two pieces of circulating advice are wrong. -XX:DisableIntrinsic=_base64_decodeBlock without -XX:+UnlockDiagnosticVMOptions stops the JVM from starting. Pushed fleet-wide, that’s an outage. And “fixed in 17.0.11 and 21.0.3” refers to JDK-8321599, an older data-loss bug in the same decoder.
Phoenix Security Recommendations
Java4Shell is a runtime CVE gated by hardware. A flat CVE list flags every Java 17+ container and host. It buries the ones that matter: AVX-512 VBMI hosts serving pre-auth Base64 to the internet.
Phoenix Security collapses the duplicates through contextual deduplication. One OpenJDK runtime seen by container scanning, SBOM ingestion and host agents becomes one finding.
Reachability analysis ranks internet-facing services with Basic auth or java-jwt above batch jobs on Graviton. Attack surface management finds exposed Jira, Confluence, Jenkins and Keycloak.
The Java4Shell remediation campaign targets OpenJDK 17, 21, 25 and 27 runtimes. It routes each one to its owner through ownership attribution. It tracks the fix until the running build moves, not just the package.
Phoenix Security correlates vulnerable runtimes with live workloads, finds exposed services through attack surface management, and assigns remediation ownership. A fleet-wide JVM problem becomes an owned, trackable backlog.
See the Java4Shell campaign on your own estate. Book a demo.
References
- OpenJDK Vulnerability Advisory for CVE-2026-114938, November 17, 2026
- Oracle Critical Security Patch Update, November 2026
- CVE-2026-114938 record on CVE.org
- CISA alert: critical Java vulnerability requires immediate patching, November 17, 2026
- CISA Known Exploited Vulnerabilities catalog
- Calif technical write-up: Java4Shell, by Quang Luong
- Calif disclosure statement on X
- VulnCheck analysis of Java4Shell
- Cardano Foundation defensive workaround, cardano-rosetta-java PR #900
- OpenJDK history of the decoder: JDK-8268276, the original AVX-512 Base64 optimization, JDK-8296735, the Java 17 backport, and JDK-8321599, the earlier data-loss bug in the same decoder
















