| 1 | // Package ssrf keurt webhook-bestemmingen. |
| 2 | // Privénetwerken zijn geblokkeerd. Een naam die naar een publiek IP |
| 3 | // wijst mag wel, ook als een router dat verkeer daarna terug naar huis |
| 4 | // stuurt. Het IP wordt bij het verbinden vastgezet, zodat een tweede |
| 5 | // DNS-antwoord niet alsnog een privéadres kan worden. |
| 6 | package ssrf |
| 7 | |
| 8 | import ( |
| 9 | "context" |
| 10 | "fmt" |
| 11 | "net" |
| 12 | "net/http" |
| 13 | "net/url" |
| 14 | "strings" |
| 15 | "time" |
| 16 | ) |
| 17 | |
| 18 | // MaxRedirects is het aantal hops dat een webhook nog volgt. |
| 19 | const MaxRedirects = 3 |
| 20 | |
| 21 | var ( |
| 22 | v4Blocked []*net.IPNet |
| 23 | v6Blocked []*net.IPNet |
| 24 | ) |
| 25 | |
| 26 | func init() { |
| 27 | // RFC1918, loopback, link-local (daar zit 169.254.169.254 bij), |
| 28 | // CGNAT, unspecified, multicast en gereserveerd. |
| 29 | v4Blocked = mustCIDR( |
| 30 | "0.0.0.0/8", |
| 31 | "10.0.0.0/8", |
| 32 | "100.64.0.0/10", |
| 33 | "127.0.0.0/8", |
| 34 | "169.254.0.0/16", |
| 35 | "172.16.0.0/12", |
| 36 | "192.168.0.0/16", |
| 37 | "224.0.0.0/4", |
| 38 | "240.0.0.0/4", |
| 39 | ) |
| 40 | // Loopback, ULA, link-local, het oude site-local, multicast. |
| 41 | v6Blocked = mustCIDR( |
| 42 | "::1/128", |
| 43 | "fc00::/7", |
| 44 | "fe80::/10", |
| 45 | "fec0::/10", |
| 46 | "ff00::/8", |
| 47 | ) |
| 48 | } |
| 49 | |
| 50 | func mustCIDR(cidrs ...string) []*net.IPNet { |
| 51 | var out []*net.IPNet |
| 52 | for _, c := range cidrs { |
| 53 | _, n, err := net.ParseCIDR(c) |
| 54 | if err != nil { |
| 55 | panic(err) |
| 56 | } |
| 57 | out = append(out, n) |
| 58 | } |
| 59 | return out |
| 60 | } |
| 61 | |
| 62 | // Private meldt of ip geen publiek unicast-adres is. |
| 63 | // IPv4-mapped adressen, 6to4 en NAT64 (64:ff9b::/96) worden beoordeeld |
| 64 | // op het ingebedde IPv4-adres. |
| 65 | func Private(ip net.IP) bool { |
| 66 | if ip == nil { |
| 67 | return true |
| 68 | } |
| 69 | if v4 := embeddedV4(ip); v4 != nil { |
| 70 | return privateV4(v4) |
| 71 | } |
| 72 | if v4 := ip.To4(); v4 != nil { |
| 73 | return privateV4(v4) |
| 74 | } |
| 75 | v6 := ip.To16() |
| 76 | if v6 == nil { |
| 77 | return true |
| 78 | } |
| 79 | if v6.Equal(net.IPv6unspecified) { |
| 80 | return true |
| 81 | } |
| 82 | for _, n := range v6Blocked { |
| 83 | if n.Contains(v6) { |
| 84 | return true |
| 85 | } |
| 86 | } |
| 87 | return false |
| 88 | } |
| 89 | |
| 90 | func privateV4(ip net.IP) bool { |
| 91 | ip = ip.To4() |
| 92 | if ip == nil { |
| 93 | return true |
| 94 | } |
| 95 | for _, n := range v4Blocked { |
| 96 | if n.Contains(ip) { |
| 97 | return true |
| 98 | } |
| 99 | } |
| 100 | return false |
| 101 | } |
| 102 | |
| 103 | // embeddedV4 haalt een IPv4-adres uit 6to4 (2002::/16) of NAT64 (64:ff9b::/96). |
| 104 | func embeddedV4(ip net.IP) net.IP { |
| 105 | v6 := ip.To16() |
| 106 | if v6 == nil || ip.To4() != nil { |
| 107 | return nil |
| 108 | } |
| 109 | if v6[0] == 0x20 && v6[1] == 0x02 { |
| 110 | return net.IPv4(v6[2], v6[3], v6[4], v6[5]).To4() |
| 111 | } |
| 112 | if v6[0] == 0x00 && v6[1] == 0x64 && v6[2] == 0xff && v6[3] == 0x9b && allZero(v6[4:12]) { |
| 113 | return net.IPv4(v6[12], v6[13], v6[14], v6[15]).To4() |
| 114 | } |
| 115 | return nil |
| 116 | } |
| 117 | |
| 118 | func allZero(b []byte) bool { |
| 119 | for _, c := range b { |
| 120 | if c != 0 { |
| 121 | return false |
| 122 | } |
| 123 | } |
| 124 | return true |
| 125 | } |
| 126 | |
| 127 | // Lookup zoekt de adressen van een hostnaam. Tests vullen een eigen functie in. |
| 128 | type Lookup func(ctx context.Context, host string) ([]net.IP, error) |
| 129 | |
| 130 | func defaultLookup(ctx context.Context, host string) ([]net.IP, error) { |
| 131 | addrs, err := net.DefaultResolver.LookupIPAddr(ctx, host) |
| 132 | if err != nil { |
| 133 | return nil, err |
| 134 | } |
| 135 | out := make([]net.IP, 0, len(addrs)) |
| 136 | for _, a := range addrs { |
| 137 | out = append(out, a.IP) |
| 138 | } |
| 139 | return out, nil |
| 140 | } |
| 141 | |
| 142 | // Pin kiest het IP waarmee verbonden wordt. |
| 143 | // Een letterlijk privéadres wordt geweigerd zonder DNS. Een naam waarvan |
| 144 | // minstens één adres geblokkeerd is, wordt helemaal geweigerd: anders kan |
| 145 | // het tweede antwoord alsnog naar het lokale net wijzen. |
| 146 | func Pin(ctx context.Context, host string, lookup Lookup) (net.IP, error) { |
| 147 | host = strings.TrimSuffix(strings.TrimSpace(host), ".") |
| 148 | if host == "" { |
| 149 | return nil, fmt.Errorf("webhook-host ontbreekt") |
| 150 | } |
| 151 | if ip := net.ParseIP(host); ip != nil { |
| 152 | if Private(ip) { |
| 153 | return nil, fmt.Errorf("%s ligt in een geblokkeerd bereik", ip) |
| 154 | } |
| 155 | return ip, nil |
| 156 | } |
| 157 | if lookup == nil { |
| 158 | lookup = defaultLookup |
| 159 | } |
| 160 | ips, err := lookup(ctx, host) |
| 161 | if err != nil { |
| 162 | return nil, fmt.Errorf("dns voor %s: %w", host, err) |
| 163 | } |
| 164 | if len(ips) == 0 { |
| 165 | return nil, fmt.Errorf("geen adres voor %s", host) |
| 166 | } |
| 167 | for _, ip := range ips { |
| 168 | if Private(ip) { |
| 169 | return nil, fmt.Errorf("%s wijst naar %s in een geblokkeerd bereik", host, ip) |
| 170 | } |
| 171 | } |
| 172 | return ips[0], nil |
| 173 | } |
| 174 | |
| 175 | // ValidateURL keurt het schema, een userinfo en een letterlijk privéadres af. |
| 176 | func ValidateURL(u *url.URL) error { |
| 177 | if u == nil || u.Hostname() == "" || u.User != nil { |
| 178 | return fmt.Errorf("webhook-URL is ongeldig") |
| 179 | } |
| 180 | if u.Scheme != "http" && u.Scheme != "https" { |
| 181 | return fmt.Errorf("webhook-URL moet http of https zijn") |
| 182 | } |
| 183 | if ip := net.ParseIP(u.Hostname()); ip != nil && Private(ip) { |
| 184 | return fmt.Errorf("%s ligt in een geblokkeerd bereik", ip) |
| 185 | } |
| 186 | return nil |
| 187 | } |
| 188 | |
| 189 | func checkRedirect(req *http.Request, via []*http.Request) error { |
| 190 | if len(via) >= MaxRedirects { |
| 191 | return fmt.Errorf("te veel redirects") |
| 192 | } |
| 193 | if err := ValidateURL(req.URL); err != nil { |
| 194 | return err |
| 195 | } |
| 196 | if len(via) == 0 || via[0].URL == nil || sameHost(via[0].URL, req.URL) { |
| 197 | return nil |
| 198 | } |
| 199 | if req.Response != nil && (req.Response.StatusCode == http.StatusTemporaryRedirect || req.Response.StatusCode == http.StatusPermanentRedirect) { |
| 200 | return fmt.Errorf("redirect naar een andere host met de oorspronkelijke body is geweigerd") |
| 201 | } |
| 202 | for k := range req.Header { |
| 203 | if strings.EqualFold(k, "Content-Type") || strings.EqualFold(k, "User-Agent") { |
| 204 | continue |
| 205 | } |
| 206 | req.Header.Del(k) |
| 207 | } |
| 208 | return nil |
| 209 | } |
| 210 | |
| 211 | func sameHost(a, b *url.URL) bool { |
| 212 | if a == nil || b == nil { |
| 213 | return false |
| 214 | } |
| 215 | return strings.EqualFold(a.Hostname(), b.Hostname()) |
| 216 | } |
| 217 | |
| 218 | // NewClient belt alleen publieke IP's en zet het gekozen adres vast. |
| 219 | // Omgevingsproxies worden niet gebruikt. |
| 220 | func NewClient(timeout time.Duration) *http.Client { |
| 221 | dialer := &net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second} |
| 222 | transport := &http.Transport{ |
| 223 | DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) { |
| 224 | host, port, err := net.SplitHostPort(addr) |
| 225 | if err != nil { |
| 226 | return nil, err |
| 227 | } |
| 228 | ip, err := Pin(ctx, host, nil) |
| 229 | if err != nil { |
| 230 | return nil, err |
| 231 | } |
| 232 | return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port)) |
| 233 | }, |
| 234 | TLSHandshakeTimeout: 5 * time.Second, |
| 235 | ForceAttemptHTTP2: true, |
| 236 | } |
| 237 | if timeout <= 0 { |
| 238 | timeout = 10 * time.Second |
| 239 | } |
| 240 | return &http.Client{Timeout: timeout, Transport: transport, CheckRedirect: checkRedirect} |
| 241 | } |