Skip to content

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

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

mod client_ip;
pub mod envelope;
mod quota;
pub mod reject;

use crate::config::{FcmConfig, ProviderEnvironment, RelayConfig};
use crate::metrics::{Metrics, RelayLeg, RelayResult};
use crate::server::{Sidecar, serve};
use crate::tokens::{TokenCache, TokenError};
use crate::unix_seconds;
use crate::vendor::{self, ApnsRequest, DeadToken, Refusal, VendorOutcome};
use axum::Router;
use axum::body::Body;
use axum::extract::{ConnectInfo, Path, State};
use axum::http::{HeaderMap, HeaderValue, StatusCode, header};
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use base64::prelude::*;
use envelope::Urgency;
use fluxer_svc::shutdown::wait_for_shutdown;
use quota::Quota;
use rand::Rng as _;
use reject::{Reason, Rejection};
use sha2::{Digest as _, Sha256};
use std::net::SocketAddr;
use std::sync::{Arc, LazyLock};
use std::time::{Duration, Instant};
use tracing::{info, warn};

pub const APNS_ROUTE: &str = "/relay/v1/apns/{app_id}/{environment}/{device_token}";
pub const APNS_VOIP_ROUTE: &str = "/relay/v1/apns-voip/{app_id}/{environment}/{device_token}";
pub const FCM_ROUTE: &str = "/relay/v1/fcm/{app_id}/{device_token}";

const AES128GCM: &str = "aes128gcm";
const TTL_HEADER: &str = "ttl";
const URGENCY_HEADER: &str = "urgency";
const JSON_CONTENT_TYPE: &str = "application/json";
const DIGEST_BYTES: usize = 8;
const LOG_SALT_BYTES: usize = 16;

static LOG_SALT: LazyLock<[u8; LOG_SALT_BYTES]> = LazyLock::new(|| {
    let mut salt = [0u8; LOG_SALT_BYTES];
    rand::rng().fill_bytes(&mut salt);
    salt
});
const MIN_APNS_DEVICE_TOKEN_LEN: usize = 64;
const MAX_APNS_DEVICE_TOKEN_LEN: usize = 256;
const MAX_FCM_DEVICE_TOKEN_LEN: usize = 512;
const MAX_TTL_SECONDS: i64 = 86_400;
const BODY_READ_TIMEOUT: Duration = Duration::from_secs(15);

pub struct AppState {
    pub(crate) cfg: RelayConfig,
    pub(crate) metrics: Arc<Metrics>,
    pub(crate) sidecar: Arc<Sidecar>,
    quota: Quota,
    http: reqwest::Client,
    apns_http: reqwest::Client,
    tokens: TokenCache,
}

impl AppState {
    pub(crate) fn try_new(cfg: RelayConfig) -> anyhow::Result<Self> {
        let metrics = Arc::new(Metrics::new());
        Ok(Self {
            sidecar: Arc::new(Sidecar::new(Arc::clone(&metrics))),
            quota: Quota::new(
                cfg.max_concurrent,
                &cfg.device_token_bucket,
                cfg.source_bucket.as_ref(),
            ),
            http: vendor::http_client()?,
            apns_http: vendor::apns_http_client()?,
            tokens: TokenCache::new(),
            metrics,
            cfg,
        })
    }
}

pub async fn run(cfg: RelayConfig) -> anyhow::Result<()> {
    let state = Arc::new(AppState::try_new(cfg)?);
    let addr = state.cfg.bind_addr;
    let serving = serve(addr, router(Arc::clone(&state))).await?;
    state.sidecar.set_serving(true);
    info!(
        %addr,
        apns = state.cfg.apns.is_some(),
        fcm = state.cfg.fcm.is_some(),
        max_body_bytes = state.cfg.max_body_bytes,
        source_rate_limit = source_rate_limit_owner(&state.cfg),
        trust_client_ip_header = state.cfg.trust_client_ip_header,
        "push relay listening"
    );

    wait_for_shutdown().await;
    state.sidecar.set_serving(false);
    serving.stop().await;
    Ok(())
}

fn source_rate_limit_owner(cfg: &RelayConfig) -> &'static str {
    if cfg.source_bucket.is_some() {
        "relay"
    } else {
        "edge"
    }
}

pub fn router(state: Arc<AppState>) -> Router {
    let sidecar = Arc::clone(&state.sidecar);
    Router::new()
        .route(APNS_ROUTE, post(apns_route))
        .route(APNS_VOIP_ROUTE, post(apns_voip_route))
        .route(FCM_ROUTE, post(fcm_route))
        .fallback(unmatched_route)
        .with_state(state)
        .merge(sidecar.router())
}

async fn unmatched_route(State(state): State<Arc<AppState>>) -> Response {
    let rejection = Rejection::new(Reason::BadRequest);
    state.metrics.record_relay_rejected(rejection.reason);
    respond(rejection.reason.status(), Some(rejection))
}

