DEV Community

Cover image for Calif Says AI Found Java4Shell (CVE-2026-114938) in an Hour for Under $200
GDS K S
GDS K S

Posted on Edited on

Calif Says AI Found Java4Shell (CVE-2026-114938) in an Hour for Under $200

Calif Says AI Found Java4Shell (CVE-2026-114938) in an Hour for Under $200

Buried in the Java4Shell (CVE-2026-114938) coverage is a line most people scrolled past. The researchers at Calif say they found the bug with AI help in about an hour. They say a first working exploit took about two hours after that. And they say the whole thing cost under $200 in AI token costs.

Qualys repeats those numbers and attributes them to the researchers, and Upwind reports the one-hour and two-hour parts. Nobody has independently checked them. Treat them as a claim. But look at what happens if they are even roughly true.

TL;DR

Claim Source Checked by others
Bug found with AI help in about an hour Calif, via Upwind and Qualys No
First working exploit about two hours later Calif, via Upwind and Qualys No
Under $200 in AI token costs Calif, via Qualys No
Fix committed under embargo October 14, 2026 Endor Labs Single source
Public disclosure and Oracle fixes November 17, 2026 Qualys, Upwind, Endor Labs Four sources
Bug leaked before its patch Calif, via Upwind and Endor Labs No

Do the arithmetic on the defender side

Put the two clocks next to each other.

The discovery side, per Calif: about three hours of work from nothing to a working exploit, for a bill that fits on a corporate card without sign-off.

The defender side, from public dates: the fix landed on October 14, 2026 and the public advisory and vendor builds landed on November 17. That is 34 days between a committed fix and a public one. Endor Labs adds that on November 17 the public jdk17u, jdk21u and jdk25u repositories did not yet carry the fix, and that a South Korean advisory flagged an unauthenticated Java RCE a day earlier.

After the build exists, you still have to find every JVM, rebuild images and restart processes. The runbook in my earlier post covers that. That part is slow, and your change windows set its pace, not the clock.

I am not saying attackers will win that race. I am saying the race is now one where one side's cost fell through the floor, while the other side's cost is the same human approval chain it always was.

What the broader numbers say

I did not read the full reports, only the headlines, so take these as pointers and not evidence for this CVE.

The headline of Rapid7's 2026 annual threat report says exploited high and critical severity vulnerabilities surged 105 percent as attack timelines collapsed. A separate Rapid7 Q2 2026 release says nearly two thirds of exploited vulnerabilities needed no user interaction. A news summary of that quarter says newly exploited vulnerabilities jumped from 8 percent to 40 percent.

None of that proves AI is the cause. That fits a world where finding bugs got cheaper, and Java4Shell is a vivid example, if Calif's numbers hold.

The Token Tab, from the other side

I have written before about the bill AI tools quietly send you. This is the reverse entry. Someone else's tokens are now a line item on your risk register. By Calif's account, the discovery took one engineer, some prompts and an afternoon.

The honest caveats matter here. Calif says it holds back its product-specific exploits and there is no universal one. The sources I read show no public proof-of-concept shell. Equixly calls code execution unproven and a crash the realistic outcome. A cheap discovery does not mean a cheap, reliable exploit against your particular deployment.

What I would change in my own process

Three policy changes follow from a cheap-discovery world, and none of them need a new product.

First, measure your restart latency. Patching a file does not fix a running JVM. How long does it take your slowest service to go from "fixed build available" to "process restarted on the fixed build"? If you cannot answer, that is your real patch window.

Second, tie your deadline to exposure instead of a flat number. Qualys orders its priorities as internet-facing identity providers first, then Jira, Confluence, Jenkins and Artifactory, then other internet-facing Java services, then internal data systems.

Third, keep a runtime inventory that is always on. The Java4Shell exposure depends on the JDK build and the CPU feature, and neither shows up in a dependency scan.

A triage script

This script takes the inventory output from the runbook, one line per JVM (pid, path, version), plus an AVX-512 flag, and sorts each into patched, exposed or not affected using the version ranges Qualys and Upwind list. It does not check for vendor-specific builds, so a version number that passes is not a promise. Confirm against the vendor advisory.

#!/usr/bin/env python3
"""java4shell_triage.py: classify JVM versions against the published ranges.

Input: lines of "pid<TAB>path<TAB>version" on stdin, e.g. 17.0.19, 21.0.13.
Usage: python3 java4shell_triage.py --avx512 < inventory.tsv
"""
import argparse
import re
import sys

# line -> first affected, first fixed (Qualys and Upwind, November 17, 2026)
RANGES = {
    17: ((17, 0, 6), (17, 0, 21, 1)),
    21: ((21, 0, 0), (21, 0, 13, 1)),
    25: ((25, 0, 0), (25, 0, 5, 1)),
    27: ((27, 0, 0), (27, 0, 1, 1)),
}


def parse(version: str) -> tuple:
    nums = [int(n) for n in re.findall(r"\d+", version)[:5]]
    return tuple(nums)


def pad(t: tuple, n: int = 5) -> tuple:
    return t + (0,) * (n - len(t))


def classify(version: str, avx512: bool) -> str:
    v = parse(version)
    if not v or v[0] not in RANGES:
        return "not-affected-or-unknown"
    first_bad, first_fixed = RANGES[v[0]]
    if pad(v) < pad(first_bad) or pad(v) >= pad(first_fixed):
        return "not-affected-or-fixed"
    return "EXPOSED" if avx512 else "vulnerable-code-no-avx512"


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--avx512", action="store_true", help="host has all four AVX-512 flags")
    args = ap.parse_args()
    for line in sys.stdin:
        parts = line.rstrip("\n").split("\t")
        if len(parts) < 3:
            continue
        pid, path, version = parts[0], parts[1], parts[2]
        print(f"{classify(version, args.avx512):28} pid={pid} {version} {path}")


if __name__ == "__main__":
    main()
Enter fullscreen mode Exit fullscreen mode

The middle state matters. A host without AVX-512 VBMI runs vulnerable code that cannot reach the bad path today. Qualys warns that a resize or instance change can move a workload onto an affected CPU later, so that state deserves a ticket, not a shrug.

The bottom line

The part of Java4Shell that will age best is not the 62-byte overflow. It is a line in a vendor blog post saying someone did the discovery work in an afternoon with a model. Even if those exact numbers fail scrutiny, plan your patch process for the version of the world where they do.

If a bug like this took three hours and under $200 to find, how long does your slowest service take to restart?


GDS K S · thegdsks.com · building Glincker · follow on X @thegdsks

Cheap discovery moves the bottleneck to your restart window.

Sources: Qualys, Upwind, Endor Labs, Equixly, Rapid7 Q2 2026 release.

Top comments (0)