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")
}
}
func TestPickupDeadKeysAreRemoved(t *testing.T) {
for _, step := range []func(http.ResponseWriter){gone("denied"), func(w http.ResponseWriter) { w.WriteHeader(404) }} {
r := newPickupRig(t)
keyFile, _ := r.newKey()
srv := fakeForge(t, []func(http.ResponseWriter){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()
if _, err := os.Stat(keyFile); !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")
}
}