Summary
Nezha Monitoring's dashboard exposes notification APIs that allow member-level users to trigger HTTP requests to arbitrary, user-controlled URLs.
Because the full response body is reflected back to the caller on non-2xx responses, an attacker can abuse this behavior as a high-impact server-side request forgery (SSRF) channel when certain network conditions are met.
Affected context
The vulnerability occurs in Nezha Monitoring dashboards where RoleMember users can access notification endpoints intended to be privileged.
Specifically, the POST /api/v1/notification and PATCH /api/v1/notification/:id routes are wired through a generic handler that does not enforce admin-only access.
When notifications are created or updated, the server synchronously sends HTTP requests to user-defined URLs and, on non-2xx status codes, streams the entire response body back to the caller without size restrictions.
Exploit preconditions
- Attack surface: Nezha dashboard HTTP API, reachable wherever RoleMember users can authenticate.
- Required access: Valid RoleMember (or higher) account on the Nezha instance; ability to invoke notification APIs.
- Trigger point: Submitting crafted POST or PATCH requests to the notification endpoints with attacker-controlled callback URLs.
- Why exploitation is possible: The notification APIs use a common handler that:
- Does not restrict outbound HTTP destinations
- Does not limit response size
- Reflects response bodies on non-2xx codes
- Is exposed to roles that were not intended to manage or probe arbitrary endpoints
Why this happens
The issue stems from a combination of overly permissive access control and unbounded server-side HTTP requests to user-controlled endpoints.
Instead of using an admin-specific handler that enforces stricter authorization, the notification routes rely on a common handler, so lower-privileged RoleMember accounts can trigger behavior that should be restricted.
Once invoked, the handler performs outbound HTTP requests directly to URLs supplied by the user and reflects the complete response on error paths, aligning with CWE-918: Server-Side Request Forgery (SSRF) and CWE-863: Incorrect Authorization.
At an abstract level, the pattern is: low-privilege users can cause the server to act as an HTTP client into its own network or adjacent systems, and then observe the raw responses, turning the application into a powerful network oracle.
Potential impact
- May allow probing of internal network services that are not directly reachable by the attacker.
- Could expose sensitive data returned by internal HTTP endpoints through reflected response bodies.
- May enable metadata service access in certain cloud environments, if reachable from the Nezha host.
- Can be abused for port scanning or service fingerprinting within the server's network boundary.
- Might be combined with other weaknesses on internal services (e.g., misconfigured admin interfaces) for further compromise.
General mitigation guidance
Effective mitigation focuses on tightening authorization boundaries and constraining outbound request behavior:
- Restrict sensitive notification management APIs to trusted administrative roles with explicit authorization checks.
- Validate and constrain callback or webhook URLs to an allowlist, or at least block link-local, loopback, and private network address ranges where feasible.
- Introduce response-size limits and avoid reflecting raw response bodies from outbound HTTP requests to end users.
- Separate notification delivery logic from direct user-triggered API calls, using background jobs or mediated services that enforce stricter policies.
- Apply least-privilege networking controls so the monitoring service has only the minimum outbound network reach needed for its legitimate functions.
How teams detect issues like this
Organizations can look for this pattern through several approaches:
- Static analysis: Flag code paths where outbound HTTP clients are invoked with user-controlled URLs, especially when responses are forwarded directly to clients.
- Code review: Examine route-to-handler wiring to ensure admin-only operations are not exposed through shared or generic handlers; verify role checks near sensitive network operations.
- Logging and monitoring: Track unusual patterns of notification configuration or many outbound requests to unexpected domains or internal IP address ranges initiated via user-facing APIs.
- Policy enforcement: Use automated review tools or CI/CD checks that detect SSRF-prone constructs (e.g., arbitrary URL fetchers, lack of allowlists) and missing authorization guards around administrative functions.

