Skip to main content

Semaphore UI CVE-2026-112305

| EUVDEUVD-2026-104397 HIGH
Improperly Controlled Modification of Dynamically-Determined Object Attributes (CWE-915)
2026-10-19 VulnCheck GHSA-6cr7-7xqc-c37c
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with task_runner role
  2. Delivery
    POST task with crafted environment JSON
  3. Exploit
    Override ansible_ssh_common_args ProxyCommand / set ansible_connection=local
  4. Execution
    Ansible runs command as Semaphore server user
  5. Impact
    Exfiltrate 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Semaphore UI 0 ≤2.19.16

Affected Packages

euvd semaphore_ui no fix

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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 54% exploitable
Prevalence
Low
niche self-hosted Ansible automation UI, limited production enterprise footprint
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy