Skip to main content

OW2 ASM EUVDEUVD-2026-101212

| CVE-2026-110258 MEDIUM
Memory Allocation with Excessive Size Value (CWE-789)
2026-10-14 VulnCheck GHSA-mx28-xgjx-vqcw
6.8
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft invalid class file with multiple RETs per JSR
  2. Delivery
    Deliver to application that parses bytecode via ASM
  3. Exploit
    Reach Label.addSubroutineRetSuccessors() without single-RET enforcement
  4. Execution
    Trigger ~2 GB memory allocation
  5. Impact
    Crash JVM / deny service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
Exploitation Conditions

Exploitation requires an application that uses OW2 ASM (versions 3.0 up to but not including 9.11) to parse an attacker-controlled or otherwise untrusted Java class file through the code path that reaches Label.addSubroutineRetSuccessors() - i.e. processing of legacy JSR/RET subroutine bytecode. The crafted file must contain a single JSR associated with multiple RET instructions, which the pre-9.11 code fails to reject. Limiting factors: impact is availability-only (a ~2 GB allocation that crashes the JVM - no code execution or data disclosure); the CVSS vector is local (AV:L) with required processing of the malicious input (UI:P), so the attacker needs a means to deliver the class file into ASM's parsing pipeline; environments that never process untrusted bytecode are effectively not exposed. There is no authentication requirement expressed in the 4.0 vector (PR:N), but the practical precondition is a feature or workflow that accepts externally-sourced class files.

Impact

This is a medium-severity denial-of-service issue (vendor CVSS 4.0 base 6.8), and the available signals paint a consistent, non-urgent picture rather than a conflicting one. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P) shows only availability impact (VA:H) with no confidentiality or integrity effect, confirming this is a JVM crash, not code execution or data exposure. No EPSS score, CISA KEV listing, or public POC was provided in the input, so there is no evidence of active or at-scale exploitation - status is 'no public exploit identified at time of analysis.' The limiting factor is the AV:L local vector plus UI:P (the vulnerable application must be made to parse an attacker-supplied class file), which sharply narrows real-world exposure: ASM itself is ubiquitous, but the exploitable path only exists where an application feeds untrusted/externally-sourced bytecode through ASM. Net: a real but low-to-medium priority for most environments, meaningfully higher for services that intentionally process untrusted class files (bytecode analyzers, class-upload features, plugin/agent loaders). Note the vector is AV:L despite the attack being 'supply a crafted file' - if your deployment accepts such files over the network, treat effective reachability as higher than the local vector implies and verify against the VulnCheck advisory.

Exploit ScenarioDerived

An application built on OW2 ASM (e.g. a bytecode analyzer, instrumentation agent, or a service that accepts user-uploaded Java class files) is passed a crafted, invalid class file containing a single JSR with multiple RET instructions. ASM's Label.addSubroutineRetSuccessors() fails to enforce the single-RET-per-JSR rule and attempts a roughly 2 GB allocation, exhausting heap and crashing the JVM, taking down the service. No public exploit code was identified in the provided data, and the local attack vector with required processing (UI:P) means the attacker must get the malicious class into the application's parsing path.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 14, 2026

Denial of service in OW2 ASM (versions 3.0 up to but not including 9.11) allows an attacker who can get a crafted Java class file into the library's bytecode parsing pipeline to trigger a roughly 2 GB heap allocation that crashes the JVM. The root cause is that Label.addSubroutineRetSuccessors() fails to enforce ASM's single-RET-per-JSR invariant, so a malformed class file containing multiple RET instructions for one JSR expands the successor set to an enormous size (CWE-789, excessive memory allocation). Impact is availability-only - no code execution or data disclosure - and exploitation requires an application that hands untrusted class files to ASM and reaches the legacy JSR/RET parsing path; the vendor CVSS 4.0 base score is 6.8 (AV:L, UI:P, PR:N), and the independent assessment rates it CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H, i.e. medium severity and availability-only. No public exploit identified at time of analysis, and there is no evidence of active exploitation.

RemediationAI

Vendor-released patch: upgrade OW2 ASM to 9.11 or later, the first release containing the fix; the fix is delivered through ASM merge request 458 (https://gitlab.ow2.org/asm/asm/-/merge_requests/458) and commit 4dabfe0aef14f8cccb0617640a4add8fbcc4ed36, with guidance in the VulnCheck advisory at https://www.vulncheck.com/advisories/ow2-asm-3.0-before-9.11-excessive-memory-allocation-via-multiple-ret-instructions and version history at https://asm.ow2.io/versions.html. If the dependency cannot be upgraded immediately, the most effective compensating control is to stop passing untrusted bytecode into ASM's JSR/RET parsing path: pre-scan incoming class files and reject any that contain legacy JSR/RET subroutine bytecode, since classes compiled for Java 6 and later use StackMapTable frames instead - the trade-off being that genuinely legacy classes will no longer be processed. As a secondary containment measure, run ASM-based parsing in a bounded JVM (for example a low -Xmx heap with supervised restart or health checks) so a runaway ~2 GB allocation fails fast instead of taking down a shared or production process; this limits blast radius but does not prevent the crash. Because no public exploit or active exploitation has been reported, remediation can follow a normal dependency patch cadence, with priority given to any service that parses externally supplied .class files.

Affected VersionsENISA

ASM 3.0 <9.11

Affected Packages

euvd asm fix: 9.11

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

OW2 ASM (ObjectWeb ASM) is a widely embedded Java bytecode manipulation and analysis framework used by JVM instrumentation agents, build tools, profilers, and application servers; the affected library is catalogued under CPE cpe:2.3:a:ow2:asm:*:*:*:*:*:*:*:*. The vulnerability class is CWE-789 (Memory Allocation with Excessive Size Value): Label.addSubroutineRetSuccessors() computes the successor labels used when ASM parses legacy JSR/RET subroutine bytecode - the pre-Java 6 subroutine construct that modern StackMapTable-based compilers no longer emit but that ASM still parses for backward compatibility. Because the pre-9.11 implementation did not enforce the single-RET-per-JSR rule, a hand-crafted invalid class file with one JSR associated with an unexpected number of RET instructions causes the successor expansion in that method to allocate roughly 2 GB, exhausting the heap and terminating the JVM. The vulnerable code path is publicly visible in the Label.java source at the ASM_9_10_1 tag (line 568), and the fix lands in ASM 9.11 via merge request 458 and commit 4dabfe0aef14f8cccb0617640a4add8fbcc4ed36. There is no privilege requirement in the module's 4.0 vector (PR:N), but the practical precondition is that the target application accepts externally-sourced or otherwise untrusted bytecode, which is why the assessed 3.1 vector is local with user interaction (AV:L/UI:R) rather than remotely triggerable without an input-delivery path.

Know when Asm 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 (VulnCheck) PRIMARY 6.8 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 5.5 MEDIUM

Attacker supplies a crafted class file the application must process (AV:L, UI:R), no privileges needed (PR:N), and the only impact is a JVM crash, so C:N/I:N/A:H with unchanged scope.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

OW2 ASM 3.0 before 9.11 contains an excessive memory allocation vulnerability in Label.addSubroutineRetSuccessors() that fails to enforce the single-RET-per-JSR rule. Attackers can supply a crafted invalid class file with multiple RET instructions for one JSR, triggering a roughly 2 GB allocation that crashes the JVM.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
foundational Java bytecode library, transitive dependency across much of the JVM ecosystem
Data Quality
4 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
High
Technical Impact
Partial

Priority Score

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

Attack Technique

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