/

CVE-2026-33407

Severity:

CRITICAL RISK

(9.1)

SSRF in Wallos logos/search Endpoint

CVE-2026-33407

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918, CWE-922

Impact:

Server-Side Request Forgery with Potential Internal Network Access

Severity:

CRITICAL RISK

(9.1)

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 subscription tracker, contains a server-side request forgery (SSRF) vulnerability where the logos/search endpoint respects HTTP_PROXY and HTTPS_PROXY environment variables without validation.

An attacker who can influence these proxy settings or crafted search terms can cause the server to perform outbound DNS lookups and HTTP requests to arbitrary domains, potentially reaching internal or otherwise unreachable services.

Affected context

This vulnerability affects Wallos deployments exposing the endpoints/logos/search.php functionality where:

  • The application process honors HTTP_PROXY and HTTPS_PROXY environment variables at runtime.
  • User-supplied search terms are used in server-side DNS resolution and outbound HTTP requests.
  • Network egress from the Wallos server to the internet or internal services is permitted by firewall rules.

The issue becomes particularly sensitive when Wallos runs on hosts with access to internal infrastructure or metadata services.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing endpoints/logos/search.php to users or the internet.
  • Required access: Ability to send requests to the logos search endpoint; in some deployments, ability to influence process environment or configuration that sets HTTP_PROXY / HTTPS_PROXY.
  • Trigger point: Submitting crafted search terms while the application is running with attacker-controlled or misconfigured proxy environment variables.
  • Why exploitation is possible: The application trusts HTTP_PROXY and HTTPS_PROXY without validation and performs DNS resolution and outbound HTTP requests based on user input, enabling proxy-based redirection of traffic to attacker-chosen destinations.

Why this happens

The core bug is a lack of validation and trust-boundary enforcement around proxy configuration combined with server-side network calls based on user input.

The logos search endpoint uses search terms supplied by the client to perform DNS resolution and HTTP requests. At the same time, it inherits HTTP_PROXY and HTTPS_PROXY environment variables, allowing those values to redirect all outbound requests without any checks.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where a server makes network requests to locations influenced by an attacker, and relates to CWE-922: Insecure Storage of Sensitive Information, in the sense that sensitive network topology or services may be exposed via these forged requests.

Abstractly, this reflects a pattern where configuration intended for trusted operators (proxy settings) is treated as implicitly safe even when combined with untrusted input, violating the separation between control-plane configuration and data-plane user input.

Potential impact

  • Discovery of internal hosts, ports, and services through blind or semi-blind SSRF.
  • Access to internal HTTP-based administrative panels, APIs, or cloud metadata endpoints reachable from the Wallos server.
  • Potential exfiltration of sensitive data from internal services that respond to HTTP requests.
  • Use of the Wallos instance as a pivot for scanning or attacking other systems on the internal network.
  • Logging of sensitive responses or network paths into application logs, increasing data exposure risk.

General mitigation guidance

Effective mitigation relies on reducing trust in environment-based proxy configuration and constraining server-initiated requests:

  • Enforce strict validation and allowlisting for all outbound destinations used by the logos search functionality, limiting it to known safe domains (e.g., curated logo providers).
  • Explicitly ignore or sanitize HTTP_PROXY and HTTPS_PROXY for the relevant network calls, or use a fixed, audited proxy configuration decoupled from user-controllable paths.
  • Introduce a clear trust boundary between user input (search terms) and network-layer configuration; user data should not influence hostnames or URLs without normalization and checks.
  • Apply network egress controls (firewalls, security groups) so the Wallos host can reach only the minimum set of external services required for its operation.
  • Run the Wallos service with least-privilege networking and credentials, avoiding deployment on highly privileged or central infrastructure where internal reach is broad.

How teams detect issues like this

Detection can focus on both code-level indicators and runtime behavior:

  • Static analysis and code review:
  • Flag server-side HTTP clients that build URLs or hostnames directly from user-supplied parameters without validation or allowlists.
  • Identify code paths that rely on process-wide proxy settings (HTTP_PROXY, HTTPS_PROXY) without explicit scoping or sanitization.
  • Look for any use of DNS resolution or cURL wrappers within HTTP handlers that accept arbitrary search or URL parameters.
  • Configuration and policy enforcement:
  • Enforce policies that disallow reliance on global proxy environment variables for security-sensitive components.
  • Use automated scanning or CI checks to detect unsafe network client defaults (e.g., auto-proxy discovery).
  • Runtime monitoring:
  • Monitor outbound traffic from the Wallos server for unusual destinations, especially internal IP ranges, metadata endpoints, or non-standard ports.
  • Correlate spikes in outbound connections with use of the logos search endpoint to identify potential probing activity.

Automated security tooling, including SAST and application-level egress monitoring, can help surface these patterns before and after deployment.

Sources

SourceLink
github.comgithub.com/ellite/Wallos/commit/e87387f0ebb540cd33e6dfda7181db9db650ecef#diff-d77202c5d47a3d7d4586e519f6f5e256da5fb2969fa8b9c75c399b2821e9de40
github.comgithub.com/ellite/Wallos/security/advisories/GHSA-hhjq-82f8-m6rc

Frequently asked

questions

Yes. If the logos search endpoint is reachable over the network (for example, over the internet or from untrusted clients), an attacker can remotely trigger SSRF by sending crafted requests, provided they can influence or leverage the proxy configuration and search terms.

It depends on how Wallos is deployed. If the logos search functionality is available to unauthenticated users, no login is required; otherwise, any account that can access this endpoint may be sufficient. The key requirement is the ability to reach endpoints/logos/search.php and interact with its parameters.

The most robust pattern is to decouple user input from raw network destinations, enforce strict allowlists for any server-initiated HTTP calls, and avoid inheriting global proxy configuration for request paths influenced by users. Application code should explicitly control its HTTP client configuration rather than trusting ambient environment variables.

Preventive practices include designing outbound network calls around fixed, validated destinations; applying input validation and normalization to all parameters that might affect URLs or hostnames; limiting network egress from application servers; and integrating security reviews or automated checks that specifically look for SSRF patterns and unsafe proxy usage in code and deployment configurations.

Find out what's already
exploitable in your codebase.