GitLabgitlab-org
cli
main
1//go:build !integration
3package api
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "io"
11 "net/http"
12 "net/http/httptest"
13 "net/http/httputil"
14 "strings"
15 "testing"
17 "github.com/stretchr/testify/assert"
18 "github.com/stretchr/testify/require"
19 "golang.org/x/oauth2"
20)
22func TestDebugTransport_RedactsTokensInResponseBodies(t *testing.T) {
23 tests := []struct {
24 name string
25 contentType string
26 body string
27 wantDump []string
28 hidden string
29 }{
30 {
31 name: "a top-level token is redacted",
32 body: `{"token":"secret-session-token","token_type":"oauth","session_id":77}`,
33 wantDump: []string{`"token":"[REDACTED]"`, `"token_type":"oauth"`, `"session_id":77`},
34 hidden: "secret-session-token",
35 },
36 {
37 name: "OAuth access and refresh tokens are redacted",
38 body: `{"access_token":"secret-access","token_type":"Bearer","expires_in":7200,"refresh_token":"secret-refresh","scope":"api","created_at":1}`,
39 wantDump: []string{`"access_token":"[REDACTED]"`, `"refresh_token":"[REDACTED]"`, `"token_type":"Bearer"`, `"expires_in":7200`, `"scope":"api"`},
40 hidden: "secret-",
41 },
42 {
43 name: "an OpenID Connect ID token is redacted",
44 body: `{"access_token":"secret-access","id_token":"secret-id","token_type":"Bearer"}`,
45 wantDump: []string{`"id_token":"[REDACTED]"`, `"token_type":"Bearer"`},
46 hidden: "secret-",
47 },
48 {
49 name: "an OAuth device authorization's device code is redacted",
50 body: `{"device_code":"secret-device","user_code":"ABCD-1234","verification_uri":"https://gitlab.example.com/oauth/device","expires_in":300,"interval":5}`,
51 wantDump: []string{`"device_code":"[REDACTED]"`, `"user_code":"ABCD-1234"`},
52 hidden: "secret-device",
53 },
54 {
55 name: "a project's runner registration token is redacted",
56 body: `{"id":1,"path_with_namespace":"group/proj","runners_token":"secret-runner"}`,
57 wantDump: []string{`"runners_token":"[REDACTED]"`, `"path_with_namespace":"group/proj"`},
58 hidden: "secret-runner",
59 },
60 {
61 name: "a body without a token is unchanged",
62 body: `{"id":1,"name":"proj"}`,
63 wantDump: []string{`{"id":1,"name":"proj"}`},
64 },
65 {
66 name: "a token nested under GraphQL data is redacted",
67 body: `{"data":{"project":{"pipelineTriggers":{"nodes":[{"id":"gid://gitlab/Ci::Trigger/1","token":"secret-graphql"}]}}}}`,
68 wantDump: []string{`{"data":{"project":{"pipelineTriggers":{"nodes":[{"id":"gid://gitlab/Ci::Trigger/1","token":"[REDACTED]"}]}}}}`},
69 hidden: "secret-graphql",
70 },
71 {
72 name: "tokens in a top-level array are redacted",
73 body: `[{"id":1,"token":"secret-one","description":"deploy"},{"id":2,"token":"secret-two"}]`,
74 wantDump: []string{`[{"id":1,"token":"[REDACTED]","description":"deploy"},{"id":2,"token":"[REDACTED]"}]`},
75 hidden: "secret-",
76 },
77 {
78 name: "the rest of the body is dumped as sent",
79 body: "{\n \"zeta\": 9007199254740993,\n \"ratio\": 1.50,\n \"token\" : \"secret-spaced\",\n \"html\": \"\\u003cb\\u003e <i> &\"\n}\n",
80 wantDump: []string{"{\n \"zeta\": 9007199254740993,\n \"ratio\": 1.50,\n \"token\" : \"[REDACTED]\",\n \"html\": \"\\u003cb\\u003e <i> &\"\n}\n"},
81 hidden: "secret-spaced",
82 },
83 {
84 name: "a number too large for float64 does not stop redaction",
85 body: `{"size":1e400,"token":"secret-after-number"}`,
86 wantDump: []string{`{"size":1e400,"token":"[REDACTED]"}`},
87 hidden: "secret-after-number",
88 },
89 {
90 name: "a token field that is not a string is searched, not replaced",
91 body: `{"token":{"id":"gid://gitlab/Clusters::AgentToken/1","token":"secret-inner"},"other":{"token":null}}`,
92 wantDump: []string{`{"token":{"id":"gid://gitlab/Clusters::AgentToken/1","token":"[REDACTED]"},"other":{"token":null}}`},
93 hidden: "secret-inner",
94 },
95 {
96 name: "a token that is a number, a boolean or a list is redacted",
97 body: `{"token":123456789,"tokens":[1],"access_token":["secret-a", "secret-b",["secret-c"]],"refresh_token":true}`,
98 wantDump: []string{`{"token":"[REDACTED]","tokens":[1],"access_token":["[REDACTED]", "[REDACTED]",["[REDACTED]"]],"refresh_token":"[REDACTED]"}`},
99 hidden: "secret-",
100 },
101 {
102 name: "a form-encoded response is redacted like a form-encoded request",
103 contentType: "application/x-www-form-urlencoded",
104 body: "access_token=secret-form&token_type=bearer",
105 wantDump: []string{"access_token=[REDACTED]&token_type=bearer"},
106 hidden: "secret-form",
107 },
108 {
109 name: "every duplicated key and concatenated value is redacted",
110 body: "{\"token\":\"secret-a\",\"token\":\"secret-b\"}\n{\"token\":\"secret-c\"}\n",
111 wantDump: []string{"{\"token\":\"[REDACTED]\",\"token\":\"[REDACTED]\"}\n{\"token\":\"[REDACTED]\"}\n"},
112 hidden: "secret-",
113 },
114 {
115 name: "JSON followed by other text is redacted",
116 body: `{"token":"secret-before-text"}<html>`,
117 wantDump: []string{`{"token":"[REDACTED]"}<html>`},
118 hidden: "secret-before-text",
119 },
120 {
121 name: "a body that is not JSON is unchanged",
122 body: `token=not-json`,
123 wantDump: []string{`token=not-json`},
124 },
125 }
126 for _, tc := range tests {
127 t.Run(tc.name, func(t *testing.T) {
128 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
129 contentType := tc.contentType
130 if contentType == "" {
131 contentType = "application/json"
132 }
133 w.Header().Set("Content-Type", contentType)
134 _, _ = io.WriteString(w, tc.body)
135 }))
136 t.Cleanup(server.Close)
138 var output bytes.Buffer
139 client := &http.Client{Transport: &debugTransport{rt: http.DefaultTransport, w: &output}}
140 resp, err := client.Get(server.URL)
141 require.NoError(t, err)
142 body, err := io.ReadAll(resp.Body)
143 require.NoError(t, err)
144 require.NoError(t, resp.Body.Close())
146 assert.Equal(t, tc.body, string(body), "the caller reads the body unchanged")
147 assert.Contains(t, output.String(), fmt.Sprintf("Content-Length: %d\r\n", len(tc.body)), "the dump shows the length that is sent")
148 for _, want := range tc.wantDump {
149 assert.Contains(t, output.String(), want)
150 }
151 if tc.hidden != "" {
152 assert.NotContains(t, output.String(), tc.hidden)
153 }
154 })
155 }
156}
158func TestDebugTransport_RedactsCredentialsInRequestBodies(t *testing.T) {
159 const form = "application/x-www-form-urlencoded"
160 tests := []struct {
161 name string
162 contentType string
163 body string
164 wantDump []string
165 hidden string
166 }{
167 {
168 name: "an OAuth authorization code exchange",
169 contentType: form,
170 body: "client_id=abc&code=secret-code&code_verifier=secret-verifier&grant_type=authorization_code&redirect_uri=http%3A%2F%2Flocalhost%3A7171%2Fauth%2Fredirect",
171 wantDump: []string{"client_id=abc&code=[REDACTED]&code_verifier=[REDACTED]&grant_type=authorization_code&redirect_uri=http%3A%2F%2Flocalhost%3A7171%2Fauth%2Fredirect"},
172 hidden: "secret-",
173 },
174 {
175 name: "an OAuth device access token request",
176 contentType: form,
177 body: "client_id=abc&device_code=secret-device&grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code",
178 wantDump: []string{"client_id=abc&device_code=[REDACTED]&grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Adevice_code"},
179 hidden: "secret-device",
180 },
181 {
182 name: "a form content type with parameters",
183 contentType: form + "; charset=utf-8",
184 body: "grant_type=refresh_token&refresh_token=secret-refresh",
185 wantDump: []string{"grant_type=refresh_token&refresh_token=[REDACTED]"},
186 hidden: "secret-refresh",
187 },
188 {
189 name: "a pipeline trigger token in a JSON body",
190 contentType: "application/json",
191 body: `{"ref":"main","token":"secret-trigger"}`,
192 wantDump: []string{`"token":"[REDACTED]"`, `"ref":"main"`},
193 hidden: "secret-trigger",
194 },
195 {
196 name: "a form without credentials is unchanged",
197 contentType: form,
198 body: "grant_type=client_credentials&scope=api",
199 wantDump: []string{"grant_type=client_credentials&scope=api"},
200 },
201 {
202 name: "a code field outside a form is unchanged",
203 contentType: "application/json",
204 body: `{"code":"puts 1"}`,
205 wantDump: []string{`{"code":"puts 1"}`},
206 },
207 }
208 for _, tc := range tests {
209 t.Run(tc.name, func(t *testing.T) {
210 var received string
211 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
212 body, _ := io.ReadAll(r.Body)
213 received = string(body)
214 w.WriteHeader(http.StatusNoContent)
215 }))
216 t.Cleanup(server.Close)
218 var output bytes.Buffer
219 client := &http.Client{Transport: &debugTransport{rt: http.DefaultTransport, w: &output}}
220 resp, err := client.Post(server.URL, tc.contentType, strings.NewReader(tc.body))
221 require.NoError(t, err)
222 require.NoError(t, resp.Body.Close())
224 assert.Equal(t, tc.body, received, "the server receives the body unchanged")
225 assert.Contains(t, output.String(), fmt.Sprintf("Content-Length: %d\r\n", len(tc.body)), "the dump shows the length that is sent")
226 for _, want := range tc.wantDump {
227 assert.Contains(t, output.String(), want)
228 }
229 if tc.hidden != "" {
230 assert.NotContains(t, output.String(), tc.hidden)
231 }
232 })
233 }
234}
236func TestDebugTransport_RedactsOAuthTokenRefresh(t *testing.T) {
237 var received string
238 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
239 body, _ := io.ReadAll(r.Body)
240 received = string(body)
241 w.Header().Set("Content-Type", "application/json")
242 _, _ = io.WriteString(w, `{"access_token":"secret-new-access","token_type":"Bearer","expires_in":7200,"refresh_token":"secret-new-refresh"}`)
243 }))
244 t.Cleanup(server.Close)
246 var output bytes.Buffer
247 client := &http.Client{Transport: &debugTransport{rt: http.DefaultTransport, w: &output}}
248 ctx := context.WithValue(t.Context(), oauth2.HTTPClient, client)
249 config := &oauth2.Config{ClientID: "glab", Endpoint: oauth2.Endpoint{TokenURL: server.URL + "/oauth/token"}}
250 token, err := config.TokenSource(ctx, &oauth2.Token{RefreshToken: "secret-old-refresh"}).Token()
251 require.NoError(t, err)
253 assert.Equal(t, "secret-new-access", token.AccessToken)
254 assert.Contains(t, received, "refresh_token=secret-old-refresh", "the server receives the refresh token")
255 assert.Contains(t, output.String(), "POST /oauth/token")
256 assert.Contains(t, output.String(), "refresh_token=[REDACTED]")
257 assert.Contains(t, output.String(), fmt.Sprintf("Content-Length: %d\r\n", len(received)))
258 assert.NotContains(t, output.String(), "secret-")
259}
261func TestDebugTransport_SendsTheRequestWhenItCannotBeDumped(t *testing.T) {
262 var output bytes.Buffer
263 sent := false
264 transport := &debugTransport{
265 rt: roundTripFunc(func(req *http.Request) (*http.Response, error) {
266 sent = true
267 return &http.Response{StatusCode: http.StatusNoContent, Body: http.NoBody, Request: req}, nil
268 }),
269 w: &output,
270 }
271 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "unsupported://gitlab.example.com/api/v4/user", http.NoBody)
272 require.NoError(t, err)
274 resp, err := transport.RoundTrip(req)
275 require.NoError(t, err)
276 require.NoError(t, resp.Body.Close())
278 assert.True(t, sent)
279 assert.Contains(t, output.String(), "request not dumped")
280}
282func TestDebugTransport_RedactsCredentialsInTheQuery(t *testing.T) {
283 var received string
284 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
285 received = r.URL.RawQuery
286 w.WriteHeader(http.StatusNoContent)
287 }))
288 t.Cleanup(server.Close)
290 var output bytes.Buffer
291 client := &http.Client{Transport: &debugTransport{rt: http.DefaultTransport, w: &output}}
292 resp, err := client.Get(server.URL + "/api/v4/projects?per_page=2&private_token=secret-pat&job%5Ftoken=secret-job")
293 require.NoError(t, err)
294 require.NoError(t, resp.Body.Close())
296 assert.Equal(t, "per_page=2&private_token=secret-pat&job%5Ftoken=secret-job", received, "the server receives the query unchanged")
297 assert.Contains(t, output.String(), "GET /api/v4/projects?per_page=2&private_token=[REDACTED]&job%5Ftoken=[REDACTED] HTTP/1.1\r\n")
298 assert.NotContains(t, output.String(), "secret-")
299}
301func TestDebugTransport_DumpsMessagesWithoutCredentialsAsHttputilDoes(t *testing.T) {
302 const body = `{"id":1,"name":"proj"}`
303 newResponse := func(req *http.Request) *http.Response {
304 return &http.Response{
305 Status: "200 OK", StatusCode: http.StatusOK, Proto: "HTTP/1.1", ProtoMajor: 1, ProtoMinor: 1,
306 Header: http.Header{"Content-Type": {"application/json"}},
307 TransferEncoding: []string{"chunked"},
308 ContentLength: -1,
309 Body: io.NopCloser(strings.NewReader(body)),
310 Request: req,
311 }
312 }
313 newRequest := func() *http.Request {
314 // A reader of unknown length, so the request is sent chunked.
315 req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "https://gitlab.example.com/api/v4/projects", io.MultiReader(strings.NewReader(body)))
316 require.NoError(t, err)
317 return req
318 }
319 wantRequest, err := httputil.DumpRequestOut(newRequest(), true)
320 require.NoError(t, err)
321 expected := newResponse(nil)
322 wantResponse, err := httputil.DumpResponse(expected, true)
323 require.NoError(t, err)
324 require.NoError(t, expected.Body.Close())
326 var output bytes.Buffer
327 transport := &debugTransport{
328 rt: roundTripFunc(func(req *http.Request) (*http.Response, error) {
329 return newResponse(req), nil
330 }),
331 w: &output,
332 }
333 resp, err := transport.RoundTrip(newRequest())
334 require.NoError(t, err)
335 require.NoError(t, resp.Body.Close())
337 assert.Equal(t, fmt.Sprintf("REQUEST:\n%s\n\nRESPONSE:\n%s\n\n", wantRequest, wantResponse), output.String())
338}
340type failingBody struct{ readErr, closeErr error }
342func (b failingBody) Read([]byte) (int, error) { return 0, b.readErr }
343func (b failingBody) Close() error { return b.closeErr }
345func TestDebugTransport_ReturnsBothTheReadAndTheCloseError(t *testing.T) {
346 readErr := errors.New("read failed")
347 closeErr := errors.New("close failed")
348 transport := &debugTransport{
349 rt: roundTripFunc(func(req *http.Request) (*http.Response, error) {
350 return &http.Response{StatusCode: http.StatusOK, Body: failingBody{readErr, closeErr}, Request: req}, nil
351 }),
352 w: io.Discard,
353 }
354 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://gitlab.example.com/api/v4/user", http.NoBody)
355 require.NoError(t, err)
357 resp, err := transport.RoundTrip(req) //nolint:bodyclose // no response is returned on error
358 assert.Nil(t, resp)
359 require.ErrorIs(t, err, readErr)
360 require.ErrorIs(t, err, closeErr)
361}
Diagnostics6 git calls · 311 ms
CallStatusSizeTime0311 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 · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=5 git.response.bytes=4273 git.response.cache=HIT git.response.duration_ms=3 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 · hit5 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=32926 git.response.cache=HIT git.response.duration_ms=5 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
fetchtree:02001.1 KiB · hit3 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=1165 git.response.cache=HIT git.response.duration_ms=3 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
fetch2003.6 KiB302 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=302 git.response.bytes=3684 git.response.cache=MISS git.response.duration_ms=302 git.fetch.wants=cd72cb74c15a97429f5f2c858db63cf3907a606c 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=3684 git.pkt.payload.max=3657 git.sideband.band1.bytes=3657 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
- a5e135e4b9be18aa
- Request
- eae7f746…
- 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