CVE-2026-92125

Executive Summary

CVE-2026-92125 is a critical Jenkins Script Security Plugin vulnerability that allows authenticated attackers with permission to define and run sandboxed scripts (including Pipelines) to bypass the Groovy sandbox protections via the @GroovyASTTransformationClass annotation. This flaw permits arbitrary AST (Abstract Syntax Tree) transformation at compile time, leading to arbitrary code execution within the Jenkins controller JVM. With a CVSS score of 8.8, this vulnerability poses a severe risk to Jenkins environments where untrusted users have script-definition privileges, potentially resulting in full compromise of the Jenkins controller and connected CI/CD infrastructure.

Technical Analysis

The vulnerability resides in the Jenkins Script Security Plugin, specifically versions 1415.v9a_f9b_3a_c253d and earlier. The plugin's sandbox mechanism is designed to restrict the execution of untrusted Groovy scripts by intercepting method calls, object instantiation, and other runtime operations. However, the @GroovyASTTransformationClass annotation is a compile-time construct that instructs the Groovy compiler to apply a custom AST transformation to the annotated code.

In a secure configuration, the sandbox should reject or neutralize such annotations because AST transformations execute during the compilation phase—before the sandbox's runtime checks are applied. Because the plugin fails to reject this annotation, an attacker can define a script that includes a class annotated with @GroovyASTTransformationClass, pointing to a malicious transformation class that is either already present on the classpath or can be loaded via other means. When the script is compiled by the Groovy compiler within the Jenkins controller, the transformation executes with the full privileges of the Jenkins controller JVM, completely bypassing the sandbox's restrictions.

The attack surface is limited to users who have the ability to define and run sandboxed scripts, which in Jenkins typically includes users with "Overall/Read" plus "Job/Configure" or "Job/Create" permissions, or those with access to the Jenkins script console (if granted). This is a compile-time code execution flaw, meaning the malicious payload runs even if the script is never actually executed, merely compiled.

The root cause is an incomplete denylist/allowlist of dangerous annotations and language features in the Script Security Plugin. The plugin's sandbox relies on a combination of static compilation checks and runtime interception; the @GroovyASTTransformationClass annotation is a static compile-time feature that was not properly filtered. The CWE-94 classification (Improper Control of Generation of Code) accurately reflects the arbitrary code generation capability enabled by the flaw.

No public proof-of-concept or exploit code is available at this time, and no patch has been released, leaving all deployments of the affected plugin version vulnerable.

Exploitation Scenarios

Attack Chain (inferred from vulnerability class; no public PoC available):

1. Reconnaissance/Target Identification: The attacker identifies a Jenkins instance accessible over the network (AV:N). They require valid credentials with permissions to create or configure a Pipeline job, or access to the Jenkins script console. This typically corresponds to a low-privileged authenticated user (PR:L). The attacker may enumerate Jenkins versions via the web UI or HTTP headers (e.g., X-Jenkins) to confirm the presence of the vulnerable Script Security Plugin.

2. Triggering the Flaw: The attacker creates a new Pipeline job or edits an existing one (or uses the script console if accessible) and inserts a Groovy script that defines a class annotated with @GroovyASTTransformationClass. The annotation references a transformation class that the attacker can control or that already exists on the Jenkins classpath and can be abused. Because the plugin does not reject this annotation, the Groovy compiler accepts it.

3. Payload/Execution Method: When the script is compiled—either upon saving the Pipeline or upon execution—the Groovy compiler invokes the specified AST transformation. This transformation executes arbitrary code at compile time within the Jenkins controller JVM. The attacker's payload can be embedded in the transformation logic, allowing them to run system commands, read/write files, or establish reverse shells. The sandbox does not intercept this because the execution happens before the sandbox's runtime guards are active.

4. Post-Exploitation Impact: Successful exploitation grants the attacker code execution in the context of the Jenkins controller JVM. This typically means access to all Jenkins credentials, secrets, configuration files, and the ability to pivot to connected build agents, source code repositories, and deployment environments. The attacker can persist by installing malicious plugins, modifying jobs, or creating backdoor accounts.

No public PoC or exploit code is available; the above chain is derived from the vulnerability class (CWE-94) and the specific annotation mentioned in the NVD description.

Impact Assessment

The CVSS v3.1 base score of 8.8 (High) reflects the following subscores:

• Attack Vector (AV:N): Exploitable remotely over the network.
• Attack Complexity (AC:L): No special conditions; the attacker simply submits a crafted script.
• Privileges Required (PR:L): The attacker needs low privileges—specifically, permission to define and run sandboxed scripts.
• User Interaction (UI:N): No user interaction required beyond the attacker's own actions.
• Scope (S:U): The impact is confined to the Jenkins controller JVM (though this is already a critical asset).
• Confidentiality (C:H): Full read access to all data accessible by the Jenkins controller, including credentials and secrets.
• Integrity (I:H): Full write access to Jenkins configuration, jobs, and the underlying filesystem.
• Availability (A:H): The attacker can disrupt or destroy the Jenkins instance.

