Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
12.3 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::{config::DeploymentMode, http_headers};
use axum::{
    body::Body,
    extract::State,
    http::{HeaderValue, Request},
    response::Response,
};
use bytes::Bytes;
use http_body::{Body as HttpBody, Frame, SizeHint};
use std::{
    pin::Pin,
    sync::{
        Arc, OnceLock,
        atomic::{AtomicU64, Ordering},
    },
    task::{Context, Poll},
};
use tokio::sync::Notify;

#[derive(Clone, Default)]
pub(in crate::server) struct HttpRequestDrain {
    inner: Arc<HttpRequestDrainInner>,
}

#[derive(Default)]
struct HttpRequestDrainInner {
    active_requests: AtomicU64,
    drained: Notify,
}

struct ActiveHttpRequest {
    drain: HttpRequestDrain,
}

struct DrainedBody {
    body: Pin<Box<Body>>,
    _active: ActiveHttpRequest,
}

impl HttpRequestDrain {
    pub(in crate::server) fn new() -> Self {
        Self::default()
    }

    pub(in crate::server) fn active_requests(&self) -> u64 {
        self.inner.active_requests.load(Ordering::Relaxed)
    }

    pub(in crate::server) async fn wait_for_requests_drained(&self) {
        loop {
            let drained = self.inner.drained.notified();
            tokio::pin!(drained);
            drained.as_mut().enable();
            if self.inner.active_requests.load(Ordering::Acquire) == 0 {
                return;
            }
            drained.await;
        }
    }

    fn begin_request(&self) -> ActiveHttpRequest {
        self.inner
            .active_requests
            .try_update(Ordering::AcqRel, Ordering::Acquire, |active| {
                active.checked_add(1)
            })
            .expect("http active request count must not overflow");
        ActiveHttpRequest {
            drain: self.clone(),
        }
    }
}

impl Drop for ActiveHttpRequest {
    fn drop(&mut self) {
        let previous = self
            .drain
            .inner
            .active_requests
            .fetch_sub(1, Ordering::AcqRel);
        assert!(previous > 0, "http active request count must stay positive");
        if previous == 1 {
            self.drain.inner.drained.notify_waiters();
        }
    }
}

impl HttpBody for DrainedBody {
    type Data = Bytes;
    type Error = axum::Error;

    fn poll_frame(
        mut self: Pin<&mut Self>,
        context: &mut Context<'_>,
    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
        self.body.as_mut().poll_frame(context)
    }

    fn is_end_stream(&self) -> bool {
        self.body.is_end_stream()
    }

    fn size_hint(&self) -> SizeHint {
        self.body.size_hint()
    }
}

pub(in crate::server) async fn track_active_request(
    State(drain): State<HttpRequestDrain>,
    request: Request<Body>,
    next: axum::middleware::Next,
) -> Response {
    let active = drain.begin_request();
    next.run(request).await.map(|body| {
        Body::new(DrainedBody {
            body: Box::pin(body),
            _active: active,
        })
    })
}

pub(in crate::server) fn build_version() -> &'static str {
    static BUILD_VERSION: OnceLock<String> = OnceLock::new();
    BUILD_VERSION
        .get_or_init(|| {
            fluxer_common::config::env_value("BUILD_VERSION").unwrap_or_else(|| "dev".to_owned())
        })
        .as_str()
}

pub(in crate::server) async fn add_version_header(
    request: Request<Body>,
    next: axum::middleware::Next,
) -> Response {
    let mut response = next.run(request).await;
    if let Ok(value) = HeaderValue::from_str(build_version()) {
        response.headers_mut().insert("x-fluxer-version", value);
    }
    response
}

