Java 17 RCE Vulnerability CVE-2026-114938: Are You at Risk?

The CyberSec Guru

Updated on:

Java 17 RCE Vulnerability CVE-2026-114938

If you like this post, then please share it:

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Why your support matters: Zero paywalls: Keep the main content 100% free for learners worldwide.

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

UPDATE: Java4Shell (CVE-2026-114938): Confirmed OpenJDK Base64 Flaw With Demonstrated RCE

The open questions around CVE-2026-114938 closed on November 17. That day Calif published its technical analysis of Java4Shell, a memory-corruption flaw in the hardware-accelerated Base64 decoder inside OpenJDK HotSpot, and Oracle and OpenJDK shipped fixes. The bug scores 9.2 under CVSS 4.0, while Oracle rates it 8.1 under CVSS 3.1.

The earlier suspicion pointed at the AVX-512 Base64 optimization that arrived in Java 17.0.6, and it was right. Calif traced the problem to a calculation error in the x86-64 assembly routine that handles padded Base64 input. Under specific conditions the routine writes past the end of an allocated Java byte array and can corrupt the objects sitting next to it on the JVM heap.

The research goes well past a crash. Calif reports unauthenticated remote code execution against default configurations of Keycloak, Atlassian Jira, Confluence, Jenkins, JFrog Artifactory and PingFederate. It also demonstrated authenticated exploitation against Apache Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. A second technique, JavaBleed, can expose memory belonging to the running Java application, which, depending on the process, could include authentication tokens, cryptographic keys, personally identifiable information and other secrets.

Running Java does not make an application exploitable. Exploitation needs an affected OpenJDK build, an x86-64 processor with AVX-512 VBMI support, and an application path that passes attacker-controlled data to the Base64 decoder. Calif also says its working remote exploits depend on application-specific heap layouts and exploitation chains. Even so, this is a genuine memory-safety failure in the Java runtime, with working demonstrations against widely deployed enterprise software.

Java4Shell at a glance

  • CVE: CVE-2026-114938, nicknamed Java4Shell by Calif
  • Severity: CVSS 4.0 score of 9.2, CVSS 3.1 score of 8.1 (Oracle)
  • Bug class: heap buffer overflow in HotSpot’s AVX-512 Base64 decoder intrinsic (VulnCheck describes the root cause as an integer underflow)
  • Affected: OpenJDK 17.0.6 and later, plus downstream builds, until the November 17 fixes are applied
  • Hardware needed: x86-64 with AVX-512 VBMI
  • Fixed in: 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1 (upstream OpenJDK)
  • Temporary mitigation: -XX:-UseBASE64Intrinsics
  • In-the-wild exploitation: none reported at the time of writing

What is Java4Shell (CVE-2026-114938)?

Java4Shell is the name Calif gave to CVE-2026-114938, a heap buffer overflow in the AVX-512 Base64 decoder that OpenJDK HotSpot uses on x86-64 processors. A malformed Base64 input makes the decoder write about 62 bytes past its output array, and researchers turned that write into information disclosure and remote code execution in several enterprise products.

Where the OpenJDK Base64 intrinsic goes wrong

The flaw sits on the boundary between Java’s memory-safe execution model and the native machine instructions HotSpot uses to speed up hot operations.

Why HotSpot swaps in native Base64 code

Applications normally reach the decoder through java.util.Base64, for example Base64.getDecoder().decode(). The Java implementation validates input and relies on array bounds checks to keep memory access inside allocated objects.

HotSpot does not always run that Java code. When the optimizing compiler recognizes a supported Base64 operation, it can substitute a processor-specific implementation written in native instructions. These routines are called intrinsics. They skip much of the per-byte overhead of Java and use SIMD instructions to transform large blocks of data in parallel.

On x86-64 processors with AVX-512 Vector Byte Manipulation Instructions (VBMI), HotSpot can process Base64 input in 512-bit vector registers. Each register holds 64 bytes, so the decoder handles 64 Base64 characters per block and produces up to 48 decoded bytes. The implementation leans on byte-permutation instructions, lookup operations, vector masks and specialized stores to turn six-bit Base64 values back into eight-bit binary data.

Enterprise software benefits a lot from this, since it constantly decodes authentication headers, serialized objects, certificates, API tokens and uploaded files.

📬 Stay Ahead of Cyber Threats

Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.

How the AVX-512 Base64 decoder overflows the heap

The native intrinsic gets no help from Java’s ordinary array bounds checks. It works directly on memory addresses tied to Java heap objects, so the assembly has to guarantee on its own that every load and store stays inside the destination array.

CVE-2026-114938 breaks that guarantee. The vulnerable routine, base64_decodeBlock, mishandles one combination of input length and Base64 padding. The result is an invalid output length, which then feeds into the mask that controls a vectorized memory store. Instead of limiting the store to the space left in the output array, the routine can write past the array’s boundary.

So Java4Shell is a flaw in HotSpot’s native implementation. The malformed Base64 only triggers it. Chainguard independently reproduced the defect and traced a JVM crash to the same routine.

Some background on the mechanics helps here. Base64 encodes three bytes of binary data as four printable characters, each carrying six bits, so a 24-bit group rebuilds into three bytes. Padding characters mark a final group that holds fewer than three original bytes, and a compliant decoder has to check that their number and placement are valid before it accepts the result.

HotSpot’s optimized code handles large groups of characters efficiently. Trouble starts at the end of the buffer, where the leftover characters no longer fill a vector-sized block. Calif found a malformed-input case in which the decoder processes complete vector blocks and then meets a short, incorrectly padded remainder. The padding calculation can go negative, and when that value builds the mask for a 512-bit vector store, the mask stops reflecting how many bytes the array can actually take. All 64 byte positions can end up enabled, even though far less space remains.

Calif documents a 65-character Base64 input as an example. Java allocates a 50-byte result array, and the native routine can write another 62 bytes beyond its end.

The write also happens before the decoder finishes rejecting the invalid input. An application can receive an IllegalArgumentException while the heap is already corrupted. Many applications catch Base64 decoding exceptions and answer with an authentication failure or an HTTP 400, and that handling does nothing to undo native memory writes made before the exception was thrown. The caller may believe it dealt with the bad input safely while unrelated objects in the Java process have already been modified.

