//! Who a space's policy authorizes (`spec/SPACES-POLICIES.md`, "Who is //! authorized"), as the other parts of spaces ask it: whether a space is //! live (`Lifecycle`), whether its authority issues a credential and //! whether the app may have it (`Perimeter`), and whether it tracks an //! account's writes (`Service::authorize_write`). Under a managedspace each //! decision for an account other than the authority asks the managing app //! afresh, with `com.atproto.managedspace.checkAccess`; one it fails to //! decide is `Undecided`. use crate::space_authority::{Policy, Space}; use crate::{Service, XrpcError, err, outbound, read}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use pds_space::SpaceRef; use serde_json::{Value as Json, json}; use std::time::{Duration, SystemTime, UNIX_EPOCH}; /// Whether a space is live: from `createSpace` or `importSpaceMeta` until /// `deleteSpace`; deleted after that, until created or imported again; and /// otherwise, as is every space whose authority is no account here, unknown. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum SpaceState { Unknown, Live, Deleted, } pub(crate) trait Lifecycle { fn space_state(&self, space: &SpaceRef) -> SpaceState; } /// A managing app's failure to decide (`spec/SPACES-POLICIES.md`, "Asking a /// managing app: checkAccess", "No answer"): neither a refusal nor an /// authorization. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct Undecided; impl Undecided { /// What the method that asked answers: `502 UpstreamFailure`. pub(crate) fn answer(self) -> Result { err( 502, "UpstreamFailure", "The space's managing app did not decide", ) } } pub(crate) trait Perimeter { /// The read column of "Who is authorized", for a live space: yes, no, /// or a managing app's failure to decide. With no `repo` (no delegation /// token), yes for a memberspace with `publicRead`, as the managing app /// answers for a managedspace, and no otherwise. `client_id`, the /// attested client, is passed to a managing app and decides nothing /// else here. fn authorize_read( &self, space: &SpaceRef, repo: Option<&str>, client_id: Option<&str>, ) -> impl Future> + Send; /// The `allowedApps` gate, asked once `authorize_read` is yes: false /// only for a memberspace with `allowedApps` and no `client_id`, or one /// not listed. fn authorize_app(&self, space: &SpaceRef, client_id: Option<&str>) -> bool; } impl Lifecycle for Service { fn space_state(&self, space: &SpaceRef) -> SpaceState { match self.account(&space.authority) { Some(a) => read(&a.store).authority.state(&space.uri()), None => SpaceState::Unknown, } } } impl Perimeter for Service { async fn authorize_read( &self, space: &SpaceRef, repo: Option<&str>, client_id: Option<&str>, ) -> Result { self.authorize(space, repo, Access::Read, client_id).await } fn authorize_app(&self, space: &SpaceRef, client_id: Option<&str>) -> bool { let Some(a) = self.account(&space.authority) else { return true; }; let st = read(&a.store); match st.authority.live(&space.uri()).map(|s| &s.policy) { Some(Policy::Member { allowed_apps: Some(apps), .. }) => client_id.is_some_and(|c| apps.iter().any(|a| a == c)), _ => true, } } } impl Service { /// The write column of "Who is authorized", for a live space: whether /// the authority tracks `repo`'s writes, or a managing app's failure to /// decide. A managing app is asked without a client. pub(crate) async fn authorize_write( &self, space: &SpaceRef, repo: &str, ) -> Result { self.authorize(space, Some(repo), Access::Write, None).await } async fn authorize( &self, space: &SpaceRef, repo: Option<&str>, access: Access, client_id: Option<&str>, ) -> Result { // The decision is made on the space as it is now, with no lock held after. let decision = { let Some(a) = self.account(&space.authority) else { return Ok(false); }; let st = read(&a.store); match st.authority.live(&space.uri()) { Some(s) => decide(&space.authority, s, repo, access), None => return Ok(false), } }; match decision { Decision::Granted => Ok(true), Decision::Refused => Ok(false), Decision::Ask(app) => { let client_id = client_id.filter(|_| access == Access::Read); let answer = ask(self, space, &app, repo, client_id) .await .ok_or(Undecided)?; Ok(match access { Access::Read => answer.read, Access::Write => answer.write, }) } } } } /// What an account is authorized to do. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum Access { Read, Write, } /// A policy's answer for an account, before any managing app is asked. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) enum Decision { Granted, Refused, /// Ask this managing app (`managingApp` as stored). Ask(String), } /// What the space's policy and member list say of `repo` (None: no /// delegation token) for `access`. Its authority is authorized under every /// policy. A member's write is as its entry says; an account not listed /// writes only under `publicWrite`. A managedspace asks its app of every /// other, with no `repo` too. pub(crate) fn decide( authority: &str, space: &Space, repo: Option<&str>, access: Access, ) -> Decision { let yes = |b: bool| { if b { Decision::Granted } else { Decision::Refused } }; if repo == Some(authority) { return Decision::Granted; } match &space.policy { Policy::Personal => Decision::Refused, Policy::Member { public_read, public_write, .. } => { let member = repo.and_then(|u| space.members.get(u)); match access { Access::Read => yes(*public_read || member.is_some_and(|m| m.read)), Access::Write => yes(member.map_or(*public_write, |m| m.write)), } } Policy::Managed { managing_app, .. } => Decision::Ask(managing_app.clone()), } } /// The method a managing app is asked with. pub(crate) const CHECK_ACCESS: &str = "com.atproto.managedspace.checkAccess"; /// How long a managing app's answer is waited for, and a slot to ask it in; /// and how many may be asked at once, across every space. #[cfg(not(test))] const WAIT: Duration = crate::outbound::WAIT; #[cfg(test)] const WAIT: Duration = Duration::from_millis(1500); #[cfg(not(test))] const IN_FLIGHT: usize = 64; #[cfg(test)] const IN_FLIGHT: usize = 4; /// The managing apps being asked: at most `IN_FLIGHT` at once; an ask that /// gets no slot within its time is undecided. pub(crate) struct Asking { slots: tokio::sync::Semaphore, } impl Default for Asking { fn default() -> Asking { Asking { slots: tokio::sync::Semaphore::new(IN_FLIGHT), } } } /// A managing app's answer: both its decisions. #[derive(Clone, Copy, Debug, PartialEq, Eq)] struct Answer { read: bool, write: bool, } /// Ask `app` about `repo` (None: a read with no delegation token) in /// `space` (`spec/SPACES-POLICIES.md`, "Asking a managing app: /// checkAccess"). Its answer when it answers `2xx` with `Content-Type` /// `application/json` and a JSON object whose `read` and `write` are both /// booleans; None, undecided, for anything else: a DID that does not /// resolve, no such service or no endpoint (one with a user name or /// password is asked nothing), a request the guard does not send, one that /// fails or takes more than `WAIT`, a redirect, another status or type, or /// a body that is not such JSON or is longer than `JSON_DOC_MAX`. async fn ask( svc: &Service, space: &SpaceRef, app: &str, repo: Option<&str>, client_id: Option<&str>, ) -> Option { let _slot = tokio::time::timeout(WAIT, svc.space_authority.asking.slots.acquire()) .await .ok()? .ok()?; let origin = outbound::origin(&endpoint(svc, app).await?)?; let url = origin.join(&format!("/xrpc/{CHECK_ACCESS}")).ok()?; let jwt = service_auth(svc, &space.authority, app, CHECK_ACCESS)?; let mut query = vec![("space", space.uri())]; if let Some(r) = repo { query.push(("repo", r.to_string())); } if let Some(c) = client_id { query.push(("clientId", c.to_string())); } let request = svc .outbound .client() .get(url) .query(&query) .bearer_auth(jwt); let got = svc .outbound .fetch_limited( crate::ops::Target::Service, request, outbound::JSON_DOC_MAX, WAIT, ) .await .ok()?; let json = got .headers .get("content-type") .and_then(|v| v.to_str().ok()) .is_some_and(|t| { t.split(';') .next() .unwrap_or_default() .trim() .eq_ignore_ascii_case("application/json") }); if !(200..300).contains(&got.status) || !json { return None; } let body: Json = serde_json::from_slice(&got.body).ok()?; match (body.get("read"), body.get("write")) { (Some(Json::Bool(read)), Some(Json::Bool(write))) if body.is_object() => Some(Answer { read: *read, write: *write, }), _ => None, } } /// The `serviceEndpoint` of a service identifier, a DID and an optional /// `#fragment`, as a managing app's is resolved: its document's service of /// that `id` (`#` or the DID and `#`), or with none, its /// `#atproto_pds`. None if the DID's document cannot be read or names no /// such service; what it names may be no endpoint (`outbound::origin`). pub(crate) async fn endpoint(svc: &Service, ident: &str) -> Option { let did = ident.split_once('#').map_or(ident, |(did, _)| did); service_endpoint(&document(svc, did).await?, ident).cloned() } /// The `serviceEndpoint` a DID document names for a service identifier, a /// DID and an optional `#fragment`: of the service of that `id` /// (`#` or the DID and `#`), or with none, its /// `#atproto_pds`. pub(crate) fn service_endpoint<'a>(doc: &'a Json, ident: &str) -> Option<&'a Json> { let (did, fragment) = ident.split_once('#').unwrap_or((ident, "atproto_pds")); let (short, full) = (format!("#{fragment}"), format!("{did}#{fragment}")); let service = doc["service"] .as_array()? .iter() .find(|s| s["id"].as_str().is_some_and(|id| id == short || id == full))?; service.get("serviceEndpoint") } /// A DID's document (`spec/SPACES-CREDENTIALS.md`, "Issuers' keys"): a /// `did:plc`'s from the directory the server uses; a `did:web`'s from its /// host, through the guard (`Outbound::did_web`), answered `2xx`. None for /// one that cannot be read so, or for another method. pub(crate) async fn document(svc: &Service, did: &str) -> Option { if did.starts_with("did:plc:") { let url = format!("{}/{did}", svc.config.plc_url.trim_end_matches('/')); return match crate::plc::document(&svc.http, &url).await { Ok(doc) => doc, Err(why) => { crate::ops::failed_for( crate::ops::Level::Warn, "reading a DID document failed", did, why, ); None } }; } if !did.starts_with("did:web:") { return None; } let got = svc .outbound .did_web(did) .await .ok() .filter(|got| (200..300).contains(&got.status))?; serde_json::from_slice(&got.body).ok() } /// Service auth (`atproto/xrpc.md`) from an account here, `iss`, for method /// `lxm`: an ES256K JWT whose body is exactly `iss`, `aud`, `lxm`, `iat`, /// `exp` a minute on and a fresh `jti`, signed with `iss`'s `#atproto` key. pub(crate) fn service_auth(svc: &Service, iss: &str, aud: &str, lxm: &str) -> Option { let a = svc.account(iss)?; let iat = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() .as_secs(); let jti = hex::encode(rand::random::<[u8; 16]>()); let header = URL_SAFE_NO_PAD.encode(json!({ "typ": "JWT", "alg": "ES256K" }).to_string()); let body = URL_SAFE_NO_PAD.encode( json!({ "iss": iss, "aud": aud, "lxm": lxm, "iat": iat, "exp": iat + 60, "jti": jti }) .to_string(), ); let signed = format!("{header}.{body}"); let sig = read(&a.store).repo.sign(signed.as_bytes()); Some(format!("{signed}.{}", URL_SAFE_NO_PAD.encode(sig))) } #[cfg(test)] mod tests { use super::*; use crate::Shared; use crate::space_authority::{Access as Member, MANAGED, MEMBER, PERSONAL}; use crate::testing::*; use axum::Router; use axum::extract::{Path, Query, State}; use axum::http::{HeaderMap, StatusCode, header}; use axum::response::{IntoResponse, Response}; use axum::routing::get; use std::collections::{BTreeMap, HashMap}; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Mutex}; fn space(policy: Policy, members: &[(&str, bool, bool)]) -> Space { let members = members .iter() .map(|(d, read, write)| { ( d.to_string(), Member { read: *read, write: *write, }, ) }) .collect(); Space { policy, members, writers: BTreeMap::new(), } } fn member(public_read: bool, public_write: bool) -> Policy { Policy::Member { public_read, public_write, publish_policy: false, publish_members: false, allowed_apps: None, } } /// Each policy's read and write columns, the authority under each, and /// no account: under `publicWrite` a member's write is as its entry says. #[test] fn policy_decisions() { use Access::{Read, Write}; use Decision::{Granted, Refused}; let auth = "did:plc:authority"; let personal = space(Policy::Personal, &[("did:plc:m", true, true)]); for access in [Read, Write] { assert_eq!(decide(auth, &personal, Some(auth), access), Granted); assert_eq!(decide(auth, &personal, Some("did:plc:m"), access), Refused); assert_eq!(decide(auth, &personal, None, access), Refused); } let members = [ ("did:plc:r", true, false), ("did:plc:w", false, true), ("did:plc:none", false, false), ]; let closed = space(member(false, false), &members); let want = [ (Some(auth), Granted, Granted), (Some("did:plc:r"), Granted, Refused), (Some("did:plc:w"), Refused, Granted), (Some("did:plc:none"), Refused, Refused), (Some("did:plc:x"), Refused, Refused), (None, Refused, Refused), ]; for (repo, read, write) in want { assert_eq!( ( decide(auth, &closed, repo, Read), decide(auth, &closed, repo, Write) ), (read, write), "{repo:?}" ); } let open = space(member(true, true), &members); let want = [ (Some(auth), Granted), (Some("did:plc:x"), Granted), (Some("did:plc:w"), Granted), (Some("did:plc:r"), Refused), (Some("did:plc:none"), Refused), ]; for (repo, write) in want { assert_eq!( ( decide(auth, &open, repo, Read), decide(auth, &open, repo, Write) ), (Granted, write), "{repo:?}" ); } // No account: only publicRead authorizes a read. assert_eq!(decide(auth, &open, None, Read), Granted); let managed = space( Policy::Managed { managing_app: "did:plc:app#forum".into(), publish_policy: false, }, &[], ); for access in [Read, Write] { assert_eq!(decide(auth, &managed, Some(auth), access), Granted); for repo in [Some("did:plc:u"), None] { assert_eq!( decide(auth, &managed, repo, access), Decision::Ask("did:plc:app#forum".into()) ); } } } type Docs = Arc>>; /// A directory that takes any account's genesis and serves its document, /// and serves documents a test puts in it. async fn directory() -> (String, Docs) { async fn post( State(docs): State, Path(did): Path, body: axum::body::Bytes, ) -> StatusCode { let op: Json = serde_json::from_slice(&body).unwrap(); docs.lock() .unwrap() .insert(did.clone(), did_document(&did, &op)); StatusCode::OK } async fn doc(State(docs): State, Path(did): Path) -> Response { match docs.lock().unwrap().get(&did) { Some(d) => { ([(header::CONTENT_TYPE, "application/json")], d.to_string()).into_response() } None => StatusCode::NOT_FOUND.into_response(), } } let docs = Docs::default(); let app = Router::new() .route("/{did}", get(doc).post(post)) .with_state(docs.clone()); (serve(app).await, docs) } async fn serve(app: Router) -> String { let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)) .await .unwrap(); let url = format!("http://{}", listener.local_addr().unwrap()); tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); url } /// What a managing app answers about a repo: its status, body, /// `Content-Type` (none if empty), and delay in ms. type Reply = (u16, String, String, u64); /// A managing app: it answers each repo (`""` for a call with none) /// from its table, and keeps each call's parameters and /// `Authorization`, and the most calls it had at once. #[derive(Default)] struct App { answers: Mutex>, calls: Mutex, String)>>, now: AtomicUsize, most: AtomicUsize, } async fn app() -> (String, Arc) { async fn check( State(app): State>, Query(q): Query>, headers: HeaderMap, ) -> Response { let auth = headers .get(header::AUTHORIZATION) .map(|v| v.to_str().unwrap().to_string()) .unwrap_or_default(); let (status, body, ctype, delay) = app .answers .lock() .unwrap() .get(q.get("repo").map_or("", String::as_str)) .cloned() .unwrap_or((404, String::new(), String::new(), 0)); app.calls.lock().unwrap().push((q, auth)); // Counted out when the call ends, answered or dropped as its asker gave up. struct InFlight(Arc); impl Drop for InFlight { fn drop(&mut self) { self.0.now.fetch_sub(1, Ordering::SeqCst); } } let now = app.now.fetch_add(1, Ordering::SeqCst) + 1; app.most.fetch_max(now, Ordering::SeqCst); let _in_flight = InFlight(app.clone()); tokio::time::sleep(std::time::Duration::from_millis(delay)).await; let mut res = Response::new(axum::body::Body::from(body.clone())); *res.status_mut() = StatusCode::from_u16(status).unwrap(); if !ctype.is_empty() { res.headers_mut() .insert(header::CONTENT_TYPE, ctype.parse().unwrap()); } // A redirect goes where its body says. if (300..400).contains(&status) { res.headers_mut() .insert(header::LOCATION, body.parse().unwrap()); } res } let state = Arc::new(App::default()); let router = Router::new() .route(&format!("/xrpc/{CHECK_ACCESS}"), get(check)) .with_state(state.clone()); (serve(router).await, state) } impl App { /// Answer `repo` with JSON. fn answer(&self, repo: &str, status: u16, body: &str, delay: u64) { self.answer_as(repo, status, body, "application/json", delay); } fn answer_as(&self, repo: &str, status: u16, body: &str, ctype: &str, delay: u64) { self.answers .lock() .unwrap() .insert(repo.into(), (status, body.into(), ctype.into(), delay)); } fn calls(&self) -> Vec<(BTreeMap, String)> { std::mem::take(&mut self.calls.lock().unwrap()) } } async fn create_space(s: &Shared, token: &str, skey: &str, policy: Json) -> SpaceRef { let body = json!({ "spaceType": "com.example.forum", "skey": skey, "policy": policy }); SpaceRef::parse( call(s, "com.atproto.space.createSpace", Some(token), body) .await .unwrap()["space"] .as_str() .unwrap(), ) .unwrap() } const YES: Result = Ok(true); const NO: Result = Ok(false); /// A memberspace and a personalspace, as `Perimeter` and `authorize_write` /// answer them, each as the space is when asked; spaces not live are refused. #[tokio::test] async fn member_and_personal_spaces() { let plc = plc().await; let dir = scratch("authz-member"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, _) = create(&s, "bob").await; let ms = create_space(&s, &ta, "m", json!({ "$type": MEMBER })).await; let put = |did: &str, read: bool, write: bool| json!({ "space": ms.uri(), "members": [{ "did": did, "read": read, "write": write }] }); let both = |repo: &str| { let (s, ms, repo) = (s.clone(), ms.clone(), repo.to_string()); async move { ( s.authorize_read(&ms, Some(&repo), None).await, s.authorize_write(&ms, &repo).await, ) } }; assert_eq!(both(&alice).await, (YES, YES)); assert_eq!(both(&bob).await, (NO, NO)); call( &s, "com.atproto.memberspace.putMembers", Some(&ta), put(&bob, true, false), ) .await .unwrap(); assert_eq!(both(&bob).await, (YES, NO)); call( &s, "com.atproto.memberspace.putMembers", Some(&ta), put(&bob, false, true), ) .await .unwrap(); assert_eq!(both(&bob).await, (NO, YES)); assert_eq!(s.authorize_read(&ms, None, None).await, NO); // Every app, until allowedApps names some; then only those, the authority's too. assert!(s.authorize_app(&ms, None)); let update = |policy: Json| json!({ "space": ms.uri(), "policy": policy }); let policy = json!({ "$type": MEMBER, "publicRead": true, "allowedApps": ["https://app.example/client"] }); call( &s, "com.atproto.space.updateSpace", Some(&ta), update(policy), ) .await .unwrap(); assert_eq!(s.authorize_read(&ms, None, None).await, YES); assert_eq!( s.authorize_read(&ms, Some("did:plc:anyone"), None).await, YES ); assert!( !s.authorize_app(&ms, None) && !s.authorize_app(&ms, Some("https://other.example/client")) ); assert!(s.authorize_app(&ms, Some("https://app.example/client"))); call( &s, "com.atproto.space.updateSpace", Some(&ta), update(json!({ "$type": MEMBER, "allowedApps": [] })), ) .await .unwrap(); assert!(!s.authorize_app(&ms, Some("https://app.example/client"))); assert_eq!(s.authorize_read(&ms, Some(&alice), None).await, YES); assert_eq!(s.authorize_read(&ms, None, None).await, NO); // Under publicWrite, an account not listed writes; a member as its entry says. call( &s, "com.atproto.space.updateSpace", Some(&ta), update(json!({ "$type": MEMBER, "publicWrite": true })), ) .await .unwrap(); assert_eq!(s.authorize_write(&ms, "did:plc:anyone").await, YES); assert!(s.authorize_app(&ms, None)); assert_eq!(s.authorize_write(&ms, &bob).await, YES); call( &s, "com.atproto.memberspace.putMembers", Some(&ta), put(&bob, true, false), ) .await .unwrap(); assert_eq!(s.authorize_write(&ms, &bob).await, NO); call( &s, "com.atproto.memberspace.removeMembers", Some(&ta), json!({ "space": ms.uri(), "dids": [bob] }), ) .await .unwrap(); assert_eq!(s.authorize_write(&ms, &bob).await, YES); // A personalspace: the authority alone; every app. let ps = create_space(&s, &ta, "p", json!({ "$type": PERSONAL })).await; assert_eq!( ( s.authorize_read(&ps, Some(&alice), None).await, s.authorize_write(&ps, &alice).await ), (YES, YES) ); assert!(s.authorize_app(&ps, None)); assert_eq!( ( s.authorize_read(&ps, Some(&bob), None).await, s.authorize_write(&ps, &bob).await, s.authorize_read(&ps, None, None).await ), (NO, NO, NO) ); // Live, deleted, unknown. assert_eq!(s.space_state(&ps), SpaceState::Live); call( &s, "com.atproto.space.deleteSpace", Some(&ta), json!({ "space": ps.uri() }), ) .await .unwrap(); assert_eq!(s.space_state(&ps), SpaceState::Deleted); assert_eq!( ( s.authorize_read(&ps, Some(&alice), None).await, s.authorize_write(&ps, &alice).await ), (NO, NO) ); let elsewhere = SpaceRef::parse("at://did:plc:elsewhere/space/com.example.forum/m").unwrap(); let never = SpaceRef { skey: "never".into(), ..ms.clone() }; for sr in [&elsewhere, &never] { assert_eq!(s.space_state(sr), SpaceState::Unknown); assert_eq!( ( s.authorize_read(sr, Some(&alice), None).await, s.authorize_write(sr, &alice).await ), (NO, NO) ); } let _ = std::fs::remove_dir_all(&dir); } /// `checkAccess` as a managing app sees it: asked afresh for each /// decision, with exactly the parameters and service auth the spec /// gives; its `read` or `write` taken from a `2xx` JSON object with /// both booleans, and anything else undecided. #[tokio::test] async fn managing_apps_are_asked() { let (plc, docs) = directory().await; let (url, app) = app().await; let dir = scratch("authz-managed"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let key = *crate::read(&s.account(&alice).unwrap().store) .repo .verifying_key(); let app_did = "did:plc:managingappmanagingappaa"; docs.lock().unwrap().insert( app_did.into(), json!({ "id": app_did, "service": [ { "id": "#forum", "type": "ManagingApp", "serviceEndpoint": url }, { "id": format!("{app_did}#other"), "type": "ManagingApp", "serviceEndpoint": format!("{url}/") }, ] }), ); let managed = |app: &str| json!({ "$type": MANAGED, "managingApp": app }); let forum = create_space(&s, &ta, "forum", managed(&format!("{app_did}#forum"))).await; let (u, v) = ("did:plc:user", "did:web:user.example"); app.answer(u, 200, r#"{"read":true,"write":false}"#, 0); app.answer(v, 200, r#"{"read":false,"write":true}"#, 0); let client = "https://client.example/meta.json"; assert_eq!(s.authorize_read(&forum, Some(u), Some(client)).await, YES); let [(q, auth)] = &app.calls()[..] else { panic!("one call") }; let want = |repo: Option<&str>, client: Option<&str>| { let mut q = BTreeMap::from([("space".to_string(), forum.uri())]); if let Some(r) = repo { q.insert("repo".into(), r.into()); } if let Some(c) = client { q.insert("clientId".into(), c.into()); } q }; assert_eq!(q, &want(Some(u), Some(client))); // Its service auth: an ES256K JWT, exactly these claims, signed with the authority's key. let jwt = auth.strip_prefix("Bearer ").unwrap(); let parts: Vec<&str> = jwt.split('.').collect(); let part = |i: usize| -> Json { serde_json::from_slice(&URL_SAFE_NO_PAD.decode(parts[i]).unwrap()).unwrap() }; assert_eq!(part(0), json!({ "typ": "JWT", "alg": "ES256K" })); let claims = part(1); assert_eq!( claims.as_object().unwrap().keys().collect::>(), ["aud", "exp", "iat", "iss", "jti", "lxm"] ); assert_eq!( (&claims["iss"], &claims["aud"], &claims["lxm"]), ( &json!(alice), &json!(format!("{app_did}#forum")), &json!(CHECK_ACCESS) ) ); assert_eq!( claims["exp"].as_u64().unwrap(), claims["iat"].as_u64().unwrap() + 60 ); assert!(!claims["jti"].as_str().unwrap().is_empty()); use k256::ecdsa::signature::hazmat::PrehashVerifier; use sha2::Digest; let sig = k256::ecdsa::Signature::from_slice(&URL_SAFE_NO_PAD.decode(parts[2]).unwrap()).unwrap(); key.verify_prehash( &sha2::Sha256::digest(format!("{}.{}", parts[0], parts[1])), &sig, ) .unwrap(); // Each decision asks afresh, each with a fresh jti, and takes its own // field; a write, and a read with no attestation, carry no clientId. assert_eq!(s.authorize_read(&forum, Some(u), None).await, YES); assert_eq!(s.authorize_write(&forum, u).await, NO); let calls = app.calls(); assert_eq!( calls.iter().map(|c| c.0.clone()).collect::>(), [want(Some(u), None), want(Some(u), None)] ); assert_ne!(calls[0].1, calls[1].1); assert_eq!(s.authorize_read(&forum, Some(v), None).await, NO); assert_eq!(s.authorize_write(&forum, v).await, YES); // The authority asks nothing. app.calls(); assert_eq!(s.authorize_read(&forum, Some(&alice), None).await, YES); assert_eq!(s.authorize_write(&forum, &alice).await, YES); assert!(s.authorize_app(&forum, None)); assert_eq!(app.calls().len(), 0); // A read with no delegation token asks with no repo. app.answer("", 200, r#"{"read":true,"write":false}"#, 0); assert_eq!(s.authorize_read(&forum, None, Some(client)).await, YES); app.answer("", 200, r#"{"read":false,"write":true}"#, 0); assert_eq!(s.authorize_read(&forum, None, None).await, NO); assert_eq!( app.calls().into_iter().map(|c| c.0).collect::>(), [want(None, Some(client)), want(None, None)] ); // Taken: any 2xx, other fields, a JSON media type in any case, with parameters. for (i, (status, body, ctype)) in [ (201, r#"{"read":true,"write":false}"#, "application/json"), ( 200, r#"{"read":true,"write":false,"other":1}"#, "application/json", ), ( 200, r#"{"write":false,"read":true}"#, "application/json; charset=utf-8", ), (200, r#"{"read":true,"write":false}"#, "Application/JSON"), ] .into_iter() .enumerate() { let repo = format!("did:plc:taken{i}"); app.answer_as(&repo, status, body, ctype, 0); assert_eq!( s.authorize_read(&forum, Some(&repo), None).await, YES, "{status} {body} {ctype}" ); } assert_eq!(app.calls().len(), 4); // Anything else is undecided, for a read and a write alike. let json = "application/json"; for (i, (status, body, ctype, delay)) in [ (200, r#"{"read":"true","write":false}"#, json, 0), (200, r#"{"read":1,"write":true}"#, json, 0), (200, r#"{"read":null,"write":true}"#, json, 0), (200, r#"{"read":true}"#, json, 0), (200, r#"{"authorized":true}"#, json, 0), (200, r#"{}"#, json, 0), (200, "not json", json, 0), (200, "[true]", json, 0), (200, r#"{"read":true,"write":true}"#, "text/plain", 0), (200, r#"{"read":true,"write":true}"#, "", 0), (204, "", json, 0), (401, r#"{"read":true,"write":true}"#, json, 0), (500, r#"{"read":true,"write":true}"#, json, 0), (200, r#"{"read":true,"write":true}"#, json, 2500), ] .into_iter() .enumerate() { let repo = format!("did:plc:undecided{i}"); app.answer_as(&repo, status, body, ctype, delay); let what = format!("{status} {body} {ctype:?} after {delay}ms"); assert_eq!( s.authorize_read(&forum, Some(&repo), None).await, Err(Undecided), "{what}" ); if delay == 0 { assert_eq!( s.authorize_write(&forum, &repo).await, Err(Undecided), "{what}" ); } } assert_eq!(app.calls().len(), 27); // The service by its full id, and an endpoint with a trailing slash. let other = create_space(&s, &ta, "other", managed(&format!("{app_did}#other"))).await; assert_eq!(s.authorize_read(&other, Some(u), None).await, YES); assert_eq!(app.calls().len(), 1); // A fragment the document lacks, and a DID that does not resolve: // undecided, with no call. for (key, managing) in [ ("missing", format!("{app_did}#missing")), ("nobody", "did:plc:nobodynobodynobodynobody#forum".into()), ] { let sr = create_space(&s, &ta, key, managed(&managing)).await; assert_eq!( ( s.authorize_read(&sr, Some(u), None).await, s.authorize_write(&sr, u).await ), (Err(Undecided), Err(Undecided)), "{managing}" ); } assert_eq!(app.calls().len(), 0); // At most IN_FLIGHT asks at once; the rest wait for a slot. (The // app is still answering the ask that took too long: wait it out.) while app.now.load(Ordering::SeqCst) > 0 { tokio::time::sleep(std::time::Duration::from_millis(20)).await; } app.most.store(0, Ordering::SeqCst); app.answer(u, 200, r#"{"read":true,"write":true}"#, 100); let asks: Vec<_> = (0..3 * IN_FLIGHT) .map(|_| s.authorize_read(&forum, Some(u), None)) .collect(); assert!(futures_all(asks).await.into_iter().all(|ok| ok == YES)); assert_eq!(app.most.load(Ordering::SeqCst), IN_FLIGHT); let _ = std::fs::remove_dir_all(&dir); } /// Where a managing app is asked (`spec/SPACES-POLICIES.md`, "Asking a /// managing app: checkAccess"): at its endpoint's origin, with the /// parameters alone; nothing to an endpoint with a user name or /// password, or to what is no endpoint; a redirect not followed; an /// answer longer than `JSON_DOC_MAX` bytes: each undecided. #[tokio::test] async fn managing_apps_are_asked_at_their_origin() { let (plc, docs) = directory().await; let (url, app) = app().await; let dir = scratch("authz-origin"); let s = open(&dir, &plc); let (_, ta) = create(&s, "alice").await; let app_did = "did:plc:managingappmanagingappbb"; let host = url.strip_prefix("http://").unwrap(); let ends = [ ("path", json!(format!("{url}/base/more?x=1#f"))), ("query", json!(format!("{url}/base?"))), ("userpass", json!(format!("http://u:p@{host}"))), ("user", json!(format!("http://u@{host}"))), ("ftp", json!(format!("ftp://{host}"))), ("bare", json!(host)), ("object", json!({ "uri": url })), ]; let services: Vec = ends.iter().map(|(id, e)| json!({ "id": format!("#{id}"), "type": "ManagingApp", "serviceEndpoint": e })).collect(); docs.lock().unwrap().insert( app_did.into(), json!({ "id": app_did, "service": services }), ); let managed = |fragment: &str| json!({ "$type": MANAGED, "managingApp": format!("{app_did}#{fragment}") }); let u = "did:plc:user"; app.answer(u, 200, r#"{"read":true,"write":true}"#, 0); for fragment in ["path", "query"] { let sr = create_space(&s, &ta, fragment, managed(fragment)).await; assert_eq!( s.authorize_read(&sr, Some(u), None).await, YES, "{fragment}" ); let want = BTreeMap::from([("space".to_string(), sr.uri()), ("repo".into(), u.into())]); assert_eq!( app.calls().into_iter().map(|c| c.0).collect::>(), [want], "{fragment}" ); } for fragment in ["userpass", "user", "ftp", "bare", "object"] { let sr = create_space(&s, &ta, fragment, managed(fragment)).await; assert_eq!( ( s.authorize_read(&sr, Some(u), None).await, s.authorize_write(&sr, u).await ), (Err(Undecided), Err(Undecided)), "{fragment}" ); } assert_eq!(app.calls().len(), 0); // A redirect to where the repo is authorized is not followed. let forum = create_space(&s, &ta, "forum", managed("path")).await; app.answer( "did:plc:moved", 302, &format!("/xrpc/{CHECK_ACCESS}?repo={u}"), 0, ); assert_eq!( s.authorize_read(&forum, Some("did:plc:moved"), None).await, Err(Undecided) ); assert_eq!(app.calls().len(), 1); // An answer is read up to JSON_DOC_MAX bytes; one longer is undecided. let of = |n: usize| { let head = r#"{"read":true,"write":true,"p":""#; format!("{head}{}\"}}", "x".repeat(n - head.len() - 2)) }; assert_eq!(of(outbound::JSON_DOC_MAX).len(), outbound::JSON_DOC_MAX); app.answer("did:plc:edge", 200, &of(outbound::JSON_DOC_MAX), 0); app.answer("did:plc:over", 200, &of(outbound::JSON_DOC_MAX + 1), 0); assert_eq!( s.authorize_read(&forum, Some("did:plc:edge"), None).await, YES ); assert_eq!( s.authorize_read(&forum, Some("did:plc:over"), None).await, Err(Undecided) ); let _ = std::fs::remove_dir_all(&dir); } /// Run futures side by side, answering their outputs in order. async fn futures_all>(fs: Vec) -> Vec { let mut set = Vec::new(); for f in fs { set.push(Box::pin(f)); } let mut out: Vec> = vec![None; set.len()]; std::future::poll_fn(|cx| { for (i, f) in set.iter_mut().enumerate() { if out[i].is_none() && let std::task::Poll::Ready(v) = f.as_mut().poll(cx) { out[i] = Some(v); } } if out.iter().all(Option::is_some) { std::task::Poll::Ready(()) } else { std::task::Poll::Pending } }) .await; out.into_iter().map(Option::unwrap).collect() } }