Business Impact: Jenkins is a central component of CI/CD pipelines in many organizations. Compromise of the Jenkins controller can lead to supply chain attacks, where malicious code is injected into build artifacts, deployment scripts, or infrastructure-as-code. The blast radius includes all projects, credentials, and environments managed by the Jenkins instance. Given the low privileges required and the lack of a patch, this vulnerability is highly dangerous for any organization that allows non-administrative users to create or modify Pipeline jobs.

Detection Guidance

Sigma Rule

title: Jenkins Script Security Plugin AST Transformation Bypass Attempt
id: 3a4b5c6d-7e8f-9a0b-1c2d-3e4f5a6b7c8d
status: experimental
description: Detects attempts to exploit CVE-2026-92125 by submitting Groovy scripts containing the @GroovyASTTransformationClass annotation.
author: Valters IT Threat Intelligence
date: 2026-01-15
logsource:
  product: jenkins
  service: script-security
detection:
  selection:
    script|contains: '@GroovyASTTransformationClass'
  condition: selection
falsepositives:
  - Legitimate administrative scripts using AST transformations (rare)
level: high
tags:
  - attack.t1190
  - cve.2026.92125

YARA Rule

rule CVE_2026_92125_Jenkins_AST_Transformation
{
    meta:
        description = "Detects Groovy scripts attempting to exploit CVE-2026-92125 via @GroovyASTTransformationClass"
        author = "Valters IT Threat Intelligence"
        date = "2026-01-15"
        cve = "CVE-2026-92125"
        severity = "high"
    strings:
        $annotation = "@GroovyASTTransformationClass" ascii wide nocase
        $groovy = "GroovyASTTransformation" ascii wide nocase
    condition:
        any of them
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-92125 Jenkins Script Security Plugin AST Transformation Exploit Attempt"; flow:to_server,established; content:"POST"; http_method; content:"@GroovyASTTransformationClass"; http_client_body; nocase; classtype:attempted-admin; sid:202692125; rev:1; metadata:created_at 2026_01_15, cve CVE_2026_92125;)

Elastic Detection

sequence by process.entity_id
  [process where process.name == "java" and event.action == "start"]
  [file where file.path : "*jenkins*" and file.name : "*.groovy"]
  [process where process.name == "java" and process.args : "*GroovyASTTransformation*"]

Splunk SPL Query

index=jenkins sourcetype=jenkins:script OR sourcetype=jenkins:audit
| search "@GroovyASTTransformationClass" OR "GroovyASTTransformation"
| stats count by user, src_ip, job_name, script
| where count > 0
| sort - count

Wazuh OSSEC Rule

<group name="jenkins,cve-2026-92125,">
  <rule id="100125" level="12">
    <decoded_as>json</decoded_as>
    <field name="script">\.*@GroovyASTTransformationClass\.*</field>
    <description>CVE-2026-92125: Jenkins Script Security Plugin AST Transformation bypass attempt detected</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source).

1. Immediate Mitigations:

   • Restrict the ability to define and run sandboxed scripts to only fully trusted users. Remove "Job/Configure", "Job/Create", and script console permissions from untrusted or low-privileged accounts.
   • Disable the Jenkins script console for all non-administrative users.
   • Audit existing Pipeline jobs and Groovy scripts for any occurrence of @GroovyASTTransformationClass or other AST transformation annotations.
   • Consider using the Jenkins "Authorize Project" plugin to run builds as a less privileged user, though this does not fully mitigate the compile-time execution.
   • Monitor Jenkins audit logs and script-security logs for suspicious annotations or unexpected compilation activity.

2. Patch/Upgrade Steps:

   • No official patch is currently available. Monitor the Jenkins Security Advisories page and the Script Security Plugin repository for updates.
   • Once a patched version is released (expected to be any version after 1415.v9a_f9b_3a_c253d), upgrade the Script Security Plugin immediately via the Jenkins Update Center or by downloading the .hpi file from the Jenkins plugin repository.
   • After upgrading, restart the Jenkins controller to ensure the new plugin is loaded.

3. Long-Term Hardening:

   • Implement a policy of least privilege for all Jenkins users; avoid granting script-definition permissions broadly.
   • Use the Jenkins Configuration as Code (JCasC) plugin to enforce consistent security settings.
   • Deploy a Web Application Firewall (WAF) with rules to block requests containing @GroovyASTTransformationClass in POST bodies (as a defense-in-depth measure).
   • Regularly review and update all Jenkins plugins; subscribe to the Jenkins Security Advisories mailing list.
   • Isolate the Jenkins controller from sensitive networks and limit outbound traffic to reduce post-exploitation impact.

References

1. NVD – CVE-2026-92125: https://nvd.nist.gov/vuln/detail/CVE-2026-92125
2. Jenkins Security Advisories: https://www.jenkins.io/security/advisories/
3. Jenkins Script Security Plugin: https://plugins.jenkins.io/script-security/
4. MITRE ATT&CK T1190 – Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
5. CWE-94 – Improper Control of Generation of Code: https://cwe.mitre.org/data/definitions/94.html

Threat Actor Campaigns / Exploit-in-the-Wild: No known threat actor campaigns or exploit-in-the-wild evidence has been observed for CVE-2026-92125 at the time of this report. CISA KEV catalog does not include this CVE. Continuous monitoring is recommended.