Why a 62-byte overflow can compromise the Java heap

A 62-byte out-of-bounds write sounds too small for a serious remote exploit, especially when the attacker does not control the bytes written. The Java4Shell research shows why that assumption is risky.

HotSpot keeps Java objects in managed heap memory. Depending on JVM configuration, object headers hold metadata that identifies the object’s class, coordinates synchronization and supports garbage collection. Java arrays also carry a length field that enforces bounds checks. On common 64-bit HotSpot configurations with compressed class pointers, an array header usually takes 16 bytes, though the exact layout depends on JVM version and runtime options.

When a native overflow reaches an adjacent Java object, it can corrupt metadata the JVM itself uses to keep memory safe. An overwritten object header may crash the process right away, especially when garbage collection or object access tries to interpret the damaged data. An overwritten array length is potentially worse. Java bytecode checks every index against the recorded length, so if an attacker corrupts that length without destabilizing the process, later accesses can pass the check while reaching beyond the memory the array actually owns. Native heap corruption can undermine the metadata Java relies on for its own memory safety.

The overwritten bytes are also not fully attacker-selected. Chainguard observed a repeatable sequence beginning with 9a 69 a6, which comes from the decoder’s lookup data. That limits direct control, but it does not remove exploitability. An attacker may still influence the destination allocation size, the surrounding object layout and the timing of the corrupted operation.

Chainguard described a separate experiment in which corrupting a neighboring array’s length gave access beyond that array’s legitimate allocation. The researchers then used that access to undermine application authorization and script restrictions. A constrained, predictable overwrite does not need to be an arbitrary write to be useful. It can become a stronger primitive through the memory structures the application already has.

Heap grooming and the garbage collection problem

Calif’s analysis treats heap grooming as a key part of the exploitation work. Heap grooming, sometimes called heap feng shui, means shaping the allocation and lifetime of objects so a vulnerable memory operation lands on a useful target.

In a Java application that is hard. Garbage collection, JIT compilation, thread scheduling and the allocation behavior of many application components all interfere. A new byte array is not guaranteed to sit next to an attacker-chosen object, and even if two objects are adjacent at one moment, garbage collection can move them or reclaim the memory around them. G1, Parallel GC, ZGC and other HotSpot collectors do not produce equivalent heap layouts, and object alignment, compressed ordinary object pointers, region sizing and allocation pressure shift the outcome further.

That is why a reproducible Base64 overflow should not be read as a universal remote code execution exploit. The researcher’s job is to turn a memory-safety violation into a predictable effect. A corrupted object header may just kill the JVM, while a carefully placed corruption can affect metadata used by later application operations. Calif reports that exploitation chains differ a lot between applications. Some expose the decoder before authentication, and others need a valid user session or a feature that allows controlled allocations.

Chainguard’s research points the same way on allocation behavior. Its experiments with script-enabled Java applications showed memory corruption defeating the restrictions of an application-level scripting sandbox. So the exposure reaches beyond conventional web-server attacks: any process that allows restricted Java operations is at risk if the restriction depends on the JVM preserving object boundaries. My read is that a process boundary is considerably stronger than an in-process allowlist when you run untrusted code. Once the runtime’s memory-safety assumptions fail, permissions enforced only through Java object structures stop providing the isolation people expect.

Which applications Calif exploited and how Base64 input reaches them

One of the most consequential findings in Calif’s disclosure is that an attacker can reach the vulnerable decoder through ordinary application functionality. No dedicated admin or debugging interface is needed.

HTTP Basic authentication is the obvious example. The protocol carries credentials as a Base64-encoded value in the Authorization header, and a Java application or authentication component may decode that value before it knows whether the client is authorized. If attacker-controlled input reaches the vulnerable intrinsic there, the memory corruption happens inside the server’s Java process. Other possible entry points include encoded API parameters, some token-processing implementations, certificate-processing paths and any feature that accepts binary data as Base64.

JWT handling deserves attention, with some precision. JWT segments normally use Base64URL encoding, and Java has separate URL-safe decoder functionality. Whether a given JWT library reaches the affected intrinsic depends on its decoder path, so the presence of JWT authentication proves nothing on its own. The same goes for third-party decoding libraries, native implementations and framework-specific parsers, which can all change reachability.

Calif reports pre-authentication exploitation against Keycloak, Jira, Confluence, Jenkins, JFrog Artifactory and PingFederate, and authenticated exploitation against Kafka Broker, Solr, Elasticsearch, Gerrit and Spinnaker. Those are demonstrations under the researchers’ test conditions, and they do not prove that every installation of those products is remotely exploitable. In a real deployment the installed Java distribution, processor capabilities, JVM options, application version and reachable decoding path all matter. Calif has withheld its weaponized, application-specific chains, so the implementation details of those demonstrations are not public.

JavaBleed: how Java4Shell can leak application secrets

Remote code execution is only one possible outcome. Calif also describes JavaBleed, an information-disclosure technique that uses the heap corruption to expose memory belonging to the affected Java application.

The comparison to Heartbleed is useful but loose. Heartbleed was an out-of-bounds read in OpenSSL’s TLS heartbeat implementation, while Java4Shell starts with an out-of-bounds write in the JVM’s Base64 decoder. To leak data, an exploitation chain has to convert that write into some form of unauthorized memory access. An attacker who subverts an array’s length metadata, for example, may cause later code to read outside the array’s original allocation. How feasible that is depends on the application’s behavior and how reliable the corrupted heap layout is.

Long-running Java servers make attractive targets. Identity-management systems can hold authentication material, session information and cryptographic objects. Application servers may hold database credentials and service account tokens. Build systems can contain deployment credentials, repository access tokens and secrets pulled from external vaults. Those are categories of data that could be exposed, and nobody has shown that all such secrets were extracted from every affected product.

Chainguard reported its own demonstration in which unauthorized heap access exposed authentication secrets and a node’s TLS private key. Its researchers also modified cached authorization data and bypassed an in-process scripting allowlist. That is independent evidence that a constrained corruption bug can become an information-disclosure and authorization-bypass problem even when direct operating-system command execution is blocked.

