Newshot

One Wrong Equals Sign Leaves All of OpenJDK Remotely Exploitable

AI summary

On November 17, security firm Calif disclosed a memory-corruption vulnerability in OpenJDK, tracked as CVE-2026-114938 and codenamed Java4Shell, with a CVSSv4.0 score of 9.2. The flaw lies in the optimized AVX-512 assembly for Base64 decoding: an extra padding equals sign at the end of the input causes the length to be calculated as negative, leading to a heap buffer overflow that an attacker can trigger without an account simply by having a program parse a crafted Base64 string. The advice is to check CPU flags first, then apply the patch.

Translation(model translation, not the source's own text)

One Wrong Equals Sign Puts All of OpenJDK at Risk of Remote Exploitation

OpenJDK's AVX-512 Base64 decoding optimization code calculates the length as a negative number when it encounters an extra padding character, resulting in an out-of-bounds heap write that can be exploited for remote code execution, CVSS 9.2. It affects versions 17.0.6 and later running on x86-64 machines that support AVX-512 VBMI. Jira, Jenkins, Tomcat, and others have been confirmed exploitable.

Cover image from Wiz Research (direct link to official site)
Cover image from Wiz Research (direct link to official site)
  • AVX-512 Base64 decoding encounters an extra padding character, the length is calculated as negative, causing an out-of-bounds heap write
  • Only OpenJDK 17.0.6+ on x86-64 with AVX-512 VBMI support takes the faulty path
  • Check whether all four AVX-512 CPU flags are present and whether the JDK version is past 17.0.6
  • Jira, Confluence, Jenkins, Keycloak, and others have been confirmed for pre-auth RCE

Wiz is a cloud security vendor; the article recommends its Threat Center lookup capability, but the vulnerability details, affected list, and mitigation commands can all be independently verified.

On November 17, security firm Calif disclosed a memory corruption vulnerability in OpenJDK, tracked as CVE-2026-114938, codenamed Java4Shell, with a CVSSv4.0 score of 9.2. The problem lies in the optimized assembly for AVX-512 Base64 decoding: when there is one extra padding equals sign at the end of the input, the length is calculated as a negative number, writing through the heap memory. An attacker does not need an account; they only need to get the program to parse a crafted piece of Base64. First check the CPU flags, then apply the patch.

How does one extra = turn the length into a negative number

The fault is not in Java's Base64 specification, but in that hand-written assembly inside the JVM meant to speed things up: when calculating the length of the output buffer, an extra padding character drives it into a negative number.

The vulnerability lies in the JVM's (Java Virtual Machine, the runtime layer that runs Java programs) Base64 decoding intrinsic engine. Intrinsic refers to the shortcut by which the JVM replaces certain high-frequency operations from generic bytecode with hand-written machine code, and Base64 decoding is one of them: on x86-64 processors that support AVX-512 VBMI (a vector byte manipulation instruction set extension on x86-64 processors), OpenJDK calls a piece of optimized assembly based on AVX-512 instructions to process a large chunk of data at once. It really is fast, and the accounting is also done in this assembly.

Base64 uses = to pad encoding blocks, and the number of padding characters in normal input is fixed. The problem lies in that "extra" one: when the input has 64 A characters followed by another =, the decoder overshoots when calculating the remaining writable bytes, wrapping around to a negative value. A negative length is not treated as "zero bytes writable" in subsequent address calculations, but as a huge offset.

The consequence is an out-of-bounds write. The decoder writes into the heap buffer according to this erroneous length, and the part written beyond the boundary of the allocated heap memory lands in the region of adjacent objects. What is adjacent on the heap is often the metadata of other objects; if an attacker can overwrite it, they have a chance to escalate a memory corruption into code execution. Wiz's disclosure describes this chain very plainly: the length is miscalculated, the write goes outside the buffer, adjacent object metadata is overwritten, ultimately leading to code execution.

The severity was given a CVSSv4.0 score of 9.2. CVSS is a common system for scoring vulnerability severity, v4.0 is its fourth version, and 9.2 falls in the "critical" range, meaning it can be triggered remotely without authentication. The vulnerability and exploitation method were discovered and disclosed by security firm Calif, and Wiz published the details on November 17, 2026.

Which Java installations are actually affected

Not everyone is affected this time. Only when the three thresholds of hardware, version, and distribution all line up does one hit this path.

First, hardware. The faulty code is optimized assembly that OpenJDK wrote for x86-64 processors, and it is only called on machines that support AVX-512 VBMI (a set of x86 vector instructions that can process more bytes at once). ARM64 processors are not affected—the same OpenJDK build running on ARM never reaches this assembly at all. The newer the x86 server you bought, the more likely it is to be on the list.

Next, version. Affected versions are OpenJDK 17.0.6 and later. Versions before 17.0.6 do not have this faulty implementation, so they are naturally immune; from 17.0.6 all the way to the latest, as long as the hardware matches, they are at risk. Version and hardware are two independent switches, and missing either one means no trigger.

The third layer is the distribution. These downstream distributions share the same OpenJDK code; reinstalling with a different vendor does not avoid it—only changing the hardware architecture or rolling back to an older version will.

ConditionAffectedNot affected
CPU architecturex86-64 with AVX-512 VBMI supportARM64
CPU modelIntel Ice Lake / Sapphire Rapids / Emerald Rapids / Granite Rapids; AMD Zen 4 and newerEarlier Intel and AMD models
OpenJDK version17.0.6 and laterBefore 17.0.6
DistributionCorretto, Temurin, Zulu, Oracle Java SE, etc.None—same codebase, changing vendors does not solve it
Wiz: Research (security research) official image 1
Wiz: Research (security research) official image 1

Three minutes to verify it yourself

The judgment takes two steps: whether the CPU takes that optimized path, and whether the JDK version is new enough. If both hold, this machine is in scope.

First, hardware. On Linux, run grep -m1 '^flags' /proc/cpuinfo; the output is this line of CPU feature flags, then filter it for the four flags avx512f, avx512bw, avx512vbmi, and bmi2. Wiz puts it bluntly: if all four are present, the host is running the vulnerable hardware execution path. Missing even one does not count—this path depends on a whole set of instruction set combinations, and without avx512vbmi AVX-512 VBMI (a vector instruction extension that can process more bytes at once), the decoder will not switch to that assembly at all.

When filtering, be careful not to be fooled by names. bmi2 BMI2 (a bit manipulation instruction extension, with no avx512 in its name) looks unrelated to AVX-512, yet it is on this criteria list; missing it will judge a genuinely affected machine as safe. Conversely, concluding based only on seeing avx512f is also wrong; it only represents the most basic AVX-512 support.

After hardware passes, check the version. Affected versions are OpenJDK 17.0.6 and later, and the threshold is exactly this minor version number: 17.0.5 and earlier are out of scope. Downstream distributions count as well as long as they are based on this version range; the specific list is as described in Section 2 and is not repeated here. ARM64 machines are excluded no matter how new the version is.

Wiz: Research (security research) official image 2
Wiz: Research (security research) official image 2

Which off-the-shelf systems have been proven exploitable

The admin backends that operations teams open every day are all on the list—Wiz's list is titled "Proven exploitable for unauthenticated remote code execution."

Atlassian Jira, Atlassian Confluence, Keycloak, JFrog Artifactory, and Jenkins—all five are in the "proven pre-auth RCE" column.

(remote code execution without logging in) What these five have in common is that their admin ports are open to the internal network year-round, and many teams even map them directly to the public internet. An attacker does not need an account; they only need to get a crafted Base64 input into the decoding path.

Applications built on Spring Boot, Apache Struts, Kafka Broker, Solr, Elasticsearch, Gerrit, Spinnaker, and Tomcat are also included by Wiz in the verified scope.

The Kafka Broker (the server-side process of the message queue) entry matters more to in-house teams: your business code may not touch Base64, but the framework layer feeds user input into the decoder for you, and the path still works.

The speed of verification deserves a separate mention. Wiz's AI vulnerability research tool Atlas built a PoC within 2 hours before the vulnerability details were public. (Working verification code that can actually run) Wiz also acknowledges that generalizing the PoC to arbitrary targets is not easy, and attackers are more likely to go after generic Java applications whose build method and memory layout repeat across multiple targets. The products on the list happen to meet this condition.

This list is "proven," not "all." Wiz did not give exclusion conclusions for untested applications, especially in-house systems.

What to do first now, and can you avoid patching for now

Yes, but how you hold out matters: turn off that fast decoding path, or simply prevent it from running on the instruction set that goes wrong. Both are JVM startup parameters, effective after a restart once changed, at the cost of performance.

The official security patch was released on the day mentioned earlier, the same day the vulnerability details were made public. From that day on, attackers have the principle in hand and defenders have the fix in hand; whoever lands it first gains the advantage. Externally exposed Java applications are first in line: once admin entry points like Jira, Confluence, Keycloak, and Jenkins are breached, what the attacker gets is not a single machine, but the credentials and pipelines behind that machine.

If the patch cannot be applied, turn the switch off first. Add the startup parameter -XX:-UseBASE64Intrinsics, and the JVM will no longer take that hand-written assembly fast path for Base64 decoding, falling back to the ordinary implementation, so the vulnerable code will not be called at all.

The other route is -XX:UseAVX=2, which stops the JVM from using that vector instruction set — effectively moving the execution path off the problematic hardware channel. Wiz puts it bluntly: these two parameters can "completely neutralize" the vulnerability, but may affect application performance. Which is the better trade-off depends on how hot Base64 decoding is in your service — for decoding-heavy services, the cost of disabling the intrinsic is visible; where decoding is only an occasional call, you basically won't notice it.

Don't use a WAF as a patch. Wiz's assessment: the root of the vulnerability lies inside OpenJDK, there are many user-input paths that can reach that decoding code, and rules can hardly block every entry point; for self-built applications the coverage is even worse, because only you know what your traffic looks like. A WAF can stop some exploits that have already appeared, but not all of them, and not inputs tailored to your business.

So the order is: patch if you can, add the parameters if you can't patch, and cut off external network access first if you can't even add the parameters. Any one of these three steps landing is better than doing nothing.

The source is the vulnerability analysis published by Wiz Research on November 17, 2026; the vulnerability was discovered and disclosed by Calif. The affected versions, CPU architecture list, and mitigation parameters can all be independently verified in the Oracle security advisory and the OpenJDK notice. Wiz is a cloud security vendor; the mention of its Threat Center query capability is product-oriented content and does not affect the technical facts above.

Glossary · Plain-language notes in this piece

The full text of in-depth pieces, research analyses, and tool tutorials, plus all podcasts, are in the members' area.

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by 听说了吗
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