RC RANDOM CHAOS

Sixty-four A's and an equals sign break OpenJDK's Base64

Java4Shell (CVE-2026-114938) is a heap overflow in OpenJDK's Base64 decoder that Calif turned into pre-auth RCE across widely deployed Java apps.

· 3 min read
Sixty-four A's and an equals sign break OpenJDK's Base64

Sixty-four A characters and a trailing = are enough to write past the end of an array inside OpenJDK’s Base64 decoder. Calif published the bug as Java4Shell (CVE-2026-114938) and scores it 9.2 under CVSS 4.0. On older OpenJDK 17 the trigger is 128 As followed by = instead of 64.

The trigger string:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=

The decoder’s fast path uses AVX-512 VBMI instructions on supported x86-64 processors to decode many bytes at once, and the bug lives in the hand-rolled assembly that handles the final characters. For that 65-byte input, OpenJDK allocates a 50-byte output array, decodes the first 64 characters cleanly, then mishandles the stray = and computes a negative output length. The negative length becomes a full 64-byte write, pushing 62 bytes past the end of the array. The runtime rejects the input a moment later, but by then neighboring heap objects may already be corrupted. Depending on what sits next to that array, the corruption can disclose memory the way Heartbleed did or be steered into remote code execution.

Base64 decoding runs almost anywhere a Java service parses input: authentication tokens, file uploads, network messages. Calif demonstrated pre-auth RCE in default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate. Post-auth RCE worked against Apache Kafka brokers, Apache Solr, Elasticsearch, Gerrit, and Spinnaker. They also got code execution in sample applications built on Apache Struts and Spring Boot. The lists are explicitly non-exhaustive; any endpoint that base64-decodes attacker-controlled bytes is a candidate.

The client-side case deserves equal attention. samczsun supplied an exploit in which a Java program that opens a TLS connection to a malicious server is compromised, even though it exposes no service of its own. Outbound connections are attack surface here, which pulls batch jobs, crawlers, and internal clients into scope alongside the obvious servers.

One detail bounds the exposure. The vulnerable routine is the AVX-512 VBMI optimization, so it only executes on x86-64 hosts whose CPUs support that instruction set. Hosts without it take a different decode path. That narrows the affected fleet, though not in a way you can rely on across mixed hardware.

There is no single universal exploit. Calif notes that depending on how an application uses Base64 and how it behaves, different steps may be required for exploitation. The trigger itself is trivial, but turning the corruption into memory disclosure or code execution takes careful exploitation.

For remediation, track your OpenJDK vendor’s advisory for the fixed build and patch the runtime rather than individual applications; the flaw is in the JDK, not in Keycloak or Kafka. Prioritize internet-facing pre-auth targets from the list, then anything that accepts uploads or federated authentication.

Calif says one of its researchers found the bug in an hour and had a working exploit two hours later, for under $200 in AI token costs, using AI agents to drive exploitation pipelines it had set up in advance. The framing the company hangs on that result, the “centaur hacker” and a pitch for AI-assisted dead-code removal it calls “vibe-uncoding,” is its own. The operational fact is that a trivially triggered heap overflow sits in a core JDK routine, with exploits already demonstrated against widely deployed applications, and the input that proves it is 65 bytes long.

Share

Keep Reading

Latest on the Wire

Full wire →

New signal daily · RSS

Stay in the loop

New writing delivered when it's ready. No schedule, no spam.