Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain session cookie via single request
-
DeliverySend request with non-numeric v-uiId
-
ExploitparseInt throws, session lock leaked
-
ExecutionRepeat requests exhaust container thread pool
-
ImpactApplication unavailable (denial of service)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Proper locking
|
| Exploitation Conditions | Requires a target running Vaadin Framework 8 in the vulnerable range (com.vaadin:vaadin-server 8.16.0-8.32.1, or vaadin-server-mpr-jakarta 8.18.0-8.32.1) reachable over HTTP. The only prerequisite is a valid session cookie, which any unauthenticated client obtains from a single initial request; no login, privileges, or user interaction are needed. Exploitation is strictly limited to Framework 8 - Vaadin Framework 7 and Vaadin 10+/Flow are not affected because Flow releases the lock in a finally block and does not read v-uiId there. The practical limiting factor is therefore product version: only Vaadin 8 deployments in the stated range are at risk. |
| Impact | This is a network-reachable, unauthenticated denial-of-service flaw (CWE-667, improper lock release) in Vaadin Framework 8. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) with pure availability impact (VA:H, VC:N/VI:N/VA only) is internally consistent with the description: a single non-numeric v-uiId parameter leaks the session lock, and repetition exhausts the container thread pool. The 8.7 score is availability-only - there is no confidentiality or integrity exposure, so despite the 'High' rating this is strictly an uptime/resilience risk, not data compromise. No EPSS score, CISA KEV listing, or public POC is present in the input, so exploitation likelihood signals are absent; no public exploit identified at time of analysis. The low attack complexity and lack of authentication make weaponization trivial if an actor targets a known-vulnerable Vaadin 8 deployment, but real-world urgency is tempered by the framework's moderate footprint and the DoS-only (recoverable) impact. Note the input Tag 'Information Disclosure' directly contradicts the CVSS vector (VC:N) and the description - this is an availability/DoS issue, not disclosure; treat that tag as erroneous. |
| Exploit ScenarioDerived | An attacker makes one ordinary request to obtain a session cookie, then replays requests carrying that cookie with a non-numeric v-uiId value (e.g. v-uiId=abc). Each such request triggers an Integer.parseInt exception in VaadinService.requestEnd() while the session lock is held, permanently leaking the lock; the session then blocks forever and repeated requests tie up container threads until the thread pool is exhausted and the application stops serving. No authentication and no user interaction are required (AV:N/AC:L/PR:N/UI:N); no public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Unauthenticated remote denial of service in Vaadin Framework 8 (com.vaadin:vaadin-server 8.16.0 through 8.32.1, and vaadin-server-mpr-jakarta 8.18.0 through 8.32.1): a request carrying a non-numeric v-uiId parameter makes Integer.parseInt throw inside VaadinService.requestEnd() while the session lock is held, so the lock is never released and the serving thread returns to the pool still owning it. Every subsequent request for that session then blocks indefinitely in VaadinService.lockSession(), and repeating the request exhausts the container thread pool and takes the application down. Exploitation requires no credentials - a session cookie from a single initial request is sufficient - and no public exploit code or confirmed active exploitation was identified at time of analysis, though the flaw is trivially reachable over HTTP by any client.
RemediationAI
Vendor-released patch: upgrade to Vaadin Framework 8.32.2 or later (com.vaadin:vaadin-server >= 8.32.2 and com.vaadin:vaadin-server-mpr-jakarta >= 8.32.2), as documented in the advisory at https://vaadin.com/security/cve-2026-110803 and the release notes at https://vaadin.com/security/cve-2026-110803's fixing tag https://github.com/vaadin/framework/releases/tag/8.32.2. If the upgrade cannot be applied immediately, the most direct compensating control is a reverse-proxy or WAF rule that rejects requests whose v-uiId parameter is present but non-numeric, since legitimate Vaadin clients send a numeric UI identifier and the malformed value is the sole trigger; the trade-off is that the rule must be scoped to the Vaadin servlet path and tuned so it does not interfere with other query parameters or with static resource requests. Additionally, cap and monitor the container's request-processing thread pool and enable per-session/per-IP request rate limiting so that an attacker cannot drive the pool to exhaustion quickly, and be prepared to restart the affected node (or invalidate the wedged session) to clear leaked locks - restart is only a temporary recovery measure, not a fix, and the lock leak re-occurs on the next crafted request until 8.32.2 is deployed. Because exploitation needs only an anonymous session cookie, there is no authentication-based mitigation to rely on.
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
The root cause is CWE-667 (Improper Locking): Vaadin Framework 8's VaadinService.requestEnd() acquires the VaadinSession lock and then reads the v-uiId request parameter outside the block that releases the lock, so the release path is not protected by a finally clause. A client-supplied non-numeric v-uiId makes Integer.parseInt throw a NumberFormatException mid-method while the session lock is still held; the exception unwinds to the servlet container, which returns the worker thread to its pool with the VaadinSession lock still owned. Because the lock is a permanent, per-session monitor, any later request routed to that same session blocks forever in VaadinService.lockSession() - converting a single malformed parameter into a persistent, self-renewing thread-pool exhaustion condition (Availability:H, no confidentiality or integrity impact). Vaadin 10 and later are structurally immune because Flow releases the lock in a finally block and does not read v-uiId at that point, and Vaadin Framework 7 does not contain the behaviour at all. Affected artifacts are identified via CPE cpe:2.3:a:vaadin:framework and the Maven coordinates com.vaadin:vaadin-server and com.vaadin:vaadin-server-mpr-jakarta.
Know when Vaadin 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:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated HTTP request with a trivially obtained session cookie (AV:N/AC:L/PR:N/UI:N); impact is availability-only (A:H) with no confidentiality or integrity effect and no scope change.
Primary rating from Vendor (Vaadin).
CVSS VectorVendor: Vaadin
Lifecycle Timeline
2DescriptionCVE.org
VaadinService.requestEnd() in Vaadin Framework 8 locks the session and then reads the v-uiId request parameter outside the block that releases the lock. A request carrying a non-numeric v-uiId makes Integer.parseInt throw while the session lock is held, so the lock is never released and the container thread returns to its pool still owning it. Every later request to that session then blocks forever in VaadinService.lockSession(), and repeating the request exhausts the thread pool and takes the application down. No authentication is required: a session cookie, which any client obtains with a single request, is enough. Vaadin 10 and later are not affected, because Flow releases the lock in a finally block and does not read that parameter there, and Vaadin Framework 7 is not affected either.
Users of affected versions should apply the following mitigation or upgrade. Releases that have fixed this issue include:
Product version Vaadin Framework 8.16.0 - 8.32.1
Mitigation Upgrade to 8.32.2
Vaadin Framework 7 and Vaadin 10 and later do not carry this behaviour and need no upgrade for this issue.
Artifacts Maven coordinates / Vulnerable versions / Fixed version com.vaadin:vaadin-server / 8.16.0 - 8.32.1 / >=8.32.2 com.vaadin:vaadin-server-mpr-jakarta / 8.18.0 - 8.32.1 / >=8.32.2
Executive ViewAI
Vaadin Framework 8 (com.vaadin:vaadin-server 8.16.0 through 8.32.1 and vaadin-server-mpr-jakarta 8.18.0 through 8.32.1) contains a high-severity flaw that allows a remote party to take a Java web application fully offline by sending crafted HTTP requests that exhaust the server's request-handling threads, blocking all legitimate users of that service. No vendor patch exists yet, and no public exploit code or confirmed active exploitation was identified at time of analysis, but any application built on these versions and reachable from untrusted networks carries unplanned-downtime risk. Leadership should care because the outcome is complete service unavailability for every user of the affected application, not a limited or privileged capability.
No vendor-released patch identified at time of analysis; interim mitigations are to block or rate-limit requests containing a non-numeric v-uiId at the reverse proxy or WAF, cap per-client concurrency, restrict the affected application to trusted networks or put edge authentication in front of it, add server-side validation of v-uiId where code is owned in-house, monitor thread-pool saturation and requests blocked in session locking, and pre-plan restart or failover to recover an exhausted thread pool.
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
Missing output sanitization in test sources in org.webjars.bowergithub.vaadin:vaadin-menu-bar versions 1.0.0 through 1.2
Charts rendered by Vaadin Charts across Vaadin 22 through 25.3.0 bundle a pinned Highcharts release (9.2.2 in Vaadin 22-
Insecure temporary directory usage in frontend build functionality of com.vaadin:flow-server versions 2.0.9 through 2.5.
The default configuration of a TreeGrid component uses Object::toString as a key on the client-side and server communica
Unsafe validation RegEx in EmailValidator component in com.vaadin:vaadin-compatibility-server versions 8.0.0 through 8.1
Overly relaxed configuration of frontend resources server in Vaadin Designer versions 4.3.0 through 4.6.3 allows remote
Vulnerability in OSGi integration in com.vaadin:flow-server versions 1.2.0 through 2.4.7 (Vaadin 12.0.0 through 14.4.9),
Unsafe validation RegEx in EmailField component in com.vaadin:vaadin-text-field-flow versions 2.0.4 through 2.3.2 (Vaadi
Authentication.logout() helper in com.vaadin:flow-client versions 5.0.0 prior to 6.0.0 (Vaadin 18), and 6.0.0 through 6.
When adding non-visible components to the UI in server side, content is sent to the browser in Vaadin 10.0.0 through 10.
Deep-merge prototype pollution in Vaadin Charts and Vaadin Component Base lets remote, unauthenticated attackers write a
Authentication bypass in Vaadin framework (14.0.0-14.14.0, 23.0.0-23.6.x, and other ranges). The web application framewo
EUVD-2026-107492
NVD
CVE.org
EPSS
GitHub
Exploit-DB