Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocate exposed JITServer TCP port
-
ExploitOpen crafted connections with malicious 4-byte length
-
ExecutionTrigger integer overflow infinite loop
-
ImpactExhaust worker thread pool halting compilation
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the target to be running in OpenJ9 JITServer mode (remote compilation server) with its TCP listening socket reachable by the attacker; this is an optional, non-default architecture rather than standard in-process JIT, which is the primary limiting factor. Given AV:N/AC:L/PR:N/UI:N, once the port is reachable there is no authentication, user interaction, or special timing required - any remote attacker can send the malformed 4-byte length prefix. Impact is confined to denial of compilation service (availability) for connected client JVMs; it does not grant data access or code execution. Vulnerable versions are those prior to 0.63.0. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a network-reachable, low-complexity, pre-authentication flaw, and the vendor-assigned base score of 8.7 (High) is driven entirely by availability impact (VA:H) with no confidentiality or integrity impact (VC:N/VI:N) - consistent with a pure denial-of-service condition rather than code execution. This is a genuine, easy-to-trigger DoS against any exposed JITServer, but its real-world priority is bounded by two factors not reflected in the raw score: no EPSS probability, CISA KEV entry, or public exploit was provided in the input, so there is 'no public exploit identified at time of analysis' and no evidence of active exploitation; and the impact is limited to loss of compilation service availability, not host compromise. Crucially, exploitation requires the optional JITServer architecture to be deployed and its TCP port reachable by the attacker - a non-default, specialized configuration - so the effective attack surface is far narrower than AV:N alone implies. A fix is confirmed to exist (PR #25008 adds a 1 GB message-size sanity check), which supports patch-based remediation. Net: a legitimate high-severity availability bug for organizations running JITServer, but not a mass-exploitation emergency absent any exploitation signal. |
| Exploit ScenarioDerived | An unauthenticated attacker who can reach the JITServer's TCP listening port opens a small number of connections, each sending a crafted 4-byte length prefix that triggers an integer overflow in MessageBuffer::computeRequiredCapacity(), driving the handling compilation worker thread into a ~100% CPU infinite loop. With only a few such connections the attacker exhausts the entire worker thread pool, silently stopping remote JIT compilation for all connected client JVMs. No public exploit code was identified in the provided data, but the low attack complexity and absence of authentication make weaponization straightforward. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Remote denial of service in Eclipse OpenJ9 JITServer before 0.63.0 lets unauthenticated network attackers exhaust compilation worker threads by sending crafted TCP connections with a malicious 4-byte length prefix. The integer overflow in MessageBuffer::computeRequiredCapacity() drives a worker thread into an infinite loop at roughly 100% CPU, so a small number of connections can silently stop compilation services for all connected client JVMs. The vendor base score of 8.7 reflects availability-only impact; no public exploit was identified at time of analysis.
RemediationAI
Upgrade to Eclipse OpenJ9 0.63.0 or later, which includes the upstream fix in PR 25008 that rejects oversized advertised message lengths before capacity computation. If upgrading is not immediately possible, disable JITServer mode or remove network reachability to the JITServer TCP listener by binding it only to trusted interfaces and restricting access with firewall or network ACL rules to known client JVMs; these controls prevent remote exploitation but break or limit remote compilation for legitimate distributed clients, and disabling JITServer forfeits its compilation-offload benefits. Monitor JITServer hosts for worker-thread CPU saturation and connection floods as a compensating detection measure. Vendor advisory: https://gitlab.eclipse.org/security/vulnerability-reports/-/work_items/940; upstream fix: https://github.com/eclipse-openj9/openj9/pull/25008.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Eclipse OpenJ9 JITServer is an optional remote-compilation architecture in which client JVMs send compilation requests to a separate server process over TCP. The initial 4-byte length field on each connection is used to size the incoming message; CWE-190 integer overflow in MessageBuffer::computeRequiredCapacity() causes the worker thread handling that connection to loop indefinitely while consuming CPU. The upstream fix in PR 25008 adds a safety check in CommunicationStream::readMessage() that rejects advertised message sizes larger than 1 GB with a StreamFailure, preventing the malformed length from reaching capacity computation. The CPE cpe:2.3:a:eclipse_foundation:eclipse_openj9:*:*:*:*:*:*:*:* covers OpenJ9 releases before 0.63.0; standard in-process JIT deployments are not exposed because they do not run the JITServer TCP listener.
Know when Eclipse Openj9 gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Pre-auth network-reachable trigger with no user interaction gives AV:N/AC:L/PR:N/UI:N; pure DoS yields C:N/I:N/A:H with no scope change.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
Lifecycle Timeline
2DescriptionCVE.org
In Eclipse OpenJ9 versions prior to 0.63.0, the JITServer component is vulnerable to a pre-authentication remote denial of service. When processing the initial 4-byte length field of an incoming TCP connection, an integer overflow in MessageBuffer::computeRequiredCapacity() causes the receiving compilation worker thread to enter an infinite loop consuming ~100% CPU. An unauthenticated remote attacker can exploit this by opening a small number of crafted TCP connections to exhaust the entire worker thread pool, silently halting compilation services for all connected client JVMs.
Executive ViewAI
Eclipse OpenJ9 JITServer deployments earlier than 0.63.0 are exposed to a remote availability attack that can silently halt compilation services for all connected client JVMs, potentially disrupting Java application performance and dependent business services. Leadership should prioritize inventory and network isolation of affected JITServer instances because no vendor-released patch was identified at time of analysis and no public exploit was identified at time of analysis.
No vendor-released patch identified at time of analysis. Interim mitigations include restricting network access to JITServer TCP ports to trusted client JVM subnets via firewall or ACL, disabling JITServer where not required, segmenting affected instances, applying connection rate limiting, monitoring CPU and worker-thread exhaustion, and upgrading to Eclipse OpenJ9 0.63.0 or later once vendor availability is confirmed.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Eclipse Openj9
View allDenial of service in Eclipse OpenJ9 through 0.63.0 affects deployments that enable the optional JITServer mode, where un
Denial of service in Eclipse OpenJ9's optional JITServer component (versions prior to 0.63.0) allows an unauthenticated
Remote unauthenticated attackers can crash Eclipse OpenJ9 JITServer instances (versions 0.21-0.58) by sending a speciall
Eclipse OpenJ9 through 0.63 can expose local files to a remote receiver when an analyst opens a crafted diagnostic dump
Eclipse OpenJ9 JVM versions through 0.60 crash with a segmentation fault when processing a crafted .class file containin
EUVD-2026-107134
GHSA-rr74-gf97-xpw7
NVD
CVE.org
EPSS
Exploit-DB