Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain account with Agent/Configure permission
-
DeliveryConfigure agent with crafted legacy launch command
-
ExploitJenkins converts command without approval check
-
ExecutionCommand executes in controller JVM
-
ImpactArbitrary code execution on Jenkins controller
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires the attacker to hold Jenkins Agent/Configure permission and to supply an agent configuration containing a legacy-style launch command, which Jenkins 2.587/LTS 2.580.1 and earlier auto-converts into a Command Agent Launcher without verifying administrator approval of that command. Limiting factors: the attacker must be an authenticated user with the elevated Agent/Configure permission (not anonymous and not a bystander), so blast radius is bounded by how broadly that permission is delegated; the flaw exists only in versions from Jenkins 2.86 / LTS 2.89.1 up to 2.587 / LTS 2.580.1 because the conversion path originates from the move of this functionality into the Command Agent Launcher Plugin. The vendor states the fix is upgrading to Jenkins 2.588 or LTS 2.580.2; no separate configuration mitigation is given for this issue. |
| Impact | No CVSS vector, EPSS score, KEV entry, or PoC reference is provided in the input for CVE-2026-117614; the vuln.today Decision label is 'awaiting_data', so the usual exploitation-probability and prioritization signals are absent. The only severity signal is the Jenkins CNA's qualitative rating of 'High' for the other core issues in the same advisory (the advisory text captured here cuts off before the SECURITY-4123 severity line, so its specific CVSS was not retrieved). What IS firmly established from the vendor advisory is the mechanism and the privilege requirement: the backward-compatibility conversion of legacy agent launch commands into Command Agent Launcher Plugin launchers does not re-check administrator approval, so an attacker holding Agent/Configure permission can run arbitrary code in the Jenkins controller JVM - a controller-level RCE, which is among the most impactful outcomes in a CI/CD system. The real-world risk is therefore gated almost entirely by who holds Agent/Configure: this is not an anonymous or low-privilege remote flaw, so it is a privileged-insider / compromised-account escalation to full controller takeover rather than a mass-exploitable internet-facing bug. Treat it as a genuine priority in environments that delegate Agent/Configure to many or semi-trusted users, but the absence of KEV/EPSS/PoC data and the required elevated permission argue against emergency-level urgency. Note explicitly: exploitation probability is UNKNOWN here because EPSS and KEV data were not supplied, not because risk is confirmed low. |
| Exploit ScenarioDerived | An attacker who has been granted (or has compromised an account with) Agent/Configure permission creates or reconfigures an agent using a legacy-style launch command. When Jenkins converts that configuration into a Command Agent Launcher, it skips the administrator-approval check, so the attacker's command executes in the controller JVM, yielding remote code execution on the Jenkins controller. No public exploit is identified in the provided data, and no user interaction by an administrator is described as required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Arbitrary code execution in the Jenkins controller JVM is possible for users holding Agent/Configure permission on Jenkins 2.587 and earlier and LTS 2.580.1 and earlier, because legacy agent launch commands carried over from Jenkins core are converted into Command Agent Launcher Plugin launchers without verifying that an administrator approved the command. The issue affects builds from Jenkins 2.86 / LTS 2.89.1 onward, where that launch functionality moved into the plugin, and is resolved only by upgrading to Jenkins 2.588 or LTS 2.580.2; no separate configuration workaround is documented for this specific issue. Exploitation requires an authenticated account with the elevated Agent/Configure permission, so the practical blast radius depends on how broadly that permission is delegated in a given installation; no public exploit code, EPSS score, or CISA KEV entry was identified at time of analysis, and the vulnerability remains at an 'awaiting data' prioritization state.
RemediationAI
Upgrade to Jenkins 2.588 (weekly) or Jenkins LTS 2.580.2, the releases that contain the fix for SECURITY-4123 / CVE-2026-117614; the vendor provides no separate configuration-level mitigation for this specific issue, so patching is the complete remediation. Plan the upgrade alongside the other core fixes published in the same advisory (https://www.jenkins.io/security/advisory/2026-10-28/), since several of those CVEs share the config.xml and Agent/Configure attack surface. Where an immediate upgrade is not feasible, the only lever supported by the described prerequisites is to tighten authorization: exploitation requires an authenticated user holding Agent/Configure permission, so review and restrict that permission to a small set of trusted administrators and audit agent configurations for unexpected legacy launch commands. The trade-off is that narrowing Agent/Configure blocks delegated agent administration for regular users and may disrupt legitimate workflows; it reduces exposure to this issue but does not remove the underlying flaw, and it should be treated as temporary until the upgrade to 2.588 or LTS 2.580.2 is applied.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Jenkins agents can be started by executing a command on the controller, and since Jenkins 2.86 / LTS 2.89.1 that capability has lived in the Command Agent Launcher Plugin rather than in core. For backward compatibility, Jenkins 2.587 and earlier / LTS 2.580.1 and earlier transparently rewrite launch commands found in older agent configurations into launchers supplied by that plugin. That rewrite path skips the plugin's administrator-approval step, so a configuration-submitted command is treated as trusted and executed inside the controller JVM. The root cause class is a missing authorization/approval enforcement step on a backward-compatibility code path rather than a memory-safety or parsing defect; no CWE identifier or CVSS vector is supplied in the source advisory data, and the independent assessment scores the issue CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, reflecting a network-reachable interface reachable only by a highly privileged authenticated user with full confidentiality, integrity, and availability impact on the controller. The flaw is scoped to versions spanning Jenkins 2.86 through 2.587 and LTS 2.89.1 through 2.580.1, since the conversion logic exists only because of the earlier migration of this functionality into the plugin.
Know when Jenkins gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Remotely reachable over HTTP (AV:N) with no special timing (AC:L), but requires the elevated Agent/Configure permission (PR:H) and no user interaction, yielding full controller-JVM RCE (C/I/A:H).
Description PRE-NVD
Executive ViewAI
CVE-2026-117614 is a critical arbitrary code execution vulnerability in Jenkins controller affecting versions 2.587 and earlier and LTS 2.580.1 and earlier. Users with Agent/Configure permission can execute arbitrary code without administrator approval. Organizations relying on Jenkins for CI/CD face potential full controller compromise if this permission is over-delegated, threatening build integrity and software supply chain security.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
Attack Technique
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
A sandbox bypass vulnerability exists in Jenkins Pipeline: Groovy Plugin 2.63 and earlier in pom.xml, src/main/java/org/
The Jenkins CLI subsystem in Jenkins before 1.638 and LTS before 1.625.2 allows remote attackers to execute arbitrary co
The remoting module in Jenkins before 2.32 and LTS before 2.19.3 allows remote attackers to execute arbitrary code via a
Multiple unspecified API endpoints in Jenkins before 1.650 and LTS before 1.642.2 allow remote authenticated users to ex
The Fingerprints pages in Jenkins before 1.638 and LTS before 1.625.2 might allow remote attackers to obtain sensitive j
The remoting module in Jenkins before 1.650 and LTS before 1.642.2 allows remote attackers to execute arbitrary code by
A sandbox bypass vulnerability exists in Jenkins Script Security Plugin 1.53 and earlier in src/main/java/org/jenkinsci/
A code execution vulnerability exists in the Stapler web framework used by Jenkins 2.153 and earlier, LTS 2.138.3 and ea
A sandbox bypass vulnerability exists in Jenkins Script Security Plugin 1.50 and earlier in src/main/java/org/jenkinsci/
A sandbox bypass vulnerability exists in Pipeline: Declarative Plugin 1.3.3 and earlier in. Rated high severity (CVSS 8.
A sandbox bypass vulnerability exists in Pipeline: Groovy Plugin 2.61 and earlier in src/main/java/org/jenkinsci/plugins
EUVD-2026-112179
GHSA-c765-qv4h-jc48
CVE.org
Exploit-DB