Java4Shell: OpenJDK Base64 Vulnerability, JVM Memory Safety, and Secure Software Engineering
Technical examination of Java4Shell (CVE-2026-114938): the OpenJDK HotSpot Base64 decoder, JVM memory integrity, AVX-512 VBMI, JDK 25, GraalVM, exploitability, security patches, performance engineering, and digital forensics.
Abstract
Java4Shell (CVE-2026-114938) is an out-of-bounds memory write in the AVX-512 VBMI accelerated Base64 decoding path of the OpenJDK HotSpot virtual machine on x86-64 systems. A Java exception raised after malformed input is detected cannot undo memory corruption that has already occurred in native code. Depending on the process, heap layout, and application's exposed decoding paths, the defect may cause a crash, disclose process memory, or enable remote code execution. Public disclosure occurred on 17 November 2026, followed by coordinated advisories and security releases from Oracle, OpenJDK vendors, and national or institutional response teams. [2, 3, 5, 15, 19]
The significance of the vulnerability extends beyond Base64 validation. Understanding the failure requires examining the boundary between bytecode and machine code, just-in-time compilation, SIMD mask semantics, Java array invariants, garbage collection, attack-controlled input, and deployed runtime versions. Particular attention is given to JDK 25, GraalVM, and Native Image, where superficially similar Java deployments may have different exposure. Findings about JDK 25, GraalVM, JVM execution, and processor behavior are grounded in original vulnerability research, vendor advisories, the Java SE API specification, and published standards. Reported exploit outcomes and performance figures belong to their cited sources; they are not presented as independent experiments or measurements.
Keywords: Java4Shell, CVE-2026-114938, OpenJDK, HotSpot, JVM, Base64, AVX-512 VBMI, memory safety, JIT, C2, intrinsics, JDK 25, GraalVM, Native Image, remote code execution, digital forensics.
1. From PHP2Shell to Java4Shell: Runtime Trust Boundaries
The October 2026 disclosure of PHP2Shell exposed the security implications of memory ownership, exceptional control flow, and object lifetimes in the PHP runtime. The issues included incorrectly finalized partially initialized structures following out-of-memory failures and references to expired allocations retained in longer-lived state. The disclosure of Java4Shell on 17 November 2026 revealed a related architectural weakness in a very different location: the memory-safety properties of a managed language depend on the correctness of native machine code used by its runtime. [2, 5]
The two incidents are not manifestations of the same code defect. PHP2Shell concerns particular Zend Engine lifecycle and memory-state failures. Java4Shell concerns a processor-specific optimization in HotSpot's Base64 decoder. Their useful connection is the observation that sound application logic does not, by itself, establish the integrity of every lower layer responsible for executing that logic. That observation supports a comparison of engineering principles without collapsing distinct vulnerabilities into a generic narrative.
Ordinary Java compilation produces bytecode that is subsequently interpreted or compiled for execution by a JVM. The instructions ultimately executed depend on the runtime distribution, its update level, processor capabilities, compiler decisions, and runtime flags. Identical application artifacts can therefore use different native instruction sequences on different hosts. Functional equivalence at the bytecode boundary is not evidence of identical exposure at the machine-code boundary.
Java4Shell should not be confused with the interactive JShell tool or the Spring4Shell vulnerability disclosed in 2022. Its name reflects the demonstrated possibility of remote code execution. The flaw is not introduced by Spring Framework or a particular web container. Assessing it requires identifying the executing runtime, the relevant CPU features, and a data path that passes untrusted Base64 content to the affected implementation. [3, 18, 19]
2. Disclosure, Severity, and Standards of Evidence
Calif researchers disclosed CVE-2026-114938 after identifying a native memory-write defect in OpenJDK's Base64 decoding implementation. Oracle and OpenJDK coordinated security releases on 17 November 2026, while CERT-EU, Red Hat, Eclipse Adoptium, Microsoft, and other organizations issued subsequent guidance about affected builds and mitigations. Calif reported both the direct heap overwrite and application-specific exploit chains that progressed to memory disclosure or code execution. [2, 3, 6, 9, 13, 19]
A technical report must distinguish four kinds of evidence. The first is verification of a source-code or machine-code defect. The second is successful reproduction of memory corruption under defined conditions. The third is an application-specific laboratory demonstration of information disclosure or code execution. The fourth is verified compromise of a real target in operational conditions. Demonstrating the first three does not imply that the fourth has been observed. As of 19 November 2026, security reporting described attack-shaped requests and scanning activity, but those observations alone did not establish confirmed successful intrusions. [2, 21]
The reported CVSS values include 9.2 under CVSS 4.0 and 8.1 under Oracle's CVSS 3.1 assessment. Different scoring frameworks should not be interpreted as competing experimental probabilities. In an operational risk assessment, severity must be combined with the reachability of pre-authentication input, CPU support, the vulnerable runtime build, service privileges, asset importance, and the feasibility of deploying a verified fix. [2, 3, 15]
It would be incorrect to label every Java application equally exploitable. It would be equally misleading to dismiss the issue merely because a specific CPU extension is required. The vulnerability's demonstrated consequence must be evaluated separately from the prevalence of its prerequisites in a given infrastructure. The first is a technical property of the defect; the second is an asset-inventory and deployment question.
3. Java Memory Safety and the Native Execution Boundary
Java arrays have lengths, and array accesses are subject to bounds checks. Memory reclamation is normally handled by the runtime, while type verification and runtime checks constrain the operations that application bytecode can perform. These properties provide a strong memory-safety model for Java language code. They do not constitute an automatic proof that all C, C++, and assembly code inside the JVM correctly observes array boundaries. [11, 14]
A virtual machine implements far more than expression evaluation. It allocates objects, manages threads, generates and caches machine code, handles exceptions, loads classes, and performs garbage collection. To application code, a byte[] is a bounded array. To a native intrinsic, it is a region of memory with an address, layout, and available capacity. The essential interface contract between these views is that the intrinsic must never write outside the memory represented by its destination array.
Garbage collectors may reclaim unreachable allocations and move live objects according to the selected collection algorithm. Neither operation repairs a native out-of-bounds write. Corruption of an object header, array length, or neighboring allocation may become observable only during a later access or collection cycle. The resulting fatal error may occur on a thread that never called the decoder. This temporal distance between cause and symptom is one reason runtime memory-corruption cases require broader incident reconstruction than ordinary Java exception debugging.
Describing Java as a managed language establishes where responsibility for ordinary memory management resides; it does not mean that all implementation code is written in a memory-safe language. JNI, other native interoperability mechanisms, runtime stubs, and compiler-generated assembly can expose distinct risks. What makes Java4Shell notable is that its entry point is a common standard-library operation rather than an obviously unsafe third-party native extension.
Using Base64.getDecoder() is not inherently a misuse of the Java API. An application may be correct to decode externally supplied data and reject invalid input. The failure occurs when a particular runtime and processor combination does not preserve the API's memory-safety invariant along an optimized path. Application source review and runtime vulnerability management address different layers and must not be substituted for each other.
4. Base64, Padding Rules, and Java Decoder Contracts
Base64 maps three bytes of binary data to four textual symbols. RFC 4648 defines the basic encoding alphabet and the rules under which the final group is padded. The = symbol expresses the absence of remaining data bytes within a final encoding group; it is not a self-contained data character that can legitimately form a group on its own. A string containing only familiar Base64 characters can therefore still be malformed. [8]
Java SE 25 provides basic, URL-safe, and MIME variants through java.util.Base64. getDecoder() applies to the basic alphabet, getUrlDecoder() to its URL-safe counterpart, and getMimeDecoder() to MIME-oriented data. These variants do not necessarily share identical input acceptance rules or internal execution paths. Datadog's examination of OpenJDK 17.0.6 found that the basic and URL-safe decoders could use the vulnerable AVX-512 path, whereas the MIME decoder did not use that path in the tested configuration. This observation should not be generalized to every release without verification. [5, 14]
4.1. Decoder API contracts and destination bounds
decode(byte[]) creates a destination array, while decode(byte[], byte[]) uses a caller-provided destination. Both interfaces require sufficient destination capacity. The Java API documentation explicitly allows partial changes to a supplied destination when invalid input causes IllegalArgumentException. This permission concerns bytes within that destination; it does not authorize a native routine to write beyond the array boundary. A valid contract can permit partial output and still require complete memory integrity in every failure path. [14]
Base64 is not an encryption or authentication scheme. A JWT transports its header and claims in Base64URL form, but decoding those components does not establish their authenticity. Likewise, the Base64 representation used by HTTP Basic authentication protects neither credentials nor transport confidentiality. The distinction matters to this vulnerability because an application may need to decode attacker-provided material before it has established the sender's identity or verified a token signature.
Correct decoding requires a coherent relationship among alphabet validity, input length, final-group padding, expected output length, and the destination buffer's bounds. Rejecting malformed input after a partial decode is acceptable only if all intermediate writes remain within the authorized region. Java4Shell violates this latter requirement in the affected native implementation.
5. HotSpot, Tiered Compilation, and Intrinsic Substitution
HotSpot uses runtime observations such as invocation frequency, loop behavior, and type profiles to decide where compilation is worthwhile. A method can initially execute in interpreted form and later be compiled by C1 or by the more aggressively optimizing C2 compiler. Consequently, the native instruction sequence used by a long-running server is not necessarily the one exercised during a short startup smoke test. Warm-up behavior matters for both performance analysis and vulnerability reproduction.
An intrinsic substitutes a specialized implementation for an operation that would otherwise follow more general Java code. Such substitutions may exploit vector instructions or other processor facilities to reduce instruction count. They are correct only when they preserve the Java-level contract: return values, exceptions, permitted side effects, and the boundaries of every memory access. A faster implementation is not a semantically correct implementation merely because it produces the right bytes for ordinary inputs.
5.1. Base64 intrinsic selection and native code generation
HotSpot contains an x86-64 Base64 decoding path that can use AVX-512 VBMI on suitable processors. Selecting that path requires more than compiling the application with a particular JDK. Runtime availability, CPU capabilities, active JVM flags, and the specific decoder path determine whether the relevant native code can execute. [2, 5, 19]
Compilation and intrinsic selection are related but distinct decisions. Repeated calls may make a method eligible for optimized compilation, but they do not establish that a particular CPU extension exists or that every possible input takes the same vectorized branch. Input size, tail length, decoder variant, and build-specific implementation details can affect control flow.
Running an entire service with JIT compilation broadly disabled should not be treated as a normal security fix. Such changes can substantially alter CPU demand, latency, and total service capacity. For Java4Shell, a targeted Base64 intrinsic disablement is available as an interim mitigation, and patched vendor builds are the durable remedy. A controlled security response should change the smallest relevant execution surface while preserving operational stability.
6. AVX-512 VBMI and Masked Vector Stores
Single Instruction, Multiple Data (SIMD) processing applies one operation to many data elements. AVX-512 extends the vector capabilities available on supported x86-64 processors and includes masked loads and stores. VBMI adds facilities useful for byte-level rearrangements, which are relevant to converting groups of encoded Base64 characters into decoded binary bytes.
Vectorization is not inherently unsafe. The dangerous condition arises when the number of valid result bytes is confused with the width of the vector that happens to contain them. A complete block and the final incomplete fragment have different write requirements. Masked stores use bits in a mask register to select the bytes that will actually reach memory. If that mask does not reflect the destination's remaining valid capacity, an instruction can write more data than the Java array permits.
6.1. Masked stores and instruction semantics
The affected implementation involves the masked store semantics of VMOVDQU8 and bit-selection behavior associated with BZHI. A bit count derived from a negative length is not a meaningful 'write zero bytes' request. In the relevant 64-bit operation, a count greater than the register width can preserve all mask bits, permitting a full-width store where only a few output bytes or none should have been written. [2, 5]
The published hardware prerequisites include avx512f, avx512bw, avx512vbmi, and bmi2. Their availability is determined by the processor and the execution environment, not simply by the label printed on the chassis. A hypervisor may expose a subset of host CPU features to a guest. Container deployments inherit the effective CPU facilities of the system on which they execute. A reliable exposure assessment therefore examines the capabilities visible to the running JVM. [3, 19]
Native ARM64 runtimes cannot execute this particular x86-64 AVX-512 implementation and are not affected by the documented code path. This is a finding about a specific mechanism, not a blanket statement that ARM64 Java deployments are free from other vulnerabilities. Hardware-specific analysis must preserve that distinction.
7. Root Cause: A Malformed Tail Becomes an Out-of-Bounds Write
The central defect in Java4Shell is a mismatch between the number of legitimate decoded bytes and the mask governing the native store for a final Base64 fragment. After the routine processes complete encoding groups, an invalid trailing padding arrangement can remain. The higher-level Java decoder ultimately rejects that arrangement, but the native path can perform a memory operation before preserving the invariant that the final fragment must correspond to a valid, nonnegative output length. [2, 5]
For a normal Base64 group, four encoded characters represent three decoded bytes. Padding reduces the result count in the final group, provided that the group and padding placement are valid. A final fragment that is too short to represent a complete group must not pass through arithmetic that first produces zero bytes and then subtracts additional padding without checking for underflow. When the resulting negative value is interpreted as a bit count for mask generation, a semantic error in length calculation can become a much larger memory-write error.
7.1. The divergence between output size and store mask
The implementation contains two relevant calculations. Java code determines the size of the destination array, while an optimized native routine determines how many bytes to write from each processed block. Their treatment of the same input must remain consistent. Even when the input is invalid and no successful decoded result should be returned, neither path is permitted to write outside the destination. Throwing an exception does not provide an automatic rollback mechanism for native stores already performed.
The original research describes a particular invalid 65-character input for which a 50-byte result array is allocated. Processing the initial complete segment produces 48 decoded bytes. The erroneous tail-mask calculation then allows a 64-byte store starting at destination offset 48, extending 62 bytes past the allocated array. The numbers characterize a demonstrated code path, not a claim that all malformed inputs generate the same overflow size. [2, 4, 5]
A useful way to express the required invariant is that the number of bytes written must be nonnegative and must not exceed the remaining destination capacity. The CPU does not know that the target address belongs to a bounded Java array; it executes an instruction using the address and mask supplied by the runtime. Therefore, validating native optimizations requires checking equivalence of memory access sets, not merely equality of decoded output for valid input.
This flaw fits the class of out-of-bounds writes identified by CWE-787. Incorrect output-buffer sizing also provides a relevant secondary classification under CWE-131. [10] The generic label 'buffer overflow' is accurate but does not adequately explain the mechanism. The consequential step is the conversion of a malformed tail's negative length into a full-width masked vector write, which violates the allocated array boundary. [11]
8. Heap Integrity, Array Metadata, and Object Layout
Java arrays present a simple interface to application code: an element type, a length, and indexed access. The HotSpot representation necessarily includes runtime metadata such as object headers and array length fields. Their byte-level layout is implementation dependent and can vary with runtime versions, object alignment, compressed-reference configuration, and object kind. Analyses that assume one universal object-header layout risk deriving conclusions that do not apply to the target process.
A write beyond an array may reach a neighboring object, unused allocation space, or memory that will later be incorporated into another object. The immediate symptom depends on which region is modified. Corruption of free or not-yet-observed memory may remain invisible for a period. Modification of an adjacent array's length metadata can create an inconsistency between the memory physically allocated and the bounds accepted by subsequent Java accesses. Damage to other critical metadata may cause crashes during allocation, class operations, or garbage collection.
8.1. Array metadata and neighboring heap objects
The fact that an overflow occurs within the Java heap does not make it safe. Garbage collectors interpret object boundaries and references using runtime metadata. If that metadata is inconsistent, a later collection may encounter an apparently unrelated failure. The first visible fatal error can therefore appear on a background thread, long after the request that reached the vulnerable decoder.
Calif reported turning a constrained initial overwrite into application-specific memory disclosure and more powerful memory modification. That result required manipulating allocation behavior and arranging for corruption to affect useful neighboring metadata. It should not be paraphrased as an immediate, arbitrary write primitive available at any address in every Java process. The practical chain depends on the target application's object lifetimes, available input and output routes, and execution environment. [2, 4]
When corrupted length metadata makes an array appear larger, the system has not safely resized the underlying allocation. The reported logical length and the actual reserved memory no longer agree. Subsequent operations may trust that invalid metadata and cross another boundary. Distinguishing metadata manipulation from legitimate memory allocation is essential to understanding how a limited overwrite can eventually support disclosure.
An exception log is insufficient as a sole incident indicator. The decoder may throw IllegalArgumentException, while the process continues until some other component touches corrupted memory. Heap corruption, garbage collection failure, and request parsing failure occupy different points along one possible causal timeline; none should be equated without supporting evidence.
9. Consequences: Availability, Confidentiality, and Code Execution
The possible security consequences belong to distinct classes. The most immediate is an availability failure: the JVM may terminate, produce a fatal error, or enter a state in which continued execution is unsafe. A second class is confidentiality loss when memory that should remain within the process becomes observable through an application response or other channel. A third is integrity compromise, which in suitably exploitable cases can progress to executing attacker-controlled code. [2, 11]
Information disclosure requires more than the existence of overwritten memory. An attacker needs a way to influence a relevant region and to obtain bytes through some response, serialization path, exception behavior, or feedback mechanism. Remote code execution requires additional steps that convert corruption into a useful application action or control-flow change. Thus, a serious CVSS rating does not imply that every exposed instance can be compromised by one universal request.
9.1. Pre-authentication exploitation demonstrations
Calif listed application-specific pre-authentication demonstrations involving Keycloak, Atlassian Jira and Confluence, Jenkins, JFrog Artifactory, and PingFederate. Its research also described authenticated demonstrations involving Apache Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker. These findings are reports about tested configurations and exploit paths; they are not evidence that every historical release or every deployment topology of those products is equivalently vulnerable. Vendor statements and runtime conditions still matter. [2]
The privileges of the hosting JVM process determine the scope of a successful compromise. A service running under a dedicated low-privilege identity with restricted filesystem access and carefully constrained network egress has a different impact profile from a broadly privileged process that holds credentials for other systems. Process separation, secret management, restricted service accounts, and network boundaries remain valuable safeguards even when they cannot remove the underlying decoder flaw.
Potentially sensitive process memory can include session tokens, service credentials, intermediate cryptographic material, user information, and connection settings. Listing these classes does not mean Java4Shell automatically retrieves all of them. A claim of actual disclosure requires evidence of memory access, the nature of the contents, and a path by which those contents left the trust boundary.
Reducing the entire vulnerability to the label 'RCE' can obscure earlier or independently significant effects, such as denial of service and exposure of secrets. Each consequence has different observable artifacts and a different evidentiary threshold. A responsible incident report separates demonstrated impact, plausible impact, and observed operational events.
10. JIT Warm-up and Reproducibility Across Execution States
The execution path taken by a Base64 call can change during a process's lifetime. HotSpot collects profiles and may compile methods only after sufficient execution. A startup smoke test might exercise a general path, while the same application later uses optimized machine code after a period of normal traffic. This is a property of adaptive compilation, not evidence that the vulnerability requires an unusually configured program.
Security must not depend on the affected intrinsic remaining cold. Authentication endpoints, token parsers, and message consumers may invoke decoding frequently enough for the optimized path to become active. Conversely, frequent decoding alone does not prove that the specific vulnerable operation is reached. Runtime version, processor capability, decoder variant, and malformed data still have to align.
A reproducible regression matrix should include the relevant execution modes and hardware capabilities. Checking successful decoding of ordinary strings is insufficient. Invalid padding, truncated final groups, short tails after complete blocks, output buffer boundaries, and differing input lengths test different decoder invariants. An optimized native path may remain untested unless a test explicitly runs under conditions that permit that optimization to execute.
Each diagnostic configuration should answer a specific question. Does a symptom disappear when the Base64 intrinsic is disabled? Does an AVX-512 limit change the relevant code path? Does the patched build preserve bounds with the same invalid input? Does a different decoder variant take a different implementation path? These are questions for controlled validation, not a recommendation to run a heap-corrupting trigger on production services.
Reproducibility also has a forensic dimension. Two nodes behind the same load balancer may handle identical HTTP traffic differently because they run different processor generations, JDK builds, or startup configurations. A request that fails harmlessly on one node does not prove the same request would be harmless on another. Routing decisions and the identity of the actual target process must be reconstructed before interpreting the observed outcome.
11. Allocation, TLABs, Garbage Collection, and Concurrency
The Java heap is not simply a fixed sequence of objects. Multi-threaded allocation and garbage collection introduce complexity into the placement and lifetime of objects. HotSpot may use Thread-Local Allocation Buffers (TLABs) to reduce coordination costs for many ordinary allocations. The space available within a TLAB and the timing of object creation can affect which region lies next to a vulnerable destination array. These facilities are performance mechanisms, not isolation guarantees between neighboring allocations.
Collectors such as G1 manage objects in regions and may relocate live data. Large allocations, temporary arrays, application bursts, and background allocation activity can alter the heap layout. Such variability may reduce the reliability of a tailored exploitation chain, but it does not make corrupted memory valid. Switching collectors or adjusting heap size is therefore not an acceptable substitute for applying the JDK security fix.
11.1. Concurrency and variability in heap placement
Any exploit strategy that depends on proximity between allocated objects is sensitive to timing and concurrent activity. Worker count, allocation rate, network pacing, request scheduling, and collection intervals can change observed placement. This does not mean that Java4Shell is fundamentally a data race. Rather, it means an existing native memory-safety defect has consequences that may depend on concurrent heap activity.
The Java API specifies that Base64.Decoder instances are safe for concurrent use. That guarantee is distinct from the safety of the affected intrinsic implementation. A decoder can be thread-safe in its Java object-level contract while still encountering an out-of-bounds native write on a particular JVM. Concurrency correctness, allocation safety, and memory bounds are related but separate engineering properties. [14]
In a high-throughput server, average request rate alone is insufficient to describe behavior. Burst patterns, input-size distribution, compiler warm-up, temporary allocation rates, and worker scheduling influence both exposure paths and the cost of mitigations. Results from a narrow microbenchmark should not be extrapolated to tail latency or aggregate system throughput without a representative workload.
Examining this vulnerability requires moving coherently between Java arrays, runtime allocation, thread scheduling, and machine-level masked stores. Each abstraction has its own contract. The failure arose where those contracts were not preserved across a lower-level optimization boundary.
12. Attack Surface: Authentication, Message Parsing, and Java Clients
The useful question in a Java4Shell exposure assessment is not whether an application is written in Java. It is whether a value controlled by an untrusted party can reach the affected Base64 decoder in an unpatched JVM. That value may appear in an HTTP header, serialized message, upload field, federation protocol, or response received from another system. These data carriers are not interchangeable: each must be traced through the actual parser and decoding library used by the deployment.
HTTP Basic authentication is a straightforward example of Base64 decoding that may take place before authentication succeeds. If an upstream reverse proxy fully processes the Authorization header and forwards only validated identity information, the backend may not decode the original field. If the proxy forwards the header and the application security filter decodes it before checking credentials, the externally supplied content may reach the JVM before a user has been authenticated. Pre-authentication reachability is a consequence of this processing order, not a universal property of all HTTP services.
12.1. JWT, Base64URL, and validation ordering
JWT processing raises a comparable ordering question. The JWT header and claims use Base64URL representation, and a parser typically must interpret encoded fields as part of verifying the token. The signature or other verification mechanism establishes trust, not the encoding itself. Appropriate size checks and syntactic validation reduce parser exposure, but they do not repair the affected native decoder. SAML and other identity federation protocols may also use Base64 representations, although the actual Java library and data path must be examined before concluding that a given service reaches this intrinsic.
File uploads form another category. A JSON property carrying binary data in Base64 form, an XML element, or an application-defined message format may trigger the standard Java decoder. By contrast, ordinary multipart/form-data transport does not inherently require every uploaded file to be Base64 decoded. A security inventory that labels all upload handlers as affected without following their decoding paths will generate false positives and can misdirect remediation work.
Client-side exposure matters as well. Calif described a scenario involving a Java program that processes data received after connecting to a malicious TLS endpoint. The relevant principle is that a JVM client can cross a trust boundary when it decodes data from a server it does not control. It would be incorrect to conclude that every TLS connection, or the TLS protocol itself, necessarily exercises the vulnerable Base64 path. The application, provider, and data-processing code determine whether the path exists. [2]
A defensible attack-surface map starts with input origin, follows parsing and conversion, identifies the exact Base64 API and decoder variant, and then resolves the executing JVM and CPU characteristics. An endpoint inventory or source-level search for Base64 is a useful starting point, not a complete proof of exploitability. Reachability should be recorded as confirmed, unconfirmed, or excluded by specific evidence.
13. Affected Java Releases, CPU Families, and JVM Implementations
The known defect concerns specific HotSpot x86-64 Base64 intrinsic implementations. The relevant code was introduced into the standard OpenJDK 17 update line beginning with 17.0.6. For the 21, 25, and 27 release lines, affected builds preceding the November 2026 fixes require remediation. Intermediate non-LTS releases must be evaluated through their vendor's implementation and support policy rather than assigned an unsupported universal status. Unsupported releases also create a broader maintenance problem even when this particular defect is not reachable. [2, 3, 19]
Oracle listed security-fix levels of 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. Eclipse Adoptium identified fixed Temurin builds 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2, and 27.0.1.1+4. Microsoft published its own updated OpenJDK 17, 21, and 25 builds. A version string from one vendor cannot always be compared mechanically with the package revision used by another. Vendor security notices, signed packages, and effective runtime identities are the appropriate records. [6, 9, 15]
13.1. Release exceptions and distribution-specific status
Standard OpenJDK 8 and 11 do not contain the vulnerable intrinsic and are not affected by this specific code path. However, Oracle Java 8 Performance Pack builds are a documented exception that must be checked separately. It is therefore wrong to state that every Java 8 deployment is vulnerable or that all Java 8 deployments have no security exposure. Absence of this one defect does not establish the broader security status or support lifecycle of the runtime. [3, 19]
Processor families with relevant implementations include suitable Intel Xeon Ice Lake and later generations, and certain AMD Zen 4 and later processors. Family names alone do not prove that all required instructions are visible to a guest operating system. Processor model, BIOS policy, hypervisor configuration, and virtual CPU exposure can differ. The published prerequisites include avx512f, avx512bw, avx512vbmi, and bmi2; the existence of a reachable decoding operation remains an independent condition.
Apache Kafka's security notice dated 19 November 2026 makes the runtime boundary particularly explicit: Kafka brokers, controllers, Connect workers, Streams applications, and clients may all require JDK remediation, while Kafka source code does not require a Java4Shell-specific change. Its apache/kafka-native artifacts do not execute the affected HotSpot intrinsic. Upgrading Kafka itself and patching the JVM that runs it are separate operations. [1]
Quarkus security guidance identifies IBM Semeru's OpenJ9 runtime as outside the affected HotSpot intrinsic path. The distinction highlights why 'Java implementation' and 'HotSpot implementation' should not be used as synonyms. GraalVM requires a similar classification, with its HotSpot-based JVM execution separated from Native Image executables. [18]
A useful runtime asset record therefore includes the Java vendor, complete build number, VM implementation, operating system package, bundled-runtime path, effective CPU flags, startup options, and patch date. Merely recording 'Java 25' in an inventory provides too little evidence to determine this vulnerability's reachability.
14. JDK 25 Production Deployments: Runtime Identity and Image Provenance
In Spring Boot services and other Java 25 applications, this vulnerability exists below the application framework. A JAR compiled against one Java release may execute under a different supported runtime, subject to compatibility constraints. Compiler settings such as --release, sourceCompatibility, and targetCompatibility describe compilation targets; they do not identify the exact HotSpot build used to process incoming data. The executing runtime, not merely the build-time JDK, is the security boundary under examination.
Container deployment introduces a separate provenance problem. A floating tag in a FROM instruction can resolve to a newer base image during a future build, but an existing application image remains composed of the layers used when it was created. Updating a registry tag does not patch a running container. The base image must be retrieved, the application image rebuilt, published, and redeployed. Environments using immutable digests must approve a new digest and prevent accidental rollback to the old vulnerable digest.
14.1. Verifying the actual JVM and deployment identity
The runtime selected by a service manager may differ from the java binary found in an administrator's interactive shell. Applications can bundle their own JRE, use a custom runtime image, inherit JAVA_HOME from the service environment, or launch through a container entrypoint that changes the effective configuration. Therefore, checking Java on the CI host or administration workstation is not evidence that the production process has been updated.
For running services, runtime version and effective flags should be established through process-aware inspection, where permissions and platform support allow it. A container host may run several versions concurrently during rolling deployment. The Scala community also emphasizes that the affected component is the JVM, so applications written in other languages targeting that JVM may share the same runtime exposure. [20] Even if the new replicas are patched, the remaining old replicas still form a potential attack surface. Inventory should capture actual runtime image digests and the period during which each revision was serving traffic.
For latency-sensitive systems, emergency runtime patching must be coordinated with regression and availability requirements. Testing should include application startup, garbage collector behavior, TLS interoperability, cryptographic providers, connection pools, and critical processing paths. These checks support a controlled rollout; they should not become an indefinite justification for leaving an internet-facing vulnerable runtime in service. Capacity-aware rolling replacements can reduce disruption if remaining unpatched instances are explicitly tracked.
A scanner's absence of a CVE alert is not a sufficient final check. Backported vendor fixes, delayed scanner feeds, bundled runtimes, and unavailable CPU information can all affect automated findings. Stronger assurance comes from correlating signed vendor packages, deployment provenance, effective process versions, and the relevant runtime feature settings.
15. GraalVM: HotSpot Execution, Native Image, and Build-Time Trust
GraalVM encompasses more than one execution model. A Java application can execute as bytecode on a JVM supplied by a GraalVM distribution, or it can be compiled ahead of time into a standalone native executable using Native Image. The existence of Java code in both arrangements does not mean that both execute the same HotSpot-specific intrinsic. For Java4Shell, the key classification is the actual runtime used in production.
Oracle GraalVM 25.0.5.1 was released on 17 November 2026 and updated its underlying Oracle JDK to build 25.0.5.1+4. GraalVM deployments executing Java code on a vulnerable HotSpot-derived JVM can be affected under the same hardware and input conditions. Their security state must be checked against the exact GraalVM and underlying JDK build, rather than inferred solely from the GraalVM product name. Older GraalVM 17 and 21 lines require their own vendor-specific assessment. [15, 16]
15.1. Native Image executables versus the builder JVM
Native Image combines compiled application code with runtime facilities and state determined during the image build. The resulting executable does not execute inside the HotSpot JIT and does not invoke the vulnerable HotSpot Base64 intrinsic. Quarkus guidance accordingly classifies affected Java4Shell HotSpot runtimes separately from Native Image output, which is not affected by this particular mechanism. This does not establish that every Native Image binary is immune to native memory vulnerabilities in general. [17, 18]
The builder has a separate trust boundary. The native-image generation process runs on a JVM, and the build can execute selected application initialization code. Build-time dependencies, plugins, and inputs may therefore interact with an affected JVM even when the resulting binary does not contain the vulnerable intrinsic. Updating build images matters for build-host security, reproducibility, and supply-chain integrity. It must not be described as evidence that a completed Native Image executable necessarily carries Java4Shell.
Quarkus reported interim mitigations in Mandrel and GraalVM CE builder images using JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics where an affected amd64 JDK was bundled. Its guidance also notes that overriding JAVA_TOOL_OPTIONS can remove the protection, and that floating builder tags must be re-pulled while pinned tags need updating. The relevant controls are properties of the builder environment, not proof of vulnerability in the native artifact. [18]
The GraalVM Native Image security guide also points out that state generated by build-time class initialization may be captured in the image heap. Sensitive data used during initialization can therefore become an artifact-security concern independent of Java4Shell. Dedicated build environments, minimal exposure of secrets, and deliberate run-time initialization choices are relevant supply-chain safeguards. [7]
Ahead-of-time compilation introduces different performance and operational trade-offs: startup time, memory footprint, closed-world assumptions, dynamic class loading limits, debugging, and compilation effort. Those differences may matter to system architecture, but none provides a general equation between Native Image and 'higher security' or 'higher throughput'. The narrow finding here is that the documented HotSpot intrinsic is absent from the corresponding native runtime path.
A deployment assessment should record whether the application runs through java -jar, executes as a Native Image binary, or uses another VM implementation. The builder's Java version, runtime image, CPU features, and vendor patch status should then be documented independently. This separation is particularly important for organizations producing both JVM and native artifacts from the same codebase.
16. Patching, Interim Mitigations, and Effective-Process Verification
The preferred permanent remedy is a Java runtime build that includes the vendor's fix for CVE-2026-114938. Oracle's November 2026 fixes include the 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1 release levels, with corresponding fixed builds supplied by Temurin, Microsoft, and other OpenJDK distributions. Applying one vendor's full build label to all other distributors would be incorrect. The authoritative comparison is between the installed artifact and the security advisory of its actual provider. [3, 6, 9, 15]
When immediate replacement is not possible, -XX:-UseBASE64Intrinsics is a focused mitigation that disables the vulnerable optimized Base64 route. On appropriate x86-64 deployments, -XX:UseAVX=2 can prevent AVX-512 use more broadly. The latter may affect unrelated vectorized operations and therefore has a larger potential performance footprint. It must not be placed unconditionally into ARM64 startup settings, because a JVM that does not recognize the option may fail to launch. [2, 5, 18]
16.1. Verifying effective JVM options
Configuration intent must be distinguished from effective configuration. A JVM flag in a repository file is not evidence that a running process received the flag. Startup scripts, systemd service units, container entrypoints, JAVA_TOOL_OPTIONS, and platform-specific options all need to be considered. A restart is required for startup changes to take effect. During staggered rollout, some replicas may be patched while others depend on interim mitigation; both states should be tracked accurately.
The following commands collect local version, effective-flag, and CPU information without sending a memory-corrupting input:
java -version
java -XX:+PrintFlagsFinal -version 2>&1 | grep -E 'UseBASE64Intrinsics|UseAVX'
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
jcmd <PID> VM.version
jcmd <PID> VM.flags -all | grep -E 'UseBASE64Intrinsics|UseAVX'Replace <PID> with the actual process identifier. Availability of jcmd depends on the JDK distribution and process access permissions. The reported Linux CPU flags indicate processor capabilities exposed to the runtime environment, but they do not by themselves establish that a reachable application decoder uses the intrinsic. These commands support exposure assessment; they are not a working exploit test.
Web application firewalls, input size caps, and early rejection of malformed padding can reduce certain routes. They cannot be assumed to cover WebSockets, message queues, RPC channels, Java client connections, or application-specific parsing beyond the firewall. In some implementations, validation by the application occurs only after the JDK decoder has already processed the data. Consequently, WAF signatures and input filtering are supplementary safeguards rather than replacements for patched runtimes. [4]
17. Throughput, Tail Latency, and Operational Resilience
Disabling the Base64 intrinsic may increase CPU work for workloads that decode significant amounts of data. The end-to-end effect depends on the decoder's share of total processing time. In a request dominated by database access, network waits, or storage operations, decoder cost may be a small fraction of latency. In a pipeline continuously decoding large binary payloads transported as text, the cost may be substantial. Neither 'no performance impact' nor 'severe performance loss' is credible without workload-specific measurement.
A useful evaluation identifies decoding operations per second, input-size distribution, CPU occupancy, allocation rates, mean latency, tail latency, and wait time in other processing stages. If representative testing is possible, the secure fallback and optimized implementation should be compared under the same hardware, JVM version, and load conditions, with the relevant flag as the controlled variable. Performance data from different JDK builds or different hardware must not be attributed entirely to a single Base64 setting.
Total request latency is the combined effect of parsing, business processing, I/O, queueing, and scheduling. A CPU speedup in one routine does not translate linearly into p99 latency improvement. Collector pauses, lock contention, connection pool saturation, and external service variability can dominate the observed tail. Microbenchmark results therefore require context before they are used for capacity planning.
A safe rolling deployment should preserve sufficient healthy replicas and monitor service continuity. However, rolling back to an older, still-vulnerable JDK cannot be treated as a routine performance recovery decision without acknowledging the resulting security exposure. A temporary throughput reduction can often be managed through additional capacity, batching choices, or traffic controls while a fully patched and validated runtime is deployed.
Process isolation limits the consequences of failure. A single large JVM hosting multiple critical workloads may experience a broader service impact when memory corruption causes a crash. Separate process identities, minimum privileges, restricted egress, and well-defined restart policies can contain some downstream effects. They do not eliminate the vulnerability or guarantee that information already accessible to a compromised process remains confidential.
Performance optimization and memory safety are not mutually exclusive design goals. A correct fast native decoder is both possible and necessary. Interim reductions in speed are an operational property of choosing a safer route before patch deployment. The durable engineering objective remains a verified high-performance implementation that preserves all bounds and failure semantics.
18. Security Testing, Fuzzing, and Regression Design
Native decoders require a broader test strategy than confirming that normal inputs produce the expected bytes. Invalid padding, incomplete final groups, boundaries between block sizes, empty data, illegal alphabet characters, very large inputs, and insufficient destination capacity stress different invariants. Java4Shell demonstrates that consistency between the final fragment's computed output length and the store mask must be treated as a distinct test obligation.
Fuzzing can systematically vary those boundary conditions, but a fuzzer observing only return values and exception classes may miss a native overwrite. Suitable isolated tests can combine memory-integrity sentinels, guarded destinations, and instrumentation that observes native memory accesses. The objective is to verify that even rejected inputs cannot cause writes outside the specified destination. Tests capable of corrupting heap memory must not be executed against production JVMs.
18.1. Differential testing and regression matrices
Differential testing compares equivalent semantic cases across optimized and nonoptimized paths: Base64 intrinsics enabled or disabled, different CPU capability sets, pre-fix and fixed builds, and applicable decoder variants. Successful output equivalence is only one check. Rejection semantics, destination bounds, behavior on malformed tails, and safe continuation after failure are equally important. A different internal path for the MIME decoder in a tested build can assist controlled comparison; switching decoder profile solely to avoid the vulnerability is not a proper mitigation. [5, 14]
Exception timing is particularly important. An implementation that rejects malformed data at the end is still incorrect if it has already written outside an allocated array. Both successful and unsuccessful method exits must satisfy memory-safety invariants. Partial output permitted by the API is constrained to legitimate target memory. Native code cannot defer safety until the Java layer raises the expected exception.
A practical vulnerability-management program does not need to reproduce arbitrary code execution on every server. Vendor patch verification, process version discovery, CPU capability inspection, effective JVM flags, and reachability analysis can establish a defensible remediation priority without deliberately corrupting memory. Where reproduction is justified, it belongs in authorized, isolated, restorable environments with no production data. Results should record exact runtime builds, processor flags, garbage collector settings, test inputs, and execution modes.
A negative fuzzing result means no violation was found within the tested state space, not that every native path is correct. The tested JVM may not have warmed its compiler, the virtual CPU may lack the relevant extension, or the test data may never reach the final-fragment branch. Security-testing claims must remain bounded by observed coverage.
19. Logs, Anomaly Detection, and Interpretation of Weak Signals
There is no guarantee that Java4Shell produces one distinctive application exception in every affected environment. An upstream validator may reject malformed Base64 with HTTP 400 or 401 before it reaches Java. Another request may trigger native corruption, then produce an exception, crash, restart, or no immediately recognizable symptom. None of those observations is, by itself, proof that CVE-2026-114938 was successfully exploited.
A useful timeline links reverse proxy routing, application parsing, JVM process state, and host-level events. The edge layer may show when a request arrived, which backend handled it, and how the connection ended. Application records may capture authentication failures or decoder exceptions. JVM diagnostic artifacts may identify fatal errors or process identity. Operating system records may show abnormal termination and restart. Load-balancer retries can distribute apparently related events across multiple processes, so correlation identifiers and routing metadata are valuable.
hs_err_pid*.log files may be produced by HotSpot when it encounters a fatal error. Their presence is relevant, but the vulnerability does not guarantee that every corruption event will produce such a file. The crash may occur later in a garbage collector, object allocation, or unrelated-looking runtime routine. A SIGSEGV, GC failure, or decoder exception can also result from causes unrelated to Java4Shell. The diagnostic context and affected runtime conditions must be examined before assigning a cause.
WAF and intrusion-detection signatures for unusual Base64 tails offer potentially useful signals. Since Base64 is a common transport encoding, invalid padding may also result from ordinary client defects or corrupted network messages. A rule that inspects only HTTP headers may miss application-level values in JSON, WebSocket frames, message queues, or client responses. The absence of one signature match is not evidence of complete protection. [4]
Reports published on 19 November 2026 described probing and attack-shaped requests observed by security organizations. Such observations establish that suspicious activity was being seen, not that a particular protected system suffered memory disclosure or code execution. A vendor's telemetry count must not be projected onto an unrelated organization without evidence of equivalent traffic, sensor coverage, or targeting. [21]
Security logging should avoid creating a second disclosure channel. Recording entire Authorization headers, credentials, bearer tokens, or decoded secret material can expose information independently of the vulnerability. When appropriate, a system can preserve request correlation identifiers, safe length metadata, parsing outcome, and error class instead. Missing evidence should be reported as missing rather than reconstructed from assumptions.
20. Digital Forensics: Evidence Integrity and Competing Hypotheses
A Java4Shell investigation begins by determining whether the process ran under the relevant affected conditions. It then reconstructs suspicious behavior and evaluates observed outcomes. A vulnerable JDK on a compatible CPU is evidence of exposure, not evidence of successful exploitation. A malformed Base64 request is evidence of a particular input, not necessarily proof that the intrinsic processed it or that memory corruption occurred.
Potential evidence includes the exact Java distribution and build, the running process's startup configuration, operating-system and virtual CPU capabilities, container digests, process restarts, edge request logs, application errors, crash artifacts, and network flow records. Deployment logs are important when patched and unpatched replicas coexisted during a rolling update. Timezone differences and clock synchronization must be documented before request and crash timestamps are connected causally.
20.1. Incident response and evidence reliability
NIST SP 800-61 Revision 3 connects incident response to organizational cybersecurity risk management. Evidence collection, containment, and recovery should be governed by documented authority and explicit operational impact, rather than by an ad hoc sequence of tools. [12]
Collecting live process memory may produce sensitive data and affect availability. A heap or process dump can contain bearer tokens, passwords, cryptographic key material, personal information, and internal connection details. Collection authority, purpose, timing, scope, access control, and retention therefore need to be established in advance. The need for volatile evidence must be balanced against the disruption that a collection tool could cause in a critical service. Full-memory acquisition is not automatically justified as the first investigative step.
At least four hypotheses should be considered separately: malicious or malformed input reached an exposed service; that input reached the vulnerable decoder; an out-of-bounds native write occurred; and the corruption led to information extraction or execution of unauthorized code. Each hypothesis requires different evidence. A reverse proxy record may support the first. A JVM crash may be consistent with the second or third but is not conclusive. Neither observation automatically proves the fourth.
Immediate process replacement can destroy volatile evidence, while leaving a vulnerable process running may preserve a live attack surface. Incident response must weigh the criticality of the service, available containment measures, current indicators, and the ability to capture evidence safely. Changes in process identity, container digest, filesystem state, and log retention must be documented so later analysis distinguishes pre-remediation events from actions taken by responders.
Information present in process memory has not necessarily been transmitted to an attacker. A suspicious outbound connection does not, by itself, establish the content or volume of a data transfer. Likewise, large legitimate maintenance or backup operations should not be mislabeled as exfiltration without additional evidence. Findings should distinguish what was directly observed, what can be inferred from verified facts, and what was merely reported by a system operator or third party.
21. Secure Software Engineering and the Correctness of Optimization
Java4Shell demonstrates why performance optimizations must be judged by more than successful results on ordinary inputs. An optimized operation must preserve the reference implementation's outputs, error behavior, authorized side effects, and memory access boundaries. Error handling and exceptional control flow deserve the same rigor as the fast path. Without that discipline, the optimization may appear correct during functional testing while violating the runtime's safety guarantees.
Native decoding routines benefit from explicit invariants: source length, valid remainder size, padding placement, destination offset, destination capacity, allowed store width, and mask population count must remain mutually consistent. Invalid intermediate states, including negative output lengths, should be rejected or handled before they are converted into bit operations that can appear to authorize a large write. Boundary assertions must cover the actual machine-level memory operation, not merely the value returned to Java.
If an API allows partial output before invalid input is rejected, that permission still confines writes to the documented destination region. This is an instance of a broader engineering rule: failure paths must preserve the invariants on which later processing depends. Exception handling does not excuse an unsafe intermediate mutation, and normal functional correctness does not compensate for invalid native memory effects.
Hardware-specific optimization requires hardware-specific tests. A CI system limited to inexpensive virtual machines may never expose AVX-512 VBMI and therefore never execute a specialized path. Regression suites should compare processor-accelerated code with a portable reference implementation under valid, invalid, and boundary inputs. Virtualization and CPU feature masking should be documented when test coverage is reported.
Software supply-chain controls also belong in this discussion. A signed application JAR does not ensure that its container base image has a patched JVM. Application dependency inventories, JDK vendor builds, container image digests, and operating-system package revisions should be correlated. Vulnerability management must distinguish a source-level library dependency from a runtime implementation dependency that may change independently of application code.
AI-assisted security analysis can help researchers explore large codebases, propose unusual boundary inputs, and investigate cross-layer control flow. Calif disclosed using AI during discovery and exploitation research. Tool output, however, is not verification. A defensible finding still requires comparison with real source code, actual CPU behavior, exact runtime builds, and repeatable observations. The speed of generating hypotheses should not be confused with the validity of the resulting evidence. [2]
The design disciplines developed in Secure Software Engineering and Runtime Optimization in Java Systems converge in this case. A trust boundary is not a property that can be delegated once and then forgotten; it must hold across the entire chain that transforms untrusted bytes into machine-level operations.
22. Systems-Engineering Findings and Conclusion
The immediate technical cause of Java4Shell is a malformed Base64 tail that can produce an invalid output-length value and an excessive masked vector store. Rejecting the input afterward does not restore the violated destination boundary. Once a HotSpot native routine can corrupt memory beyond a Java array, the ordinary language-level protections of Java are not sufficient to contain the resulting failure. [2, 5, 11]
Exposure is a conjunction of conditions rather than a property of a framework name. The process must use a relevant vulnerable HotSpot build, the effective CPU must provide the necessary instruction support, the affected intrinsic must be enabled, and attacker-controlled input must reach the pertinent decoder. The possible consequence then depends on the application's memory allocation behavior, feedback channels, process privileges, and deployment topology. Treating these variables as interchangeable leads either to unwarranted confidence or to overstated risk.
For JDK 25 production workloads, the immediate priority is to establish which runtime builds actually execute the services, deploy vendor fixes, and verify the resulting state at the process level. GraalVM on HotSpot and GraalVM Native Image are different exposure categories, with builder environments forming an additional security boundary. If a temporary intrinsic disablement is required, its performance cost should be assessed under representative traffic and it should not become a reason to postpone a permanent patch indefinitely.
A forensic report must distinguish vulnerable configuration, attempted exploitation, actual memory corruption, information disclosure, and code execution. Each conclusion has a different evidentiary threshold. Because a native overwrite may become visible only after subsequent JVM operations, reconstructing a coherent request, process, JVM, and operating-system timeline is often essential. Missing logs do not prove that an incident occurred, and they do not prove that one did not occur.
The broader engineering conclusion is that hardware acceleration cannot be allowed to weaken a programming language's correctness contract. Java memory safety depends on the safety of the native operations used to implement Java semantics. Secure systems treat optimized execution, rejection of malformed input, integrity after failure, verifiable runtime updates, and controlled deployment as parts of one continuous trust model.
References
[1] Apache Kafka. Mitigating CVE-2026-114938 ("Java4Shell") in Apache Kafka Deployments, 19 November 2026.
[2] Calif. Java4Shell: Write Once, RCE Everywhere, 17 November 2026.
[3] CERT-EU. High Severity Vulnerability in Java SE and OpenJDK, Security Advisory 2026-021, 18 November 2026.
[4] Cloudflare. How Cloudflare WAF Helps Protect Against Java4Shell (CVE-2026-114938), 18 November 2026.
[5] Datadog Security Labs. Java4Shell: Remote Code Execution in OpenJDK (CVE-2026-114938), 17 November 2026.
[6] Eclipse Adoptium. Eclipse Temurin Guidance for CVE-2026-114938, 18 November 2026.
[7] GraalVM. Security Considerations in Native Image.
[8] Josefsson, S. RFC 4648: The Base16, Base32, and Base64 Data Encodings, IETF, 2006.
[9] Microsoft. Java OpenJDK November 2026 Critical Patch Update, 18 November 2026.
[10] MITRE. CWE-131: Incorrect Calculation of Buffer Size.
[11] MITRE. CWE-787: Out-of-bounds Write.
[12] NIST. SP 800-61 Rev. 3: Incident Response Recommendations and Considerations for Cybersecurity Risk Management, 2025, DOI: 10.6028/NIST.SP.800-61r3.
[13] OpenJDK Vulnerability Group. OpenJDK Security Advisory — 17 November 2026, 17 November 2026.
[14] Oracle. Java SE 25 API: Base64.Decoder.
[15] Oracle. Critical Security Patch Update Advisory — November 2026, 17 November 2026.
[16] Oracle. GraalVM for JDK 25 Release Notes, 17 November 2026 security release.
[17] Oracle. Native Image Basics.
[18] Quarkus. Java4Shell (CVE-2026-114938): Status and Mitigation for Quarkus Users, 18 November 2026.
[19] Red Hat. RHSB-2026-018: Remote Code Execution via Memory Corruption on x86-64 Systems — OpenJDK, 17–19 November 2026.
[20] Scala Programming Language. Security Advisory: Update Your JDK (CVE-2026-114938, "Java4Shell"), 18 November 2026.
[21] SecurityWeek. Java4Shell Exploitation Attempts Begin as Vendors Rush Out Advisories, 19 November 2026.