GitLabgitlab-org
cli
main
1//go:build !integration
3package proxy
5import (
6 "bufio"
7 "bytes"
8 "context"
9 "errors"
10 "fmt"
11 "io"
12 "log"
13 "net"
14 "net/http"
15 "net/http/httptest"
16 "net/url"
17 "os"
18 "strings"
19 "sync"
20 "sync/atomic"
21 "testing"
22 "time"
24 "github.com/stretchr/testify/assert"
25 "github.com/stretchr/testify/require"
27 "gitlab.com/gitlab-org/cli/internal/dependencyfirewall/policy"
28 "gitlab.com/gitlab-org/cli/internal/dependencyfirewall/verdict"
29)
31const plainJarPath = "/repository/public/org/slf4j/slf4j-api/2.0.9/slf4j-api-2.0.9.jar"
33// startPlainProxy starts a proxy that a plain-HTTP client reaches with
34// absolute-form requests, the way Maven uses its http <proxy> entry.
35func startPlainProxy(t *testing.T, checker policy.Checker, opts ...Option) (*Proxy, *http.Client) {
36 t.Helper()
37 p, err := New(MavenMatcher{}, checker, "group/proj", opts...)
38 require.NoError(t, err)
39 require.NoError(t, p.Start())
40 t.Cleanup(p.Stop)
41 proxyURL, err := url.Parse("http://svc:proxy-secret@" + p.Addr())
42 require.NoError(t, err)
43 return p, &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}
44}
46// recordingUpstream serves a jar and records what reached it.
47type recordingUpstream struct {
48 hits atomic.Int32
49 mu sync.Mutex
50 headers http.Header
51 body string
52}
54func (u *recordingUpstream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
55 u.hits.Add(1)
56 body, _ := io.ReadAll(r.Body)
57 u.mu.Lock()
58 u.headers = r.Header.Clone()
59 u.body = string(body)
60 u.mu.Unlock()
61 _, _ = io.WriteString(w, "jar-bytes")
62}
64// sendPartialUpload sends an absolute-form jar upload over a raw connection
65// that declares a large body but sends only its first few bytes, then stalls.
66func sendPartialUpload(t *testing.T, p *Proxy, upstream *httptest.Server) net.Conn {
67 t.Helper()
68 conn, err := net.Dial("tcp", p.Addr())
69 require.NoError(t, err)
70 t.Cleanup(func() { _ = conn.Close() })
71 host := upstream.Listener.Addr().String()
72 _, err = fmt.Fprintf(conn, "PUT http://%s%s HTTP/1.1\r\nHost: %s\r\nContent-Length: %d\r\n\r\npartial", host, plainJarPath, host, 1<<20)
73 require.NoError(t, err)
74 return conn
75}
77// h2cUpgradeRequest builds a GET carrying the h2c upgrade offer that libcurl
78// adds to every plain-HTTP request when it may use HTTP/2.
79func h2cUpgradeRequest(t *testing.T, target string) *http.Request {
80 t.Helper()
81 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, target, http.NoBody)
82 require.NoError(t, err)
83 req.Header.Set("Connection", "Upgrade, HTTP2-Settings")
84 req.Header.Set("Upgrade", "h2c")
85 req.Header.Set("HTTP2-Settings", "AAMAAABkAAQAoAAAAAIAAAAA")
86 return req
87}
89func waitFor(t *testing.T, ch <-chan struct{}, what string) {
90 t.Helper()
91 select {
92 case <-ch:
93 case <-time.After(5 * time.Second):
94 t.Fatalf("timed out waiting for %s", what)
95 }
96}
98// lockedBuffer lets the standard logger write from server goroutines while
99// the test reads it.
100type lockedBuffer struct {
101 mu sync.Mutex
102 buf bytes.Buffer
103}
105func (b *lockedBuffer) Write(p []byte) (int, error) {
106 b.mu.Lock()
107 defer b.mu.Unlock()
108 return b.buf.Write(p)
109}
111func (b *lockedBuffer) String() string {
112 b.mu.Lock()
113 defer b.mu.Unlock()
114 return b.buf.String()
115}
117// captureStdLog redirects the standard logger, which both dbg and an
118// unconfigured ReverseProxy write to, for the rest of the test.
119func captureStdLog(t *testing.T) *lockedBuffer {
120 t.Helper()
121 buf := &lockedBuffer{}
122 out, flags := log.Writer(), log.Flags()
123 log.SetOutput(buf)
124 log.SetFlags(0)
125 t.Cleanup(func() {
126 log.SetOutput(out)
127 log.SetFlags(flags)
128 })
129 return buf
130}
132func TestProxyPlainHTTPFailedCheckKeepsErrorOutOfResponse(t *testing.T) {
133 t.Parallel()
134 upstream := httptest.NewServer(&recordingUpstream{})
135 t.Cleanup(upstream.Close)
136 notices := &warningRecorder{}
137 checker := verdictChecker{"org.slf4j:slf4j-api": {Verdict: verdict.Blocked, Reason: "policy check failed: GET https://gitlab.example/api/v4/projects/9/x: 500 {host=10.0.0.5}", CheckFailed: true}}
138 p, client := startPlainProxy(t, checker, WithBlockNotice(notices.Logf))
140 resp, err := client.Get(upstream.URL + plainJarPath)
141 require.NoError(t, err)
142 body, err := io.ReadAll(resp.Body)
143 require.NoError(t, err)
144 resp.Body.Close()
146 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
147 assert.NotContains(t, string(body), "gitlab.example")
148 assert.Empty(t, notices.Lines())
149 verdicts := p.Verdicts()
150 require.Len(t, verdicts, 1)
151 assert.Contains(t, verdicts[0].Reason, "gitlab.example", "the summary keeps the full error")
152}
154func TestProxyPlainHTTP(t *testing.T) {
155 t.Run("when a rule names the real package behind an http mirror", func(t *testing.T) {
156 up := &recordingUpstream{}
157 upstream := httptest.NewServer(up)
158 t.Cleanup(upstream.Close)
159 p, client := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
161 resp, err := client.Get(upstream.URL + plainJarPath)
162 require.NoError(t, err)
163 defer resp.Body.Close()
165 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
166 assert.Equal(t, "blocked", resp.Header.Get(firewallHeader))
167 assert.True(t, resp.Close, "the 403 closes the connection, so a client mid-upload stops sending")
168 assert.Zero(t, up.hits.Load(), "a blocked request must not reach the upstream")
169 verdicts := p.Verdicts()
170 require.Len(t, verdicts, 1)
171 assert.Equal(t, "org.slf4j:slf4j-api", verdicts[0].Package)
172 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
173 })
175 t.Run("when the package is allowed", func(t *testing.T) {
176 up := &recordingUpstream{}
177 upstream := httptest.NewServer(up)
178 t.Cleanup(upstream.Close)
179 p, client := startPlainProxy(t, verdictChecker{})
181 resp, err := client.Get(upstream.URL + plainJarPath)
182 require.NoError(t, err)
183 defer resp.Body.Close()
184 body, err := io.ReadAll(resp.Body)
185 require.NoError(t, err)
187 assert.Equal(t, http.StatusOK, resp.StatusCode)
188 assert.Equal(t, "jar-bytes", string(body))
189 assert.Equal(t, int32(1), up.hits.Load())
190 up.mu.Lock()
191 defer up.mu.Unlock()
192 assert.Equal(t, "allowed", up.headers.Get(firewallHeader))
193 assert.Empty(t, up.headers.Get("Proxy-Authorization"), "the client's proxy credentials must not reach the upstream")
194 assert.Empty(t, p.Verdicts())
195 })
197 t.Run("when a warn rule names the real package", func(t *testing.T) {
198 upstream := httptest.NewServer(&recordingUpstream{})
199 t.Cleanup(upstream.Close)
200 p, client := startPlainProxy(t, verdictChecker{"org.slf4j:slf4j-api": {Verdict: verdict.Warning, Reason: "warned"}})
202 resp, err := client.Get(upstream.URL + plainJarPath)
203 require.NoError(t, err)
204 defer resp.Body.Close()
206 assert.Equal(t, http.StatusOK, resp.StatusCode)
207 verdicts := p.Verdicts()
208 require.Len(t, verdicts, 1)
209 assert.Equal(t, verdict.Warning, verdicts[0].Verdict)
210 assert.Equal(t, "org.slf4j:slf4j-api", verdicts[0].Package)
211 })
213 t.Run("when the policy check fails", func(t *testing.T) {
214 up := &recordingUpstream{}
215 upstream := httptest.NewServer(up)
216 t.Cleanup(upstream.Close)
217 p, client := startPlainProxy(t, errChecker{on: "org.slf4j:slf4j-api"})
219 resp, err := client.Get(upstream.URL + plainJarPath)
220 require.NoError(t, err)
221 defer resp.Body.Close()
223 assert.Equal(t, http.StatusForbidden, resp.StatusCode, "a failed check must fail closed")
224 assert.Equal(t, "blocked", resp.Header.Get(firewallHeader))
225 assert.Zero(t, up.hits.Load())
226 verdicts := p.Verdicts()
227 require.Len(t, verdicts, 1)
228 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
229 assert.Contains(t, verdicts[0].Reason, "policy check failed")
230 })
232 t.Run("when the request is not for a Maven artifact", func(t *testing.T) {
233 up := &recordingUpstream{}
234 upstream := httptest.NewServer(up)
235 t.Cleanup(upstream.Close)
236 p, client := startPlainProxy(t, stubChecker{result: policy.Result{Verdict: verdict.Blocked, Reason: "blocks everything"}})
238 resp, err := client.Get(upstream.URL + "/repository/public/org/slf4j/slf4j-api/maven-metadata.xml")
239 require.NoError(t, err)
240 defer resp.Body.Close()
242 assert.Equal(t, http.StatusOK, resp.StatusCode)
243 assert.Equal(t, int32(1), up.hits.Load())
244 up.mu.Lock()
245 defer up.mu.Unlock()
246 assert.Equal(t, "allowed", up.headers.Get(firewallHeader))
247 assert.Empty(t, p.Verdicts())
248 })
250 t.Run("when an upload is allowed", func(t *testing.T) {
251 up := &recordingUpstream{}
252 upstream := httptest.NewServer(up)
253 t.Cleanup(upstream.Close)
254 _, client := startPlainProxy(t, verdictChecker{})
256 req, err := http.NewRequestWithContext(t.Context(), http.MethodPut, upstream.URL+plainJarPath, strings.NewReader("uploaded-jar"))
257 require.NoError(t, err)
258 resp, err := client.Do(req)
259 require.NoError(t, err)
260 defer resp.Body.Close()
262 assert.Equal(t, http.StatusOK, resp.StatusCode)
263 up.mu.Lock()
264 defer up.mu.Unlock()
265 assert.Equal(t, "uploaded-jar", up.body, "the upload must reach the upstream intact")
266 })
268 t.Run("when an upload is blocked", func(t *testing.T) {
269 up := &recordingUpstream{}
270 upstream := httptest.NewServer(up)
271 t.Cleanup(upstream.Close)
272 p, client := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
274 req, err := http.NewRequestWithContext(t.Context(), http.MethodPut, upstream.URL+plainJarPath, strings.NewReader("uploaded-jar"))
275 require.NoError(t, err)
276 resp, err := client.Do(req)
277 require.NoError(t, err)
278 defer resp.Body.Close()
280 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
281 assert.Zero(t, up.hits.Load(), "a blocked upload must not reach the upstream")
282 verdicts := p.Verdicts()
283 require.Len(t, verdicts, 1)
284 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
285 })
287 t.Run("when a blocked upload is still sending its body", func(t *testing.T) {
288 up := &recordingUpstream{}
289 upstream := httptest.NewServer(up)
290 t.Cleanup(upstream.Close)
291 p, _ := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
292 conn := sendPartialUpload(t, p, upstream)
294 require.NoError(t, conn.SetReadDeadline(time.Now().Add(time.Second)))
295 resp, err := http.ReadResponse(bufio.NewReader(conn), nil)
296 require.NoError(t, err, "the block must reach a client that is still uploading")
297 defer resp.Body.Close()
299 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
300 assert.Zero(t, up.hits.Load())
301 assert.Empty(t, resp.TransferEncoding)
302 body, err := io.ReadAll(resp.Body)
303 require.NoError(t, err, "the whole 403 must arrive while the upload is still being drained")
304 assert.Equal(t, int64(len(body)), resp.ContentLength)
305 })
307 t.Run("when a blocked upload stalls after the 403", func(t *testing.T) {
308 upstream := httptest.NewServer(&recordingUpstream{})
309 t.Cleanup(upstream.Close)
310 p, _ := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
311 conn := sendPartialUpload(t, p, upstream)
313 require.NoError(t, conn.SetReadDeadline(time.Now().Add(time.Second)))
314 br := bufio.NewReader(conn)
315 resp, err := http.ReadResponse(br, nil)
316 require.NoError(t, err)
317 resp.Body.Close()
318 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
320 require.NoError(t, conn.SetReadDeadline(time.Now().Add(plainBlockDrainTimeout+2*time.Second)))
321 _, err = io.ReadAll(br)
322 assert.NotErrorIs(t, err, os.ErrDeadlineExceeded, "the proxy must stop draining a stalled upload well before Stop's timeout")
323 })
325 t.Run("when a blocked upload is written in full before the response is read", func(t *testing.T) {
326 up := &recordingUpstream{}
327 upstream := httptest.NewServer(up)
328 t.Cleanup(upstream.Close)
329 p, _ := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
330 addr, err := net.ResolveTCPAddr("tcp", p.Addr())
331 require.NoError(t, err)
332 conn, err := net.DialTCP("tcp", nil, addr)
333 require.NoError(t, err)
334 t.Cleanup(func() { _ = conn.Close() })
335 // Left to auto-tune, the send buffer can absorb the whole body unread
336 // and hide the reset.
337 require.NoError(t, conn.SetWriteBuffer(64<<10))
339 host := upstream.Listener.Addr().String()
340 body := bytes.Repeat([]byte("x"), 1<<20)
341 written := make(chan error, 1)
342 go func() {
343 _, err := fmt.Fprintf(conn, "PUT http://%s%s HTTP/1.1\r\nHost: %s\r\nContent-Length: %d\r\n\r\n", host, plainJarPath, host, len(body))
344 if err == nil {
345 _, err = conn.Write(body)
346 }
347 written <- err
348 }()
349 select {
350 case err := <-written:
351 require.NoError(t, err, "the client must be able to finish sending its body")
352 case <-time.After(5 * time.Second):
353 t.Fatal("timed out sending the upload")
354 }
356 require.NoError(t, conn.SetReadDeadline(time.Now().Add(5*time.Second)))
357 resp, err := http.ReadResponse(bufio.NewReader(conn), nil)
358 require.NoError(t, err, "the block must reach a client that reads only after sending its whole body")
359 defer resp.Body.Close()
361 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
362 assert.Zero(t, up.hits.Load())
363 })
365 t.Run("when the client sends forwarding headers", func(t *testing.T) {
366 up := &recordingUpstream{}
367 upstream := httptest.NewServer(up)
368 t.Cleanup(upstream.Close)
369 _, client := startPlainProxy(t, verdictChecker{})
371 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, upstream.URL+plainJarPath, http.NoBody)
372 require.NoError(t, err)
373 req.Header.Set("X-Forwarded-For", "203.0.113.7")
374 req.Header.Set("Forwarded", "for=203.0.113.7")
375 resp, err := client.Do(req)
376 require.NoError(t, err)
377 defer resp.Body.Close()
379 assert.Equal(t, http.StatusOK, resp.StatusCode)
380 up.mu.Lock()
381 defer up.mu.Unlock()
382 assert.Empty(t, up.headers.Values("X-Forwarded-For"), "neither the client's nor the proxy's address may reach the upstream")
383 assert.Empty(t, up.headers.Values("Forwarded"))
384 })
386 t.Run("when the request offers an h2c upgrade", func(t *testing.T) {
387 up := &recordingUpstream{}
388 upstream := httptest.NewServer(up)
389 t.Cleanup(upstream.Close)
390 p, client := startPlainProxy(t, verdictChecker{})
392 resp, err := client.Do(h2cUpgradeRequest(t, upstream.URL+plainJarPath))
393 require.NoError(t, err)
394 defer resp.Body.Close()
396 assert.Equal(t, http.StatusOK, resp.StatusCode, "libcurl offers h2c on every request, so the offer must not be refused")
397 assert.Equal(t, int32(1), up.hits.Load())
398 up.mu.Lock()
399 defer up.mu.Unlock()
400 assert.Empty(t, up.headers.Values("Upgrade"), "the upstream must not be asked to switch protocols")
401 assert.Empty(t, p.Verdicts())
402 })
404 t.Run("when a blocked request offers an h2c upgrade", func(t *testing.T) {
405 up := &recordingUpstream{}
406 upstream := httptest.NewServer(up)
407 t.Cleanup(upstream.Close)
408 p, client := startPlainProxy(t, &denyChecker{name: "org.slf4j:slf4j-api"})
410 resp, err := client.Do(h2cUpgradeRequest(t, upstream.URL+plainJarPath))
411 require.NoError(t, err)
412 defer resp.Body.Close()
414 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
415 assert.Zero(t, up.hits.Load())
416 verdicts := p.Verdicts()
417 require.Len(t, verdicts, 1)
418 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
419 })
421 t.Run("when the upstream switches protocols", func(t *testing.T) {
422 ln, err := net.Listen("tcp", "127.0.0.1:0")
423 require.NoError(t, err)
424 t.Cleanup(func() { _ = ln.Close() })
425 afterSwitch := make(chan string, 1)
426 upstreamConn := make(chan net.Conn, 1)
427 go func() {
428 conn, err := ln.Accept()
429 if err != nil {
430 afterSwitch <- ""
431 return
432 }
433 upstreamConn <- conn
434 br := bufio.NewReader(conn)
435 if _, err := http.ReadRequest(br); err == nil {
436 _, _ = io.WriteString(conn, "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n")
437 }
438 rest, _ := io.ReadAll(br)
439 afterSwitch <- string(rest)
440 }()
441 p, _ := startPlainProxy(t, verdictChecker{})
442 conn, err := net.Dial("tcp", p.Addr())
443 require.NoError(t, err)
444 t.Cleanup(func() { _ = conn.Close() })
446 host := ln.Addr().String()
447 _, err = fmt.Fprintf(conn, "GET http://%s%s HTTP/1.1\r\nHost: %s\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n", host, plainJarPath, host)
448 require.NoError(t, err)
449 require.NoError(t, conn.SetReadDeadline(time.Now().Add(2*time.Second)))
450 br := bufio.NewReader(conn)
451 resp, err := http.ReadResponse(br, nil)
452 require.NoError(t, err)
453 resp.Body.Close()
454 assert.Equal(t, http.StatusBadGateway, resp.StatusCode)
456 _, err = io.WriteString(conn, "GET /after-switch HTTP/1.1\r\nHost: probe\r\n\r\n")
457 require.NoError(t, err)
458 if resp, err := http.ReadResponse(br, nil); assert.NoError(t, err, "the proxy itself must answer the next request") {
459 resp.Body.Close()
460 assert.Equal(t, http.StatusMethodNotAllowed, resp.StatusCode)
461 }
463 _ = conn.Close()
464 _ = ln.Close()
465 select {
466 case c := <-upstreamConn:
467 _ = c.Close()
468 default:
469 }
470 assert.NotContains(t, <-afterSwitch, "/after-switch", "bytes after a 101 must not be spliced to the upstream")
471 })
473 t.Run("when the upstream switches protocols without an upgrade offer", func(t *testing.T) {
474 ln, err := net.Listen("tcp", "127.0.0.1:0")
475 require.NoError(t, err)
476 t.Cleanup(func() { _ = ln.Close() })
477 closed := make(chan error, 1)
478 go func() {
479 conn, err := ln.Accept()
480 if err != nil {
481 closed <- err
482 return
483 }
484 defer conn.Close()
485 _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
486 br := bufio.NewReader(conn)
487 if _, err := http.ReadRequest(br); err != nil {
488 closed <- err
489 return
490 }
491 _, _ = io.WriteString(conn, "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n")
492 _, err = br.ReadByte()
493 closed <- err
494 }()
495 warnings := &warningRecorder{}
496 _, client := startPlainProxy(t, verdictChecker{}, WithUpstreamFailureWarning(warnings.Logf))
498 resp, err := client.Get("http://" + ln.Addr().String() + plainJarPath)
499 require.NoError(t, err)
500 resp.Body.Close()
501 assert.Equal(t, http.StatusBadGateway, resp.StatusCode)
503 select {
504 case err := <-closed:
505 require.ErrorIs(t, err, io.EOF, "the proxy must close the upstream connection it refused to switch")
506 case <-time.After(5 * time.Second):
507 t.Fatal("timed out waiting for the upstream connection to close")
508 }
509 assert.Equal(t, []string{
510 fmt.Sprintf("warning: dependency firewall request to registry %s failed: %v\n", ln.Addr(), errUnpromptedSwitch),
511 }, warnings.Lines())
512 })
514 t.Run("when an outbound proxy is configured", func(t *testing.T) {
515 up := &recordingUpstream{}
516 upstream := httptest.NewServer(up)
517 t.Cleanup(upstream.Close)
518 outbound := &recordingUpstream{}
519 outboundServer := httptest.NewServer(outbound)
520 t.Cleanup(outboundServer.Close)
521 outboundURL, err := url.Parse(outboundServer.URL)
522 require.NoError(t, err)
523 _, client := startPlainProxy(t, verdictChecker{}, WithUpstreamProxy(http.ProxyURL(outboundURL)))
525 resp, err := client.Get(upstream.URL + plainJarPath)
526 require.NoError(t, err)
527 defer resp.Body.Close()
529 assert.Equal(t, http.StatusOK, resp.StatusCode)
530 assert.Equal(t, int32(1), outbound.hits.Load(), "the request must go through the outbound proxy")
531 assert.Zero(t, up.hits.Load(), "the request must not bypass the outbound proxy")
532 })
534 t.Run("when the upstream is unreachable", func(t *testing.T) {
535 upstream := httptest.NewServer(&recordingUpstream{})
536 dead := upstream.URL
537 upstream.Close()
538 var warnings []string
539 var mu sync.Mutex
540 _, client := startPlainProxy(t, verdictChecker{}, WithUpstreamFailureWarning(func(format string, args ...any) {
541 mu.Lock()
542 defer mu.Unlock()
543 warnings = append(warnings, fmt.Sprintf(format, args...))
544 }))
546 for range 2 {
547 resp, err := client.Get(dead + plainJarPath)
548 require.NoError(t, err)
549 resp.Body.Close()
550 assert.Equal(t, http.StatusBadGateway, resp.StatusCode)
551 }
553 mu.Lock()
554 defer mu.Unlock()
555 assert.Len(t, warnings, 1, "each registry is reported once")
556 })
558 t.Run("when the client aborts its upload", func(t *testing.T) {
559 arrived := make(chan struct{}, 1)
560 upstream := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
561 arrived <- struct{}{}
562 _, _ = io.Copy(io.Discard, r.Body)
563 }))
564 t.Cleanup(upstream.Close)
565 warnings := &warningRecorder{}
566 p, client := startPlainProxy(t, verdictChecker{}, WithUpstreamFailureWarning(warnings.Logf))
568 body, bodyWriter := io.Pipe()
569 req, err := http.NewRequestWithContext(t.Context(), http.MethodPut, upstream.URL+plainJarPath, body)
570 require.NoError(t, err)
571 req.ContentLength = 1 << 20
572 done := make(chan error, 1)
573 go func() {
574 resp, err := client.Do(req)
575 if err == nil {
576 resp.Body.Close()
577 }
578 done <- err
579 }()
580 _, err = bodyWriter.Write([]byte("partial upload"))
581 require.NoError(t, err)
582 waitFor(t, arrived, "the upload to reach the upstream")
583 bodyWriter.CloseWithError(errors.New("package manager aborted the upload"))
584 require.Error(t, <-done)
585 p.Stop()
587 assert.Empty(t, warnings.Lines(), "a request the package manager aborted is not a registry failure")
588 })
590 t.Run("when the upstream drops the connection mid-response", func(t *testing.T) {
591 t.Setenv("GLAB_DEBUG", "true")
592 logs := captureStdLog(t)
593 upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
594 conn, buf, err := http.NewResponseController(w).Hijack()
595 if err != nil {
596 return
597 }
598 defer conn.Close()
599 _, _ = buf.WriteString("HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\npartial")
600 _ = buf.Flush()
601 }))
602 t.Cleanup(upstream.Close)
603 p, client := startPlainProxy(t, verdictChecker{})
605 if resp, err := client.Get(upstream.URL + plainJarPath); err == nil {
606 _, _ = io.Copy(io.Discard, resp.Body)
607 resp.Body.Close()
608 }
609 p.Stop()
611 out := logs.String()
612 assert.Contains(t, out, "dependency firewall proxy: httputil: ReverseProxy read error during body copy")
613 assert.NotRegexp(t, `(?m)^httputil:`, out, "ReverseProxy must not write to glab's stderr")
614 })
616 t.Run("when the request is not absolute-form", func(t *testing.T) {
617 p, _ := startPlainProxy(t, verdictChecker{})
619 resp, err := http.Get("http://" + p.Addr() + plainJarPath)
620 require.NoError(t, err)
621 defer resp.Body.Close()
623 assert.Equal(t, http.StatusMethodNotAllowed, resp.StatusCode)
624 })
626 t.Run("when Stop runs while the upstream hangs", func(t *testing.T) {
627 reached := make(chan struct{})
628 release := make(chan struct{})
629 upstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
630 close(reached)
631 <-release
632 }))
633 t.Cleanup(upstream.Close)
634 p, client := startPlainProxy(t, verdictChecker{})
635 // Registered after startPlainProxy so it runs before its p.Stop, which
636 // would otherwise wait on this handler if the code under test regressed.
637 t.Cleanup(func() { close(release) })
639 go func() {
640 if resp, err := client.Get(upstream.URL + plainJarPath); err == nil {
641 resp.Body.Close()
642 }
643 }()
644 waitFor(t, reached, "the request to reach the upstream")
646 stopped := make(chan struct{})
647 go func() {
648 p.Stop()
649 close(stopped)
650 }()
651 select {
652 case <-stopped:
653 case <-time.After(5 * time.Second):
654 t.Fatal("Stop must not wait on a hung plain-HTTP upstream")
655 }
656 })
658 t.Run("when Stop runs while a client stalls mid-upload", func(t *testing.T) {
659 reached := make(chan struct{}, 1)
660 upstream := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
661 reached <- struct{}{}
662 _, _ = io.Copy(io.Discard, r.Body)
663 }))
664 t.Cleanup(upstream.Close)
665 p, _ := startPlainProxy(t, verdictChecker{})
666 conn := sendPartialUpload(t, p, upstream)
667 waitFor(t, reached, "the upload to reach the upstream")
669 stopped := make(chan struct{})
670 go func() {
671 p.Stop()
672 close(stopped)
673 }()
674 select {
675 case <-stopped:
676 case <-time.After(tunnelDrainTimeout + 2*time.Second):
677 t.Fatal("Stop must not wait on a client that stalls mid-upload")
678 }
679 require.NoError(t, conn.SetReadDeadline(time.Now().Add(time.Second)))
680 _, err := io.ReadAll(conn)
681 assert.NotErrorIs(t, err, os.ErrDeadlineExceeded, "Stop must close a stalled client's connection")
682 })
683}
685// ctxWaitChecker holds each check until its context ends, and reports when
686// the first check starts and ends.
687type ctxWaitChecker struct {
688 started, ended chan struct{}
689 startOnce, endOnce sync.Once
690}
692func (c *ctxWaitChecker) Check(ctx context.Context, _ policy.Request) (policy.Result, error) {
693 c.startOnce.Do(func() { close(c.started) })
694 <-ctx.Done()
695 c.endOnce.Do(func() { close(c.ended) })
696 return policy.Result{}, ctx.Err()
697}
699func TestProxyPlainHTTPClientGoesAway(t *testing.T) {
700 upstream := httptest.NewServer(&recordingUpstream{})
701 t.Cleanup(upstream.Close)
702 checker := &ctxWaitChecker{started: make(chan struct{}), ended: make(chan struct{})}
703 _, client := startPlainProxy(t, checker)
704 ctx, cancel := context.WithCancel(t.Context())
705 req, err := http.NewRequestWithContext(ctx, http.MethodGet, upstream.URL+plainJarPath, http.NoBody)
706 require.NoError(t, err)
707 done := make(chan struct{})
708 go func() {
709 defer close(done)
710 if resp, err := client.Do(req); err == nil {
711 _ = resp.Body.Close()
712 }
713 }()
715 waitFor(t, checker.started, "the policy check to start")
716 cancel()
718 waitFor(t, checker.ended, "the policy check to end when the client goes away")
719 waitFor(t, done, "the client to return")
720}
722// TestProxyFailsClosedOnUnclearedMatch pins admit's guard for a request the
723// matcher recognized but couldn't clear. The checker allows everything, so
724// only the guard can block.
725func TestProxyFailsClosedOnUnclearedMatch(t *testing.T) {
726 // The file names the artifact but not the directory's version.
727 const path = "/repository/public/org/example/foo/1/foo-10.jar"
729 t.Run("when the request is plain HTTP", func(t *testing.T) {
730 up := &recordingUpstream{}
731 upstream := httptest.NewServer(up)
732 t.Cleanup(upstream.Close)
733 p, client := startPlainProxy(t, verdictChecker{})
735 resp, err := client.Get(upstream.URL + path)
736 require.NoError(t, err)
737 defer resp.Body.Close()
739 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
740 assert.Zero(t, up.hits.Load())
741 verdicts := p.Verdicts()
742 require.Len(t, verdicts, 1)
743 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
744 })
746 t.Run("when the request is tunnelled", func(t *testing.T) {
747 up := &recordingUpstream{}
748 upstream := httptest.NewTLSServer(up)
749 t.Cleanup(upstream.Close)
750 p := startProxyWithMatcher(t, upstream, MavenMatcher{}, verdictChecker{})
752 resp, err := newClient(t, p).Get(upstream.URL + path)
753 require.NoError(t, err)
754 defer resp.Body.Close()
756 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
757 assert.Zero(t, up.hits.Load())
758 verdicts := p.Verdicts()
759 require.Len(t, verdicts, 1)
760 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
761 })
762}
764func TestProxyRefusesOtherAbsoluteSchemes(t *testing.T) {
765 for _, scheme := range []string{"https", "ftp"} {
766 t.Run("when the request names an "+scheme+" URL", func(t *testing.T) {
767 up := &recordingUpstream{}
768 upstream := httptest.NewServer(up)
769 t.Cleanup(upstream.Close)
770 p, _ := startPlainProxy(t, verdictChecker{})
771 conn, err := net.Dial("tcp", p.Addr())
772 require.NoError(t, err)
773 t.Cleanup(func() { _ = conn.Close() })
774 host := upstream.Listener.Addr().String()
776 _, err = fmt.Fprintf(conn, "GET %s://%s%s HTTP/1.1\r\nHost: %s\r\n\r\n", scheme, host, plainJarPath, host)
777 require.NoError(t, err)
778 resp, err := http.ReadResponse(bufio.NewReader(conn), nil)
779 require.NoError(t, err)
780 defer resp.Body.Close()
782 assert.Equal(t, http.StatusMethodNotAllowed, resp.StatusCode, "only http:// is served as a plain request")
783 assert.Zero(t, up.hits.Load())
784 })
785 }
786}
788// TestProxyPlainHTTPOutboundProxyFromEnvironment reads the environment, as
789// production does. Loopback is never proxied, so the registry is a name, and
790// no assertion depends on whether that name resolves.
791func TestProxyPlainHTTPOutboundProxyFromEnvironment(t *testing.T) {
792 const registry = "http://registry.example"
793 outbound := func(t *testing.T) (*recordingUpstream, string) {
794 t.Helper()
795 rec := &recordingUpstream{}
796 srv := httptest.NewServer(rec)
797 t.Cleanup(srv.Close)
798 return rec, srv.URL
799 }
800 setProxyEnv := func(t *testing.T, httpsProxy, httpProxy, noProxy string) {
801 t.Helper()
802 for _, kv := range [][2]string{{"HTTPS_PROXY", httpsProxy}, {"HTTP_PROXY", httpProxy}, {"NO_PROXY", noProxy}} {
803 t.Setenv(kv[0], kv[1])
804 t.Setenv(strings.ToLower(kv[0]), kv[1])
805 }
806 }
807 get := func(t *testing.T) int {
808 t.Helper()
809 _, client := startPlainProxy(t, verdictChecker{})
810 resp, err := client.Get(registry + plainJarPath)
811 require.NoError(t, err)
812 defer resp.Body.Close()
813 return resp.StatusCode
814 }
816 t.Run("when only HTTPS_PROXY is set", func(t *testing.T) {
817 via, viaURL := outbound(t)
818 setProxyEnv(t, viaURL, "", "")
820 assert.Equal(t, http.StatusOK, get(t))
821 assert.Equal(t, int32(1), via.hits.Load(), "HTTPS_PROXY is the outbound proxy glab documents")
822 })
824 t.Run("when HTTP_PROXY is set too", func(t *testing.T) {
825 viaHTTPS, httpsURL := outbound(t)
826 viaHTTP, httpURL := outbound(t)
827 setProxyEnv(t, httpsURL, httpURL, "")
829 assert.Equal(t, http.StatusOK, get(t))
830 assert.Equal(t, int32(1), viaHTTP.hits.Load(), "HTTP_PROXY takes plain-HTTP requests when it's set")
831 assert.Zero(t, viaHTTPS.hits.Load())
832 })
834 t.Run("when NO_PROXY names the registry", func(t *testing.T) {
835 via, viaURL := outbound(t)
836 setProxyEnv(t, viaURL, "", "registry.example")
837 _, client := startPlainProxy(t, verdictChecker{})
838 ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
839 defer cancel()
840 req, err := http.NewRequestWithContext(ctx, http.MethodGet, registry+plainJarPath, http.NoBody)
841 require.NoError(t, err)
842 if resp, err := client.Do(req); err == nil {
843 resp.Body.Close()
844 }
846 assert.Zero(t, via.hits.Load(), "a registry in NO_PROXY is reached directly, not through the outbound proxy")
847 })
848}
850// bodyReadingMatcher reads the whole upload before deciding, as upload
851// matchers do, and fails closed a moment after the body can't be read.
852type bodyReadingMatcher struct{ reading chan struct{} }
854func (m bodyReadingMatcher) Match(req *http.Request) Match {
855 close(m.reading)
856 if _, err := io.ReadAll(req.Body); err != nil {
857 time.Sleep(200 * time.Millisecond)
858 return Match{Matched: true, Coordinate: policy.Coordinate{Name: "stalled"}, Reason: "upload unreadable"}
859 }
860 return Match{}
861}
863func TestProxyStopDrainsPlainHandlerBeforeVerdicts(t *testing.T) {
864 t.Parallel()
865 upstream := httptest.NewServer(http.NotFoundHandler())
866 t.Cleanup(upstream.Close)
867 matcher := bodyReadingMatcher{reading: make(chan struct{})}
868 p, err := New(matcher, verdictChecker{}, "group/proj")
869 require.NoError(t, err)
870 require.NoError(t, p.Start())
871 sendPartialUpload(t, p, upstream)
872 waitFor(t, matcher.reading, "the matcher to start reading the upload")
874 p.Stop()
876 verdicts := p.Verdicts()
877 require.Len(t, verdicts, 1, "Stop must wait for a plain-HTTP handler that records after Shutdown gives up")
878 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
879}
Diagnostics7 git calls · 525 ms
CallStatusSizeTime0525 ms
discover200185 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 KiB · hit2 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=HIT 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
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=4 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 · hit4 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=4 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:0200361 B · 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=361 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=506cba622ceda1473ee3cde63969809c144b7247 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=361 git.pkt.payload.max=334 git.sideband.band1.bytes=334 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=334 git.pack.trailer=26d32585a3a474717e00a318584ccd16918c9d32Open pack map
fetchtree:02001.0 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=1051 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=7a2a90605315ba5b37f63c08726e6b2caa26e48d 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=1051 git.pkt.payload.max=1024 git.sideband.band1.bytes=1024 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=1024 git.pack.trailer=7503ef36a75d3595b473035c69e639fd0ce41598Open pack map
fetch2006.6 KiB516 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=515 git.response.bytes=6726 git.response.cache=MISS git.response.duration_ms=516 git.fetch.wants=7c1c6fc76c68305874152e6ce01e395967138373 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=6726 git.pkt.payload.max=6699 git.sideband.band1.bytes=6699 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
- a5e22f105c62a594
- Request
- d5eb5649…
- 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