CVE-2026-92122

Executive Summary

CVE-2026-92122 is a sandbox bypass vulnerability in the Jenkins Script Security Plugin, affecting versions up to and including 1415.v9a_f9b_3a_c253d. Authenticated attackers with permission to define and run sandboxed scripts, including Pipelines, can exploit improper method resolution when a script coerces a value to an interface to execute arbitrary code in the context of the Jenkins controller JVM. With a CVSS score of 8.8 (High) and no public exploit or patch currently available, this flaw poses a significant risk to Jenkins environments where script authoring privileges are broadly granted.

Technical Analysis

The vulnerability resides in the Jenkins Script Security Plugin's handling of Groovy proxy objects created during sandboxed script execution. When a sandboxed script coerces a value to an interface, the plugin generates a dynamic proxy that intercepts method calls. The plugin's sandbox enforcement normally checks whether the called method is permitted under the script security sandbox. However, the code fails to verify the method actually invoked on the proxy when the underlying value inherits a method of the same name as an interface method. This allows an attacker to define a class or use an existing class that extends a permitted interface, overriding or inheriting methods that are not themselves subject to the same sandbox restrictions.

Because the sandbox check is applied to the interface method signature rather than the concrete implementation, the attacker can craft a script that calls a method through the interface proxy, causing the sandbox to approve the call based on the interface method name. The proxy then dispatches to the inheriting class's method, which may contain arbitrary code or invoke unsafe operations. This bypasses the sandbox protection entirely, granting the attacker the ability to execute arbitrary Java/Groovy code within the Jenkins controller JVM. The vulnerability class is an incomplete method resolution check, falling under CWE-693 (Protection Mechanism Failure).

The attack surface is limited to authenticated users who possess the "Overall/Read" permission and the "Job/Configure" or equivalent permission to define and run sandboxed scripts, such as Pipelines. Jenkins typically grants these permissions to developers or build engineers, making the vulnerability exploitable from within the trusted development team or by any compromised account with those privileges. The flaw does not require user interaction beyond executing the malicious script and can be exploited over the network via the Jenkins web interface or API.

Exploitation Scenarios

1. Reconnaissance and target identification: The attacker identifies a Jenkins instance running a vulnerable version of the Script Security Plugin (1415.v9a_f9b_3a_c253d or earlier). This can be done through version detection via the Jenkins web UI (e.g., the "About Jenkins" page or plugin manager) or by analyzing HTTP responses. The attacker must have valid credentials with permissions to create or modify a Pipeline job or run scripts in the Script Console.

2. Triggering the flaw: The attacker crafts a Groovy script that defines or reuses a class implementing an interface that is allowed by the sandbox. The script then coerces an object to that interface, creating a proxy. By invoking a method through the interface reference, the attacker leverages the inherited method of the same name from a malicious class. The sandbox check inspects the interface method's signature and approves it, but the actual execution flows to the attacker-controlled method.

3. Payload execution: The malicious method contains code that performs arbitrary operations, such as executing system commands ("command".execute()), reading sensitive files, or establishing a reverse shell. Because the sandbox is bypassed, the code runs with the full privileges of the Jenkins controller JVM, typically as the jenkins user or SYSTEM/root depending on the installation.

4. Post-exploitation impact: The attacker gains arbitrary code execution on the Jenkins controller. This allows for full compromise of the Jenkins instance, including access to credentials stored in Jenkins, the ability to modify jobs, pivot to connected build agents, and potentially move laterally within the network. The attacker can also install persistent backdoors, exfiltrate source code, or disrupt CI/CD pipelines.

No public PoC is available; the attack chain is inferred from the vulnerability class and the NVD description. The exact method names or interface names are not provided in the description, so specific implementation details cannot be confirmed without further analysis.

Impact Assessment

The CVSS v3.1 vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, resulting in a base score of 8.8 (High). The attack is network-exploitable (AV:N) with low complexity (AC:L) and requires low privileges (PR:L) — specifically, the ability to define and run sandboxed scripts. No user interaction is needed (UI:N). The scope is unchanged (S:U), but the impact on confidentiality, integrity, and availability is high (C:H/I:H/A:H). Successful exploitation leads to complete compromise of the Jenkins controller, affecting all jobs, credentials, and connected systems. The blast radius includes any downstream systems that trust the Jenkins instance, such as production deployment targets, artifact repositories, and code signing services. The vulnerability is particularly dangerous in environments where many users have script authoring permissions, as it enables privilege escalation from a limited developer role to full administrative control.

Detection Guidance

Sigma Rule

