/

CVE-2026-32609

Severity:

HIGH RISK

(7.5)

Information Disclosure / Sensitive Data Exposure

CVE-2026-32609

Analyzed

Vulnerability type

Category:

Information Disclosure / Sensitive Data Exposure

CWE:

CWE-200

Impact:

Exposure of authentication secrets and configuration data, enabling follow-on compromise

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Glances exposes sensitive runtime configuration data through the /api/v4/args and /api/v4/args/{item} endpoints, which return the full command-line arguments namespace without robust redaction.

When Glances is run with default settings (without --password), these endpoints can be accessed without authentication, potentially leaking password hashes, SNMP credentials, and configuration paths to an unauthenticated network attacker.

Affected context

This vulnerability appears in Glances deployments that:

  • Expose the REST API, especially /api/v4/args and /api/v4/args/{item}, over a network interface
  • Run without the --password option (the default behavior), leaving the API unauthenticated
  • Include sensitive parameters in process command-line arguments such as:
  • Password hashes (salt + pbkdf2_hmac)
  • SNMP community strings
  • SNMP authentication keys
  • Configuration file paths that may reference additional secrets

In such contexts, any network client able to reach the API can retrieve the arguments namespace and inspect sensitive fields that were not redacted by the earlier configuration secrecy fix.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints exposed by the Glances API (/api/v4/args and /api/v4/args/{item})
  • Required access: Network reachability to the Glances API port; no authentication required when --password is not enabled
  • Trigger point: A basic HTTP GET request to the affected endpoints
  • Why exploitation is possible: The implementation serializes vars(self.args) directly, returning the entire command-line arguments namespace without applying the as_dict_secure() redaction logic, so sensitive fields are disclosed verbatim.

Why this happens

The underlying issue is incomplete protection of sensitive data returned by the API.

While the prior fix added redaction for configuration data via as_dict_secure() on certain endpoints, the /api/v4/args and /api/v4/args/{item} endpoints still expose the raw arguments namespace using vars(self.args).

This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, where sensitive secrets (password hashes, SNMP communities, authentication keys, and configuration paths) are returned to clients without access control or selective filtering.

Conceptually, the design assumes that internal runtime arguments are safe to disclose, but in practice they contain credentials and secret-derived material that should be treated as confidential and either omitted or rigorously redacted before being sent over an unauthenticated channel.

Potential impact

  • Attackers may obtain password hashes (salt + pbkdf2_hmac) and attempt offline cracking.
  • SNMP community strings and authentication keys may be exposed, enabling unauthorized network monitoring or device manipulation.
  • Disclosure of configuration file paths can reveal the filesystem layout and potential locations of other sensitive files.
  • Leaked secrets can facilitate lateral movement, privilege escalation, or unauthorized access to monitored infrastructure.
  • Knowledge of runtime options and flags can assist attackers in tailoring further attacks or evading monitoring.

General mitigation guidance

Mitigation generally focuses on reducing exposure of sensitive runtime metadata and enforcing strict access control around monitoring APIs.

Common defensive patterns include:

  • Treating command-line arguments and configuration-derived values as potentially sensitive, and applying the same redaction logic used for configuration objects to any API that surfaces them.
  • Designing API schemas that avoid returning raw internal objects or unrestricted dumps of argument namespaces, instead exposing only specific, non-sensitive fields.
  • Enforcing authentication and, where appropriate, authorization on administrative or introspection endpoints, even in default configurations.
  • Binding monitoring APIs to trusted interfaces by default (e.g., loopback or management networks) and using network-layer controls (firewalls, reverse proxies, VPNs) to limit who can reach them.
  • Centralizing secret management and avoiding long-lived or high-value secrets on command-line arguments, preferring environment variables or dedicated secret stores with tight access controls.

How teams detect issues like this

Detection efforts can focus on both code-level and deployment-level indicators:

  • Static analysis and code review:
  • Flag endpoints that serialize and return entire internal objects such as vars(args) or similar generic dumps.
  • Look for API handlers that bypass existing redaction or sanitization utilities (e.g., not using a secure as_dict_* variant).
  • Review routes that are reachable without authentication but access configuration, credentials, or process metadata.
  • Configuration and deployment audits:
  • Scan running instances for Glances processes without --password or equivalent access control enabled, especially when bound to non-local interfaces.
  • Use automated tools or scripts to enumerate /api/v4/* endpoints and verify that responses do not contain credentials or hashes.
  • Security policy enforcement:
  • Define CI/CD checks to prevent introduction of new endpoints returning unrestricted debug or configuration dumps.
  • Employ API gateways or WAF rules to restrict or log requests to introspective endpoints for anomaly detection.

Sources

SourceLink
github.comgithub.com/nicolargo/glances/commit/ff14eb9780ee10ec018c754754b1c8c7bfb6c44f
github.comgithub.com/nicolargo/glances/releases/tag/v4.5.2
github.comgithub.com/nicolargo/glances/security/advisories/GHSA-cvwp-r2g2-j824

Frequently asked

questions

Yes, if the Glances API is bound to a network-accessible interface and runs without --password, an unauthenticated remote client can query the affected endpoints and retrieve sensitive data.

The attacker only needs network-level access to the Glances API port. No local shell or prior credentials are required when the default unauthenticated configuration is used.

Apply consistent redaction or omission of sensitive fields whenever internal configuration or arguments are exposed via APIs, and ensure that any endpoints returning potentially sensitive operational data are protected by authentication and least-privilege access controls.

Treat all introspection, debug, and configuration endpoints as high-risk surfaces; design them with explicit schemas that exclude secrets, centralize redaction logic, enforce secure-by-default authentication, and use automated reviews to detect generic object dumps or unfiltered metadata exposure.

Find out what's already
exploitable in your codebase.