Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure victim to attacker-controlled page
-
DeliverySet window.name with single-quote payload
-
ExploitRedirect same tab into vulnerable Wicket page
-
ExecutionPayload persisted in server-side page store
-
ImpactScript executes in application origin on render
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the target application has explicitly added org.apache.wicket.ajax.AjaxNewWindowNotifyingBehavior to a component; the Wicket framework never installs this behaviour itself, so applications that do not use it are entirely unaffected - this non-default requirement is the primary limiting factor. The attacker must cause the browser's window.name (delivered to the server as the windowName request parameter) to contain a single quote that terminates the single-quoted JavaScript literal, which Wicket then writes into the page as raw script; window.name is client-supplied and receives no validation or escaping. The CVSS vector is PR:N (unauthenticated) but UI:P/AT:P, so success also depends on victim interaction - the victim loading/opening the vulnerable page instance (typically across a window/tab) under attacker-influenced window.name - rather than a fully automated remote hit. Note the behaviour's self-generated name, used when the browser reports no name, is a random UUID and is not attacker-controllable. |
| Impact | This is a genuine but conditional stored cross-site scripting flaw (CWE-79) whose real-world priority is moderate rather than urgent. The CVSS 4.0 vector (CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:N, score 7.6) describes an unauthenticated network-reachable issue with high confidentiality and integrity impact in the application origin, but it carries both AT:P (a specific attack requirement) and UI:P (passive user interaction), which materially lower automatability and mass-exploitability. The vuln.today decision label is 'this_week', consistent with a serious-but-not-emergency issue. No EPSS score, no CISA KEV listing, and no POC reference are present in the input, so there is no signal of active exploitation or published exploit code; exploitation status is therefore 'no public exploit identified at time of analysis'. The dominant mitigating factor is not in the CVSS score at all: the advisory states an application is affected ONLY if it has explicitly added org.apache.wicket.ajax.AjaxNewWindowNotifyingBehavior to a component - no part of the framework installs it - so the exploitable population is a narrow subset of Wicket deployments. Net: a real, well-described vulnerability worth patching on a normal priority cadence, not a high-CVSS-but-illusory issue, yet far from a drop-everything emergency given the non-default prerequisite and absence of exploitation signals. |
| Exploit ScenarioDerived | An attacker lures a user to a page they control, sets the browser's window.name to a payload containing a single quote (e.g. breaking out of the JavaScript string literal), then navigates the same tab to a Wicket application that uses AjaxNewWindowNotifyingBehavior. The behaviour reports the client-supplied window.name to the server as the windowName parameter and stores it in the page's serialized state, so the injected script is emitted unescaped into the Ajax-call precondition and executes in the application's origin on every subsequent render of that page instance. No public exploit code is identified at time of analysis; the mechanism is fully described in the Apache advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
Stored cross-site scripting in Apache Wicket's AjaxNewWindowNotifyingBehavior allows a client-supplied browser window name to be persisted in a page instance's serialized state and later emitted as raw, unescaped JavaScript, executing in the application's origin each time that page instance is rendered. Wicket 8.0.0 through 8.19.0, 9.0.0 through 9.24.0 and 10.0.0 through 10.11.0 are affected, but only applications that explicitly added the behaviour to a component are exposed, since the framework never installs it; the vector is unauthenticated (PR:N) yet requires victim interaction and specific attack prerequisites, so real-world priority is moderate rather than urgent. No public exploit identified at time of analysis, and the vendor has released fixes in 8.20.0, 9.25.0 and 10.12.0.
RemediationAI
Upgrade to the vendor-fixed releases: Apache Wicket 8.20.0, 9.25.0 or 10.12.0 depending on the branch in use, as documented in the Apache advisory at https://lists.apache.org/thread.html/fs3vdddt9bwshdstj952psj49s5w4vqm. Where an immediate upgrade is not possible, the effective compensating control is to audit application code and remove AjaxNewWindowNotifyingBehavior from any component that declares it, accepting the loss of the second-window/tab detection functionality that the behaviour provides; applications that never added the behaviour require no action on this issue.
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
Apache Wicket is a component-oriented Java web framework in which page instances carry serialized state held in a page store. The affected class, org.apache.wicket.ajax.AjaxNewWindowNotifyingBehavior, detects that a page has been opened in a second browser window or tab by asking the browser for window.name, which arrives at the server as the windowName request parameter and is retained in a field of the behaviour; because that field is part of the page's serialized state, the value survives for the lifetime of the page instance. On every later render the behaviour builds the precondition of its Ajax call by substituting the remembered value into a single-quoted JavaScript string literal, and Wicket writes an Ajax call listener's precondition into the page as raw JavaScript because that script is treated as caller-supplied and is emitted without quoting or escaping. Wicket applies no validation to the window name, so a remembered value containing a single quote terminates the literal and the remainder executes as script in the application's origin. This is CWE-79 improper neutralization of input during web page generation, tracked against the CPE cpe:2.3:a:apache_software_foundation:apache_wicket. The name the behaviour generates for itself when the browser reports no window name is a random UUID and is not client-controllable, and no part of the framework installs the behaviour automatically - exposure depends entirely on an application explicitly adding it to a component.
Know when Apache Wicket 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:P/PR:N/UI:P/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N
Network-reachable and unauthenticated (AV:N/PR:N); AC:H reflects the required window.name manipulation plus the non-default behaviour; UI:R and S:C because injected script runs in the browser against the app origin.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Improper neutralization of input during web page generation in Apache Wicket.
org.apache.wicket.ajax.AjaxNewWindowNotifyingBehavior notices that a page instance has been opened in a second browser window or tab. It asks the browser for the value of window.name, which reaches the server as the request parameter windowName, and remembers what the browser reported in a field of the behaviour. That field is part of the page's serialized state, so the remembered value stays in the page store for as long as the page instance does.
On every later render of that page instance the behaviour builds the precondition of its Ajax call by substituting the remembered value into a single-quoted JavaScript string literal, and Wicket writes that precondition into the page as raw JavaScript, because the precondition of an Ajax call listener is script supplied by the caller and is emitted without quoting or escaping. Nothing on that path escapes the value. The window name is client-supplied and Wicket applies no validation to it, so a remembered name containing a single quote ends the literal and the rest of it runs as script in the application's origin, every time that page instance is rendered.
An application is affected only where it has explicitly added AjaxNewWindowNotifyingBehavior to a component. No part of the framework installs the behaviour, so an application that does not use it is not affected. The name the behaviour generates for itself, when the browser reports no name at all, is a random UUID and is not client-supplied.
This issue affects Apache Wicket: from 8.0.0 through 8.19.0, from 9.0.0 through 9.24.0, from 10.0.0 through 10.11.0.
Users are recommended to upgrade to version 8.20.0, 9.25.0 or 10.12.0, which fix the issue.
Articles & Coverage 2
Executive ViewAI
A stored cross-site scripting flaw in Apache Wicket, a Java web framework, can allow an attacker to execute malicious JavaScript in the context of our applications. Only applications that have explicitly added the vulnerable AjaxNewWindowNotifyingBehavior component are affected. While exploitation requires user interaction and specific prerequisites, the potential for session hijacking or data theft means leadership should prioritize identifying exposure and upgrading to a fixed version.
Apply vendor patch.
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
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
More in Apache Wicket
View allPath traversal vulnerability in Apache Wicket's FolderUploadsFileManager allows unauthenticated attackers to read arbitr
Apache Wicket's form-less upload endpoint (AbstractFileUploadResource, the server side of FileUploadToResourceField, or
Heap-exhaustion denial of service in Apache Wicket 9.14.0 through 9.24.0 and 10.0.0 through 10.11.0, reachable without a
Cross-site scripting in Apache Wicket 8.0.0 through 8.19.0, 9.0.0 through 9.24.0 and 10.0.0 through 10.11.0 allows text
Cross-site scripting in Apache Wicket 8.0.0 through 8.19.0, 9.0.0 through 9.24.0 and 10.0.0 through 10.11.0 lets a value
Cross-site scripting in Apache Wicket 8.0.0 through 8.19.0 lets remote attackers get script executed in the application'
Apache Wicket's public JavaScriptUtils.escapeQuotes() helper fails to escape backslashes before quotes, so attacker-infl
Cross-site scripting in Apache Wicket's SmartLinkLabel and SmartLinkMultiLineLabel components turns attacker-influenced
Session fixation in Apache Wicket's role-based authentication module leaves the container session id unchanged when an a
Missing authorization in Apache Wicket 8.x, 9.x and 10.x allows unauthenticated remote attackers to invoke a component's
Missing authorization in Apache Wicket 10.3.0 through 10.11.0 allows a remote unauthenticated caller to invoke the serve
Unauthenticated remote attackers can partially read and modify data in Apache Wicket versions 9.0.0 through 9.23.0 and 1
EUVD-2026-114894
GHSA-cvcm-96v9-xgwm
NVD
CVE.org
EPSS
Exploit-DB