title: Jenkins Script Security Sandbox Bypass - CVE-2026-92122
id: 3f7a2b1c-9d4e-4f5a-8b6c-7e8f9a0b1c2d
status: experimental
description: Detects attempts to exploit CVE-2026-92122 by monitoring for suspicious Groovy script execution in Jenkins logs that indicates interface coercion and method resolution bypass.
author: Valters IT Threat Intelligence
date: 2026-06-01
logsource:
  product: jenkins
  service: script-security
detection:
  selection:
    EventID: 'ScriptSecurity'
    Message|contains:
      - 'coerce'
      - 'interface'
      - 'proxy'
      - 'sandbox bypass'
  condition: selection
falsepositives:
  - Legitimate scripts that use interface coercion in a benign manner
level: high
tags:
  - attack.t1190
  - cve.2026-92122

YARA Rule

rule CVE_2026_92122_Jenkins_Sandbox_Bypass
{
    meta:
        description = "Detects Groovy script patterns indicative of CVE-2026-92122 exploitation attempt"
        author = "Valters IT Threat Intelligence"
        date = "2026-06-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-92122"
        hash = "unknown"
    strings:
        $s1 = "as " ascii wide
        $s2 = "interface" ascii wide
        $s3 = "proxy" ascii wide
        $s4 = "execute()" ascii wide
        $s5 = "Runtime.getRuntime()" ascii wide
        $s6 = "ProcessBuilder" ascii wide
    condition:
        (uint16(0) == 0x0A0D or uint16(0) == 0x0A) and
        all of ($s1, $s2, $s3) and any of ($s4, $s5, $s6)
}

Suricata IDS Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"Possible Jenkins Script Security Sandbox Bypass CVE-2026-92122"; flow:to_server,established; content:"POST"; http_method; content:"/scriptText"; http_uri; content:"script"; http_client_body; pcre:"/interface|coerce|proxy|ProcessBuilder|Runtime\.getRuntime\(\)/i"; reference:cve,2026-92122; classtype:attempted-admin; sid:10000001; rev:1;)

Elastic Detection

process where event.type == "start" and process.parent.name == "java" and process.parent.args : "*jenkins*" and process.args : ("*groovy*" or "*script*") and process.args : ("*execute*" or "*Runtime*" or "*ProcessBuilder*")

Splunk SPL Query

index=jenkins_logs source="*script*" OR source="*pipeline*"
| search ("coerce" OR "interface" OR "proxy") AND ("execute" OR "Runtime" OR "ProcessBuilder")
| stats count by user, job_name, script, _time
| where count > 0
| sort - _time

Wazuh OSSEC Rule

<group name="jenkins,">
  <rule id="100200" level="12">
    <decoded_as>json</decoded_as>
    <field name="event_type">ScriptSecurity</field>
    <field name="message">\.*(coerce|interface|proxy|execute|Runtime|ProcessBuilder)</field>
    <description>CVE-2026-92122: Possible Jenkins Script Security sandbox bypass attempt</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 permissions to define and run sandboxed scripts (e.g., Pipeline jobs, Script Console) to only the most trusted administrators. Remove "Job/Configure" and "Overall/Read" from untrusted users where possible.
   • Disable the Jenkins Script Console for non-administrators by configuring the "Groovy" script approval settings or using the "Script Security" plugin's deny list to block dangerous method calls, though this may not fully mitigate the bypass.
   • Monitor for suspicious script execution patterns as outlined in the detection guidance.
   • Consider implementing network segmentation to limit access to the Jenkins controller UI and API.

2. Patch/upgrade steps:

   • No official patch is currently available. Monitor the Jenkins Security Advisory page and the Script Security Plugin changelog for updates. When a fixed version is released, upgrade immediately.
   • As a temporary measure, consider upgrading to a non-vulnerable version if one is released, or applying mitigation through the plugin's configuration.

3. Long-term hardening:

   • Follow the principle of least privilege: grant script authoring permissions only to users who absolutely require them.
   • Enable audit logging for all script executions and regularly review logs for anomalies.
   • Use a sandboxed environment for Jenkins controllers, such as running the controller in a container with limited privileges and no direct network access to sensitive systems.
   • Keep Jenkins and all plugins up to date, and subscribe to security advisories.
   • Implement a Web Application Firewall (WAF) with rules to detect and block malicious script payloads, though this may be bypassed.

References

1. NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-92122
2. Jenkins Security Advisories: https://www.jenkins.io/security/advisories/
3. Script Security Plugin Documentation: https://plugins.jenkins.io/script-security/
4. CWE-693: Protection Mechanism Failure: https://cwe.mitre.org/data/definitions/693.html
5. MITRE ATT&CK T1190: https://attack.mitre.org/techniques/T1190/

There is currently no evidence of exploit-in-the-wild or threat actor campaigns targeting this specific CVE. The vulnerability is not listed in CISA KEV.