BlueGit

timfa bluegit

Files

bluegit / internal / sshd / client_test.go

client_test.go

fix: accepteer een checkout van een andere uid en toon het update-log
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
71de6a16 History
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 if !strings.Contains(out, "post-quantum") {
72 t.Fatalf("OpenSSH 10 hoort te waarschuwen zonder pq-kex:\n%s", out)
73 }
74 if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
75 t.Fatalf("fallback hoort curve25519 te zijn:\n%s", out)
76 }
77 }
78
79 addr := startSSH(t, base)
80 out := sshProbe(t, sshBin, key, addr)
81 if supportsMLKEM {
82 if strings.Contains(out, "post-quantum") {
83 t.Fatalf("waarschuwing bleef staan:\n%s", out)
84 }
85 if !strings.Contains(out, "kex: algorithm: "+kexMLKEM) {
86 t.Fatalf("geen mlkem:\n%s", out)
87 }
88 } else if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
89 t.Fatalf("oude client hoort op curve25519 te vallen:\n%s", out)
90 }
91
92 work := filepath.Join(t.TempDir(), "work")
93 remote := fmt.Sprintf("ssh://git@%s/tim/demo.git", addr)
94 gitSSH(t, sshBin, key, addr, "", "init", "-b", "master", work)
95 if err := os.WriteFile(filepath.Join(work, "README"), []byte("hallo\n"), 0o644); err != nil {
96 t.Fatal(err)
97 }
98 gitSSH(t, sshBin, key, addr, work, "add", "README")
99 gitSSH(t, sshBin, key, addr, work, "-c", "user.email=tim@users.git.timfalken.com", "-c", "user.name=tim", "commit", "-m", "een")
100 gitSSH(t, sshBin, key, addr, work, "remote", "add", "origin", remote)
101 gitSSH(t, sshBin, key, addr, work, "push", "-u", "origin", "HEAD:master")
102
103 clone := filepath.Join(t.TempDir(), "clone")
104 gitSSH(t, sshBin, key, addr, "", "clone", remote, clone)
105 body, err := os.ReadFile(filepath.Join(clone, "README"))
106 if err != nil || string(body) != "hallo\n" {
107 t.Fatalf("clone %q %v", body, err)
108 }
109}
110
111func testSSH(t *testing.T) string {
112 t.Helper()
113 if bin := os.Getenv("BLUEGIT_TEST_SSH"); bin != "" {
114 if _, err := os.Stat(bin); err != nil {
115 t.Fatalf("BLUEGIT_TEST_SSH: %v", err)
116 }
117 return bin
118 }
119 bin, err := exec.LookPath("ssh")
120 if err != nil {
121 t.Skip("ssh ontbreekt")
122 }
123 return bin
124}
125
126func sshVersion(t *testing.T, bin string) string {
127 t.Helper()
128 cmd := exec.Command(bin, "-V")
129 out, _ := cmd.CombinedOutput()
130 line := strings.TrimSpace(string(out))
131 if i := strings.IndexByte(line, ' '); i > 0 {
132 return line[:i]
133 }
134 return line
135}
136
137func opensshMajor(version string) int {
138 rest, ok := strings.CutPrefix(version, "OpenSSH_")
139 if !ok {
140 return 0
141 }
142 major, _, _ := strings.Cut(rest, ".")
143 n, err := strconv.Atoi(major)
144 if err != nil {
145 return 0
146 }
147 return n
148}
149
150func sshQuery(t *testing.T, bin, kind string) string {
151 t.Helper()
152 out, err := exec.Command(bin, "-Q", kind).CombinedOutput()
153 if err != nil {
154 t.Fatalf("ssh -Q %s: %v %s", kind, err, out)
155 }
156 return string(out)
157}
158
159func openSSHStore(t *testing.T) *store.Store {
160 t.Helper()
161 key := make([]byte, 32)
162 for i := range key {
163 key[i] = byte(i + 1)
164 }
165 st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
166 if err != nil {
167 t.Fatal(err)
168 }
169 t.Cleanup(func() { _ = st.Close() })
170 return st
171}
172
173func startSSH(t *testing.T, srv *Server) string {
174 t.Helper()
175 ln, err := net.Listen("tcp", "127.0.0.1:0")
176 if err != nil {
177 t.Fatal(err)
178 }
179 addr := ln.Addr().String()
180 _ = ln.Close()
181 srv.Listen = addr
182 srv.HostKey = filepath.Join(t.TempDir(), "hostkey")
183 ctx, cancel := context.WithCancel(context.Background())
184 t.Cleanup(cancel)
185 go func() { _ = srv.Run(ctx) }()
186 deadline := time.Now().Add(2 * time.Second)
187 for time.Now().Before(deadline) {
188 conn, err := net.DialTimeout("tcp", addr, 50*time.Millisecond)
189 if err == nil {
190 _ = conn.Close()
191 return addr
192 }
193 time.Sleep(20 * time.Millisecond)
194 }
195 t.Fatalf("ssh luistert niet op %s", addr)
196 return ""
197}
198
199func sshProbe(t *testing.T, bin, key, addr string) string {
200 t.Helper()
201 host, port, err := net.SplitHostPort(addr)
202 if err != nil {
203 t.Fatal(err)
204 }
205 ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
206 defer cancel()
207 cmd := exec.CommandContext(ctx, bin, "-vvv",
208 "-i", key,
209 "-o", "IdentitiesOnly=yes",
210 "-o", "StrictHostKeyChecking=no",
211 "-o", "UserKnownHostsFile=/dev/null",
212 "-o", "BatchMode=yes",
213 "-p", port,
214 "git@"+host,
215 "ls",
216 )
217 out, _ := cmd.CombinedOutput()
218 return string(out)
219}
220
221func gitSSH(t *testing.T, bin, key, addr, dir string, args ...string) {
222 t.Helper()
223 _, port, err := net.SplitHostPort(addr)
224 if err != nil {
225 t.Fatal(err)
226 }
227 sshCmd := fmt.Sprintf("%s -i %s -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o BatchMode=yes -p %s",
228 shellQuote(bin), shellQuote(key), port)
229 cmd := exec.Command("git", args...)
230 if dir != "" {
231 cmd.Dir = dir
232 }
233 cmd.Env = append(os.Environ(), "GIT_SSH_COMMAND="+sshCmd)
234 if out, err := cmd.CombinedOutput(); err != nil {
235 t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
236 }
237}
238
239func git(t *testing.T, dir string, args ...string) {
240 t.Helper()
241 cmd := exec.Command("git", args...)
242 if dir != "" {
243 cmd.Dir = dir
244 }
245 if out, err := cmd.CombinedOutput(); err != nil {
246 t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
247 }
248}
249
250func shellQuote(s string) string {
251 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
252}