feat: blocked_networks config and extended SSRF ranges (closes #67)

Add a blocked_networks config key: a list of CIDRs parsed with net/netip,
added to (not replacing) the built-in SSRF blocklist. An invalid CIDR
aborts startup naming the key and the offending value.

Extend the built-in blocklist to CGNAT 100.64.0.0/10, IETF protocol
assignments 192.0.0.0/24, benchmark 198.18.0.0/15, and NAT64 64:ff9b::/96,
unmapping IPv4-mapped IPv6 so the IPv4 ranges are caught in both forms.
Enforcement stays in the dial-time re-resolution (dialSSRFSafe), which now
also consults the operator-supplied prefixes, so the DNS-rebinding window
remains closed.

Model: opus-4-8

internal/config/config.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log/slog"
 	"math"
+	"net/netip"
 	"net/url"
 	"os"
 	"path/filepath"
@@ -42,6 +43,7 @@ const (
 	keyAllowHTTP                  = "allow_http"
 	keyUpstreamConnectionsPerHost = "upstream_connections_per_host"
 	keyCacheMaxBytes              = "cache_max_bytes"
+	keyBlockedNetworks            = "blocked_networks"
 )
 
 // Static validation errors. Each use site attaches the offending key
@@ -54,6 +56,7 @@ var (
 	errNotAnInteger      = errors.New("not an integer")
 	errNotABoolean       = errors.New("not a boolean")
 	errNotAStringList    = errors.New("not a list of strings")
+	errNotAValidCIDR     = errors.New("not a valid CIDR network")
 	errNotAMetricsMap    = errors.New("not a map of metrics settings")
 	errEmptyListEntry    = errors.New("list contains an empty entry")
 	errEmptyEntry        = errors.New("contains an empty entry")
@@ -100,6 +103,11 @@ type Config struct {
 	AllowHTTP                  bool     // Allow non-TLS upstream (testing only)
 	UpstreamConnectionsPerHost int      // Max concurrent connections per upstream host
 
+	// BlockedNetworks are operator-supplied CIDR ranges to refuse in
+	// addition to the built-in SSRF blocklist. Enforced by the upstream
+	// fetcher's dialer; the built-in ranges always apply.
+	BlockedNetworks []netip.Prefix
+
 	// CacheMaxBytes is the disk cache size limit in bytes. Zero
 	// disables the disk cache entirely. When cache_max_bytes is
 	// omitted from the configuration, this holds the computed default
@@ -168,6 +176,11 @@ func newFromSmartConfig(sc *smartconfig.Config) (*Config, error) {
 		}
 	}
 
+	blockedNetworks, err := getBlockedNetworks(sc)
+	if err != nil {
+		return nil, err
+	}
+
 	loader := &strictLoader{sc: sc}
 
 	c := &Config{
@@ -183,7 +196,8 @@ func newFromSmartConfig(sc *smartconfig.Config) (*Config, error) {
 		AllowHTTP:       loader.boolVal(keyAllowHTTP, false),
 		UpstreamConnectionsPerHost: loader.intVal(
 			keyUpstreamConnectionsPerHost, DefaultUpstreamConnectionsPerHost),
-		CacheMaxBytes: loader.int64Val(keyCacheMaxBytes, 0),
+		CacheMaxBytes:   loader.int64Val(keyCacheMaxBytes, 0),
+		BlockedNetworks: blockedNetworks,
 	}
 
 	// The computed default for cache_max_bytes needs a validated
@@ -215,7 +229,7 @@ func newFromSmartConfig(sc *smartconfig.Config) (*Config, error) {
 		return nil, loader.err
 	}
 
-	err := c.validate()
+	err = c.validate()
 	if err != nil {
 		return nil, err
 	}
@@ -299,7 +313,7 @@ func isKnownConfigKey(key string) bool {
 	switch key {
 	case keyDebug, keyMaintenanceMode, keyPort, keyStateDir, keySentryDSN,
 		keyDBURL, keyMetrics, keySigningKey, keyAllowlistHosts, keyAllowHTTP,
-		keyUpstreamConnectionsPerHost, keyCacheMaxBytes, "env":
+		keyUpstreamConnectionsPerHost, keyCacheMaxBytes, keyBlockedNetworks, "env":
 		return true
 	}
 
@@ -778,3 +792,87 @@ func getStringSlice(sc *smartconfig.Config) []string {
 
 	return nil
 }
+
+// getBlockedNetworks parses the blocked_networks value into CIDR prefixes,
+// or returns nil if the key is omitted. It accepts a YAML list of strings
+// or a comma-separated string. An explicitly null value, a wrong type, an
+// empty entry, a non-string entry, or an unparseable CIDR aborts startup
+// naming the key and the offending value; a default (the built-in
+// blocklist alone) applies only to an omitted key.
+func getBlockedNetworks(sc *smartconfig.Config) ([]netip.Prefix, error) {
+	if sc == nil {
+		return nil, nil
+	}
+
+	raw, ok := sc.Get(keyBlockedNetworks)
+	if !ok {
+		return nil, nil
+	}
+
+	if raw == nil {
+		return nil, errNullConfigValue(keyBlockedNetworks)
+	}
+
+	entries, err := blockedNetworkEntries(raw)
+	if err != nil {
+		return nil, err
+	}
+
+	prefixes := make([]netip.Prefix, 0, len(entries))
+
+	for _, entry := range entries {
+		prefix, err := netip.ParsePrefix(entry)
+		if err != nil {
+			return nil, fmt.Errorf("config key %q: value %q is %w",
+				keyBlockedNetworks, entry, errNotAValidCIDR)
+		}
+
+		prefixes = append(prefixes, prefix)
+	}
+
+	return prefixes, nil
+}
+
+// blockedNetworkEntries extracts the raw blocked_networks entries as
+// trimmed, non-empty strings, from either a YAML list of strings or a
+// comma-separated string. Any other shape is a configuration error.
+func blockedNetworkEntries(raw any) ([]string, error) {
+	switch val := raw.(type) {
+	case []any:
+		entries := make([]string, 0, len(val))
+
+		for _, item := range val {
+			str, ok := item.(string)
+			if !ok {
+				return nil, fmt.Errorf("config key %q: list entry %v (%T) is %w",
+					keyBlockedNetworks, item, item, errNotAString)
+			}
+
+			if strings.TrimSpace(str) == "" {
+				return nil, fmt.Errorf("config key %q: %w",
+					keyBlockedNetworks, errEmptyListEntry)
+			}
+
+			entries = append(entries, strings.TrimSpace(str))
+		}
+
+		return entries, nil
+	case string:
+		entries := make([]string, 0)
+
+		for part := range strings.SplitSeq(val, ",") {
+			trimmed := strings.TrimSpace(part)
+			if trimmed == "" {
+				return nil, fmt.Errorf("config key %q: value %q %w",
+					keyBlockedNetworks, val, errEmptyEntry)
+			}
+
+			entries = append(entries, trimmed)
+		}
+
+		return entries, nil
+	default:
+		return nil, fmt.Errorf("config key %q: value %v (%T) is %w",
+			keyBlockedNetworks, raw, raw, errNotAStringList)
+	}
+}