Skip to content
quarry Artifact [60b014a255]
Login

Artifact [60b014a255]

Artifact 60b014a255aa2715c0045c0c0e9057659bdce30be6a1239a4c2b82db1112d243:


package pickupclient

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync/atomic"
	"testing"
	"time"
)

const pickupTestSecret = "s3cr3t-token-value-0123456789"

type zitCall struct {
	dir  string
	env  []string
	args []string
}

type pickupRig struct {
	t      *testing.T
	dir    string
	out    bytes.Buffer
	errw   bytes.Buffer
	calls  []zitCall
	sleeps []time.Duration
	runErr error
	// remoteOut is what a bare "zit remote" prints; failOn names the
	// zit command that fails.
	remoteOut string
	failOn    string
}

func (r *pickupRig) env() *Env {
	return &Env{
		Client:   &http.Client{},
		Stdout:   &r.out,
		Stderr:   &r.errw,
		StateDir: filepath.Join(r.dir, "state"),
		Sleep: func(ctx context.Context, d time.Duration) error {
			r.sleeps = append(r.sleeps, d)
			return nil
		},
		Run: func(ctx context.Context, dir string, env []string, args []string) (string, error) {
			r.calls = append(r.calls, zitCall{dir, env, args})
			if len(args) == 1 && args[0] == "remote" {
				return r.remoteOut, nil
			}
			if r.failOn == args[0] {
				return "", os.ErrInvalid
			}
			return "", r.runErr
		},
	}
}

func (r *pickupRig) do(args ...string) int {
	return Command(context.Background(), args, r.env())
}

func newPickupRig(t *testing.T) *pickupRig { return &pickupRig{t: t, dir: t.TempDir()} }

func (r *pickupRig) newKey() (keyFile, code string) {
	r.t.Helper()
	keys := filepath.Join(r.dir, "keys")
	if rc := r.do("new", "--dir", keys); rc != 0 {
		r.t.Fatalf("FAIL: new exited %d", rc)
	}
	code = strings.TrimSpace(r.out.String())
	r.out.Reset()
	return filepath.Join(keys, code), code
}

// fakeForge answers the collect route as the real one does; script is
// the answers in order, the last repeating.
func fakeForge(t *testing.T, script []func(w http.ResponseWriter), seen *[]string) *httptest.Server {
	var n atomic.Int32
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		if req.Method != "POST" || !strings.HasSuffix(req.URL.Path, "/pickup") && req.URL.Path != "/api/v1/pickups/collect" {
			w.WriteHeader(404)
			return
		}
		if seen != nil {
			*seen = append(*seen, req.Header.Get("Authorization"))
		}
		i := int(n.Add(1)) - 1
		if i >= len(script) {
			i = len(script) - 1
		}
		w.Header().Set("Content-Type", "application/json")
		script[i](w)
	}))
}

func pending(w http.ResponseWriter) { w.WriteHeader(202); w.Write([]byte(`{"state":"pending"}`)) }
func gone(state string) func(http.ResponseWriter) {
	return func(w http.ResponseWriter) {
		w.WriteHeader(410)
		json.NewEncoder(w).Encode(map[string]string{"state": state, "error": "x"})
	}
}
func approved(host string) func(http.ResponseWriter) {
	return func(w http.ResponseWriter) {
		json.NewEncoder(w).Encode(map[string]any{
			"request": "r1", "op": "agent.setup", "agent": "client of dan", "owner": "dan",
			"result": map[string]any{"agent": "bot", "token": map[string]string{"id": "tok1"}, "remotes": []map[string]string{{"repo": "ns/r", "url": host + "/r/ns/r", "project_code": "abc"}}},
			"secret": map[string]string{"value": pickupTestSecret},
		})
	}
}

func (r *pickupRig) noLeak() {
	r.t.Helper()
	for _, c := range r.calls {
		for _, a := range c.args {
			if strings.Contains(a, pickupTestSecret) {
				r.t.Errorf("FAIL: secret in argv %v", c.args)
			}
		}
	}
	if strings.Contains(r.out.String()+r.errw.String(), pickupTestSecret) {
		r.t.Errorf("FAIL: secret in captured output")
	}
}

