CVE-2026-68518

Executive Summary

CVE-2026-68518 is an OS command injection vulnerability (CWE-78) in Glances, an open-source cross-platform system monitoring tool, affecting versions prior to 4.5.6. A sanitization bypass in the Mustache templating pipeline (_sanitize_mustache_dict() in glances/actions.py) allows attacker-controlled process or container fields to reconstruct shell operators when rendered by an administrator-configured action template, ultimately resulting in arbitrary command execution via secure_popen(). No CVSS score or EPSS data has been assigned, the CVE is not listed in CISA KEV, and no public exploit or Nuclei template has been confirmed; patch confidence remains low (0/4) despite the NVD description citing 4.5.6 as the fix version.

Technical Analysis

Glances is a Python-based monitoring agent/daemon that collects system telemetry including process lists and container metadata. Administrators can define "action templates" — Mustache-templated commands that render monitored fields into operational actions (e.g., restarting or inspecting a container). The vulnerability sits at the boundary between the rendering library and the shell execution primitive.

The NVD description identifies three key components:

1. _sanitize_mustache_dict() in glances/actions.py — a helper that sanitizes individual Mustache variable values before they are substituted into a template.
2. chevron.render() — the Mustache templating engine invoked to produce the final command string.
3. secure_popen() — the shell execution wrapper that eventually runs the rendered command string.