async fn apns_route(
    State(state): State<Arc<AppState>>,
    ConnectInfo(peer): ConnectInfo<SocketAddr>,
    Path(path): Path<(String, String, String)>,
    headers: HeaderMap,
    body: Body,
) -> Response {
    apns_leg(&state, RelayLeg::Apns, peer, path, headers, body).await
}

async fn apns_voip_route(
    State(state): State<Arc<AppState>>,
    ConnectInfo(peer): ConnectInfo<SocketAddr>,
    Path(path): Path<(String, String, String)>,
    headers: HeaderMap,
    body: Body,
) -> Response {
    apns_leg(&state, RelayLeg::ApnsVoip, peer, path, headers, body).await
}

async fn apns_leg(
    state: &AppState,
    leg: RelayLeg,
    peer: SocketAddr,
    (app_id, environment, device_token): (String, String, String),
    headers: HeaderMap,
    body: Body,
) -> Response {
    relay(
        state,
        Incoming {
            leg,
            app_id,
            environment: ProviderEnvironment::from_label(&environment),
            device_token,
            peer,
        },
        headers,
        body,
    )
    .await
}

async fn fcm_route(
    State(state): State<Arc<AppState>>,
    ConnectInfo(peer): ConnectInfo<SocketAddr>,
    Path((app_id, device_token)): Path<(String, String)>,
    headers: HeaderMap,
    body: Body,
) -> Response {
    relay(
        &state,
        Incoming {
            leg: RelayLeg::Fcm,
            app_id,
            environment: None,
            device_token,
            peer,
        },
        headers,
        body,
    )
    .await
}

struct Incoming {
    leg: RelayLeg,
    app_id: String,
    environment: Option<ProviderEnvironment>,
    device_token: String,
    peer: SocketAddr,
}

struct Delivery {
    urgency: Urgency,
    ttl_seconds: i64,
}

impl Delivery {
    fn parse(urgency: Option<&str>, ttl_seconds: Option<&str>) -> Result<Self, Rejection> {
        let bad_request = Rejection::new(Reason::BadRequest);
        Ok(Self {
            urgency: Urgency::from_header(urgency).ok_or(bad_request)?,
            ttl_seconds: ttl_seconds
                .ok_or(bad_request)?
                .parse::<i64>()
                .map_err(|_| bad_request)?
                .clamp(0, MAX_TTL_SECONDS),
        })
    }
}

enum Target<'a> {
    Apns {
        environment: ProviderEnvironment,
        topic: &'a str,
    },
    Fcm(FcmTarget<'a>),
}

pub struct FcmTarget<'a> {
    cfg: &'a FcmConfig,
    project_id: &'a str,
    device_token: &'a str,
}

impl<'a> FcmTarget<'a> {
    pub fn resolve(
        cfg: Option<&'a FcmConfig>,
        app_id: &str,
        device_token: &'a str,
    ) -> Option<Self> {
        let cfg = cfg?;
        Some(Self {
            project_id: cfg.listed_project_id(app_id)?,
            cfg,
            device_token,
        })
    }
}

pub async fn forward_fcm(
    http: &reqwest::Client,
    tokens: &TokenCache,
    metrics: &Metrics,
    target: &FcmTarget<'_>,
    record: &[u8],
    urgency: &str,
    ttl_seconds: &str,
) -> u16 {
    let verdict = async {
        if !device_token_is_shaped(RelayLeg::Fcm, target.device_token) {
            return Err(Rejection::new(Reason::DeviceTokenInvalid));
        }
        let delivery = Delivery::parse(Some(urgency), Some(ttl_seconds))?;
        let payload = envelope::encode_payload(record);
        send_fcm(http, tokens, metrics, target, &delivery, &payload).await
    }
    .await;
    verdict
        .err()
        .map_or(StatusCode::OK, |rejection| rejection.reason.status())
        .as_u16()
}

async fn relay(state: &AppState, incoming: Incoming, headers: HeaderMap, body: Body) -> Response {
    let started = Instant::now();
    let mut bytes = 0;
    let outcome = forward(state, &incoming, &headers, body, &mut bytes).await;

    let rejection = outcome.err();
    let status = rejection.map_or(StatusCode::OK, |rejection| rejection.reason.status());
    state.metrics.record_relay_served(
        incoming.leg,
        if status.is_success() {
            RelayResult::Accepted
        } else if status.is_server_error() {
            RelayResult::Failed
        } else {
            RelayResult::Rejected
        },
    );
    if let Some(rejection) = rejection {
        state.metrics.record_relay_rejected(rejection.reason);
    }

    info!(
        leg = incoming.leg.label(),
        app_id = incoming.app_id,
        environment = incoming.environment.map_or("-", ProviderEnvironment::label),
        device_token = digest(&incoming.device_token),
        status = status.as_u16(),
        reason = rejection.map_or("accepted", |rejection| rejection.reason.label()),
        bytes,
        duration_ms = started.elapsed().as_millis(),
        "relay request"
    );
    respond(status, rejection)
}

