GitLabgitlab-org
cli
main
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"
22)
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)
31}
33func newTestClient(t *testing.T, baseURL string) *gitlab.Client {
34 t.Helper()
35 return tokenexchangetest.NewTestClient(t, baseURL)
36}
38func makeJWT(t *testing.T, claims jwt.RegisteredClaims) string {
39 t.Helper()
40 return tokenexchangetest.MakeJWT(t, claims)
41}
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)
66}
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)
87}
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 }
120}
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())
136}
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())
153}
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())
169}
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")
189}
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")
209}
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())
226}
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 }
266}
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)
287}
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
298}
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())
323}
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 })
344}
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 })
370}
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=44Open 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=61886367c69619d8db2b2cf2d7d24dca2016141cOpen 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=cb5fa2850a001f0015a161f432a87b299fd95ab9Open 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