Oracle rolled out an out-of-band emergency security update for the Java platform on November 17, 2026, scrambling to neutralize a critical memory-corruption vulnerability dubbed "Java4Shell". Tracked as CVE-2026-114938, the flaw exists within OpenJDK’s hardware-accelerated Base64 decoding routine. Under specific hardware configurations, the vulnerability enables unauthenticated attackers to trigger remote code execution (RCE) or exfiltrate sensitive memory from thousands of enterprise server applications worldwide.
The incident escalated rapidly when technical details leaked online hours before the coordinated disclosure deadline, forcing Oracle, the OpenJDK Vulnerability Group, and independent security firm Calif to publish fixes and technical advisories ahead of schedule. Within hours of the coordinated release, the Cybersecurity and Infrastructure Security Agency (CISA) issued an emergency alert urging organizations to apply the official Java4Shell vulnerability fix or implement immediate runtime mitigations.
The vulnerability scores an 8.1 on the Common Vulnerability Scoring System (CVSS) version 3.1 scale—and 9.2 under CVSS 4.0—reflecting its ability to cross security boundaries without authentication, tempered primarily by high environmental and architectural prerequisites. Proof-of-concept tests demonstrated unauthenticated remote code execution across standard installations of ubiquitous enterprise software, including Atlassian Jira, Confluence, JFrog Artifactory, Jenkins, and identity platforms like Keycloak and PingFederate.
This security event provides an instructive case study. It illustrates the operational hazards of hardware-dependent microcode optimizations in managed runtimes, the structural vulnerabilities hidden inside decades-old foundational libraries, and the accelerating speed of AI-driven vulnerability discovery.
Technical Anatomy: How a Managed Language Suffered a Heap Overflow
Java has long marketed itself on the guarantee of memory safety. Memory bounds checking, automatic garbage collection, and strong typing are designed to render classic buffer overflows impossible within pure bytecode. CVE-2026-114938 bypasses this protection entirely by striking at the boundary where Java bytecode hands execution off to native CPU hardware.
Untrusted HTTP / TLS Input (Base64 payload ending with malformed padding)
│
▼
java.util.Base64.Decoder (Standard Java API)
│
▼
HotSpot C2 JIT Compiler Path
│
▼
AVX-512 VBMI Vectorized Intrinsic (Hand-written x86-64 Assembly)
│
├─► Logic error calculates negative output length on stray '='
└─► 64-byte vector store mask miscalculated
│
▼
Heap Buffer Overflow (62–63 bytes written past allocated memory)
│
├─► Option A: Corrupt neighboring objects ──► Unauthenticated RCE
└─► Option B: Overwrite response buffers ──► Data Leak ("JavaBleed")
The defect lives inside the HotSpot Java Virtual Machine's (JVM) C2 Just-In-Time (JIT) compiler, specifically within a performance intrinsic that accelerates Base64 decoding using x86-64 Single Instruction, Multiple Data (SIMD) instruction sets. First backported to OpenJDK 17 in late 2022 under change request JDK-8296735, the code uses advanced vector extensions—specifically AVX-512 Vector Byte Manipulation Instructions (VBMI)—to process 64 bytes of data in a single CPU cycle.
The Mechanics of the Tail Bug
The flaw is located in the assembly code responsible for handling the "tail" of the Base64 input—the final few characters that often contain padding (=). When processing standard data, the intrinsic parses input in 64-byte chunks, converting ASCII values back into raw binary bytes.
However, Calif researcher Quang Luong discovered that if an unauthenticated user submits an invalid Base64 string that terminates unexpectedly with a stray = character, the assembly routine's arithmetic logic breaks down:
- The intrinsic calculates the length of the remaining bytes to store in memory.
- Under malformed padding, this calculation produces a negative output length.
- Instead of cleanly terminating or throwing an immediate runtime error, the routine miscalculates the 64-byte write mask.
- The vectorized assembly instructions execute a full 64-byte write into the JVM heap, overshooting the allocated destination byte array by 62 to 63 bytes.
- The HotSpot JVM subsequently detects that the Base64 input was invalid and raises an IllegalArgumentException, but the memory corruption on the heap has already occurred.
Because the write happens directly via native CPU registers without going through Java’s managed bounds checks, the runtime corrupts adjacent objects on the Java heap before the application catches the error.
Dual Exploitation Vectors: Memory Leak and Execution Takeover
Security analysts confirmed two distinct weaponization paths for CVE-2026-114938:
- Remote Memory Disclosure ("JavaBleed"): By carefully manipulating the placement of heap allocations, an attacker can overwrite the size headers of neighboring byte buffers or string objects without crashing the JVM. When the server subsequently returns an HTTP response, it sends back 62 bytes of uninitialized heap memory. Repeated requests allow an attacker to reconstruct live heap memory, siphoning active session tokens, encryption keys, and personally identifiable information (PII).
- Pre-Authentication Remote Code Execution (RCE): In software suites where Base64 decoding happens prior to authentication—such as parsing HTTP Basic Authentication headers, SAML assertions, or mutual TLS certificates—the corruption can overwrite internal object metadata, class pointers, or callback references. While the exact exploit chain varies per application due to memory layout differences, Calif successfully demonstrated unauthenticated RCE on multiple industry-standard platforms. Researcher samczsun also verified a reverse vector: a Java-based client making an outbound TLS request to a malicious server can be compromised when decoding crafted server certificates.
The Hardware Fracture: Why Microarchitecture Dictates Exposure
Unlike previous broad Java vulnerabilities such as Log4Shell (CVE-2021-44228) or Spring4Shell (CVE-2022-22965), Java4Shell contains an uncommon dependency: CPU architecture. The vulnerable code path executes exclusively on processors that support the AVX-512 VBMI instruction set.
| Hardware Family | Architecture | Vulnerable to CVE-2026-114938? | Technical Rationale |
|---|---|---|---|
| Intel Xeon Scalable (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) | x86-64 | Yes | Supports full AVX-512 VBMI; HotSpot enables the intrinsic by default. |
| AMD EPYC & Ryzen (Zen 4, Zen 5) | x86-64 | Yes | Includes AVX-512 VBMI support; intrinsic compiles and executes. |
| Intel Xeon (Skylake, Cascade Lake, Cooper Lake) | x86-64 | No | Supports basic AVX-512, but lacks the specific VBMI extension; intrinsic stays disabled. |
| Older x86 Processors (Intel Broadwell, AMD Zen 1–3) | x86-64 | No | Restricts HotSpot to AVX2 instructions; unaffected fallback decoder is used. |
| ARM64 (AWS Graviton 2/3/4, Ampere Altra, Apple Silicon) | ARM64 (AArch64) | No | Intrinsic is architecture-specific to x86-64; ARM NEON/SVE routines lack the bug. |
This hardware dependency divides cloud infrastructure into asymmetric risk tiers. Enterprise deployments operating on modern bare-metal servers or current-generation cloud instances (such as AWS c6i, m6i, c7a, or equivalent Azure and Google Cloud instances) are directly exposed. Conversely, identical container images deployed onto AWS Graviton (ARM64) or older legacy hardware are invulnerable to exploitation, despite running the exact same software build.
This architectural split complicates incident response. Vulnerability management tools that scan Software Bill of Materials (SBOM) data or container manifests can flag an application as vulnerable based on its Java version, even when the underlying hypervisor or CPU lacks the instructions needed to trigger the flaw.
Deploying the Java4Shell Vulnerability Fix: Patches and Operational Defenses
Remediating CVE-2026-114938 requires addressing both runtime distributions and system configurations. The official OpenJDK and Oracle security update alters the intrinsics handling routine: instead of executing the broken hand-coded assembly when processing unaligned or malformed tails, HotSpot now immediately transfers the remaining bytes to a safe, pure-Java decoding loop.
┌───────────────────────────────────┐
│ Incoming Base64 Decoding Request │
└─────────────────┬─────────────────┘
│
Is CPU x86-64 with AVX-512 VBMI?
│
┌────────────────┴────────────────┐
YES NO
│ │
┌──────────┴──────────┐ ┌─────────┴─────────┐
│ Patch Applied (.1)? │ │ Pure-Java Fallback│
└──────────┬──────────┘ │ or AVX2 Decoder │
│ └─────────┬─────────┘
┌───────┴───────┐ │
YES NO ▼
│ │ Safe Execution
▼ ▼
Vector Intrinsic VULNERABLE
+ Safe Fallback Run with:
for Tail Padding -XX:-UseBASE64Intrinsics
│
▼
Safe Execution
Affected Versions and Patched Builds
The flaw was introduced into OpenJDK 17 starting with version 17.0.6, and subsequently carried into all later Long-Term Support (LTS) and feature releases. Standard builds of Java 8 and Java 11 do not include this intrinsic and remain immune. However, Oracle's proprietary Java 8 Performance Pack (specifically build 8u511b33-perf) backported the optimization and is vulnerable.
| Java Line | Vulnerable Releases | Official Oracle Patched Build | Downstream Status (Corretto, Temurin, Red Hat) |
|---|---|---|---|
| Java 17 (LTS) | 17.0.6 up to 17.0.21 | 17.0.21.1 | Amazon Corretto: 17.0.21.1.2 Temurin/Red Hat rolling out. |
| Java 21 (LTS) | 21.0.0 up to 21.0.13 | 21.0.13.1 | Patching actively across cloud package repositories. |
| Java 25 (LTS) | 25.0.0 up to 25.0.5 | 25.0.5.1 | Updated builds available via Oracle and vendor repos. |
| Java 27 | 27.0.0 up to 27.0.1 | 27.0.1.1 | Patch shipped in November CSPU. |
| Oracle Java 8 | 8u511b33-perf only | Patched in emergency build | Standard Java 8 builds unaffected. |
Applying the Java4Shell vulnerability fix involves swapping out underlying Java Runtime Environments (JREs) and JDKs, rebuilding container base images, and restarting affected processes to terminate in-memory instances of the vulnerable JIT compiler.
Runtime Workarounds Without Service Downtime
For teams unable to execute emergency deployments across hundreds of microservices immediately, the HotSpot engine provides command-line flags that deactivate the vulnerable routine on running servers without breaking Base64 functionality:
- Disable Base64 Intrinsics Globally:
Adding the flag -XX:-UseBASE64Intrinsics to the JVM launch arguments instructs HotSpot to use the standard, memory-safe software decoding algorithm. This stops the heap overflow across all hardware architectures, though it introduces a negligible processing overhead during Base64-intensive operations.
- Cap Vector Instruction Levels:
Supplying -XX:UseAVX=2 on x86-64 instances restricts HotSpot from compiling AVX-512 instructions altogether, falling back to AVX2 instructions where the flawed intrinsic is not implemented.
Both mitigations require a process restart, but they allow engineering teams to stabilize environments while comprehensive patching schedules are organized.
Case Study Analysis: Four Core Lessons from Java4Shell
The Java4Shell incident serves as a case study that reveals structural fault lines across enterprise security architectures. By analyzing how this vulnerability developed, escaped notice, and was ultimately addressed, engineering organizations can identify foundational systemic weaknesses.
Lesson 1: The Managed Runtime Illusion and the Cost of Native Intrinsics
Software development teams frequently operate under the assumption that selecting a memory-safe language isolates them from memory corruption vulnerabilities. If a service is written in Java, Go, or C#, conventional wisdom suggests engineers need only protect against logic flaws, cross-site scripting (XSS), SQL injection, and deserialization issues.
Java4Shell demonstrates how this boundary erodes when managed runtimes chase raw computational speed. To maintain performance parity with C, C++, and Rust, language runtimes routinely bypass their own internal safeguards using intrinsics—subroutines written in assembly that map directly to native processor instructions.
┌────────────────────────────────────────────────────────┐
│ High-Level Code: java.util.Base64.Decoder │
│ - Guaranteed boundary checks │
│ - Strict type enforcement │
├────────────────────────────────────────────────────────┤
│ JIT Optimization Boundary │
│ - C2 HotSpot compiler strips runtime checks │
│ - Replaces bytecode with hand-written assembly │
├────────────────────────────────────────────────────────┤
│ Native CPU Execution: AVX-512 Vector Assembly │
│ - Raw memory pointers │
│ - Direct heap access │
│ - Native memory-safety vulnerabilities recreated │
└────────────────────────────────────────────────────────┘
When an intrinsic miscalculates an array index, there is no language-level safety net. The assembly routine writes directly into raw heap addresses. As runtimes incorporate more specialized SIMD pipelines for encryption, string manipulation, JSON parsing, and encoding, they reintroduce the very memory vulnerabilities they were built to eliminate.
Lesson 2: The Fragmentation of Attack Surfaces by Microarchitecture
Traditional enterprise patch management operates on a binary evaluation: an asset is either running an affected software version or it is not. Vulnerability management teams rely on package registries, lockfiles, and container image scans to flag exposed assets.
Java4Shell demonstrates that vulnerability triage now requires evaluating the physical and virtual CPU architecture beneath the software stack. If two Kubernetes pods execute identical container images of Keycloak 24.0 running OpenJDK 21.0.12, but Pod A runs on an AWS Graviton instance while Pod B runs on an Intel Xeon Sapphire Rapids host, only Pod B is vulnerable to exploitation.
Container Image
(Keycloak + OpenJDK 21.0.12)
│
┌────────────────┴────────────────┐
▼ ▼
Node Pool A: ARM64 Node Pool B: x86-64
(AWS Graviton 3/4) (Intel Sapphire Rapids)
│ │
▼ ▼
NO VBMI INTRINSIC VBMI INTRINSIC ACTIVE
│ │
SAFE FROM EXPLOIT CRITICAL RCE EXPOSURE
Security teams that rely solely on software inventories face two primary problems:
- False Alarms: Expending critical response time evaluating thousands of container workloads deployed on ARM or pre-AVX-512 infrastructure.
- Blind Spots: Overlooking internet-facing edge proxies and identity providers running on modern x86 chips where exploitation can happen before authentication occurs.
Vulnerability management programs must incorporate host-level CPU feature flags (/proc/cpuinfo or cloud hypervisor metadata) directly into their attack-surface inventories to triage flaws tied to hardware optimizations.
Lesson 3: The Compressing Response Window Driven by AI Discovery
The discovery timeline of CVE-2026-114938 signals a shift in vulnerability research. Calif reported that researcher Quang Luong identified the memory corruption bug in roughly one hour using AI-assisted source auditing, and constructed the first functional remote exploit within two hours.
This incident followed disclosures where automated AI security agents located deep bugs in the PHP engine within hours.
The implications for enterprise defenders are significant:
- Shorter Time-to-Exploit: Attackers and researchers no longer need weeks of manual reverse-engineering to discover edge-case assembly flaws. Machine learning systems can rapidly ingest complex JIT compiler trees and identify mathematical boundary discrepancies.
- Pre-Patch Disclosure Risks: Java4Shell leaked before the scheduled coordination window concluded. As AI makes vulnerability discovery easier for a wider group of researchers and independent actors, leaks and accidental disclosures are likely to become more frequent.
- The Demise of "Security Through Complexity": Obscure assembly implementations were once considered relatively safe from broad exploitation simply because writing weaponized exploits for JIT-compiled heap layouts required niche expertise. AI-driven testing environments automate heap-grooming simulations, drastically lowering the technical barrier to operationalizing an exploit.
Organizations cannot assume a 30-day grace period between vulnerability discovery and weaponization. The time between bug identification, leak, and broad exploitation has compressed into a single operational window.
Lesson 4: The Enterprise Blind Spot of Embedded Runtime Dependencies
The blast radius of Java4Shell spans foundational infrastructure software: Atlassian Jira, Confluence, Jenkins, JFrog Artifactory, Keycloak, PingFederate, Apache Solr, Spinnaker, and Elasticsearch.
This distribution highlights the persistent risk of runtime embedding. In modern enterprise architectures, Java is rarely managed merely as a single platform runtime installed at the operating system layer (/usr/bin/java). Instead, it is distributed as:
- Vendor-managed software appliances that bundle their own custom JREs inside private directories.
- OCI/Docker container images containing multi-stage, stripped-down base images (like Alpine, Distroless, or Chainguard) with embedded JVMs.
- Standalone binaries compiled via GraalVM Native Image containing embedded HotSpot intrinsics.
Enterprise Infrastructure Attack Surface
│
┌────────────────────────┬────────┴───────────────┬────────────────────────┐
▼ ▼ ▼ ▼
Operating System Vendor Appliances Container Images Compiled Binaries
System Java (Jira, Artifactory) (Alpine/Distroless) (GraalVM Native)
│ │ │ │
Easily Updated Hidden Bundled JRE Requires Base Image Requires Full
via Package Mgr Requires Vendor Patch Rebuild + Redeploy Recompilation
When an emergency patch is released, standard operating system package updates (apt upgrade or yum update) leave these embedded runtimes untouched. Unless security teams possess deep process-level visibility, vulnerable instances inside enterprise appliances remain unpatched and exposed to untrusted external traffic.
Strategic Principles for Enterprise Defense
Responding effectively to hardware-linked runtime flaws requires balancing immediate incident response with long-term architectural adaptations. The following structured playbook outlines how engineering and security organizations should navigate this and future vulnerabilities.
Immediate Tactical Phase (Hours 0–48)
The initial priority is reducing attack exposure on externally reachable boundaries without disrupting critical operations.
1. Map Internet-Exposed Ingestion Points
Identify all internet-facing Java applications decoding Base64 data prior to user authentication.
- Focus immediately on identity providers (Keycloak, PingFederate), single sign-on (SSO) gateways processing SAML assertions, and CI/CD tools (Jenkins).
- Inspect public-facing ingress points: review API gateways and load balancers handling HTTP Basic Authentication strings or custom headers containing Base64 payloads.
2. Cross-Reference Workload Process Trees with CPU Topology
Execute an inventory check across your server fleet to correlate running Java versions with underlying processor capabilities:
# Verify whether the underlying CPU supports the vulnerable instruction set
grep -q 'avx512_vbmi' /proc/cpuinfo && echo "HARDWARE AT RISK: AVX-512 VBMI Detected" || echo "HARDWARE SAFE"
# Identify running Java processes across the host
ps aux | grep java
If the host CPU does not list avx512_vbmi, the process is immune to the heap corruption flaw. If the flag is present and the process runs Java 17.0.6–17.0.21, 21.0.0–21.0.13, or 25.0.0–25.0.5, the workload requires immediate remediation.
3. Implement the Interim JVM Flag
Where immediate patching of container fleets is impossible due to change-freeze windows or deployment complexity, apply the JVM runtime mitigation flag:
-XX:-UseBASE64Intrinsics
Inject this argument through container environment variables (e.g., JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics") and cycle the deployment pods.
Sustained Remediation Phase (Days 3–14)
Once temporary mitigations are active on external perimeters, attention turns to permanent software remediation across downstream assets.
1. Implement the Official Java4Shell Vulnerability Fix Across Base Images
Update central CI/CD base images to the patched releases (Oracle .1 builds, Corretto 17.0.21.1.2, or equivalent vendor builds). Trigger automated pipeline rebuilds for all internal application images, verifying that testing suites pass before releasing them into production.
2. Manage Third-Party Enterprise Software Vendors
Identify all third-party software that bundles an embedded Java runtime. Request formal advisories from vendors including Atlassian, JFrog, and Elastic regarding their timeline for shipping updated bundles containing the Java4Shell vulnerability fix. If vendor updates are delayed, determine whether the application's configuration files permit manually appending -XX:-UseBASE64Intrinsics to its internal JVM arguments.
3. Establish Runtime Process Verification
Do not rely exclusively on static file scans or software build tags to confirm that remediation succeeded. Use runtime inspection tools (e.g., eBPF sensors, dynamic instrumentation) to confirm the arguments and binaries running on active hardware:
# Inspect runtime parameters of a running Java process (replace <PID>)
jcmd <PID> VM.command_line | grep -E "UseBASE64Intrinsics|UseAVX"
Enterprise Vulnerability Remediation Lifecycle
┌─────────────────────────────────────────────────────────────────────────┐
│ Phase 1: Hours 0–48 (Triage & Containment) │
│ • Identify exposed perimeters (Keycloak, Jenkins, API Gateways) │
│ • Query hosts for 'avx512_vbmi' CPU support │
│ • Deploy '-XX:-UseBASE64Intrinsics' mitigation flag │
└────────────────────────────────────┬────────────────────────────────────┘
│
┌────────────────────────────────────▼────────────────────────────────────┐
│ Phase 2: Days 3–14 (Permanent Remediation) │
│ • Apply official Java4Shell vulnerability fix (.1 builds) │
│ • Rebuild central base container images │
│ • Update third-party vendor appliances (Jira, Artifactory) │
└────────────────────────────────────┬────────────────────────────────────┘
│
┌────────────────────────────────────▼────────────────────────────────────┐
│ Phase 3: Days 15+ (Long-Term Hardening) │
│ • Verify live running processes via runtime eBPF/jcmd auditing │
│ • Update SBOM tools to correlate CPU flags with package manifests │
│ • Audit internal high-performance intrinsics across codebases │
└─────────────────────────────────────────────────────────────────────────┘
Strategic Architectural Hardening (Long-Term)
Preventing future disruptions from similar flaws requires changes to runtime management and infrastructure strategy.
Decouple Parsing of Untrusted Input from Optimization Intrinsics
Architectural teams should isolate untrusted input parsing from critical backend systems. Where edge components parse user data (such as Base64 strings, JSON tokens, or TLS handshakes), terminate and validate these payloads within hardened, sandboxed gateway layers before passing sanitized, native objects to internal business logic.
Evolve SBOM Tools for Hardware Context
Security architecture groups must push software asset inventory vendors to include host-level hardware profiles in vulnerability databases. An SBOM should record not only that a service uses openjdk-21.0.12, but also record whether its environment exposes AVX-512, Intel AMX, or ARM Neon extensions. This hardware context is vital for accurately assessing exposure during critical incidents.
Looking Ahead: The Growing Scrutiny of JIT Intrinsics
The disclosure and rapid remediation of Java4Shell marks the beginning of deeper security assessments targeting managed language runtimes.
For years, vulnerability research focused heavily on high-level logic flaws: deserialization bugs, command injections, and broken access controls. As automated static analysis and memory-safe design patterns have reduced the frequency of these traditional bugs, researchers are increasingly examining the lower-level components of language runtimes.
The JIT compiler engines that power Java (HotSpot C2), JavaScript (V8, JavaScriptCore), Go, and .NET are complex environments containing thousands of lines of handwritten assembly designed to squeeze peak performance from modern CPUs. Because these intrinsics bypass language-level bounds checking, any flaw in their index calculations, vector masks, or register allocations can introduce native vulnerabilities into memory-safe environments.
Organizations should track several key developments over the coming weeks:
- Exploitation Telemetry: Threat intelligence monitors such as GreyNoise and watchTowr have begun observing initial exploit payloads scanning the internet. As fully weaponized exploits emerge from private security tools into open-source repositories, unpatched edge servers face automated scanning and exploitation campaigns.
- Downstream Packaging Delays: While Oracle and Amazon Corretto released their builds promptly, long-tail open-source distributions, Linux system packages, and enterprise software appliances may take weeks to issue patched versions.
- Broader Audits of Hardware Acceleration Code: OpenJDK contributors and independent researchers are auditing other AVX-512 and SIMD intrinsics across the JVM codebase. Functions handling SHA hashing, array searching, BigInteger arithmetic, and String operations are likely to face scrutiny for similar boundary-calculation errors.
The release of the Java4Shell vulnerability fix successfully closes a critical vector into enterprise servers. However, the incident highlights a broader lesson: as applications continue to rely on low-level hardware optimizations to maximize throughput, managing security requires understanding every layer of the stack—from high-level software abstractions down to the microscopic CPU silicon executing the code.
Reference:
- https://www.upwind.io/blog/java4shell-what-we-know-now-and-what-comes-next
- https://www.tenable.com/blog/java4shell-cve-2026-114938-frequently-asked-questions-about-openjdk-rce-vulnerability
- https://www.rapid7.com/blog/post/etr-cve-2026-114938-reported-critical-pre-authentication-remote-code-execution-java-17/
- https://www.securityweek.com/java4shell-vulnerability-puts-many-enterprise-applications-at-risk-of-takeover/
- https://threatdefence.com/article/java4shell-cve-2026-114938-openjdk-rce-patching-hunting
- https://www.cybersecuritydive.com/news/java-vulnerability-oracle-ai-java4shell/875029/
- https://blackpointcyber.com/blog/java4shell-cve-2026-114938-java-base64-decoder-flaw/
- https://calif.io/java4shell
- https://www.mycert.org.my/portal/advisory?id=MA-1510.112026
- https://www.aikido.dev/blog/java-17-rce-vulnerability-cve-2026-114938
- https://www.sophos.com/en-us/blog/java4shell-could-allow-remote-code-execution
- https://watchtowr.com/intelligence/java4shell-cve-2026-114938-faq/