Java4Shell can damage memory even when Java rejects the input
A rejected request can hide a heap overwrite. Java4Shell exposure depends on the runtime, processor features…
The short version
- Java4Shell affects certain Java runtimes on x86-64 systems with specific processor features; ARM64 is excluded from this flaw.
- One published test measured a 62-byte overwrite before input rejection; the patched build rejected input without overflowing.
- Operators need to identify affected serving JVMs, apply vendor-supported fixes, restart or replace processes, and verify the active runtime.
Java4Shell: the same app, a different chip, a different risk
A rejected login is poor comfort when the decoder has already scribbled over neighboring memory. That puts a Java4Shell patch ahead of my sprint backlog.

Solosoft’s experiment, published November 18, measured 62 bytes written beyond the output array on the vulnerable runtime, versus none after updating. Both builds rejected the input. My reassuring failed-request graph would look much the same.
The previous day, Calif published its analysis, OpenJDK issued an advisory, and Oracle released fixes. CERT-EU confirms both vendors shipped corrections that day.
The identifier is CVE-2026-114938. Has anyone used it to steal customer data? Published evidence doesn’t establish that. Upwind and VulnCheck reported no known exploitation at their respective snapshots. Nobody has established how many production deployments expose a reachable vulnerable decoder.
My application version leaves out the processor
Identical application code on two servers can inherit different exposure. The same Java call can select different native instructions depending on processor features. Apparently my dependency inventory needs to know about the silicon downstairs.
Kanishka Narayan said:
For too long, Britain has produced some of the world’s best scientific ideas, only to see too much of the technology, industry and wealth they create built elsewhere.
Calif locates the defect in HotSpot’s accelerated Base64 decoder for x86-64 processors. An intrinsic replaces an operation with optimized native code. As Chainguard explains, that implementation must enforce its own memory boundaries; ordinary Java array checks still exist elsewhere.
For exposure, I need to know how Java selects that shortcut. My application requests decoding; the runtime selects an implementation using available processor features. AVX-512 VBMI instructions manipulate batches of bytes together. Supported machines enable this acceleration by default unless configuration disables it. Moving an unchanged deployment between hosts can therefore change exposure. That follows from documented behavior; I haven’t reproduced a migration-related incident.
CERT-EU’s advisory specifies the required features: avx512f, avx512bw, avx512vbmi, and bmi2. They must be visible to the Java virtual machine, or JVM. A processor’s marketing name won’t establish what a guest exposes.
ARM64 takes a different path and is excluded from this flaw. That qualification belongs in my tickets.
Release boundaries matter too. CIRCL identifies affected unpatched Java 17 releases starting with 17.0.6; earlier builds in that line fall outside that boundary.
It also identifies affected releases in the Java 21, 25, and 27 lines. Standard OpenJDK 8 and 11 lack this intrinsic.
Oracle’s Java 8 Enterprise Performance Pack is an exception with an affected build. “We’re on an older Java” leaves homework.
I run my own Docker stack on Linux, but owning deployment doesn’t mean I can name every bundled runtime. Red Hat’s inventory guidance explicitly includes containers, product installations, and appliances. That last category promises a tedious support conversation.
Kat Jones said:
Hyperscale AI datacentres simply cannot run on renewable power alone, they absolutely need a highly reliable source of grid power.
The exception arrives after the damage
Solosoft compared vulnerable and patched Zulu builds on the same AMD EPYC 9354P, with the required acceleration available.
The vulnerable build, 21.0.13.0.3, overwrote space where neighboring objects can live.
Its replacement, 21.0.13.1, stayed within the allocation for the same malformed input. I’m treating the overwrite size as that test’s result, not a constant across inputs or runtimes.
Here’s the mechanism from Calif’s report and the upstream correction. Java calculates decoded-result space and allocates an output array. The optimized decoder processes attacker-controlled input until a malformed padded tail makes a decoded-length calculation drop below zero. That invalid value produces a mask, switches controlling which bytes get stored, that enables the entire vector store. The processor writes beyond the array before Java detects invalid input and throws an exception. Catching it cannot undo neighboring memory changes.
The upstream fix sends tails shorter than a complete Base64 block back to Java, bypassing the vulnerable vector path. It corrects the accelerated implementation’s faulty assumptions.
Calif’s firsthand report describes turning the largely fixed-value overwrite into memory disclosure and remote code execution through heap manipulation. Blackpoint describes array-length manipulation in that strategy: corrupt the recorded length, and later operations can trust a boundary larger than the allocation. With suitable neighboring objects, another corrupted array can expose memory through an application response.
The strongest objection to calling this immediate remote execution on my installation is legitimate: it requires considerably more than submitting the public trigger. VulnCheck describes straightforward crashes at reachable decoder inputs, but remote execution requires difficult heap arrangement and an application-specific address-disclosure route. Blackpoint did not independently reproduce remote exploitation. Upwind says Calif withheld the full product-specific chains.
Those gaps limit claims about my installation. They don’t erase the demonstrated heap overwrite.
Conflicting reports also prevent one scary product list. Wiz categorizes Kafka Broker, Solr, Elasticsearch, Gerrit, and Spinnaker as pre-authentication demonstrations; Upwind categorizes them as post-authentication. Calif’s available account doesn’t resolve that discrepancy product by product.
For Keycloak and Jenkins, SecurityWeek’s November 18 report attributes pre-authentication execution demonstrations in default configurations to Calif. Whether my installation exposes the same chain needs investigation.

