The record for CVE-2026-114938 —"Java4Shell"— opens with Oracle's own words: "Difficult to exploit vulnerability". The vector backs it up, AC:H, high attack complexity, and that discount is worth 1.7 points: the same vector with low complexity would be a 9.8. The people who found it also published a critical 9.2, but under CVSS 4.0 —a different scale, not the same arithmetic—. In their own write-up, the team that discovered it says something else: "It took our own Quang Luong an hour to discover the vulnerability, and two more hours to develop the first working exploit. The total token cost was less than $200." Both sentences are true. The one you plan with is the second.
This came out yesterday, 17 November, so we are not bringing an incident of our own to tell: there isn't one. What we bring is the operational reading of what has been published and what it means for a real estate of machines, with its appliances, its containers and its hypervisor underneath.
Two scores for the same bug
Oracle published the advisory on 17 November and with it its assessment: CVSS 3.1 base 8.1, vector AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. Look at the detail: impact is high on all three —confidentiality, integrity and availability— no authentication is needed, nobody has to click, and it is reachable over the network. With those same values and AC:L, the score would be 9.8. Everything between 9.8 and 8.1 is that H for complexity.
That same NVD record carries a section almost nobody reads and that is worth more than the score: the SSVC assessment signed by CISA Coordinator, with exploitation: none, automatable: no and technicalImpact: total. That is the honest portrait: nobody is using it, it does not automate easily, and whoever it does reach loses the lot. The complexity discount has always been, in practice, a way of saying "this will take someone very good several weeks". It was a stand-in for time. That translation is the one that has stopped working, and it is worth saying without drama: not because the bug is easier than Oracle says —it is not— but because the expert work that used to take weeks can now take an afternoon and an API invoice.
It is worth reading how the researcher himself tells it, because it is not the movie you might imagine: "I told Codex to look at those areas like any serious security researcher in 2026", and then "most early results Codex brought me were slops, either unreachable or the requirement of exploitation is not realistic at all". That hour of discovery includes "around 20 minutes" of throwing away junk. It is not magic; it is a tool that turns expert hours into minutes of sifting. And that is exactly the part the complexity discount priced as expensive.
Three conditions that must hold at once
The bug lives in HotSpot's x86-64 Base64 intrinsic: the accelerated version of the decoder the virtual machine installs when it detects the processor can handle it. With an input of 65 characters —64 A letters and one =, or 128 and one = on OpenJDK 17— it allocates a 50-byte array and writes 62 bytes past the end. Everything else follows from there.
And a fourth thing that is not a condition but a caveat, worth stating so nobody panics more than warranted: crashing the virtual machine is trivial; taking control of it is not. The latter needs heap grooming and a separate leak to defeat address randomisation, and the very team that pulled it off warns that "the current attack is sensitive to network conditions, like RTT and jitter". As of 18 November there is no confirmed exploitation, it is not in CISA's KEV catalogue, and the only public artefact is a trigger that causes the crash, not a full exploit.
When this is not urgent for you (and why that does not close the finding)
Saying "this does not affect you" when it genuinely does not is part of the job. If your application runs on standard Java 8 or Java 11, you are out. If it runs on Graviton, Ampere or any ARM64, also out. If the processor is a pre-Ice Lake Xeon or a Zen 3 or older EPYC, the instruction does not exist and the accelerated decoder is never installed.
The Qualys guidance has one line that sums up what to do with the processor condition better than anything else published, and we repeat it in full: "Use the processor condition to order the work, not to close findings. A workload on an unaffected CPU today can land on an affected one after an instance resize or a move to newer hardware." Translated into our trade: the exemption has an expiry date, and the date is the next time that workload moves.
On a cluster, the CPU condition depends on one line in a file
This is where it stops being a Java story and becomes a virtualisation question, which is our ground. A virtual machine does not see the host's processor: it sees the CPU model you gave it. On Proxmox VE the backend default is kvm64 and what the interface proposes when you create a machine is x86-64-v2-AES. None of the generic models carries the instruction you need: x86-64-v3 adds AVX, AVX2 and the BMI ones, among others, and x86-64-v4 adds avx512f, avx512bw, avx512cd, avx512dq and avx512vl — but not avx512vbmi, which is precisely the one required.
The ones that do pass it through are cpu: host —which per Proxmox's documentation makes "the VM have exactly the same CPU flags as your host system"— and the generation-named models, Icelake-Server, SapphireRapids, EPYC-Genoa, plus any custom model somebody gave +avx512vbmi. All of them are reasonable choices, and they are almost always set for performance. But it means that, on the same cluster and with the same Java, one machine is exposed and the one next to it is not, and the difference is a single line in its configuration file: the same way of failing as when network queue allocation decided which server fell over and which did not.
- 1With
cpu: hostand nodes of different generations, CPUID is fixed when the machine powers on, and HotSpot picks its intrinsics when the JVM starts. So you do not lose it on the live migration: you lose it on the first restart on a newer node —a cold migration, an HA start, a cloud resize—. The delay makes it worse, not better: nobody logs it as a change. - 2An LXC container does not mask CPU flags: it shares the host kernel and sees the host's. If the node has them, the Java inside has them. There is no file to check there.
- 3Same with Docker and Kubernetes: the container does not change the instruction set. What decides is the node where the scheduler places that pod today, which need not be tomorrow's.
The Java you did not install
CISA devotes one line to this in its 17 November alert, and it is the line that will generate the most work: "JDKs and Java runtimes may not appear as separate entries in software inventories." It asks you to review container images and appliances too. Put plainly: the Java that will bite you is not the one you installed with apt, it is the one that came bundled inside something else.
The backup server, the log collector, the storage console, the document manager, the ERP, the integration gateway, the monitoring system: many ship their own runtime under /opt, and the operating system's patch cycle does not touch it. Until the vendor ships its own fixed build, that Java stays as it is. We have written before about inventories that do not contain what is actually there: you bought the company and inherited the system that is not in your inventory. This week the inventory gets reviewed by running process, not by installed package.
The check, per machine, is four commands. jcmd -l lists the Java virtual machines actually running —including the ones nobody on the team installed—; jcmd <pid> VM.version gives each one's version; jcmd <pid> VM.flags shows the flags it started with; and grep -m1 '^flags' /proc/cpuinfo tells you whether the processor that system sees has avx512vbmi. The combination that flags you is: version in the affected range, the four flags the check looks at (avx512f, avx512bw, avx512vbmi and bmi2) present, UseAVX at 3 and UseBASE64Intrinsics set to true. With one catch that bites exactly where it hurts: on an image that ships only the runtime, jcmd is not installed. There the equivalent is java -XX:+PrintFlagsFinal -version | grep -E ' (UseAVX|UseBASE64Intrinsics) ' run inside the container or the appliance.
The boundary rule you can deploy this afternoon
Among the temporary measures CISA recommends —including "restricting and validating Base64 input at the application boundary, enforcing input-size limits, and limiting unauthenticated access"— the first has a concrete and very cheap form that not everyone has noticed.
Valid Base64 is never four times a number plus one in length. The encoding groups bytes three at a time and emits characters four at a time; with padding the length is always a multiple of four, and without padding the possible lengths leave a remainder of 0, 2 or 3. Remainder 1 is impossible. The published trigger is exactly that: 65 characters, 64 and one. A rule that rejects, at the boundary, any Base64 field whose length leaves remainder 1 when divided by 4 breaks no legitimate traffic, because that traffic does not exist. Two caveats before you deploy it: it covers the published trigger, not every future variant; and if the path ends in Base64.getMimeDecoder(), which skips characters outside the alphabet, a line break dropped in the middle brings the field back to a multiple-of-four length with the same 65 valid characters inside. Measure the length after normalising the field, not before. It is a net, not a door.
That rule, a sensible size limit and the third measure —who can reach that service without authenticating— are the only levers that do not depend on having found 100% of your Java virtual machines. And the third buys the most time, because it applies at once to what you know about and what you do not. Taking identity, build and collaboration consoles off the open internet while they get patched is not an elegant measure, but it works, and it is exactly the discipline we sell when we talk about Zero Trust: not "trusting less", but making each service reachable only by whoever has to reach it, so that a flaw in a library does not automatically become a flaw exposed to the internet.
If you cannot patch today: two flags
The fixed builds shipped on 17 November itself: 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 and 8u513-perf, Corretto and Red Hat shipped theirs the same day, with Temurin, Zulu, Liberica, SapMachine and Microsoft following behind. Patching is the right answer. But for what you cannot patch today —the appliance whose vendor has not shipped a build yet— there are two switches that close the path:
- 1
-XX:-UseBASE64Intrinsics— turns off the accelerated decoder and nothing else. It is the one to prefer: surgical, with every other optimisation left standing. - 2
-XX:UseAVX=2— turns off AVX-512 entirely. It works, but it takes down optimisations that have nothing to do with this, so measure first if that application is tight on CPU. And it is for x86: on ARM it does not apply.
The operational detail that saves the afternoon: on an appliance or a container image where you cannot edit the start-up line, these flags go in through the JAVA_TOOL_OPTIONS environment variable. And when the vendor ships its build, they come out. They are time patches, not fixes: write them down in the same place you record changes that have to be undone, because a flag set in a hurry and forgotten is debt somebody else pays two years from now.
What to look for in the logs
CISA asks you to watch for "rogue runtimes, unexpected JVM crashes, and suspicious Java processes". The second leaves traces on disk: every fatal crash writes an hs_err_pid<number>.log in the process working directory, and system logs show "A fatal error has been detected by the Java Runtime Environment" or a SIGSEGV with libjvm nearby. If you have central log collection, that string is a five-minute alerting job.
And here is the realistic risk of the coming weeks, which is not the headline one. Taking control demands the fine work. knocking the process over demands almost nothing: 65 well-placed characters —Calif speaks of crashes with incorrect heap alignment— and the application falls, restarts and falls again. That does not show up in the confidentiality column of any record; it shows up in the invoice for the day your e-invoicing was unresponsive for five hours.
What has actually changed
What has not changed is that a serious flaw turned up in a ubiquitous library; that happens every year. What has changed is that the number many people use to decide when to patch carries an assumption that no longer holds: that high complexity hands you weeks. We already wrote about what a score means today and who assigns it, apropos of a different vendor: Cisco has changed what a CVE means. This is the same problem from the other end.
There is no need to argue with Oracle's score: it is correctly calculated for what it measures. What has to change is what you do with it. An 8.1 with AC:H is still useful for ordering the work queue; it is no longer useful for setting the date. The date is now set by a different question, and it happens to be the only one you can answer without waiting for anybody: who can send data to that process without authenticating first? If the answer is "anyone with the URL", it does not matter what the vector says.
Sources (verified at origin): Oracle's description ("Difficult to exploit vulnerability…"), the 8.1 score, the CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H vector, the component and the affected Oracle Java SE and GraalVM versions — the CVE-2026-114938 record at NVD, published 17/11/2026, over Oracle's security alert. The hour of discovery, the two hours of exploit work, the "less than $200" in tokens, Quang Luong's quotes about Codex, the 9.2 under CVSS 4.0, the mechanism (65 characters, 50-byte array, 62 bytes written past the end), the 128 characters on OpenJDK 17, the sensitivity to RTT and jitter, the AVX-512 VBMI requirement, ARM64 being unaffected and the two mitigation flags — Calif's technical write-up. The "strongly urges organizations to immediately patch", the temporary measures, the crash monitoring and the line about software inventories, container images and appliances — CISA alert of 17/11/2026. The fixed builds, the 17.0.6-onwards range, the affected processor families and the line about using the processor condition to order work rather than close findings — Qualys guidance. That there is no confirmed exploitation and no KEV entry, and that what is public is a trigger rather than a full exploit — Tenable's FAQ. The check commands, the version + flags + UseAVX 3 + UseBASE64Intrinsics combination, the hs_err_pid files, the log strings and the use of JAVA_TOOL_OPTIONS to inject the flag where the start-up line cannot be touched — ThreatDefence's detection guide. The kvm64 and x86-64-v2-AES defaults, the flags each x86-64-vN model adds and the "exactly the same CPU flags as your host system" for host — Proxmox VE documentation, virtual machines chapter. The remainder-1 arithmetic, the reading that the CPU exemption expires at the first restart on a newer node and the translations of the quotes are ours. Photograph: Jud McCranie, CC BY-SA 4.0 via Wikimedia Commons. We are not Oracle resellers, nor Microsoft's, nor any platform's, and we do not sell anybody's licences.
Do you know how many Java runtimes are running in your estate today?
At everyWAN we sweep by running process —not by installed package—, we tell you what each service exposes to the internet, and we put the boundary where it belongs. We design and run Zero Trust architectures and the rest of the managed security that holds them up. If you want the real inventory before there is a public exploit, get in touch.
Talk to everyWAN