pub(in crate::server) async fn add_security_header_middleware(
    State(mode): State<DeploymentMode>,
    request: Request<Body>,
    next: axum::middleware::Next,
) -> Response {
    let mut response = next.run(request).await;
    let status = response.status();
    let headers = response.headers_mut();
    http_headers::add_security_headers(headers);
    if mode == DeploymentMode::Static {
        headers.remove("X-Robots-Tag");
    } else {
        http_headers::neutralize_script_content_type(status, headers);
    }
    response
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        server::{routes::dispatch::catch_all, state::AppState},
        storage::tests::{FakeObject, fake_s3},
    };
    use axum::{
        Router,
        http::{HeaderMap, HeaderName, Method, StatusCode, header},
        routing::get,
    };

    const INERT: &str = "text/plain; charset=utf-8";

    const BROWSER_PARSED_JAVASCRIPT: [&str; 7] = [
        "text/javascript x",
        "text/javascript\tx",
        "text/javascript(x)",
        "TEXT/JAVASCRIPT (x)",
        "video/mp4, text/javascript x",
        " text/javascript ;charset=x",
        "image/png,text/javascript(x)",
    ];

    async fn headers_for(mode: DeploymentMode, content_type: Option<&'static str>) -> HeaderMap {
        headers_with_status(mode, StatusCode::OK, content_type).await
    }

    async fn headers_with_status(
        mode: DeploymentMode,
        status: StatusCode,
        content_type: Option<&'static str>,
    ) -> HeaderMap {
        let router = Router::new()
            .route(
                "/probe",
                get(move || async move {
                    let mut response = Response::new(Body::empty());
                    *response.status_mut() = status;
                    if let Some(content_type) = content_type {
                        response
                            .headers_mut()
                            .insert(header::CONTENT_TYPE, HeaderValue::from_static(content_type));
                    }
                    response
                }),
            )
            .layer(axum::middleware::from_fn_with_state(
                mode,
                add_security_header_middleware,
            ));
        let response = tower::ServiceExt::oneshot(
            router,
            Request::builder()
                .uri("/probe")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
        response.headers().clone()
    }

    fn header_text(headers: &HeaderMap, name: HeaderName) -> Option<&str> {
        headers.get(name).map(|value| value.to_str().unwrap())
    }

    #[tokio::test]
    async fn every_mode_that_serves_stored_bytes_neutralizes_javascript() {
        for mode in [
            DeploymentMode::Mp,
            DeploymentMode::Upload,
            DeploymentMode::Relay,
        ] {
            for content_type in ["text/javascript", "application/javascript; charset=utf-8"]
                .into_iter()
                .chain(BROWSER_PARSED_JAVASCRIPT)
            {
                let headers = headers_for(mode, Some(content_type)).await;
                assert_eq!(
                    Some(INERT),
                    header_text(&headers, header::CONTENT_TYPE),
                    "{mode:?} {content_type:?}"
                );
            }
        }
    }

    fn transport_stream_object(content_type: &str) -> FakeObject {
        let mut body = vec![0_u8; 376];
        body[0] = 0x47;
        body[188] = 0x47;
        FakeObject {
            body,
            head_length: Some(376),
            content_type: Some(content_type.to_owned()),
            ..FakeObject::default()
        }
    }

    fn security_layered_router(app: &Arc<AppState>, mode: DeploymentMode) -> Router {
        Router::new()
            .fallback(axum::routing::any(catch_all))
            .layer(axum::middleware::from_fn_with_state(
                mode,
                add_security_header_middleware,
            ))
            .with_state(Arc::clone(app))
    }

    async fn send(
        router: &Router,
        method: Method,
        uri: &str,
        range: Option<&'static str>,
    ) -> Response {
        let mut request = Request::builder().method(method).uri(uri);
        if let Some(range) = range {
            request = request.header(header::RANGE, range);
        }
        tower::ServiceExt::oneshot(router.clone(), request.body(Body::empty()).unwrap())
            .await
            .unwrap()
    }

    fn assert_attachment_named(headers: &HeaderMap, filename: &str) {
        let disposition =
            header_text(headers, header::CONTENT_DISPOSITION).expect("content disposition");
        assert!(
            disposition.starts_with("attachment") && disposition.contains(filename),
            "{disposition}"
        );
    }

    #[tokio::test]
    async fn a_stored_javascript_attachment_is_plain_text_through_the_security_layer() {
        let fake = fake_s3().await;
        let tmp = tempfile::tempdir().unwrap();
        let mut cfg = fake.config(tmp.path());
        cfg.mode = DeploymentMode::Mp;
        let app = Arc::new(AppState::for_tests(cfg));
        let bucket = app.cfg.storage.bucket_cdn.clone();
        let segment = transport_stream_object("text/javascript");
        fake.put_object(
            &format!("{bucket}/attachments/1/2/segment.js"),
            segment.clone(),
        );
        fake.put_object(
            &format!("{bucket}/attachments/1/2/seg.ts"),
            transport_stream_object("video/mp2t"),
        );
        fake.put_object(
            &format!("{bucket}/themes/abc123.css"),
            FakeObject {
                body: b"body{color:#fff}".to_vec(),
                content_type: Some("text/css".to_owned()),
                ..FakeObject::default()
            },
        );
        let mp = security_layered_router(&app, DeploymentMode::Mp);

        let response = send(&mp, Method::GET, "/attachments/1/2/segment.js", None).await;
        assert_eq!(StatusCode::OK, response.status());
        assert_eq!(
            Some(INERT),
            header_text(response.headers(), header::CONTENT_TYPE)
        );
        assert_eq!(
            Some("nosniff"),
            header_text(response.headers(), header::X_CONTENT_TYPE_OPTIONS)
        );
        assert_attachment_named(response.headers(), "segment.js");
        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
            .await
            .unwrap();
        assert_eq!(segment.body.as_slice(), &body[..]);

        let head = send(&mp, Method::HEAD, "/attachments/1/2/segment.js", None).await;
        assert_eq!(StatusCode::OK, head.status());
        assert_eq!(
            Some(INERT),
            header_text(head.headers(), header::CONTENT_TYPE)
        );

        let ranged = send(
            &mp,
            Method::GET,
            "/attachments/1/2/segment.js",
            Some("bytes=0-0"),
        )
        .await;
        assert_eq!(StatusCode::PARTIAL_CONTENT, ranged.status());
        assert_eq!(
            Some(INERT),
            header_text(ranged.headers(), header::CONTENT_TYPE)
        );

        let unsatisfiable = send(
            &mp,
            Method::HEAD,
            "/attachments/1/2/segment.js",
            Some("bytes=999-"),
        )
        .await;
        assert_eq!(StatusCode::RANGE_NOT_SATISFIABLE, unsatisfiable.status());
        assert_eq!(None, unsatisfiable.headers().get(header::CONTENT_TYPE));
        assert_eq!(
            Some("nosniff"),
            header_text(unsatisfiable.headers(), header::X_CONTENT_TYPE_OPTIONS)
        );

        let download = send(
            &mp,
            Method::GET,
            "/attachments/1/2/segment.js?download=1",
            None,
        )
        .await;
        assert_eq!(StatusCode::OK, download.status());
        assert_eq!(
            Some(INERT),
            header_text(download.headers(), header::CONTENT_TYPE)
        );
        assert_attachment_named(download.headers(), "segment.js");

        let upload = security_layered_router(&app, DeploymentMode::Upload);
        let neutralized = send(&upload, Method::GET, "/attachments/1/2/segment.js", None).await;
        assert_eq!(StatusCode::OK, neutralized.status());
        assert_eq!(
            Some(INERT),
            header_text(neutralized.headers(), header::CONTENT_TYPE)
        );

        let transport_stream = send(&mp, Method::GET, "/attachments/1/2/seg.ts", None).await;
        assert_eq!(StatusCode::OK, transport_stream.status());
        assert_eq!(
            Some("video/mp2t"),
            header_text(transport_stream.headers(), header::CONTENT_TYPE)
        );

        let theme = send(&mp, Method::GET, "/themes/abc123.css", None).await;
        assert_eq!(StatusCode::OK, theme.status());
        assert_eq!(
            Some("text/css; charset=utf-8"),
            header_text(theme.headers(), header::CONTENT_TYPE)
        );
    }
}