/

CVE-2026-30828

Severity:

HIGH RISK

(7.5)

Path Traversal / Server-Side Request Forgery (SSRF)

CVE-2026-30828

Analyzed

Vulnerability type

Category:

Path Traversal / Server-Side Request Forgery (SSRF)

CWE:

CWE-22, CWE-29, CWE-918

Impact:

Sensitive Information Disclosure via Local File Access

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

Wallos, a self-hostable personal subscription tracker, contained a flaw where the url parameter could be abused to access local system files instead of just remote resources.

When an attacker can control this parameter, they may trick the application into reading arbitrary files from the host environment, exposing sensitive configuration and runtime data.

Affected context

This vulnerability occurs in deployments of the Wallos subscription tracker where a url parameter is used by the backend to fetch or process resources on behalf of the user.

The issue manifests when user-controlled values are passed directly into file or URL handling routines without strict normalization, validation, or origin restrictions.

Any environment that exposes the affected endpoint to untrusted or semi-trusted users may be impacted, particularly if the application runs with access to sensitive local files or internal network resources.

Exploit preconditions

  • Attack surface: HTTP endpoint(s) that accept a url parameter and trigger backend file or URL retrieval.
  • Required access: Ability to send crafted requests to the Wallos instance (e.g., over the network or via a web client).
  • Trigger point: Supplying a specially crafted url parameter that references local paths or internal endpoints instead of intended remote URLs.
  • Why exploitation is possible: The application trusts and forwards the url parameter directly into file or URL handling APIs without constraining the scheme, location, or path, enabling path traversal and potential SSRF-style behavior.

Why this happens

The underlying flaw stems from treating a user-controlled url parameter as a trusted input for resource access operations.

Instead of enforcing strict allowlists, canonicalization, or path/scheme checks, the backend appears to use the parameter directly with file or network APIs.

This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), in combination with aspects of CWE-29: Path Traversal in Process Variables and CWE-918: Server-Side Request Forgery (SSRF), because untrusted input dictates which local files or internal resources the server reads.

Conceptually, this is an access control failure at the resource layer: the application becomes a proxy that exposes its own filesystem and potentially internal network to the attacker.

Potential impact

  • Access to application configuration files that may contain secrets, API keys, or database credentials
  • Disclosure of environment-specific files, such as logs or OS configuration, aiding further attacks
  • Exposure of source code, enabling targeted exploitation of other bugs
  • Potential SSRF-like access to internal services or metadata endpoints if internal URLs are accepted
  • Collection of reconnaissance data for lateral movement within the hosting environment

General mitigation guidance

Effective mitigation focuses on constraining how user-supplied URLs or paths are interpreted and used:

  • Enforce strict validation of the url parameter, including scheme, host, and path; prefer allowlists of trusted domains or resource identifiers.
  • Avoid passing raw user input directly into filesystem or URL handling APIs; instead, map user choices to predefined, server-side resource identifiers.
  • Normalize and canonicalize paths before use, ensuring they resolve inside an expected base directory and rejecting any that escape it.
  • Separate responsibilities by running the application with least-privilege filesystem and network permissions so that even if misused, damage is limited.
  • Treat any feature that fetches remote or local resources on behalf of users as a high-risk area and design it with a default-deny posture.

How teams detect issues like this

Detection typically relies on examining both code paths and runtime behavior:

  • Static analysis: Flag instances where request parameters (e.g., $_GET['url'], query params, or body fields) flow directly into file access or HTTP client calls without validation or canonicalization.
  • Code review: Look for URL or path parameters used in functions like file readers, stream wrappers, or HTTP clients; verify the presence of allowlists, scheme checks, and base-path enforcement.
  • Dynamic testing: Use security testing or fuzzing tools to send crafted url values (file://, http://localhost, ../../ patterns) and observe whether responses contain unexpected file contents or internal responses.
  • Policy enforcement: Introduce CI/CD rules that require documented validation for any new endpoint that accepts URLs or file paths and integrates with I/O operations.

Sources

SourceLink
github.comgithub.com/ellite/Wallos/commit/e8a513591dbbf885966e2ef55c38622785b9060d
github.comgithub.com/ellite/Wallos/releases/tag/v4.6.2
github.comgithub.com/ellite/Wallos/security/advisories/GHSA-p7qj-669r-grvc

Frequently asked

questions

Yes, if the affected Wallos instance is reachable over the network and exposes the vulnerable endpoint, an attacker can exploit it remotely by sending crafted requests with a malicious url parameter.

An attacker generally only needs the ability to interact with the web interface or API that accepts the url parameter. No local system access is required, though authentication requirements depend on how the instance is configured.

The safest approach is to decouple user input from direct resource access: use strict allowlists of permitted hosts or resource identifiers, canonicalize all paths, enforce base directories, and reject any input that cannot be safely mapped to known, controlled resources.

Treat any user-controlled URL or path as untrusted by default, design resource access APIs with explicit security boundaries (e.g., only internal IDs, not raw paths), incorporate validation libraries and static analysis checks into the development process, and apply least-privilege principles to filesystem and network access.

Find out what's already
exploitable in your codebase.