/

CVE-2026-33399

Severity:

HIGH RISK

(7.7)

SSRF in Wallos Notification Webhooks

CVE-2026-33399

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources via server-initiated HTTP requests

Severity:

HIGH RISK

(7.7)

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 an incomplete SSRF protection in its notification webhook handling, allowing authenticated users to save internal or private IPs as notification URLs.

When the scheduled notification job runs, it sends HTTP requests to these unvalidated URLs, which can result in server-side requests to internal network resources.

Affected context

This vulnerability affects Wallos deployments where:

  • Notification webhooks are configured by authenticated users, and
  • The sendnotifications.php cron job is used to deliver notifications, and
  • Network paths from the Wallos host to internal or private services are reachable.

The issue arises because SSRF validation is applied to test notification endpoints but not to the corresponding save endpoints that persist webhook URLs.

Exploit preconditions

  • Attack surface: Web application notification configuration interface.
  • Required access: Authenticated Wallos account with permissions to configure or save notification URLs.
  • Trigger point: Execution of the sendnotifications.php cron job, which sends notifications to stored webhook URLs.
  • Why exploitation is possible: The saved notification URLs are not passed through validate_webhook_url_for_ssrf() or an equivalent validation routine before being persisted or used, allowing internal/private IP addresses and sensitive schemes to be targeted.

Why this happens

The root cause is an incomplete application of SSRF defenses: validation logic (validate_webhook_url_for_ssrf()) was only attached to "test" notification endpoints and not to the corresponding "save" endpoints.

This creates a gap where persisted webhook URLs are never subjected to the same SSRF checks before being used by the background job.

Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF), where the server makes HTTP requests to attacker-controlled URLs without enforcing strict allowlisting, network egress constraints, or URL normalization and validation.

Potential impact

  • Access to internal HTTP services that are not directly exposed to the internet.
  • Interaction with cloud metadata or management endpoints (where reachable), which can lead to sensitive data exposure or token leakage.
  • Port scanning or service enumeration of internal network ranges from the Wallos host.
  • Indirect interaction with other internal applications, potentially triggering side effects such as cache poisoning, log injection, or job execution.

General mitigation guidance

Effective mitigation centers on enforcing strict control over all outbound requests that depend on user-provided URLs:

  • Apply the same SSRF validation routine consistently to all code paths that accept, store, or use webhook URLs, not just "test" flows.
  • Prefer a strict allowlist of permitted domains or endpoints for notification URLs rather than attempting to block disallowed IP ranges.
  • Normalize and parse URLs using robust libraries, then validate components (scheme, host, port) before accepting or persisting them.
  • Restrict server egress at the network level so that application containers or hosts cannot reach internal-only subnets or cloud metadata endpoints unless strictly required.
  • Run the notification-sending process with least-privilege network access, segregating it from sensitive internal services where possible.

How teams detect issues like this

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

  • Static/code review: Look for HTTP client calls that use user-controlled or configurable URLs without passing through a common SSRF-validation helper or allowlist.
  • Security testing: Conduct application-level SSRF tests by configuring webhook URLs pointing to controlled endpoints (e.g., canary servers) and observing server callbacks from scheduled jobs.
  • Log and network monitoring: Monitor outbound HTTP requests from the Wallos host or container for unusual destinations such as RFC1918 IP ranges, link-local addresses, or metadata service IPs.
  • Automated analysis: Use SAST tools configured with SSRF-specific rules to flag unvalidated use of URL parameters, and complement this with DAST scanners capable of exercising background jobs and webhooks.

Sources

SourceLink
github.comgithub.com/ellite/Wallos/commit/e87387f0ebb540cd33e6dfda7181db9db650ecef#diff-d77202c5d47a3d7d4586e519f6f5e256da5fb2969fa8b9c75c399b2821e9de40
github.comgithub.com/ellite/Wallos/security/advisories/GHSA-mfjc-3258-cq3j

Frequently asked

questions

It requires an authenticated Wallos user who can configure notification URLs. While it is not an unauthenticated, fully remote issue, it can often be exploited by any user with standard access if proper role restrictions are not in place.

The attacker needs valid credentials for a Wallos account with permission to save or modify notification webhook URLs. No direct shell access or administrative OS-level privileges on the server are required.

The most robust approach is to centralize SSRF protection in a single validation routine and ensure all paths that accept or use URLs (test, save, update, import) call this routine. Complement this with a tight domain allowlist and, where feasible, network egress controls that prevent access to internal and metadata IP ranges.

Establish a standard pattern for handling user-controlled URLs: parse and normalize them, enforce scheme and port restrictions, use strict allowlists, and enforce egress controls at the network layer. Incorporate SSRF-specific checks into code review guidelines and CI pipelines so new endpoints leveraging callbacks or webhooks cannot bypass established defenses.

Find out what's already
exploitable in your codebase.