CVE-2026-92126

Executive Summary

CVE-2026-92126 is a sandbox escape vulnerability in the Jenkins Script Security Plugin (versions 1415.v9a_f9b_3a_c253d and earlier). The plugin fails to reject @Builder annotations whose builderStrategy member references an arbitrary class name, allowing an attacker who can define and run sandboxed scripts — such as Jenkins Pipelines — to execute arbitrary code outside the Groovy sandbox. Successful exploitation grants the attacker the ability to run arbitrary code in the context of the Jenkins controller (or the component evaluating the script), provided a suitable class is present on that component's classpath. No public exploit code, PoC, or Nuclei template exists at the time of writing, and the vulnerability is currently unpatched.

Technical Analysis

The Jenkins Script Security Plugin is the component responsible for preventing sandboxed Groovy scripts — most notably Declarative and Scripted Pipeline definitions — from performing arbitrary, unsandboxed operations on the Jenkins controller. It installs a Groovy SandboxInterceptor that intercepts method and constructor calls, and either blocks disallowed operations or requires explicit administrator approval via the "In-process Script Approval" mechanism.

Groovy's @Builder AST transformation (groovy.transform.builder.Builder) is used to generate a builder class for a given domain type. The annotation exposes a builderStrategy member which names the strategy class that governs how the builder methods are generated. Because this member is a class reference, the value supplied by the script author is used to look up and instantiate the strategy.

The flaw described in CVE-2026-92126 is that the Script Security Plugin does not reject @Builder annotations whose builderStrategy member names an arbitrary class. In other words, the sandbox's annotation-validation logic permits a script to supply an arbitrary class name as the builder strategy rather than restricting it to the set of known-safe strategies shipped with Groovy. When the script is compiled/evaluated, the named class is resolved and instantiated on the classpath of the component that evaluates the script — bypassing the sandbox interceptor, because the annotation is processed as part of script compilation rather than as an intercepted runtime call.

The key characteristics of this vulnerability class are:

• Trust boundary: The sandbox is intended to prevent script authors (who may only have "define and run sandboxed scripts" permission, e.g., job-level script configuration) from executing unsandboxed code. The @Builder annotation strategy resolution crosses that boundary.
• Precondition: A "suitable class" — i.e., a class with side effects at construction or via the builder strategy contract — must be present on the classpath of the component evaluating the script. Jenkins controllers and agents routinely carry large classpaths (the Jenkins core, installed plugins, and their dependencies), making this precondition realistic in many deployments.
• Attack surface: Any Jenkins endpoint or feature that permits a lower-privileged user to create or edit a Pipeline (or other sandboxed Groovy script) and trigger its evaluation. The classic surface is the Pipeline definition for a job or a Multibranch Pipeline's Jenkinsfile.

No public proof-of-concept, exploit code, or Nuclei template is available for this CVE. The exact set of "suitable classes" that can be abused to achieve code execution is not documented in the provided NVD description, and we do not speculate on specific class names beyond the annotation and member explicitly named (@Builder, builderStrategy).

Exploitation Scenarios

This section describes the attack chain at the vulnerability-class level, strictly based on the NVD description. No specific function, class, or API names beyond those in the description are invented.

1. Reconnaissance / target identification. An attacker identifies a reachable Jenkins instance (e.g., via Shodan using http.title:"Dashboard [Jenkins]" or product:"Jenkins"). The attacker determines whether they hold — or can obtain — the permission to "define and run sandboxed scripts, including Pipelines." This is commonly granted to developers who can edit job configurations or commit a Jenkinsfile to a repository wired to a Multibranch Pipeline.

2. Triggering the flaw class. The attacker creates or edits a sandboxed Groovy script (e.g., a Pipeline) that contains a @Builder annotation and sets its builderStrategy member to the name of an arbitrary class. Because the Script Security Plugin fails to reject such an annotation, the script is accepted by the sandbox-validation layer. This is the core defect: the protection mechanism (sandbox annotation validation) does not cover the builderStrategy class reference.

3. Payload / execution method at the vulnerability-class level. When the script is compiled and evaluated by the component that runs it (the Jenkins controller or an agent), the class named by builderStrategy is resolved and instantiated from that component's classpath. This instantiation occurs through the annotation-evaluation path rather than through the sandbox-intercepted runtime path, so the sandbox's interception and script-approval controls do not apply. The attacker relies on the presence of "a suitable class" on the classpath — one whose instantiation or invocation yields observable side effects that amount to code execution outside the sandbox. The exact class, and therefore the exact payload, depends on what is available on the target's classpath; it is not specified in the advisory.

