diff options
| author | tv <tv@krebsco.de> | 2026-11-19 20:06:05 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-19 21:26:49 +0100 |
| commit | fc6c7101cdb42666c1f79df4206029c7cf7e61c6 (patch) | |
| tree | b9a2f088aedcafa762d552cada23eba134f9e849 /src/api | |
| parent | d93f574d14a2e52a1d7dfd1e256f70c6eb9644ef (diff) | |
federated nodes: users who read the federation alone (--store-readers)
On a federated node, every user its htpasswd or proxy lets in may do
everything: put events, have it drop what it took, vote through it with
its party's key, make fork roots, read the document. An application or
someone watching needn't act for the node.
`--store-readers USER,...` names users who read the federation and do
nothing else (`api::access::federated`, before the registry's checks):
GET and HEAD of the events API (/events and below), checking a fork
(POST /events/fork), and keeping a session (whoami, refresh, logout);
anything else is 403, saying so. Its other users are its operators, as
all were: a node setting nothing changes nothing.
Diffstat (limited to 'src/api')
| -rw-r--r-- | src/api/access.rs | 78 |
1 files changed, 78 insertions, 0 deletions
diff --git a/src/api/access.rs b/src/api/access.rs index 9157e1d..47e24ba 100644 --- a/src/api/access.rs +++ b/src/api/access.rs @@ -340,6 +340,10 @@ pub(crate) async fn authorize( else { return error_response(StatusCode::UNAUTHORIZED, "not authenticated", None); }; + #[cfg(feature = "federation")] + if let Some(refused) = federated(&state, &request, &user) { + return refused; + } let access = { let replica = state.doc.read().await; if !registry::exists(&replica.doc) { @@ -389,6 +393,54 @@ pub(crate) async fn authorize( next.run(request).await } +/// On a node holding a federated store, what its users who aren't its operators may do: a +/// user of `--store-readers` reads the federation (`federation_work`), and nothing else. +/// Its other users are its operators, who may do everything. The answer refusing the +/// request, where it is refused. +#[cfg(feature = "federation")] +fn federated(state: &AppState, request: &Request<Body>, user: &str) -> Option<Response> { + if !state.store_readers.contains(user) { + return None; + } + if state.holding.with(|_| ()).is_none() { + return Some(error_response( + StatusCode::FORBIDDEN, + format!("{user} reads a federated store here alone, and this node holds none"), + None, + )); + } + if federation_work(request.method(), request.uri().path(), false) { + return None; + } + debug!(user = %user, method = %request.method(), path = %request.uri().path(), "Refused a reader's request that doesn't read the federation"); + Some(error_response( + StatusCode::FORBIDDEN, + format!( + "{user} reads the federation here, and does nothing else (--store-readers; \ + docs/guides/federation/running-a-node.md, Its API)" + ), + None, + )) +} + +/// Whether a request is federation work: reading the events API (`GET` and `HEAD` of +/// `/events` and below), checking a fork (`POST /events/fork`), and keeping a session +/// (`GET /auth/whoami`, `POST /auth/refresh`, `POST /auth/logout`); with `puts`, putting +/// an event (`POST /events`) too. Nothing of the document (`/store`, `/stream`), the +/// node (`/peers`, `/admin/…`), nor what a node's operator does to its store +/// (`/admin/events/…`). +#[cfg(feature = "federation")] +fn federation_work(method: &Method, path: &str, puts: bool) -> bool { + let reads = matches!(*method, Method::GET | Method::HEAD); + let posts = *method == Method::POST; + match path { + "/auth/whoami" => reads, + "/auth/refresh" | "/auth/logout" | "/events/fork" => posts, + "/events" => reads || (puts && posts), + _ => reads && path.starts_with("/events/"), + } +} + #[cfg(test)] mod tests { use super::*; @@ -402,6 +454,32 @@ mod tests { .collect() } + /// Federation work is reading the events API, checking a fork and keeping a session; + /// putting events where it puts; nothing of the document, the node, or what an + /// operator does to the store. + #[cfg(feature = "federation")] + #[test] + fn federation_work_is_the_events_api() { + let work = |method: Method, path: &str, puts: bool| federation_work(&method, path, puts); + assert!(work(Method::GET, "/events", false)); + assert!(work(Method::GET, "/events/counts", false)); + assert!(work(Method::HEAD, "/events/0c7e", false)); + assert!(work(Method::POST, "/events/fork", false)); + assert!(work(Method::POST, "/auth/refresh", false)); + assert!(work(Method::GET, "/auth/whoami", false)); + assert!(!work(Method::POST, "/events", false)); + assert!(work(Method::POST, "/events", true)); + assert!(!work(Method::POST, "/admin/events/drop", true)); + assert!(!work(Method::POST, "/admin/events/vote", true)); + assert!(!work(Method::GET, "/admin/events/fork", true)); + assert!(!work(Method::GET, "/store", true)); + assert!(!work(Method::GET, "/store/home/tv", true)); + assert!(!work(Method::GET, "/stream", true)); + assert!(!work(Method::GET, "/peers", true)); + assert!(!work(Method::GET, "/eventsx", true)); + assert!(!work(Method::PUT, "/events/0c7e", true)); + } + /// A token's limit narrows what an endpoint takes, not only what the store's handlers /// read: the dashboard's hand-over token (the member list, read) of an operator may /// look, and nothing else. |
