//! Deactivating, taking down and deleting an account, and what each state //! does to every method, as `spec/LIFECYCLE.md` says: `deactivateAccount`, //! `activateAccount`, `checkAccountStatus`, `requestAccountDelete`, //! `deleteAccount`, and the admin's `updateSubjectStatus` and //! `getSubjectStatus`. //! //! An account's state is its `State`, behind a lock of its own, changed only //! with its store held for writing, so that the events a change puts on the //! firehose are numbered in order with its commits'. A change is entries of //! the service log (`ENTRIES`) in one frame: the state, the sessions a //! takedown ends, and the change's events, so that it is whole or not at //! all. A deletion is one entry, `deleted`, holding the deletion's event and //! the seqs of every event of the account's, which are dropped: once it is //! on disk the account is gone, and its files are removed after; a server //! started again removes any left, once it serves //! (`directory::Accounts::sweep`), and the dropped events' seqs stay holes //! in the firehose's numbers, as no seq is given out twice. //! //! A record taken down is an entry of its account's own log, `takedownRecord`, //! made under its lock, and stays on its key until a commit deletes it; a //! blob taken down is the blobs' (`blobs::ENTRIES`), and goes when the blob //! is no longer held. //! //! `gate` and `gate_query` are the one check of an account's state the //! dispatch consults: `row` says what each method answers of an account //! deactivated, taken down or deleted, once its token and input are checked. use crate::email::{self, Purpose}; use crate::events::{self, Firehose, Landing, Reserved}; use crate::oauth::Ends; use crate::server::{password, password_length}; use crate::sessions::{self, Bearer, Token}; use crate::{ Account, Auth, Call, Handler, Resp, Service, Shared, Store, XrpcError, durable, err, internal, invalid, invalid_token, opt, read, required, write, }; use base64::Engine; use pds_store::Wal; use serde_json::{Map, Value as Json, json}; use std::sync::Arc; /// The kinds of `accounts.log` entry this module keeps, each naming its account by `did`. pub(crate) const ENTRIES: &[&str] = &["deactivated", "takedown", "event", "deleted"]; /// Those of them that change an account's `State`, which its row of the /// service checkpoint keeps (`compact`). pub(crate) const STATES: &[&str] = &["deactivated", "takedown"]; /// The entry of an account's own log that takes a record down, or lifts that. pub(crate) const RECORD_TAKEDOWN: &str = "takedownRecord"; const REPO_REF: &str = "com.atproto.admin.defs#repoRef"; const STRONG_REF: &str = "com.atproto.repo.strongRef"; const BLOB_REF: &str = "com.atproto.admin.defs#repoBlobRef"; /// An account's state: active unless it is deactivated or taken down, each /// set and cleared on its own. #[derive(Clone, Debug, Default, PartialEq, Eq)] pub(crate) struct State { pub deactivated: bool, /// The takedown's reference, while it is down. pub takedown: Option, /// Gone: set as it is deleted, for whoever held the account then. pub deleted: bool, } impl State { /// What the methods answer for it: none while it is active. pub fn status(&self) -> Option<&'static str> { if self.deleted { Some("deleted") } else if self.takedown.is_some() { Some("takendown") } else if self.deactivated { Some("deactivated") } else { None } } /// Make the change an entry says, as it is logged and as it is replayed. pub fn apply(&mut self, e: &Json) -> Result<(), String> { match e["t"].as_str() { Some("deactivated") => { self.deactivated = e["applied"] .as_bool() .ok_or_else(|| format!("a deactivation with no applied: {e}"))? } Some("takedown") => { self.takedown = match &e["ref"] { Json::Null => None, Json::String(r) => Some(r.clone()), _ => return Err(format!("a takedown whose ref is not a string: {e}")), } } t => return Err(format!("a log entry of no known type: {t:?}")), } Ok(()) } /// The entries that make this state again, for a compacted log. pub fn entries(&self, did: &str) -> Vec { let deactivated = self.deactivated.then(|| deactivated_entry(did, true)); let takedown = self .takedown .as_deref() .map(|r| takedown_entry(did, Some(r))); deactivated.into_iter().chain(takedown).collect() } } pub(crate) fn deactivated_entry(did: &str, applied: bool) -> Json { json!({ "t": "deactivated", "did": did, "applied": applied }) } fn takedown_entry(did: &str, r: Option<&str>) -> Json { json!({ "t": "takedown", "did": did, "ref": r }) } /// An event of the service log, of the account `did`. fn event_entry(did: &str, seq: u64, frame: &[u8]) -> Json { json!({ "t": "event", "did": did, "seq": seq, "frame": hex::encode(frame) }) } /// `seqs`, in order, as runs `[first, last]`. fn runs(ords: &[u64]) -> Vec<[u64; 2]> { let mut out: Vec<[u64; 2]> = Vec::new(); for &o in ords { match out.last_mut() { Some(r) if r[1] + 1 == o => r[1] = o, _ => out.push([o, o]), } } out } /// An event `accounts.log` holds, as replayed. pub(crate) struct LoggedEvent { pub did: String, pub seq: u64, pub frame: Vec, /// Whether it is an account's deletion's, which its `deleted` entry holds. deletion: bool, } /// What the service log's entries of the kinds in `ENTRIES` that are not /// one account's state leave: the events the log holds, and the seqs of the /// events of the accounts deleted, dropped with them. #[derive(Default)] pub(crate) struct Replayed { pub events: Vec, pub gaps: Vec, /// The `deleted` entries, as logged, for a compacted log. pub deletions: Vec, } impl Replayed { /// Replay an `event` or a `deleted` entry; answers the DID of an /// account the entry deletes, which is then no account. pub fn replay(&mut self, e: &Json) -> Result, String> { let Some(did) = e["did"].as_str() else { return Err(format!("an entry with no did: {e}")); }; let event = |e: &Json| -> Result { let Some(seq) = e["seq"].as_u64().filter(|s| *s > 0) else { return Err(format!("an event with no seq: {e}")); }; let frame = e["frame"] .as_str() .and_then(|f| hex::decode(f).ok()) .ok_or_else(|| format!("an event with no frame: {e}"))?; Ok(LoggedEvent { did: did.to_string(), seq, frame, deletion: false, }) }; match e["t"].as_str() { Some("event") => self.events.push(event(e)?), Some("deleted") => { let gaps = e["gaps"] .as_array() .ok_or_else(|| format!("a deletion with no gaps: {e}"))?; for g in gaps { let (Some(first), Some(last)) = (g[0].as_u64(), g[1].as_u64()) else { return Err(format!("a gap that is not two numbers: {e}")); }; if first == 0 || last < first { return Err(format!("a gap out of order: {e}")); } self.gaps.extend(first..=last); } self.events.retain(|x| x.did != did); self.events.push(LoggedEvent { deletion: true, ..event(e)? }); self.deletions.push(e.clone()); return Ok(Some(did.to_string())); } t => return Err(format!("a log entry of no known type: {t:?}")), } Ok(None) } /// The entries that make what was replayed again, for a checkpoint: /// the deletions whose events `keep` keeps, then the events it keeps /// but theirs, so that no event logged after a deletion is dropped by /// it. pub fn entries(&self, keep: impl Fn(u64, &[u8]) -> bool) -> Vec { let mut out: Vec = Vec::new(); let kept = |e: &LoggedEvent| keep(e.seq, &e.frame); let deleted: std::collections::HashSet<&str> = self .events .iter() .filter(|e| e.deletion && kept(e)) .map(|e| e.did.as_str()) .collect(); out.extend( self.deletions .iter() .filter(|d| d["did"].as_str().is_some_and(|did| deleted.contains(did))) .map(|d| { let mut d = d.clone(); if let Some(m) = d.as_object_mut() { m.remove("ord"); } d }), ); out.extend( self.events .iter() .filter(|e| !e.deletion && kept(e)) .map(|e| event_entry(&e.did, e.seq, &e.frame)), ); out } /// The greatest seq of the events replayed. pub fn last_seq(&self) -> u64 { self.events.iter().map(|e| e.seq).max().unwrap_or(0) } } pub(crate) fn handler(nsid: &str) -> Option { Some(match nsid { "com.atproto.server.deactivateAccount" => { Handler::Authed(sessions::deactivating_token, |s, t, _| { Box::pin(deactivate_account(s, t)) }) } "com.atproto.server.activateAccount" => { Handler::Authed(sessions::full_access_token, |s, t, _| { Box::pin(activate_account(s, t)) }) } "com.atproto.server.checkAccountStatus" => { Handler::Authed(sessions::access_token, |s, t, _| { Box::pin(check_account_status(s, t)) }) } "com.atproto.server.requestAccountDelete" => { Handler::Authed(sessions::full_access_token, |s, t, _| { Box::pin(request_account_delete(s, t)) }) } "com.atproto.server.deleteAccount" => { Handler::Procedure(|s, b| Box::pin(delete_account(s, b))) } "com.atproto.admin.updateSubjectStatus" => { Handler::Authed(admin, |s, _, b| Box::pin(update_subject_status(s, b))) } "com.atproto.admin.getSubjectStatus" => { Handler::Authed(admin, |s, _, p| Box::pin(get_subject_status(s, p))) } _ => return None, }) } // ---- The gate ----------------------------------------------------------------- /// What a method answers of an account in a state. #[derive(Clone, Copy)] enum Answer { /// As for an active account: the method itself answers. Pass, Refuse(u16, &'static str), } /// Which account a method's state check is of. #[derive(Clone, Copy)] enum Of { /// The token's. Token, /// The one a parameter names; with `readers`, the account itself and the /// admin read it as if it were active, a `com.atproto.takendown` token /// too if `readers` is `Some(true)`. Param(&'static str, Option), } /// What a method answers of an account deactivated, taken down, and deleted. struct Row { of: Of, deactivated: Answer, takendown: Answer, deleted: Answer, } const PASS: Answer = Answer::Pass; const TAKEDOWN: Answer = Answer::Refuse(401, "AccountTakedown"); const NOT_FOUND: Answer = Answer::Refuse(403, "AccountNotFound"); const INVALID: Answer = Answer::Refuse(400, "InvalidRequest"); /// The table of `spec/LIFECYCLE.md`'s "What each state does to every /// method", for the methods a state refuses. A method not here answers as /// for an active account, or says its state itself (`getRepoStatus`, /// `listRepos`, `resolveHandle`, `createSession`, `deleteAccount`, and the /// answers of `getSession`, `refreshSession` and `checkAccountStatus`), and /// a deleted account is no account at all to a method that looks it up. /// `com.atproto.repo.getRecord` of an account that is not active is /// answered as of a repository the server does not hold (`proxy::get_record`). fn row(nsid: &str) -> Option { let own = |takendown, deleted| Row { of: Of::Token, deactivated: PASS, takendown, deleted, }; let read = |name, readers, deactivated, takendown| Row { of: Of::Param(name, readers), deactivated, takendown, deleted: PASS, }; let repo_deactivated = Answer::Refuse(400, "RepoDeactivated"); let repo_takendown = Answer::Refuse(400, "RepoTakendown"); Some(match nsid { "com.atproto.server.getSession" => own(INVALID, INVALID), "com.atproto.server.refreshSession" => own(TAKEDOWN, INVALID), "com.atproto.server.createAppPassword" | "com.atproto.repo.uploadBlob" | "com.atproto.identity.updateHandle" | "com.atproto.server.requestAccountDelete" | "com.atproto.server.requestEmailConfirmation" | "com.atproto.server.confirmEmail" | "com.atproto.server.requestEmailUpdate" | "com.atproto.server.updateEmail" | "app.bsky.actor.putPreferences" // The account's own route of no lexicon (`spec/PASSKEYS.md`). | "_passkeyAdd" => own(TAKEDOWN, NOT_FOUND), "com.atproto.server.getAccountInviteCodes" => Row { of: Of::Token, deactivated: Answer::Refuse(400, "NotFound"), takendown: TAKEDOWN, deleted: NOT_FOUND, }, "app.bsky.actor.getPreferences" => own(PASS, Answer::Refuse(400, "NotFound")), "com.atproto.identity.getRecommendedDidCredentials" => { own(PASS, Answer::Refuse(500, "InternalServerError")) } "com.atproto.server.checkAccountStatus" => own(PASS, Answer::Refuse(400, "NotFound")), "com.atproto.server.deactivateAccount" => own(PASS, INVALID), // spec/MIGRATION.md. `importRepo` checks its account's state with // its token (`migration`); `listMissingBlobs`, `submitPlcOperation` // and `signPlcOperation` each answer a deleted account where they // find it gone. "com.atproto.repo.importRepo" => own(TAKEDOWN, NOT_FOUND), "com.atproto.identity.requestPlcOperationSignature" => own(PASS, INVALID), // `activateAccount` checks its account's state itself, after its DID // document (`activate`, `activate_gone`). // A write's is the account of its `repo` (`write_repo`). "com.atproto.repo.createRecord" | "com.atproto.repo.putRecord" | "com.atproto.repo.deleteRecord" | "com.atproto.repo.applyWrites" => Row { of: Of::Token, deactivated: Answer::Refuse(401, "AccountDeactivated"), takendown: TAKEDOWN, deleted: NOT_FOUND, }, "com.atproto.repo.describeRepo" => read("repo", None, repo_deactivated, repo_takendown), "com.atproto.repo.listRecords" => read("repo", None, INVALID, INVALID), "com.atproto.sync.getRepo" | "com.atproto.sync.getBlob" | "com.atproto.sync.listBlobs" => { read("did", Some(true), repo_deactivated, repo_takendown) } "com.atproto.sync.getLatestCommit" | "com.atproto.sync.getBlocks" | "com.atproto.sync.getRecord" => { read("did", Some(false), repo_deactivated, repo_takendown) } _ => return None, }) } fn refuse(a: Answer, did: &str) -> Result<(), XrpcError> { match a { Answer::Pass => Ok(()), Answer::Refuse(status, name) => { let message = match name { "RepoDeactivated" => format!("Repo has been deactivated: {did}"), "RepoTakendown" => format!("Repo has been takendown: {did}"), "AccountDeactivated" => "Account is deactivated".into(), "AccountTakedown" => "Account has been taken down".into(), "AccountNotFound" => "Account not found".into(), "NotFound" => "Account not found".into(), "InternalServerError" => "Internal Server Error".into(), _ => "Account is not active".into(), }; err(status, name, message) } } } /// What a row answers of the account `did`, as its state is now: of none, /// it is deleted. fn answer_of(s: &Service, r: &Row, did: &str) -> Result<(), XrpcError> { let Some(a) = s.account(did) else { return refuse(r.deleted, did); }; let state = read(&a.state); let which = if state.deleted { r.deleted } else if state.takedown.is_some() { r.takendown } else if state.deactivated { r.deactivated } else { Answer::Pass }; refuse(which, &a.did) } /// The state check of a call of `nsid` whose token, input and rate limits /// are checked: of the account `did`, the token's, or a write's `repo`'s. pub(crate) fn gate(s: &Service, nsid: &str, did: &str) -> Result<(), XrpcError> { match row(nsid) { Some(r) => answer_of(s, &r, did), None => Ok(()), } } /// Whether a call of `nsid` has its state checked with its token, before its /// input and rate limits: the account's own calls a taken-down account is /// refused with `401 AccountTakedown` and a deleted one with `403 /// AccountNotFound`, as the reference refuses them with the token, and /// `getPreferences`, which has no input. A query among them checks its /// token, and then its state, itself (`getAccountInviteCodes`). pub(crate) fn with_token(nsid: &str) -> bool { matches!( nsid, "com.atproto.server.createAppPassword" | "com.atproto.repo.uploadBlob" | "com.atproto.identity.updateHandle" | "com.atproto.server.requestAccountDelete" | "com.atproto.server.requestEmailConfirmation" | "com.atproto.server.confirmEmail" | "com.atproto.server.requestEmailUpdate" | "com.atproto.server.updateEmail" | "com.atproto.server.getAccountInviteCodes" | "app.bsky.actor.getPreferences" | "app.bsky.actor.putPreferences" ) } /// Whether an error is the refusal of a call's account's state made with /// its token, which costs the call nothing of the rate limits. pub(crate) fn refused_with_token(nsid: &str, e: &XrpcError) -> bool { with_token(nsid) && matches!(e.name, "AccountTakedown" | "AccountNotFound") } /// The state check of a query once its parameters are checked: of its /// token's account, if its token is one, which the query checks itself if /// not; or of the account a parameter names, if any has it, which the query /// answers itself if none does. A read the account itself and the admin /// make as of an active account checks its `Authorization` first, as /// `viewer` says. pub(crate) fn gate_query(s: &Service, call: &Call, p: &Map) -> Result<(), XrpcError> { let Some(r) = row(call.nsid) else { return Ok(()); }; match r.of { Of::Token if with_token(call.nsid) => Ok(()), Of::Token => match s.auth(call.bearer) { Auth::Account(did) => answer_of(s, &r, &did), _ => Ok(()), }, Of::Param(name, readers) => { let viewer = match readers { Some(takendown) => viewer(s, call.bearer, takendown)?, None => Viewer::Anyone, }; let Some(a) = opt(p, name).and_then(|id| s.account(id)) else { return Ok(()); }; match viewer { Viewer::Admin => Ok(()), Viewer::Account(did) if did == a.did => Ok(()), _ => answer_of(s, &r, &a.did), } } } } /// Who reads a repository, as its `Authorization` says. enum Viewer { Anyone, Account(String), Admin, } /// The reader of the sync reads: none; an account, by an access token, or a /// `com.atproto.takendown` one if `takendown`; or the admin, by its `Basic`. /// A token the server would refuse is `400 InvalidToken`, one past its /// `exp` `400 ExpiredToken`, and a `Basic` that is not the admin's `401`. fn viewer(s: &Service, b: Bearer, takendown: bool) -> Result { match b { Bearer::None => Ok(Viewer::Anyone), Bearer::Token(_) if takendown => { sessions::takendown_ok_token(s, b).map(|t| Viewer::Account(t.did)) } Bearer::Token(_) => sessions::access_token(s, b).map(|t| Viewer::Account(t.did)), Bearer::Basic(_) => crate::invites::admin(s, b).map(|_| Viewer::Admin), Bearer::OAuth(g) => Ok(Viewer::Account(g.did.clone())), Bearer::DPoP(_) | Bearer::Malformed => invalid_token(), } } /// `403 AccountNotFound` if the account was deleted: checked with its store /// held, by what writes to it, as it may have been deleted while they waited. pub(crate) fn not_deleted(a: &Account) -> Result<(), XrpcError> { if read(&a.state).deleted { account_not_found() } else { Ok(()) } } /// What a method of a deleted account's answers when it gets that far. pub(crate) fn account_not_found() -> Result { err(403, "AccountNotFound", "Account not found") } /// Whether an account is active, as `resolveHandle`, `listRepos` and /// `getRepoStatus` answer it. pub(crate) fn status(a: &Account) -> Option<&'static str> { read(&a.state).status() } // ---- Changing an account's state ------------------------------------------------ /// A change of an account's state, and the events it puts on the firehose. enum Change { /// Deactivate it: `#account` with its status. With an OAuth token, every /// OAuth session of the account ends too, and its app passwords are /// deleted, as the reference does. Deactivate { by_oauth: bool }, /// Activate it: `#account`, `#identity` and `#sync`. Activate, /// Take it down with this reference, or lift that, either way ending its /// sessions: `#account` with its status. Takedown(Option), } /// Make a change to an account's state, with its store held, logged in one /// frame of `accounts.log` with its events and what it ends of OAuth's (a /// takedown, applied or lifted, its sessions and the requests approved for /// it; a deactivation those requests, and with an OAuth token its sessions /// and the clients it approved too): answers the frame, and the events to /// land once it is on disk. OAuth's lock is taken before the state's /// (`oauth::OAuth::end_for`). fn change(s: &Service, a: &Account, c: Change) -> Result<(u64, Landing), XrpcError> { let st = write(&a.store); not_deleted(a)?; let ends = match c { Change::Takedown(_) => Ends { sessions: true, requests: true, ..Ends::default() }, Change::Deactivate { by_oauth } => Ends { requests: true, sessions: by_oauth, clients: by_oauth, ..Ends::default() }, Change::Activate => Ends::default(), }; s.oauth.end_for(&a.did, ends, |ended| { let mut state = write(&a.state); let mut next = state.clone(); let mut entries = match &c { Change::Deactivate { .. } => vec![deactivated_entry(&a.did, true)], Change::Activate => vec![deactivated_entry(&a.did, false)], Change::Takedown(r) => vec![takedown_entry(&a.did, r.as_deref())], }; for e in &entries { next.apply(e) .unwrap_or_else(|why| panic!("a change made under its account's lock: {why}")); } let n = if matches!(c, Change::Activate) { 3 } else { 1 }; let r = s .events .reserve_kept(&a.did, n) .or_else(email::not_logged)?; let frames = match c { Change::Activate => activation(a, &r, next.status(), &st), _ => vec![events::account_event( &a.did, r.seq, &r.time(), next.status(), )], }; let seq = r.seq; entries.extend( frames .iter() .enumerate() .map(|(i, f)| event_entry(&a.did, seq + i as u64, f)), ); entries.extend(ended); let logged = match c { Change::Takedown(_) => s.sessions.end_all(&s.log, &a.did, entries), Change::Deactivate { by_oauth: true } => { s.sessions.drop_app_passwords(&s.log, &a.did, entries) } _ => s.log.append(&entries), }; let n = match logged { Ok(n) => n, Err(e) => { s.events.fail(seq, frames.len()); return email::not_logged(e); } }; *state = next; Ok((n, r.landing(frames.into_iter().map(Into::into).collect()))) }) } /// The events an activation puts on the firehose, numbered as `r` says: /// `#account` with the status it has, `#identity` with its handle, and /// `#sync` of its latest commit, as its store has it. fn activation(a: &Account, r: &Reserved, status: Option<&str>, st: &Store) -> Vec> { let time = r.time(); vec![ events::account_event(&a.did, r.seq, &time, status), events::identity_event(&a.did, &a.handle(), r.seq + 1, &time), events::sync_event(&a.did, r.seq + 2, &time, st.repo.head_bytes(), &st.repo.rev), ] } /// Put on the firehose, for an active account a write of which was found /// whole after a power cut with nothing kept of its event, the events an /// activation puts there, so that those who read the firehose learn what /// its repository holds (`spec/STORE.md`, "The firehose after a start"): /// logged in one frame of the service log, `log`, as `change` logs an /// activation's, its store held so that they are in order with its other /// events, and nothing changed. Answers the frame and the events to land /// once it and their entry are on disk; none for an account not active, /// which its activation announces when it comes. pub(crate) fn announce_found( events: &Firehose, log: &Wal, a: &Account, ) -> std::io::Result> { let st = write(&a.store); if read(&a.state).status().is_some() { return Ok(None); } let r = events.reserve_kept(&a.did, 3)?; let frames = activation(a, &r, None, &st); let entries: Vec = frames .iter() .enumerate() .map(|(i, f)| event_entry(&a.did, r.seq + i as u64, f)) .collect(); match log.append(&entries) { Ok(n) => Ok(Some(( n, r.landing(frames.into_iter().map(Into::into).collect()), ))), Err(e) => { events.fail(r.seq, frames.len()); Err(e) } } } /// Wait for the events' entry in the index and a frame of `accounts.log` /// to be on disk, in that order, then land the events. async fn settle(s: &Shared, n: u64, landing: Landing) -> Result<(), XrpcError> { let entry = match landing.entry() { Some((index, k)) => durable(index, k).await, None => Ok(()), }; let synced = durable(s.log.clone(), n).await; s.events.land(landing); entry.and(synced) } /// Make a change and wait for it. async fn make(s: &Shared, a: &Account, c: Change) -> Result<(), XrpcError> { let (n, landing) = change(s, a, c)?; settle(s, n, landing).await } /// Put `#account` on the firehose for the account `did` with no change: its /// status now, or `deleted` if no account here has it. async fn announce(s: &Shared, did: &str) -> Result<(), XrpcError> { let account = s.account(did); let (n, landing) = { // Held, so that the event is in order with its account's others. let st = account.as_ref().map(|a| write(&a.store)); let status = match &account { Some(a) => read(&a.state).status(), None => Some("deleted"), }; let r = s.events.reserve_kept(did, 1).or_else(email::not_logged)?; let frame = events::account_event(did, r.seq, &r.time(), status); let n = match s.log.append(&[event_entry(did, r.seq, &frame)]) { Ok(n) => n, Err(e) => { s.events.fail(r.seq, 1); return email::not_logged(e); } }; drop(st); (n, r.landing(vec![frame.into()])) }; settle(s, n, landing).await } /// Put one event of the account `a`'s on the firehose, made by `frame` of /// its seq and time, logged in the service log as `announce`'s is: the /// `#identity` of a PLC operation submitted for it (`spec/MIGRATION.md`). pub(crate) async fn tell( s: &Shared, a: &Account, frame: impl FnOnce(u64, &str) -> Vec, ) -> Result<(), XrpcError> { let (n, landing) = { // Held, so that the event is in order with its account's others. let st = write(&a.store); let r = s .events .reserve_kept(&a.did, 1) .or_else(email::not_logged)?; let frame = frame(r.seq, &r.time()); let n = match s.log.append(&[event_entry(&a.did, r.seq, &frame)]) { Ok(n) => n, Err(e) => { s.events.fail(r.seq, 1); return email::not_logged(e); } }; drop(st); (n, r.landing(vec![frame.into()])) }; settle(s, n, landing).await } /// The PLC directory's current data for `did`: none if it does not know the /// DID, `502 UpstreamFailure` if it cannot be read. async fn did_data(s: &Service, did: &str) -> Result, XrpcError> { let url = format!("{}/{did}/data", s.config.plc_url.trim_end_matches('/')); crate::plc::document(&s.http, &url).await.or_else(|why| { crate::ops::failed_for( crate::ops::Level::Error, "reading a DID's data failed", did, why, ); err( 502, "UpstreamFailure", "The PLC directory could not be reached", ) }) } /// Whether a DID's data names this server: its rotation keys include the /// server's and its PDS is this one, looked at first, then its signing key /// is `signing`, if the account has one still. fn names_server(s: &Service, data: &Json, signing: Option<&str>) -> bool { let rotation = crate::plc::did_key(s.config.rotation_key.verifying_key()); data["rotationKeys"] .as_array() .is_some_and(|keys| keys.iter().any(|k| *k == json!(rotation))) && data["services"]["atproto_pds"]["endpoint"] == json!(s.config.public_url) && signing.is_none_or(|k| data["verificationMethods"]["atproto"] == json!(k)) } /// Whether the PLC directory's current data for the account's DID names /// this server: its PDS, its signing key, and the server's rotation key. A /// `did:web`'s document is read from its host instead, its errors as /// `identity::web_doc_now` gives them, and names this server by its /// endpoint and signing key alone (`spec/MIGRATION.md`, "A `did:web` account"). async fn valid_did(s: &Service, a: &Account) -> Result { let signing = *read(&a.store).repo.verifying_key(); if crate::identity::is_web(&a.did) { let doc = crate::identity::web_doc_now(s, a).await?; return Ok(crate::identity::web_names_server(s, &doc, Some(&signing))); } let Some(data) = did_data(s, &a.did).await? else { return Ok(false); }; let signing = crate::plc::did_key(&signing); Ok(names_server(s, &data, Some(&signing))) } fn not_this_server() -> Result { invalid("Requested DID does not match current DID document") } /// Activate an account, by its owner or the admin: refused if its DID /// document does not name this server, then if it is taken down. async fn activate(s: &Shared, a: &Account) -> Result<(), XrpcError> { if !valid_did(s, a).await? { return not_this_server(); } if read(&a.state).takedown.is_some() { return err(400, "AccountNotFound", "Account has been taken down"); } make(s, a, Change::Activate).await } /// Activate a DID no account here has, deleted or never made, by its /// deleted account's token or the admin: its DID document is read as an /// account's, but there is no signing key to find in it, and one that /// otherwise names this server is `500`, as the reference answers it. async fn activate_gone(s: &Service, did: &str) -> Result<(), XrpcError> { let names = if crate::identity::is_web(did) { let doc = crate::proxy::read_did(s, did).await?; crate::identity::web_names_server(s, &doc, None) } else { did_data(s, did) .await? .is_some_and(|data| names_server(s, &data, None)) }; if names { return internal(); } not_this_server() } /// The token's account, which the gate found. fn own(s: &Service, t: &Token) -> Result, XrpcError> { s.account(&t.did).map_or_else(internal, Ok) } async fn deactivate_account(s: Shared, t: Token) -> Result { let a = own(&s, &t)?; make(&s, &a, Change::Deactivate { by_oauth: t.oauth }).await?; Ok(Resp::Nothing) } async fn activate_account(s: Shared, t: Token) -> Result { match s.account(&t.did) { Some(a) => activate(&s, &a).await?, None => activate_gone(&s, &t.did).await?, } Ok(Resp::Nothing) } async fn check_account_status(s: Shared, t: Token) -> Result { let a = own(&s, &t)?; // A directory that cannot be read is answered as one that does not name this server. let valid = valid_did(&s, &a).await.unwrap_or(false); let (mut out, wal, n) = { let st = read(&a.store); let (expected, imported) = st.blobs.counts(s.limits.clock.now(), s.config.blob_ttl); let out = json!({ "activated": status(&a).is_none(), "repoCommit": st.repo.head_string(), "repoRev": st.repo.rev, "repoBlocks": st.repo.block_count(), "indexedRecords": st.repo.record_count(), "privateStateValues": 0, "expectedBlobs": expected, "importedBlobs": imported, }); (out, st.wal.clone(), st.wal.written()) }; out["validDid"] = json!(valid); // What it read of the account's state is on disk once `accounts.log` is. durable(wal, n).await?; durable(s.log.clone(), s.log.written()).await?; Ok(Resp::Json(out)) } async fn request_account_delete(s: Shared, t: Token) -> Result { let a = own(&s, &t)?; let out = { let mut m = email::lock(&a.mail); email::make(&s, &a.did, &mut m, Purpose::DeleteAccount)? }; email::deliver(&s, out).await?; Ok(Resp::Nothing) } /// The longest password `deleteAccount` takes, in UTF-16 code units. const MAX_PASSWORD: usize = 512; async fn delete_account(s: Shared, b: Map) -> Result { let refuse = || err(401, "AuthenticationRequired", "Invalid did or password"); let (did, pw, token) = ( required(&b, "did")?, required(&b, "password")?.to_string(), required(&b, "token")?, ); if password_length(&pw) > MAX_PASSWORD { return refuse(); } let Some(a) = s.account(did) else { return invalid("Could not find account"); }; // Hashed as for any account, one without a password too, with no lock held. let stored = email::lock(&a.mail).password.clone(); let hash = stored.clone(); let right = s .limits .hashes .run(move || password::verify_or_none(&pw, hash.as_deref())) .await .unwrap_or(false); if !right { return refuse(); } let now = s.sessions.now(); let (n, landing, objects) = { let m = email::lock(&a.mail); // A password reset meanwhile makes it wrong. if m.password != stored { return refuse(); } m.check(Purpose::DeleteAccount, token, now)?; remove(&s, &a, &m)? }; settle(&s, n, landing).await?; // Its objects in a bucket go once its deletion is on disk. if let Some(bucket) = &s.ctx.bucket { bucket.doom(&a.did, objects); } // Its files go once its deletion is on disk; a server started again // removes any left. A DID may be made again: the journal forgets its // directory, durably, before it goes, so that a start never writes what // it held of these files into another account's. let dir = s.dir.join("repos").join(&a.did); let journal = s.ctx.files.journal().cloned(); let removed = tokio::task::spawn_blocking(move || { if let Some(j) = &journal { j.forget(&dir) .map_err(|e| format!("{}: {e}", dir.display()))?; } match std::fs::remove_dir_all(&dir) { Err(e) if e.kind() != std::io::ErrorKind::NotFound => { Err(format!("{}: {e}", dir.display())) } _ => Ok(()), } }); if let Ok(Err(why)) = removed.await { crate::ops::failed("removing a deleted account failed", why); } Ok(Resp::Nothing) } /// Delete an account, with its mail held: logged, in one entry with its /// deletion's event and the places of its events, dropped from the /// firehose; then it is no account, its handle and email free, its sessions, /// app passwords and tokens gone. With blobs in a bucket, the objects it may /// keep are named in the same frame, to delete (`blobstore`). Answers the /// frame, the event to land, and those objects. fn remove( s: &Service, a: &Account, m: &email::Mail, ) -> Result<(u64, Landing, Vec), XrpcError> { // Its events the index holds are known before any lock is taken. s.events.find_old(); let st = write(&a.store); not_deleted(a)?; // OAuth's lock, taken before the state's, is held throughout: no OAuth // change is logged meanwhile, and once logged, OAuth forgets the account. let out = s.oauth.end_for(&a.did, Ends { account: true, ..Ends::default() }, |_| { let mut state = write(&a.state); let mut d = write(&s.directory); // Its events: those its store holds, and the service log's. let mut seqs: Vec = st .event_seqs() .into_iter() .map(|(seq, _)| seq) .chain(s.events.seqs_of(&a.did)) .collect(); seqs.sort_unstable(); seqs.dedup(); let r = s .events .reserve_kept(&a.did, 1) .or_else(email::not_logged)?; let seq = r.seq; let frame = events::account_event(&a.did, seq, &r.time(), Some("deleted")); let entry = json!({ "t": "deleted", "did": a.did, "gaps": runs(&seqs), "seq": seq, "frame": hex::encode(&frame) }); let objects = match &s.ctx.bucket { Some(_) => st.blobs.kept_list(), None => Vec::new(), }; let mut entries = vec![entry]; if !objects.is_empty() { entries.push(crate::blobstore::doomed_entry(&a.did, &objects)); } let (n, at) = match s.log.append_at(&entries) { Ok(logged) => logged, Err(e) => { s.events.fail(seq, 1); return email::not_logged(e); } }; s.events.drop_events(&seqs, |seq| st.event_frame(seq)); s.ctx.eager.forget(&a.did); state.deleted = true; d.remove(a, m.email.as_deref(), at.generation); let landing = r.landing(vec![frame.into()]); Ok((n, landing, objects)) })?; s.sessions.forget(&a.did); s.resets.forget(&a.did); s.prefs.forget(&a.did); Ok(out) } // ---- The admin ------------------------------------------------------------------ /// The admin's `Basic` auth, as the admin's methods of this page check it: a /// `Bearer` token is taken for a moderation service's JWT, which the server /// does not take, and a header that is not two words is `InvalidToken`. fn admin(s: &Service, b: Bearer) -> Result { match b { Bearer::Token(jwt) => { let typ = jwt .split('.') .next() .and_then(|h| { base64::engine::general_purpose::URL_SAFE_NO_PAD .decode(h) .ok() }) .and_then(|h| serde_json::from_slice::(&h).ok()) .and_then(|h| h["typ"].as_str().map(str::to_string)); match typ.as_deref() { Some("at+jwt" | "refresh+jwt") => err(401, "BadJwtType", "Invalid jwt type"), _ => err(401, "BadJwt", "Jwt could not be verified"), } } Bearer::Malformed => invalid_token(), _ => crate::invites::admin(s, b), } } /// A takedown's or a deactivation's `applied`, if it is given. fn applied(b: &Map, name: &str) -> Option { b.get(name).and_then(|a| a["applied"].as_bool()) } async fn update_subject_status(s: Shared, b: Map) -> Result { let subject = b.get("subject").cloned().unwrap_or_default(); let ty = subject["$type"].as_str().unwrap_or_default(); let (takedown, deactivated) = (applied(&b, "takedown"), applied(&b, "deactivated")); if takedown == Some(true) && deactivated == Some(false) { return invalid("Cannot both take down and activate an account"); } if takedown.is_some() && ![REPO_REF, STRONG_REF, BLOB_REF].contains(&ty) { return invalid("Invalid subject"); } let text = |k: &str| subject[k].as_str().unwrap_or_default().to_string(); if let Some(on) = takedown { let r = on.then(|| { b["takedown"]["ref"] .as_str() .map_or_else(events::timestamp, str::to_string) }); match ty { REPO_REF => match s.account(&text("did")) { Some(a) => make(&s, &a, Change::Takedown(r)).await?, None => announce(&s, &text("did")).await?, }, STRONG_REF => take_record_down(&s, &text("uri"), r).await?, _ => take_blob_down(&s, &text("did"), &text("cid"), r).await?, } } if let (Some(on), REPO_REF) = (deactivated, ty) { let did = text("did"); match s.account(&did) { Some(a) if on => make(&s, &a, Change::Deactivate { by_oauth: false }).await?, Some(a) => activate(&s, &a).await?, None if on => return invalid("Account not found"), None => activate_gone(&s, &did).await?, } } if takedown.is_none() && b.get("deactivated").is_none() && ty == REPO_REF { announce(&s, &text("did")).await?; } let mut out = json!({ "subject": subject }); if let Some(t) = b.get("takedown") { out["takedown"] = t.clone(); } Ok(Resp::Json(out)) } /// An `at://` URI's authority, and the path `collection/rkey` of the record /// it names, if it names one: none of its authority alone, or of a /// collection and no key. Any other URI is none. fn record_uri(uri: &str) -> Option<(&str, Option)> { let mut parts = uri.strip_prefix("at://")?.splitn(3, '/'); let authority = parts.next().filter(|a| !a.is_empty())?; let path = match ( parts.next().filter(|c| !c.is_empty()), parts.next().filter(|k| !k.is_empty()), ) { (Some(collection), Some(rkey)) if !rkey.contains('/') => { Some(format!("{collection}/{rkey}")) } (_, Some(_)) => return None, _ => None, }; Some((authority, path)) } /// Take down the record the repository now has at the URI's key, or lift /// that: a key it does not hold changes nothing, nor a URI of an account /// here that names no record. One whose authority is a handle, or a DID no /// account here has, is `500`, as the reference answers it. async fn take_record_down(s: &Shared, uri: &str, r: Option) -> Result<(), XrpcError> { let Some((did, path)) = record_uri(uri).filter(|(a, _)| a.starts_with("did:")) else { return internal(); }; let Some(a) = s.account(did) else { return internal(); }; let Some(path) = path else { return Ok(()) }; let (wal, n) = { let mut st = write(&a.store); not_deleted(&a)?; let changes = match &r { Some(_) => st.holds(&path), None => st.takedowns.contains_key(&path), }; if changes { if let Err(e) = st .wal .append(&[json!({ "t": RECORD_TAKEDOWN, "path": path, "ref": r })]) { crate::ops::failed_for( crate::ops::Level::Error, "logging a takedown failed", did, e, ); return internal(); } match r { Some(r) => st.takedowns.insert(path, r), None => st.takedowns.remove(&path), }; } (st.wal.clone(), st.wal.written()) }; durable(wal, n).await } /// Take down a blob the account holds, or lift that: one it does not hold /// changes nothing. async fn take_blob_down( s: &Shared, did: &str, cid: &str, r: Option, ) -> Result<(), XrpcError> { let Some(a) = s.account(did) else { return internal(); }; let (wal, n) = { let mut st = write(&a.store); not_deleted(&a)?; st.blobs.time(s.limits.clock.now(), s.config.blob_ttl); if let Some(e) = st.blobs.takedown_entry(cid, r.as_deref()) { if let Err(e) = st.wal.append(std::slice::from_ref(&e)) { crate::ops::failed_for( crate::ops::Level::Error, "logging a takedown failed", did, e, ); return internal(); } st.blobs .replay(&e) .unwrap_or_else(|why| panic!("a takedown made under its account's lock: {why}")); } (st.wal.clone(), st.wal.written()) }; durable(wal, n).await } /// A subject's takedown, as `getSubjectStatus` answers it. fn takedown_json(r: Option<&str>) -> Json { match r { Some(r) => json!({ "applied": true, "ref": r }), None => json!({ "applied": false }), } } async fn get_subject_status(s: Shared, p: Map) -> Result { let not_found = || err(400, "NotFound", "Subject not found"); let (did, uri, blob) = (opt(&p, "did"), opt(&p, "uri"), opt(&p, "blob")); let (out, wal, n) = if let Some(cid) = blob { let Some(did) = did else { return invalid("Must provide a did to request blob state"); }; let Some(a) = s.account(did) else { return not_found(); }; let mut st = write(&a.store); st.blobs.time(s.limits.clock.now(), s.config.blob_ttl); let Some(r) = st.blobs.held_takedown(cid) else { return not_found(); }; let out = json!({ "subject": { "$type": BLOB_REF, "did": a.did, "cid": cid }, "takedown": takedown_json(r) }); (out, st.wal.clone(), st.wal.written()) } else if let Some(uri) = uri { let Some((did, path)) = record_uri(uri) else { return not_found(); }; // As the reference answers a handle, whether or not an account has it. if !did.starts_with("did:") { return internal(); } let Some(a) = s.account(did) else { return not_found(); }; let Some(path) = path else { return not_found() }; let st = read(&a.store); let Some(rec) = st.record(&path) else { return not_found(); }; let cid = pds_repo::data::cid_string(&rec.cid); let out = json!({ "subject": { "$type": STRONG_REF, "uri": uri, "cid": cid }, "takedown": takedown_json(st.takedowns.get(&path).map(String::as_str)) }); (out, st.wal.clone(), st.wal.written()) } else if let Some(did) = did { let Some(a) = s.account(did) else { return not_found(); }; let state = read(&a.state).clone(); let out = json!({ "subject": { "$type": REPO_REF, "did": a.did }, "takedown": takedown_json(state.takedown.as_deref()), "deactivated": { "applied": state.deactivated }, }); (out, s.log.clone(), s.log.written()) } else { return invalid("No provided subject"); }; durable(wal, n).await?; Ok(Resp::Json(out)) } #[cfg(test)] mod tests;