Summary
Dozzle's unauthenticated webhook test endpoint allows an attacker to trigger server-side HTTP requests to arbitrary URLs and observe the response.
In default deployments without authentication configured, this can be abused as a server-side request forgery (SSRF) primitive to reach internal services and exfiltrate response data.
Affected context
This vulnerability affects Dozzle deployments using the default quickstart configuration where DOZZLE_AUTH_PROVIDER is not set and HTTP access to the Dozzle UI/API is exposed.
In this setup, the /api/notifications/test-webhook endpoint is reachable without authentication and will send HTTP POST requests from the Dozzle server to a URL supplied by the caller.
The endpoint then returns the response status code and, when the target replies with a non-2xx status, up to 1MB of the response body to the client, creating a powerful SSRF channel.
Exploit preconditions
- Attack surface: HTTP interface of the Dozzle instance (typically internal dashboard, but sometimes exposed on a network or the internet).
- Required access: Network-level ability to send HTTP requests to the Dozzle server (no application-level authentication required in default setup).
- Trigger point: A POST request to
/api/notifications/test-webhookwith attacker-controlled parameters, including the target URL and headers. - Why exploitation is possible:
- The endpoint accepts user-supplied URLs and request headers.
- The server performs outbound HTTP POST requests to these URLs without origin or network-zone restrictions.
- The response status and up to 1MB of the response body for non-2xx replies are reflected back to the requester, enabling data extraction from internal or protected services.
Why this happens
The core issue is an SSRF design flaw where external input is allowed to control where the server sends HTTP requests and what headers are included, without adequate validation, access control, or network segmentation.
The test webhook endpoint acts as a generic HTTP client on behalf of the server, treating user-controlled target URLs as trustworthy and relaying significant portions of the response.
This maps to CWE-918: Server-Side Request Forgery (SSRF), in which a web application fetches remote resources based on user input and exposes or leverages those responses in potentially unsafe ways.
Potential impact
- Discovery and probing of internal services and endpoints not directly reachable by the attacker.
- Access to sensitive internal HTTP endpoints (e.g., admin panels, metadata services, container orchestration APIs) that respond over HTTP.
- Exfiltration of response bodies (up to 1MB) from internal services, potentially leaking secrets, configuration, or tokens.
- Use of Dozzle as a pivot point for further attacks within the internal network (e.g., scanning, enumeration).
- Abuse of outgoing HTTP requests for limited reflected or stored attacks on third-party services (e.g., log pollution or targeted POSTs), depending on network egress controls.
General mitigation guidance
Effective mitigation generally focuses on tightening trust boundaries around outbound HTTP requests and enforcing least privilege on diagnostic features:
- Restrict test or diagnostic endpoints so they are not exposed without strong authentication and authorization, especially in default deployments.
- Validate and constrain target URLs passed to webhook or HTTP client features, such as:
- Restricting to an allowlist of domains or paths.
- Blocking private, loopback, link-local, and metadata IP ranges.
- Enforcing HTTPS and known-safe hostnames when possible.
- Limit the information returned from outbound requests, avoiding reflection of full response bodies or headers to callers, and implement strict size caps.
- Apply network-layer controls (firewalls, egress policies, or service mesh rules) to prevent application containers from freely accessing internal infrastructure segments or metadata endpoints.
- Design webhook testing and similar utilities with secure defaults, disabling them or limiting their capabilities in production environments.
How teams detect issues like this
Organizations can detect and monitor SSRF risks in similar components using a combination of code-level and operational controls:
- Static analysis and code review:
- Flag any code paths where user input influences outbound HTTP requests (URL, host, port, scheme) without rigorous validation.
- Look for "test webhook" or "HTTP test" endpoints that forward full responses to callers.
- Identify lack of authentication/authorization on administrative or diagnostic endpoints.
- Security testing and fuzzing:
- Include SSRF test cases in application security testing, attempting to access internal IP ranges and metadata services.
- Use automated tools or scripts to probe endpoints that accept URLs, hostnames, or callback addresses.
- Runtime monitoring:
- Monitor outbound HTTP requests from application containers for anomalous destinations (e.g., internal IPs, metadata addresses).
- Configure network logging and alerts for attempts to access sensitive internal services from web-facing components.
- Policy enforcement:
- Enforce infrastructure policies that restrict outbound traffic from user-facing services.
- Integrate security checks in CI/CD pipelines to catch new endpoints that proxy arbitrary requests.

