Back to Intelligence

CVE-2026-114938 (Java4Shell): Pre-Auth RCE in Jira, Jenkins & Keycloak — Detection and Mitigation Guide

SA
Security Arsenal Team
November 18, 2026
13 min read

Security research firm Calif disclosed Java4Shell (CVE-2026-114938) this week: a pre-authentication remote code execution flaw in the Java runtime affecting Java 17.0.6 and later, exploitable against at least six widely deployed applications — including Atlassian Jira, Jenkins, and Keycloak. If your organization runs internet-facing Java services on modern Intel or AMD server silicon, this is a stop-what-you're-doing event.

Introduction: Why This One Matters

In 15+ years of incident response, I've learned to treat three combinations with immediate urgency: pre-auth + RCE + ubiquitous platform. Java4Shell hits all three. The vulnerability lives in the Java runtime itself — not in any single application — which means the blast radius extends across every Java-based product in your stack that satisfies the hardware and version conditions. Atlassian Jira and Jenkins are, from an attacker's perspective, among the highest-value targets in any enterprise: Jira holds your project intelligence and credentials; Jenkins holds your build secrets, deployment keys, and effectively the keys to production. Keycloak compounds the problem — a compromise there undermines your entire identity and access management plane.

The one mitigating factor is the hardware constraint: exploitation requires an x86-64 Intel or AMD processor with AVX-512 VBMI support. Do not let that lull you into complacency. AVX-512-capable silicon (Intel Ice Lake/Sapphire Rapids generations, AMD Zen 4/5) is precisely what modern cloud instances and datacenter servers run on. If you patched your hardware estate in the last five years, you are very likely in scope.

Action required: inventory, verify exposure, apply mitigations now, and patch the moment vendor runtimes are updated.

Technical Analysis

