Java4Shell (CVE-2026-114938): What's Affected and How to Fix It
Java4Shell (CVE-2026-114938) is an OpenJDK RCE in Java 17.0.6+ on recent Intel and AMD servers. How to check if you're exposed, patch, or mitigate.
#Heads up: Java 17 or newer on a recent Intel or AMD server is probably exposed.
On November 17, 2026, CVE-2026-114938 was disclosed. It's nicknamed "Java4Shell." Java is the platform a lot of business software is built on, and the bug lives in the part of it that decodes Base64, a format web apps use constantly to pack data into plain text.
It's a heap-based buffer overflow, which means the program can be tricked into writing data past the edge of the memory it was given. The OpenJDK advisory rates it HIGH (CVSS 3.1: 8.1) on the standard 0 to 10 severity scale. It can lead to remote code execution: someone on the internet running their own commands on your server.
#The short version for business owners.
- What it is: a bug that can let someone on the internet run their own code on a server that runs Java. No login needed.
- Does it apply to you? Probably, if you run Java 17 or newer on an Intel or AMD server. The bug needs a processor feature called AVX-512 VBMI, which current server chips have and older ones don't.
- Who's safe: Java 8 and 11, and ARM servers (a different chip family, like Amazon's Graviton), are not affected.
- What fixing it costs: a Java update or one setting, plus a restart.
- What waiting costs: an open door through Thanksgiving week, when most teams are short-staffed and attackers know it.
- My advice: assume you're exposed until you've checked. Fix it before the holiday freeze. If a check shows you're not exposed, take the update in your normal cycle.
One catch: an older server can spare you today and stop sparing you tomorrow. Move an app to newer hardware, or let your cloud provider move it, and it can go from safe to exposed with no change on your side. As Sonatype put it, "That does not mean every Java application is exposed in the same way."
#If someone else runs your software.
Plenty of business software runs on Java without advertising it. If a vendor or managed service hosts yours, send them one email: "Are you affected by CVE-2026-114938 (Java4Shell), and when will your Java runtimes be on a fixed build or have the workaround in place?" Get the answer in writing.
The next few sections are for whoever decides when to act. After that it gets technical, for whoever runs the servers.
#Risk vs reward: act this week, or after the holidays?
A quick decoder for the table. A JVM (Java Virtual Machine) is the engine that runs Java programs on a server, and a JDK is the Java package your team installs. A load balancer is the traffic cop that sits in front of your web servers and spreads visitors across them.
| Act this week | Wait until after the holidays | |
|---|---|---|
| What it costs you | A fixed JDK build, or one JVM flag. A restart. Base64 decoding gets a little slower, and almost nothing notices. | Nothing today. |
| What can go wrong | The flag lands in the wrong variable and a Java 8 job refuses to start. You see it right away and fix it. | Exposed servers stay open through Thanksgiving and Black Friday, while your team is out. |
| Worst case | A restart during business hours. If you run more than one copy behind a load balancer, a rolling restart avoids downtime. | Someone runs code on a server that handles your customers' logins and data. |
#Why waiting costs more than it looks.
Holidays are when attackers move. CISA and the FBI warned in 2021 about high-impact ransomware attacks on holidays and weekends, "when offices are normally closed." CISA is the federal government's cybersecurity agency. Not much has changed since.
Semperis found that more than three-quarters of companies cut SOC staffing by half or more on holidays and weekends. (A SOC, or security operations center, is the team that watches for attacks.) Sophos found that 88% of ransomware payloads are deployed outside business hours.
The patch itself starts a clock. OpenJDK is open source, so anyone can compare the code before and after the fix. On November 16, Google's threat intelligence team reported attackers using an AI framework that does this for popular web software: it diffs patched code, drafts an exploit and runs it, with no human in the loop.
Last month, Amazon saw PHP2Shell exploitation start four days before the patch shipped. And Mandiant's M-Trends 2026 estimates time-to-exploit for 2025 at minus seven days. Exploits now tend, on average, to show up before the fix does.
A breach costs far more than a restart. IBM's Cost of a Data Breach Report 2026 puts the global average cost of a breach at $4.99 million, a record high. That's an average across organizations of every size. Your number may be smaller, but so is the bank account that has to absorb it.
#When your risk is genuinely low.
Not everyone needs to rush. Your exposure is low or zero if:
- You run Java 8 or Java 11. Standard builds are not affected. Oracle's Java 8 Enterprise Performance Pack build is the exception.
- Your servers are ARM64, the non-Intel, non-AMD chip design. AWS Graviton and Apple Silicon are not affected.
- Your x86 (Intel or AMD) hosts are an older generation, and you checked. Skylake and Cascade Lake parts, like AWS m5 and c5, lack VBMI. This is the weakest reason on the list. Current Intel and AMD server chips have VBMI, and one move or resize onto newer hardware exposes you.
- Nothing untrusted reaches the JVM. An internal batch job that only reads your own data is a much smaller risk than a public login page.
To be fair to Java4Shell: Cloudflare Radar, citing Aikido, reported no exploitation as of November 17, and Cycode says it wasn't in CISA's Known Exploited Vulnerabilities catalog as of November 18. It's rated hard to exploit. The hardware it needs is less of a barrier than it sounds, because current server chips have it.
Bottom line: the fix is cheap and a miss is expensive. Nobody is known to be exploiting this yet, which gives you a quiet window. Use it this week, before the freeze.
#What it actually is.
From here down, this is for whoever runs your servers.
To make Java faster, HotSpot swaps parts of java.util.Base64 for CPU-specific shortcuts called intrinsics. On x86-64 processors with AVX-512 VBMI, the decode intrinsic mishandles crafted input and writes past the end of a heap buffer.
So the question becomes: does anything in your stack Base64-decode data an attacker can send you? Almost certainly yes:
- JWTs
- Basic auth headers
- Data URIs
- Webhook payloads
- SAML responses
- Anything a framework decodes for you without asking
You never have to call the decoder yourself for this to matter. Your framework is happy to do it for you, no questions asked.
#Who is affected.
All three of these have to be true:
- OpenJDK 17 or later. Wiz puts the floor at 17.0.6. Standard Java 8 and Java 11 are not affected. Oracle's Java 8 Enterprise Performance Pack build is the exception.
- x86-64. ARM64, including Graviton and Apple Silicon, is not affected.
- A CPU with AVX-512 VBMI. Intel Ice Lake and later server parts (Sapphire Rapids, Emerald Rapids, Granite Rapids), and AMD Zen 4 and later. That's current x86 server hardware. Older parts like Skylake and Cascade Lake lack it.
Don't count on the CPU condition to protect you. It rules out older chips, not current ones. In AWS terms, Skylake and Cascade Lake families like m5 and c5 lack VBMI. Ice Lake families like m6i and c6i have it, and so do Zen 4 families like m7a and c7a.
Outside the cloud, a server bought in recent years will likely qualify too. Watch for one gotcha: the same container image can be safe on an old node today and exposed after a reschedule onto a newer one. The scheduler doesn't ask first, and it definitely doesn't send a memo.
Don't trust a table, including this one. Check your own fleet.
#How to check a host
grep -o avx512vbmi /proc/cpuinfo | head -1
If that prints avx512vbmi, the CPU qualifies. Then check whether the JVM actually has the intrinsic turned on:
java -XX:+PrintFlagsFinal -version 2>/dev/null | grep UseBASE64Intrinsics
true on JDK 17+ on a VBMI host means you're exposed until you patch or mitigate.
Here's what that looks like across three nodes running the same image, and then the workaround applied and verified:
#The workaround: turn the intrinsic off.
-XX:-UseBASE64Intrinsics
Base64 then takes the plain Java path. It's slower, but almost nothing will notice. The flag is easy. Getting it onto every JVM is where the surprises are.
#JAVA_TOOL_OPTIONS vs JDK_JAVA_OPTIONS
| Variable | Reaches | Watch out for |
|---|---|---|
JAVA_TOOL_OPTIONS | Every JVM: java, javac, keytool, jar, embedded JVMs | Java 8 refuses to start with this flag, even with -XX:+IgnoreUnrecognizedVMOptions |
JDK_JAVA_OPTIONS | Only the java launcher, Java 9+ | Misses javac, keytool, jar and JNI-embedded JVMs. Java 8 ignores it, so it's safe on mixed hosts |
The Java 8 behavior is what bites build images. Many images ship several JDKs side by side, and setting JAVA_TOOL_OPTIONS globally breaks the Java 8 one. Two patterns worked:
- Per-version gating in images. Set
JAVA_TOOL_OPTIONSonly in the 17+ variants. With a DockerfileARGper major version,ENV JAVA_TOOL_OPTIONS=${MITIGATE:+-XX:-UseBASE64Intrinsics}expands to nothing for 8 and 11. JDK_JAVA_OPTIONSon mixed hosts, like VM images with Java 8 next to 17 and 21. You trade coverage ofjavacand friends for not breaking Java 8.
JDK 11 accepts the flag. It isn't vulnerable, but setting it there is harmless.
#Where the workaround breaks.
- Your value replaces the image's value. If a job or deployment already sets
JAVA_TOOL_OPTIONS(for-Xmxor a trust store), it silently drops the mitigation. Append instead:JAVA_TOOL_OPTIONS="-Xmx2g -XX:-UseBASE64Intrinsics". - A new line on stderr. The JVM prints
Picked up JAVA_TOOL_OPTIONS: ...(orNOTE: Picked up JDK_JAVA_OPTIONS: ...). Scripts that parsejava -version 2>&1 | head -1now get that line. On Windows, PowerShell with$ErrorActionPreference='Stop'and2>&1can turn it into a terminating error. sudostrips it.env_resetdrops both variables, and it's very polite about it: no warning, no error, just gone. Usesudo -Eor pass the flag explicitly.- Sidecars and service containers don't inherit it. A JVM-based sidecar (Elasticsearch, Kafka, Keycloak) needs the variable set on its own container spec.
- Shells that don't source your profile. If you set the flag in a bash rc file,
/bin/shsteps and non-login shells won't see it. - Bundled JREs. Tools that ship their own runtime don't use your system JDK. One database migration tool's official image bundled a Temurin JRE and, two minor releases after disclosure, was still shipping the unfixed build. Inventory these separately.
- You verified the Dockerfile instead of the process. Run the
PrintFlagsFinalcheck inside the running container or host. That's the only proof.
#Fixed builds, and the gap between "released" and "available."
Fixed builds arrived quickly, but unevenly:
- Eclipse Temurin shipped 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1 for Linux x64 about a day after disclosure. aarch64 builds lagged, and at first one major line had a fixed aarch64 build only for Alpine. Multi-arch images couldn't move to the fixed JDK until every architecture had it.
- Official container base images (tags like
eclipse-temurin:21-jdk) lagged the Temurin release itself. If your Dockerfile isFROMthe official tag, a rebuild may still hand you the old JDK. Check the version inside the image, not the tag name. - Ubuntu published fixed packages in USN-9155-1 (openjdk-17), USN-9156-1 (openjdk-21), USN-9157-1 (openjdk-25) and USN-9158-1 (openjdk-27). For a while, one scanner's "fixed version" field ran ahead of what Ubuntu had actually published. So "a fix exists" in the scanner did not mean
apt upgradewould install one, andaptwould cheerfully tell you there was nothing to do. Check the distro tracker.
If you're on a Java version that's out of support, there may be nothing to install. Cycode notes that end-of-life Java 18 to 20, 22 to 24 and 26 share the vulnerable code and get no fix. Use the flag, then move to 17, 21, 25 or 27.
The same OpenJDK release fixed nine other CVEs. Even where Java4Shell doesn't apply to you, the fixed builds are worth taking.
#Rollout lessons.
- Images pinned by digest or old tags don't move. If you publish images, updating tags in place reaches most consumers, but digest pins and old version tags keep the vulnerable build. Say so plainly in your customer guidance.
- Merging before the build finishes can strand a release. With a "build on the branch, promote on merge" pipeline, merging mid-build breaks promotion because the staging image doesn't exist yet.
- Not every repo rebuilds on every merge. Some image pipelines only build when a manifest or generated file changes. A mitigation-only change can merge and never ship. Confirm a new image was actually published.
- Scanner exceptions need the exact ID. If your scanner blocks builds on this CVE and you add a time-boxed risk exception, copy the CVE ID from the finding instead of typing it. An exception for the wrong ID matches nothing, and the build stays blocked. Six digits after the year is a lot to type correctly at 11 p.m.
#Detection: what to hunt for.
Patching is the fix. Detection tells you whether you need to dig further.
- A Java process spawning a shell (
java→sh/bash). Most EDR and workload-protection tools ship a rule for it, and it fits post-exploitation for this bug. - JVM crashes. A failed exploit attempt usually means a crash. Look for
hs_err_pid*.logfiles, sudden container restarts, and load balancer 502/503s clustered in time. - Odd Base64 in request logs. Unusually long Base64 runs in URLs and headers, and strange padding (runs of
=or a=mid-token). - Know the blind spot. Load balancer access logs don't record POST bodies, and that's where most Base64 payloads would live. "Clean access logs" is weaker evidence than it sounds.
#Look at what's exposed first.
Before you hunt, list what's actually reachable. In most organizations the realistic risk is the forgotten demo or test service, not the hardened production fleet: an old JDK behind a public load balancer, no auth, debug endpoints open.
Every company has one. Somebody set it up for a single sales call, and it's still running years later. Shutting those down beats patching them.
#Before you log off for Thanksgiving.
Thanksgiving is November 26. Black Friday is the 27th. For a lot of businesses that means a change freeze (a stretch where nobody touches production), then a week where half the team is out.
Get this done before the freeze starts. Nobody wants to be patching Java between the turkey and the pie.
If you run the servers:
- Inventory JVMs at version 17 or later, including bundled JREs and sidecars. Treat every one on x86-64 as exposed until a host check says otherwise.
- Move to a fixed vendor build where one exists for every architecture you ship. Otherwise, set
-XX:-UseBASE64Intrinsics:JAVA_TOOL_OPTIONSwhere Java 8 isn't present,JDK_JAVA_OPTIONSwhere it is. - Verify with
PrintFlagsFinalinside the running container or host, not in the Dockerfile. - Shut down exposed one-off services rather than patching them.
- Hunt: Java spawning shells, JVM crash logs, load balancer 5xx clusters, long Base64 in request logs.
- Put a ticket in to remove the flag once fixed builds are everywhere, or it stays forever.
For everyone:
- If a vendor hosts your Java apps, get their answer in writing before Wednesday.
- Name an on-call person for Thursday through Sunday, and make sure they can actually reach the hosts.
- Write down who to call if something looks wrong: your hosting provider, your IT partner, your cyber insurance hotline.
#Not sure what's running Java? Start with an inventory.
The flag is one line. The painful part of this one was inventory. Which JVMs do you run? Which ones are bundled inside tools you forgot about? Which nodes did the scheduler put them on? If you can't answer those quickly, start there.
That's the part we help with. We list every JVM you run, including the ones bundled inside other tools, with its version and the CPU it actually lands on. We check from outside your network what's reachable, and check the flag and version inside the running processes.
You get a written answer, system by system: exposed or not, the fix, and who owns it. Your team, your insurer or a customer can read it. If something is exposed, we help you roll out the fix and prove it took.
If you're not sure where you stand, book thirty minutes. No pitch. We'll look at what you run and tell you straight whether it needs attention before Thanksgiving.
#Further reading
- NVD: CVE-2026-114938 - official vulnerability entry
- OpenJDK Vulnerability Group Advisory, 2026-11-17 - CVSS details and affected versions
- Adoptium: Temurin November 2026 CSPU - fixed Temurin builds
- Wiz Research: CVE-2026-114938 - RCE analysis
- Ubuntu CVE Tracker - fixed packages (USN-9155-1, USN-9156-1, USN-9157-1, USN-9158-1)
- Sonatype: Critical OpenJDK RCE CVE-2026-114938 - affected builds and exposure factors
- Cycode: Java4Shell - end-of-life versions and exploitation status
- Cloudflare Radar: Java4Shell - status summary and fixed versions
- CISA/FBI AA21-243A: Ransomware Awareness for Holidays and Weekends - why attackers like holiday weekends
- Google GTIG: Agentic Threat Activity Crosses a Significant Threshold - fully automated patch diffing and exploitation
- BleepingComputer: PHP2Shell exploitation began 4 days before patches - exploitation ahead of patches
- IBM: Cost of a Data Breach Report 2026 - global average breach cost