Affected OpenJDK versions and processor requirements

The reported affected range starts at OpenJDK 17.0.6. Later release families, including Java 21, 25 and 27, contain affected implementations until the November 17 fixes are applied. Downstream distributions built from the vulnerable OpenJDK code are affected too: Amazon Corretto, Eclipse Temurin, Azul Zulu, Microsoft Build of OpenJDK, Red Hat OpenJDK, BellSoft Liberica, SAP SapMachine and the relevant Oracle Java releases.

The hardware requirement matters just as much. The vulnerable path needs x86-64 hardware with AVX-512 VBMI support. Calif lists Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, along with AMD Zen 4 and newer, as the relevant families. Processor branding alone does not settle exposure, though. Virtual machines may not pass every host CPU instruction through to the guest, and JVM settings can disable the affected intrinsic.

On Linux you can inspect the processor flags:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' \
| grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

All four flags are relevant to Calif’s assessment. Seeing them means the hardware is compatible, and says nothing yet about whether an application is exploitable.

Check the installed Java runtime next:

java -version

For long-running services, the system’s default Java executable is not enough, because the executable a service actually uses can differ from the one in your shell. On Linux, list running Java processes with:

ps -eo pid,args | grep '[j]ava'

For an identified process, inspect the JVM executable and its effective arguments with your usual process-management tools. Where jcmd is available and permissions allow, these commands help establish the runtime configuration:

jcmd <PID> VM.version
jcmd <PID> VM.command_line
jcmd <PID> VM.flags

These checks matter most for containers and products that bundle a private JDK. Updating a host’s Java installation does not update the runtime inside an application container.

Which systems are actually vulnerable to Java4Shell (CVE-2026-114938)?

Running an affected Java version is not enough to be vulnerable to CVE-2026-114938. Java4Shell needs four things to line up: the Java runtime version, the processor architecture, CPU instruction support and the JVM configuration. The vulnerable AVX-512 Base64 decoding path is available only when a system runs an unpatched OpenJDK-based runtime containing the affected implementation, uses an x86-64 processor with AVX-512 VBMI, exposes that instruction set to the JVM, and has hardware acceleration enabled. Even then, exploitation requires an application path that passes attacker-controlled Base64 input to the vulnerable decoder.

The affected OpenJDK implementation was introduced in Java 17.0.6 and appears in later release families. Potentially vulnerable installations include Eclipse Temurin, Amazon Corretto, Azul Zulu, BellSoft Liberica, Microsoft Build of OpenJDK, Red Hat OpenJDK, SAP SapMachine and Oracle’s OpenJDK-derived distributions. Oracle Java SE and GraalVM for JDK should be checked against their own vendor advisories. Installations that have received the November 2026 security correction are unaffected by this flaw. Older OpenJDK releases such as Java 8 and Java 11 lack the same AVX-512 implementation, although Oracle lists certain Java SE 8 performance builds as affected. For that reason the exact vendor build number tells you more than the Java major version.

The processor requirement narrows things considerably. Java4Shell affects the x86-64 AVX-512 VBMI decoding path, not every Base64 decoder in OpenJDK. ARM64 systems, including AWS Graviton, Ampere processors, Microsoft’s Cobalt, Google’s Axion, NVIDIA Grace and Apple Silicon, never execute the affected x86-64 intrinsic. x86 processors without AVX-512 VBMI use a different decoding implementation. AVX-512 alone is not enough either: it is a family of extensions, and older processors may support some of them without VBMI.

Virtualization adds another layer. A physical server may support AVX-512 VBMI while the virtual machine running Java cannot see it. VMware environments set to older Enhanced vMotion Compatibility CPU baselines, such as Cascade Lake or earlier, may mask the instruction. KVM and Proxmox virtual machines using generic CPU models such as kvm64 or x86-64-v2-AES also hide the capability. Virtual machines with host CPU passthrough or a sufficiently recent CPU model may expose VBMI to the guest. Containers generally see whatever their host exposes, though extra virtualization layers can change which features are visible.

The fourth condition is JVM configuration. Administrators can disable the hardware-accelerated Base64 decoder with -XX:-UseBASE64Intrinsics, which stops the JVM from using the affected intrinsic. Setting -XX:UseAVX=2 can also keep the vulnerable AVX-512 path from being selected on supported x86-64 HotSpot configurations. Neither flag changes the installed Java version, but either can stop the vulnerable code from running while you prepare a permanent update. Validate the flags against the deployed JVM, and don’t apply them across different processor architectures without checking.

Vulnerability scanners are where this matters most. A scanner that checks only the Java version may flag a deployment as critical even when its processor cannot execute the affected instructions, its virtual CPU masks VBMI, or its JVM disables the intrinsic. An accurate assessment has to look at the Java build, the CPU features visible inside the actual execution environment, and the JVM’s effective startup flags.

Which Intel, AMD and cloud processors can execute the vulnerable Base64 decoder?

On the Intel server side, the relevant families are Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids. These cover third-, fourth- and fifth-generation Xeon Scalable processors, relevant sixth-generation Xeon processors using performance cores, and associated Xeon W and Xeon D models. Intel introduced VBMI in these newer server architectures, so they are the ones to prioritize when verifying Java runtime patches in enterprise data centers.

Older Xeon generations behave differently. Skylake-SP, Cascade Lake and Cooper Lake support some AVX-512 instructions but lack VBMI. That covers first- and second-generation Xeon Scalable processors and certain third-generation Xeon H-series models. Despite advertising AVX-512, they do not execute the affected VBMI-based decoder. Newer Xeon processors built only on efficiency cores may lack AVX-512 entirely, so check the actual CPU flags instead of assuming a recent product name guarantees the instruction set.

Intel’s consumer processors need the same care. Selected 10th-generation Ice Lake laptop processors, including models with G1, G4 and G7 suffixes, support the instruction set, and so do 11th-generation Tiger Lake and Rocket Lake. Mainstream Intel Core processors from the 12th generation onward generally lack exposed AVX-512 support, as do the Core Ultra families. Some older high-end Core X-series processors support AVX-512 but not VBMI. A newer Intel desktop or laptop processor is therefore not necessarily more exposed to Java4Shell than an older one.

