Skip to main content

hyprstream_core/services/oauth/
public_git.rs

1//! Fixed-path, read-only public Git canary proxy.
2//!
3//! The OAuth process owns the public TLS listener. A separately managed
4//! loopback-only sidecar runs `git-http-backend` against exactly the canary
5//! repository on the retained host volume. This module intentionally exposes
6//! only the two upload-pack smart-HTTP endpoints and never accepts a repository
7//! path from the request.
8
9use 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
40/// Build the public router for the configured loopback backend. Generic state
41/// keeps this router mergeable with the OAuth router while letting these route
42/// tests run without constructing the full OAuth state graph.
43pub 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}