Free Java4Shell scanner - check Java services for CVE-2026-114938
Scan your Java services for Java4Shell (CVE-2026-114938), the OpenJDK Base64 decoder flaw that can lead to pre-authentication remote code execution, and get a PDF report with the documented finding.
The scanner reads the Java version from endpoints that already expose it and shows if that version is affected. It provides the version evidence behind the result, and the fixed build to install. It never sends the exploit payload.
Need to find every Java service first? The Network Vulnerability Scanner maps them across your attack surface.
- Scan type
Light scan
Scan your Java services for Java4Shell (CVE-2026-114938), the OpenJDK Base64 decoder flaw that can lead to pre-authentication remote code execution, and get a PDF report with the documented finding.
The scanner reads the Java version from endpoints that already expose it and shows if that version is affected. It provides the version evidence behind the result, and the fixed build to install. It never sends the exploit payload.
Need to find every Java service first? The Network Vulnerability Scanner maps them across your attack surface.

Does Java4Shell affect my Java servers?
Java4Shell needs four conditions at once:
an affected JVM (Java 17.0.6 through 17.0.21, or Java 21, 25, or 27 before the November 17, 2026 fixes)
an x86-64 CPU with AVX-512 VBMI (Intel Xeon Ice Lake and newer, AMD Zen 4 and newer)
untrusted Base64 reaching
Base64.getDecoder()orgetUrlDecoder()a JIT-compiled decoder, which any busy service has
Java 8, Java 11, and ARM hosts aren't affected.
This free scanner checks the first one. Our Java4Shell deep dive shows how to check the other three on the host.
How we detect Java4Shell (CVE-2026-114938)
Confirming Java4Shell directly means sending malformed Base64 that writes past a buffer on the target's heap, or probing the memory it leaks. Either one can crash the service. We do neither.
Instead, our Java4Shell Scanner checks the one condition visible from the outside: the Java version.
- Method: the scanner connects to ports 443, 8393, and 9200 and reads the Java version from endpoints and headers that already expose it:
- Apache Solr
- Elasticsearch and OpenSearch
- Spring Boot Actuator
- Quarkus
- Jolokia
- Hadoop JMX
- the
X-Powered-Byheader
- Match condition: the reported version falls in an affected range: 17.0.6 to 17.0.21, 21 before 21.0.13.1, 25 before 25.0.5.1, or 27 before 27.0.1.1.
- What we can't see from the outside:
- The CPU. The bug only triggers on x86-64 CPUs with AVX-512 VBMI.
- JVM mitigation flags, such as
-XX:-UseBASE64Intrinsics. - Vendor builds that ship the fix under the same version number.
- Whether your application passes untrusted Base64 to the decoder.
- Services that don't expose their Java version, which includes many Keycloak, Jira, Confluence, Jenkins, Artifactory, and PingFederate deployments.
- How to read a finding: "this host runs an affected Java version." Then confirm the CPU and JVM flags on the host. If the scan can't read a version, treat the result as unknown, and check the runtime with
java -version. - Safety: the scanner sends only standard HTTP requests to endpoints that already expose the Java version. It never sends malformed Base64, the exploit payload, or a probe for the memory leak.
- CVE coverage: CVE-2026-114938 only.
- Evidence and confidence: each finding includes the Java version, the endpoint or header it came from, and the port.
- A side note on exposed endpoints: if the scanner reads your Java version from Spring Boot Actuator, Jolokia, or Hadoop JMX, that endpoint likely exposes more than a version string, such as configuration, environment variables, or management operations. Restrict it to internal networks, whether or not you're affected.