On the AMD side, AVX-512 VBMI support starts with Zen 4 and continues into Zen 5. The relevant server processors are the AMD EPYC 9004, 8004 and 9005 families, covering Genoa, Bergamo, Siena and Turin. These are widely used in modern enterprise virtualization and cloud infrastructure, so Java deployments on them deserve assessment.

AMD’s consumer and workstation lines include capable hardware too: Ryzen 7000 desktop processors based on Zen 4, the Ryzen 8000 and 9000 families, Ryzen AI 300 processors, and Threadripper 7000 and 9000 systems. Certain Ryzen 7040 and 7045 laptop processors also support the required instructions. The Ryzen 7000 branding does not guarantee Zen 4, though. Some Ryzen 7000 laptop models, including parts in the 7×20, 7×30 and 7×35 series, use older Zen 2 or Zen 3 designs and lack VBMI.

Zen, Zen 2 and Zen 3 do not support AVX-512 VBMI. That rules out the older EPYC 7001, 7002 and 7003 generations (Naples, Rome and Milan), Ryzen 5000 and earlier, and older Threadripper generations. These systems cannot execute the vulnerable VBMI routine even if the installed Java release contains the defective implementation.

Public cloud follows the same split. AWS EC2 families that may be capable include Intel-based m6i, c6i and r6i, the newer m7i, c7i and r7i, and AMD-based m7a, c7a and r7a. Azure Dv5/Ev5, Dv6 and Dasv6/Easv6, along with Google Cloud C3, C3D, C4, C4D and N4 configurations, are further examples. Actual exposure depends on the processor model assigned to the instance and the instruction sets presented to the guest operating system.

AWS Graviton instances use ARM64 processors and cannot execute the affected x86-64 intrinsic. Older AWS m5, c5, r5, m6a, c6a and r6a families generally use processors without VBMI. The same goes for older Azure Dasv4 and Dasv5 families and for Google Cloud N1, C2, C2D and C4A configurations. Google Cloud N2 instances commonly use Cascade Lake or Ice Lake processors, so the assigned CPU generation decides whether VBMI is available.

Instance family names are useful for deciding where to look first, but they are no substitute for checking the CPU features exposed to the workload. The underlying processor can differ between regions, instance generations and configurations.

How to verify Java4Shell exposure on Linux servers and virtual machines

On Linux, you can check whether AVX-512 VBMI is visible to the operating system by examining /proc/cpuinfo. A quick check is:

grep -qw avx512vbmi /proc/cpuinfo && echo "VBMI present"

If the command prints VBMI present, the operating system sees the VBMI capability. That confirms one hardware condition only. It does not show that the installed Java runtime is vulnerable or that the JVM has enabled the affected intrinsic.

In virtualized environments, run the command inside the virtual machine, not only on the physical host. For containerized services, also verify the capabilities visible in the container and the runtime the application actually uses.

You can identify the Java installation with java -version, but also inspect the JVM executable behind each running service. Products such as Jenkins, Jira, Confluence, Keycloak and Artifactory may ship bundled runtimes or container images that differ from the system’s default Java.

Next, examine the JVM startup arguments for -XX:-UseBASE64Intrinsics or -XX:UseAVX=2. Either one can keep the vulnerable decoding path from running even when the Java version and hardware would otherwise meet the exposure conditions.

Finally, consider whether the decoder is reachable from the application. Calif’s research demonstrated unauthenticated remote code execution against default configurations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, so those deployments come first wherever the processor and JVM conditions are met. An unpatched JDK on compatible hardware does not by itself make an application remotely exploitable. The vulnerable decoder must still be reachable through an attacker-controlled input path, and code execution depends on the application-specific exploitation chain.

Java4Shell exposure cannot be determined from the Java version alone. A reliable assessment correlates the specific JDK build, AVX-512 VBMI support, the CPU features visible inside virtual machines, the effective JVM flags and the application’s reachable Base64 decoding paths. Systems that meet those conditions should get the November 2026 JDK security updates as a priority instead of relying indefinitely on processor-specific mitigations.

OpenJDK and Oracle fixes for CVE-2026-114938 (released November 17)

Oracle and OpenJDK released fixes for CVE-2026-114938 on November 17, 2026. Chainguard’s November 17 analysis documents these patched OpenJDK versions:

Java release familyFixed version
OpenJDK 1717.0.21.1
OpenJDK 2121.0.13.1
OpenJDK 2525.0.5.1
OpenJDK 2727.0.1.1

Downstream vendors may use additional build identifiers, so check the advisory for your actual distribution and do not rely on the upstream number alone.

The upstream correction handles the invalid tail-processing condition. Chainguard describes the fix as an early return from the affected stub when fewer than four characters remain, which keeps the malformed remainder away from the masked-store calculation. It fixes the underlying defect and does more than filter one example of bad Base64.

Temporary mitigations if you cannot patch yet

If you cannot deploy an updated runtime right away, Calif recommends disabling the hardware-accelerated Base64 intrinsic:

-XX:-UseBASE64Intrinsics

That sends the JVM down a different path than the vulnerable optimized code. The cost is slower Base64 handling, which shows up mostly in applications that decode large volumes of data.

An alternative is to restrict the JVM’s AVX usage:

-XX:UseAVX=2

This stops the AVX-512 path from being selected on compatible x86-64 systems. It also affects other vectorized JVM operations, so test performance-sensitive deployments first. Calif specifically warns against applying -XX:UseAVX=2 across the board to ARM64 deployments, where the option may not be recognized and can stop the JVM from starting.

Both options are stopgaps. Installing a verified, patched JDK remains the preferred fix.

Is Java4Shell being exploited in the wild?

Not as far as anyone has reported. VulnCheck’s November 17 write-up says CVE-2026-114938 is not known to be exploited in the wild, and describes Calif’s public proof of concept as one that only triggers the flaw. GreyNoise’s Java4Shell tracker, last updated at 00:35 UTC on November 18, showed zero IPs sending Java4Shell-shaped Base64 and zero matching requests since the write-up went live.

