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.phpcron 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.phpcron 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.

