233 lines
7.9 KiB
Rust
233 lines
7.9 KiB
Rust
//! Meow v2 relay server.
|
||||
|
|
//!
|
|||
|
|
//! Routes:
|
|||
|
|
//! * `GET /v2/card` – self-signed `ServerCard` (protobuf);
|
|||
|
|
//! * `POST /v2/rpc` – `SealedRequest` → `SealedResponse`;
|
|||
|
|
//! * `GET /healthz`.
|
|||
|
|
//!
|
|||
|
|
//! The server never sees message contents nor who talks to whom: deposits are
|
|||
|
|
//! anonymous, and pulls are authorised by a signature of the mailbox key.
|
|||
|
|
|
|||
|
|
#![forbid(unsafe_code)]
|
|||
|
|
#![cfg_attr(not(test), warn(clippy::unwrap_used, clippy::expect_used))]
|
|||
|
|
|
|||
|
|
pub mod config;
|
|||
|
|
pub mod store;
|
|||
|
|
|
|||
|
|
use std::collections::HashSet;
|
|||
|
|
use std::sync::Arc;
|
|||
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|||
|
|
|
|||
|
|
use axum::body::Bytes;
|
|||
|
|
use axum::extract::{DefaultBodyLimit, State};
|
|||
|
|
use axum::http::{header, StatusCode};
|
|||
|
|
use axum::response::IntoResponse;
|
|||
|
|
use axum::routing::{get, post};
|
|||
|
|
use axum::Router;
|
|||
|
|
use meow_core::rpc;
|
|||
|
|
use meow_core::server::ServerKeys;
|
|||
|
|
use meow_proto::v2::{self, error::Code, request::Body as Req, response::Body as Resp};
|
|||
|
|
use meow_proto::Message;
|
|||
|
|
use tokio::sync::broadcast;
|
|||
|
|
|
|||
|
|
use crate::store::{Mailbox, ServerStore, StoreError};
|
|||
|
|
|
|||
|
|
/// Operational limits.
|
|||
|
|
#[derive(Clone, Debug)]
|
|||
|
|
pub struct Limits {
|
|||
|
|
pub max_body_bytes: usize,
|
|||
|
|
pub max_deposits: usize,
|
|||
|
|
pub max_payload_bytes: usize,
|
|||
|
|
pub max_mailboxes_per_pull: usize,
|
|||
|
|
pub max_wait: Duration,
|
|||
|
|
pub max_invitation_ttl: Duration,
|
|||
|
|
pub replay_ttl: Duration,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
impl Default for Limits {
|
|||
|
|
fn default() -> Self {
|
|||
|
|
Self {
|
|||
|
|
max_body_bytes: 16 * 1024 * 1024,
|
|||
|
|
max_deposits: 128,
|
|||
|
|
max_payload_bytes: 8 * 1024 * 1024,
|
|||
|
|
max_mailboxes_per_pull: 512,
|
|||
|
|
max_wait: Duration::from_secs(120),
|
|||
|
|
max_invitation_ttl: Duration::from_secs(7 * 86_400),
|
|||
|
|
replay_ttl: Duration::from_secs(2 * rpc::AUTH_WINDOW_SECS),
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Shared state of a running server.
|
|||
|
|
pub struct AppState {
|
|||
|
|
pub keys: ServerKeys,
|
|||
|
|
pub card: Vec<u8>,
|
|||
|
|
pub store: Arc<dyn ServerStore>,
|
|||
|
|
pub notify: broadcast::Sender<Mailbox>,
|
|||
|
|
pub limits: Limits,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pub fn now() -> u64 {
|
|||
|
|
SystemTime::now()
|
|||
|
|
.duration_since(UNIX_EPOCH)
|
|||
|
|
.map(|d| d.as_secs())
|
|||
|
|
.unwrap_or(0)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Build the HTTP router.
|
|||
|
|
pub fn router(state: Arc<AppState>) -> Router {
|
|||
|
|
let limit = state.limits.max_body_bytes;
|
|||
|
|
Router::new()
|
|||
|
|
.route("/v2/card", get(card))
|
|||
|
|
.route("/v2/rpc", post(rpc_handler))
|
|||
|
|
.route("/healthz", get(|| async { "ok" }))
|
|||
|
|
.layer(DefaultBodyLimit::max(limit))
|
|||
|
|
.with_state(state)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
async fn card(State(st): State<Arc<AppState>>) -> impl IntoResponse {
|
|||
|
|
([(header::CONTENT_TYPE, "application/x-protobuf")], st.card.clone())
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
async fn rpc_handler(State(st): State<Arc<AppState>>, body: Bytes) -> impl IntoResponse {
|
|||
|
|
let (req, key) = match rpc::open_request(&st.keys, &body) {
|
|||
|
|
Ok(x) => x,
|
|||
|
|
Err(_) => return (StatusCode::BAD_REQUEST, Vec::new()),
|
|||
|
|
};
|
|||
|
|
let rid = req.request_id.clone();
|
|||
|
|
let resp = match handle(&st, req).await {
|
|||
|
|
Ok(body) => v2::Response {
|
|||
|
|
request_id: rid,
|
|||
|
|
body: Some(body),
|
|||
|
|
},
|
|||
|
|
Err((code, msg)) => {
|
|||
|
|
tracing::debug!(?code, msg, "request rejected");
|
|||
|
|
rpc::error_response(rid, code, msg)
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
(StatusCode::OK, rpc::seal_response(&key, &resp))
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
type HResult = Result<Resp, (Code, &'static str)>;
|
|||
|
|
|
|||
|
|
fn store_err(e: StoreError) -> (Code, &'static str) {
|
|||
|
|
match e {
|
|||
|
|
StoreError::NotFound => (Code::NotFound, "not found"),
|
|||
|
|
StoreError::Unauthorized => (Code::Unauthorized, "bad password"),
|
|||
|
|
StoreError::Locked => (Code::Unauthorized, "invitation destroyed after too many attempts"),
|
|||
|
|
StoreError::Backend(e) => {
|
|||
|
|
tracing::error!("store error: {e}");
|
|||
|
|
(Code::Internal, "storage error")
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
async fn handle(st: &AppState, req: v2::Request) -> HResult {
|
|||
|
|
let now = now();
|
|||
|
|
if req.request_id.len() != 16 {
|
|||
|
|
return Err((Code::BadRequest, "bad request id"));
|
|||
|
|
}
|
|||
|
|
if req.timestamp.abs_diff(now) > rpc::AUTH_WINDOW_SECS {
|
|||
|
|
return Err((Code::Expired, "request timestamp out of window"));
|
|||
|
|
}
|
|||
|
|
if !st
|
|||
|
|
.store
|
|||
|
|
.mark_request(&req.request_id, st.limits.replay_ttl)
|
|||
|
|
.await
|
|||
|
|
.map_err(store_err)?
|
|||
|
|
{
|
|||
|
|
return Err((Code::Unauthorized, "replayed request"));
|
|||
|
|
}
|
|||
|
|
match req.body.ok_or((Code::BadRequest, "empty request"))? {
|
|||
|
|
Req::Ping(_) => Ok(Resp::Pong(v2::Pong { server_time: now })),
|
|||
|
|
Req::Post(p) => post_messages(st, p, now).await,
|
|||
|
|
Req::Pull(p) => pull(st, &req.request_id, p, now).await,
|
|||
|
|
Req::InvPublish(p) => {
|
|||
|
|
if p.payload.len() > 64 * 1024 {
|
|||
|
|
return Err((Code::TooLarge, "invitation too large"));
|
|||
|
|
}
|
|||
|
|
let ttl = Duration::from_secs(p.ttl_seconds.max(60) as u64).min(st.limits.max_invitation_ttl);
|
|||
|
|
let len = (p.shortcode_len as usize).clamp(6, 64);
|
|||
|
|
let code = st
|
|||
|
|
.store
|
|||
|
|
.put_invitation(p.payload, &p.password, ttl, len)
|
|||
|
|
.await
|
|||
|
|
.map_err(store_err)?;
|
|||
|
|
Ok(Resp::InvPublished(v2::InvitationPublished {
|
|||
|
|
shortcode: code,
|
|||
|
|
expires_at: now + ttl.as_secs(),
|
|||
|
|
}))
|
|||
|
|
}
|
|||
|
|
Req::InvFetch(f) => {
|
|||
|
|
let payload = st
|
|||
|
|
.store
|
|||
|
|
.get_invitation(&f.shortcode, &f.password)
|
|||
|
|
.await
|
|||
|
|
.map_err(store_err)?;
|
|||
|
|
Ok(Resp::InvFetched(v2::InvitationFetched { payload }))
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
async fn post_messages(st: &AppState, p: v2::Post, now: u64) -> HResult {
|
|||
|
|
if p.deposits.is_empty() || p.deposits.len() > st.limits.max_deposits {
|
|||
|
|
return Err((Code::BadRequest, "bad number of deposits"));
|
|||
|
|
}
|
|||
|
|
let mut accepted = 0u32;
|
|||
|
|
for d in p.deposits {
|
|||
|
|
let mb: Mailbox = d
|
|||
|
|
.mailbox
|
|||
|
|
.as_slice()
|
|||
|
|
.try_into()
|
|||
|
|
.map_err(|_| (Code::BadRequest, "bad mailbox"))?;
|
|||
|
|
if d.payload.len() > st.limits.max_payload_bytes {
|
|||
|
|
return Err((Code::TooLarge, "payload too large"));
|
|||
|
|
}
|
|||
|
|
st.store.post(mb, d.payload, now).await.map_err(store_err)?;
|
|||
|
|
accepted += 1;
|
|||
|
|
}
|
|||
|
|
Ok(Resp::PostAck(v2::PostAck { accepted }))
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
async fn pull(st: &AppState, request_id: &[u8], p: v2::Pull, now: u64) -> HResult {
|
|||
|
|
if p.auths.is_empty() || p.auths.len() > st.limits.max_mailboxes_per_pull {
|
|||
|
|
return Err((Code::BadRequest, "bad number of mailboxes"));
|
|||
|
|
}
|
|||
|
|
let sign = st.keys.sign.public();
|
|||
|
|
let mut mailboxes = Vec::with_capacity(p.auths.len());
|
|||
|
|
for a in &p.auths {
|
|||
|
|
let mb = rpc::verify_mailbox_auth(&sign, request_id, a, now)
|
|||
|
|
.map_err(|_| (Code::Unauthorized, "bad mailbox auth"))?;
|
|||
|
|
mailboxes.push(mb.0);
|
|||
|
|
}
|
|||
|
|
// Subscribe before draining, so a deposit landing in between is not missed.
|
|||
|
|
let mut rx = st.notify.subscribe();
|
|||
|
|
let mut messages = st.store.drain(&mailboxes).await.map_err(store_err)?;
|
|||
|
|
let wait = Duration::from_secs(p.wait_seconds as u64).min(st.limits.max_wait);
|
|||
|
|
if messages.is_empty() && !wait.is_zero() {
|
|||
|
|
let wanted: HashSet<Mailbox> = mailboxes.iter().copied().collect();
|
|||
|
|
let _ = tokio::time::timeout(wait, async {
|
|||
|
|
loop {
|
|||
|
|
match rx.recv().await {
|
|||
|
|
Ok(mb) if wanted.contains(&mb) => break,
|
|||
|
|
Ok(_) => continue,
|
|||
|
|
// Lagged: we may have missed ours, check anyway. Closed: stop.
|
|||
|
|
Err(_) => break,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
})
|
|||
|
|
.await;
|
|||
|
|
messages = st.store.drain(&mailboxes).await.map_err(store_err)?;
|
|||
|
|
}
|
|||
|
|
Ok(Resp::PullResult(v2::PullResult { messages }))
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Serve on an already bound listener until the future is dropped.
|
|||
|
|
pub async fn serve(listener: tokio::net::TcpListener, state: Arc<AppState>) -> std::io::Result<()> {
|
|||
|
|
axum::serve(listener, router(state)).await
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// Encode the card for `GET /v2/card`.
|
|||
|
|
pub fn encode_card(keys: &ServerKeys, url: &str, name: &str, description: &str) -> Vec<u8> {
|
|||
|
|
keys.card(url, name, description, now()).encode_to_vec()
|
|||
|
|
}
|