async fn forward(
    state: &AppState,
    incoming: &Incoming,
    headers: &HeaderMap,
    body: Body,
    bytes: &mut usize,
) -> Result<(), Rejection> {
    let target = resolve(state, incoming)?;
    if !device_token_is_shaped(incoming.leg, &incoming.device_token) {
        return Err(Rejection::new(Reason::DeviceTokenInvalid));
    }
    if !is_aes128gcm(headers) {
        return Err(Rejection::new(Reason::BadRequest));
    }
    let delivery = Delivery::parse(header(headers, URGENCY_HEADER), header(headers, TTL_HEADER))?;
    let lowered;
    let quota_token: &str = match incoming.leg {
        RelayLeg::Apns | RelayLeg::ApnsVoip => {
            lowered = incoming.device_token.to_ascii_lowercase();
            &lowered
        }
        RelayLeg::Fcm => &incoming.device_token,
    };
    state.quota.take(
        &state.metrics,
        quota_token,
        match incoming.leg {
            RelayLeg::ApnsVoip => Urgency::Alert,
            _ => delivery.urgency,
        },
        client_ip::for_rate_limit(&state.cfg, incoming.peer, headers),
        Instant::now(),
    )?;

    let body = tokio::time::timeout(
        BODY_READ_TIMEOUT,
        axum::body::to_bytes(body, state.cfg.max_body_bytes),
    )
    .await
    .map_err(|_| Rejection::new(Reason::BadRequest))?
    .map_err(|_| Rejection::new(Reason::PayloadTooLarge))?;
    *bytes = body.len();
    if body.is_empty() {
        return Err(Rejection::new(Reason::BadRequest));
    }
    let _permit = state.quota.admit()?;
    let payload = envelope::encode_payload(&body);

    match target {
        Target::Apns { environment, topic } => {
            send_apns(state, incoming, &delivery, &payload, environment, topic).await
        }
        Target::Fcm(target) => {
            send_fcm(
                &state.http,
                &state.tokens,
                &state.metrics,
                &target,
                &delivery,
                &payload,
            )
            .await
        }
    }
}

fn resolve<'a>(state: &'a AppState, incoming: &'a Incoming) -> Result<Target<'a>, Rejection> {
    let unknown = Rejection::new(Reason::AppUnknown);
    match incoming.leg {
        RelayLeg::Apns | RelayLeg::ApnsVoip => {
            let cfg = state.cfg.apns.as_ref().ok_or(unknown)?;
            let environment = incoming.environment.ok_or(unknown)?;
            let topic = match incoming.leg {
                RelayLeg::ApnsVoip => cfg.voip_topic_for(&incoming.app_id, environment),
                _ => cfg.topic_for(&incoming.app_id, environment),
            };
            Ok(Target::Apns {
                environment,
                topic: topic.ok_or(unknown)?,
            })
        }
        RelayLeg::Fcm => FcmTarget::resolve(
            state.cfg.fcm.as_ref(),
            &incoming.app_id,
            &incoming.device_token,
        )
        .map(Target::Fcm)
        .ok_or(unknown),
    }
}

async fn send_apns(
    state: &AppState,
    incoming: &Incoming,
    delivery: &Delivery,
    payload: &str,
    environment: ProviderEnvironment,
    topic: &str,
) -> Result<(), Rejection> {
    let cfg = state
        .cfg
        .apns
        .as_ref()
        .ok_or(Rejection::new(Reason::AppUnknown))?;
    let (headers, body) = match incoming.leg {
        RelayLeg::ApnsVoip => (
            envelope::apns_voip_headers(),
            envelope::apns_voip_body(payload)?,
        ),
        _ => (
            envelope::apns_headers(delivery.urgency, unix_seconds(), delivery.ttl_seconds),
            envelope::apns_body(payload, delivery.urgency)?,
        ),
    };
    let request = ApnsRequest {
        environment,
        topic,
        device_token: &incoming.device_token,
        headers: &headers,
        body,
    };
    let outcome = vendor::send_apns(
        &state.apns_http,
        &state.tokens,
        &state.metrics,
        cfg,
        request,
    )
    .await;
    finish(&state.metrics, incoming.leg, outcome)
}

async fn send_fcm(
    http: &reqwest::Client,
    tokens: &TokenCache,
    metrics: &Metrics,
    target: &FcmTarget<'_>,
    delivery: &Delivery,
    payload: &str,
) -> Result<(), Rejection> {
    let body = envelope::fcm_body(
        target.device_token,
        payload,
        delivery.urgency,
        delivery.ttl_seconds,
    )?;
    let outcome =
        vendor::send_fcm(http, tokens, metrics, target.cfg, target.project_id, body).await;
    finish(metrics, RelayLeg::Fcm, outcome)
}