Java can reject input after the decoder damages neighboring memory. Disclosure or execution requires additional, application-specific work.
Codex generated leads, and someone discarded the bad ones
Calif’s researcher directed Codex toward JIT compilation, intrinsics, widely accessible APIs, and cryptography. I find that more useful than the headline where AI wanders into a repository and emerges holding a critical vulnerability.
A JIT compiler translates frequently executed Java operations into machine code while the application runs. That boundary puts managed-language guarantees beside native implementation details: a sensible inspection target.
In Calif’s account, early findings were often unreachable or required unrealistic conditions. The researcher describes about twenty minutes prompting and discarding poor results before the useful finding. That measures searching and filtering; the complete investigation and exploit-development time remains unquantified.
I read this as checks that can kill a promising lead. A researcher chooses a boundary. The model proposes weaknesses, including attractive nonsense. Someone checks whether ordinary application behavior reaches the suspect routine. A reproducer tests corruption on the required runtime and hardware. Exploit development asks whether the application can arrange neighboring objects and expose useful memory. A crash answers only part of that. Skipping checks makes research faster the way deleting tests makes my build greener.
Chainguard’s published chronology dates Calif’s discovery to October 30 and its own report to November 13. Those dates don’t establish coordination or identical methods. Separate teams reaching the same weakness does pressure disclosure while vendors prepare releases.
Chainguard also says an AI-generated testing harness crashed after about three minutes exercising a server’s credential parser; agents then isolated the failure in the JDK. That measures one run against one target. There’s no comparable human-only investigation baseline.
I buy faster searching. Neither account provides an audited end-to-end labor comparison, so I’m leaving the productivity multiplier blank.
Calif researcher Quang Luong puts the difficulty this way:
Complicated system interactions are hard, and this complexity can make exploiting hard bugs easy.
I want proof from the process answering requests
A downloaded patch supplies replacement files. The service may still run the old JVM, making “updated” an impressively elastic word in an incident channel.
First, identify the serving process and its exposure. I want its owner, exact Java vendor/build, processor features visible to that JVM, and evidence of whether untrusted input reaches the decoder. Internet-facing identity services deserve early attention: credential parsing can precede authentication.
Red Hat’s guidance covers bundled runtimes for good reason. My terminal’s java -version identifies what that shell launches. A service can use another executable buried in its installation directory, surviving my confident announcement that Java has been updated.
Second, apply the vendor-supported correction. CIRCL lists these fixed release-line reference points for affected earlier builds. Exact identifiers matter; rounding makes this advice useless.
- Java 17: replace affected earlier builds with 17.0.21.1.
- Java 21: replace affected earlier builds with 21.0.13.1.
- Java 25: replace affected earlier builds with 25.0.5.1.
- Java 27: replace affected earlier builds with 27.0.1.1.
Oracle’s release notes identify its full build as 17.0.21.1+4, a security update. CERT-EU identifies that release as the affected line’s fix. Before declaring a build safe, I want its distribution’s advisory; vendor backports can defeat a universal suffix test.
If patching must wait, Red Hat recommends temporarily disabling Base64 intrinsics with -XX:-UseBASE64Intrinsics. CERT-EU’s instructions include unlocking diagnostic options. I’d check the exact vendor and product startup guidance, then verify the launch wrapper passed the setting through.
Disabling AVX-512 more broadly is another documented option. Red Hat warns that -XX:UseAVX=2 is inappropriate for ARM64 JVMs and can prevent startup. Pasting it across a mixed fleet gives the incident channel something else to discuss.
Third, replace the process and verify the result. For me, activation needs separate evidence. Updating disk files leaves a running JVM executing its existing runtime. Rebuilding an image leaves old containers untouched until replacement instances start. Startup flags affect processes launched with those settings. CERT-EU consequently recommends JVM restarts after updating and says its startup mitigations also require a restart. After replacement, I want the actual service process and launch configuration checked. Temporary mitigations need an owner and review date.
Replacing the runtime fixes the vulnerable implementation; it doesn’t establish whether earlier requests compromised the service. Microsoft describes its WAF rules as supplementary to patching. Their effectiveness across every application-specific decoder path remains unknown.
For managed services, I ask providers to name the team responsible for replacement and show a verifiable deployment state. An advisory pasted into a support reply won’t identify the process accepting my customers’ credentials.
My next ticket ends with a request: show me the executable path and build of the JVM serving traffic after the restart.
Frequently asked questions
Which Java versions and processors are affected by Java4Shell?
Java4Shell affects unpatched releases in the Java 17, 21, 25, and 27 lines on x86-64 systems exposing avx512f, avx512bw, avx512vbmi, and bmi2 to the JVM. The affected Java 17 range begins at 17.0.6. ARM64 and standard OpenJDK 8 and 11 are excluded; Oracle’s Java 8 Enterprise Performance Pack has an affected build.
Can Java4Shell corrupt memory even if Java rejects the input?
Java4Shell can overwrite neighboring memory before Java throws an exception for malformed Base64 input. Solosoft measured a 62-byte overwrite in one vulnerable-runtime test, while the patched runtime stayed within its allocation. Both rejected the input. Remote execution requires additional heap manipulation and an application-specific route for disclosing addresses.
How do you patch Java4Shell and verify the fix is active?
Apply the Java distribution’s supported correction, then restart the JVM or replace the running container. Verify the executable path, exact build, and launch configuration of the process serving traffic. Updating files or rebuilding an image does not replace an existing process. Temporary startup mitigations also require a restart.
Sources
- Java4Shell: Write once, RCE everywhere
- Oracle Critical Security Patch Update Advisory - November 2026
- Java4Shell: How a malformed Base64 string breaks the JVM on AVX-512
- RHSB-2026-018 Remote Code Execution via memory corruption on x86-64 systems - OpenJDK (CVE-2026-114938) - "java4shell"
- Java4Shell Measured: 62 Bytes Past the Buffer, a Four-Line Fix, and a Trigger That Fires Once per JIT Compile
- Addressing Java4Shell CVE-2026-114938: upgrade guidance and Azure WAF mitigations