Those are snapshots, and the absence of scanning data does not show that nobody has tried. The research so far establishes working laboratory exploitation, including reported remote code execution. It does not establish widespread attacks against production systems.

One detail gives me pause. iThome reports that Calif found the flaw in about an hour using AI, built its first exploit chain in roughly two more hours, and spent under $200 in tokens doing it. If that account is accurate, the withheld application-specific chains took a small team very little time to build, and I would not plan around them staying private for long. That is my inference from the reported timeline and not a finding from the research.

How to detect Java4Shell exploitation and investigate JVM crashes

Detection is hard because the vulnerable operation is an ordinary decoding function used all over Java applications. A suspicious request may carry malformed Base64, but malformed Base64 shows up in normal operation too, in invalid authentication headers and badly encoded application data. An attacker also does not need an unusual URL or exploit-specific endpoint when an existing feature already passes untrusted values to the vulnerable decoder.

So correlate several sources of evidence. Repeated Base64 decoding exceptions deserve a look, especially when they coincide with unexpected JVM crashes. HotSpot fatal error reports usually have names starting with hs_err_pid and can identify the native code involved in a crash, and evidence pointing at the optimized Base64 decoder is worth much more than an isolated exception in an application log. Indicators to look for:

  • an unexpected SIGSEGV
  • a fatal error inside JIT-generated or VM stub code
  • repeated crashes after requests containing malformed encoded values
  • unusual authentication failures just before process termination

There are real limits. The intrinsic is JIT-dependent, and ordinary stack traces may not tie a crash to the HTTP request that caused it. Garbage collection or a later object access may hit the damaged heap long after the malicious input was processed. Preserve JVM crash reports, relevant request logs, service restart history and any process telemetry you have.

Do not blame every crash on CVE-2026-114938 just because the server runs an affected Java version, since other JVM defects, native libraries and hardware faults produce similar symptoms. The reverse holds too: a lack of crashes does not show that exploitation was impossible, because a successful corruption chain may never kill the process.

Java4Shell vs Log4Shell: why the comparison only goes so far

The names are similar and the bugs are very different. Log4Shell, tracked as CVE-2021-44228, came from unsafe lookup behavior in affected Apache Log4j versions. Exploitation depended on reaching the vulnerable logging functionality and getting attacker-controlled lookup expressions evaluated.

Java4Shell lives inside the JVM implementation. An application does not need Log4j, a particular logging configuration or any vulnerable third-party package to contain the affected Base64 intrinsic. The vulnerable code ships with the runtime, and exploitability depends on whether attacker-controlled data reaches the optimized decoder under the right hardware and runtime conditions.

Remediation looks different as a result. With Log4Shell, defenders could find vulnerable Log4j versions and update or remove the dependency. With Java4Shell, the fix may mean replacing the JDK underneath many unrelated products. The same runtime flaw can show up in identity-management services, CI/CD platforms and application servers whose codebases have nothing in common.

What to prioritize after the November 17 disclosure

The disclosure changes the risk assessment. CVE-2026-114938 is no longer a suspected Java vulnerability waiting for technical confirmation. Calif has published its findings, Chainguard has independently analyzed the memory-corruption mechanism, and security updates are available.

Start by identifying Java workloads that run vulnerable JDK builds on compatible x86-64 hardware, especially systems that expose authentication, token processing or encoded-input features to untrusted clients. Internet-facing applications come first because some of Calif’s demonstrated chains need no authentication. Internal services still count, particularly where low-privilege users can invoke script engines or features that eventually decode untrusted Base64.

Then inventory the Java runtimes inside containers and vendor-managed products, upgrade to fixed builds, and confirm that production processes actually restarted on the updated runtime. Where you cannot upgrade yet, disabling the Base64 intrinsic is the documented temporary mitigation.

The broader lesson is about trust in the runtime. The JVM’s memory-safety guarantees only hold if its native components behave correctly, and one error in a performance-oriented assembly routine was enough to compromise object boundaries and weaken restrictions enforced throughout the application. The routine in question is Base64 decoding, which sits in nearly every authentication path. A small calculation error there has been shown, under the right conditions, to escalate into information disclosure and remote

— Original Story Continues Below —

A vulnerability report published on November 16, 2026 contains nearly every term that makes an infrastructure team drop what it is doing: unauthenticated, remote code execution, Java 17, CVSS 9.2. The identifier, CVE-2026-114938, is said to affect OpenJDK 17.0.6 and every later Java 17 update. That range reaches back to January 2023 and covers almost four years of builds on one of the most widely deployed long-term support runtimes in production. By the next day the security press had picked the story up, watchTowr had publicly acknowledged it, and Oracle was hours from a scheduled Java security release whose advance notice promised fixes for eleven remotely exploitable, unauthenticated flaws in Java SE.

The obvious move would be an emergency post. I think a more useful exercise is to separate what the documents establish from what people are inferring, because the operational risk sits in the gap between the two.

When I checked, the CVE record was still reserved by its numbering authority. It had no public description, no vendor advisory naming a component, no proof-of-concept code, and no entry in CISA’s Known Exploited Vulnerabilities catalog. I also found something more interesting than the headline. The reported boundary, 17.0.6, lines up exactly with a specific, well documented change to the Java 17 codebase, one with a history of memory-safety trouble. That coincidence confirms nothing, but it is the most informative clue in the report, and it points at a corner of the JVM most administrators have never had reason to inspect.

What the CVE-2026-114938 documents actually say

Oracle’s pre-release announcement for the November 2026 Critical Security Patch Update is a real, citable document, and it is narrower than the coverage suggests. It schedules the release for Tuesday, November 17 and describes 652 new security patches across the Oracle portfolio, eleven of them for Java SE. All eleven “may be remotely exploitable without authentication.” The highest CVSS 3.1 base score in the Java SE section is 8.1.

The announcement lists the affected products precisely: Oracle Java SE 8u511, 8u511-perf, 11.0.33, 17.0.21, 21.0.13, 25.0.5 and 27.0.1; Oracle GraalVM for JDK 17.0.21 and 21.0.13; Oracle GraalVM Enterprise Edition 21.3.20.0.3; and Oracle JavaFX 21.0.13, 25.0.5 and 27.0.1. It does not name a single CVE, component, or attack precondition, and it warns that its contents may change before the final advisory publishes.

