Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft invalid class file with multiple RETs per JSR
-
DeliveryDeliver to application that parses bytecode via ASM
-
ExploitReach Label.addSubroutineRetSuccessors() without single-RET enforcement
-
ExecutionTrigger ~2 GB memory allocation
-
ImpactCrash 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Excessive resource consumption in OW2 ASM versions 1.4.3 through 9.10.x allows an unauthenticated local attacker to trig
Denial of service in OW2 ASM versions 3.0 up to but not including 9.11 allows a crafted legacy class file with nested JS
Uncontrolled recursion in OW2 ASM's SignatureReader.parseType() lets an attacker crash any application that reads or tra
CPU exhaustion in the OW2 ASM Java bytecode library (versions 3.0 through 9.10.x) lets attackers who can supply crafted
Denial of service in OW2 ASM versions 3.0 through 9.10.x allows a crafted class file to exhaust JVM heap memory when an
Denial of service in OW2 ASM versions 3.0 through 9.10.x (prior to 9.11) allows an attacker to crash applications that t
Denial of service in OW2 ASM 5.0 through 9.10.x allows an attacker who can supply a crafted Java class file to trigger e
Excessive memory allocation in the asm-commons AdviceAdapter of OW2 ASM (versions 3.1 through 9.10.x, fixed in 9.11) let
EUVD-2026-101212
GHSA-mx28-xgjx-vqcw
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB