/

CVE-2026-120324

Severity:

HIGH RISK

(8.3)

Path Traversal (CWE-22) in Zilla HTTP Filesystem Binding

CVE-2026-120324

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Potential unauthorized access to files outside the intended directory

Severity:

HIGH RISK

(8.3)

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

A path traversal weakness in Aklivity Zilla's HTTP filesystem binding allows a remotely supplied parameter to influence path resolution. If a request can reach the affected functionality, an attacker may cause paths to resolve outside the intended filesystem area, with the consequences depending on the operation and the service's permissions.

A path traversal weakness in Aklivity Zilla's HTTP filesystem binding allows a remotely supplied parameter to influence path resolution. If a request can reach the affected functionality, an attacker may cause paths to resolve outside the intended filesystem area, with the consequences depending on the operation and the service's permissions.

Affected context

The issue is in Path.resolve in FileSystemServerFactory for the HTTP filesystem binding. It affects the specified Zilla release lines up to 1.3.4, 2.4.7, and 2.5.0-rc2. Risk depends on whether the binding is reachable and on the filesystem permissions available to the Zilla process.

The issue is in Path.resolve in FileSystemServerFactory for the HTTP filesystem binding. It affects the specified Zilla release lines up to 1.3.4, 2.4.7, and 2.5.0-rc2. Risk depends on whether the binding is reachable and on the filesystem permissions available to the Zilla process.

Exploit preconditions

  • Attack surface: A remotely reachable HTTP filesystem binding
  • Required access: The ability to send requests to the affected binding; whether authentication is required depends on deployment configuration
  • Trigger point: Processing a request whose params argument influences path resolution
  • Why exploitation is possible: The resolved path can escape its intended location if traversal inputs are not safely constrained
  • Attack surface: A remotely reachable HTTP filesystem binding
  • Required access: The ability to send requests to the affected binding; whether authentication is required depends on deployment configuration
  • Trigger point: Processing a request whose params argument influences path resolution
  • Why exploitation is possible: The resolved path can escape its intended location if traversal inputs are not safely constrained

Why this happens

The path-resolution logic allows externally influenced parameters to affect filesystem paths without sufficiently ensuring that the final resolved path remains within the intended directory. This is a path traversal weakness mapped to CWE-22: Improper Limitation of a Pathname to a Restricted Directory. The insecure pattern is trusting a constructed path without enforcing its boundary against the permitted filesystem root.

The path-resolution logic allows externally influenced parameters to affect filesystem paths without sufficiently ensuring that the final resolved path remains within the intended directory. This is a path traversal weakness mapped to CWE-22: Improper Limitation of a Pathname to a Restricted Directory. The insecure pattern is trusting a constructed path without enforcing its boundary against the permitted filesystem root.

Potential impact

  • A requester may be able to access files outside the intended directory, subject to filesystem permissions and binding behavior.
  • Sensitive data could be exposed if readable files are reachable through the affected operation.
  • Files could potentially be modified or removed if the operation permits it and the process has sufficient permissions.
  • Unexpected paths may cause service errors or disruption.
  • A requester may be able to access files outside the intended directory, subject to filesystem permissions and binding behavior.
  • Sensitive data could be exposed if readable files are reachable through the affected operation.
  • Files could potentially be modified or removed if the operation permits it and the process has sufficient permissions.
  • Unexpected paths may cause service errors or disruption.

General mitigation guidance

Defensive approaches focus on keeping filesystem operations within an explicit, trusted directory boundary.

  • Resolve paths against a configured root and verify that the final canonical path remains within that root.
  • Prefer APIs that enforce directory-relative access and reject traversal outside the permitted area.
  • Treat request parameters as untrusted; avoid relying only on string filtering or normalization.
  • Limit the service account's filesystem permissions and expose only necessary directories.
  • Use secure-by-default binding configuration that restricts filesystem scope and minimizes remotely reachable operations.

Defensive approaches focus on keeping filesystem operations within an explicit, trusted directory boundary.

  • Resolve paths against a configured root and verify that the final canonical path remains within that root.
  • Prefer APIs that enforce directory-relative access and reject traversal outside the permitted area.
  • Treat request parameters as untrusted; avoid relying only on string filtering or normalization.
  • Limit the service account's filesystem permissions and expose only necessary directories.
  • Use secure-by-default binding configuration that restricts filesystem scope and minimizes remotely reachable operations.

How teams detect issues like this

  • Use static analysis to identify request-controlled values flowing into path-resolution and filesystem APIs.
  • Review code for path checks performed before canonical resolution, prefix-only boundary checks, or missing root containment checks.
  • Test that normalized paths remain within the configured root, including encoded, nested, and platform-specific path forms.
  • Apply policy checks requiring explicit filesystem boundaries and least-privilege runtime permissions.
  • Use static analysis to identify request-controlled values flowing into path-resolution and filesystem APIs.
  • Review code for path checks performed before canonical resolution, prefix-only boundary checks, or missing root containment checks.
  • Test that normalized paths remain within the configured root, including encoded, nested, and platform-specific path forms.
  • Apply policy checks requiring explicit filesystem boundaries and least-privilege runtime permissions.

Sources

SourceLink
github.comgithub.com/0xGenesi/CVE/blob/main/Zilla_Http_Filesystem_Binding_Path_Traversal.md
github.comgithub.com/aklivity/zilla/
github.comgithub.com/aklivity/zilla/commit/46a8b15cbea157f7ae8b7cb865809a02fd6b1988
github.comgithub.com/aklivity/zilla/pull/2623
github.comgithub.com/aklivity/zilla/releases/tag/2.5.0-rc3
vuldb.comvuldb.com/cve/CVE-2026-120324
vuldb.comvuldb.com/submit/1015032
vuldb.comvuldb.com/vuln/429656
vuldb.comvuldb.com/vuln/429656/cti

Frequently asked

questions

The reported issue is remotely exploitable when an attacker can reach the affected HTTP filesystem binding and influence the parameters used for path resolution.

The attacker needs access to the relevant binding. Authentication requirements depend on the deployment's configuration; the Zilla process's filesystem permissions also affect possible outcomes.

Ensure every resolved path remains within an explicit trusted root, using canonical path checks or directory-relative APIs that enforce this boundary.

Treat request-derived paths as untrusted, test boundary enforcement, restrict filesystem permissions, and review data flows into filesystem APIs.

The reported issue is remotely exploitable when an attacker can reach the affected HTTP filesystem binding and influence the parameters used for path resolution.

The attacker needs access to the relevant binding. Authentication requirements depend on the deployment's configuration; the Zilla process's filesystem permissions also affect possible outcomes.

Ensure every resolved path remains within an explicit trusted root, using canonical path checks or directory-relative APIs that enforce this boundary.

Treat request-derived paths as untrusted, test boundary enforcement, restrict filesystem permissions, and review data flows into filesystem APIs.

Find out what's already
exploitable in your codebase.