That silence is Oracle’s policy. The company says it gives no advance notification or per-flaw detail to individual customers, distributes no exploit code, and publishes nothing beyond the advisory, readme and FAQ once a release ships. The information vacuum around CVE-2026-114938 is the normal shape of a Java disclosure under that process. It is no evidence of a cover-up or of an unusually dangerous bug.

At the time of my checks, Oracle’s security-alerts index still listed the November CSPU as a pre-release announcement. The OpenJDK Vulnerability Group’s advisory page ended at October 24, with no November entry and no risk matrix mapping CVE-2026-114938 to a fixed build. The CVE record itself returned the standard reserved-state notice: the identifier exists, and the assigning authority has not published details.

The reporting chain deserves the same scrutiny. The November 16 advisory is attributed to South Korea’s National Cyber Security Center, but the outlets carrying the story cite it secondhand, and ZIEN Lens says outright that the original document still needs verification. watchTowr’s public statement shows restraint. Its intel team is “aware of public reports of an unauthenticated RCE in Java,” affecting OpenJDK 17.0.6 and later, with the technical details unconfirmed. Astra’s advisory carries a disclaimer that its details come from secondary reporting and need confirmation against the vendor advisory, and it confirms that no CWE identifier, CVSS vector string, component name, or input path has been published. Early reports describe the root cause only as memory corruption. More granular technical narratives circulated in early summaries, but I could not trace any of them to a research writeup, bug report, or vendor advisory for this identifier, so I give them no weight here.

Oracle’s monthly Java security patches explain the timing

Part of why this report reads like a five-alarm fire is that it arrived next to a large Oracle patch release, as if the two were one event. They may not be. The release itself reflects a deliberate structural change. Oracle shipped its first Critical Security Patch Update on May 28, 2026, and CSPUs now land on the third Tuesday of February, March, May, June, August, September, November and December. They sit alongside the quarterly cumulative Critical Patch Updates in January, April, July and October. After November 17, the next scheduled dates are December 15, 2026, then February 16 and March 16, 2027.

Oracle’s Java product blog explains the reasoning, and one passage is worth quoting because it reframes the story. Donald Smith’s post, published July 20 and updated September 10, 2026, says Oracle intends to move Java security to a monthly cadence focused on security and stability fixes rather than features. It says “the latest generation of AI is transforming how software vulnerabilities are identified and fixed.” The post warns organizations that bundle a JDK or JRE with their applications to reassess their build, test, release and deployment pipelines for a faster update tempo, and it announces plans for multiple monthly updates in calendar 2027.

The November CSPU is therefore the cadence working as designed. Whether CVE-2026-114938 is one of its eleven Java SE fixes, or an OpenJDK-side issue tracked separately through the Vulnerability Group, is a question only the final risk matrix can answer. The pre-release notice cannot.

OpenJDK 17.0.6 and the AVX-512 Base64 decoder

Strip away the unconfirmed severity and the unlocated advisory, and one checkable fact remains: the reported affected range begins at OpenJDK 17.0.6. That version shipped in January 2023, and it is a specific release, not an arbitrary starting point. It is the one in which the AVX-512 accelerated Base64 decoding intrinsic entered the Java 17 line.

The upstream history is fully documented in the OpenJDK bug system. JDK-8268276, “Base64 Decoding optimization for x86 using AVX-512,” was written by Scott Gibbons of Intel and resolved into JDK 18 in June 2021. It added a decode intrinsic that uses 512-bit vector instructions and introduced an isMIME parameter so the stub could fast-path MIME decoding.

The enhancement was backported to the 17 update stream as JDK-8296735, resolved on November 9, 2022 into build b03 of what became 17.0.6. A parallel Oracle backport, JDK-8296885, landed in 17.0.7-oracle. The backport request cited a roughly nineteenfold performance improvement and numerous customer requests. The approving maintainer, Goetz Lindenmaier, recorded his reservations in the bug: the change “touches a central algorithm,” assembly coding is error prone, and a related bug had been found only through extensive internal testing that the open community cannot run. He approved it anyway because the code had been live in JDK 18 for months and the performance benefit was large.

The code path then did what he feared it might. JDK-8273108 records a segmentation fault in markWord::displaced_mark_helper() triggered after JDK-8268276, a crash in the machinery that handles object headers during locking and garbage collection, directly attributable to the new decode intrinsic.

In December 2023, Oli Gillespie reported JDK-8321599, “Data loss in AVX3 Base64 decoding.” He reproduced wrong decode results on an AWS Ice Lake instance and narrowed the trigger to four simultaneous conditions: a non-zero source offset, padding characters at a specific position relative to that offset, an input of at least 32 characters, and non-MIME mode. The root cause was an omitted source offset when checking for padding in the final block. The bug needed both the avx512bw and avx512vbmi CPU features, it disappeared under -XX:UseAVX=2, and -XX:DisableIntrinsic=_base64_decodeBlock sidestepped it entirely. After a security evaluation that temporarily closed the public pull request, the fix went into JDK 23 and was backported to 22.0.1, 21.0.3 and 17.0.11, among others.

None of this confirms that CVE-2026-114938 is a Base64 bug. No vendor has named the component, and the version boundary could reflect some other change that also landed in 17.0.6. But the alignment is specific enough to be the leading hypothesis, and it has a practical implication that the generic “memory corruption” framing hides. If the flaw is in this path, Java 17 builds before 17.0.6 are not affected, non-x86 hosts are not affected, and x86 hosts whose CPUs or JVM configuration do not enable the relevant AVX-512 decode path are not affected either. That is a materially different exposure population from “every Java 17 server,” and it should drive patch prioritization more than a blanket 9.2 does.

How a Base64 decoder bug could become pre-auth RCE

To see why a decoder optimization is a plausible home for a critical vulnerability, follow a call from application code down to the silicon. java.util.Base64 has had an intrinsic hook for encoding for years, but decoding only gained one in JDK 16, when JDK-8248188 added a decodeBlock intrinsic candidate with a defensive contract. The stub may process whatever block size it likes, it returns -1 on an illegal character so the portable Java implementation can take over and throw the proper exception, and trailing fragments are left to Java.

