Skip to main content

OW2 ASM CVE-2026-110260

| EUVDEUVD-2026-101214 MEDIUM
Inefficient Algorithmic Complexity (CWE-407)
2026-10-14 VulnCheck GHSA-f8m6-wmrx-8vh2
6.8
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted class file with overlapping handlers
  2. Exploit
    Application parses it via ASM with COMPUTE_MAXS/COMPUTE_FRAMES
  3. Execution
    Quadratic Edge allocation in MethodWriter exhausts heap
  4. Impact
    OutOfMemoryError 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.

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

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

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

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.

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

EPSS Score
0.2%
Top 94% exploitable
Prevalence
High
OW2 ASM is a near-ubiquitous Java bytecode library and transitive dependency
Data Quality
3 sources
Confidence: Low

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· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
High

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