package main
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"net"
"net/http"
"net/url"
"os"
"os/exec"
"path/filepath"
"regexp"
"strconv"
"strings"
"time"
)
// quarry pickup: the client half of RFC 0030's credential pickup. It
// makes the pickup key, collects the credential from the forge's collect
// route, and hands it to zit through ZIT_PASSWORD, so the value is in no
// argv, log, file or terminal of the caller.
const (
pickupPoll = 10 * time.Second // the route allows 6 a minute for one key
pickupDefaultWait = 15 * time.Minute
pickupBodyMax = 1 << 20
)
var pickupAgentName = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$`)
type pickupEnv struct {
client *http.Client
stdout io.Writer
stderr io.Writer
stateDir string
now func() time.Time
sleep func(ctx context.Context, d time.Duration) error
// run starts zit in dir with env added to the caller's environment
// and returns its combined output.
run func(ctx context.Context, dir string, env []string, args []string) (string, error)
}
func pickupMain(args []string) int {
e := &pickupEnv{stdout: os.Stdout, stderr: os.Stderr}
return pickupCmd(context.Background(), args, e)
}
func (e *pickupEnv) fill() {
if e.client == nil {
e.client = &http.Client{Timeout: time.Minute}
}
// The key goes to the address given and nowhere else.
c := *e.client
c.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
e.client = &c
if e.now == nil {
e.now = time.Now
}
if e.sleep == nil {
e.sleep = func(ctx context.Context, d time.Duration) error {
t := time.NewTimer(d)
defer t.Stop()
select {
case <-ctx.Done():
return ctx.Err()
case <-t.C:
return nil
}
}
}
if e.run == nil {
e.run = func(ctx context.Context, dir string, env []string, args []string) (string, error) {
cmd := exec.CommandContext(ctx, "zit", args...)
cmd.Dir = dir
base := os.Environ()[:0:0]
for _, kv := range os.Environ() {
if !strings.HasPrefix(kv, "ZIT_PASSWORD=") {
base = append(base, kv)
}
}
cmd.Env = append(base, env...)
out, err := cmd.CombinedOutput()
return string(out), err
}
}
if e.stateDir == "" {
if d := os.Getenv("XDG_STATE_HOME"); d != "" {
e.stateDir = filepath.Join(d, "quarry", "pickup")
} else if h, err := os.UserHomeDir(); err == nil {
e.stateDir = filepath.Join(h, ".local", "state", "quarry", "pickup")
}
}
}
// Exit statuses: 0 done, 1 refused or closed, 2 usage, 3 still pending
// when the wait ended.
func pickupCmd(ctx context.Context, args []string, e *pickupEnv) int {
e.fill()
fail := func(code int, format string, a ...any) int {
fmt.Fprintf(e.stderr, "quarry pickup: "+format+"\n", a...)
return code
}
if len(args) == 0 {
return fail(2, "usage: quarry pickup new [--dir D] | collect URL [--key FILE] [--wait D] (--clone DIR | --checkout DIR | --print-env)")
}
switch args[0] {
case "new":
fs := flag.NewFlagSet("pickup new", flag.ContinueOnError)
fs.SetOutput(io.Discard)
dir := fs.String("dir", e.stateDir, "")
if err := fs.Parse(args[1:]); err != nil || fs.NArg() != 0 || *dir == "" {
return fail(2, "usage: quarry pickup new [--dir D]")
}
code, err := pickupMake(*dir)
if err != nil {
return fail(1, "%v", err)
}
fmt.Fprintln(e.stdout, code)
return 0
case "collect":
return pickupCollect(ctx, args[1:], e, fail)
}
return fail(2, "unknown subcommand %q", args[0])
}
func pickupMake(dir string) (string, error) {
key := make([]byte, 32)
if _, err := rand.Read(key); err != nil {
return "", err
}
sum := sha256.Sum256(key)
code := hex.EncodeToString(sum[:])
if err := os.MkdirAll(dir, 0o700); err != nil {
return "", err
}
f, err := os.OpenFile(filepath.Join(dir, code), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
if err != nil {
return "", err
}
_, werr := f.Write(key)
if cerr := f.Close(); werr == nil {
werr = cerr
}
if werr != nil {
os.Remove(f.Name())
return "", werr
}
return code, nil
}
type pickupAnswer struct {
Agent string `json:"agent"`
Result struct {
Agent string `json:"agent"`
Remotes []struct {
URL string `json:"url"`
} `json:"remotes"`
} `json:"result"`
Secret struct {
Value string `json:"value"`
} `json:"secret"`
State string `json:"state"`
}
func pickupCollect(ctx context.Context, args []string, e *pickupEnv, fail func(int, string, ...any) int) int {
fs := flag.NewFlagSet("pickup collect", flag.ContinueOnError)
fs.SetOutput(io.Discard)
keyPath := fs.String("key", "", "")
wait := fs.Duration("wait", pickupDefaultWait, "")
clone := fs.String("clone", "", "")
checkout := fs.String("checkout", "", "")
printEnv := fs.Bool("print-env", false, "")
var rawURL string
rest := args
for {
if err := fs.Parse(rest); err != nil {
return fail(2, "bad flags: %v", err)
}
if fs.NArg() == 0 {
break
}
if rawURL != "" {
return fail(2, "one URL only")
}
rawURL, rest = fs.Arg(0), fs.Args()[1:]
}
modes := 0
for _, on := range []bool{*clone != "", *checkout != "", *printEnv} {
if on {
modes++
}
}
if rawURL == "" || modes != 1 {
return fail(2, "usage: quarry pickup collect URL [--key FILE] [--wait D] (--clone DIR | --checkout DIR | --print-env)")
}
base, collectURL, err := pickupURL(rawURL)
if err != nil {
return fail(2, "%v", err)
}
if *keyPath == "" {
ents, _ := os.ReadDir(e.stateDir)
if len(ents) != 1 {
return fail(2, "give --key FILE (%d keys are kept in the default directory)", len(ents))
}
*keyPath = filepath.Join(e.stateDir, ents[0].Name())
}
key, err := os.ReadFile(*keyPath)
if err != nil || len(key) != 32 {
return fail(2, "the key file cannot be used")
}
auth := "Pickup " + base64.RawURLEncoding.EncodeToString(key)
deadline := e.now().Add(*wait)
var ans pickupAnswer
for {
status, retry, body, err := pickupPost(ctx, e, collectURL, auth)
if err != nil {
return fail(1, "%v", err)
}
if status == http.StatusOK {
if err := json.Unmarshal(body, &ans); err != nil {
return fail(1, "the forge's answer was not understood")
}
break
}
var st pickupAnswer
json.Unmarshal(body, &st)
pause := pickupPoll
switch status {
case http.StatusAccepted:
case http.StatusTooManyRequests:
if retry > 0 {
pause = retry
}
case http.StatusGone:
return fail(1, "the credential cannot be collected: %s", pickupWord(st.State))
case http.StatusConflict:
return fail(1, "this credential does not reach that repository; nothing was collected")
case http.StatusNotFound:
return fail(1, "no such pickup: the forge holds no request for this key")
default:
return fail(1, "the forge answered %d", status)
}
if !e.now().Add(pause).Before(deadline) {
return fail(3, "still pending when the wait ended")
}
if err := e.sleep(ctx, pause); err != nil {
return fail(1, "interrupted")
}
}
secret := ans.Secret.Value
scrub := func(s string) string {
if secret != "" {
s = strings.ReplaceAll(s, secret, "***")
}
return s
}
// The forge has handed the value over once and cleared it: the key
// opens nothing more.
os.Remove(*keyPath)
agent := ans.Result.Agent
if agent == "" || secret == "" || !pickupAgentName.MatchString(agent) || (ans.Agent != "" && ans.Agent != agent) {
return fail(1, "the answer is not a credential for an agent; refused")
}
var first string
for _, r := range ans.Result.Remotes {
u, err := url.Parse(r.URL)
if err != nil || u.Scheme != base.Scheme || u.Host != base.Host {
return fail(1, "the answer names a remote that is not on the forge's own host; refused")
}
if first == "" {
first = r.URL
}
}
target := rawURL
if strings.Trim(base.Path, "/") == "" {
if first == "" {
return fail(1, "the answer names no remote to use")
}
target = first
}
env := []string{"ZIT_PASSWORD=" + secret}
run := func(dir string, env []string, args ...string) int {
out, err := e.run(ctx, dir, env, args)
if err != nil {
fmt.Fprintf(e.stderr, "quarry pickup: zit %s failed: %s\n", args[0], scrub(strings.TrimSpace(tail(out, 400))))
return 1
}
return 0
}
switch {
case *clone != "":
if rc := run("", env, "clone", target, *clone, "--user", agent); rc != 0 {
return rc
}
case *checkout != "":
if rc := run(*checkout, nil, "remote", target); rc != 0 {
return rc
}
if rc := run(*checkout, env, "pull", "--user", agent); rc != 0 {
return rc
}
default:
fmt.Fprintf(e.stdout, "export ZIT_PASSWORD='%s'\n", strings.ReplaceAll(secret, "'", `'\''`))
return 0
}
fmt.Fprintf(e.stdout, "logged in as %s\n", agent)
return 0
}
func tail(s string, n int) string {
if len(s) > n {
return s[len(s)-n:]
}
return s
}
func pickupWord(state string) string {
switch state {
case "denied", "failed", "expired", "lapsed", "collected":
return state
}
return "closed"
}
// pickupURL is the forge URL given and the collect route for it: a bare
// origin collects at the API's path, a repository's sync URL at its own
// /pickup.
func pickupURL(raw string) (*url.URL, string, error) {
u, err := url.Parse(raw)
if err != nil || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" {
return nil, "", errors.New("URL must be a forge address with no login, query or fragment")
}
switch u.Scheme {
case "https":
case "http":
if ip := net.ParseIP(u.Hostname()); !(ip != nil && ip.IsLoopback()) && u.Hostname() != "localhost" {
return nil, "", errors.New("the key is sent only over https (http only to loopback)")
}
default:
return nil, "", errors.New("URL must be http or https")
}
c := *u
if p := strings.Trim(u.Path, "/"); p == "" {
c.Path = "/api/v1/pickups/collect"
} else {
c.Path = "/" + p + "/pickup"
}
return u, c.String(), nil
}
func pickupPost(ctx context.Context, e *pickupEnv, u, auth string) (status int, retry time.Duration, body []byte, err error) {
req, err := http.NewRequestWithContext(ctx, "POST", u, nil)
if err != nil {
return 0, 0, nil, errors.New("bad URL")
}
req.Header.Set("Authorization", auth)
resp, err := e.client.Do(req)
if err != nil {
// The transport's error carries the URL, never the header.
var ue *url.Error
if errors.As(err, &ue) {
err = ue.Err
}
return 0, 0, nil, fmt.Errorf("the forge could not be reached: %v", err)
}
defer resp.Body.Close()
body, err = io.ReadAll(io.LimitReader(resp.Body, pickupBodyMax))
if err != nil {
return 0, 0, nil, errors.New("the forge's answer was cut off")
}
if n, err := strconv.Atoi(resp.Header.Get("Retry-After")); err == nil && n > 0 {
retry = time.Duration(n) * time.Second
}
return resp.StatusCode, retry, body, nil
}