The x86 AVX-512 stub from JDK-8268276 is the concrete implementation behind that hook. It is generated at VM initialization in stubGenerator_x86_64.cpp and invoked when C2, the server JIT compiler, replaces a hot decodeBlock call with the vectorized routine. Cold code runs the Java implementation. Only the busy, compiled decode loops in request-handling paths reach the assembly.

The danger in any such stub is the arithmetic at block edges, and padding is the classic edge. A decoder computes how many output bytes an input span should produce, subtracts for padding, and writes that many bytes into a destination array. If the subtraction runs on an unsigned length and the padding accounting is wrong, the result can wrap to a huge value or mis-size the write. That is the integer-underflow class of bug, CWE-191. The JDK-8321599 padding-offset error was a correctness bug and not a memory-safety one, but it lived in exactly this final-block logic, and the earlier markWord crash shows the same stub corrupting object metadata. A write that overruns its destination here does not land in anonymous native memory. It lands in the managed Java heap.

That is what makes a small overflow consequential. On a 64-bit HotSpot with default compressed class pointers, a Java byte[] begins with a mark word and a compressed class pointer, followed by a 32-bit length field, with the payload right after. Objects are allocated bump-pointer style inside a thread-local allocation buffer, so a freshly allocated destination array usually sits directly before the next object that thread allocates. An overrun of a few dozen bytes can reach a neighboring object’s header or an adjacent array’s length field.

Corrupt a length field to a larger value and every later bounds check against it passes, which turns a single overflow into a relative read and write primitive across the heap. Corrupt a class pointer and you get type confusion. From either primitive, an attacker who can shape surrounding allocations can escalate toward controlled execution. The caveat is reliability. The more common outcome of heap corruption is a crash during the next garbage collection or lock operation, which is what JDK-8273108 documented, and a CVSS impact score assumes the worst case of successful exploitation, not the typical one.

The “pre-auth” label is less exotic than it sounds for a runtime library. The JVM has no login screen. The term means attacker-controlled bytes reach the vulnerable code before any credential check, which is ordinary for Base64. HTTP Basic authentication headers are Base64-decoded during request parsing. JWT segments and SAML messages are Base64URL-decoded, and cookies, data URIs and MIME parts routinely carry Base64 payloads. The Security Manager was deprecated for removal in Java 17 under JEP 411 and is disabled by default, so server-side Java runs with the full privileges of its process account, and code execution through a decoder bug inherits whatever that account can touch. The exposure is conditional, but the conditions are common on internet-facing services, so dismissing the report because “it needs AVX-512” would be its own mistake.

CVSS 9.2 vs 8.1: why both scores can describe the same Java bug

The reported 9.2 and Oracle’s stated Java SE maximum of 8.1 look contradictory until you notice that different scoring systems produced them. The 9.2 is a CVSS 4.0 figure, while Oracle scores Java SE under CVSS 3.1. The two frameworks treat exploit conditions differently, and the difference is systematic enough to show with arithmetic.

Under CVSS 3.1, a network-reachable, unauthenticated flaw with high confidentiality, integrity and availability impact scores 9.8 when attack complexity is low. Raise attack complexity to high, which is how Oracle typically encodes a bug that needs specific conditions, and the same impact profile drops to 8.1. The impact sub-score is 5.8731 in both cases, the exploitability sub-score falls from 3.8870 to 2.2212, and the rounded base score moves from 9.8 to 8.1.

CVSS 4.0 splits the old attack-complexity metric into attack complexity proper and a separate attack-requirements metric for deployment, configuration or hardware preconditions. It also separates vulnerable-system impact from subsequent-system impact. A bug that needs a particular CPU feature set maps naturally to attack requirements present, and the vector AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N scores exactly 9.2 in the official calculator.

A real advisory shows the same pattern. SUSE’s November 4 apache2 update, SUSE-SU-2026:5099-1, scores CVE-2026-57941, a use-after-free in mod_http2, three ways in one alert: 9.2 under CVSS 4.0 with attack requirements present, 8.1 under CVSS 3.1 with high attack complexity, and 9.8 under NVD’s CVSS 3.1 with low complexity. The same alert repeats the pattern for the mod_rewrite and mod_charset_lite flaws. One vulnerability can carry three numbers without contradiction.

It is therefore plausible that the 9.2 attached to CVE-2026-114938 and an 8.1 row in Oracle’s eventual risk matrix describe the same bug. Plausible is not the same as confirmed. Until Oracle publishes the matrix that maps CVE identifiers to rows, the assumption that this CVE is among the eleven Java SE patches stays unverified, and the OpenJDK Vulnerability Group, which also publishes CVSS 3.1 vectors, may track it on a different line altogether.

Is CVE-2026-114938 being exploited in the wild?

Coverage of this report keeps sliding between three distinct conditions: a public proof-of-concept exists, a vendor has verified an exploit internally, and attacks are happening in the wild. At the time of my checks, CVE-2026-114938 was in none of these states, which is unsurprising for a reserved record. The pressure to treat a 9.2 as actively exploited is strong, and recent history shows how easily the categories blur.

October’s PHP2Shell disclosures are a clean example. CrowdStrike documented two core-PHP memory-corruption RCEs, CVE-2026-109618 and CVE-2026-109619, both CVSS 4.0 9.2, rooted in zend_bailout() performing a longjmp without unwinding and leaving data structures half-built for cleanup code to consume. CrowdStrike verified end to end that a single anonymous POST could launch a shell on an Apache mod_php worker, reliably across x86-64 and ARM. That is a vendor-verified exploit and not a claim of in-the-wild attacks. The reachable configuration was also narrower than the headline implied, requiring roughly memory_limit < 4 × post_max_size, which stock defaults do not satisfy.

Public reporting on whether PHP2Shell was actually exploited diverged. Some outlets described exploitation within a week of the October 21 patches, while Astra’s November 17 analysis questioned whether it detonated at all. A Java team reading “9.2, memory corruption, pre-auth” should keep all three states separate and not collapse them into “under attack.”

