/

CVE-2026-72567

Severity:

CRITICAL RISK

(9.8)

Path Traversal (CWE-22) in DeepWiki wiki-cache API Endpoint

CVE-2026-72567

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Write and Deletion

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

A critical path validation vulnerability in DeepWiki's wiki-cache API allows unauthenticated remote attackers to influence filesystem paths through user-controlled repository fields. Under deployments where the service runs with root privileges, an attacker may write to or delete arbitrary files on the host.

Affected context

The vulnerability occurs in the api/api.py wiki-cache endpoint when it builds filesystem paths from user-controlled owner, repo, and repo_type values. Deployments are at risk when the endpoint is remotely reachable, these fields are not constrained to expected repository identifiers, and the service has write or delete permissions beyond its intended cache directory.

Exploit preconditions

  • Attack surface: Remotely accessible wiki-cache API endpoint
  • Required access: No authentication, if the endpoint is exposed as described
  • Trigger point: Processing requests containing user-controlled repository path fields
  • Required conditions: The service must have filesystem permissions affecting the targeted paths
  • Why exploitation is possible: User input is incorporated into filesystem paths without sufficient normalization, containment checks, or allowlisting

Why this happens

The underlying bug is improper path validation, mapped to CWE-22: Improper Limitation of a Pathname to a Restricted Directory. The application treats externally supplied repository identifiers as trusted path components and constructs filesystem locations without reliably enforcing that the resulting path remains within the intended cache directory. This insecure pattern can allow traversal outside the permitted directory and unauthorized filesystem operations.

Potential impact

  • An attacker may write arbitrary files accessible to the service account.
  • An attacker may delete files accessible to the service account.
  • System or application availability may be disrupted.
  • Sensitive data may be overwritten or damaged.
  • Root-level execution or broader host compromise could become possible if writable locations influence privileged services.

General mitigation guidance

Mitigation generally focuses on making filesystem boundaries explicit and reducing trust in request-derived path data.

Common defensive patterns include:

  • Resolve candidate paths and verify that they remain beneath a fixed, dedicated cache directory.
  • Use opaque server-generated identifiers instead of user input as filesystem names.
  • Apply strict allowlists and schema validation to repository fields.
  • Avoid constructing paths directly from raw request values.
  • Run the service as a dedicated unprivileged account with narrowly scoped filesystem permissions.
  • Use separate, restricted storage for cached content and limit deletion operations to owned objects.
  • Fail closed when normalization, validation, or containment checks produce ambiguous results.

How teams detect issues like this

Detection approaches commonly include:

  • Static analysis rules identifying string concatenation or path-joining operations that consume request parameters.
  • Code review checks for missing canonicalization, containment validation, or allowlists before filesystem access.
  • Runtime monitoring for API requests containing traversal indicators or unexpected path-like values.
  • File integrity monitoring for writes and deletions outside the designated cache directory.
  • Policy enforcement requiring non-root service accounts and restricted filesystem permissions.
  • Automated security review tools can help identify path construction using untrusted input, but findings should be validated against deployment behavior.

Sources

SourceLink
github.comgithub.com/AsyncFuncAI/deepwiki-open
github.comgithub.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py

Frequently asked

questions

Yes. If the wiki-cache endpoint is reachable and behaves as described, an attacker may be able to exploit it without authentication by supplying crafted repository field values.

No application-level authentication is necessarily required. However, the scope of impact depends on the filesystem permissions of the DeepWiki process; root execution substantially increases the potential damage.

Constrain all cache operations to a dedicated directory using canonical path resolution and strict containment checks, while preferably replacing user-derived filenames with server-generated identifiers.

Treat request values as untrusted, use allowlisted identifiers, test path-boundary enforcement, and run services with the least filesystem privileges needed.

Find out what's already
exploitable in your codebase.