// Package ssrf keurt webhook-bestemmingen. // Privénetwerken zijn geblokkeerd. Een naam die naar een publiek IP // wijst mag wel, ook als een router dat verkeer daarna terug naar huis // stuurt. Het IP wordt bij het verbinden vastgezet, zodat een tweede // DNS-antwoord niet alsnog een privéadres kan worden. package ssrf import ( "context" "net" "net/http" "net/url" "strings" "time" "gitlab.com/Timfa/bluegit/internal/i18n" ) // MaxRedirects is het aantal hops dat een webhook nog volgt. const MaxRedirects = 3 var ( v4Blocked []*net.IPNet v6Blocked []*net.IPNet ) func init() { // RFC1918, loopback, link-local (daar zit 169.254.169.254 bij), // CGNAT, unspecified, multicast en gereserveerd. v4Blocked = mustCIDR( "0.0.0.0/8", "10.0.0.0/8", "100.64.0.0/10", "127.0.0.0/8", "169.254.0.0/16", "172.16.0.0/12", "192.168.0.0/16", "224.0.0.0/4", "240.0.0.0/4", ) // Loopback, ULA, link-local, het oude site-local, multicast. v6Blocked = mustCIDR( "::1/128", "fc00::/7", "fe80::/10", "fec0::/10", "ff00::/8", ) } func mustCIDR(cidrs ...string) []*net.IPNet { var out []*net.IPNet for _, c := range cidrs { _, n, err := net.ParseCIDR(c) if err != nil { panic(err) } out = append(out, n) } return out } // Private meldt of ip geen publiek unicast-adres is. // IPv4-mapped adressen, 6to4 en NAT64 (64:ff9b::/96) worden beoordeeld // op het ingebedde IPv4-adres. func Private(ip net.IP) bool { if ip == nil { return true } if v4 := embeddedV4(ip); v4 != nil { return privateV4(v4) } if v4 := ip.To4(); v4 != nil { return privateV4(v4) } v6 := ip.To16() if v6 == nil { return true } if v6.Equal(net.IPv6unspecified) { return true } for _, n := range v6Blocked { if n.Contains(v6) { return true } } return false } func privateV4(ip net.IP) bool { ip = ip.To4() if ip == nil { return true } for _, n := range v4Blocked { if n.Contains(ip) { return true } } return false } // embeddedV4 haalt een IPv4-adres uit 6to4 (2002::/16) of NAT64 (64:ff9b::/96). func embeddedV4(ip net.IP) net.IP { v6 := ip.To16() if v6 == nil || ip.To4() != nil { return nil } if v6[0] == 0x20 && v6[1] == 0x02 { return net.IPv4(v6[2], v6[3], v6[4], v6[5]).To4() } if v6[0] == 0x00 && v6[1] == 0x64 && v6[2] == 0xff && v6[3] == 0x9b && allZero(v6[4:12]) { return net.IPv4(v6[12], v6[13], v6[14], v6[15]).To4() } return nil } func allZero(b []byte) bool { for _, c := range b { if c != 0 { return false } } return true } // Lookup zoekt de adressen van een hostnaam. Tests vullen een eigen functie in. type Lookup func(ctx context.Context, host string) ([]net.IP, error) func defaultLookup(ctx context.Context, host string) ([]net.IP, error) { addrs, err := net.DefaultResolver.LookupIPAddr(ctx, host) if err != nil { return nil, err } out := make([]net.IP, 0, len(addrs)) for _, a := range addrs { out = append(out, a.IP) } return out, nil } // Pin kiest het IP waarmee verbonden wordt. // Een letterlijk privéadres wordt geweigerd zonder DNS. Een naam waarvan // minstens één adres geblokkeerd is, wordt helemaal geweigerd: anders kan // het tweede antwoord alsnog naar het lokale net wijzen. func Pin(ctx context.Context, host string, lookup Lookup) (net.IP, error) { host = strings.TrimSuffix(strings.TrimSpace(host), ".") if host == "" { return nil, i18n.E("err.whHost") } if ip := net.ParseIP(host); ip != nil { if Private(ip) { return nil, i18n.E("err.whBlockedIP", ip.String()) } return ip, nil } if lookup == nil { lookup = defaultLookup } ips, err := lookup(ctx, host) if err != nil { return nil, i18n.E("err.whDNS", host, err.Error()) } if len(ips) == 0 { return nil, i18n.E("err.whNoAddr", host) } for _, ip := range ips { if Private(ip) { return nil, i18n.E("err.whBlockedHost", host, ip.String()) } } return ips[0], nil } // ValidateURL keurt het schema, een userinfo en een letterlijk privéadres af. func ValidateURL(u *url.URL) error { if u == nil || u.Hostname() == "" || u.User != nil { return i18n.E("err.whURL") } if u.Scheme != "http" && u.Scheme != "https" { return i18n.E("err.whScheme") } if ip := net.ParseIP(u.Hostname()); ip != nil && Private(ip) { return i18n.E("err.whBlockedIP", ip.String()) } return nil } func checkRedirect(req *http.Request, via []*http.Request) error { if len(via) >= MaxRedirects { return i18n.E("err.whRedirects") } if err := ValidateURL(req.URL); err != nil { return err } if len(via) == 0 || via[0].URL == nil || sameHost(via[0].URL, req.URL) { return nil } if req.Response != nil && (req.Response.StatusCode == http.StatusTemporaryRedirect || req.Response.StatusCode == http.StatusPermanentRedirect) { return i18n.E("err.whRedirectHost") } for k := range req.Header { if strings.EqualFold(k, "Content-Type") || strings.EqualFold(k, "User-Agent") { continue } req.Header.Del(k) } return nil } func sameHost(a, b *url.URL) bool { if a == nil || b == nil { return false } return strings.EqualFold(a.Hostname(), b.Hostname()) } // NewClient belt alleen publieke IP's en zet het gekozen adres vast. // Omgevingsproxies worden niet gebruikt. func NewClient(timeout time.Duration) *http.Client { dialer := &net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second} transport := &http.Transport{ DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) { host, port, err := net.SplitHostPort(addr) if err != nil { return nil, err } ip, err := Pin(ctx, host, nil) if err != nil { return nil, err } return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port)) }, TLSHandshakeTimeout: 5 * time.Second, ForceAttemptHTTP2: true, } if timeout <= 0 { timeout = 10 * time.Second } return &http.Client{Timeout: timeout, Transport: transport, CheckRedirect: checkRedirect} }