Java4Shell (CVE-2026-114938): Pre-Auth RCE Hits Keycloak, Jira

Java4Shell lets unauthenticated attackers hit Jira, Jenkins, and Keycloak alike. Patching the JVM is step one — rotating every token your identity provider issued during the exposure window is the step most advisories skip.

The short version: CVE-2026-114938, nicknamed "Java4Shell," is a memory-corruption bug in OpenJDK's hardware-accelerated Base64 decoder that lets an unauthenticated attacker send a single crafted string and reach remote code execution on affected Java 17, 21, 25, and 27 servers. Researchers at Calif demonstrated pre-auth RCE against default installs of Jira, Jenkins, Confluence, Artifactory, PingFederate, and Keycloak. Oracle shipped fixed builds on November 17, 2026, and CISA told organizations to patch immediately. Patching closes the hole, but it does nothing about the OAuth tokens, client secrets, and signing material that Keycloak and PingFederate issued while they were exposed — that cleanup is a separate job, and most advisories barely mention it.

What actually broke

Java4Shell lives in a narrow, specific place: the CPU-accelerated version of java.util.Base64.Decoder that OpenJDK's HotSpot JVM uses on x86-64 processors with AVX-512 VBMI instructions. When that intrinsic decodes a malformed Base64 string, it can write past the end of a heap buffer. Researcher Quang Luong at the security firm Calif found and reported the issue, and Oracle credits him along with Albert Yang in its advisory.

The attack surface is wherever an application Base64-decodes attacker-supplied input before authentication — login forms, SSO callback parameters, file uploads, basic-auth headers. No account or session is required, which is why this is being described as a pre-auth bug rather than a privilege-escalation one.

What makes it more than a crash bug is the second stage researchers reported: before (or instead of) full code execution, the same memory corruption can be used to read adjacent heap contents. Qualys's analysis is blunt about what that means in practice — an attacker with no credentials can corrupt Java heap memory, read secrets from it, and reach remote code execution, and that memory can hold private keys, tokens, and personal data.

The product list should get your attention

This isn't an obscure library. Calif's own testing, cited widely across the vendor writeups published in the last two days, showed working pre-auth exploitation against six widely deployed applications running vulnerable Java: Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate.

6
major applications with demonstrated pre-auth RCE in default installs: Jira, Jenkins, Confluence, Artifactory, Keycloak, and PingFederate
90%
of Fortune 500 companies run Java somewhere in their stack, by the figure researchers cited when sizing up the blast radius
8.1
Oracle's CVSS v3.1 severity score; early researcher writeups scored it 9.2 under the newer CVSS v4.0 scale

Four of those six are "just" critical infrastructure — a compromised Jira or Confluence instance is bad, but it's a contained, auditable kind of bad. The other two, Keycloak and PingFederate, are identity providers. That distinction is the whole reason this incident deserves a different remediation checklist than a typical RCE.

Why an IdP breach doesn't end when you patch

Keycloak doesn't just serve a web UI. It issues OAuth2 access tokens, refresh tokens, and ID tokens; it signs them with realm keys; it stores client secrets for every application registered against it; and in many deployments it brokers access to downstream APIs on behalf of users and service accounts. A pre-auth RCE against that system is not "one more server to patch." It's a question about the integrity of every credential the system touched while it was vulnerable.

This is the detail most of the same-day advisories skip past. They correctly tell you to patch the JVM. Few of them walk through what to do about the tokens and secrets Keycloak already handed out before you patched — because that work has to happen in your identity and API layer, not in the JVM.

HeroDevs' writeup on the framework-level exposure is one of the few that says this plainly: the heap-disclosure stage happens before code execution, so the right response is to rotate the secrets that service held in memory: session signing keys, API tokens, database credentials, and TLS private keys. For an identity server, that list expands to include every token it minted and every client secret it stored, because you can't tell from the outside which ones an attacker's crafted request happened to land near in memory.

The uncomfortable part: there's no log entry that reliably tells you "this specific token was read from heap memory." If Keycloak or PingFederate was internet-facing and unpatched between November 17 and whenever you applied the fix, the safe assumption is that anything issued in that window is unverified, not clean.

