Skip to main content

Eclipse OpenJ9 EUVDEUVD-2026-107134

| CVE-2026-111074 HIGH
Integer Overflow or Wraparound (CWE-190)
2026-10-21 eclipse GHSA-rr74-gf97-xpw7
8.7
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Locate exposed JITServer TCP port
  2. Exploit
    Open crafted connections with malicious 4-byte length
  3. Execution
    Trigger integer overflow infinite loop
  4. Impact
    Exhaust 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Eclipse OpenJ9 0.8.0 <0.63

Affected Packages

euvd eclipse_openj9 fix: 0.63

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

Vendor (eclipse) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 21, 2026 - 09:16 EUVD
CVE Published
Oct 21, 2026 - 07:57 cve.org
HIGH 8.7

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Low
JITServer is an optional, non-default OpenJ9 deployment mode, not broadly used
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy