Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with task_runner role
-
DeliveryPOST task with crafted environment JSON
-
ExploitOverride ansible_ssh_common_args ProxyCommand / set ansible_connection=local
-
ExecutionAnsible runs command as Semaphore server user
-
ImpactExfiltrate encryption keys, SSH keys and stored secrets
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V4 - API and Web Service Object attribute protection
|
| Exploitation Conditions | Exploitation requires an authenticated account bearing the task_runner role on a Semaphore UI instance at or below version 2.19.16, plus the ability to POST a task and supply arbitrary keys in the task environment JSON. The concrete trigger is injecting protected Ansible variables - specifically ansible_ssh_common_args carrying a ProxyCommand, or ansible_connection=local - which Semaphore passes through to Ansible unfiltered. Limiting factors: no path to exploitation without a valid task_runner credential (PR:L), so unauthenticated internet attackers cannot exploit it directly; impact is bounded to the Semaphore server user's privileges and the secrets/keys that process can reach. No special non-default configuration is otherwise needed, and no victim user interaction is required. |
| Impact | This is a credible, actionable priority rather than a CVSS-inflated non-issue. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H) scores 8.7 and is internally consistent with the description: a network-reachable web application where an authenticated low-privilege user (task_runner role, hence PR:L) can achieve full-impact remote code execution with no user interaction and low complexity. CWE-915 (improper modification of dynamically-determined attributes) matches the root cause precisely - unfiltered user-supplied keys override protected Ansible variables. Exploitation is confirmed-fixed by vendor PR #3888 and the flaw was reported by VulnCheck, a credible research source, but there is no CISA KEV listing and no EPSS score was supplied, so there is no evidence of active exploitation or mass scanning; treat this as a high-value post-authentication privilege-escalation-to-RCE that an insider or a foothold-holding attacker would weaponize, not an internet-wide worm candidate. The main mitigating signal is PR:L: an attacker must already hold a task_runner account, which bounds the realistic attacker population to existing users or anyone who can obtain such credentials. No signals conflict; the chief missing data points are EPSS and POC status. |
| Exploit ScenarioDerived | An attacker holding (or phishing/credential-stuffing into) a Semaphore account with the task_runner role submits a task whose environment JSON includes ansible_ssh_common_args with an embedded ProxyCommand, or sets ansible_connection=local. When Semaphore runs the task, Ansible executes the injected command as the Semaphore server process user, yielding arbitrary code execution and access to the server's encryption keys, stored SSH keys, and secrets. No public exploit code was identified at time of analysis, and low attack complexity plus no required user interaction make reliable exploitation straightforward once an account is obtained. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Remote code execution in Semaphore UI through 2.19.16 allows an authenticated user holding the task_runner role to escape the intended Ansible execution boundary by placing protected connection variables into a task's environment JSON. Supplying ansible_ssh_common_args with a ProxyCommand, or ansible_connection=local, makes Ansible run attacker-chosen commands as the Semaphore server process user, exposing encryption keys, SSH keys and other stored secrets. The project addressed the issue upstream in pull request #3888, but no tagged patched release number is stated in the available data, and no public exploit code was identified at time of analysis (CVSS 8.7 / assessed CVSS 3.1 8.8, CWE-915).
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - the vendor states a patch is available and the hardening change is carried in https://github.com/semaphoreui/semaphore/pull/3888, so upgrade Semaphore UI past 2.19.16 to the current release containing that PR (track the project releases at https://github.com/semaphoreui/semaphore and the VulnCheck advisory at https://www.vulncheck.com/advisories/semaphore-ui-through-2.19.16-rce-via-task-environment-ansible-variable-override for the fixed build). Until upgraded, treat every task_runner account as effectively equivalent to server-level access: restrict the task_runner role to a small, audited set of trusted operators and remove it from general project members (side effect: reduced self-service automation for those users), and add an admission check or reverse-proxy/API filter that rejects task environment keys beginning with ansible_ (notably ansible_connection, ansible_ssh_common_args, ansible_host, ansible_python_interpreter), accepting that legitimate jump-host ProxyCommand workflows must then be expressed through pre-approved Semaphore inventory/template configuration instead of per-task overrides. Additionally run the Semaphore server and its runners in a container or VM whose filesystem and network reach is limited to the managed hosts it truly needs, mount no unrelated credentials, and rotate the instance encryption key, stored SSH keys and repository/task secrets, since any prior task_runner submission may already have exposed them.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Semaphore UI is an open-source Go web application that fronts Ansible, Terraform/OpenTofu and shell task execution for CI/CD style automation; tasks are submitted through the project tasks API (api/projects/tasks.go) and dispatched by the task runner (services/tasks/TaskRunner.go). The root cause is CWE-915, improperly controlled modification of dynamically-determined object attributes: the task environment JSON is merged into the variables handed to Ansible without a denylist for Ansible's own reserved connection keywords. Because Ansible treats ansible_connection, ansible_ssh_common_args, ansible_host and similar keys as control-plane settings rather than ordinary data, a task_runner can redirect the 'managed host' back to the Semaphore server itself (ansible_connection=local) or tunnel the SSH invocation through an attacker-controlled ProxyCommand, so the playbook's commands execute in the context of the Semaphore server user rather than the intended remote target. That user typically holds the instance's encryption key material, SSH private keys and task/project secrets, turning a low-privilege automation role into full compromise of the control node's secrets. The attack is network-reachable and needs no user interaction, but requires a valid task_runner credential (CVSS PR:L); blast radius is bounded by the privileges and reachable secrets of the Semaphore service account rather than by host-level root access.
Know when Semaphore Ui 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable web app exploitable by a low-privilege task_runner account (PR:L), no user interaction, yielding full-host RCE as the server user, so C/I/A all High; scope unchanged per vendor SC:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Semaphore UI through 2.19.16 contains a remote code execution vulnerability that allows users with the task_runner role to override protected Ansible variables by supplying arbitrary keys in the task environment JSON. Attackers can POST tasks setting ansible_ssh_common_args with a ProxyCommand or ansible_connection=local to execute commands as the Semaphore server user, exposing encryption keys, SSH keys and stored secrets.
Executive ViewAI
Semaphore UI deployments at or below 2.19.16 can allow a legitimate task_runner user to cross the automation boundary and run commands as the Semaphore service account, potentially exposing stored SSH and encryption secrets. Leadership should care because this turns a limited operational role into a path to sensitive infrastructure credentials, affecting any team relying on Semaphore for Ansible automation and increasing the risk of lateral movement and secret compromise.
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
SSVC AssessmentENISA
Priority Score
Attack Technique
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-104397
GHSA-6cr7-7xqc-c37c
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB