/

CVE-2026-46717

Severity:

HIGH RISK

(7.7)

SSRF and Privilege Issue (CWE-918) in Nezha Dashboard

CVE-2026-46717

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-863, CWE-918

Impact:

Server-Side Request Forgery and Unauthorized Network Access

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.

Sources

SourceLink
github.comgithub.com/nezhahq/nezha/security/advisories/GHSA-w4g9-mxgg-j532

Frequently asked

questions

It can be, if the Nezha dashboard is exposed to the internet and an attacker can obtain or abuse a RoleMember account. The actual reach of the SSRF depends on how the Nezha server is networked.

The attacker must have credentials for at least a RoleMember account, or exploit some other weakness to act as such a user. Completely unauthenticated attackers typically cannot reach these APIs as designed.

Restrict the notification management endpoints to administrative roles only, and ensure that any outbound HTTP requests from these endpoints are tightly controlled with URL validation, network restrictions, and response handling that does not echo arbitrary bodies back to clients.

Apply defense-in-depth by enforcing strict role-based access control around admin-level features, auditing all HTTP client usage for user-controlled destinations, and embedding SSRF-aware design reviews and automated checks into the development and deployment lifecycle.

Find out what's already
exploitable in your codebase.