Creuto is now an OpenAI Select Partner Read More
A java4shell scanner keyed on your package list misses the JDKs bundled in Jira, Jenkins and Keycloak. Find every running JVM, scope by CPU, prove the fix.

CISA's Java4Shell alert carries a line most patch reports skip: JDKs and Java runtimes "may not appear as separate entries in software inventories". A java4shell scanner that reads your package list will report a clean host while Jira or Keycloak runs its own unpatched runtime beside it. By the end of this post you will have a sweep that finds those JVMs, scopes them by CPU, and proves the fix in CI.
That matters if you have been asked to tell leadership that no unpatched JVM remains, internal tools included. The products Calif showed falling to a pre-auth attack are mostly internal tools, and several of them ship their own Java.
Java4Shell (CVE-2026-114938) is a memory-corruption bug in OpenJDK's x86-64 Base64 decoder intrinsic, disclosed by Calif on 17 November 2026. Three conditions decide whether a given JVM is exposed, and a scanner has to answer all three per process, not per host.
| Condition | Exposed when | Source |
|---|---|---|
| Runtime version | OpenJDK 17.0.6 or newer, 21, 25 or 27 without the fix; Oracle Java SE 8u511b33-perf | OX Security |
| CPU | x86-64 with AVX-512 VBMI (Intel Ice Lake to Granite Rapids, AMD Zen 4 and newer); ARM64 is not affected | Calif |
| Mitigation | The running process lacks -XX:-UseBASE64Intrinsics or -XX:UseAVX=2 | Calif |
Standard Java 8 and Java 11 builds, and Java 17.0.0 to 17.0.5, do not contain the vulnerable code, according to OX. Which patched build each vendor shipped is a separate question, and the vendor advisories are the place to settle it.
OX puts the problem plainly: "Many products ship their own runtime, including Jira, Confluence, Jenkins images, Keycloak and Elasticsearch", and the version java -version reports on the host may not be the one the service uses. Qualys gives the same warning about its own platform: "Bundled JDKs in containers and appliances may not appear in a standard inventory, so check those separately."
Now set that against the list of products Calif demonstrated pre-auth RCE on: Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. Post-auth, it adds Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. These are the identity, ticketing, build and artifact systems that sit behind the VPN and get patched last. If Artifactory is already on your patch list from the earlier Artifactory vulnerability chain, the same host deserves a second look now.
There is a second gap, and it is quieter. Qualys InstaScan findings are "based on the installed version", while the same Qualys post tells you to restart every Java process and verify the running process rather than only the installed package. A host where the package was upgraded but Jenkins was never restarted looks fixed to an installed-version check and is still running the old code.
The reliable way to detect Java4Shell exposure is to ask each running JVM which binary it is, then ask that binary its version. On Linux, every process exposes its executable at /proc/<pid>/exe, which resolves to the bundled runtime even when PATH points elsewhere.
for p in $(pgrep -f java); do readlink -f /proc/$p/exe; done | sort -u/path/from/step1 -version 2>&1 | head -1. For a JVM owned by another user, jcmd <pid> VM.version run as that user gives the same answer.find / -xdev -type f -path '*/bin/java' 2>/dev/nullStep 3 matters because a scheduled job or a service that starts on demand will not appear in step 1 on the day you run it. Treat any binary path that is not under your distro's package directories as a bundled runtime and trace it to the product that installed it.
Containers need the same question asked from inside the image. For a running container, docker exec <container> java -version works when java is on the image's PATH; when it is not, read the entrypoint and call that binary directly. For a Kubernetes cluster, start with the set of images actually running: kubectl get pods -A -o jsonpath='{range .items[*]}{.spec.containers[*].image}{"\n"}{end}' | sort -u.
For images at rest, an SBOM tool helps if it looks for the runtime and not just application libraries. Syft lists a java-jvm-cataloger that keys on the JDK's release file. Trivy's Java coverage page lists JAR/WAR/PAR/EAR, pom.xml, Gradle and sbt lock files, which describes your application's dependencies, not the JVM running them. Whatever tool you use, check one known image with a bundled JDK and confirm the runtime shows up before you trust a clean result across the fleet.
A host meets the hardware condition only when all four flags appear in this check, published by Calif:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
The counter-argument deserves its strongest form here. If most of your fleet is Graviton, Cascade Lake or Zen 3, the CPU check removes most of the work, so why chase every bundled runtime on hosts that cannot trigger the bug? Qualys answers it in one line: use the CPU check "to order the work, not to close findings". Autoscaling groups and container schedulers can move workloads between CPU generations, and a JVM that is safe on today's node may land on a Sapphire Rapids node next week.
The CPU check is the right tool for deciding what to patch first. It is the wrong tool for closing a ticket.
Calif published a bounded trigger, not an exploit. Its Base64Trigger class warms the decoder with 200,000 valid decodes, then decodes a malformed input into a 4,096-byte array and checks whether bytes past the output were overwritten. It prints REPRODUCED on success, or NOT REPRODUCED to stderr with exit code 1. Calif says every write lands inside a real array, so the trigger is safe to run.
That exit code makes it a usable gate in a CI pipeline: run the class with the exact java binary each image ships, and fail the build if it prints REPRODUCED. For a vendor product, that means running it with the product's bundled runtime, not with the JDK on the build agent.
The trap is the runner. The bug needs a CPU with all four flags, so NOT REPRODUCED on a runner without them tells you nothing about the image. Run the cpuinfo check as the first step of the job and fail it, rather than pass it, when the flags are missing. Calif notes the trigger input differs by version: 64 A characters plus = on newer builds and 128 on OpenJDK 17, so pin the variant to the major version you are testing.
Be careful where you get any other proof of concept. Tenable quotes Kevin Breen saying he has "a functional exploit POC for CVE-2026-114938", though the post does not say it has been released, and OX notes that Calif has not released its exploits and that fake PoC repositories for high-profile CVEs regularly carry malware. Use Calif's trigger from Calif's page and nothing from a repository you found by searching.
Qualys shipped three detections in VULNSIGS-2.6.747-3: QID 389494 for OpenJDK, 389610 for the Oracle November 2026 CPU and 389608 for Amazon Corretto, with distribution-specific QIDs promised later. Tenable lists its plugins on the CVE page as they are released and points users to its Explore > Software view and Java Visibility and Exposures report.
Use both, but read what they measure. Neither post says its checks cover a JDK bundled inside a vendor product, and Qualys says outright that those may not appear in a standard inventory. A commercial java4shell scanner gives you breadth across the fleet; the process sweep above fills the gap it admits to. Where the two disagree, the process sweep is the one reading the binary that is actually running.
Where a patch cannot go in this week, Calif's workaround is -XX:-UseBASE64Intrinsics, or the blunter -XX:UseAVX=2, which OpenJDK on ARM will not start with. Qualys warns that applications decoding large amounts of Base64 may slow down, so test first.
A flag in a config file proves nothing until the process restarts with it. Check the live JVM with jcmd <pid> VM.flags -all | grep UseBASE64Intrinsics and record the result in the same evidence table as the version. Bundled products set JVM options in their own launch scripts, so a flag added to a system-wide JAVA_OPTS may never reach Jira or Keycloak.
The question you have been asked is a proof question, and it has the same shape as any cryptographic inventory: list everything, then show each item's state. One row per running JVM, with host, CPU flags present, binary path, version, patched or mitigated, and the date checked. Rows from the scanner and rows from the process sweep should reconcile; any JVM in one list and not the other is the finding.
Then keep it true. The CI gate catches the next image built on an old base, and a scheduled re-run of the process sweep catches the vendor appliance someone installs next quarter. If you want help turning this sweep into a standing check, our QA and automation team can wire the runtime inventory, the CPU check and the reproducer gate into the pipelines you already run, so the next "are we exposed?" question has an answer you can send the same day.
Scanning for Java4Shell means checking each running JVM, not each package. List the binary behind every Java process through /proc/ /exe, ask that binary its version, check the host for the avx512f, avx512bw, avx512vbmi and bmi2 CPU flags, and confirm whether the live process carries the -XX:-UseBASE64Intrinsics workaround.
Calif, which disclosed Java4Shell, published a bounded Base64Trigger class rather than an exploit. It prints REPRODUCED when the decoder overwrites memory inside a test array and exits with code 1 otherwise. OX Security warns that fake proof-of-concept repositories for high-profile CVEs often carry malware, so use only Calif's own page.
Jenkins and Jira were both among the products Calif demonstrated pre-authentication remote code execution against, alongside Keycloak, Confluence, Artifactory and PingFederate. OX Security notes that Jira, Confluence, Jenkins images, Keycloak and Elasticsearch ship their own runtime, so patching the host JDK alone may leave the bundled one exposed.
A Qualys or Tenable scan may not find every bundled JDK. Qualys says bundled JDKs in containers and appliances may not appear in a standard inventory and should be checked separately, and its InstaScan findings rely on installed versions. Pair scanner results with a process-level sweep of running JVMs and reconcile the two lists.
A host without AVX-512 VBMI does not meet Java4Shell's hardware condition today, but Qualys advises using the CPU check to order the work, not to close findings. Workloads can move between instance types and CPU generations, so an unpatched runtime on an older host still needs patching or the workaround.
Ready to take the first step towards unlocking opportunities, realizing goals, and embracing innovation? We're here and eager to connect.