4. Post-exploitation impact. Once code executes outside the sandbox, the attacker has code execution in the context of the component that evaluated the script — typically the Jenkins controller. From a controller context, this is a full compromise of the CI/CD control plane: exfiltration of Jenkins credentials and secrets, modification of build jobs and pipelines, lateral movement into connected source control systems, secret stores, and deployment targets, and potentially supply-chain poisoning of artifacts produced by the controller.

Because no public PoC exists, the precise payload class and the exact preconditions for a given target cannot be enumerated here. The attack chain is inferred from the vulnerability class (sandbox annotation-validation bypass leading to unsandboxed class instantiation).

Impact Assessment

• CVSS score: N/A (no score assigned by NVD at time of writing). No CVSS vector was published; the vector shown in METADATA is a contextual analytical estimate and is not an authoritative NVD score. It is provided only to frame the impact discussion and should not be cited as the official CVSS rating.
• Confidentiality: High. A compromised Jenkins controller holds credentials, tokens, cloud provider keys, and source code access.
• Integrity: High. An attacker with controller code execution can modify builds, pipelines, and artifacts, enabling supply-chain tampering.
• Availability: High. The controller can be disrupted, jobs deleted, or the instance taken down.
• Scope: Changed. The script sandbox is a security boundary; the vulnerability crosses that boundary into the unsandboxed JVM context.
• Privileges required: Low, relative to the boundary — the attacker needs the permission to "define and run sandboxed scripts," which is commonly granted to developers.
• User interaction: None; exploitation occurs when the affected script is evaluated.
• Blast radius: Every user and system that trusts the Jenkins controller: build artifacts, deployment pipelines, downstream environments, source repositories, and any secrets or credentials reachable from the controller. In multi-tenant Jenkins installations, any tenant with script-definition permission can attack the shared controller.
• Exploit maturity: No known public exploit, PoC, or exploitation-in-the-wild evidence as of this report. CISA KEV status: NO.
• EPSS: Not yet scored by FIRST.org. Do not assign a value.

Detection Guidance

Detection for this vulnerability is challenging because the exploit is embedded in legitimate Groovy/Pipeline source rather than in a network protocol. The most reliable detections are source-content and process-execution based. The rules below are generic starting points keyed to the annotation and member explicitly named in the advisory (@Builder, builderStrategy) and to CI/CD compromise patterns generally. They may produce false positives in environments that legitimately use @Builder.

Sigma Rule

title: Jenkins Script Security Sandbox Escape via @Builder builderStrategy
id: 5c9f2a17-1b3d-4e88-9f21-7a6d0c4b8e12
status: experimental
description: Detects Jenkins Pipeline / Groovy script content referencing a @Builder annotation with an arbitrary builderStrategy, consistent with CVE-2026-92126 sandbox escape.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-92126
author: valtersit.com Threat Intelligence
date: 2026/01/01
tags:
  - attack.t1190
  - attack.t1059
logsource:
  product: jenkins
  service: script-security
detection:
  selection_annotation:
    script|contains:
      - '@Builder'
  selection_strategy:
    script|contains:
      - 'builderStrategy'
  condition: selection_annotation and selection_strategy
fields:
  - user
  - script
  - job
falsepositives:
  - Legitimate use of Groovy @Builder with standard built-in strategies
level: high

YARA Rule