Java4Shell only bites when four things line up: an affected Java build, a CPU with AVX-512 VBMI, untrusted Base64 reaching the decoder, and a JIT-compiled decoder. From the outside, we can see the first one, and only when a service volunteers its Java version.
So that's what this free scanner checks. It reads the version from Solr, Elasticsearch, Spring Boot Actuator, and the other endpoints that already expose it.
We don't send the exploit payload, and we don't probe for the memory leak, because either one could take down the server you're trying to protect.
Treat a finding as your cue to check the CPU and the JVM flags on that host. And if the scan can't read a version, don't count that as a pass. Check the runtime directly.
Product Security Manager at Pentest-Tools.com
Free Java4Shell scanner report (PDF) sample
The report helps anyone who needs to patch a Java runtime or hand the finding to the team that owns it. For Java4Shell, the vulnerability scan report includes:
the finding with the tested host and port, the Java version, and the endpoint or header that exposed it
the fixed Java builds for each version line and vendor
the host-level checks you still need to do yourself: CPU support for AVX-512 VBMI and JVM flags
severity and step-by-step remediation, including the temporary
-XX:-UseBASE64Intrinsicsflag
The scan also collects open ports, DNS records, and detected technologies.
Download sample report (PDF)What is Java4Shell (CVE-2026-114938)?
Technical details
Java4Shell is a heap out-of-bounds write in the Base64 decoder built into OpenJDK's HotSpot JVM.
On x86-64 CPUs with AVX-512 VBMI, HotSpot swaps Java's Base64 decoding for a hand-written assembly routine to speed it up. That routine misses an edge case.
A malformed 65-byte input (64 valid characters followed by a stray =) makes the routine compute an output length of -1. The write mask then covers all 64 bytes, and the routine writes 62 bytes past the end of the output buffer. Java rejects the input as invalid, but by then the neighboring heap objects are already corrupted.
The fix, JDK-8393212, adds a three-line length check. Oracle and OpenJDK shipped it on November 17, 2026, the same day Calif, the team that found the flaw, published its write-up.
What an attacker can do by exploiting Java4Shell
- Corrupt heap memory in the JVM and read it back, in the style of Heartbleed, without credentials, when an unauthenticated path reaches the decoder
- Potentially run code with the Java process's privileges. Calif reports pre-auth RCE in Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate in default configurations, and post-auth RCE in Kafka Broker, Solr, Elasticsearch, Gerrit, and Spinnaker. As of November 18, 2026, nobody has independently verified these claims.
- Attack Java clients that connect to a malicious TLS server (per Calif)
Calif also says no universal exploit exists yet: each target needs its own decoder route, a writable buffer, a feedback channel, and the right heap layout.
Any product that bundles an affected Java runtime inherits the flaw, including container images and appliances. Check those with the vendor.
Potential business impact: what this can mean for your organization
The risk depends on what the affected service does:
- Identity providers (Keycloak, PingFederate): code execution there lets an attacker mint sessions for every application that trusts the provider.
- CI/CD and artifact stores (Jenkins, Artifactory): these hold build credentials, signing keys, and the artifacts other teams deploy, so one foothold can become a supply chain incident.
- Collaboration tools (Jira, Confluence): architecture docs, incident notes, and credentials pasted into tickets give an attacker a map of the rest of your environment.
- Availability: heap corruption can crash the JVM and drop every request it serves.
If a compromise leads to a personal data breach, GDPR gives you 72 hours to notify, and NIS2 asks organizations in scope for an early warning within 24 hours.
Java versions vulnerable to Java4Shell
Java 17, 21, 25, and 27 are vulnerable in every OpenJDK-based distribution, on x86-64 CPUs with AVX-512 VBMI.
Status as of November 18, 2026:
| Distribution | Vulnerable versions | Fixed in |
|---|---|---|
| Oracle Java SE 17 | 17.0.6 to 17.0.21.0.3 | 17.0.21.1 |
| Oracle Java SE 21 | 21.0.13.0.3 and earlier | 21.0.13.1 |
| Oracle Java SE 25 | 25.0.5.0.3 and earlier | 25.0.5.1 |
| Oracle Java SE 27 | 27.0.1.0.3 and earlier | 27.0.1.1 |
| Oracle Java SE 8 Performance Pack | 8u511b33-perf | 8u513-perf |
| Oracle GraalVM | Builds on affected JDK 17 and 21 releases | GraalVM for JDK 17.0.21.1 and 21.0.13.1; Enterprise Edition 21.3.20.1 |
| Amazon Corretto | 17, 21, 25, and 27 builds before the fix | 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4 |
| Azul Zulu (free builds) | 17, 21, 25, and 27 builds before the fix | 17.70.201, 21.54.201, 25.38.201, 27.30.201 |
| Red Hat build of OpenJDK and RHEL packages | Affected | Fix pending as of November 18, 2026 |
| Eclipse Temurin, Microsoft Build of OpenJDK, BellSoft Liberica, SAP SapMachine | Affected | On each vendor's schedule |
Not affected: standard Java 8 and Java 11, Java 17.0.0 through 17.0.5, ARM64 hosts, and x86-64 CPUs without AVX-512 VBMI.
Two notes to consider when assessing your servers:
- Vendor builds can carry the fix under a version number that looks unpatched, so check the vendor's release notes, not only the version string.
- "Fixed in 17.0.11 and 21.0.3" refers to JDK-8321599, an older bug in the same decoder. Those versions are still vulnerable to Java4Shell.
Java4Shell severity score unpacked
- Oracle (CNA): CVSS v3.1 base score 8.1
- Calif: CVSS v4.0 base score 9.2
- NVD: not yet assigned
Scoring factors:
- Reachable over the network
- No authentication required on paths that decode Base64 before login
- No user interaction required
What slows exploitation: the CPU requirement, a per-target exploit, and the need for the right heap layout.
The TL;DR for leadership: Java 17, 21, 25, and 27 services on recent Intel Xeon or AMD Zen 4 hardware that decode untrusted Base64 before login are exposed to heap corruption, with claimed pre-auth RCE in widely used products. Patching the JVM closes it, and a JVM flag buys time.
Java4Shell disclosure timeline
| Date | Event |
|---|---|
| November 12, 2026 | The fix, JDK-8393212, lands in the public jdk17u repository |
| November 17, 2026 | Oracle and OpenJDK release fixed builds; Calif publishes its write-up and a safe reproducer |
| November 17, 2026 | CISA publishes an alert urging immediate patching |
| November 17, 2026 | Kevin Breen (Immersive) reports a working exploit that needs adapting per application |
| November 17, 2026 | We publish our Java4Shell deep dive |
| November 18, 2026 | A lab-grade reproduction of the memory write appears publicly |
| November 18, 2026 | We add Java4Shell detection to the Network Vulnerability Scanner |
| November 18, 2026 | We launch this free Java4Shell scanner |
Use our free Java4Shell checker
Java4Shell exploitation - how attackers could use this Java vulnerability
No credentials required: yes, on paths that decode Base64 before authentication (per Calif)
No user interaction required: yes
Remotely exploitable: yes, when an affected JVM on a CPU with AVX-512 VBMI decodes attacker-supplied Base64
Public proofs-of-concept: a lab-grade reproduction of the memory write (ikow/java4shell-poc) and Calif's safe reproducer. No public code reaches code execution in a product as of November 18, 2026
Unreleased exploits: Calif holds back its product exploits; Kevin Breen reports a per-application exploit he hasn't released
Exploited in the wild: no reports as of November 18, 2026
CISA KEV: not listed as of November 18, 2026
Common pre-login paths to check in your own apps:
- SSO and identity providers
- Basic authentication (for example in Apache Tomcat)
- JWT handling (for example the java-jwt library)
- File uploads
- Network messages
If exploitation succeeds, an attacker can:
Run code with the Java process's privileges
Read secrets, tokens, and credentials the process holds
In containers, read mounted service account tokens or request cloud credentials, depending on the setup
Reach the systems that trust the compromised service, such as every app behind an identity provider
A word of caution: some repositories labeled "Java4Shell PoC" are only local version checkers. Treat any PoC for this bug as untrusted code and run it only in an isolated lab.
Why this may move fast: Calif reports finding the bug with AI assistance in about an hour, and building a first working exploit two hours later, for under $200 in AI tokens. That's their timeline, not an independently checked one, but it suggests per-target exploits may not stay rare.
How to mitigate Java4Shell
- Complete fix: install your vendor's fixed Java build (see the table above). Updating the Java runtime is the only complete fix. Start with internet-facing services that decode untrusted input before login.
- Upgrade path:
- Oracle Java SE and GraalVM: install the November 17, 2026 builds.
- Amazon Corretto and Azul Zulu: install the fixed builds listed above.
- Red Hat, Temurin, Microsoft, Liberica, and SapMachine: watch your vendor's advisories.
- Containers: rebuild images on a patched base image.
- Products that bundle Java (Jira, Confluence, Keycloak, appliances): ask the vendor for its fixed build or how to swap the runtime.
- Verification: on each host, run
java -version, check the CPU withgrep -m1 -o avx512vbmi /proc/cpuinfo, and check the JVM flags withjcmd <pid> VM.flags -all | grep UseBASE64Intrinsics. Then rescan with this scanner. - Temporary control: start the JVM with
-XX:-UseBASE64Intrinsics. It stopped the overflow on every affected version Upwind tested. Test the performance impact on a staging host first. - Two pieces of advice to ignore:
- Don't use
-XX:DisableIntrinsic=_base64_decodeBlockon its own. It stops the JVM from starting, and pushed throughJAVA_TOOL_OPTIONS, it causes a fleet-wide outage. - Don't trust "fixed in 17.0.11 and 21.0.3." That's JDK-8321599, a different bug.
- Don't use
- Monitoring option: public detection rules for Suricata, Sigma, and ModSecurity flag short, malformed Base64 values that end in a stray
=in authentication headers, tokens, and upload fields. They help you spot probing, but they can't tell you whether a host is vulnerable. - Closing note: the JVM flag removes the vulnerable code path while it stays set. Patching removes the bug.

