package sshd import ( "bytes" "context" "fmt" "io" "log/slog" "net" "os" "os/exec" "path/filepath" "strconv" "strings" "testing" "time" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/store" "golang.org/x/crypto/ssh" ) func TestOpenSSHClonePush(t *testing.T) { if _, err := exec.LookPath("git"); err != nil { t.Skip("git ontbreekt") } sshBin := testSSH(t) clientKex := sshQuery(t, sshBin, "kex") supportsMLKEM := strings.Contains(clientKex, kexMLKEM) && kexSupported(kexMLKEM) version := sshVersion(t, sshBin) storage := t.TempDir() st := openSSHStore(t) ctx := context.Background() user, err := st.UpsertUser(ctx, 1, "tim", "", false) if err != nil { t.Fatal(err) } if _, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private"); err != nil { t.Fatal(err) } repoDir := gitrepo.Dir(storage, "tim", "demo") git(t, "", "init", "--bare", "--initial-branch", "master", repoDir) key := filepath.Join(t.TempDir(), "id_ed25519") if out, err := exec.Command("ssh-keygen", "-t", "ed25519", "-f", key, "-N", "", "-q").CombinedOutput(); err != nil { t.Fatalf("ssh-keygen: %v %s", err, out) } pubLine, err := os.ReadFile(key + ".pub") if err != nil { t.Fatal(err) } pub, _, _, _, err := ssh.ParseAuthorizedKey(bytes.TrimSpace(pubLine)) if err != nil { t.Fatal(err) } stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub))) if err := st.AddSSHKey(ctx, user.ID, "laptop", stored, ssh.FingerprintSHA256(pub)); err != nil { t.Fatal(err) } log := slog.New(slog.NewTextHandler(io.Discard, nil)) base := &Server{Store: st, GitBin: "git", Storage: storage, Log: log} if opensshMajor(version) >= 10 { // Geen kopie van base: Server bevat een sync.RWMutex en go vet // weigert die assignment. limited := &Server{Store: st, GitBin: "git", Storage: storage, Log: log, kex: []string{kexCurve, kexLibSSH}} addr := startSSH(t, limited) out := sshProbe(t, sshBin, key, addr) // De waarschuwing zelf kwam pas in OpenSSH 10.1 (Debian 10.0 toont // hem niet); de gekozen kex is wat telt. if !strings.Contains(out, "kex: algorithm: curve25519-sha256") { t.Fatalf("fallback hoort curve25519 te zijn:\n%s", out) } } addr := startSSH(t, base) out := sshProbe(t, sshBin, key, addr) if supportsMLKEM { if strings.Contains(out, "post-quantum") { t.Fatalf("waarschuwing bleef staan:\n%s", out) } if !strings.Contains(out, "kex: algorithm: "+kexMLKEM) { t.Fatalf("geen mlkem:\n%s", out) } } else if !strings.Contains(out, "kex: algorithm: curve25519-sha256") { t.Fatalf("oude client hoort op curve25519 te vallen:\n%s", out) } work := filepath.Join(t.TempDir(), "work") remote := fmt.Sprintf("ssh://git@%s/tim/demo.git", addr) gitSSH(t, sshBin, key, addr, "", "init", "-b", "master", work) if err := os.WriteFile(filepath.Join(work, "README"), []byte("hallo\n"), 0o644); err != nil { t.Fatal(err) } gitSSH(t, sshBin, key, addr, work, "add", "README") gitSSH(t, sshBin, key, addr, work, "-c", "user.email=tim@users.git.timfalken.com", "-c", "user.name=tim", "commit", "-m", "een") gitSSH(t, sshBin, key, addr, work, "remote", "add", "origin", remote) gitSSH(t, sshBin, key, addr, work, "push", "-u", "origin", "HEAD:master") clone := filepath.Join(t.TempDir(), "clone") gitSSH(t, sshBin, key, addr, "", "clone", remote, clone) body, err := os.ReadFile(filepath.Join(clone, "README")) if err != nil || string(body) != "hallo\n" { t.Fatalf("clone %q %v", body, err) } } func testSSH(t *testing.T) string { t.Helper() if bin := os.Getenv("BLUEGIT_TEST_SSH"); bin != "" { if _, err := os.Stat(bin); err != nil { t.Fatalf("BLUEGIT_TEST_SSH: %v", err) } return bin } bin, err := exec.LookPath("ssh") if err != nil { t.Skip("ssh ontbreekt") } return bin } func sshVersion(t *testing.T, bin string) string { t.Helper() cmd := exec.Command(bin, "-V") out, _ := cmd.CombinedOutput() line := strings.TrimSpace(string(out)) if i := strings.IndexByte(line, ' '); i > 0 { return line[:i] } return line } func opensshMajor(version string) int { rest, ok := strings.CutPrefix(version, "OpenSSH_") if !ok { return 0 } major, _, _ := strings.Cut(rest, ".") n, err := strconv.Atoi(major) if err != nil { return 0 } return n } func sshQuery(t *testing.T, bin, kind string) string { t.Helper() out, err := exec.Command(bin, "-Q", kind).CombinedOutput() if err != nil { t.Fatalf("ssh -Q %s: %v %s", kind, err, out) } return string(out) } func openSSHStore(t *testing.T) *store.Store { t.Helper() key := make([]byte, 32) for i := range key { key[i] = byte(i + 1) } st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key) if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = st.Close() }) return st } func startSSH(t *testing.T, srv *Server) string { t.Helper() ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } addr := ln.Addr().String() _ = ln.Close() srv.Listen = addr srv.HostKey = filepath.Join(t.TempDir(), "hostkey") ctx, cancel := context.WithCancel(context.Background()) t.Cleanup(cancel) go func() { _ = srv.Run(ctx) }() deadline := time.Now().Add(2 * time.Second) for time.Now().Before(deadline) { conn, err := net.DialTimeout("tcp", addr, 50*time.Millisecond) if err == nil { _ = conn.Close() return addr } time.Sleep(20 * time.Millisecond) } t.Fatalf("ssh luistert niet op %s", addr) return "" } func sshProbe(t *testing.T, bin, key, addr string) string { t.Helper() host, port, err := net.SplitHostPort(addr) if err != nil { t.Fatal(err) } ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second) defer cancel() cmd := exec.CommandContext(ctx, bin, "-vvv", "-i", key, "-o", "IdentitiesOnly=yes", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "BatchMode=yes", "-p", port, "git@"+host, "ls", ) out, _ := cmd.CombinedOutput() return string(out) } func gitSSH(t *testing.T, bin, key, addr, dir string, args ...string) { t.Helper() _, port, err := net.SplitHostPort(addr) if err != nil { t.Fatal(err) } sshCmd := fmt.Sprintf("%s -i %s -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o BatchMode=yes -p %s", shellQuote(bin), shellQuote(key), port) cmd := exec.Command("git", args...) if dir != "" { cmd.Dir = dir } cmd.Env = append(os.Environ(), "GIT_SSH_COMMAND="+sshCmd) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out) } } func git(t *testing.T, dir string, args ...string) { t.Helper() cmd := exec.Command("git", args...) if dir != "" { cmd.Dir = dir } if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out) } } func shellQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'" }