Affected Products and Platforms

  • Vulnerable component: Java runtime, version 17.0.6 and later (LTS 17 line is explicitly called out; defenders should assume later LTS lines in the affected window are at risk until vendor advisories confirm otherwise)
  • Hardware dependency: x86-64 Intel and AMD CPUs supporting the AVX-512 VBMI instruction set extension
  • Confirmed exploitable applications (per Calif's disclosure): Atlassian Jira, Jenkins, Keycloak, plus three additional widely used applications (names pending in the truncated disclosure — treat all internet-facing Java services as potentially in scope)
  • Authentication requirement: None — this is pre-authentication RCE
  • CVSS: Not published in the disclosure summary; treat as Critical (pre-auth RCE in a foundational runtime) until scored. The naming itself — "Java4Shell" — deliberately echoes Log4Shell, and the research firm is signaling comparable severity.

How the Attack Works (Defender's Perspective)

Based on the disclosed parameters, the exploitation profile points to a flaw in the JVM's optimized code path — almost certainly the JIT (Just-In-Time) compiler's vectorized intrinsic handling for AVX-512 VBMI instructions. This class of bug works roughly as follows:

  1. Trigger delivery: The attacker sends crafted input to an application endpoint reachable without authentication (Jira REST endpoints, Jenkins CLI/web endpoints, Keycloak auth flows, etc.).
  2. JIT compilation path: The malicious input drives specific Java bytecode patterns into the JIT compiler's hot path. When the JVM detects AVX-512 VBMI support, it emits vectorized native code through the vulnerable intrinsic.
  3. Memory corruption in generated code: The flaw corrupts the JIT-compiled native code — bypassing Java's memory safety model entirely. This is why it's so dangerous: the vulnerability lives below the JVM's sandbox, in generated machine code.
  4. Code execution: The attacker achieves arbitrary native code execution with the privileges of the JVM process — typically the jira, jenkins, or keycloak service account.

Exploitation prerequisites that matter for triage:

  • The JVM must be running on AVX-512 VBMI-capable silicon. ARM instances, older Intel (pre-Ice Lake SP), and AMD pre-Zen 4 are out of scope for the native execution path — but verify rather than assume.
  • The vulnerable code path must be exercised — which in practice means normal application request patterns are likely sufficient, since JIT tiering kicks in under routine load.

Exploitation Status

  • Disclosure: Public via Calif (research firm), week of the news item (November 2026)
  • PoC / in-the-wild status: Not confirmed in the available summary. However, the Log4Shell precedent is instructive: weaponization of pre-auth Java RCE flaws historically moves from disclosure to mass scanning within 24–72 hours. Assume active exploitation attempts imminently.
  • CISA KEV: Not yet listed at time of writing — monitor CISA KEV continuously; if added, federal remediation deadlines will follow.

Detection & Response

This is a technical threat. The detection strategy for JIT-compiler RCE is indirect but effective: you rarely see the corruption itself, but you always see the post-exploitation behavior — a JVM doing things a JVM should never do. Focus your telemetry there.

Sigma Rules

YAML
---
title: Java Application Server Spawning Shell or Script Interpreter
description: Detects a JVM process (java/javaw) spawning a shell, script interpreter, or download utility — a high-fidelity post-exploitation indicator for Java runtime RCE such as CVE-2026-114938 (Java4Shell). Legitimate Java application servers almost never spawn interactive shells or curl/wget.
references:
  - https://thehackernews.com/2026/11/java4shell-cve-2026-114938-enables-pre.html
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/06
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\java.exe'
      - '\javaw.exe'
      - '\javaservice.exe'
      - '\commons-daemon.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\curl.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\rundll32.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Jenkins Pipeline jobs legitimately invoking batch/PowerShell steps (filter by known Jenkins agent parent trees and job workspaces)
  - Custom Jira/Keycloak admin plugins executing scripts
level: high
---
title: Linux JVM Spawning Shell or Download Utility
description: Detects a Java process on Linux spawning sh/bash, curl, wget, python, perl, or base64 decode pipelines — classic post-exploitation behavior following Java application server compromise such as CVE-2026-114938 (Java4Shell) against Jira, Jenkins, or Keycloak.
references:
  - https://thehackernews.com/2026/11/java4shell-cve-2026-114938-enables-pre.html
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/06
tags:
  - attack.execution
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|contains:
      - '/java'
      - '/jre/'
      - '/jdk'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
      - '/socat'
      - '/base64'
      - '/chmod'
      - '/chown'
  condition: selection_parent and selection_child
falsepositives:
  - Jenkins freestyle/pipeline jobs executing shell build steps — correlate with Jenkins agent workspace paths (/var/lib/jenkins/workspace/) before tuning
  - Application health-check wrappers
level: high
---
title: JVM Crash Artifacts Indicating JIT Compiler Memory Corruption
description: Detects JVM fatal error log (hs_err_pid) generation or repeated JVM crashes, which can indicate attempted exploitation of JIT-compiler memory corruption vulnerabilities like CVE-2026-114938. Failed exploit attempts against the AVX-512 VBMI code path are likely to crash the JVM before successful code execution.
references:
  - https://thehackernews.com/2026/11/java4shell-cve-2026-114938-enables-pre.html
  - https://attack.mitre.org/techniques/T1499/
author: Security Arsenal
date: 2026/11/06
tags:
  - attack.impact
  - attack.t1499
logsource:
  category: file_event
  product: linux
detection:
  selection:
    TargetFilename|contains:
      - 'hs_err_pid'
      - 'replay_pid'
  condition: selection
falsepositives:
  - JVMs crashing due to resource exhaustion or unrelated bugs — but any hs_err file on a production app server warrants review regardless
level: medium

Tuning note from the field: the Jenkins false positive is real — Jenkins legitimately spawns shells for build steps. Do not disable the rule. Instead, scope it: alert at high when the child process spawns from the Jenkins controller's own JVM (not agents), and at medium from agent JVMs, then triage against the build job audit log. A shell spawned by the controller JVM outside an active build is a five-alarm fire.

KQL (Microsoft Sentinel / Defender)

The following hunt query identifies JVM processes spawning suspicious child processes across Windows and Linux endpoints (via Defender for Endpoint) and Syslog-ingested Linux hosts. Run it environment-wide, then narrow to your Jira/Jenkins/Keycloak servers.

KQL — Microsoft Sentinel / Defender
// Java4Shell (CVE-2026-114938) post-exploitation hunt: JVM spawning shells/tools
let SuspiciousChildren = dynamic(["cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","curl.exe","certutil.exe","bitsadmin.exe","rundll32.exe","sh","bash","dash","curl","wget","python","python3","perl","nc","ncat","socat","base64"]);
union isfuzzy=true
    (DeviceProcessEvents
    | where TimeGenerated > ago(7d)
    | where InitiatingProcessFileName in~ ("java","java.exe","javaw.exe","javaw")
    | where FileName in~ (SuspiciousChildren)
    | project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName, InitiatingProcessId, Source="MDE"),
    (Syslog
    | where TimeGenerated > ago(7d)
    | where SyslogMessage has_any ("java") and SyslogMessage has_any (SuspiciousChildren)
    | where SyslogMessage has "Process Create" or Facility == "user"
    | project TimeGenerated, HostName, ProcessName, SyslogMessage, Source="Syslog")
| order by TimeGenerated desc
// Secondary hunt: JVM crash artifacts (hs_err_pid) signaling failed exploit attempts
;
DeviceFileEvents
| where TimeGenerated > ago(7d)
| where FileName startswith "hs_err_pid"
| project TimeGenerated, DeviceName, FolderPath, FileName, InitiatingProcessFileName
| order by TimeGenerated desc

Correlate any hits with inbound HTTP request logs from your WAF/reverse proxy for the 5-minute window preceding the child process creation. For pre-auth exploitation, you are looking for unauthenticated requests to Jira REST endpoints (/rest/api/, /rest/gadget/), Jenkins (/cli, /script, /jnlpJars/), or Keycloak (/realms/, /auth/) from IPs with no prior session history.

Velociraptor VQL

Use this artifact to hunt across your Linux server fleet for Java processes with suspicious child processes or unexpected network connections — the two post-exploitation observables that survive even a clean, fileless intrusion.

VQL — Velociraptor
-- Java4Shell (CVE-2026-114938) hunt: JVM processes with suspicious children or connections
-- Identifies java processes and cross-references against shell-spawn and outbound C2 patterns

SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime,
       netstat() AS Connections
FROM pslist()
WHERE Name =~ 'java'
   OR CommandLine =~ '(?i)(jira|jenkins|keycloak)'

-- Follow-up: enumerate children of identified JVM PIDs
SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Ppid IN (
    SELECT Pid FROM pslist() WHERE Name =~ 'java'
)
AND Name =~ '(?i)(sh|bash|dash|curl|wget|python|perl|nc|ncat|socat|base64|chmod)'

-- Network connections from JVM processes to unusual destinations
SELECT Pid, Name, Status, Laddr, Raddr
FROM netstat()
WHERE Name =~ 'java'
  AND Status == 'ESTABLISHED'
  AND NOT Raddr.IP =~ '^(10\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|192\\.168\\.|127\\.)'

Any JVM holding an established connection to a public IP that is not your known artifact repository, Atlassian/Maven/CDN endpoints, or IdP infrastructure requires immediate investigation.

Exposure Verification Script

The fastest way to shrink your scope is to enumerate which servers actually meet the exploitation prerequisites: Java 17.0.6+ AND AVX-512 VBMI. This Bash script audits a Linux host for both, and flags any JVM running the vulnerable combination.

Bash / Shell
#!/usr/bin/env bash
# Java4Shell (CVE-2026-114938) exposure audit
# Checks: (1) AVX-512 VBMI CPU support, (2) Java versions present, (3) running JVMs

echo "=== [1] CPU AVX-512 VBMI capability ==="
if grep -q 'avx512vbmi' /proc/cpuinfo; then
    echo "[EXPOSED-HW] CPU supports AVX-512 VBMI — hardware prerequisite MET"
    grep -m1 'model name' /proc/cpuinfo
else
    echo "[OK] CPU does not support AVX-512 VBMI — not exploitable via this path"
fi

echo ""
echo "=== [2] Installed Java runtimes ==="
for j in $(which -a java 2>/dev/null) $(ls /usr/lib/jvm/*/bin/java 2>/dev/null); do
    ver=$("$j" -version 2>&1 | head -1)
    echo "FOUND: $j -> $ver"
    # Flag Java 17.0.6 and later
    if echo "$ver" | grep -qE '17\.(0\.([6-9]|[1-9][0-9])|[1-9])'; then
        echo "  [VULNERABLE-VERSION] Java 17.0.6+ detected"
    fi
done

echo ""
echo "=== [3] Running JVM processes (Jira/Jenkins/Keycloak) ==="
ps -eo pid,user,comm,args | grep -E '[j]ava|[j]ira|[j]enkins|[k]eycloak' | head -50

echo ""
echo "=== [4] JVM crash artifacts (possible failed exploitation) ==="
find / -name 'hs_err_pid*' -mtime -14 2>/dev/null | head -20

echo ""
echo "=== [5] Recommended immediate mitigation (if patch unavailable) ==="
echo "Add to JVM options for affected services: -XX:UseAVX=2"
echo "This caps JIT vectorization below AVX-512 and avoids the vulnerable code path."

Run this across your fleet via your orchestration tool of choice (Ansible, Salt, SSM). Any host that flags [EXPOSED-HW] and [VULNERABLE-VERSION] and runs Jira, Jenkins, Keycloak, or another internet-reachable Java service goes to the top of the remediation queue.

Remediation

1. Immediate Mitigation (Today — Do Not Wait for the Patch)

The hardware dependency gives defenders a powerful stopgap: disable the AVX-512 JIT code path at the JVM level by capping vector instruction usage:

Code
-XX:UseAVX=2

Add this to the JVM options for every affected service (JIRA_JAVA_OPTS/setenv.sh for Jira, JAVA_OPTS in the Jenkins service unit or /etc/default/jenkins, JAVA_OPTS_APPEND for Keycloak on Quarkus). This forces the JIT compiler to emit AVX2-or-lower vectorized code, sidestepping the vulnerable AVX-512 VBMI intrinsic path entirely. Expect a marginal performance impact on vectorization-heavy workloads — an acceptable trade against pre-auth RCE. Validate this workaround against Calif's technical write-up when published, but based on the disclosed exploitation prerequisite (the vulnerable code runs only on AVX-512 VBMI hardware), suppressing that code path is a sound interim control.

If your orchestration allows, you can also schedule workloads to non-AVX-512 nodes temporarily — a blunt but effective containment for containerized Java services.

2. Patch the Java Runtime

  • Apply the fixed OpenJDK/vendor runtime (Oracle, Amazon Corretto, Azul, Eclipse Temurin, Red Hat) the moment a release addressing CVE-2026-114938 ships. Subscribe to your distribution's security feed and the OpenJDK Vulnerability Advisories today.
  • Do not forget the bundled runtimes. Jira, Jenkins installers, and Keycloak containers frequently ship their own JRE. Patching the system Java does nothing if the application bundles its own. Rebuild container images from patched base images and redeploy — patching inside a running container is an anti-pattern I still see in IR engagements and it will burn you here.
  • Verify post-patch: java -version on every service, and re-run the audit script above.

3. Reduce the Pre-Auth Attack Surface

  • Jenkins should never be internet-facing. Full stop. If yours is, that is a finding independent of this CVE. Put it behind VPN or identity-aware proxy (SSO via Keycloak — ironically — with device posture checks).
  • Place Jira and Keycloak behind a WAF or reverse proxy with request-rate anomaly detection. Pre-auth exploit delivery requires direct HTTP reachability; every layer between the attacker and the JVM buys detection time.
  • Restrict egress from Java application servers to an explicit allowlist (artifact repos, IdP, Atlassian endpoints). JIT RCE payloads that can't call home or pull second stages are dramatically less valuable to the attacker.

4. Validate Detection Coverage

  • Deploy the Sigma rules above to your process-creation telemetry (Sysmon/auditd/EDR). Test them deliberately: spawn a shell from a JVM on a staging host and confirm the alert fires.
  • Backfill the KQL hunt over the last 30 days — public disclosure is when mass exploitation starts, but targeted exploitation frequently precedes disclosure. Look for JVM-spawned shells before the news broke.
  • Review JVM crash artifacts (hs_err_pid* files) on all in-scope servers. Failed exploitation attempts against JIT corruption bugs typically crash the JVM; a cluster of crashes on an internet-facing Java service in recent weeks deserves forensic attention.

5. Monitor for Escalation

  • Watch the CISA KEV catalog — if CVE-2026-114938 is added, BOD 22-01 deadlines apply to federal agencies and the exploitation is confirmed.
  • Track Calif's full technical write-up and vendor advisories from Atlassian, the Jenkins project, and the Keycloak/CNCF maintainers for application-specific guidance, indicators, and any confirmed IOCs.

The Bottom Line

Java4Shell is the second time a "4Shell" has named itself after the Java ecosystem's blast radius, and the defensive playbook rhymes: inventory fast, mitigate the code path you can control, patch the runtime everywhere it hides, and hunt for the JVM misbehaving. The AVX-512 constraint is a gift — it tells you exactly which servers are in scope. Use it. The teams that come through this cleanly will be the ones who treated "theoretical, PoC not yet public" as "exploit incoming," because in the Java ecosystem, that assumption has been correct every single time it mattered.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.