package ssrf

import (
	"context"
	"net"
	"net/http"
	"net/url"
	"testing"
)

func TestPrivateRanges(t *testing.T) {
	blocked := []string{
		"0.0.0.0", "10.1.2.3", "127.0.0.1", "127.255.0.1",
		"100.64.0.1", "100.100.100.200", "100.127.255.255",
		"169.254.1.1", "169.254.169.254", "169.254.170.2",
		"172.16.0.1", "172.31.255.255", "192.168.1.1",
		"224.0.0.1", "240.0.0.1", "255.255.255.255",
		"::", "::1", "fc00::1", "fd00:ec2::254", "fd12:3456::1",
		"fe80::1", "fec0::1", "ff02::1",
		"::ffff:10.1.2.3", "::ffff:127.0.0.1",
		"2002:0a00:0001::",
		"64:ff9b::a00:1",
	}
	for _, s := range blocked {
		ip := net.ParseIP(s)
		if ip == nil {
			t.Fatalf("ongeldig testadres %s", s)
		}
		if !Private(ip) {
			t.Errorf("%s hoort geblokkeerd", s)
		}
	}
	allowed := []string{
		"1.1.1.1", "8.8.8.8", "203.0.113.5", "86.95.10.20",
		"100.63.255.255", "172.15.255.255", "172.32.0.1", "11.0.0.1",
		"2001:4860:4860::8888",
		"2002:0808:0808::",
		"64:ff9b::808:808",
	}
	for _, s := range allowed {
		ip := net.ParseIP(s)
		if ip == nil {
			t.Fatalf("ongeldig testadres %s", s)
		}
		if Private(ip) {
			t.Errorf("%s hoort publiek", s)
		}
	}
}

func TestPinLiteralAndDNS(t *testing.T) {
	ctx := context.Background()
	if _, err := Pin(ctx, "127.0.0.1", func(context.Context, string) ([]net.IP, error) {
		t.Fatal("letterlijk IP hoort geen DNS te doen")
		return nil, nil
	}); err == nil {
		t.Fatal("loopback hoort geweigerd")
	}
	if _, err := Pin(ctx, "169.254.169.254", nil); err == nil {
		t.Fatal("metadata-adres hoort geweigerd")
	}
	got, err := Pin(ctx, "hooks.example", func(context.Context, string) ([]net.IP, error) {
		return []net.IP{net.ParseIP("86.95.10.20")}, nil
	})
	if err != nil {
		t.Fatal(err)
	}
	if !got.Equal(net.ParseIP("86.95.10.20")) {
		t.Fatalf("vastgezet IP %s", got)
	}
	if _, err := Pin(ctx, "evil.example", func(context.Context, string) ([]net.IP, error) {
		return []net.IP{net.ParseIP("1.1.1.1"), net.ParseIP("10.0.0.1")}, nil
	}); err == nil {
		t.Fatal("een gemengd DNS-antwoord hoort geweigerd")
	}
}

func TestRedirectChecksEachHop(t *testing.T) {
	literal, err := url.Parse("http://192.168.1.9/hook")
	if err != nil {
		t.Fatal(err)
	}
	if err := checkRedirect(&http.Request{URL: literal}, nil); err == nil {
		t.Fatal("redirect naar een privé-IP hoort geweigerd")
	}
	next, err := url.Parse("https://hooks.example/hook")
	if err != nil {
		t.Fatal(err)
	}
	via := make([]*http.Request, MaxRedirects)
	for i := range via {
		via[i] = &http.Request{URL: next}
	}
	if err := checkRedirect(&http.Request{URL: next}, via); err == nil {
		t.Fatal("te veel redirects")
	}

	origin, err := url.Parse("https://discord.example/api")
	if err != nil {
		t.Fatal(err)
	}
	other, err := url.Parse("https://other.example/land")
	if err != nil {
		t.Fatal(err)
	}
	req := &http.Request{URL: other, Header: http.Header{}, Response: &http.Response{StatusCode: http.StatusFound}}
	req.Header.Set("Authorization", "Bearer geheim")
	req.Header.Set("Content-Type", "application/json")
	if err := checkRedirect(req, []*http.Request{{URL: origin}}); err != nil {
		t.Fatal(err)
	}
	if req.Header.Get("Authorization") != "" {
		t.Fatal("header naar een andere host bleef staan")
	}
	if req.Header.Get("Content-Type") != "application/json" {
		t.Fatal("content-type hoort te blijven")
	}
	keep := &http.Request{URL: other, Header: http.Header{}, Response: &http.Response{StatusCode: http.StatusTemporaryRedirect}}
	if err := checkRedirect(keep, []*http.Request{{URL: origin}}); err == nil {
		t.Fatal("307 naar een andere host hoort geweigerd")
	}
}
