Description

Jenkins GitLab Plugin 1.9.16 and earlier allows overwriting the global GitLab connection configuration through Stapler data binding, allowing attackers to connect to an attacker-specified URL using GitLab API tokens already configured by administrators.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "5.4",
  "pubDate": "2026-09-02T16:17:31.047Z",
  "pubdate": "2026-09-02T16:17:31.047Z",
  "executiveSummary": "The Jenkins GitLab Plugin versions 1.9.16 and earlier are susceptible to an improper input validation vulnerability involving Stapler data binding. This flaw allows an attacker to manipulate the global GitLab connection configuration by injecting arbitrary values.\nBy overwriting these global settings, an unauthorized actor can redirect Jenkins' outbound GitLab API requests to an attacker-controlled endpoint. The critical impact is the potential exfiltration of existing, administrator-configured GitLab API tokens.\nThis vulnerability is categorized as an improper access control or configuration manipulation issue. The primary risk lies in the compromise of sensitive authentication credentials, which could lead to unauthorized access to the victim's GitLab repositories, service accounts, or broader CI/CD pipeline infrastructure.\nExploitation requires no complex interaction beyond the ability to trigger the affected Stapler data binding process, often occurring through crafted HTTP requests. The vulnerability effectively turns the Jenkins instance into a relay for the attacker, enabling them to capture sensitive tokens that the server would otherwise transmit securely to the legitimate GitLab instance. Organizations using affected versions should prioritize updates or configuration access restrictions to mitigate the risk of credential theft.",
  "technicalDetails": "The vulnerability originates from the insecure use of Stapler data binding in the Jenkins GitLab Plugin. Stapler is the core request-handling framework in Jenkins, responsible for mapping HTTP requests to Java object properties. In this instance, the plugin fails to properly restrict which fields can be modified during the binding process of the global configuration object.\nThe root cause lies in the exposure of internal configuration parameters to the data binding mechanism without sufficient authorization checks or input filtering. An attacker can craft a specific POST request containing parameters that correspond to the GitLab connection settings. When this request is processed, the Stapler framework automatically maps these parameters to the plugin's configuration object in memory, effectively overwriting legitimate settings with malicious ones.\nThe attack flow follows a predictable sequence. First, the attacker identifies that the application allows arbitrary binding of configuration properties. The attacker sends a request designed to update the 'GitLab Host URL' or similar connection-related fields to an attacker-controlled server. Because the plugin does not enforce a strict schema or require a specific administrative context for these updates, the state of the Jenkins configuration is mutated.\nOnce the target host is updated, the Jenkins instance will attempt to authenticate with the attacker-controlled server whenever a GitLab-related action or background synchronization is triggered. As part of this handshake, the Jenkins plugin includes the configured GitLab API tokens in the request headers or body. The attacker's server receives these tokens, successfully completing the exfiltration.\nThis vulnerability impacts all versions up to 1.9.16. Exploitation is typically performed over the network, and the attacker does not necessarily need highly privileged Jenkins access if the endpoint responsible for the data binding is exposed without proper CSRF (Cross-Site Request Forgery) protection or specific permission requirements. Post-exploitation, the attacker possesses valid API tokens, enabling them to perform unauthorized actions against the organization's GitLab environment, including repository cloning, privilege escalation within GitLab, or persistent access to private project data. The lack of validation on the binding process renders the internal configuration state untrustworthy."
}