Severity:

CRITICAL RISK

(9.8)

Path Traversal (CWE-35) in Intrado 911 Emergency Gateway Debug Log Download

CVE-2026-6074

Awaiting Analysis

Vulnerability type

Category:

Path Traversal / Directory Traversal

CWE:

CWE-35

Impact:

Unauthenticated Arbitrary File Read

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

Intrado 911 Emergency Gateway (EGW) versions 5.x, 6.x, and 7.x contain a path traversal flaw in the download_debuglog_file.php endpoint that handles debug log downloads.

By manipulating the name parameter, an unauthenticated attacker can request and read arbitrary files outside the intended log directory, exposing sensitive system and configuration data over the network.

Affected context

The vulnerability affects deployments of Intrado 911 Emergency Gateway (EGW) 5.x, 6.x, and 7.x where the download_debuglog_file.php endpoint is reachable over the network.

The issue occurs in the debug log download functionality, which takes a file name parameter and returns the corresponding log file.

Because path components in this parameter are not sufficiently constrained, the application can be tricked into serving files from outside the intended debug log directory, depending on underlying OS permissions and web server configuration.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing download_debuglog_file.php
  • Required access: None; endpoint is reachable without authentication according to the description
  • Trigger point: Supplying a crafted name parameter value in a request to the debug log download endpoint
  • Why exploitation is possible: The file path is built or accepted using attacker-controlled input without normalizing and strictly validating it against an allowed directory or allowlist, enabling traversal outside the log directory using special path sequences

Why this happens

This issue stems from improper validation and normalization of user-controlled file path input before it is used to access files on the server.

The download_debuglog_file.php script appears to accept a name parameter and use it directly—or with insufficient checks—to locate log files, failing to strip or reject directory traversal tokens and absolute paths.

Conceptually, this maps to CWE-35: Path Traversal, where the software allows external input to influence filesystem paths without enforcing a strict, canonical constraint to an intended directory or set of filenames.

The insecure pattern is trusting filename parameters to select files on disk, instead of binding requests to a predefined set of log files or performing robust canonical path checks against a fixed root.

Potential impact

  • Unauthenticated reading of sensitive configuration files that may contain credentials, API keys, or network details
  • Disclosure of system files that could aid in further attacks, such as privilege escalation or lateral movement
  • Exposure of application source code or PHP scripts, revealing internal logic and other vulnerabilities
  • Leakage of logs or data containing personally identifiable information (PII) or emergency service context where such information exists on accessible paths
  • Facilitation of reconnaissance for subsequent targeted exploitation of the host or surrounding infrastructure

General mitigation guidance

Effective mitigation centers on constraining how filenames are resolved and eliminating direct trust in user-supplied paths:

  • Restrict file access to a dedicated log directory and enforce this constraint by resolving the requested path to its canonical form and verifying it remains within the allowed directory.
  • Replace free-form filename parameters with an allowlist of known log identifiers or IDs that are mapped server-side to actual filenames.
  • Normalize and validate all path input, explicitly rejecting directory traversal patterns, absolute paths, and any path that resolves outside the intended root.
  • Avoid exposing debug-oriented endpoints in production, or protect them behind strong authentication and authorization controls.
  • Run the web application under a minimally privileged account that has read access only to the directories strictly required for operation, reducing the impact of any file disclosure.

How teams detect issues like this

Detection typically involves both code-centric and operational approaches:

  • Static analysis: Flag uses of user-controlled input in filesystem APIs (e.g., fopen, readfile, file_get_contents) where input is not validated against an allowlist or canonical path checks.
  • Code review: Look for download or log-export endpoints that accept arbitrary filenames or paths via query parameters such as file, name, or path, and verify they enforce a strict directory constraint.
  • Security testing: Use web application scanning or manual testing to probe for directory traversal patterns (e.g., encoded ../ sequences) in file download or log access endpoints and confirm actual filesystem exposure.
  • Runtime monitoring: Analyze web server and application logs for suspicious use of traversal sequences in query parameters, which can indicate active probing or exploitation.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-113-06.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-113-06

Frequently asked

questions

It is remotely exploitable as long as the vulnerable download_debuglog_file.php endpoint is exposed over the network; no local shell or file-system access is required.

Based on the description, the endpoint can be reached and abused without authentication, meaning any network-accessible instance is potentially at risk.

The safest pattern is to remove direct user control over filesystem paths by using server-side mappings or allowlists for log identifiers, combined with canonical path verification to ensure all file accesses stay within a dedicated, restricted directory.

Adopt secure file access patterns that never trust raw path input, enforce strong input validation and canonicalization, include traversal checks in code review and automated testing, and avoid exposing diagnostic or debug download endpoints in production without robust access controls.

Find out what's already
exploitable in your codebase.