Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted class file with overlapping handlers
-
ExploitApplication parses it via ASM with COMPUTE_MAXS/COMPUTE_FRAMES
-
ExecutionQuadratic Edge allocation in MethodWriter exhausts heap
-
ImpactOutOfMemoryError crashes JVM
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | Exploitation requires that the target application process an attacker-supplied class file through OW2 ASM (3.0 up to but not including 9.11) with the ClassWriter COMPUTE_MAXS or COMPUTE_FRAMES option enabled; the malicious class must contain thousands of overlapping exception handlers to trigger the quadratic Edge allocation in MethodWriter.computeMaxStackAndLocal()/computeAllFrames(). Limiting factors: the application must accept and analyze untrusted/attacker-controlled bytecode (UI:P - the app must load and process the crafted file), and must use the COMPUTE_MAXS/COMPUTE_FRAMES frame-computation modes; applications that only handle trusted class files or that do not enable these compute flags are not exposed. Authentication is not required (PR:N), and the vendor models the attack vector as Local (AV:L) rather than network-reachable. |
| Impact | Signals point to a genuine but bounded availability risk rather than a top-tier emergency. The vendor-supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, VA:H, confidentiality and integrity N) scores 6.8 (Medium) and describes a pure denial-of-service: no data disclosure or modification, only a JVM crash via OutOfMemoryError. CWE-407 (inefficient algorithmic complexity / quadratic blow-up) is consistent with the description. The attack is unauthenticated (PR:N) and low-complexity (AC:L), but exploitation is gated on passive user interaction (UI:P) - the target application must actually parse the attacker's crafted class file through ASM with COMPUTE_MAXS or COMPUTE_FRAMES enabled, and the vendor models the vector as Local (AV:L) rather than Network. No EPSS score was provided, so exploitation probability cannot be quantified. The issue is NOT in CISA KEV, so it is not confirmed as actively exploited; and although VulnCheck published an advisory, the input does not flag public exploit code, so no POC should be assumed. Net: treat as a Medium-severity, availability-only DoS that matters most for services that compile, transform, or load untrusted bytecode with ASM's compute flags - not a drop-everything critical. One tension to verify: the CVSS vector is Local (AV:L) while real deployments (e.g. upload-and-process pipelines) could make the crafted class remotely reachable, which would raise effective exposure - verify the delivery path in your own environment. |
| Exploit ScenarioDerived | An application uses OW2 ASM with COMPUTE_MAXS or COMPUTE_FRAMES to analyze or rewrite bytecode it accepts from users (for example a plugin loader, bytecode-processing service, or build tool). An attacker submits a crafted .class file containing thousands of overlapping exception handlers; when ASM's MethodWriter.computeMaxStackAndLocal()/computeAllFrames() builds its control-flow Edge graph, allocations grow quadratically and the JVM throws OutOfMemoryError, crashing the process. No public exploit code is identified in the provided data, though VulnCheck has published a technical advisory. |
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 through 9.10.x allows a crafted class file to exhaust JVM heap memory when an application analyzes untrusted bytecode with the ClassWriter COMPUTE_MAXS or COMPUTE_FRAMES option enabled. A malicious class containing thousands of overlapping exception handlers triggers quadratic Edge allocation inside MethodWriter.computeMaxStackAndLocal() and computeAllFrames(), producing an OutOfMemoryError that crashes the JVM. The vendor scores this CVSS 4.0 6.8 (AV:L, PR:N, UI:P) with high availability impact only, and no public exploit or confirmed in-the-wild exploitation has been identified; the attack is bounded by the requirement that the victim application load attacker-controlled bytecode through ASM's frame-computation path.
RemediationAI
Upgrade to OW2 ASM 9.11 or later, which contains the upstream fix delivered through merge request https://gitlab.ow2.org/asm/asm/-/merge_requests/461 and commit https://gitlab.ow2.org/asm/asm/-/commit/91057c98239d994aed5e46434e34e00d593c0daf; the fix targets the quadratic Edge allocation in MethodWriter.computeMaxStackAndLocal() and computeAllFrames(). Because ASM is typically a transitive dependency, identify and upgrade the embedding framework, agent, or tool rather than assuming a top-level version bump, and confirm the resolved asm artifact is 9.11+ in the dependency tree. If an upgrade cannot be scheduled immediately, the most effective compensating control is to stop feeding untrusted class files into ClassWriter with COMPUTE_MAXS or COMPUTE_FRAMES enabled - trade-off: disabling those flags removes automatic frame/max-stack computation and requires callers to supply valid frames themselves, which many scanners and instrumentation agents cannot do. Additional mitigations with their trade-offs include: validating or capping the number of exception-table entries and handler ranges in any class file accepted for analysis (rejects legitimate but unusually complex obfuscated bytecode); running the analysis step in a sandboxed worker JVM with a hard -Xmx heap cap and watchdog so a fatal OutOfMemoryError is contained rather than crashing the primary service (adds overhead and still requires restart of the worker); and restricting the analysis pipeline to trusted, pre-vetted bytecode where untrusted input is unavoidable (reduces functionality). No vendor-published workaround beyond upgrading is identified in the provided references.
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 is a widely embedded Java bytecode manipulation and analysis library used by frameworks, build tools, instrumentation agents, and bytecode scanners. The vulnerable code path lies in MethodWriter, the ClassWriter component responsible for recomputing stack map frames and max stack/local values when the COMPUTE_MAXS or COMPUTE_FRAMES flags are set. Per CWE-407 (Inefficient Algorithmic Complexity), the routines computeMaxStackAndLocal() and computeAllFrames() build an Edge graph whose size grows quadratically with the number of overlapping exception handler ranges declared in the class's exception table; a class file declaring thousands of overlapping handlers therefore causes allocation of a disproportionately large number of Edge objects. The cumulative allocation exceeds the JVM heap limit and raises OutOfMemoryError, terminating the process. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N) and the independent assessment (CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) agree that this is a purely availability-impacting, non-network, unauthenticated condition in which the application must actively process (UI:P/UI:R) the hostile class file. The problem is algorithmic rather than a memory-safety bug, so exploitation depends solely on the consuming application enabling one of the frame-computation modes and feeding it untrusted bytecode.
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
Local crafted-class input (AV:L), low complexity and no auth (AC:L/PR:N), but the app must load the file (UI:R); availability-only crash gives C:N/I:N/A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
OW2 ASM 3.0 before 9.11 contains a quadratic memory allocation vulnerability in MethodWriter.computeMaxStackAndLocal() and computeAllFrames() when using COMPUTE_MAXS or COMPUTE_FRAMES. Attackers can supply a crafted class file with thousands of overlapping exception handlers, causing excessive Edge allocations and an OutOfMemoryError 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 (prior to 9.11) allows an attacker to crash applications that t
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 c
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-101214
GHSA-f8m6-wmrx-8vh2
NVD
CVE.org
EPSS
Exploit-DB