BlueGit

timfa bluegit

Files

bluegit / internal / sshd / client_test.go

client_test.go

client_test.go 6.8 KiB Download Raw
1package sshd
2
3import (
4 "bytes"
5 "context"
6 "fmt"
7 "io"
8 "log/slog"
9 "net"
10 "os"
11 "os/exec"
12 "path/filepath"
13 "strconv"
14 "strings"
15 "testing"
16 "time"
17
18 "gitlab.com/Timfa/bluegit/internal/gitrepo"
19 "gitlab.com/Timfa/bluegit/internal/store"
20 "golang.org/x/crypto/ssh"
21)
22
23func TestOpenSSHClonePush(t *testing.T) {
24 if _, err := exec.LookPath("git"); err != nil {
25 t.Skip("git ontbreekt")
26 }
27 sshBin := testSSH(t)
28 clientKex := sshQuery(t, sshBin, "kex")
29 supportsMLKEM := strings.Contains(clientKex, kexMLKEM) && kexSupported(kexMLKEM)
30 version := sshVersion(t, sshBin)
31
32 storage := t.TempDir()
33 st := openSSHStore(t)
34 ctx := context.Background()
35 user, err := st.UpsertUser(ctx, 1, "tim", "", false)
36 if err != nil {
37 t.Fatal(err)
38 }
39 if _, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private"); err != nil {
40 t.Fatal(err)
41 }
42 repoDir := gitrepo.Dir(storage, "tim", "demo")
43 git(t, "", "init", "--bare", "--initial-branch", "master", repoDir)
44
45 key := filepath.Join(t.TempDir(), "id_ed25519")
46 if out, err := exec.Command("ssh-keygen", "-t", "ed25519", "-f", key, "-N", "", "-q").CombinedOutput(); err != nil {
47 t.Fatalf("ssh-keygen: %v %s", err, out)
48 }
49 pubLine, err := os.ReadFile(key + ".pub")
50 if err != nil {
51 t.Fatal(err)
52 }
53 pub, _, _, _, err := ssh.ParseAuthorizedKey(bytes.TrimSpace(pubLine))
54 if err != nil {
55 t.Fatal(err)
56 }
57 stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
58 if err := st.AddSSHKey(ctx, user.ID, "laptop", stored, ssh.FingerprintSHA256(pub)); err != nil {
59 t.Fatal(err)
60 }
61
62 log := slog.New(slog.NewTextHandler(io.Discard, nil))
63 base := &Server{Store: st, GitBin: "git", Storage: storage, Log: log}
64
65 if opensshMajor(version) >= 10 {
66 // Geen kopie van base: Server bevat een sync.RWMutex en go vet
67 // weigert die assignment.
68 limited := &Server{Store: st, GitBin: "git", Storage: storage, Log: log, kex: []string{kexCurve, kexLibSSH}}
69 addr := startSSH(t, limited)
70 out := sshProbe(t, sshBin, key, addr)
71 // De waarschuwing zelf kwam pas in OpenSSH 10.1 (Debian 10.0 toont
72 // hem niet); de gekozen kex is wat telt.
73 if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
74 t.Fatalf("fallback hoort curve25519 te zijn:\n%s", out)
75 }
76 }
77
78 addr := startSSH(t, base)
79 out := sshProbe(t, sshBin, key, addr)
80 if supportsMLKEM {
81 if strings.Contains(out, "post-quantum") {
82 t.Fatalf("waarschuwing bleef staan:\n%s", out)
83 }
84 if !strings.Contains(out, "kex: algorithm: "+kexMLKEM) {
85 t.Fatalf("geen mlkem:\n%s", out)
86 }
87 } else if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
88 t.Fatalf("oude client hoort op curve25519 te vallen:\n%s", out)
89 }
90
91 work := filepath.Join(t.TempDir(), "work")
92 remote := fmt.Sprintf("ssh://git@%s/tim/demo.git", addr)
93 gitSSH(t, sshBin, key, addr, "", "init", "-b", "master", work)
94 if err := os.WriteFile(filepath.Join(work, "README"), []byte("hallo\n"), 0o644); err != nil {
95 t.Fatal(err)
96 }
97 gitSSH(t, sshBin, key, addr, work, "add", "README")
98 gitSSH(t, sshBin, key, addr, work, "-c", "user.email=tim@users.git.timfalken.com", "-c", "user.name=tim", "commit", "-m", "een")
99 gitSSH(t, sshBin, key, addr, work, "remote", "add", "origin", remote)
100 gitSSH(t, sshBin, key, addr, work, "push", "-u", "origin", "HEAD:master")
101
102 clone := filepath.Join(t.TempDir(), "clone")
103 gitSSH(t, sshBin, key, addr, "", "clone", remote, clone)
104 body, err := os.ReadFile(filepath.Join(clone, "README"))
105 if err != nil || string(body) != "hallo\n" {
106 t.Fatalf("clone %q %v", body, err)
107 }
108}
109
110func testSSH(t *testing.T) string {
111 t.Helper()
112 if bin := os.Getenv("BLUEGIT_TEST_SSH"); bin != "" {
113 if _, err := os.Stat(bin); err != nil {
114 t.Fatalf("BLUEGIT_TEST_SSH: %v", err)
115 }
116 return bin
117 }
118 bin, err := exec.LookPath("ssh")
119 if err != nil {
120 t.Skip("ssh ontbreekt")
121 }
122 return bin
123}
124
125func sshVersion(t *testing.T, bin string) string {
126 t.Helper()
127 cmd := exec.Command(bin, "-V")
128 out, _ := cmd.CombinedOutput()
129 line := strings.TrimSpace(string(out))
130 if i := strings.IndexByte(line, ' '); i > 0 {
131 return line[:i]
132 }
133 return line
134}
135
136func opensshMajor(version string) int {
137 rest, ok := strings.CutPrefix(version, "OpenSSH_")
138 if !ok {
139 return 0
140 }
141 major, _, _ := strings.Cut(rest, ".")
142 n, err := strconv.Atoi(major)
143 if err != nil {
144 return 0
145 }
146 return n
147}
148
149func sshQuery(t *testing.T, bin, kind string) string {
150 t.Helper()
151 out, err := exec.Command(bin, "-Q", kind).CombinedOutput()
152 if err != nil {
153 t.Fatalf("ssh -Q %s: %v %s", kind, err, out)
154 }
155 return string(out)
156}
157
158func openSSHStore(t *testing.T) *store.Store {
159 t.Helper()
160 key := make([]byte, 32)
161 for i := range key {
162 key[i] = byte(i + 1)
163 }
164 st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
165 if err != nil {
166 t.Fatal(err)
167 }
168 t.Cleanup(func() { _ = st.Close() })
169 return st
170}
171
172func startSSH(t *testing.T, srv *Server) string {
173 t.Helper()
174 ln, err := net.Listen("tcp", "127.0.0.1:0")
175 if err != nil {
176 t.Fatal(err)
177 }
178 addr := ln.Addr().String()
179 _ = ln.Close()
180 srv.Listen = addr
181 srv.HostKey = filepath.Join(t.TempDir(), "hostkey")
182 ctx, cancel := context.WithCancel(context.Background())
183 t.Cleanup(cancel)
184 go func() { _ = srv.Run(ctx) }()
185 deadline := time.Now().Add(2 * time.Second)
186 for time.Now().Before(deadline) {
187 conn, err := net.DialTimeout("tcp", addr, 50*time.Millisecond)
188 if err == nil {
189 _ = conn.Close()
190 return addr
191 }
192 time.Sleep(20 * time.Millisecond)
193 }
194 t.Fatalf("ssh luistert niet op %s", addr)
195 return ""
196}
197
198func sshProbe(t *testing.T, bin, key, addr string) string {
199 t.Helper()
200 host, port, err := net.SplitHostPort(addr)
201 if err != nil {
202 t.Fatal(err)
203 }
204 ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
205 defer cancel()
206 cmd := exec.CommandContext(ctx, bin, "-vvv",
207 "-i", key,
208 "-o", "IdentitiesOnly=yes",
209 "-o", "StrictHostKeyChecking=no",
210 "-o", "UserKnownHostsFile=/dev/null",
211 "-o", "BatchMode=yes",
212 "-p", port,
213 "git@"+host,
214 "ls",
215 )
216 out, _ := cmd.CombinedOutput()
217 return string(out)
218}
219
220func gitSSH(t *testing.T, bin, key, addr, dir string, args ...string) {
221 t.Helper()
222 _, port, err := net.SplitHostPort(addr)
223 if err != nil {
224 t.Fatal(err)
225 }
226 sshCmd := fmt.Sprintf("%s -i %s -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o BatchMode=yes -p %s",
227 shellQuote(bin), shellQuote(key), port)
228 cmd := exec.Command("git", args...)
229 if dir != "" {
230 cmd.Dir = dir
231 }
232 cmd.Env = append(os.Environ(), "GIT_SSH_COMMAND="+sshCmd)
233 if out, err := cmd.CombinedOutput(); err != nil {
234 t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
235 }
236}
237
238func git(t *testing.T, dir string, args ...string) {
239 t.Helper()
240 cmd := exec.Command("git", args...)
241 if dir != "" {
242 cmd.Dir = dir
243 }
244 if out, err := cmd.CombinedOutput(); err != nil {
245 t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
246 }
247}
248
249func shellQuote(s string) string {
250 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
251}