Skip to main content

Eclipse OpenJ9 EUVDEUVD-2026-107138

| CVE-2026-111075 HIGH
Integer Underflow (CWE-191)
2026-10-21 eclipse GHSA-9wq7-cgfv-cwx8
8.7
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Reach exposed JITServer endpoint
  2. Exploit
    Send malformed DataDescriptor message
  3. Execution
    Trigger unsigned integer underflow and OOB heap read
  4. Impact
    Crash JITServer process (SIGSEGV, DoS)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer underflow checks
Exploitation Conditions

Requires that the Eclipse OpenJ9 JITServer component (the remote distributed-JIT compilation server) is deployed, running, and network-reachable by the attacker - this is an optional performance feature, not a default JVM configuration, which is the primary limiting factor. When JITServer is exposed, no authentication or user interaction is needed (CVSS PR:N/UI:N): the attacker simply sends one crafted DataDescriptor message with inconsistent _size, _paddingSize, and _dataOffset values that pre-patch code (before 0.63.0) fails to cross-validate. Impact is limited to a process crash (availability only); there is no confidentiality or integrity effect, and exposure is further constrained wherever the JITServer port is restricted to trusted internal networks.

Impact

Signals are consistent but point to a narrower real-world risk than the headline 8.7 suggests. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms unauthenticated, low-complexity, remote reachability, but the impact set is availability-only (VC:N/VI:N/VA:H) - this is a pure denial-of-service crash (SIGSEGV), not code execution or data exposure, which is corroborated by the description, CWE-191 (integer underflow), and the fix PR adding bounds/validation checks. No EPSS score was provided in the input, so exploitation-probability cannot be quantified. KEV status is not present (no active exploitation claimed), and no proof-of-concept exploit is referenced - the only linked code is the vendor fix (PR #25009), not an attack tool. No SSVC decision record was supplied. The dominant risk-limiting factor is deployment scope: the flaw lives in the JITServer component, an opt-in distributed-JIT feature that must be running and network-reachable; it is not active in a default OpenJ9/JVM configuration. Net assessment: a credible, easy-to-trigger DoS for the subset of environments that actually run JITServer, but not a widespread or high-urgency issue absent that specific deployment.

Exploit ScenarioDerived

An attacker with network reach to an exposed JITServer listener sends a single crafted DataDescriptor message whose _size, _paddingSize, and _dataOffset fields are inconsistent. During deserialization, getPayloadSize()/getNextDescriptor() compute an unsigned integer underflow, producing an out-of-bounds heap read that immediately crashes the server process, taking down JIT compilation services for all connected clients. No public exploit code is identified at time of analysis; the only referenced code is the vendor patch.

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

Denial of service in Eclipse OpenJ9's optional JITServer component (versions prior to 0.63.0) allows an unauthenticated remote attacker to crash the server process by sending a crafted DataDescriptor message. The flaw is an unsigned integer underflow caused by missing cross-field validation of _size, _paddingSize, and _dataOffset, leading to an out-of-bounds heap read and SIGSEGV. Exploitation requires JITServer to be enabled and network-reachable; no public exploit code or CISA KEV entry was identified at time of analysis, and the assessed impact is availability-only (CVSS 3.1 base 7.5), narrower than the headline CVSS 4.0 score of 8.7 suggests.

RemediationAI

Upgrade Eclipse OpenJ9 to 0.63.0 or later, which contains the vendor fix (upstream PR https://github.com/eclipse-openj9/openj9/pull/25009) adding cross-field DataDescriptor validation and message-size limits. If upgrading immediately is not possible, disable JITServer when remote compilation is not required - accepting the loss of distributed-JIT performance benefits - or restrict the JITServer port with firewall rules and network segmentation so only trusted JVM clients can reach it, noting that this may break legitimate remote compilation. Monitor JITServer processes for unexpected SIGSEGV crashes. Advisory references: https://gitlab.eclipse.org/security/vulnerability-reports/-/work_items/941 and https://gitlab.eclipse.org/security/cve-assignment/-/work_items/423.

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's JITServer is a remote distributed-JIT compilation service that serializes compiler requests between a JVM client and a JITServer process over a network socket. Message deserialization uses DataDescriptor structures with _size, _paddingSize, and _dataOffset fields; pre-0.63.0 code did not validate these fields against each other, so a crafted descriptor can make DataDescriptor::getPayloadSize() and getNextDescriptor() perform unsigned integer arithmetic that underflows (CWE-191). The resulting out-of-bounds heap read triggers a SIGSEGV and terminates the JITServer process. The CPE identifies Eclipse OpenJ9 releases before 0.63.0; the upstream PR adds checks that _paddingSize is at most 3, _dataOffset is 0 or 4, padding plus offset does not exceed _size, message sizes are capped at 1 GB, data-point counts at 256, and descriptors stay within message bounds.

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

Unauthenticated single-message trigger over the network with no user interaction gives AV:N/AC:L/PR:N/UI:N; impact is a crash only, so C:N/I:N/A:H.

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 - 08:00 cve.org
HIGH 8.7

DescriptionCVE.org

In Eclipse OpenJ9 versions prior to 0.63.0, the JITServer component fails to perform cross-field validation on attacker-controlled _size, _paddingSize, and _dataOffset fields during DataDescriptor message deserialization. An unauthenticated remote attacker can send a crafted network payload that triggers an unsigned integer underflow in DataDescriptor::getPayloadSize() and DataDescriptor::getNextDescriptor(). This results in an out-of-bounds heap read and an immediate process crash (SIGSEGV), causing a denial of service.

Executive ViewAI

Why It Matters

Eclipse OpenJ9's optional JITServer component can be crashed remotely by a crafted message, causing availability loss for services that rely on an exposed JITServer instance. Leadership should care because affected Java workloads may experience service disruption, but exposure is limited to environments that have enabled and network-exposed this optional component; no public exploit was identified at time of analysis.

Business Impact: Medium
Compensating Controls

Disable the optional JITServer component where not required; restrict JITServer network reachability to trusted hosts via firewall, segmentation, or allowlisting; monitor for server process crashes and abnormal DataDescriptor messages; validate availability of Eclipse OpenJ9 0.63.0 or later with the vendor before upgrade. No vendor-released patch identified at time of analysis.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Medium
Alternative JVM in IBM/containerized Java; vulnerable JITServer component is opt-in
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
Medium

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.

Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.

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