1use std::{sync::OnceLock, time::Duration};
10
11use axum::{
12 body::{to_bytes, Body},
13 extract::{Extension, RawQuery},
14 http::{header, HeaderMap, HeaderValue, Method, StatusCode},
15 response::{IntoResponse, Response},
16 routing::{get, post},
17 Router,
18};
19use bytes::Bytes;
20use futures::{stream, StreamExt};
21use tokio::sync::{Semaphore, SemaphorePermit};
22
23const INFO_REFS_PATH: &str = "/git/canary.git/info/refs";
24const UPLOAD_PACK_PATH: &str = "/git/canary.git/git-upload-pack";
25const UPLOAD_PACK_ADVERTISEMENT: &str = "application/x-git-upload-pack-advertisement";
26const UPLOAD_PACK_REQUEST: &str = "application/x-git-upload-pack-request";
27const UPLOAD_PACK_RESULT: &str = "application/x-git-upload-pack-result";
28const MAX_REQUEST_BYTES: usize = 4 * 1024 * 1024;
29const MAX_RESPONSE_BYTES: u64 = 256 * 1024 * 1024;
30const MAX_CONCURRENT_REQUESTS: usize = 2;
31const REQUEST_BODY_TIMEOUT: Duration = Duration::from_secs(30);
32const BACKEND_TIMEOUT: Duration = Duration::from_secs(300);
33
34static REQUESTS: Semaphore = Semaphore::const_new(MAX_CONCURRENT_REQUESTS);
35static BACKEND_CLIENT: OnceLock<Result<reqwest::Client, ()>> = OnceLock::new();
36
37#[derive(Clone, Copy)]
38struct BackendPort(u16);
39
40pub fn routes<S>(port: u16) -> Router<S>
44where
45 S: Clone + Send + Sync + 'static,
46{
47 Router::new()
48 .route(INFO_REFS_PATH, get(info_refs))
49 .route(UPLOAD_PACK_PATH, post(upload_pack))
50 .layer(Extension(BackendPort(port)))
51 .with_state(())
52}
53
54fn error(status: StatusCode) -> Response {
55 (
56 status,
57 [
58 (header::CACHE_CONTROL, "no-store"),
59 (header::CONTENT_TYPE, "text/plain; charset=utf-8"),
60 ],
61 "Git canary request failed\n",
62 )
63 .into_response()
64}
65
66fn backend_client() -> Option<&'static reqwest::Client> {
67 BACKEND_CLIENT
68 .get_or_init(|| {
69 reqwest::Client::builder()
70 .no_proxy()
71 .redirect(reqwest::redirect::Policy::none())
72 .timeout(BACKEND_TIMEOUT)
73 .build()
74 .map_err(|_| ())
75 })
76 .as_ref()
77 .ok()
78}
79
80fn exact_upload_pack_query(raw_query: Option<&str>) -> bool {
81 let Some(raw) = raw_query else {
82 return false;
83 };
84 let mut pairs = url::form_urlencoded::parse(raw.as_bytes());
85 matches!(pairs.next(), Some((key, value)) if key == "service" && value == "git-upload-pack")
86 && pairs.next().is_none()
87}
88
89fn safe_git_protocol(headers: &HeaderMap) -> Result<Option<HeaderValue>, StatusCode> {
90 let Some(value) = headers.get("git-protocol") else {
91 return Ok(None);
92 };
93 let text = value.to_str().map_err(|_| StatusCode::BAD_REQUEST)?;
94 if !matches!(text, "version=1" | "version=2") {
95 return Err(StatusCode::BAD_REQUEST);
96 }
97 Ok(Some(value.clone()))
98}
99
100async fn info_refs(
101 Extension(BackendPort(port)): Extension<BackendPort>,
102 RawQuery(query): RawQuery,
103 method: Method,
104 headers: HeaderMap,
105) -> Response {
106 if port == 0 || method != Method::GET || !exact_upload_pack_query(query.as_deref()) {
107 return error(StatusCode::NOT_FOUND);
108 }
109 let protocol = match safe_git_protocol(&headers) {
110 Ok(value) => value,
111 Err(status) => return error(status),
112 };
113 let permit = match request_permit() {
114 Ok(permit) => permit,
115 Err(status) => return error(status),
116 };
117 proxy(
118 port,
119 Method::GET,
120 "/git/canary.git/info/refs?service=git-upload-pack",
121 UPLOAD_PACK_ADVERTISEMENT,
122 protocol,
123 Bytes::new(),
124 permit,
125 )
126 .await
127}
128
129async fn upload_pack(
130 Extension(BackendPort(port)): Extension<BackendPort>,
131 RawQuery(query): RawQuery,
132 headers: HeaderMap,
133 body: Body,
134) -> Response {
135 if port == 0 || query.as_deref().is_some_and(|value| !value.is_empty()) {
136 return error(StatusCode::NOT_FOUND);
137 }
138 let content_type = headers
139 .get(header::CONTENT_TYPE)
140 .and_then(|value| value.to_str().ok());
141 if content_type != Some(UPLOAD_PACK_REQUEST) {
142 return error(StatusCode::UNSUPPORTED_MEDIA_TYPE);
143 }
144 let protocol = match safe_git_protocol(&headers) {
145 Ok(value) => value,
146 Err(status) => return error(status),
147 };
148 let permit = match request_permit() {
149 Ok(permit) => permit,
150 Err(status) => return error(status),
151 };
152 let request_body =
153 match tokio::time::timeout(REQUEST_BODY_TIMEOUT, to_bytes(body, MAX_REQUEST_BYTES)).await {
154 Ok(Ok(bytes)) => bytes,
155 Ok(Err(_)) => return error(StatusCode::PAYLOAD_TOO_LARGE),
156 Err(_) => return error(StatusCode::REQUEST_TIMEOUT),
157 };
158 if request_body.is_empty() {
159 return error(StatusCode::BAD_REQUEST);
160 }
161 proxy(
162 port,
163 Method::POST,
164 UPLOAD_PACK_PATH,
165 UPLOAD_PACK_RESULT,
166 protocol,
167 request_body,
168 permit,
169 )
170 .await
171}
172
173fn request_permit() -> Result<SemaphorePermit<'static>, StatusCode> {
174 REQUESTS
175 .try_acquire()
176 .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)
177}
178
179async fn proxy(
180 port: u16,
181 method: Method,
182 path_and_query: &'static str,
183 expected_content_type: &'static str,
184 protocol: Option<HeaderValue>,
185 request_body: Bytes,
186 permit: SemaphorePermit<'static>,
187) -> Response {
188 let Some(client) = backend_client() else {
189 return error(StatusCode::BAD_GATEWAY);
190 };
191 let url = format!("http://127.0.0.1:{port}{path_and_query}");
192 let mut request = client
193 .request(method, url)
194 .header(header::ACCEPT, expected_content_type)
195 .header(header::CACHE_CONTROL, "no-store");
196 if path_and_query == UPLOAD_PACK_PATH {
197 request = request.header(header::CONTENT_TYPE, UPLOAD_PACK_REQUEST);
198 }
199 if let Some(protocol) = protocol {
200 request = request.header("git-protocol", protocol);
201 }
202 if !request_body.is_empty() {
203 request = request.body(request_body);
204 }
205 let upstream = match request.send().await {
206 Ok(response) => response,
207 Err(_) => return error(StatusCode::BAD_GATEWAY),
208 };
209 if upstream.status() != reqwest::StatusCode::OK {
210 return error(StatusCode::BAD_GATEWAY);
211 }
212 let upstream_content_type = upstream
213 .headers()
214 .get(header::CONTENT_TYPE)
215 .and_then(|value| value.to_str().ok())
216 .and_then(|value| value.split(';').next())
217 .map(str::trim);
218 if upstream_content_type != Some(expected_content_type) {
219 return error(StatusCode::BAD_GATEWAY);
220 }
221 if upstream
222 .content_length()
223 .is_some_and(|length| length > MAX_RESPONSE_BYTES)
224 {
225 return error(StatusCode::BAD_GATEWAY);
226 }
227
228 let upstream_body = upstream.bytes_stream();
229 let body_stream = stream::try_unfold(
230 (upstream_body, 0_u64, permit),
231 |(mut source, sent, permit): (_, u64, SemaphorePermit<'static>)| async move {
232 match source.next().await {
233 Some(Ok(chunk)) => {
234 let next = sent.saturating_add(chunk.len() as u64);
235 if next > MAX_RESPONSE_BYTES {
236 return Err(std::io::Error::other(
237 "Git canary response exceeds byte cap",
238 ));
239 }
240 Ok(Some((chunk, (source, next, permit))))
241 }
242 Some(Err(_)) => Err(std::io::Error::other("Git canary backend stream failed")),
243 None => Ok(None),
244 }
245 },
246 );
247 Response::builder()
248 .status(StatusCode::OK)
249 .header(header::CONTENT_TYPE, expected_content_type)
250 .header(header::CACHE_CONTROL, "no-store")
251 .header("x-content-type-options", "nosniff")
252 .body(Body::from_stream(body_stream))
253 .unwrap_or_else(|_| error(StatusCode::BAD_GATEWAY))
254}
255
256#[cfg(test)]
257mod tests {
258 use super::*;
259 use axum::{
260 body::to_bytes,
261 extract::{OriginalUri, State},
262 http::Request,
263 routing::{any, get},
264 };
265 use std::sync::{
266 atomic::{AtomicUsize, Ordering},
267 Arc,
268 };
269 use tokio::net::TcpListener;
270 use tower::ServiceExt;
271
272 static TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
273
274 #[derive(Clone)]
275 struct BackendProbe {
276 count: Arc<AtomicUsize>,
277 }
278
279 async fn backend(
280 State(probe): State<BackendProbe>,
281 OriginalUri(uri): OriginalUri,
282 headers: HeaderMap,
283 body: Body,
284 ) -> Response {
285 probe.count.fetch_add(1, Ordering::SeqCst);
286 let content_type = if uri.path().ends_with("info/refs") {
287 UPLOAD_PACK_ADVERTISEMENT
288 } else {
289 UPLOAD_PACK_RESULT
290 };
291 let bytes = to_bytes(body, MAX_REQUEST_BYTES).await.unwrap_or_default();
292 let response = if uri.path().ends_with("info/refs") {
293 format!(
294 "ad:{}:{}:{}:{}",
295 uri.query().unwrap_or_default(),
296 headers
297 .get("git-protocol")
298 .and_then(|h| h.to_str().ok())
299 .unwrap_or("none"),
300 headers.contains_key(header::COOKIE),
301 headers.contains_key(header::AUTHORIZATION)
302 )
303 .into_bytes()
304 } else {
305 [b"pack:".as_slice(), bytes.as_ref()].concat()
306 };
307 ([(header::CONTENT_TYPE, content_type)], response).into_response()
308 }
309
310 async fn start_backend() -> (u16, Arc<AtomicUsize>, tokio::task::JoinHandle<()>) {
311 let count = Arc::new(AtomicUsize::new(0));
312 let listener = TcpListener::bind("127.0.0.1:0")
313 .await
314 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
315 let port = listener
316 .local_addr()
317 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"))
318 .port();
319 let app = Router::new()
320 .route("/git/canary.git/info/refs", get(backend))
321 .route("/git/canary.git/git-upload-pack", any(backend))
322 .with_state(BackendProbe {
323 count: Arc::clone(&count),
324 });
325 let task = tokio::spawn(async move {
326 let _ = axum::serve(listener, app).await;
327 });
328 (port, count, task)
329 }
330
331 #[tokio::test]
332 async fn public_routes_are_fixed_and_forward_only_upload_pack() {
333 let _guard = TEST_LOCK.lock().await;
334 let (port, count, task) = start_backend().await;
335 let app: Router<()> = routes(port);
336
337 let response = app
338 .clone()
339 .oneshot(
340 Request::builder()
341 .uri("/git/canary.git/info/refs?service=git-upload-pack")
342 .header("git-protocol", "version=2")
343 .header(header::COOKIE, "must-not-forward")
344 .header(header::AUTHORIZATION, "Bearer must-not-forward")
345 .body(Body::empty())
346 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
347 )
348 .await
349 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
350 assert_eq!(response.status(), StatusCode::OK);
351 let advertisement = to_bytes(response.into_body(), 4096)
352 .await
353 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
354 assert_eq!(
355 advertisement.as_ref(),
356 b"ad:service=git-upload-pack:version=2:false:false"
357 );
358
359 let response = app
360 .clone()
361 .oneshot(
362 Request::builder()
363 .method(Method::POST)
364 .uri(UPLOAD_PACK_PATH)
365 .header(header::CONTENT_TYPE, UPLOAD_PACK_REQUEST)
366 .header("git-protocol", "version=1")
367 .body(Body::from(
368 "want 0123456789012345678901234567890123456789\n",
369 ))
370 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
371 )
372 .await
373 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
374 assert_eq!(response.status(), StatusCode::OK);
375 assert!(to_bytes(response.into_body(), 4096)
376 .await
377 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"))
378 .starts_with(b"pack:want "));
379
380 for request in [
381 Request::builder()
382 .uri("/git/other.git/info/refs?service=git-upload-pack")
383 .body(Body::empty())
384 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
385 Request::builder()
386 .uri("/git/canary.git/info/refs?service=git-receive-pack")
387 .body(Body::empty())
388 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
389 Request::builder()
390 .uri("/git/canary.git/info/refs?service=git-upload-pack&extra=1")
391 .body(Body::empty())
392 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
393 Request::builder()
394 .method(Method::HEAD)
395 .uri("/git/canary.git/info/refs?service=git-upload-pack")
396 .body(Body::empty())
397 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
398 Request::builder()
399 .method(Method::POST)
400 .uri("/git/canary.git/git-receive-pack")
401 .body(Body::empty())
402 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
403 Request::builder()
404 .method(Method::POST)
405 .uri(UPLOAD_PACK_PATH)
406 .header(
407 header::CONTENT_TYPE,
408 "application/x-git-receive-pack-request",
409 )
410 .body(Body::from("write"))
411 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
412 Request::builder()
413 .method(Method::POST)
414 .uri(UPLOAD_PACK_PATH)
415 .header(header::CONTENT_TYPE, UPLOAD_PACK_REQUEST)
416 .header("git-protocol", "version=3")
417 .body(Body::from("want x"))
418 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
419 ] {
420 let response = app
421 .clone()
422 .oneshot(request)
423 .await
424 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
425 assert_ne!(response.status(), StatusCode::OK);
426 }
427 assert_eq!(
428 count.load(Ordering::SeqCst),
429 2,
430 "denied requests must not reach the loopback backend"
431 );
432 task.abort();
433 }
434
435 #[tokio::test]
436 async fn wrong_backend_media_type_and_redirect_are_not_forwarded() {
437 let _guard = TEST_LOCK.lock().await;
438 async fn wrong_backend() -> Response {
439 Response::builder()
440 .status(StatusCode::FOUND)
441 .header(header::LOCATION, "https://attacker.example/collect")
442 .header(header::CONTENT_TYPE, UPLOAD_PACK_ADVERTISEMENT)
443 .body(Body::from("redirect"))
444 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"))
445 }
446 let listener = TcpListener::bind("127.0.0.1:0")
447 .await
448 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
449 let port = listener
450 .local_addr()
451 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"))
452 .port();
453 let app = Router::new().route("/git/canary.git/info/refs", get(wrong_backend));
454 let task = tokio::spawn(async move {
455 let _ = axum::serve(listener, app).await;
456 });
457 let app: Router<()> = routes(port);
458 let response = app
459 .oneshot(
460 Request::builder()
461 .uri("/git/canary.git/info/refs?service=git-upload-pack")
462 .body(Body::empty())
463 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
464 )
465 .await
466 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
467 assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
468 assert!(response.headers().get(header::LOCATION).is_none());
469 task.abort();
470 }
471
472 #[tokio::test]
473 async fn oversized_or_malformed_upload_requests_are_rejected_before_proxy() {
474 let _guard = TEST_LOCK.lock().await;
475 let (port, count, task) = start_backend().await;
476 let app: Router<()> = routes(port);
477 let response = app
478 .clone()
479 .oneshot(
480 Request::builder()
481 .method(Method::POST)
482 .uri(UPLOAD_PACK_PATH)
483 .header(header::CONTENT_TYPE, UPLOAD_PACK_REQUEST)
484 .body(Body::from(vec![b'x'; MAX_REQUEST_BYTES + 1]))
485 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
486 )
487 .await
488 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
489 assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);
490
491 let response = app
492 .oneshot(
493 Request::builder()
494 .method(Method::POST)
495 .uri(UPLOAD_PACK_PATH)
496 .header(header::CONTENT_TYPE, UPLOAD_PACK_REQUEST)
497 .body(Body::empty())
498 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}")),
499 )
500 .await
501 .unwrap_or_else(|error| panic!("test fixture failed: {error:?}"));
502 assert_eq!(response.status(), StatusCode::BAD_REQUEST);
503 assert_eq!(count.load(Ordering::SeqCst), 0);
504 task.abort();
505 }
506}