The flaw is a per-value sanitization bypass. Sanitization is applied independently to each Mustache value, but the template engine concatenates adjacent variables during rendering. When two or more unescaped Mustache variables are rendered adjacently, characters at the boundary between values can recombine into shell operators (e.g., ;, &&, ||, |, backticks, $() that were never present in any single sanitized value. Because each individual value passes the sanitizer, the final rendered string can nevertheless contain a functional shell operator, which secure_popen() then interprets.

Attack surface characteristics:

• The attacker-controlled input is the process or container field (e.g., process name, container name, or related metadata) that Glances ingests from monitored hosts.
• The vulnerable sink is triggered when an administrator-configured action template renders those fields into a shell command.
• The Glances web interface exposes the telemetry and action functionality to the network; unauthenticated or weakly authenticated exposure of the web UI expands the practical attack surface, although the NVD description specifically requires an administrator-configured action template.

No public PoC, exploit code, or Nuclei template has been identified, and the NVD description does not disclose proof-of-concept specifics. The vulnerability class is Mustache template injection leading to OS command injection; the precise operator-reconstruction payloads are not documented in the available data.

Exploitation Scenarios

Exploitation requires a specific but realistic configuration chain. No public PoC exists; the attack chain below is inferred from the vulnerability class and the CVE description.

Step 1 — Reconnaissance / target identification. An attacker enumerates internet-exposed Glances web instances using dorks such as title:Glances, product:Glances, or port:61208 http. A Shodan hit alone is insufficient; the target must also have an action template defined by an administrator and must accept process/container telemetry from hosts the attacker can influence.

Step 2 — Injecting attacker-controlled telemetry. The attacker must cause a monitored host to report a crafted process or container field. For example, on a monitored host where the attacker has low-privileged code execution, a process can be spawned with a crafted name, or a container can be created with a malicious name/metadata field. These fields are harvested by Glances and stored in the telemetry stream that feeds action templates.

Step 3 — Triggering the template render. When an administrator views the dashboard or triggers an action (e.g., a button that runs a pre-defined action template), the template engine (chevron.render()) substitutes the malicious process/container values into the command string. Because _sanitize_mustache_dict() validates each value in isolation, adjacent variables at render time recombine into a shell operator such as ;, &&, `, or $(...). The reconstructed operator escapes the intended command context. The resulting string is handed to secure_popen(), which executes it through the system shell — achieving arbitrary OS command injection with the privileges of the Glances process.

Step 4 — Post-exploitation. The injected command executes on the Glances server host. If Glances is running as root (common in container/VM monitoring deployments), the attacker gains full control of the monitoring server. From there, the attacker can pivot to other monitored endpoints using credentials or agent configuration data, modify or suppress monitoring telemetry to hide further intrusions, and use the monitoring data plane for lateral movement and data exfiltration. Because the injection happens inside the monitoring pipeline, traditional perimeter detection may miss the activity.

Impact Assessment

The primary impact is remote OS command execution on the Glances server, with severity contingent on the privileges of the Glances process and the reachability of the web/action surface.

• Confidentiality: An attacker can read local files, environment variables, and any credentials stored in Glances configuration or monitoring data.
• Integrity: Malicious commands can alter the host, tamper with monitoring data, disable logging agents, or implant backdoors.
• Availability: The attacker can crash or corrupt the Glances process, or use the compromised host as a staging point for broader disruption.
• Blast radius: Compromise of the monitoring infrastructure creates visibility gaps across all monitored hosts; in environments where Glances runs with elevated privileges or with access to orchestration/cloud credentials, the blast radius extends to the entire monitored fleet.
• Scoring: CVSS is officially N/A (no vector assigned). EPSS has not been scored by FIRST.org. The CVE is not in CISA KEV as of this report, indicating no confirmed exploitation-in-the-wild evidence.

Qualitatively, this should be treated as a high-severity command injection vulnerability (CWE-78), especially in deployments that expose the Glances web UI and use administrator-configured action templates. Deployments that do not use action templates have a reduced practical risk.

Detection Guidance

The following detections target the observable artifacts of exploitation: child processes spawned by Glances with suspicious shell metacharacters, network payloads containing Mustache delimiters combined with shell operators, and file/source artifacts referencing the vulnerable sanitization path. Detection engineering teams should tune false positives against legitimate action template usage.

Sigma Rule

title: CVE-2026-68518 - Glances Action Template Command Injection
id: 7d3c9a1e-55b2-4f7a-8c2d-3f9b1e68a042
status: experimental
description: >
  Detects child processes spawned by the Glances process whose command line
  contains shell metacharacters or operator patterns consistent with the
  Mustache template injection described in CVE-2026-68518.
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-68518
author: Valters IT Threat Intelligence
date: 2026/01/01
logsource:
    category: process_creation
    product: linux
detection:
    selection_parent:
        ParentImage|endswith:
            - '/glances'
    selection_cmdline:
        CommandLine|contains:
            - '&&'
            - '||'
            - ';'
            - '`'
            - '$('
            - '${'
    condition: selection_parent and selection_cmdline
falsepositives:
    - Legitimate administrator-configured action templates that intentionally
      execute shell commands with rendered process/container fields
level: high

YARA Rule

rule Glances_Mustache_Command_Injection_Payload
{
    meta:
        author = "Valters IT Threat Intelligence"
        description = "Detects Glances action templates or payloads containing adjacent Mustache variables capable of reconstructing shell operators (CVE-2026-68518)"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-68518"
        cve = "CVE-2026-68518"
        date = "2026-01-01"
    strings:
        $s_sanitize = "_sanitize_mustache_dict" ascii
        $s_render   = "chevron.render" ascii
        $s_popen    = "secure_popen" ascii
        $s_actions  = "glances/actions.py" ascii
        $s_must1    = "{{" ascii
        $s_must2    = "}}" ascii
        $s_op1      = "&&" ascii
        $s_op2      = ";" ascii
        $s_op3      = "|" ascii
        $s_op4      = "`" ascii
        $s_op5      = "$(" ascii
    condition:
        (uint16(0) == 0x5A4D or uint32(0) == 0x464C457F or filesize < 2MB)
        and 2 of ($s_sanitize, $s_render, $s_popen, $s_actions)
        and $s_must1 and $s_must2
        and 1 of ($s_op*)
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-68518 - Glances Mustache Command Injection Attempt"; flow:established,to_server; http_client_body; pcre:"/\{\{[^}]{0,256}?(?:&&|\|\||;|\||`|\$\(|\$\{)/i"; sid:202668518; rev:1; metadata:created_at 2026_01_01, updated_at 2026_01_01, cve CVE-2026-68518;)

Note: the Glances web UI listens on TCP port 61208 by default; operators may add port:61208 to this rule to reduce noise in high-traffic environments.

Elastic Detection

process where process.parent.name == "glances" and
  process.command_line regex~ ".*(;|&&|\\|\\||`|\\$\\(|\\$\\{).*"

Splunk SPL Query

index=main (sourcetype=ProcessRollup2 OR sourcetype=linux_audit OR sourcetype=WinEventLog)
  (ParentProcessName="*glances*" OR parent_process_name="*glances*")
| where match(CommandLine, "(?i)([;&|`]|\\$\\(|\\$\\{)")
| table _time, host, user, ParentProcessName, CommandLine
| sort - _time

Wazuh OSSEC Rule

<group name="glances,">
  <rule id="100685" level="12" frequency="6" timeframe="120">
    <if_sid>80700</if_sid>
    <field name="audit.data.parent_process">glances</field>
    <regex>(\;|\&amp;\&amp;|\|\||\x60|\$\(|\$\{)</regex>
    <description>CVE-2026-68518: Glances spawned a child process with shell metacharacters indicative of action template command injection.</description>
    <mitre>
      <id>T1059</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. The NVD description states the issue is "fixed in 4.5.6," but no patch evidence has been confirmed from any tracked source. The update may exist upstream, but its release artifact has not been verified by the tracking data. Treat the fix as unverified until confirmed from an official Glances release.

1) Immediate mitigations

• Disable or remove administrator-configured action templates that render process or container fields into shell commands, or restrict them to trusted, non-rendered static commands only.
• Restrict network access to the Glances web interface (e.g., firewalls/VPNs); do not expose it to the internet or untrusted networks. The default TCP 61208 port should not be publicly routable.
• Run the Glances daemon with the least privilege possible (dedicated unprivileged service account); avoid running as root in production.
• If Glances is monitored but not actively used with action templates, assume the risk is mitigated but validate the template configuration.

2) Patch/upgrade steps

• Monitor official Glances release channels (project GitHub releases) for version 4.5.6.
• Before deploying, verify the 4.5.6 release artifact exists and that it addresses the sanitization boundary issue; do not assume the fix is present solely because the NVD description claims it.
• Upgrade all Glances instances to 4.5.6 once verified, then re-enable action templates only after testing.
• If 4.5.6 cannot be verified, consider temporarily disabling action templates or isolating Glances hosts until a confirmed patched release is available.

3) Long-term hardening

• Fix the root cause at the code level: perform sanitization on the fully rendered command string immediately before execution, rather than per-value before template rendering.
• Prefer parameterized execution APIs that do not invoke a shell; if shell execution is unavoidable, reject strings containing operator characters after complete template rendering.
• Treat all monitored hosts as untrusted input sources. Process/container names must be considered attacker-influenceable and should never flow into privileged shell commands.
• Enable command-line auditing (auditd, EDR, osquery) across Glances servers and monitor for child process creation with shell metacharacters, as described in the Detection Guidance section.

References

1. NVD entry for CVE-2026-68518: https://nvd.nist.gov/vuln/detail/CVE-2026-68518
2. MITRE CWE-78 — Improper Neutralization of Special Elements used in an OS Command: https://cwe.mitre.org/data/definitions/78.html
3. MITRE ATT&CK Technique T1059 — Command and Scripting Interpreter: https://attack.mitre.org/techniques/T1059/
4. Glances official project repository (release verification for 4.5.6): https://github.com/nicolargo/glances
5. CISA Known Exploited Vulnerabilities catalog (CVE-2026-68518 not listed): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

As of this report, there is no evidence of active threat-actor campaigns exploiting CVE-2026-68518, no public exploit code, and no CISA KEV inclusion. Organizations using Glances with action templates should prioritize the mitigations above while awaiting verified patch confirmation.