A new vulnerability in OpenJDK has surfaced, and this one caught my attention because there's an interesting detail that makes it a little different from your usual Java security advisory.
Tracked as CVE-2026-114938 and nicknamed Java4Shell, it can potentially allow remote code execution in Java-based applications. Sounds bad, right? Well, before anyone starts checking every machine in their network, there's something worth understanding.
This vulnerability doesn't affect every system running Java. In fact, exploitation depends on a combination of factors: an affected OpenJDK version, an x86-64 processor with AVX-512 VBMI support, and an application processing attacker-controlled Base64 input through the vulnerable decoder.
So, simply having Java installed doesn't mean you're vulnerable. The hardware matters just as much as the software in this particular case.
The vulnerability was disclosed on November 17, 2026. Security researchers have demonstrated that specially crafted input can trigger memory corruption, potentially allowing an unauthenticated attacker to execute arbitrary code on a vulnerable system.
It has received a CVSS score of 9.2 (CVSS 4.0) from the researchers, while Oracle assigned it 8.1 (CVSS 3.1).
What exactly is Java4Shell?
The problem is in an optimized implementation of the Java Base64 decoder, more specifically its hardware-accelerated execution path.
If you're wondering what Base64 has to do with all this, it's simply a way of encoding binary data into text. You'll find it in all sorts of places, including authentication headers, SAML tokens, CSRF tokens and various application-level operations.
On supported processors, OpenJDK uses AVX-512 VBMI instructions to make Base64 decoding faster. Unfortunately, specially crafted malformed input can make this implementation write beyond its allocated memory area, potentially corrupting adjacent memory.
Depending on the application and how an attacker can manipulate that corrupted memory, the consequences can range from a service crash to information disclosure or even arbitrary code execution.
And here's the particularly nasty part: Base64 decoding can happen before authentication. In other words, having a login page doesn't necessarily protect an application if the vulnerable code processes incoming data before checking who is sending it.
Researchers have already demonstrated pre-authentication remote code execution against several popular enterprise applications, including:
- Jenkins
- Keycloak
- Atlassian Jira
- Atlassian Confluence
- JFrog Artifactory
- PingFederate
Am I affected? Let's look at the hardware first
This is probably the most interesting part of this vulnerability, and also the one that can save you some unnecessary worrying.
Java4Shell does not affect every system running a vulnerable OpenJDK version. There are three things that need to come together before a system can be considered potentially vulnerable.
1. An affected OpenJDK version
First, the application needs to be running an affected OpenJDK runtime.
Having Java installed isn't enough, and don't assume that checking the Java version reported by your operating system tells you everything. Some applications bundle their own Java runtime, completely independently of the system-wide installation.
2. The right hardware
This is where things get interesting.
The vulnerable implementation uses hardware-accelerated Base64 decoding through AVX-512 VBMI instructions. This means the underlying processor needs to support that particular instruction set.
The documented affected hardware includes supported x86-64 processors from Intel Ice Lake onwards and AMD Zen 4 onwards.
ARM64 processors and x86-64 processors without AVX-512 VBMI support are not known to be affected.
So, even if you're running an affected Java version, an older processor without the required instruction set doesn't meet the documented hardware requirements.
3. An application that actually processes malicious input
There's one more piece to the puzzle. The application needs to use the vulnerable Base64 decoding implementation and process input that an attacker can control.
All three conditions matter. Having a vulnerable Java version alone isn't enough. Neither is having a compatible processor. The software, hardware and application behaviour need to line up.
How to check whether your hardware is affected
Rather than guessing based on your processor model, you can check directly from Linux.
Run the following command:
grep -m1 -o avx512vbmi /proc/cpuinfoThat's it. We're looking for one specific CPU flag: avx512vbmi.
Here's how to interpret the result:
- If it returns `avx512vbmi`: your processor supports the relevant instruction set. That's one of the prerequisites, but it does NOT automatically mean your system is vulnerable.
- If it returns nothing: your processor does not expose AVX-512 VBMI, so it doesn't meet the documented hardware requirement for Java4Shell.
I actually find this distinction important because it's easy to see a critical vulnerability announcement, check your Java version and assume the worst. In this case, the hardware check is an important first step.
Of course, this only checks the processor. It doesn't tell you which Java version an application is using, whether the vulnerable decoder is enabled or whether the application processes attacker-controlled input.
You can check your system-wide Java version with:
java -versionJust remember that applications can bundle their own Java runtime. If you're running services inside containers, for example, you need to check those environments as well.
The bottom line: you need an affected OpenJDK implementation, compatible AVX-512 VBMI hardware and an application using the vulnerable decoder with attacker-controlled input. Finding the CPU flag is only the beginning of the assessment, not proof of vulnerability.
How to mitigate the vulnerability
As usual, the best solution is to update OpenJDK to a patched version provided by your distribution or software vendor.
Oracle and OpenJDK published fixes on November 17, 2026, although package availability depends on your operating system and distribution.
If you cannot update immediately, there is an interim workaround for affected JVM installations.
You can disable the vulnerable hardware-accelerated Base64 implementation using:
-XX:-UseBASE64IntrinsicsThis disables the affected optimization while retaining other AVX-512 optimizations.
Another option is:
-XX:UseAVX=2This prevents the JVM from using AVX-512 instructions altogether. The first option is generally preferable because it's more targeted.
Keep in mind that these are workarounds, not replacements for installing the security updates.
And if an application comes with its own bundled JVM, follow the vendor's instructions rather than randomly replacing its Java runtime. You don't want to fix one problem and create another.
What about Home Assistant?
I also wondered about this one, since Home Assistant is something you might have running alongside all sorts of other services in a homelab.
The good news is that Home Assistant Core is written in Python, as is its Supervisor. Neither is directly affected by this OpenJDK vulnerability.
However, Home Assistant OS also supports additional applications (formerly known as add-ons), which run in separate containers and can use completely different technologies.
If you're running Java-based software in one of those containers, or somewhere else in your homelab, it's worth checking its runtime and the underlying processor capabilities.
The same goes for other self-hosted services. Just because the main application is written in Python, for example, doesn't mean every component or dependency it uses is automatically free from Java-related vulnerabilities.
A final word about Internet exposure
One last thing worth mentioning: whether a vulnerable service is exposed to the Internet makes a big difference to your actual risk.
If an application accepts unauthenticated requests directly from the Internet, an attacker has a much easier way of reaching it. Keeping administrative interfaces and internal services behind a firewall, VPN or other access controls is therefore a very good idea.
But don't confuse not being publicly accessible with being completely safe. A compromised device or another untrusted machine on your local network could still interact with vulnerable services.
Personally, I prefer keeping management interfaces and services that don't need public access private in the first place. There's no reason to expose something to the entire Internet just because it happens to work that way.
As always, keep your software updated, minimize exposed services and, perhaps most importantly, understand what you're actually running before deciding whether a particular vulnerability affects you.
References
Red Hat - CVE-2026-114938 Security Advisory
- Log in to post comments
- 6 views