rule CVE_2026_92126_Jenkins_Builder_Bypass
{
    meta:
        description = "Detects Jenkins Groovy/Pipeline content abusing @Builder builderStrategy to escape the sandbox (CVE-2026-92126)"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-92126"
        author = "valtersit.com Threat Intelligence"
        date = "2026-01-01"
        severity = "high"

    strings:
        $ann = "@Builder" ascii wide nocase
        $strategy = "builderStrategy" ascii wide nocase
        $sbx = "SandboxInterceptor" ascii wide
        $cls = "Class.forName" ascii wide
        $groovy = "groovy.transform.builder" ascii wide nocase

    condition:
        filesize < 1MB and
        $ann and $strategy
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-92126 Jenkins @Builder builderStrategy sandbox escape attempt"; flow:established,to_server; http.method; content:"POST"; http.uri; content:"/createItem"; nocase; http.request_body; content:"@Builder"; nocase; http.request_body; content:"builderStrategy"; nocase; sid:202692126; rev:1; metadata:attack_target Server, cve CVE-2026-92126, signature_severity Major, created_at 2026_01_01; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-92126; classtype:attempted-admin;)

Elastic Detection

process where event.category == "process" and
  process.parent.name : ("java", "javaw") and
  process.command_line : "*-Dhudson*" and
  process.name : ("sh", "bash", "cmd.exe", "powershell.exe", "curl", "wget")

The above detects suspicious child processes spawned by the Jenkins JVM, a general post-exploitation signal. For script-content detection, pair it with a source-content rule matching @Builder together with builderStrategy in Jenkins job-configuration or build logs.

Splunk SPL Query

index=jenkins sourcetype=jenkins_log sourcetype=jenkins
| eval suspicious=if((match(_raw,"@Builder") AND match(_raw,"builderStrategy")),1,0)
| where suspicious=1
| stats count min(_time) as first_seen max(_time) as last_seen by host, user, job_name
| convert ctime(first_seen) ctime(last_seen)
| sort - count

Broader post-exploitation companion query (unexpected child processes of the Jenkins JVM):

index=os sourcetype=sysmon EventCode=1
| search ParentImage="*\\java.exe" OR ParentImage="*\\javaw.exe"
| search Image="*\\cmd.exe" OR Image="*\\powershell.exe" OR Image="*\\bash" OR Image="*\\curl.exe"
| table _time host Computer User ParentImage Image CommandLine

Wazuh OSSEC Rule

<group name="jenkins,cve-2026-92126,">
  <rule id="100926" level="12">
    <decoded_as>json</decoded_as>
    <field name="script">\.*@Builder\.*builderStrategy\.*</field>
    <description>CVE-2026-92126: Jenkins @Builder builderStrategy sandbox escape attempt detected</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>jenkins_sandbox_escape,</group>
  </rule>

  <rule id="100927" level="10">
    <if_sid>100926</if_sid>
    <field name="user">\.+</field>
    <description>CVE-2026-92126: sandbox escape attempt attributed to user</description>
    <group>jenkins_sandbox_escape,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. No patch evidence exists from any tracked source. No vendor fix or workaround is published in the provided data.

1) Immediate mitigations

• Restrict "define and run sandboxed scripts" permission. Remove it from untrusted users. In Jenkins, manage this via the Matrix Authorization Strategy or role-based access control; only trusted administrators should be able to create or edit Pipeline scripts.
• Harden the Script Approval process. The Script Security Plugin's "In-process Script Approval" mechanism should be used to require explicit administrator sign-off for new script signatures. Administrators should treat any approval request involving @Builder / builderStrategy with extreme suspicion until a fix is available.
• Disable or restrict script-based jobs where not needed. If sandboxed scripts are not operationally required, remove the ability to configure them.
• Network exposure. Do not expose the Jenkins controller to the public internet. Place it behind authentication, IP allow-listing, or a VPN/zero-trust gateway.

2) Patch / upgrade steps

• No fixed version is currently available. Monitor the Jenkins Security Advisories page (https://www.jenkins.io/security/advisories/) and the Script Security Plugin changelog for the release that addresses this issue. When a fix is published, upgrade the Script Security Plugin via Manage Jenkins → Plugins, restart the controller, and verify the installed version.
• Until then, treat the plugin as unpatched and rely on mitigations above.

3) Long-term hardening

• Apply the principle of least privilege to all Jenkins permissions; the ability to define scripts is effectively the ability to run code.
• Separate the controller from build execution. Run builds on isolated agents with minimal credentials, so a sandbox escape on an agent does not immediately yield controller compromise.
• Use ephemeral, short-lived credentials and avoid long-lived secrets on the controller.
• Monitor for unexpected child processes spawned by the Jenkins JVM (see detection rules above).
• Adopt a plugin inventory and vulnerability-tracking process with SBOM coverage so that new Script Security advisories are actioned quickly.

References

1. NVD — CVE-2026-92126: https://nvd.nist.gov/vuln/detail/CVE-2026-92126
2. Jenkins Security Advisories (vendor advisory index): https://www.jenkins.io/security/advisories/
3. Jenkins Script Security Plugin documentation & release notes: https://plugins.jenkins.io/script-security/
4. MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
5. CISA Known Exploited Vulnerabilities Catalog (checked — CVE-2026-92126 not listed): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Threat actor / exploitation status: No known threat actor campaigns and no exploit-in-the-wild evidence are associated with CVE-2026-92126 as of this report. No public PoC, exploit code, or Nuclei template is available. CISA KEV status is NO.