Get your free Java4Shell scan report
About our Network Vulnerability Scanner
Our Network Vulnerability Scanner is a well-rounded tool for all your network security assessments.
It combines multiple engines and fine-tuned scan settings that surface more than 17,500 vulnerabilities, misconfigurations, and outdated services. Each scan automatically updates your attack surface.
See what else it can doJava4Shell FAQs
What is Java4Shell?
Java4Shell (CVE-2026-114938) is a heap out-of-bounds write in the Base64 decoder built into OpenJDK. It affects Java 17, 21, 25, and 27 on x86-64 CPUs with AVX-512 VBMI. Calif, the team that found it, reports it can lead to pre-authentication remote code execution in products such as Keycloak and Jira.
How does the Java4Shell scanner work?
It reads the Java version from endpoints that already expose it (Solr, Elasticsearch, OpenSearch, Spring Boot Actuator, Quarkus, Jolokia, Hadoop JMX, or the X-Powered-By header) and checks it against the affected ranges.
It never sends the exploit payload or probes the memory leak, because either could crash the server.
Why can't the scanner confirm that my server is vulnerable?
Three of the four conditions don't show from the outside: the CPU, whether your app decodes untrusted Base64, and JVM flags such as -XX:-UseBASE64Intrinsics.
A finding tells you a host runs an affected Java version. Confirm the rest on the host.
The scan couldn't read my Java version. Am I safe?
We can't tell. Most Java services don't expose their version, which is good practice.
Run java -version on the host, or ask the vendor of the product that bundles Java.
Does ARM or AWS Graviton protect against Java4Shell?
Yes. The vulnerable routine only runs on x86-64 CPUs with AVX-512 VBMI. ARM64 hosts, including AWS Graviton, aren't affected.
Watch out for autoscaling groups and clusters that mix CPU types, though: the same image can be exposed on one node and safe on another.
Does -XX:-UseBASE64Intrinsics protect against Java4Shell?
Yes, while it stays set. The flag stopped the overflow on every affected version Upwind tested.
Test the performance impact first, and patch the JVM when you can.
Don't use -XX:DisableIntrinsic=_base64_decodeBlock on its own: the JVM won't start.
How does Java4Shell compare to Log4Shell?
Log4Shell was a logic bug in a logging library, exploitable with one string across most apps that used it.
Java4Shell is memory corruption in the JVM, depends on the CPU, and needs a per-target exploit.
Fewer hosts qualify, and each exploit takes more work, but exposure is harder to inventory.
Which applications are affected?
Any Java application that decodes untrusted Base64 on an affected JVM and CPU.
Calif demonstrated pre-auth RCE in Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate, and post-auth RCE in Kafka Broker, Solr, Elasticsearch, Gerrit, and Spinnaker.
Why are you offering a free scanner for Java4Shell?
Every day, our team develops tools, detections, and exploits to help security professionals find vulnerabilities before attackers can exploit them.
We know the fight is unfair: security teams follow strict rules, while threat actors do whatever they want. That's why we build free tools like this one, so security teams can validate their exposure quickly, without waiting for a scheduled scan or a costly engagement.






