Description

Jenkins 2.579 and earlier, LTS 2.568.2 and earlier does not escape map keys when serializing objects as JSON and Python through its REST API, allowing attackers able to control map property names to inject arbitrary fields into JSON and Python API responses.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "4.3",
  "pubDate": "2026-09-02T16:17:30.177Z",
  "pubdate": "2026-09-02T16:17:30.177Z",
  "executiveSummary": "A critical security flaw in Jenkins allows for the injection of arbitrary fields into JSON and Python REST API responses.\nThe vulnerability stems from improper sanitization of map keys during the object serialization process.\nAffected products include Jenkins 2.579 and earlier, and LTS 2.568.2 and earlier.\nThis vulnerability facilitates an injection attack where an attacker capable of controlling map property names can manipulate the structure of API responses.\nThe primary risk involves data manipulation or potential downstream processing errors in systems that consume Jenkins API data.\nExploitation requires the attacker to have the capability to influence map property names used by the application, which may be achievable through various input vectors depending on the specific Jenkins plugin or configuration.\nThe vulnerability does not inherently grant remote code execution, but it compromises the integrity of data exchanged via the REST API, potentially leading to unauthorized data exposure or misleading automated processes.",
  "technicalDetails": "The vulnerability is rooted in an improper handling of map key serialization within the Jenkins REST API framework. When Jenkins serializes objects into JSON or Python formats for API responses, it fails to perform adequate input validation or character escaping on map keys.\nIn scenarios where an attacker can supply input that is subsequently used as a map key in a serialized object, they can inject arbitrary characters, such as control characters, quote marks, or structural JSON markers, into the resulting output stream.\nThis behavior allows for an injection attack whereby the attacker forces the serialization logic to terminate the intended field prematurely or insert additional fields into the JSON/Python object structure that were not originally intended by the system.\nThe attack flow proceeds as follows: First, the attacker identifies an API endpoint or input mechanism within Jenkins or its installed plugins that allows user-controlled data to populate map keys. Second, the attacker crafts a malicious payload containing JSON structural characters intended to break out of the intended key context. Third, the application processes the request and improperly serializes the map keys without escaping the malicious input. Finally, the REST API returns a response containing the injected fields, effectively spoofing, augmenting, or corrupting the expected data structure.\nThis flaw affects Jenkins core versions 2.579 and earlier, and LTS versions 2.568.2 and earlier. The exposure is primarily network-based, as the REST API is typically accessible over HTTP/HTTPS, and the impact depends on the privileges required to reach the specific vulnerable endpoint. The lack of proper escaping effectively permits an attacker to alter the schema of the API response, which could be leveraged to bypass client-side validation, trick automated downstream systems that rely on specific response formats, or facilitate secondary attacks by manipulating the response payload.\nPost-exploitation, the impact is strictly limited by the context of the JSON or Python response. While not a direct path to server-side code execution, the integrity of the data stream is violated, undermining the trust model between the Jenkins instance and any consuming services or scripts."
}