fn finish(
    metrics: &Metrics,
    leg: RelayLeg,
    outcome: Result<VendorOutcome, TokenError>,
) -> Result<(), Rejection> {
    let outcome = outcome.map_err(|error| {
        warn!(%error, leg = leg.label(), "the relay could not mint its own vendor credential");
        Rejection::new(Reason::Internal)
    })?;
    let (result, verdict) = match outcome {
        VendorOutcome::Accepted => (RelayResult::Accepted, Ok(())),
        VendorOutcome::Unreachable(_) => (
            RelayResult::Failed,
            Err(Rejection::new(Reason::ProviderUnavailable)),
        ),
        VendorOutcome::Refused(refusal) => (
            if refusal.is_transient() {
                RelayResult::Failed
            } else {
                RelayResult::Rejected
            },
            Err(Rejection::new(refusal_reason(&refusal))),
        ),
    };
    metrics.record_relay_vendor_request(leg, result);
    verdict
}

fn refusal_reason(refusal: &Refusal) -> Reason {
    match refusal.dead_token {
        Some(DeadToken::Gone(_)) => Reason::DeviceTokenGone,
        Some(DeadToken::Invalid(_)) => Reason::DeviceTokenInvalid,
        None if refusal.is_transient() => Reason::ProviderUnavailable,
        None => Reason::BadRequest,
    }
}

fn device_token_is_shaped(leg: RelayLeg, device_token: &str) -> bool {
    match leg {
        RelayLeg::Apns | RelayLeg::ApnsVoip => {
            (MIN_APNS_DEVICE_TOKEN_LEN..=MAX_APNS_DEVICE_TOKEN_LEN).contains(&device_token.len())
                && device_token.len().is_multiple_of(2)
                && device_token.bytes().all(|byte| byte.is_ascii_hexdigit())
        }
        RelayLeg::Fcm => {
            !device_token.is_empty()
                && device_token.len() <= MAX_FCM_DEVICE_TOKEN_LEN
                && device_token.bytes().all(is_fcm_token_byte)
        }
    }
}

fn is_fcm_token_byte(byte: u8) -> bool {
    byte.is_ascii_alphanumeric() || matches!(byte, b':' | b'-' | b'_' | b'.')
}

fn is_aes128gcm(headers: &HeaderMap) -> bool {
    header(headers, header::CONTENT_ENCODING.as_str())
        .is_some_and(|value| value.eq_ignore_ascii_case(AES128GCM))
}

fn header<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> {
    headers
        .get(name)
        .and_then(|value| value.to_str().ok())
        .map(str::trim)
        .filter(|value| !value.is_empty())
}

fn respond(status: StatusCode, rejection: Option<Rejection>) -> Response {
    let mut response = match rejection {
        None => status.into_response(),
        Some(rejection) => (
            status,
            [(header::CONTENT_TYPE, JSON_CONTENT_TYPE)],
            rejection.body(),
        )
            .into_response(),
    };
    if let Some(seconds) = rejection.and_then(|rejection| rejection.retry_after)
        && let Ok(value) = HeaderValue::from_str(&seconds.to_string())
    {
        response.headers_mut().insert(header::RETRY_AFTER, value);
    }
    response
}

fn digest(value: &str) -> String {
    if value.is_empty() {
        return "-".to_owned();
    }
    let mut hasher = Sha256::new();
    hasher.update(*LOG_SALT);
    hasher.update(value.as_bytes());
    BASE64_URL_SAFE_NO_PAD.encode(&hasher.finalize()[..DIGEST_BYTES])
}

#[cfg(test)]
mod tests {
    use super::*;

    fn hex(len: usize) -> String {
        "a".repeat(len)
    }

    #[test]
    fn apns_rejects_tokens_that_are_not_even_length_hex() {
        for token in [hex(62), hex(63), hex(161), hex(258), "z".repeat(64)] {
            assert!(
                !device_token_is_shaped(RelayLeg::Apns, &token),
                "{token} must be rejected"
            );
        }
    }

    #[test]
    fn the_log_digest_is_not_a_bare_hash_of_the_token() {
        const TOKEN: &str = "3dbc5a5ef1a1c1666afc26f466e1b3ebaaf4c66d92dddeb0fd1b69c49641d4cd";
        let unsalted =
            BASE64_URL_SAFE_NO_PAD.encode(&Sha256::digest(TOKEN.as_bytes())[..DIGEST_BYTES]);
        assert_ne!(digest(TOKEN), unsalted);
        assert_eq!(digest(TOKEN), digest(TOKEN));
        assert_eq!(digest(""), "-");
    }
}