BlueGit

timfa bluegit

Merge branch 'cursor/ssh-pq-kex-65da' into 'master'

Post-quantum key exchange voor de SSH-server

See merge request Timfa/bluegit!31

timfa Tim Falken · pushed by timfa

Authored 2026-10-23 · 3 weeks ago

Hash
eb9b4092635886e00830a1dd214ba78689236751
4 files changed +378 −2
internal/sshd/client_test.go added +251 −0
@@ -0,0 +1,251 @@
1 package sshd
2
3 import (
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
23 func 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 old := *base
67 old.kex = []string{kexCurve, kexLibSSH}
68 addr := startSSH(t, &old)
69 out := sshProbe(t, sshBin, key, addr)
70 if !strings.Contains(out, "post-quantum") {
71 t.Fatalf("OpenSSH 10 hoort te waarschuwen zonder pq-kex:\n%s", out)
72 }
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
110 func 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
125 func 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
136 func 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
149 func 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
158 func 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
172 func 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
198 func 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
220 func 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
238 func 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
249 func shellQuote(s string) string {
250 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
251 }
@@ -0,0 +1,251 @@
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 old := *base
67 old.kex = []string{kexCurve, kexLibSSH}
68 addr := startSSH(t, &old)
69 out := sshProbe(t, sshBin, key, addr)
70 if !strings.Contains(out, "post-quantum") {
71 t.Fatalf("OpenSSH 10 hoort te waarschuwen zonder pq-kex:\n%s", out)
72 }
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}
internal/sshd/kex.go added +61 −0
@@ -0,0 +1,61 @@
1 package sshd
2
3 import "golang.org/x/crypto/ssh"
4
5 const (
6 kexMLKEM = "mlkem768x25519-sha256"
7 kexCurve = "curve25519-sha256"
8 kexLibSSH = "curve25519-sha256@libssh.org"
9 )
10
11 // Voorkeur van de ingebouwde SSH-server. Post-quantum eerst, daarna
12 // curve25519, dezelfde fallback als voorheen. Een naam die de gelinkte
13 // golang.org/x/crypto niet implementeert valt weg. Go 1.22 houdt dan
14 // curve25519; een nieuwere library zet mlkem vooraan.
15 var preferredKEX = []string{
16 kexMLKEM,
17 "sntrup761x25519-sha512",
18 "sntrup761x25519-sha512@openssh.com",
19 kexCurve,
20 kexLibSSH,
21 "ecdh-sha2-nistp256",
22 "ecdh-sha2-nistp384",
23 "ecdh-sha2-nistp521",
24 "diffie-hellman-group14-sha256",
25 "diffie-hellman-group14-sha1",
26 }
27
28 // keyExchanges is de lijst die de server aanbiedt. De libssh-alias hoort
29 // erbij: oudere clients vragen curve25519-sha256@libssh.org.
30 func keyExchanges() []string {
31 return supportedKEX(preferredKEX)
32 }
33
34 // supportedKEX houdt de volgorde en laat namen vallen die deze
35 // crypto-bibliotheek niet kent. SetDefaults doet dat filteren.
36 func supportedKEX(names []string) []string {
37 cfg := ssh.Config{KeyExchanges: append([]string(nil), names...)}
38 cfg.SetDefaults()
39 seen := map[string]bool{}
40 var out []string
41 for _, name := range cfg.KeyExchanges {
42 if name == "" || seen[name] {
43 continue
44 }
45 seen[name] = true
46 out = append(out, name)
47 }
48 if seen[kexCurve] && !seen[kexLibSSH] {
49 out = append(out, kexLibSSH)
50 }
51 return out
52 }
53
54 func kexSupported(name string) bool {
55 for _, got := range supportedKEX([]string{name}) {
56 if got == name {
57 return true
58 }
59 }
60 return false
61 }
@@ -0,0 +1,61 @@
1package sshd
2
3import "golang.org/x/crypto/ssh"
4
5const (
6 kexMLKEM = "mlkem768x25519-sha256"
7 kexCurve = "curve25519-sha256"
8 kexLibSSH = "curve25519-sha256@libssh.org"
9)
10
11// Voorkeur van de ingebouwde SSH-server. Post-quantum eerst, daarna
12// curve25519, dezelfde fallback als voorheen. Een naam die de gelinkte
13// golang.org/x/crypto niet implementeert valt weg. Go 1.22 houdt dan
14// curve25519; een nieuwere library zet mlkem vooraan.
15var preferredKEX = []string{
16 kexMLKEM,
17 "sntrup761x25519-sha512",
18 "sntrup761x25519-sha512@openssh.com",
19 kexCurve,
20 kexLibSSH,
21 "ecdh-sha2-nistp256",
22 "ecdh-sha2-nistp384",
23 "ecdh-sha2-nistp521",
24 "diffie-hellman-group14-sha256",
25 "diffie-hellman-group14-sha1",
26}
27
28// keyExchanges is de lijst die de server aanbiedt. De libssh-alias hoort
29// erbij: oudere clients vragen curve25519-sha256@libssh.org.
30func keyExchanges() []string {
31 return supportedKEX(preferredKEX)
32}
33
34// supportedKEX houdt de volgorde en laat namen vallen die deze
35// crypto-bibliotheek niet kent. SetDefaults doet dat filteren.
36func supportedKEX(names []string) []string {
37 cfg := ssh.Config{KeyExchanges: append([]string(nil), names...)}
38 cfg.SetDefaults()
39 seen := map[string]bool{}
40 var out []string
41 for _, name := range cfg.KeyExchanges {
42 if name == "" || seen[name] {
43 continue
44 }
45 seen[name] = true
46 out = append(out, name)
47 }
48 if seen[kexCurve] && !seen[kexLibSSH] {
49 out = append(out, kexLibSSH)
50 }
51 return out
52}
53
54func kexSupported(name string) bool {
55 for _, got := range supportedKEX([]string{name}) {
56 if got == name {
57 return true
58 }
59 }
60 return false
61}
internal/sshd/kex_test.go added +52 −0
@@ -0,0 +1,52 @@
1 package sshd
2
3 import (
4 "strings"
5 "testing"
6 )
7
8 func TestKeyExchangePreference(t *testing.T) {
9 got := keyExchanges()
10 if kexSupported(kexMLKEM) && (len(got) == 0 || got[0] != kexMLKEM) {
11 t.Fatalf("mlkem hoort vooraan: %v", got)
12 }
13 curve := indexOf(got, kexCurve)
14 libssh := indexOf(got, kexLibSSH)
15 if curve < 0 || libssh < 0 || libssh < curve {
16 t.Fatalf("curve25519 hoort als fallback: %v", got)
17 }
18 for _, name := range []string{kexMLKEM, "sntrup761x25519-sha512", "sntrup761x25519-sha512@openssh.com"} {
19 has := indexOf(got, name) >= 0
20 if kexSupported(name) != has {
21 t.Fatalf("%s ondersteund=%v aangeboden=%v in %v", name, kexSupported(name), has, got)
22 }
23 if has && indexOf(got, name) > curve {
24 t.Fatalf("%s hoort voor curve25519: %v", name, got)
25 }
26 }
27 if strings.Join(got, ",") != strings.Join(unique(got), ",") {
28 t.Fatalf("dubbele namen: %v", got)
29 }
30 }
31
32 func indexOf(list []string, want string) int {
33 for i, name := range list {
34 if name == want {
35 return i
36 }
37 }
38 return -1
39 }
40
41 func unique(list []string) []string {
42 seen := map[string]bool{}
43 var out []string
44 for _, name := range list {
45 if seen[name] {
46 continue
47 }
48 seen[name] = true
49 out = append(out, name)
50 }
51 return out
52 }
@@ -0,0 +1,52 @@
1package sshd
2
3import (
4 "strings"
5 "testing"
6)
7
8func TestKeyExchangePreference(t *testing.T) {
9 got := keyExchanges()
10 if kexSupported(kexMLKEM) && (len(got) == 0 || got[0] != kexMLKEM) {
11 t.Fatalf("mlkem hoort vooraan: %v", got)
12 }
13 curve := indexOf(got, kexCurve)
14 libssh := indexOf(got, kexLibSSH)
15 if curve < 0 || libssh < 0 || libssh < curve {
16 t.Fatalf("curve25519 hoort als fallback: %v", got)
17 }
18 for _, name := range []string{kexMLKEM, "sntrup761x25519-sha512", "sntrup761x25519-sha512@openssh.com"} {
19 has := indexOf(got, name) >= 0
20 if kexSupported(name) != has {
21 t.Fatalf("%s ondersteund=%v aangeboden=%v in %v", name, kexSupported(name), has, got)
22 }
23 if has && indexOf(got, name) > curve {
24 t.Fatalf("%s hoort voor curve25519: %v", name, got)
25 }
26 }
27 if strings.Join(got, ",") != strings.Join(unique(got), ",") {
28 t.Fatalf("dubbele namen: %v", got)
29 }
30}
31
32func indexOf(list []string, want string) int {
33 for i, name := range list {
34 if name == want {
35 return i
36 }
37 }
38 return -1
39}
40
41func unique(list []string) []string {
42 seen := map[string]bool{}
43 var out []string
44 for _, name := range list {
45 if seen[name] {
46 continue
47 }
48 seen[name] = true
49 out = append(out, name)
50 }
51 return out
52}
internal/sshd/server.go +14 −2
@@ -37,7 +37,9 @@ type Server struct {
37 37 HostKey string
38 38 Log *slog.Logger
39 39 OnPush PushFunc
40 mu sync.RWMutex
40 // kex vervangt de standaardlijst. Tests zetten hier een korte lijst.
41 kex []string
42 mu sync.RWMutex
41 43 }
42 44
43 45 // SetStorage wijzigt de map met repositories. De hostkey blijft apart.
@@ -59,7 +61,10 @@ func (s *Server) Run(ctx context.Context) error {
59 61 if err != nil {
60 62 return err
61 63 }
62 cfg := &ssh.ServerConfig{PublicKeyCallback: s.authorize}
64 cfg := &ssh.ServerConfig{
65 PublicKeyCallback: s.authorize,
66 Config: ssh.Config{KeyExchanges: s.kexList()},
67 }
63 68 cfg.AddHostKey(signer)
64 69 ln, err := net.Listen("tcp", s.Listen)
65 70 if err != nil {
@@ -82,6 +87,13 @@ func (s *Server) Run(ctx context.Context) error {
82 87 }
83 88 }
84 89
90 func (s *Server) kexList() []string {
91 if len(s.kex) > 0 {
92 return s.kex
93 }
94 return keyExchanges()
95 }
96
85 97 func (s *Server) authorize(meta ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
86 98 fp := ssh.FingerprintSHA256(key)
87 99 rec, err := s.Store.SSHKeyByFingerprint(context.Background(), fp)
@@ -37,7 +37,9 @@ type Server struct {
37 HostKey string
37 HostKey string
38 Log *slog.Logger
38 Log *slog.Logger
39 OnPush PushFunc
39 OnPush PushFunc
40 mu sync.RWMutex
40 // kex vervangt de standaardlijst. Tests zetten hier een korte lijst.
41 kex []string
42 mu sync.RWMutex
41}
43}
42
44
43// SetStorage wijzigt de map met repositories. De hostkey blijft apart.
45// SetStorage wijzigt de map met repositories. De hostkey blijft apart.
@@ -59,7 +61,10 @@ func (s *Server) Run(ctx context.Context) error {
59 if err != nil {
61 if err != nil {
60 return err
62 return err
61 }
63 }
62 cfg := &ssh.ServerConfig{PublicKeyCallback: s.authorize}
64 cfg := &ssh.ServerConfig{
65 PublicKeyCallback: s.authorize,
66 Config: ssh.Config{KeyExchanges: s.kexList()},
67 }
63 cfg.AddHostKey(signer)
68 cfg.AddHostKey(signer)
64 ln, err := net.Listen("tcp", s.Listen)
69 ln, err := net.Listen("tcp", s.Listen)
65 if err != nil {
70 if err != nil {
@@ -82,6 +87,13 @@ func (s *Server) Run(ctx context.Context) error {
82 }
87 }
83}
88}
84
89
90func (s *Server) kexList() []string {
91 if len(s.kex) > 0 {
92 return s.kex
93 }
94 return keyExchanges()
95}
96
85func (s *Server) authorize(meta ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
97func (s *Server) authorize(meta ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
86 fp := ssh.FingerprintSHA256(key)
98 fp := ssh.FingerprintSHA256(key)
87 rec, err := s.Store.SSHKeyByFingerprint(context.Background(), fp)
99 rec, err := s.Store.SSHKeyByFingerprint(context.Background(), fp)