func TestPickupNewWritesKey0600PrintsOnlyCode(t *testing.T) {
	r := newPickupRig(t)
	keyFile, code := r.newKey()
	st, err := os.Stat(keyFile)
	if err != nil {
		t.Fatalf("FAIL: key file: %v", err)
	}
	if st.Mode().Perm() != 0o600 {
		t.Errorf("FAIL: mode %v", st.Mode().Perm())
	}
	raw, _ := os.ReadFile(keyFile)
	sum := sha256.Sum256(raw)
	if len(raw) != 32 || hex.EncodeToString(sum[:]) != code {
		t.Errorf("FAIL: key is not 32 bytes hashing to the code")
	}
	if strings.Contains(r.out.String(), base64.RawURLEncoding.EncodeToString(raw)) {
		t.Errorf("FAIL: key printed")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupNewRefusesToOverwrite(t *testing.T) {
	r := newPickupRig(t)
	keys := filepath.Join(r.dir, "keys")
	r.do("new", "--dir", keys)
	before, _ := os.ReadDir(keys)
	r.do("new", "--dir", keys)
	after, _ := os.ReadDir(keys)
	if len(before) != 1 || len(after) != 2 {
		t.Errorf("FAIL: each new is its own file and never replaces one: %d then %d", len(before), len(after))
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupCollectPendingThenApprovedClone(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	raw, _ := os.ReadFile(keyFile)
	var seen []string
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){pending, pending, func(w http.ResponseWriter) { approved(srv.URL)(w) }}, &seen)
	defer srv.Close()
	dest := filepath.Join(r.dir, "co")
	rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", dest)
	if rc != 0 {
		t.Fatalf("FAIL: exit %d: %s", rc, r.errw.String())
	}
	if len(seen) != 3 {
		t.Errorf("FAIL: %d polls", len(seen))
	}
	want := "Pickup " + base64.RawURLEncoding.EncodeToString(raw)
	for _, a := range seen {
		if a != want {
			t.Errorf("FAIL: authorization header shape")
		}
	}
	if len(r.sleeps) != 2 || r.sleeps[0] < 10*time.Second {
		t.Errorf("FAIL: polling budget: %v", r.sleeps)
	}
	if len(r.calls) != 1 {
		t.Fatalf("FAIL: zit calls %d", len(r.calls))
	}
	c := r.calls[0]
	if c.args[0] != "clone" || c.args[1] != srv.URL+"/r/ns/r" || c.args[2] != dest {
		t.Errorf("FAIL: argv %v", c.args)
	}
	if !contains(c.args, "--user") || !contains(c.args, "bot") {
		t.Errorf("FAIL: --user missing %v", c.args)
	}
	if !contains(c.env, "ZIT_PASSWORD="+pickupTestSecret) {
		t.Errorf("FAIL: password not in env")
	}
	if _, err := os.Stat(keyFile); !os.IsNotExist(err) {
		t.Errorf("FAIL: key file remains")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func contains(s []string, v string) bool {
	for _, x := range s {
		if x == v {
			return true
		}
	}
	return false
}

func TestPickupCollectCheckout(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	co := filepath.Join(r.dir, "co")
	os.MkdirAll(co, 0o755)
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--checkout", co); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if len(r.calls) != 3 || len(r.calls[0].args) != 1 || r.calls[1].args[0] != "remote" || r.calls[2].args[0] != "pull" {
		t.Fatalf("FAIL: calls %v", r.calls)
	}
	for _, c := range r.calls {
		if c.dir != co {
			t.Errorf("FAIL: ran in %q", c.dir)
		}
	}
	if !contains(r.calls[2].env, "ZIT_PASSWORD="+pickupTestSecret) || !contains(r.calls[2].args, "bot") {
		t.Errorf("FAIL: pull login")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupTerminalStatesExitNonZero(t *testing.T) {
	for _, st := range []string{"denied", "lapsed", "expired", "failed", "collected"} {
		r := newPickupRig(t)
		keyFile, _ := r.newKey()
		srv := fakeForge(t, []func(http.ResponseWriter){gone(st)}, nil)
		rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", filepath.Join(r.dir, "x"))
		srv.Close()
		if rc != 1 {
			t.Errorf("FAIL: %s exit %d", st, rc)
		}
		if len(r.calls) != 0 {
			t.Errorf("FAIL: %s ran zit", st)
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupPendingPastWaitExits3(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	srv := fakeForge(t, []func(http.ResponseWriter){pending}, nil)
	defer srv.Close()
	e := r.env()
	clock := time.Unix(0, 0)
	e.Now = func() time.Time { return clock }
	e.Sleep = func(ctx context.Context, d time.Duration) error { clock = clock.Add(d); return nil }
	rc := Command(context.Background(), []string{"collect", srv.URL + "/r/ns/r", "--key", keyFile, "--clone", "x", "--wait", "35s"}, e)
	if rc != 3 {
		t.Errorf("FAIL: exit %d", rc)
	}
	if _, err := os.Stat(keyFile); err != nil {
		t.Errorf("FAIL: key must stay while pending")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickup429HonoursRetryAfter(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	busy := func(w http.ResponseWriter) { w.Header().Set("Retry-After", "42"); w.WriteHeader(429) }
	srv = fakeForge(t, []func(http.ResponseWriter){busy, func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if len(r.sleeps) != 1 || r.sleeps[0] != 42*time.Second {
		t.Errorf("FAIL: sleeps %v", r.sleeps)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupRefusesForeignHost(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	srv := fakeForge(t, []func(http.ResponseWriter){approved("https://evil.example")}, nil)
	defer srv.Close()
	rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d")
	if rc == 0 {
		t.Errorf("FAIL: foreign remote accepted")
	}
	if len(r.calls) != 0 {
		t.Errorf("FAIL: zit ran")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupRefusesRedirect(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var hit atomic.Int32
	other := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { hit.Add(1) }))
	defer other.Close()
	srv := httptest.NewServer(http.RedirectHandler(other.URL, 307))
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc == 0 || hit.Load() != 0 {
		t.Errorf("FAIL: redirect followed (rc %d hits %d)", rc, hit.Load())
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupZitFailureScrubbed(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	e := r.env()
	e.Run = func(ctx context.Context, dir string, env []string, args []string) (string, error) {
		return "login " + pickupTestSecret + " refused", os.ErrInvalid
	}
	rc := Command(context.Background(), []string{"collect", srv.URL + "/r/ns/r", "--key", keyFile, "--clone", "d"}, e)
	if rc == 0 {
		t.Errorf("FAIL: exit 0 on zit failure")
	}
	r.noLeak()
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupPrintEnvOnlyWhenAsked(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile); rc != 2 {
		t.Errorf("FAIL: no mode should be usage, got %d", rc)
	}
	if _, err := os.Stat(keyFile); err != nil {
		t.Errorf("FAIL: usage error consumed the key")
	}
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--print-env"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if !strings.Contains(r.out.String(), "ZIT_PASSWORD=") || !strings.Contains(r.out.String(), pickupTestSecret) {
		t.Errorf("FAIL: env line missing")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func approvedWith(remote string) func(http.ResponseWriter) {
	return func(w http.ResponseWriter) {
		json.NewEncoder(w).Encode(map[string]any{
			"request": "r1", "op": "agent.setup", "agent": "client of dan", "owner": "dan",
			"result": map[string]any{"agent": "bot", "token": map[string]string{"id": "tok1"}, "remotes": []map[string]string{{"repo": "ns/r", "url": remote}}},
			"secret": map[string]string{"value": pickupTestSecret},
		})
	}
}

func TestPickupReleasedThenRefusedNamesWhatToRevoke(t *testing.T) {
	for name, tc := range map[string]struct {
		remote string
		failOn string
	}{
		"foreign host": {remote: "https://evil.example/r/x"},
		"zit fails":    {failOn: "clone"},
	} {
		r := newPickupRig(t)
		keyFile, _ := r.newKey()
		r.failOn = tc.failOn
		var srv *httptest.Server
		srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) {
			rem := tc.remote
			if rem == "" {
				rem = srv.URL + "/r/ns/r"
			}
			approvedWith(rem)(w)
		}}, nil)
		rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", filepath.Join(r.dir, "x"))
		srv.Close()
		if rc != 1 {
			t.Errorf("FAIL: %s: exit %d", name, rc)
		}
		if e := r.errw.String(); !strings.Contains(e, "r1") || !strings.Contains(e, "tok1") {
			t.Errorf("FAIL: %s: stderr does not name the request and token to revoke", name)
		}
		if _, err := os.Stat(keyFile); !os.IsNotExist(err) {
			t.Errorf("FAIL: %s: a spent key remains", name)
		}
		r.noLeak()
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupAcceptsTheServersAskerAndSameOriginForms(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	// the asker is "client of dan" and the remote is a relative path
	srv := fakeForge(t, []func(http.ResponseWriter){approvedWith("/r/ns/r")}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL, "--key", keyFile, "--clone", "d"); rc != 0 {
		t.Fatalf("FAIL: exit %d: %s", rc, r.errw.String())
	}
	if len(r.calls) != 1 || r.calls[0].args[1] != srv.URL+"/r/ns/r" {
		t.Errorf("FAIL: calls %v", r.calls)
	}
	for _, c := range []struct {
		a, b string
		same bool
	}{
		{"https://Forge.Example/x", "https://forge.example:443/y", true},
		{"http://forge.example/x", "http://forge.example:80/y", true},
		{"https://forge.example", "http://forge.example", false},
		{"https://forge.example", "https://forge.example:8443", false},
		{"https://forge.example", "https://forge.example.evil", false},
	} {
		a, _ := url.Parse(c.a)
		b, _ := url.Parse(c.b)
		if sameOrigin(a, b) != c.same {
			t.Errorf("FAIL: sameOrigin(%s, %s) != %v", c.a, c.b, c.same)
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupCheckoutRemoteOnAnotherHostIsRefusedBeforePolling(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var seen []string
	srv := fakeForge(t, []func(http.ResponseWriter){pending}, &seen)
	defer srv.Close()
	r.remoteOut = "https://other.example/r/x\n"
	co := filepath.Join(r.dir, "co")
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--checkout", co); rc == 0 {
		t.Errorf("FAIL: accepted")
	}
	if len(seen) != 0 {
		t.Errorf("FAIL: polled before refusing")
	}
	if _, err := os.Stat(keyFile); err != nil {
		t.Errorf("FAIL: key spent")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupCheckoutPullFailureRestoresTheRemote(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	r.remoteOut = srv.URL + "/r/old\n"
	r.failOn = "pull"
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--checkout", r.dir); rc != 1 {
		t.Errorf("FAIL: exit %d", rc)
	}
	last := r.calls[len(r.calls)-1]
	if len(last.args) != 2 || last.args[0] != "remote" || last.args[1] != srv.URL+"/r/old" {
		t.Errorf("FAIL: previous remote not restored: %v", last.args)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// A 410 is a request gone for good, so its key goes too; a 404 may be
// a mistyped address for a request still pending, so its key stays.
func TestPickupDeadKeysAreRemoved(t *testing.T) {
	for _, c := range []struct {
		step func(http.ResponseWriter)
		kept bool
	}{{gone("denied"), false}, {func(w http.ResponseWriter) { w.WriteHeader(404) }, true}} {
		r := newPickupRig(t)
		keyFile, _ := r.newKey()
		srv := fakeForge(t, []func(http.ResponseWriter){c.step}, nil)
		if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc != 1 {
			t.Errorf("FAIL: exit %d", rc)
		}
		srv.Close()
		_, err := os.Stat(keyFile)
		if c.kept && err != nil {
			t.Errorf("FAIL: a key was removed on a 404")
		}
		if !c.kept && !os.IsNotExist(err) {
			t.Errorf("FAIL: a dead key remains")
		}
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupNewTightensAnExistingDirectory(t *testing.T) {
	r := newPickupRig(t)
	keys := filepath.Join(r.dir, "keys")
	os.Mkdir(keys, 0o755)
	os.Chmod(keys, 0o755)
	if rc := r.do("new", "--dir", keys); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if st, _ := os.Stat(keys); st.Mode().Perm() != 0o700 {
		t.Errorf("FAIL: dir mode %v", st.Mode().Perm())
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupPrintEnvSurvivesAShell(t *testing.T) {
	secret := `a'b"c$d` + "`e`" + `\f;g h*&|<>(){}!#~` + "\n"
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	srv = fakeForge(t, []func(http.ResponseWriter){func(w http.ResponseWriter) {
		json.NewEncoder(w).Encode(map[string]any{"request": "r1", "agent": "client of dan",
			"result": map[string]any{"agent": "bot", "remotes": []map[string]string{{"url": srv.URL + "/r/x"}}},
			"secret": map[string]string{"value": secret}})
	}}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/x", "--key", keyFile, "--print-env"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	got, err := exec.Command("sh", "-c", strings.TrimRight(r.out.String(), "\n")+`; printf %s "$ZIT_PASSWORD"`).Output()
	if err != nil || string(got) != secret {
		t.Errorf("FAIL: the eval'd value differs (%v)", err)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

func TestPickupRetriesServerErrorsWithBackoff(t *testing.T) {
	r := newPickupRig(t)
	keyFile, _ := r.newKey()
	var srv *httptest.Server
	boom := func(w http.ResponseWriter) { w.WriteHeader(503) }
	srv = fakeForge(t, []func(http.ResponseWriter){boom, boom, func(w http.ResponseWriter) { approved(srv.URL)(w) }}, nil)
	defer srv.Close()
	if rc := r.do("collect", srv.URL+"/r/ns/r", "--key", keyFile, "--clone", "d"); rc != 0 {
		t.Fatalf("FAIL: exit %d", rc)
	}
	if len(r.sleeps) != 2 || r.sleeps[1] <= r.sleeps[0] {
		t.Errorf("FAIL: no backoff: %v", r.sleeps)
	}
	if !t.Failed() {
		t.Log("ok")
	}
}

// Hosts compare in ASCII case only: a Unicode fold would let the Kelvin
// sign stand in for k.
func TestSameOriginComparesASCIICaseOnly(t *testing.T) {
	a, _ := url.Parse("https://Forge.Example:443/x")
	b, _ := url.Parse("https://forge.example/y")
	if !sameOrigin(a, b) {
		t.Errorf("FAIL: case and default port did not match")
	}
	k, _ := url.Parse("https://\u212Aeys.example/")
	plain, _ := url.Parse("https://keys.example/")
	if sameOrigin(k, plain) {
		t.Errorf("FAIL: a Kelvin sign matched k")
	}
	if !t.Failed() {
		t.Log("ok")
	}
}