GitLabgitlab-org

cli

main
ply6 git calls30 ms99 KiB5 cachedprotocol v2
423 lines12 KiBRaw
1//go:build !integration
3package api
5import (
6 "crypto"
7 "crypto/ecdsa"
8 "crypto/elliptic"
9 "crypto/rand"
10 "crypto/rsa"
11 "crypto/tls"
12 "crypto/x509"
13 "crypto/x509/pkix"
14 "encoding/pem"
15 "errors"
16 "fmt"
17 "math/big"
18 "net/http"
19 "net/http/httptest"
20 "os"
21 "path/filepath"
22 "testing"
23 "time"
25 "github.com/stretchr/testify/assert"
26 "github.com/stretchr/testify/require"
27 "github.com/zalando/go-keyring"
28 "software.sslmate.com/src/go-pkcs12"
31const clientCertCN = "glab-mtls-client"
33type clientIdentity struct {
34 ca *x509.Certificate
35 leaf *x509.Certificate
36 key crypto.Signer
39func newClientIdentity(t *testing.T, key crypto.Signer) clientIdentity {
40 t.Helper()
42 caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
43 require.NoError(t, err)
44 caTemplate := &x509.Certificate{
45 SerialNumber: big.NewInt(1),
46 Subject: pkix.Name{CommonName: "glab test client CA"},
47 NotBefore: time.Now().Add(-time.Hour),
48 NotAfter: time.Now().Add(time.Hour),
49 KeyUsage: x509.KeyUsageCertSign,
50 BasicConstraintsValid: true,
51 IsCA: true,
52 }
53 caDER, err := x509.CreateCertificate(rand.Reader, caTemplate, caTemplate, caKey.Public(), caKey)
54 require.NoError(t, err)
55 ca, err := x509.ParseCertificate(caDER)
56 require.NoError(t, err)
58 leafTemplate := &x509.Certificate{
59 SerialNumber: big.NewInt(2),
60 Subject: pkix.Name{CommonName: clientCertCN},
61 NotBefore: time.Now().Add(-time.Hour),
62 NotAfter: time.Now().Add(time.Hour),
63 KeyUsage: x509.KeyUsageDigitalSignature,
64 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
65 }
66 leafDER, err := x509.CreateCertificate(rand.Reader, leafTemplate, ca, key.Public(), caKey)
67 require.NoError(t, err)
68 leaf, err := x509.ParseCertificate(leafDER)
69 require.NoError(t, err)
71 return clientIdentity{ca: ca, leaf: leaf, key: key}
74func newECKey(t *testing.T) crypto.Signer {
75 t.Helper()
77 key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
78 require.NoError(t, err)
79 return key
82func newRSAKey(t *testing.T) crypto.Signer {
83 t.Helper()
85 key, err := rsa.GenerateKey(rand.Reader, 2048)
86 require.NoError(t, err)
87 return key
90// newMTLSServer starts a TLS server that requires a client certificate signed
91// by ca and reports the common name of each certificate it accepts.
92func newMTLSServer(t *testing.T, ca *x509.Certificate) (*httptest.Server, <-chan string) {
93 t.Helper()
95 names := make(chan string, 1)
96 srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
97 names <- r.TLS.PeerCertificates[0].Subject.CommonName
98 w.WriteHeader(http.StatusOK)
99 }))
100 clientCAs := x509.NewCertPool()
101 clientCAs.AddCert(ca)
102 srv.TLS = &tls.Config{ClientAuth: tls.RequireAndVerifyClientCert, ClientCAs: clientCAs}
103 srv.StartTLS()
104 t.Cleanup(srv.Close)
105 return srv, names
108func writeFile(t *testing.T, name string, data []byte) string {
109 t.Helper()
111 path := filepath.Join(t.TempDir(), name)
112 require.NoError(t, os.WriteFile(path, data, 0o600))
113 return path
116func pkcs8DER(t *testing.T, key crypto.Signer) []byte {
117 t.Helper()
119 der, err := x509.MarshalPKCS8PrivateKey(key)
120 require.NoError(t, err)
121 return der
124func pkcs12Bundle(t *testing.T, id clientIdentity, password string) []byte {
125 t.Helper()
127 data, err := pkcs12.Modern.Encode(id.key, id.leaf, []*x509.Certificate{id.ca}, password)
128 require.NoError(t, err)
129 return data
132func TestNewClientFromConfig_ClientCertificateFormats(t *testing.T) {
133 t.Parallel()
135 tests := []struct {
136 name string
137 key func(*testing.T) crypto.Signer
138 settings func(*testing.T, clientIdentity) map[string]string
139 }{
140 {
141 name: "PEM certificate and PKCS#8 key",
142 key: newECKey,
143 settings: func(t *testing.T, id clientIdentity) map[string]string {
144 t.Helper()
145 return map[string]string{
146 "client_cert": writeFile(t, "client.crt", pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: id.leaf.Raw})),
147 "client_key": writeFile(t, "client.key", pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: pkcs8DER(t, id.key)})),
148 }
149 },
150 },
151 {
152 name: "DER certificate and PKCS#8 key",
153 key: newECKey,
154 settings: func(t *testing.T, id clientIdentity) map[string]string {
155 t.Helper()
156 return map[string]string{
157 "client_cert": writeFile(t, "client.der", id.leaf.Raw),
158 "client_key": writeFile(t, "client.key.der", pkcs8DER(t, id.key)),
159 }
160 },
161 },
162 {
163 name: "DER certificate and PKCS#1 key",
164 key: newRSAKey,
165 settings: func(t *testing.T, id clientIdentity) map[string]string {
166 t.Helper()
167 rsaKey, ok := id.key.(*rsa.PrivateKey)
168 require.True(t, ok)
169 return map[string]string{
170 "client_cert": writeFile(t, "client.der", id.leaf.Raw),
171 "client_key": writeFile(t, "client.key.der", x509.MarshalPKCS1PrivateKey(rsaKey)),
172 }
173 },
174 },
175 {
176 name: "DER certificate and EC key",
177 key: newECKey,
178 settings: func(t *testing.T, id clientIdentity) map[string]string {
179 t.Helper()
180 ecKey, ok := id.key.(*ecdsa.PrivateKey)
181 require.True(t, ok)
182 keyDER, err := x509.MarshalECPrivateKey(ecKey)
183 require.NoError(t, err)
184 return map[string]string{
185 "client_cert": writeFile(t, "client.der", id.leaf.Raw),
186 "client_key": writeFile(t, "client.key.der", keyDER),
187 }
188 },
189 },
190 {
191 name: "PKCS#12 bundle",
192 key: newRSAKey,
193 settings: func(t *testing.T, id clientIdentity) map[string]string {
194 t.Helper()
195 return map[string]string{
196 "client_cert": writeFile(t, "client.p12", pkcs12Bundle(t, id, "changeit")),
197 "client_cert_password": "changeit",
198 }
199 },
200 },
201 {
202 name: "PKCS#12 bundle without a password",
203 key: newECKey,
204 settings: func(t *testing.T, id clientIdentity) map[string]string {
205 t.Helper()
206 return map[string]string{
207 "client_cert": writeFile(t, "client.p12", pkcs12Bundle(t, id, "")),
208 }
209 },
210 },
211 }
213 for _, tc := range tests {
214 t.Run(tc.name, func(t *testing.T) {
215 t.Parallel()
217 id := newClientIdentity(t, tc.key(t))
218 srv, names := newMTLSServer(t, id.ca)
219 settings := tc.settings(t, id)
220 settings["skip_tls_verify"] = "true"
221 cfg := newServerConfig(t, srv, settings)
223 client, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test")
224 require.NoError(t, err)
225 mustGet(t, client, srv.URL)
227 assert.Equal(t, clientCertCN, <-names)
228 })
229 }
232func TestNewClientFromConfig_ClientCertificateErrors(t *testing.T) {
233 t.Parallel()
235 tests := []struct {
236 name string
237 settings func(*testing.T, clientIdentity) map[string]string
238 wantErr string
239 }{
240 {
241 name: "wrong PKCS#12 password",
242 settings: func(t *testing.T, id clientIdentity) map[string]string {
243 t.Helper()
244 return map[string]string{
245 "client_cert": writeFile(t, "client.p12", pkcs12Bundle(t, id, "changeit")),
246 "client_cert_password": "wrong",
247 }
248 },
249 wantErr: "incorrect password for the PKCS#12 client certificate",
250 },
251 {
252 name: "unknown certificate format with a key",
253 settings: func(t *testing.T, id clientIdentity) map[string]string {
254 t.Helper()
255 return map[string]string{
256 "client_cert": writeFile(t, "client.crt", []byte("not a certificate")),
257 "client_key": writeFile(t, "client.key.der", pkcs8DER(t, id.key)),
258 }
259 },
260 wantErr: "is not a PEM or DER certificate",
261 },
262 {
263 name: "PKCS#12 bundle without a private key",
264 settings: func(t *testing.T, id clientIdentity) map[string]string {
265 t.Helper()
266 data, err := pkcs12.Passwordless.EncodeTrustStore([]*x509.Certificate{id.leaf}, "")
267 require.NoError(t, err)
268 return map[string]string{"client_cert": writeFile(t, "truststore.p12", data)}
269 },
270 wantErr: "loading PKCS#12 client certificate",
271 },
272 {
273 name: "client_cert_password with a PEM certificate",
274 settings: func(t *testing.T, id clientIdentity) map[string]string {
275 t.Helper()
276 return map[string]string{
277 "client_cert": writeFile(t, "client.crt", pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: id.leaf.Raw})),
278 "client_cert_password": "changeit",
279 }
280 },
281 wantErr: "is not a PKCS#12 bundle",
282 },
283 {
284 name: "client_cert_password with a missing file",
285 settings: func(t *testing.T, _ clientIdentity) map[string]string {
286 t.Helper()
287 return map[string]string{
288 "client_cert": filepath.Join(t.TempDir(), "missing.p12"),
289 "client_cert_password": "changeit",
290 }
291 },
292 wantErr: "cannot be read",
293 },
294 }
296 for _, tc := range tests {
297 t.Run(tc.name, func(t *testing.T) {
298 t.Parallel()
300 id := newClientIdentity(t, newECKey(t))
301 srv, _ := newMTLSServer(t, id.ca)
302 settings := tc.settings(t, id)
303 settings["skip_tls_verify"] = "true"
304 cfg := newServerConfig(t, srv, settings)
306 _, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test")
308 require.ErrorContains(t, err, tc.wantErr)
309 assert.ErrorContains(t, err, settings["client_cert"])
310 })
311 }
314func TestNewClientFromConfig_ClientCertificateWithoutKeyNotPKCS12IsNotSent(t *testing.T) {
315 t.Parallel()
317 tests := []struct {
318 name string
319 certFile func(*testing.T, clientIdentity) string
320 }{
321 {
322 name: "PEM certificate",
323 certFile: func(t *testing.T, id clientIdentity) string {
324 t.Helper()
325 return writeFile(t, "client.crt", pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: id.leaf.Raw}))
326 },
327 },
328 {
329 name: "DER certificate",
330 certFile: func(t *testing.T, id clientIdentity) string {
331 t.Helper()
332 return writeFile(t, "client.der", id.leaf.Raw)
333 },
334 },
335 {
336 name: "unknown format",
337 certFile: func(t *testing.T, _ clientIdentity) string {
338 t.Helper()
339 return writeFile(t, "client.crt", []byte("not a certificate"))
340 },
341 },
342 {
343 name: "missing file",
344 certFile: func(t *testing.T, _ clientIdentity) string {
345 t.Helper()
346 return filepath.Join(t.TempDir(), "missing.crt")
347 },
348 },
349 }
351 for _, tc := range tests {
352 t.Run(tc.name, func(t *testing.T) {
353 t.Parallel()
355 id := newClientIdentity(t, newECKey(t))
356 peerCerts := make(chan int, 1)
357 srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
358 peerCerts <- len(r.TLS.PeerCertificates)
359 w.WriteHeader(http.StatusOK)
360 }))
361 srv.TLS = &tls.Config{ClientAuth: tls.RequestClientCert}
362 srv.StartTLS()
363 t.Cleanup(srv.Close)
364 cfg := newServerConfig(t, srv, map[string]string{
365 "skip_tls_verify": "true",
366 "client_cert": tc.certFile(t, id),
367 })
369 client, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test")
370 require.NoError(t, err)
371 mustGet(t, client, srv.URL)
373 assert.Zero(t, <-peerCerts)
374 })
375 }
378func TestNewClientFromConfig_ClientCertificateWithoutKeyIgnoresUnreadablePassword(t *testing.T) {
379 t.Setenv("GLAB_CLIENT_CERT_PASSWORD", "")
381 id := newClientIdentity(t, newECKey(t))
382 peerCerts := make(chan int, 1)
383 srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
384 peerCerts <- len(r.TLS.PeerCertificates)
385 w.WriteHeader(http.StatusOK)
386 }))
387 srv.TLS = &tls.Config{ClientAuth: tls.RequestClientCert}
388 srv.StartTLS()
389 t.Cleanup(srv.Close)
390 cfg := newServerConfig(t, srv, map[string]string{
391 "skip_tls_verify": "true",
392 "use_keyring": "true",
393 "client_cert": writeFile(t, "client.crt", pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: id.leaf.Raw})),
394 })
395 keyring.MockInitWithError(errors.New("keyring locked"))
396 t.Cleanup(keyring.MockInit)
398 client, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithoutAuthentication())
399 require.NoError(t, err)
400 mustGet(t, client, srv.URL)
402 assert.Zero(t, <-peerCerts)
405func TestNewClientFromConfig_PKCS12PasswordReadErrorIsWrapped(t *testing.T) {
406 t.Setenv("GLAB_CLIENT_CERT_PASSWORD", "")
408 id := newClientIdentity(t, newECKey(t))
409 srv, _ := newMTLSServer(t, id.ca)
410 cfg := newServerConfig(t, srv, map[string]string{
411 "skip_tls_verify": "true",
412 "use_keyring": "true",
413 "client_cert": writeFile(t, "client.p12", pkcs12Bundle(t, id, "changeit")),
414 })
415 errLocked := errors.New("keyring locked")
416 keyring.MockInitWithError(errLocked)
417 t.Cleanup(keyring.MockInit)
419 _, err := NewClientFromConfig(serverHost(srv), cfg, false, "glab-test", WithoutAuthentication())
421 require.ErrorIs(t, err, errLocked)
422 assert.ErrorContains(t, err, fmt.Sprintf("failed to read client_cert_password for %q", serverHost(srv)))
Diagnostics6 git calls · 30 ms
CallStatusSizeTime030 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:02001.1 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=1165
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=71c8407e0ff0e0af10f6a041ae330f754b68e7eb
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1165
git.pkt.payload.max=1138
git.sideband.band1.bytes=1138
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1138
git.pack.trailer=61886367c69619d8db2b2cf2d7d24dca2016141c
Open pack map
fetch2002.6 KiB · hit23 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=23
git.response.bytes=2693
git.response.cache=HIT
git.response.duration_ms=23
git.fetch.wants=23da6b7c88dc8bbd1e8fde87043ac8986505d678
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2693
git.pkt.payload.max=2666
git.sideband.band1.bytes=2666
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5e18ab1ec3c5e37
Request
a1b4cfe2…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format