1 · Discovery

Calif researcher Quang Luong identifies the Base64 decoder flaw while auditing OpenJDK, reports it to Oracle, and privately verifies pre-auth RCE against several popular Java applications.

2 · Disclosure and patch, November 17, 2026

Oracle ships fixed builds (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1) as part of its Critical Patch Update, the CVE goes public, Calif publishes its technical writeup, and CISA issues an alert urging immediate patching.

3 · Vendor analysis wave

Wiz, Qualys, Endor Labs, Blackpoint Cyber, and others publish same-day breakdowns. The Keycloak project ships a mitigation commit disabling the vulnerable Base64 intrinsic by default in its startup scripts and operator images.

4 · Where things stand now

No confirmed in-the-wild exploitation has been reported and the CVE is not yet in CISA's Known Exploited Vulnerabilities catalog. That's reassuring but not proof of anything — absence of confirmed exploitation is not the same as absence of exploitation.

A practical response, in order

If you run any of the affected products, the sequence matters:

  1. Inventory first. Find every Java 17+ deployment on x86-64 hardware with AVX-512 VBMI support, since the bug only fires on that CPU path. Prioritize anything internet-facing, especially identity, CI/CD, and collaboration systems.
  2. Patch to the fixed build. Oracle's November 17 builds, or your distribution's equivalent (Amazon Corretto 17.0.21.1.2 is one example already out), are the only complete fix. Framework updates to Spring Boot, Tomcat, or Jetty don't close this on their own, since the flaw sits below the application layer.
  3. Apply the JVM flag as a stopgap only. Where patching has to wait, starting the JVM with -XX:-UseBASE64Intrinsics (or the broader -XX:UseAVX=2) disables the vulnerable code path. Neither is an Oracle-endorsed fix; both are documented interim mitigations while you schedule the real patch.
  4. Then rotate downstream of every identity system that was exposed. For Keycloak specifically: rotate realm signing keys, rotate client secrets for every registered application, and treat refresh tokens and offline tokens issued during the exposure window as suspect. Force re-authentication where you can. Do the same for PingFederate if it's in your stack.
  5. Extend rotation to anything those tokens unlocked. If Keycloak-issued tokens were used to call downstream APIs, rotate the API keys and service-account credentials on the other end too, not just the tokens themselves.
  6. Review logs for the exposure window, even knowing they won't show a clean "yes/no" answer. Look for unusual token issuance volume, unexpected client registrations, or admin API calls you can't attribute.

Where an egress-layer architecture actually helps — and where it doesn't

It's worth being precise about what this incident does and doesn't argue for. Java4Shell is a memory-safety bug in the JVM itself; no secrets-management or API-gateway architecture would have stopped the heap overflow from existing, and nothing should claim otherwise.

Where architecture does matter is in what happens after a system like this is compromised. KnoxCall's model injects third-party API keys at the egress wire, so the application process, the CI runner, and the agent calling out never hold the literal credential in memory or in an environment variable. If your Keycloak instance brokered access to those downstream APIs, the question "which third-party keys were exposed to the compromised process" has a much shorter, more concrete answer when the process itself never had the raw key to leak in the first place. That doesn't touch Keycloak's own signing keys or the tokens it issued directly — those still need the rotation steps above. It does shrink the list of things you have to worry about downstream.

For teams managing that downstream credential sprawl, our guides on OAuth2 token management and on why secrets stored in cleartext keep causing incidents like this one cover the rotation mechanics in more depth. For the gateway side of this, see KnoxCall's security architecture.

What's still unconfirmed

A few things are genuinely unsettled as of this writing. The CVSS score discrepancy — Oracle's 8.1 under CVSS v3.1 versus the 9.2 figure circulating under CVSS v4.0 — reflects two different scoring systems rather than a dispute over severity, but it has caused confusion in early coverage. Whether AI-assisted vulnerability research (Calif has said the bug was found with help from an AI coding assistant) changes the timeline for similar discoveries is a separate, open question. And as noted above, "no known exploitation" is the current state of public knowledge, not a guarantee.

