/

CVE-2026-30840

Severity:

HIGH RISK

(8.8)

SSRF in Wallos Notification Testers

CVE-2026-30840

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-295, CWE-918

Impact:

Network Perimeter Bypass and Access to Internal Resources

Severity:

HIGH RISK

(8.8)

CVSS version:

3.0

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, 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).

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-mr2c-prqv-hqm8

Frequently asked

questions

Yes, if an attacker can reach the Wallos interface and access the notification testing feature, they can attempt SSRF from outside the network, using the Wallos server to contact internal or otherwise inaccessible hosts.

In most realistic deployments, exploitation requires at least the level of access needed to configure or trigger notification tests, which is typically an authenticated user role; the exact requirement depends on how access control is configured.

The most robust approach is to constrain all server-initiated HTTP(S) requests to a strict allowlist of trusted domains, combined with strong URL validation and proper TLS certificate verification, rather than permitting arbitrary destinations.

Treat any feature that makes outbound requests as security-sensitive, design APIs to use predefined integrations instead of user-specified URLs, enforce network egress restrictions, and include SSRF-specific checks in code review, static analysis, and testing processes.

Find out what's already
exploitable in your codebase.