Summary
A server-side request forgery (SSRF) flaw in New API's default configuration allows authenticated users to register webhook-like URLs that resolve to internal or metadata IP addresses.
Because hostname-based URLs were not subjected to IP filtering, domain rules could be bypassed to make the system initiate requests into internal networks.
Affected context
This vulnerability appears in New API deployments that:
- Rely on the default SSRF protection configuration
- Allow authenticated users to configure notification endpoints (Webhook, Bark, Gotify, etc.)
- Use hostname-based URLs rather than literal IP addresses
In this context, hostnames are validated only against allow/block lists without resolving and re-checking the resulting IP address, which weakens network egress controls.
Exploit preconditions
- Attack surface: Application-level notification URL configuration (e.g., Webhook, Bark, Gotify).
- Required access: Authenticated access with permission to set or modify outbound notification URLs.
- Trigger point: The system sending a notification to the user-provided URL, causing an outbound HTTP(S) request.
- Why exploitation is possible: The SSRF filter examines domain names but does not resolve hostnames and enforce IP-based restrictions, allowing crafted hostnames that resolve to internal or metadata IP ranges to pass validation.
Why this happens
The underlying issue is incomplete server-side request forgery protection, aligned with CWE-918: Server-Side Request Forgery (SSRF).
The security control only evaluated hostname-based allow/block rules and did not perform IP resolution and subsequent IP range filtering.
As a result, user-controlled URLs could reference domains that resolve to sensitive internal or metadata IP addresses, leading the gateway to make unintended outbound requests on behalf of the attacker.
Potential impact
- Gain of indirect access to internal HTTP services that are not exposed externally.
- Interaction with cloud provider metadata services, which could lead to credential or token exposure.
- Discovery of internal network structure and service behavior through error messages and timing.
- Use of the application as a pivot point for further attacks against internal assets.
General mitigation guidance
Mitigation typically focuses on strengthening outbound request controls and reducing trust in user-supplied URLs.
Common defensive patterns include:
- Resolving hostnames server-side and enforcing strict IP-based allowlists, including re-checking after DNS changes.
- Denying or tightly restricting access to private, link-local, loopback, and metadata address ranges by default.
- Segregating network egress for notification components so they cannot directly reach sensitive internal services.
- Minimizing the set of user-configurable destinations, favoring predefined, vetted endpoints where practical.
- Applying least-privilege to any credentials used for outbound calls, reducing the impact of SSRF if it occurs.
How teams detect issues like this
Detection efforts can focus on both code-level and operational signals:
- Static analysis rules that identify user-controlled URLs being passed into HTTP clients without robust SSRF filtering.
- Code review checklists that explicitly require hostname resolution and IP range validation for outbound connections.
- Centralized egress logging and anomaly detection to flag unexpected calls to internal or metadata address ranges.
- Security tests or red-team exercises that attempt to register notification URLs pointing to internal or reserved IP ranges.
Automated code scanning and policy enforcement in CI/CD can help ensure future changes preserve strong SSRF defenses.

