// 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}
}
