GCVE-1988-2026-0508
Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30| Vendor | Product | Version | CPE status | |
|---|---|---|---|---|
| unknown | Continued Apache Struts2 |
Affected:
unknown
|
guessed |
{
"containers": {
"cna": {
"affected": [
{
"product": "Continued Apache Struts2",
"vendor": "unknown",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "Daniel Owens via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "Summary\nThus far we have written extensively about the rampant number of insecure JavaScript Object Notation (JSON) \ndeserialisers available today, like in \"Struts2 and Related Framework Array/Collection DoS\" (26 October 2025) and \"JSON \nDeserialiser Unconstrained Resource Consumption Quick Overview\" (07 March 2026), along with a na\u00efve proof of concept \nscript that demonstrated what we were talking about -- \"JSON Deserialiser Unconstrained Resource Consumption Proof of \nConcept\" (29 August 2026). Today we will continue analyse the Apache Struts2 JSON plugin, which serves as a clear case \nstudy in how shallow input limits fail to protect against underlying architectural memory amplification bugs.\n\nAs previously mentioned, this vulnerability has existed and been known/exploited by members of this team across \nnumerous deserialisers for decades. JSON and alternative format parsers (such as CBOR or multi-part forms) are \nnear-universally susceptible to this issue. Some formats allow what we call \"skip counting\", which Apache Struts\u0027 base \ndeserialiser did for many years, but many simply do not properly control for memory growth as the parser deserialises \nthe data. These flaws can be used to cause denial of service conditions, bypass authentication, inject unintended data \ninto the information system, and so much more based on what you do, how you do it, and what your goals are. This work \nwill continue to focus on the DOS aspect to keep things simple and because it allows us to discuss the issue across \nsystems, rather than in specific contexts and use cases.\n\nEvaluation of the WW-5618 and S2-072 Hardening Controls\nFirst, let\u0027s walk through the timeline. In October 2025, we reported the \"greater issue\" and, on 16 January 2026, we, \nvia VulnCheck, attempted to properly disclose the vulnerability to Apache. Apache classified it as \"not a \nvulnerability\" and, instead, took it as an opportunity to \"harden\" the code by putting in a few basic checks via PR \n#1625 (https://github.com/apache/struts/pull/1625) and PR #1626 (https://github.com/apache/struts/pull/1626) (tracked \ncollectively as WW-5618, which shipped as version 6.9.0 on 27 April 2026 and version 7.2.1 on 15 June 2026). In short, \non 17 March 2026 (after our second writing on the matter), they added in:\n\n * struts.json.maxElements (default: 10,000)\n * struts.json.maxDepth (default: 64)\n * struts.json.maxLength (default: 2,097,152)\n * struts.json.maxStringLength (default: 262,144)\n * struts.json.maxKeyLength (default: 512)\n\nIn addition to each of those, the development team added input validation checks inside of `StrutsJSONreader` \n(`JSONReader` was, effectively, renamed thereto as part of the aforementioned pulls -- it is now simply an interface) \nthat\n\n * check the String length as it is built up (inside of `string(char)`)\n * check the String length of a Map key (inside of `object()`)\n * check the array depth when deserialising a collection, array, or similar object that is represented in JSON as a \nJSON array (inside of `array()`)\n * check the number of elements in the collection, array, or similar object that is represented in JSON as a JSON \narray (inside of `array()`)\n\nLater, Apache issues S2-072 in a further attempt to improve the input validation process. The implementation, however, \nfails to close the gap, due in part to the boundary checks being applied in isolation to individual collection \ninstances during recursion, rather than thereacross. Today we\u0027ll look at the `array()` changes and how they have, \neffectively, solved little, leaving information systems vulnerable to the same vulnerability that we continue to \ndiscuss.\n\nThe Code\nThe following is taken directly from the official Apache Struts repository -- \nhttps://raw.githubusercontent.com/apache/struts/refs/heads/main/plugins/json/src/main/java/org/apache/struts2/json/StrutsJSONReader.java\n (27 October 2026):\n\n protected List\u003cObject\u003e array() throws JSONException {\n if (this.depth \u003e= this.maxDepth) {\n throw new JSONException(\"JSON array nesting exceeds maximum allowed depth (\"\n + this.maxDepth + \"). Use \" + JSONConstants.JSON_MAX_DEPTH + \" to increase the limit.\");\n }\n this.depth++;\n try {\n List\u003cObject\u003e ret = new ArrayList\u003c\u003e();\n Object value = this.read();\n\n while (this.token != ARRAY_END) {\n if (ret.size() \u003e= this.maxElements) {\n throw new JSONException(\"JSON array exceeds maximum allowed elements (\"\n + this.maxElements + \"). Use \" + JSONConstants.JSON_MAX_ELEMENTS + \" to increase the \nlimit.\");\n }\n ret.add(value);\n\n Object read = this.read();\n if (read == COMMA) {\n value = this.read();\n } else if (read != ARRAY_END) {\n throw buildInvalidInputException();\n }\n }\n\n return ret;\n } finally {\n this.depth--;\n }\n }\n\nThe Process\nFirst, to understand where they continue to go wrong, we have to understand how they operate:\n\n 1. Input traverses to StrutsJSONReader via a call to the public \"read(String)\" method.\n 2. It sets up an iterator, starts it on the first character, sets the depth to `0`, and then runs `read()`.\n 3. `read()`coordinates tokenisation and, upon seeing `[` outside of quotes (single or double), passes tokenisation \nto `array()`, which is the code above.\n 4. `array()` checks its depth and, if too great, it throws an exception, otherwise it continues.\n 5. `array()` increments `depth`.\n 6. `array()` creates a new `ArrayList` to store the elements.\n 7. `array()` tokenises, via `read()` calls, until either its array has too many elements (at which point an \nexception is thrown) or the array is ended (either via `]`, which is positive, or rude termination of the iterator).\n 8. `array()` decrements `depth` and returns the array to the caller.\n\nThe Deep Defect: Tracking Flaws \u0026 Heap Amplification\nThe problem with this process is that it protects only against a very small set of inputs. For example, the obvious \narray-of-arrays attack currently means that you can have 10,000^64 (or 1 x 10^256) elements via an array-of-arrays \nstructure because the limit checks are scoped per-instance of a single array context inside the recursion.\n\nUnderstanding that the default maximum length is two megabytes (struts.json.maxLength), and assuming that a victim does \nnot adjust that value, we are talking about roughly 690,000 elements if the JSON is merely an array-of-arrays of empty \nstrings, or 419,000 elements if the JSON is an array-of-arrays of nulls or two-character Strings. With those numbers, \nyou really only need a nesting depth of 2 to build a structure holding 100,000,000 elements - which is 10,000 * 10,000 \nand far more than fits the payload bill.\n\nBut that\u0027s not the full story. We know that a pointer -- regardless of to what it points -- takes 4 bytes if your \nmaximum heap size is under 32GB (with compressed oops enabled) and 8 bytes on a 64-bit JVM if the heap size is greater \nthan 32GB. This means that an array of nulls incurs the cost of the ArrayList wrapper plus the cost of each pointer. \nThe wrapper itself requires roughly 40 bytes plus its backing array, which accounts for an additional 32-40 bytes plus \n(elements * pointerSize).\n\nIf, instead, we use two-byte strings, we have the cost of the ArrayList, plus the cost of each pointer, plus the cost \nof each String. Java interns certain literals, so duplicates might be interned, but during parsing, this is not \nlikely. Strings carry substantial object overhead, typically consuming 48 bytes on the heap on a 64-bit machine. \nAssuming none of the Strings are interned, a single 10,000 element array of two-character strings consumes roughly \n520KB of RAM - at the transmission cost of just 50,001 characters (~50KB). At a 2MB maximum payload restriction, an \nattacker can cleanly pack roughly 40 of these structures, yielding 20.8MB of RAM for a single collection layer.\n\nThat, however, is only after the ArrayList is fully constructed. ArrayLists are dynamic -- they start at a capacity of \n10 by default and grow automatically by 50% each time that they need to expand. For an array scaling to 10,000 \nelements, the capacity progression is simply:\n10 -\u003e 15 -\u003e 22 -\u003e 33 -\u003e 49 -\u003e 73 -\u003e 109 -\u003e 163 -\u003e 244 -\u003e 366 -\u003e 549 -\u003e 823 -\u003e 1234 -\u003e 1851 -\u003e 2776 -\u003e 4164 -\u003e 6246 -\u003e \n9369 -\u003e 14053\n\nIn other words, that single ArrayList backing array will grow 18 times with each step requiring a fresh array \nallocation, a memory copy from the old to the new (where both sit in memory simultaneously), and an unpredictable, \neventual deallocation of the old array by the Garbage Collector.\n\nMoreover, the final array won\u0027t stop at 10,000 elements -- its allocated size will remain at 14,053 internal spaces. \nThe remaining 4,053 slots will be empty pointers that still consume heap space (~56KB total for the backing array, of \nwhich ~16KB is completely wasted heap space). If transient backing arrays exist concurrently during expansion, that \nscales to ~168.6KB of RAM just for a single array\u0027s resizing churn.\n\nWhen assuming 40 concurrent attackers running an automated script like Commas of D00m, this transient cost translates \nto ~6.76MB just for array allocations, completely independent of the data payload. Balancing the number of arrays \nagainst their node weights allows an attacker to easily optimise this footprint -- attackers can fill arrays to 9370 \nelements, forcing the largest wasted space, and then carefully pick the payload to maximise the consumed space from the \ninput. For example, boxed objects like Integer are exceptionally heavy computationally and structurally, and because \nnative Java Collections do not accept primitives, they force object header overhead across every entry, like Strings, \nand so can be especially good options, particularly if mixed with Strings and other such devices. Adding up these \ncomponents, a single automated payload sequence can easily consume:\n(20.8MB per request * 40 concurrent requests) + 6.76MB = ~838.8MB\n\nStandard production deployments of Apache Tomcat running on normal VMs default to a maximum heap space (-Xmx) \nequivalent to 25% of available physical RAM. For a standard 4GB host allocation, Tomcat\u0027s total available heap size \nsits at exactly 1,024MB, so a minor concurrent attack consumes over 80% of the entire application heap, with an \naddition 257.3MB consumed by total parallel allocation, completely exhausting available memory resources and triggering \nimmediate java.lang.OutOfMemoryError failures that crash the service before garbage collection can clear the transient \ndata.\n\nTaking Things Seriously\nUnderstanding how the deserialiser operates, how the parser operates, which to attack, and when to attack each allows \ndiscovering (and acting upon) a wide array of vulnerabilities and attack vectors, with devastating outcomes to the \nvictim. Organisations need to understand how their system works, how third-party libraries operate, what your use \nthereof and reliance thereupon means to the information system and its data, and understand the risk appetite of your \norganisation, your users, and any third-parties upon which you rely.\n\nBut it all goes to another point: attackers don\u0027t really need true concurrency, either. A stepped attack, which is \nmuch less likely to trigger DoS protections, can achieve the same goal, as can simply adjusting the rate and body, \noptimising what you send and how you send it. In other words, developers (and security professionals) need to take \nthis seriously because it\u0027s not simply a DoS attack and it\u0027s not simply \"flood the victim with data\". Truthfully, \nit\u0027s, like so many other issues, all about your system, how it interacts with and relies on the code, and how "
}
],
"providerMetadata": {
"dateUpdated": "2026-11-02T07:30:04Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/49"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Oct/49"
},
{
"url": "https://github.com/apache/struts/pull/1625"
},
{
"url": "https://github.com/apache/struts/pull/1626"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://raw.githubusercontent.com/apache/struts/refs/heads/main/plugins/json/src/main/java/org/apache/struts2/json/StrutsJSONReader.java"
},
{
"url": "https://seclists.org/fulldisclosure/"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Oct/49"
],
"discovery": "EXTERNAL"
},
"title": "Continued Apache Struts2 JSON Plugin Insecure Deserialisation",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0508",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/49",
"automated": true,
"contentSha256": "c144cc1929170637916496c08867f865746ec7aa88905b611deafdde5ef9d213",
"evidenceScore": 9,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Oct/49",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-10-27T16:59:24Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-02T07:30:04Z",
"dateUpdated": "2026-11-02T07:30:04Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0508"
},
"dataType": "CVE_RECORD",
"dataVersion": "5.2"
}
Drag nodes to arrange them. Double-click a related vulnerability to open it, or a source to visit its link. The Physics button on the left tunes the layout and the simulation; the legend at the bottom left hides or shows nodes by kind and by sighting type.
Sightings
| Author | Source | Type | Date | Other |
|---|
Nomenclature
- Seen: The vulnerability was mentioned, discussed, or observed by the user.
- Confirmed: The vulnerability has been validated from an analyst's perspective.
- Published Proof of Concept: A public proof of concept is available for this vulnerability.
- Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
- Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
- Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
- Not confirmed: The user expressed doubt about the validity of the vulnerability.
- Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.
Vulnerability timeline
Sightings and recorded dates, grouped by day · UTC
How durations are calculated
Following the VTEM framework (Black Hat USA 2015), time to patch starts when the vendor or a coordinator was informed, total time to patch at discovery, and disclosure to patch at public disclosure; vendor response time runs from the report to its acknowledgement. Time to exploit and time unpatched start at the earliest discovery or report, falling back to public disclosure. Unpatched time ends at the first recorded patch, or the calculation time when no patch is recorded. Exploitation to patch shows the interval between those two events; a published proof of concept is a public exploit, not exploitation.
Each result shows its source dates. A negative interval means the end event came first; when date-only inputs leave the order open, the result says so. Date-only inputs are approximate. The earliest evidence wins: KEV report dates and sightings are labelled as such. Records describing another vulnerability are listed but never calculated from, and a PoC alone does not establish exploitation. Missing patch evidence does not prove that no patch exists. Filters below change the event list only.
Loading timeline…
The approach is described in our paper Mapping CVEs to MITRE ATT&CK Techniques: A Curated Gold-Set Classifier and the Limits of LLM-Assisted Label Expansion.
Browse all ATT&CK techniques and the vulnerabilities related to each.
Related by attack behaviour
Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.