GitLabgitlab-org

cli

main
ply7 git calls304 ms99 KiB4 cachedprotocol v2
370 lines12 KiBRaw
1//go:build !integration
3package tokenexchange
5import (
6 "encoding/json"
7 "fmt"
8 "net/http"
9 "net/http/httptest"
10 "strings"
11 "sync/atomic"
12 "testing"
13 "time"
15 "github.com/golang-jwt/jwt/v5"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
19 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
21 "gitlab.com/gitlab-org/cli/internal/testing/tokenexchangetest"
24const testAudience = "gitlab-example-service"
26type wireRequest = tokenexchangetest.WireRequest
28func newTestServer(t *testing.T, handler http.HandlerFunc) (*httptest.Server, *atomic.Int32) {
29 t.Helper()
30 return tokenexchangetest.NewTestServer(t, handler)
33func newTestClient(t *testing.T, baseURL string) *gitlab.Client {
34 t.Helper()
35 return tokenexchangetest.NewTestClient(t, baseURL)
38func makeJWT(t *testing.T, claims jwt.RegisteredClaims) string {
39 t.Helper()
40 return tokenexchangetest.MakeJWT(t, claims)
43func TestExchange_Success(t *testing.T) {
44 exp := time.Now().Add(time.Minute).Truncate(time.Second)
45 wantToken := makeJWT(t, jwt.RegisteredClaims{
46 Issuer: "https://gitlab.example.com",
47 Subject: "gid://gitlab/User/1",
48 Audience: jwt.ClaimStrings{testAudience},
49 ExpiresAt: jwt.NewNumericDate(exp),
50 })
52 var gotBody wireRequest
53 srv, count := tokenexchangetest.NewTokenExchangeServer(t, wantToken, &gotBody)
55 result, err := Exchange(t.Context(), newTestClient(t, srv.URL), testAudience, time.Minute)
56 require.NoError(t, err)
57 require.NotNil(t, result)
59 assert.EqualValues(t, 1, count.Load())
60 assert.Equal(t, wireRequest{Audience: testAudience, ExpiresIn: 60}, gotBody)
61 assert.Equal(t, wantToken, result.Token)
62 assert.WithinDuration(t, exp, result.ExpiresAt, 0)
63 assert.Equal(t, "https://gitlab.example.com", result.Issuer)
64 assert.Equal(t, "gid://gitlab/User/1", result.Subject)
65 assert.Equal(t, testAudience, result.Audience)
68func TestExchange_ZeroDurationOmitsExpiresIn(t *testing.T) {
69 wantToken := makeJWT(t, jwt.RegisteredClaims{
70 Issuer: "https://gitlab.example.com",
71 Subject: "gid://gitlab/User/1",
72 ExpiresAt: jwt.NewNumericDate(time.Now().Add(5 * time.Minute)),
73 })
75 var gotBody map[string]any
76 srv, _ := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
77 assert.NoError(t, json.NewDecoder(r.Body).Decode(&gotBody))
78 w.Header().Set("Content-Type", "application/json")
79 w.WriteHeader(http.StatusCreated)
80 _, _ = w.Write([]byte(`{"token":"` + wantToken + `"}`))
81 })
83 _, err := Exchange(t.Context(), newTestClient(t, srv.URL), testAudience, 0)
84 require.NoError(t, err)
86 assert.Equal(t, map[string]any{"audience": testAudience}, gotBody)
89func TestExchange_RoundsSubSecondDuration(t *testing.T) {
90 tests := []struct {
91 duration time.Duration
92 wantExpireIn int
93 }{
94 {duration: 1500 * time.Millisecond, wantExpireIn: 2},
95 {duration: 1100 * time.Millisecond, wantExpireIn: 1},
96 }
98 for _, tc := range tests {
99 t.Run(tc.duration.String(), func(t *testing.T) {
100 wantToken := makeJWT(t, jwt.RegisteredClaims{
101 Issuer: "https://gitlab.example.com",
102 Subject: "gid://gitlab/User/1",
103 ExpiresAt: jwt.NewNumericDate(time.Now().Add(tc.duration)),
104 })
106 var gotBody wireRequest
107 srv, _ := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
108 assert.NoError(t, json.NewDecoder(r.Body).Decode(&gotBody))
109 w.Header().Set("Content-Type", "application/json")
110 w.WriteHeader(http.StatusOK)
111 _, _ = w.Write([]byte(`{"token":"` + wantToken + `"}`))
112 })
113 gl := newTestClient(t, srv.URL)
115 _, err := Exchange(t.Context(), gl, testAudience, tc.duration)
116 require.NoError(t, err)
117 assert.Equal(t, tc.wantExpireIn, gotBody.ExpiresIn)
118 })
119 }
122func TestExchange_ServerBadRequest(t *testing.T) {
123 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
124 w.Header().Set("Content-Type", "application/json")
125 w.WriteHeader(http.StatusBadRequest)
126 _, _ = w.Write([]byte(`{"error":"expires_in does not have a valid value"}`))
127 })
129 gl := newTestClient(t, srv.URL)
131 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
132 require.Error(t, err)
133 assert.Nil(t, result)
134 assert.Contains(t, err.Error(), "expires_in does not have a valid value")
135 assert.EqualValues(t, 1, count.Load())
138func TestExchange_NotFound(t *testing.T) {
139 // An instance that does not serve token exchange responds 404: a
140 // Community Edition instance, a release before 19.1, or 19.1 to 19.3
141 // with the gate_token_exchange_endpoint feature flag disabled.
142 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
143 w.WriteHeader(http.StatusNotFound)
144 })
146 gl := newTestClient(t, srv.URL)
148 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
149 require.Error(t, err)
150 assert.Nil(t, result)
151 assert.Contains(t, err.Error(), "token exchange is not available on this instance (requires GitLab EE 19.4 or later)")
152 assert.EqualValues(t, 1, count.Load())
155func TestExchange_EmptyToken(t *testing.T) {
156 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
157 w.Header().Set("Content-Type", "application/json")
158 w.WriteHeader(http.StatusCreated)
159 _, _ = w.Write([]byte(`{}`))
160 })
162 gl := newTestClient(t, srv.URL)
164 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
165 require.Error(t, err)
166 assert.Nil(t, result)
167 assert.Contains(t, err.Error(), "empty token")
168 assert.EqualValues(t, 1, count.Load())
171func TestExchange_MissingIssuerClaim(t *testing.T) {
172 wantToken := makeJWT(t, jwt.RegisteredClaims{
173 Subject: "gid://gitlab/User/1",
174 ExpiresAt: jwt.NewNumericDate(time.Now().Add(15 * time.Minute)),
175 })
177 srv, _ := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
178 w.Header().Set("Content-Type", "application/json")
179 w.WriteHeader(http.StatusCreated)
180 _, _ = w.Write([]byte(`{"token":"` + wantToken + `"}`))
181 })
183 gl := newTestClient(t, srv.URL)
185 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
186 require.Error(t, err)
187 assert.Nil(t, result)
188 assert.Contains(t, err.Error(), "no issuer claim")
191func TestExchange_MissingSubjectClaim(t *testing.T) {
192 wantToken := makeJWT(t, jwt.RegisteredClaims{
193 Issuer: "https://gitlab.example.com",
194 ExpiresAt: jwt.NewNumericDate(time.Now().Add(15 * time.Minute)),
195 })
197 srv, _ := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
198 w.Header().Set("Content-Type", "application/json")
199 w.WriteHeader(http.StatusCreated)
200 _, _ = w.Write([]byte(`{"token":"` + wantToken + `"}`))
201 })
203 gl := newTestClient(t, srv.URL)
205 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
206 require.Error(t, err)
207 assert.Nil(t, result)
208 assert.Contains(t, err.Error(), "no subject claim")
211func TestExchange_MalformedToken(t *testing.T) {
212 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
213 w.Header().Set("Content-Type", "application/json")
214 w.WriteHeader(http.StatusOK)
215 _, _ = w.Write([]byte(`{"token":"not-a-jwt"}`))
216 })
218 gl := newTestClient(t, srv.URL)
220 require.NotPanics(t, func() {
221 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
222 require.Error(t, err)
223 assert.Nil(t, result)
224 })
225 assert.EqualValues(t, 1, count.Load())
228func TestExchange_RejectsTokenCarryingLineBreaks(t *testing.T) {
229 valid := makeJWT(t, jwt.RegisteredClaims{
230 Issuer: "https://gitlab.example.com",
231 Subject: "gid://gitlab/User/1",
232 ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour).Truncate(time.Second)),
233 })
234 segments := strings.Split(valid, ".")
235 require.Len(t, segments, 3)
237 tests := map[string]string{
238 "newline inside the signature": segments[0] + "." + segments[1] + "." + segments[2][:3] + "\n" + segments[2][3:],
239 "newline inside the payload": segments[0] + "." + segments[1] + "\n." + segments[2],
240 "trailing newline": valid + "\n",
241 "leading newline": "\n" + valid,
242 "carriage return": valid + "\r",
243 }
245 for name, token := range tests {
246 t.Run(name, func(t *testing.T) {
247 // Proves the guard is load-bearing rather than a restatement of
248 // what the claims decode already rejects.
249 claims, decodeErr := decodeUnverifiedClaims(token)
250 require.NoError(t, decodeErr, "precondition: this token decodes, so only the shape guard can reject it")
251 require.Equal(t, "https://gitlab.example.com", claims.Issuer)
253 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
254 w.Header().Set("Content-Type", "application/json")
255 w.WriteHeader(http.StatusOK)
256 _, _ = w.Write(mustJSON(t, token))
257 })
259 result, err := Exchange(t.Context(), newTestClient(t, srv.URL), testAudience, 15*time.Minute)
260 require.Error(t, err)
261 assert.Nil(t, result)
262 assert.Contains(t, err.Error(), "not in JWS compact form")
263 assert.EqualValues(t, 1, count.Load())
264 })
265 }
268func TestExchange_AcceptsEmptySignature(t *testing.T) {
269 valid := makeJWT(t, jwt.RegisteredClaims{
270 Issuer: "https://gitlab.example.com",
271 Subject: "gid://gitlab/User/1",
272 ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour).Truncate(time.Second)),
273 })
274 segments := strings.Split(valid, ".")
275 unsigned := segments[0] + "." + segments[1] + "."
277 srv, _ := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
278 w.Header().Set("Content-Type", "application/json")
279 w.WriteHeader(http.StatusOK)
280 _, _ = w.Write(mustJSON(t, unsigned))
281 })
283 result, err := Exchange(t.Context(), newTestClient(t, srv.URL), testAudience, 15*time.Minute)
284 require.NoError(t, err)
285 require.NotNil(t, result)
286 assert.Equal(t, unsigned, result.Token)
289func mustJSON(t *testing.T, token string) []byte {
290 t.Helper()
292 body, err := json.Marshal(struct {
293 Token string `json:"token"`
294 }{Token: token})
295 require.NoError(t, err)
297 return body
300func TestExchange_MissingExpiryClaim(t *testing.T) {
301 // ExpiresAt is a *jwt.NumericDate, so a token with no exp claim decodes fine
302 // and leaves it nil. Exchange must error rather than dereference it.
303 wantToken := makeJWT(t, jwt.RegisteredClaims{
304 Issuer: "https://gitlab.example.com",
305 Subject: "gid://gitlab/User/1",
306 })
308 srv, count := newTestServer(t, func(w http.ResponseWriter, r *http.Request) {
309 w.Header().Set("Content-Type", "application/json")
310 w.WriteHeader(http.StatusOK)
311 _, _ = w.Write([]byte(`{"token":"` + wantToken + `"}`))
312 })
314 gl := newTestClient(t, srv.URL)
316 require.NotPanics(t, func() {
317 result, err := Exchange(t.Context(), gl, testAudience, 15*time.Minute)
318 require.Error(t, err)
319 assert.Nil(t, result)
320 assert.Contains(t, err.Error(), "no expiry claim")
321 })
322 assert.EqualValues(t, 1, count.Load())
325func TestResult_RedactsToken(t *testing.T) {
326 result := Result{
327 Token: "super-secret-bearer-token",
328 ExpiresAt: time.Now(),
329 Issuer: "https://gitlab.example.com",
330 Subject: "gid://gitlab/User/1",
331 Audience: "gitlab-artifact-registry",
332 }
334 t.Run("String", func(t *testing.T) {
335 s := fmt.Sprintf("%+v", result)
336 assert.NotContains(t, s, result.Token)
337 })
339 t.Run("MarshalJSON", func(t *testing.T) {
340 b, err := json.Marshal(result)
341 require.NoError(t, err)
342 assert.NotContains(t, string(b), result.Token)
343 })
346func TestDecodeUnverifiedClaims(t *testing.T) {
347 t.Run("valid token", func(t *testing.T) {
348 exp := time.Now().Add(30 * time.Minute).Truncate(time.Second)
349 token := makeJWT(t, jwt.RegisteredClaims{
350 Issuer: "https://gitlab.example.com",
351 Subject: "gid://gitlab/User/42",
352 ExpiresAt: jwt.NewNumericDate(exp),
353 })
355 claims, err := decodeUnverifiedClaims(token)
356 require.NoError(t, err)
357 require.NotNil(t, claims)
359 assert.Equal(t, "https://gitlab.example.com", claims.Issuer)
360 assert.Equal(t, "gid://gitlab/User/42", claims.Subject)
361 require.NotNil(t, claims.ExpiresAt)
362 assert.WithinDuration(t, exp, claims.ExpiresAt.Time, 0)
363 })
365 t.Run("malformed token", func(t *testing.T) {
366 claims, err := decodeUnverifiedClaims("not-a-jwt")
367 require.Error(t, err)
368 assert.Nil(t, claims)
369 })
Diagnostics7 git calls · 304 ms
CallStatusSizeTime0304 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
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 KiB2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=59849
git.response.cache=UPDATING
git.response.duration_ms=2
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
fetchtree:0 · deepen 1020032 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=2
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
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit4 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=4273
git.response.cache=HIT
git.response.duration_ms=4
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: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=11
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
fetchtree:0200145 B · hit11 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=284
git.response.bytes=145
git.response.cache=HIT
git.response.duration_ms=11
git.fetch.filter=tree:0
git.fetch.wants=61a86c3cd09248644c3c2b7a4404d83963e3f410
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=145
git.pkt.payload.max=118
git.sideband.band1.bytes=118
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=118
git.pack.trailer=cb5fa2850a001f0015a161f432a87b299fd95ab9
Open pack map
fetch2002.5 KiB284 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=2569
git.response.cache=MISS
git.response.duration_ms=284
git.fetch.wants=fd8bc6a7b3dcfd506c8e330d9e07d38923dd7bf6
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=2569
git.pkt.payload.max=2542
git.sideband.band1.bytes=2542
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
a5e17450ce753488
Request
78019ae1…
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