Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocate mounted upload resource endpoint
-
DeliveryPOST multipart request with oversized maxSize parameter
-
ExploitParser applies no effective size/count limit
-
ExecutionSpool huge parts to disk and read parts into heap
-
ImpactRepeat to exhaust disk or memory (DoS)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitable only where the application deliberately uses FileUploadToResourceField or itself mounts FileUploadResourceReference - this is not the ordinary Form/FileUploadField or AjaxFileDropBehavior path, which read limits from the component and are unaffected; the 8.x line lacks the resource entirely. The defect only removes protection if the application actually configured a limit via setMaxSize()/setFileMaxSize()/setFileCountMax(); an application that set no total-size limit loses nothing because Wicket imposes none by default. The trigger is a client-supplied maxSize (and omitted fileMaxSize/fileCountMax) request parameter overriding the configured value. Per CVSS PR:N and the default authorization strategy permitting all resource requests, no authentication, session, prior page view or user interaction is required - unless the application explicitly authorizes the resource, which would then gate access. |
| Impact | This is a CWE-770 resource-exhaustion (denial-of-service) flaw in Apache Wicket's form-less upload resource, rated CVSS 4.0 8.3 (AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:H). The network vector, low complexity and PR:N indicate that where the vulnerable resource is mounted, a remote unauthenticated attacker can trigger it against default authorization. The decisive limiter is AT:P (attack requirements present), which here is not a race or timing condition but the deployment precondition: the application must deliberately use FileUploadToResourceField or mount FileUploadResourceReference, AND must have configured an upload limit for the defect to remove anything - an app that sets no limit loses nothing. No EPSS score and no KEV listing are provided, and the sole reference is an Apache advisory, so there is no public exploit identified at time of analysis. The vuln.today decision label is this_week, consistent with a serious but conditional DoS rather than an emergency: impact is primarily availability (VA:H, heap/disk exhaustion) with limited integrity (VI:L, attacker-named files written to the uploads folder) and no confidentiality impact. Net: a genuine priority for the specific minority of Wicket applications using this upload resource with configured limits, but not a mass-exploitation threat given the deliberate, non-default deployment requirement. |
| Exploit ScenarioDerived | An application mounts Wicket's FileUploadToResourceField / FileUploadResourceReference and relies on setMaxSize()/setFileMaxSize()/setFileCountMax() to cap uploads. A remote unauthenticated attacker POSTs a multipart request to that resource endpoint supplying its own huge maxSize parameter (and omitting fileMaxSize/fileCountMax), so the server-configured ceilings are ignored and the parser applies no effective limit. Repeating the request spools arbitrarily large file parts to disk and reads non-file parts fully into the heap, exhausting disk or memory; no public exploit code is identified, but the technique follows directly from the advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
Apache Wicket's form-less upload endpoint (AbstractFileUploadResource, the server side of FileUploadToResourceField, or a manually mounted FileUploadResourceReference) takes its upload bounds from client-supplied request parameters - maxSize, fileMaxSize and fileCountMax - instead of from the values the application configured via setMaxSize(), setFileMaxSize() and setFileCountMax(). A client that supplies a very large maxSize, or omits the per-part and part-count parameters, can therefore drive one repeatable request to spool unlimited data to disk or read non-file parts into the heap, exhausting disk or memory. Affected releases are 9.14.0 through 9.24.0 and 10.0.0 through 10.9.1; the 8.x line has no such resource, and the ordinary Form/FileUploadField and AjaxFileDropBehavior paths are unaffected because they read limits from the component. Rated CVSS 4.0 8.3 (with attack requirements present, AT:P, since the application must deliberately use or mount this resource) and rated 'this_week' by priority; no public exploit code was identified at time of analysis.
RemediationAI
Upgrade to the vendor-fixed releases: Apache Wicket 9.25.0 for the 9.x line or 10.12.0 for the 10.x line (Vendor-released patch: 9.25.0 and 10.12.0), as announced in the Apache advisory at https://lists.apache.org/thread.html/bw3hn5cch3q7yrsl05m8mvmgyx4m98y7. If an immediate upgrade is not possible, change where the upload bounds come from: stop mounting FileUploadResourceReference or stop using FileUploadToResourceField in code handling untrusted clients, which removes the feature entirely for those callers rather than letting a request override the configured limits - the trade-off is loss of form-less uploads until the upgrade. Alternatively, add an explicit authorization check on the resource (Wicket's default strategy permits every resource request), which forces authentication or other gating before the multipart parser is reached but will break legitimate anonymous or session-less uploads. Enforcing request body-size limits at the front proxy or servlet container caps total upload size for the whole application rather than this endpoint specifically and can truncate legitimate large uploads. Note that a configured setMaxSize()/setFileMaxSize()/setFileCountMax() value provides no protection on these versions when the client supplies the matching parameter, so configuration alone is not a mitigation.
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-770, allocation of resources without limits or throttling. org.apache.wicket.markup.html.form.upload.resource.AbstractFileUploadResource is an application-wide singleton with no owning component to consult, so newResourceResponse() hands the multipart parser the total request size, per-part maximum and part-count maximum taken straight from the request parameters maxSize, fileMaxSize and fileCountMax. Nothing binds those numbers to the field that is uploading, and the application-configured values are only consulted when the corresponding parameter is absent - so against a client that supplies one, the configured ceiling has no effect. Parts above the parser's in-memory threshold are spooled to the servlet container's temporary directory and then copied into the folder managed by the application's IUploadsFileManager under a request-named sub-folder, where they remain; non-file parts are read fully into heap during parsing. The resource carries no authorization annotation and Wicket's default authorization strategy permits every resource request, so without application-level authorization the request needs no authentication, session, prior page view or user interaction. The CVSS 4.0 vector's AT:P reflects that this is not a default-exposed path: the application must deliberately use FileUploadToResourceField or mount FileUploadResourceReference. No CPE-differentiated variants are listed beyond the single apache_software_foundation:apache_wicket CPE; the version split (9.x, 10.x affected, 8.x unaffected) is the meaningful deployment distinction, and the trigger is not described beyond the client-supplied parameter override.
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:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated request against default resource authorization (AV:N/AC:L/PR:N/UI:N); availability exhaustion drives A:H, attacker-written files give I:L, no confidentiality impact so C:N.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Allocation of resources without limits or throttling in Apache Wicket.
org.apache.wicket.markup.html.form.upload.resource.AbstractFileUploadResource is the server side of the form-less upload offered by FileUploadToResourceField, which posts the selected files to a separately mounted resource rather than through a Form. The resource is an application-wide singleton with no component to consult, so newResourceResponse() takes the three limits that bound the upload - the total request size, the maximum size of a single part and the maximum number of parts - from the request parameters maxSize, fileMaxSize and fileCountMax, and hands them to the multipart parser as they arrive. Nothing binds those numbers to the field that is supposed to be uploading. A request naming a very large maxSize is therefore parsed with no effective ceiling on the total size, and omitting fileMaxSize and fileCountMax leaves the per-part and part-count limits unset as well. The values the application configured through FileUploadToResourceField#setMaxSize(), #setFileMaxSize() and #setFileCountMax() are consulted only when the client omits the corresponding parameter, so against a client that supplies one they have no effect at all.
Parts above the parser's in-memory threshold are spooled to the container's temporary directory, and the file parts are then copied into the folder the application's IUploadsFileManager owns, under a sub-folder the request names, where they remain. A part that is not a file is read into the heap in full while the request is parsed. One request, repeatable, can therefore consume as much disk or as much heap as the client chooses to send. The resource carries no authorization annotation and the default authorization strategy permits every resource request, so unless the application authorizes the resource itself the request needs no authentication, no session, no prior page view and no user interaction.
An application is affected where it uses FileUploadToResourceField, or mounts FileUploadResourceReference itself. This is not the ordinary upload path: the resource is a singleton that has to be created and mounted deliberately. An application that configures no upload limit at all loses nothing, because Wicket applies no total-size limit of its own by default; what the defect removes is a limit the application set. Uploads through Form with FileUploadField, and through AjaxFileDropBehavior, are not affected, because both read their limits from the component rather than from the request. The upload resource does not exist in the 8.x line.
This issue affects Apache Wicket: from 9.14.0 through 9.24.0, from 10.0.0 through 10.9.1. Users are recommended to upgrade to version 9.25.0 or 10.12.0, which fix the issue.
Articles & Coverage 2
Executive ViewAI
CVE-2026-84170 is a high-severity vulnerability in Apache Wicket's form-less upload endpoint (AbstractFileUploadResource) affecting releases 9.14.0-9.24.0 and 10.0.0-10.9.1. It allows a client to override configured upload limits, potentially exhausting server disk or memory with a single repeatable request. This impacts the availability of customer-facing applications that rely on this optional resource, but the standard Form/FileUploadField and AjaxFileDropBehavior paths are not affected, and the attack requires the application to deliberately use or mount the resource.
No vendor-released patch identified at time of analysis. Interim mitigations: enforce request size limits and rate limiting at the reverse proxy or load balancer; avoid exposing the form-less upload resource unless required; monitor disk and memory usage for abnormal spikes; restrict or disable the endpoint if not in active use.
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.
More in Apache Wicket
View allPath traversal vulnerability in Apache Wicket's FolderUploadsFileManager allows unauthenticated attackers to read arbitr
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
Stored cross-site scripting in Apache Wicket's AjaxNewWindowNotifyingBehavior allows a client-supplied browser window na
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-114898
GHSA-w478-29fp-9q59
NVD
CVE.org
EPSS
Exploit-DB