The base rates argue for calm where the headline argues for panic. Waratek’s State of Java Exploits 2026 report, a snapshot taken November 2, counted 5,649 Java CVEs published between January 1 and November 1, more than seven times the same period in 2025. Only eighteen had been exploited, against nineteen at the same point the prior year. Oracle products accounted for 3,659 of those CVEs, up from 165, and only two had public exploit code. Waratek also found that no JDK flaw published since 2016 has been attacked in the wild, and that across the historical corpus public exploit code covers four in five attacked Java flaws, while a queue built on CVSS 7.0 and up misses one in six. A reported JDK-level RCE would break a decade-long pattern, which is a reason to verify it carefully before assuming the pattern has already broken.

The window between disclosure and weaponization is still real, and short when it closes. Waratek recorded nine Java flaws attacked within a week of publication over the past year, five of them on the same day. Oracle’s own behavior shows how fast a genuine Java emergency moves. The eMudhra certificate-trust flaw, CVE-2026-91403, drew a standalone Security Alert on October 21, one day after the quarterly CPU. It scored 9.1 under CVSS 3.1 in the JSSE component and affected every current line, and a companion alert, CVE-2026-114820, followed on October 30 to remove the affected root certificates. The OpenJDK Vulnerability Group published a matching advisory the same day as the first alert. Once a fix ships, reverse engineering of the patch begins immediately, so the absence of an exploit today reflects timing and gives no guarantee of safety.

How to check whether your Java 17 servers are exposed

The valuable work right now is inventory and exposure reduction, and most of it is unglamorous. Start by finding the JVM that actually runs each service, which is often not the one on the shell’s path. java -version reports the executable the current environment resolves, and that is frequently not what a bundled application uses. On Linux, run ps -eo pid,args | grep ‘[j]ava’, then readlink -f /proc/<PID>/exe to reveal the real binary. Running jcmd <PID> VM.version as the same effective user as the target process reports the exact build of the live JVM.

Containers need the same care. docker exec <container> java -version and kubectl exec report a newly launched executable inside the image, which may differ from the running service. Check the base image in each Dockerfile and build pipeline too, so an old JDK is not quietly reintroduced on the next deploy. A label like “Java 17” is too coarse to match against a vendor’s affected-version list. The distribution, version and build string are what count.

Exposure triage comes next. sudo ss -lntp lists listening sockets and their owning processes, but a port list does not establish internet reachability. You have to trace the path through load balancers, cloud security groups, firewalls and proxies. Administrative interfaces that do not need public access should be restricted to management networks or allowlisted addresses. These steps reduce risk without fixing any code, and a WAF cannot reliably block an attack whose input shape has not been disclosed, so record them in the incident log as interim measures, separate from patch status.

JVM workarounds: -XX:UseAVX=2 and -XX:DisableIntrinsic

Precision matters most for JVM-level stopgaps. -XX:UseAVX=2 caps the vector instruction set at AVX2 and avoids the 512-bit EVEX paths. -XX:DisableIntrinsic=_base64_decodeBlock forces the portable Java decoder. Both are documented workarounds for the 2023 AVX3 Base64 bug, verified in that bug’s own reproducer. No vendor has confirmed either as a mitigation for CVE-2026-114938, and applying them speculatively gives up the roughly nineteenfold decode throughput the backport was prized for, on a code path that may not be the vulnerable one.

If your organization chooses to deploy them as a hedge, the mechanics are simple. Both flags require a restart, and -XX:+PrintFlagsFinal confirms the effective UseAVX value. JAVA_TOOL_OPTIONS can inject them fleet-wide because JNI_CreateJavaVM reads it, which covers embedded JVMs, whereas JDK_JAVA_OPTIONS is honored only by the java launcher. Test the decision against your specific build and workload, record it as a stopgap, and reverse it once the real fix is in place.

Patching Java 17 after the November 2026 CSPU

Patching follows your distribution, not the headline. Oracle JDK and GraalVM customers receive fixes through the November CSPU. Oracle’s operations site lists 17.0.21.1 and 21.0.13.1 as the planned Java 17 and Java 21 replacements, and Oracle’s own 17.0.21 release notes advise against continued use of that build after the update.

Downstream OpenJDK distributions ship on their own schedules and version labels. That covers Eclipse Temurin, Amazon Corretto, Azul Zulu, the Microsoft Build of OpenJDK, the Red Hat build, and the packages in Ubuntu, Debian, RHEL and SUSE. The “.1” monthly-build convention already visible in October’s OpenJDK advisories means upstream tags will not match Oracle’s commercial numbering. Vendors in the OpenJDK Vulnerability Group typically receive advance notice, so same-day downstream releases are common, but read the fixed build for each distribution from that vendor’s own advisory and do not infer it from Oracle’s.

After updating, restart the Java processes and verify the running build with jcmd, not just the installed package. Treat any rollback to a vulnerable version as a return to the unpatched list.

What security teams should take from the CVE-2026-114938 report

Oracle has told its users in writing that AI-accelerated discovery is pushing Java toward a monthly security cadence, and that vendors who bundle a runtime need to rebuild their pipelines for it. The organizations that handle this well will keep a continuous, build-level inventory of every JVM they run, treat internet-facing services as a separate remediation tier, and keep a clean line in their incident notes between what is reported and what is known.

CVE-2026-114938 may turn out to be a serious Base64-stub flaw with a four-year reach, or it may shrink into something narrower once the risk matrix publishes. With the CVE record reserved and the primary advisory still unlocated, neither outcome is established today. Do the inventory now, read the matrix when it lands, and patch the running build. A 9.2 headline has not yet earned its decimals.

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Your contribution powers free tutorials, hands-on labs, and security resources.

Why your support matters:
  • Writeup Access: Get complete writeup access within 12 hours
  • Zero paywalls: Keep the main content 100% free for learners worldwide

Perks for one-time supporters:
☕️ $5: Shoutout in Buy Me a Coffee
🛡️ $8: Fast-track Access to Live Webinars
💻 $10: Vote on future tutorial topics + exclusive AMA access

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

If you like this post, then please share it:

Exploits

Discover more from The CyberSec Guru

Subscribe to get the latest posts sent to your email!

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.