The bottom line

Patch the JVM. That part is not optional and not complicated: get to the November 17 builds or your vendor's equivalent, or apply the intrinsic-disabling flag while you wait. But if Keycloak, PingFederate, or any other identity system in your environment was internet-facing and unpatched in the exposure window, patching is the start of the remediation, not the end of it. Rotate the signing keys. Rotate the client secrets. Treat tokens issued during that window as unverified. The advisories that only say "update your JDK" are correct as far as they go — they just don't go far enough for a system whose entire job is minting credentials.

Frequently asked questions

What is Java4Shell (CVE-2026-114938)?

Java4Shell is the nickname for CVE-2026-114938, a memory-corruption vulnerability in OpenJDK's hardware-accelerated Base64 decoder. It lets an unauthenticated attacker send a crafted Base64 string to reach heap memory disclosure and, in several demonstrated cases, remote code execution on affected Java 17, 21, 25, and 27 servers.

Is Keycloak affected by Java4Shell?

Yes. Security researchers at Calif demonstrated pre-authentication remote code execution against a default Keycloak installation running a vulnerable OpenJDK build, alongside Jira, Jenkins, Confluence, Artifactory, and PingFederate. The Keycloak project has since shipped a mitigation that disables the vulnerable Base64 intrinsic by default.

How do I patch CVE-2026-114938?

Update to the fixed OpenJDK builds Oracle released on November 17, 2026 (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1) or your JDK vendor's equivalent patched release. Where patching has to wait, starting the JVM with the flag -XX:-UseBASE64Intrinsics disables the vulnerable decoding path as an interim, unofficial workaround.

Does patching Java4Shell mean I'm fully protected?

Patching stops new exploitation, but it doesn't undo anything that may have happened while the system was exposed. If an internet-facing Keycloak or PingFederate instance was unpatched during the exposure window, tokens and client secrets it issued in that period should be treated as unverified and rotated, since there's no reliable log signal confirming whether heap memory was read.

Has Java4Shell been exploited in the wild?

As of the most recent public reporting, no confirmed in-the-wild exploitation has been reported and the CVE is not listed in CISA's Known Exploited Vulnerabilities catalog. CISA has nonetheless urged organizations to patch immediately given the severity and the breadth of affected software.

Why is a CVSS score of both 8.1 and 9.2 being reported?

The two numbers come from different scoring systems rather than a disagreement about severity. Oracle's official advisory scores the flaw 8.1 under CVSS v3.1, while early researcher writeups cited a 9.2 score under the newer CVSS v4.0 framework.

Sources

  1. CVE-2026-114938 RCE in OpenJDK: Everything You Need to Know (Wiz)
  2. How to Find, Mitigate, and Patch the Critical Java4Shell Flaw (Qualys)
  3. Java4Shell (CVE-2026-114938): Pre-Auth Heap Overflow in OpenJDK (Endor Labs)
  4. Java4Shell (CVE-2026-114938): Inside a Critical Flaw in Java's Base64 Decoder (Blackpoint Cyber)
  5. Java4Shell (CVE-2026-114938) Enables Pre-Auth RCE in Jira, Jenkins, Keycloak (The Hacker News)
  6. Critical Java Vulnerability Requires Immediate Patching (CISA)
  7. Java4Shell (CVE-2026-114938): OpenJDK RCE Vulnerability FAQ (Tenable)
  8. Java4Shell CVE-2026-114938: Exposure and How to Patch (HeroDevs)
  9. Mitigate OpenJDK Base64 intrinsic vulnerability (Keycloak GitHub Issue #55293)
  10. Critical Java4Shell flaw allows RCE attacks on major Java applications (BleepingComputer)

Keycloak can be patched in an afternoon. Your downstream key sprawl can't.

Java4Shell is a reminder that identity systems get breached too; KnoxCall keeps the third-party API keys those systems broker out of app memory and CI runners so a compromised IdP isn't also a compromised credential store.

Start Free →

Or get new posts by email. Double opt-in, unsubscribe anytime.