Summary
Wallos, a self-hostable personal subscription tracker, contains a server-side request forgery (SSRF) flaw in its notification testing feature in versions prior to 4.6.2.
Under certain conditions, an attacker can coerce the Wallos server into making arbitrary outbound HTTP requests, potentially reaching internal services and bypassing network-layer defenses.
Affected context
The vulnerability occurs in the notification testing functionality of Wallos when it allows users to configure and test outbound notification endpoints.
In deployments where the Wallos instance sits on a trusted network segment or has access to internal services, unvalidated or weakly validated URLs in these test requests may allow attackers to pivot through the application server.
The risk is most pronounced when Wallos can reach internal HTTP(S) endpoints, cloud metadata services, or management interfaces that are not directly exposed to the internet.
Exploit preconditions
- Attack surface: HTTP(S) interface where notification test endpoints are configured or triggered.
- Required access: Ability to invoke the notification testing feature (e.g., authenticated user with configuration or notification testing permissions).
- Trigger point: Submission of a crafted notification test configuration or URL that the server uses to perform an outbound request.
- Why exploitation is possible: The server constructs and sends outbound HTTP or HTTPS requests based on user-controlled or insufficiently validated URL parameters, allowing the attacker to influence destination hosts, ports, and paths.
Why this happens
This issue is rooted in the classic Server-Side Request Forgery pattern, captured by CWE-918, where server-side functionality makes outbound network requests based on attacker-controlled input.
The notification testing feature likely accepts a target endpoint (URL or host) and instructs the Wallos backend to contact it, without enforcing strict allowlists, destination constraints, or robust URL parsing.
The presence of CWE-295 (Improper Certificate Validation) suggests that HTTPS requests initiated by the server may not properly verify TLS server certificates, further weakening trust boundaries and enabling connections to potentially spoofed or untrusted endpoints.
Together, these behaviors allow an attacker to treat the Wallos server as a network proxy into environments the attacker cannot directly reach.
Potential impact
- May allow access to internal HTTP(S) services not exposed to the public internet.
- Could be used to interact with cloud provider metadata endpoints and potentially obtain credentials or tokens.
- May enable reconnaissance of internal network structure, open ports, and available services.
- Could be leveraged to bypass firewall rules or network segmentation controls based on source IP.
- Might allow attackers to trigger unintended actions on internal APIs (e.g., configuration changes, data access, or job execution) if those APIs lack strong authentication.
General mitigation guidance
Effective mitigation focuses on constraining server-initiated outbound requests and treating user-supplied URLs as untrusted input:
- Introduce strict allowlists of permitted domains or endpoints for notification tests rather than accepting arbitrary URLs.
- Implement robust URL validation and normalization, rejecting private IP ranges, loopback addresses, link-local networks, and non-HTTP(S) schemes by default.
- Enforce proper TLS certificate validation and hostname verification for all outbound HTTPS requests, and avoid disabling certificate checks.
- Apply network-level egress controls so that the application host can only reach known, necessary external services.
- Design the notification testing flow so users select from predefined, vetted integrations instead of free-form endpoints whenever possible.
- Run the application with least network privilege, segmenting it away from sensitive internal services and metadata endpoints.
How teams detect issues like this
Detection generally combines code-level analysis with runtime monitoring:
- Use static analysis and code review to identify server-side HTTP client calls that depend on user-controlled URL or host parameters, especially in testing or integration features.
- Define security review checklists that flag any feature which issues outbound requests as high-risk and requiring explicit SSRF safeguards (allowlists, IP checks, URL parsing).
- Monitor logs for unusual notification test activity, such as requests to non-standard ports, internal IP ranges, or unexpected domains.
- Employ application security testing tools or proxies configured to probe SSRF by attempting internal IP and metadata endpoint access via any URL-taking parameter.
- Where possible, enforce policy-as-code in CI (e.g., scanning for dangerous URL handling patterns or disabled TLS verification in outbound requests).

