Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLoad page exposing the callback URL
-
DeliveryCraft filesInfo JSON with a ~2GB file size
-
ExploitInvoke Ajax callback via GET or POST
-
ExecutionTrigger oversized byte-array allocation in UploadInfo#get()
-
ImpactExhaust JVM heap and deny service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Exploitation requires an application that deliberately extends and mounts org.apache.wicket.markup.html.form.upload.resource.FileUploadToResourceField - this is NOT the ordinary FileUploadField/Form upload path - AND that calls UploadInfo#get() to obtain upload bytes rather than reading UploadInfo#getFile() itself; absent the get() call the oversized allocation does not occur. No prior upload, no user interaction, and no authentication beyond whatever the hosting page itself requires are needed (PR:N); both GET and POST reach the callback, whose URL is rendered into the page. Exploitation is refused where the application's authorization strategy denies the ENABLE action on the field. Affected: Wicket 9.14.0 through 9.24.0 and 10.0.0 through 10.11.0; the 8.x line does not contain this component and is not affected. A size value that the int conversion turns negative instead raises an uncaught NegativeArraySizeException that escapes into the application. |
| Impact | The source assigns CVSS 4.0 of 8.3 (High) with vector AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:H, which correctly frames this as a network-reachable, low-complexity availability (DoS) issue rather than a confidentiality breach - note the 'Information Disclosure' tag conflicts with VC:N and CWE-789 (memory allocation with excessive size) and appears mislabeled. The vuln.today decision label is 'this_week' (prompt, not emergency). No EPSS score, no CISA KEV listing, and no PoC/exploit reference were supplied - the only reference is the Apache advisory thread - so there is no public exploit identified at time of analysis and no evidence of active exploitation. The AT:P (attack requirements present) metric reflects the real limiter: exploitation only works where an application has deliberately extended and mounted FileUploadToResourceField AND calls UploadInfo#get(), which is not the ordinary FileUploadField/Form upload path. Net: a genuinely high-severity DoS when the preconditions hold, but real-world exposure is narrowed sharply by the uncommon component usage, so this is a prioritize-but-not-drop-everything item consistent with the 'this_week' label rather than a mass-exploitation emergency. |
| Exploit ScenarioDerived | An attacker loads any page of a Wicket application that mounts FileUploadToResourceField, reads the callback URL rendered into that page, and sends a crafted request whose filesInfo JSON declares a file (never actually uploaded) with a size near two gigabytes. If the application then calls UploadInfo#get(), the server allocates that oversized byte array up front; repeating a few such trivial requests exhausts the JVM heap and denies service to all requests. No published PoC exploit code was provided in the input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
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 authentication (CVSS 4.0 PR:N) by any client that can load a page rendering the FileUploadToResourceField callback URL. The Ajax callback trusts the client-supplied filesInfo JSON without binding it to a real upload, and UploadInfo#get() allocates a byte array sized from the attacker-controlled UploadInfo#getSize() before opening any file, so a single small request can cost close to two gigabytes of heap and repeated requests exhaust the JVM heap for all requests; a size that converts to a negative int instead throws an uncaught NegativeArraySizeException into the application. Exploitation is narrowly scoped: the application must deliberately extend and mount this component (not the ordinary FileUploadField/Form path) and must call UploadInfo#get(); no public exploit code or active exploitation was identified at time of analysis, and the priority label is this_week.
RemediationAI
Upgrade to Apache Wicket 9.25.0 (for the 9.x line) or 10.12.0 (for the 10.x line), which fix the issue; see the vendor advisory at https://lists.apache.org/thread.html/h5lxspxg746pzjd437n3n7mq5t3sfbcb. If an immediate upgrade is not possible, two application-level controls apply as stated by the vendor: replace calls to UploadInfo#get() with direct reads of UploadInfo#getFile(), which avoids the byte-array allocation sized from the request-supplied value and therefore removes the heap-exhaustion path (applications relying on the convenience of get() must reimplement that byte retrieval themselves, including their own size validation); or have the authorization strategy deny the ENABLE action on the field, which causes the callback to be refused like any other listener, at the cost of disabling the component's upload callback functionality for that field. Applications that do not need the separate-resource upload model can also stop extending and mounting FileUploadToResourceField altogether, reverting to the standard FileUploadField/Form path, which is unaffected. Note that the negative-size case raises NegativeArraySizeException outside the internal exception handler, so applications calling get() should also bound the size they accept.
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 flaw is CWE-789 (memory allocation with an excessive size value) in org.apache.wicket.markup.html.form.upload.resource.FileUploadToResourceField, a Wicket component that uploads files to a separately mounted resource rather than through a form and receives the outcome afterwards over its own Ajax callback. That callback reads the request parameter filesInfo - a JSON array of client file name, size and content type per entry - and converts it into the list of FileUploadToResourceField.UploadInfo passed to onUploadSuccess(). Nothing binds that JSON to an upload the resource actually performed and nothing re-derives the values from stored files, so the entry count and every value are whatever the request supplied; the callback URL is rendered into the page, no prior upload is needed, and both GET and POST reach it. The oversized allocation occurs in UploadInfo#get(), which the class offers as the way to obtain upload bytes and which sizes a byte array from UploadInfo#getSize() before opening the file, so the array is sized from the request-supplied number and allocated even for a file that was never stored. If the size conversion to int produces a negative value, NegativeArraySizeException is thrown outside the exception handler inside that method and escapes into the application. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:H) reflects that specific deployment prerequisites must be present (the component extended and mounted, and get() used) while confidentiality impact is none and availability impact is high; the accompanying 'Information Disclosure' tag conflicts with VC:N and with CWE-789 and appears mislabeled, and this is consistent with the independently assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H. The 8.x line does not contain this component and is not affected.
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
Network-reachable callback hit by a trivial, repeatable request (AV:N/AC:L), no auth beyond the page (PR:N), no UI; heap-exhaustion DoS (A:H) with minor integrity from forged file metadata (I:L) and no confidentiality impact (C:N).
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Memory allocation with an excessive size value in Apache Wicket.
org.apache.wicket.markup.html.form.upload.resource.FileUploadToResourceField uploads files to a separately mounted resource rather than through a form, and is told the outcome afterwards over its own Ajax callback. That callback reads the request parameter filesInfo, a JSON array carrying a client file name, a size and a content type for each file, and turns it into the list of FileUploadToResourceField.UploadInfo that onUploadSuccess() receives. Nothing binds that JSON to an upload the resource performed and nothing re-derives it from the stored files, so the number of entries and every value in them are whatever the request supplied. The callback URL is rendered into the page, no prior upload is required, and both GET and POST reach it, so any client that can load the page can have the component report files that were never uploaded, without authenticating beyond whatever the page itself requires and without any user interaction.
UploadInfo#get(), which the class offers as the way to obtain the bytes of an upload, allocates a byte array from UploadInfo#getSize() before it opens the file. The array is therefore sized by the number the request supplied, and the allocation happens even for a file that was never stored. One small request can cost the server close to two gigabytes of heap, and the request is trivially repeatable, so a few of them exhaust the heap for every request the Java virtual machine is serving. A size that the conversion to int turns negative instead throws NegativeArraySizeException, which the exception handler inside that method does not cover, so it escapes into the application.
An application is affected where it uses FileUploadToResourceField, which is not the ordinary upload path through FileUploadField and Form and has to be extended and mounted deliberately. The allocation additionally requires the application to call UploadInfo#get() rather than reading UploadInfo#getFile() itself. Where the application denies the ENABLE action on the field through its authorization strategy, the callback is refused like any other listener. The 8.x line does not contain this component and is not affected.
This issue affects Apache Wicket: from 9.14.0 through 9.24.0, from 10.0.0 through 10.11.0. 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-83594 is a high-severity denial-of-service vulnerability in Apache Wicket, a widely used Java web framework, affecting versions 9.14.0 through 9.24.0 and 10.0.0 through 10.11.0. Unauthenticated attackers can render a page that mounts the FileUploadToResourceField component, then send a single small request that allocates nearly two gigabytes of heap memory, rapidly exhausting the JVM and disrupting service for all users. Only applications that deliberately extend and mount this specific component and call UploadInfo#get() are exposed, but for those that do, the impact is severe service unavailability with no vendor patch yet available.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict network exposure of endpoints mounting FileUploadToResourceField, apply WAF rules and rate limiting, enforce server-side bounds on UploadInfo#getSize() and filesInfo JSON before array allocation, and monitor JVM heap usage for anomalous spikes.
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
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
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-114897
GHSA-7x2v-qvvr-3xhg
NVD
CVE.org
EPSS
Exploit-DB