/

CVE-2026-53611

Severity:

CRITICAL RISK

(9.8)

OS Command Injection (CWE-78) in Looking Glass Platform

CVE-2026-53611

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

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

Looking Glass versions before 1.3.5 contain a critical OS command injection vulnerability caused by an unanchored regular expression in input validation. An attacker who can submit crafted diagnostic input through an exposed API, web interface, or client may be able to influence commands executed by the service.

Affected context

The vulnerability occurs in Looking Glass deployments that process user-controlled network-diagnostic parameters through the platform's gRPC (ConnectRPC) API, embedded SvelteKit interface, or lg-cli client. The risk is greatest when these interfaces are reachable by untrusted users and submitted values are incorporated into operating-system command execution after incomplete validation.

Exploit preconditions

  • Attack surface: Network-accessible Looking Glass API, web UI, or client-facing diagnostic functionality
  • Required access: Ability to submit or influence diagnostic request parameters
  • Trigger point: Processing of attacker-controlled input by the vulnerable validation and command-execution path
  • Why exploitation is possible: An unanchored regular expression may accept input outside the intended format, allowing values to reach an operating-system command context without sufficient separation from command syntax

Why this happens

The underlying bug is insufficient input validation before incorporating externally supplied data into operating-system commands. An unanchored regular expression can match an allowed substring while ignoring additional surrounding content, causing validation to approve values that do not conform to the complete expected format. This behavior maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, because untrusted input can cross a command-execution boundary without reliable structural enforcement.

Potential impact

  • An attacker may execute arbitrary commands with the privileges of the Looking Glass process.
  • The service could be fully compromised.
  • Router credentials, diagnostic data, or network topology information could be exposed.
  • The attacker could alter local data or disrupt diagnostic operations.
  • Compromise could support lateral movement into connected infrastructure.

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from application workflows and making validation complete, strict, and context-aware.

Common defensive patterns include:

  • Prefer direct process-execution APIs with fixed argument arrays instead of invoking a shell.
  • Anchor validation expressions and require complete-string matches against narrowly defined formats.
  • Use allowlists and typed representations for hosts, addresses, protocols, and diagnostic options.
  • Keep user-controlled values separate from executable commands and fixed arguments.
  • Run the service with the least privileges needed to perform diagnostics and restrict access to router credentials.
  • Apply network segmentation and authentication controls to administrative and diagnostic interfaces.

These measures reduce command-injection risk and limit the consequences of validation failures.

How teams detect issues like this

Detection approaches commonly include:

  • Static analysis for shell invocation, command construction, and process-execution calls that receive request-derived data.
  • Code review checks for regular expressions that are not anchored or that validate substrings rather than complete inputs.
  • Tracing data flow from ConnectRPC handlers, web routes, and CLI arguments into operating-system process APIs.
  • Runtime monitoring for unusual child processes, unexpected command arguments, or diagnostic services spawning unrelated programs.
  • Policy enforcement requiring approved command-execution wrappers, strict input schemas, and security review for new diagnostic parameters.

Automated code-review and software-composition tools may help identify related unsafe command-construction patterns.

Sources

SourceLink
github.comgithub.com/AS203038/looking-glass/releases/tag/1.3.5
github.comgithub.com/AS203038/looking-glass/security/advisories/GHSA-8hgf-p844-425m

Frequently asked

questions

It may be remotely exploitable when an attacker can reach a vulnerable Looking Glass API or web interface and submit diagnostic parameters. Exploitability depends on exposure, authentication, and authorization controls.

The attacker generally needs access to a request path that accepts input processed by the vulnerable validation and command-execution logic. The required level of access depends on the deployment's access controls.

Use direct, non-shell process execution with fixed argument boundaries, and validate complete input values using strict allowlists and anchored matching.

Treat all request and CLI input as untrusted, enforce typed schemas, review every data flow into process execution, apply least privilege, and monitor diagnostic services for unexpected child processes.

Find out what's already
exploitable in your codebase.