Files
zapret-autotune/cmd/zapret-autotune/resource_check_test.go
T
2026-10-14 12:21:52 +03:00

500 lines
19 KiB
Go

package main
import (
"bytes"
"context"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"sync"
"testing"
"time"
)
const resourceCheckExample = `{"version":1,"services":[{"id":"first","resources":[{"id":"page","group":"web","kind":"http","url":"https://example.com/private?secret=value","method":"GET","tls":"tls12","timeout_ms":1000,"expect":{"statuses":[200],"content_type":"text/plain","min_bytes":1,"max_bytes":100}}]},{"id":"second","resources":[{"id":"headers","group":"web","kind":"http","url_env":"CHECK_URL","method":"HEAD","tls":"both","timeout_ms":1000,"expect":{"statuses":[200],"min_bytes":0,"max_bytes":100},"headers_env":{"Authorization":"CHECK_TOKEN"}}]}]}`
func resourceCheckLookup(key string) (string, bool) {
values := map[string]string{"CHECK_URL": "https://example.org/secret", "CHECK_TOKEN": "Bearer private-token", "ZAPRET_AUTOTUNE_SOCKS_PROXY": "socks5h://127.0.0.1:1080"}
v, ok := values[key]
return v, ok
}
func resourceCheckFile(t *testing.T, data string) string {
t.Helper()
path := filepath.Join(t.TempDir(), "checks.json")
if err := os.WriteFile(path, []byte(data), 0600); err != nil {
t.Fatal(err)
}
return path
}
func configuredWire(raw, method, protocol, mode string, out, diag io.Writer) {
body := "hello"
length := len(body)
if method == "HEAD" {
body, length = "", 999999999
}
status, verify, redirects, speed := 200, 0, 0, 50
if method == "HEAD" {
speed = 0
}
if mode == "redirect" {
status = 302
}
if mode == "status500" {
status = 500
}
if mode == "redirect-count" {
redirects = 1
}
if mode == "verify" {
verify = 60
}
if mode == "origin" {
raw = "https://evil.example/"
}
if mode == "overflow" {
body, length = strings.Repeat("a", 101), 101
}
if mode == "truncated" {
length++
}
if mode == "extra" {
body += "extra"
}
if mode == "chunked" {
fmt.Fprint(out, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n")
body = "5\r\nhello\r\n0\r\n\r\n"
} else {
fmt.Fprintf(out, "HTTP/1.1 %d OK\r\nContent-Type: text/plain\r\nContent-Length: %d\r\n\r\n", status, length)
}
fmt.Fprint(out, body)
metrics, _ := json.Marshal(map[string]interface{}{"url_effective": raw, "ssl_verify_result": verify, "num_redirects": redirects, "http_code": status, "time_total": 0.1, "speed_download": speed, "size_download": len(body)})
fmt.Fprint(out, resourceTrailer, string(metrics))
if mode == "tls" {
protocol = "tls13"
}
version := "1.2"
if protocol == "tls13" {
version = "1.3"
}
fmt.Fprintln(diag, "SSL connection using TLSv"+version)
}
func TestResourceCheckSchema(t *testing.T) {
if _, err := parseResourceChecks([]byte(resourceCheckExample), resourceCheckLookup); err != nil {
t.Fatal(err)
}
for _, data := range []string{
resourceCheckExample + ` {}`, strings.Replace(resourceCheckExample, `"version":1`, `"version":2`, 1),
strings.Replace(resourceCheckExample, `"version":1`, `"version":1,"version":1`, 1),
strings.Replace(resourceCheckExample, `"version":1`, `"unknown":1,"version":1`, 1),
strings.Replace(resourceCheckExample, `"id":"first"`, `"id":"First /"`, 1),
strings.Replace(resourceCheckExample, `"id":"second"`, `"id":"first"`, 1),
strings.Replace(resourceCheckExample, `"max_bytes":100`, `"max_bytes":0`, 1),
strings.Replace(resourceCheckExample, `"method":"GET"`, `"method":"POST"`, 1),
strings.Replace(resourceCheckExample, `"kind":"http"`, `"kind":"image"`, 1),
strings.Replace(resourceCheckExample, `"statuses":[200]`, `"statuses":[302]`, 1),
strings.Replace(resourceCheckExample, `"statuses":[200]`, `"statuses":[200,200]`, 1),
strings.Replace(resourceCheckExample, `"tls":"tls12"`, `"tls":"auto"`, 1),
strings.Replace(resourceCheckExample, `"timeout_ms":1000`, `"timeout_ms":30001`, 1),
strings.Replace(resourceCheckExample, `"headers_env":{"Authorization":"CHECK_TOKEN"}`, `"headers_env":{"Host":"CHECK_TOKEN"}`, 1),
strings.Replace(resourceCheckExample, `"CHECK_TOKEN"`, `"missing"`, 1),
strings.Replace(resourceCheckExample, `"CHECK_TOKEN"`, `"MISSING"`, 1),
strings.Replace(resourceCheckExample, `"CHECK_URL"`, `"MISSING"`, 1),
strings.Replace(resourceCheckExample, `"method":"GET"`, `"method":null`, 1),
strings.Replace(resourceCheckExample, `"kind":"http"`, `"allow_private":true,"kind":"http"`, 1),
strings.Replace(resourceCheckExample, `"kind":"http"`, `"allowed_networks":["10.0.0.1/24"],"kind":"http"`, 1),
} {
if _, err := parseResourceChecks([]byte(data), resourceCheckLookup); err == nil {
t.Fatal("invalid schema accepted")
}
}
for _, raw := range []string{"http://example.com/", "https://user:password@example.com/", "https://example.com:444/", "https://example.com/a%0d%0aHeader", "https://example.com/a\n", "https://example.com/#fragment", "https://example.com:/", "https://[::1]/", "https://2130706433/", "https://127.1/", "https://0x7f000001/", "https://0177.0.0.1/"} {
lookup := func(key string) (string, bool) {
if key == "CHECK_URL" {
return raw, true
}
return resourceCheckLookup(key)
}
if _, err := parseResourceChecks([]byte(resourceCheckExample), lookup); err == nil {
t.Fatal("invalid origin accepted")
}
}
lookup := func(key string) (string, bool) {
if key == "CHECK_TOKEN" {
return "secret\r\nHost: evil", true
}
return resourceCheckLookup(key)
}
if _, err := parseResourceChecks([]byte(resourceCheckExample), lookup); err == nil {
t.Fatal("header injection")
}
for _, name := range []string{"Range", "rAnGe", "Accept-Encoding", "Host", "Connection", "Content-Length", "Proxy-Authorization"} {
data := strings.Replace(resourceCheckExample, `"headers_env":{"Authorization":"CHECK_TOKEN"}`, `"headers_env":{"`+name+`":"CHECK_TOKEN"}`, 1)
if _, err := parseResourceChecks([]byte(data), resourceCheckLookup); err == nil {
t.Fatal("transport header accepted", name)
}
}
}
func TestResourceCheckFiles(t *testing.T) {
path := resourceCheckFile(t, resourceCheckExample)
link := filepath.Join(t.TempDir(), "link")
if err := os.Symlink(path, link); err != nil {
t.Fatal(err)
}
for _, p := range []string{link, t.TempDir(), resourceCheckFile(t, strings.Repeat("x", (1<<20)+1))} {
if _, err := readResourceChecks(p, resourceCheckLookup); err == nil {
t.Fatal("unsafe file accepted")
}
}
if _, err := readResourceChecks(path, resourceCheckLookup); err != nil {
t.Fatal(err)
}
info, _ := os.Stat(path)
if info.Mode().Perm() != 0600 {
t.Fatal("changed permissions")
}
}
func TestResourceCheckResolverPinnedServer(t *testing.T) {
var workers sync.WaitGroup
dial := func(ctx context.Context, network, address string) (net.Conn, error) {
if network != "tcp" || address != dnsListenAddress {
t.Error("DNS fallback", network, address)
}
client, server := net.Pipe()
workers.Add(1)
go func() {
defer workers.Done()
defer server.Close()
server.SetDeadline(time.Now().Add(time.Second))
var length [2]byte
if _, err := io.ReadFull(server, length[:]); err != nil {
t.Error(err)
return
}
query := make([]byte, int(binary.BigEndian.Uint16(length[:])))
if _, err := io.ReadFull(server, query); err != nil {
t.Error(err)
return
}
end, name, ok := dnsQuestion(query)
if !ok {
t.Error("invalid query")
return
}
if !bytes.Equal(name[:len(name)-4], []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0}) {
t.Error("search-domain expansion")
}
response := append([]byte(nil), query[:end]...)
response[2], response[3] = 0x81, 0x80
response[10], response[11] = 0, 0 // strip query EDNS
if binary.BigEndian.Uint16(query[end-4:end-2]) == 1 {
response[7] = 2
for _, ip := range [][]byte{{93, 184, 216, 34}, {10, 0, 0, 1}} {
response = append(response, 0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 1, 0, 4)
response = append(response, ip...)
}
}
binary.BigEndian.PutUint16(length[:], uint16(len(response)))
server.Write(append(length[:], response...))
}()
return client, nil
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
ips, err := resolveResourceIPsWithDial(ctx, dnsListenAddress, "example.com", dial)
workers.Wait()
if err != nil || len(ips) != 2 {
t.Fatal("lost mixed DNS answers", ips, err)
}
for _, ip := range ips {
if ip.String() != "93.184.216.34" && ip.String() != "10.0.0.1" {
t.Fatal("unexpected answer", ip)
}
}
_, err = resolveResourceIPsWithDial(ctx, dnsListenAddress, "example.com", func(context.Context, string, string) (net.Conn, error) {
return nil, errors.New("forwarder unavailable")
})
if err == nil {
t.Fatal("DNS outage fell back")
}
}
func TestResourceCheckDestinationPolicy(t *testing.T) {
cfg, _ := parseResourceChecks([]byte(resourceCheckExample), resourceCheckLookup)
r := cfg.Services[0].Resources[0]
for _, raw := range []string{"127.0.0.1", "10.0.0.1", "172.16.0.1", "192.168.0.1", "169.254.169.254", "0.0.0.0", "224.0.0.1", "100.64.0.1", "100.100.100.200", "198.18.0.1", "::1", "::2", "fe80::1", "fc00::1", "fd00:ec2::254", "168.63.129.16", "::ffff:127.0.0.1", "2002:7f00:1::1"} {
if approvedResourceIP(r, net.ParseIP(raw)) {
t.Fatal("unsafe destination", raw)
}
}
if !approvedResourceIP(r, net.ParseIP("93.184.216.34")) {
t.Fatal("public denied")
}
data := strings.Replace(resourceCheckExample, `"kind":"http"`, `"allow_private":true,"allowed_networks":["10.20.0.0/16"],"kind":"http"`, 1)
cfg, err := parseResourceChecks([]byte(data), resourceCheckLookup)
if err != nil {
t.Fatal(err)
}
r = cfg.Services[0].Resources[0]
if !approvedResourceIP(r, net.ParseIP("10.20.1.2")) || approvedResourceIP(r, net.ParseIP("10.21.1.2")) || approvedResourceIP(r, net.ParseIP("93.184.216.34")) || approvedResourceIP(r, net.ParseIP("169.254.169.254")) {
t.Fatal("explicit subnet policy")
}
data = strings.Replace(resourceCheckExample, `"kind":"http"`, `"allowed_networks":["93.184.216.0/24"],"kind":"http"`, 1)
cfg, err = parseResourceChecks([]byte(data), resourceCheckLookup)
if err != nil {
t.Fatal(err)
}
r = cfg.Services[0].Resources[0]
if !approvedResourceIP(r, net.ParseIP("93.184.216.34")) || approvedResourceIP(r, net.ParseIP("8.8.8.8")) {
t.Fatal("public CIDR did not restrict")
}
data = strings.Replace(resourceCheckExample, `"kind":"http"`, `"allow_private":true,"allowed_networks":["0.0.0.0/0","::/0"],"kind":"http"`, 1)
cfg, err = parseResourceChecks([]byte(data), resourceCheckLookup)
if err != nil {
t.Fatal(err)
}
r = cfg.Services[0].Resources[0]
for _, raw := range []string{"127.0.0.1", "::1", "::ffff:127.0.0.1", "169.254.169.254", "fd00:ec2::254", "100.100.100.200", "168.63.129.16", "198.18.0.1", "fe80::1"} {
if approvedResourceIP(r, net.ParseIP(raw)) {
t.Fatal("private opt-in enabled metadata/reserved", raw)
}
}
}
func TestResourceCheckIsolationPrivacyAndPinning(t *testing.T) {
for _, mode := range []string{"pass", "mixed", "rebind", "runner", "expect", "guard"} {
t.Run(mode, func(t *testing.T) {
calls, resolves, guards := 0, 0, 0
var output, diagnostic bytes.Buffer
d := resourceCheckDeps{lookup: resourceCheckLookup, guard: func() error {
guards++
if mode == "guard" {
return errors.New("private-secret")
}
return nil
}, resolve: func(_ context.Context, server, host string) ([]net.IP, error) {
resolves++
if server != dnsListenAddress {
t.Fatal("wrong resolver")
}
if host == "example.com" && mode == "mixed" {
return []net.IP{net.ParseIP("93.184.216.34"), net.ParseIP("127.0.0.1")}, nil
}
if resolves == 3 && mode == "rebind" {
return []net.IP{net.ParseIP("10.0.0.1")}, nil
}
return []net.IP{net.ParseIP("93.184.216.34")}, nil
}, runner: func(ctx context.Context, args []string, stdin io.Reader, out, diag io.Writer) error {
calls++
argv := strings.Join(args, " ")
if strings.Contains(argv, "example.") || strings.Contains(argv, "secret") || strings.Contains(argv, "private-token") || strings.Contains(argv, "93.184.") {
t.Fatal("private argv", args)
}
config, _ := io.ReadAll(stdin)
if !strings.Contains(string(config), `connect-to = "example.`) || !strings.Contains(string(config), `:443:93.184.216.34:443"`) || strings.Contains(argv, "--resolve") {
t.Fatal("not pinning CONNECT")
}
lines := strings.Split(string(config), "\n")
raw, err := strconv.Unquote(strings.TrimPrefix(lines[0], "url = "))
if err != nil {
t.Fatal(err)
}
method, protocol := "GET", "tls12"
if strings.Contains(argv, "--head") {
method = "HEAD"
if !strings.Contains(string(config), "Bearer private-token") {
t.Fatal("missing private header")
}
}
if strings.Contains(argv, "--tlsv1.3") {
protocol = "tls13"
}
if method == "GET" && mode == "runner" {
return errors.New("private-secret")
}
wireMode := ""
if mode == "expect" && method == "GET" {
wireMode = "redirect"
}
configuredWire(raw, method, protocol, wireMode, out, diag)
return nil
}}
code := resourceCheckCLI(context.Background(), resourceCheckFile(t, resourceCheckExample), &output, &diagnostic, d)
if mode == "pass" && (code != 0 || calls != 3 || resolves != 3) {
t.Fatalf("code=%d calls=%d output=%s", code, calls, output.String())
}
if mode != "pass" && code == 0 {
t.Fatal("false pass")
}
if mode == "rebind" && (calls != 2 || !strings.Contains(output.String(), `"outcome":"destination_denied"`)) {
t.Fatal("rebinding was not revalidated", output.String())
}
if mode != "guard" && strings.Count(output.String(), `"outcome":"pass"`) < 2 {
t.Fatal("failure stopped second service", output.String())
}
if mode == "guard" && (calls != 0 || resolves != 0 || guards != 1) {
t.Fatal("unguarded probe")
}
if strings.Contains(output.String()+diagnostic.String(), "secret") || strings.Contains(output.String(), "example.") || strings.Contains(output.String(), "Bearer") {
t.Fatal("private output")
}
})
}
}
func TestResourceCheckTransferContract(t *testing.T) {
for _, method := range []string{"GET", "HEAD"} {
for _, mode := range []string{"pass", "chunked", "redirect", "redirect-count", "verify", "origin", "tls", "overflow", "truncated", "extra"} {
t.Run(method+"/"+mode, func(t *testing.T) {
if method == "HEAD" && mode == "chunked" {
return
}
runner := func(_ context.Context, _ []string, _ io.Reader, out, diag io.Writer) error {
configuredWire("https://example.com/", method, "tls12", mode, out, diag)
return nil
}
transfer, _, err := collectResourceTransferOptions(context.Background(), "socks5h://127.0.0.1:1080", "https://example.com/", "example.com", "tls12", false, runner, resourceTransferOptions{generic: true, method: method, limit: 100, timeout: time.Second})
valid := mode == "pass" || mode == "chunked" || method == "HEAD" && mode == "truncated"
if (err == nil) != valid {
t.Fatalf("err=%v", err)
}
if method == "HEAD" && err == nil && len(transfer.Body) != 0 {
t.Fatal("HEAD body")
}
})
}
}
}
func TestResourceCheckCancellationAndPrevalidation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
joined := false
d := resourceCheckDeps{lookup: resourceCheckLookup, guard: func() error { return nil }, resolve: func(context.Context, string, string) ([]net.IP, error) {
return []net.IP{net.ParseIP("93.184.216.34")}, nil
}, runner: func(ctx context.Context, _ []string, _ io.Reader, _, _ io.Writer) error {
cancel()
<-ctx.Done()
joined = true
return ctx.Err()
}}
var output, diagnostic bytes.Buffer
if resourceCheckCLI(ctx, resourceCheckFile(t, resourceCheckExample), &output, &diagnostic, d) != 1 || !joined || strings.Count(output.String(), "cancelled") != 1 {
t.Fatal("cancel/join")
}
d.guard = func() error { t.Fatal("guard before all config validated"); return nil }
bad := strings.Replace(resourceCheckExample, `"CHECK_URL"`, `"MISSING"`, 1)
if resourceCheckCLI(context.Background(), resourceCheckFile(t, bad), &output, &diagnostic, d) != 2 {
t.Fatal("prevalidation")
}
// Runtime child deadlines are bounded and returned only after the child joins.
d.guard = func() error { return nil }
d.runner = func(ctx context.Context, _ []string, _ io.Reader, _, _ io.Writer) error {
<-ctx.Done()
return ctx.Err()
}
short := strings.ReplaceAll(resourceCheckExample, `"timeout_ms":1000`, `"timeout_ms":100`)
output.Reset()
if resourceCheckCLI(context.Background(), resourceCheckFile(t, short), &output, &diagnostic, d) != 1 || strings.Count(output.String(), `"outcome":"timeout"`) != 3 {
t.Fatal("timeouts", output.String())
}
}
// This loopback-only SOCKS fixture observes real curl's CONNECT destination.
// It rejects CONNECT immediately: no TLS or resource traffic leaves the fixture.
func TestResourceCheckCurlSOCKSPinnedDestination(t *testing.T) {
if _, err := exec.LookPath("curl"); err != nil {
t.Skip("curl unavailable")
}
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer listener.Close()
target := make(chan string, 1)
go func() {
conn, err := listener.Accept()
if err != nil {
target <- "accept failed"
return
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(3 * time.Second))
fail := func() { target <- "invalid SOCKS framing" }
var hello [2]byte
if _, err := io.ReadFull(conn, hello[:]); err != nil || hello[0] != 5 {
fail()
return
}
methods := make([]byte, int(hello[1]))
if _, err := io.ReadFull(conn, methods); err != nil {
fail()
return
}
conn.Write([]byte{5, 0})
var header [4]byte
if _, err := io.ReadFull(conn, header[:]); err != nil || header[0] != 5 || header[1] != 1 {
fail()
return
}
var host string
switch header[3] {
case 1:
b := make([]byte, 4)
if _, err := io.ReadFull(conn, b); err != nil {
fail()
return
}
host = net.IP(b).String()
case 3:
var size [1]byte
if _, err := io.ReadFull(conn, size[:]); err != nil {
fail()
return
}
b := make([]byte, int(size[0]))
if _, err := io.ReadFull(conn, b); err != nil {
fail()
return
}
host = string(b)
default:
fail()
return
}
var port [2]byte
if _, err := io.ReadFull(conn, port[:]); err != nil || port != [2]byte{1, 187} {
fail()
return
}
target <- host
conn.Write([]byte{5, 5, 0, 1, 0, 0, 0, 0, 0, 0})
}()
ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
defer cancel()
_, _, err = collectResourceTransferOptions(ctx, "socks5h://"+listener.Addr().String(), "https://example.com/private?secret=value", "example.com", "tls12", false, runResourceCurl, resourceTransferOptions{generic: true, method: "GET", limit: 100, timeout: 3 * time.Second, config: "connect-to = \"example.com:443:93.184.216.34:443\"\n"})
if err == nil {
t.Fatal("fixture unexpectedly transferred")
}
select {
case host := <-target:
if host != "93.184.216.34" {
t.Fatal("CONNECT not pinned", host)
}
case <-ctx.Done():
t.Fatal("SOCKS child not joined")
}
}