//! Sessions' tokens, refreshing and ending sessions, and app passwords: //! `refreshSession`, `deleteSession`, `createAppPassword`, //! `listAppPasswords` and `revokeAppPassword`, as `spec/SESSIONS.md` says, //! within the bounds `spec/LIMITS.md` sets. //! //! Tokens are JWTs signed with HS256, by a secret the server makes once and //! keeps in `PDS_DATA_DIR/jwt.key`. An access token is checked by its //! signature and `exp` alone. A refresh token names, by its `jti`, a session //! the server keeps. Each account's sessions and app passwords are kept apart //! from every other's, behind a lock of their own, and each change to them is //! an entry in `accounts.log`, appended under that lock, so that the log has //! an account's changes in the order they were made, and on disk before the //! change is answered. A change is made in memory only once its entry is //! written. Sessions past their expiry are dropped whenever the account's //! sessions are touched, and as its account is loaded, with no entry: they //! are expired after a restart too. An account keeps at most `MAX_SESSIONS`; //! those dropped to keep it so are an entry of their own, in the frame of //! the change that made one too many. //! //! An account's sessions and app passwords are held once the account is //! loaded (`directory`), so every token checked loads the account it names //! before anything reads them (`known`). use crate::server::session_json; use crate::{ Call, Handler, Resp, Service, Shared, Shown, XrpcError, durable, err, internal, invalid_token, read, required, write, }; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD as B64; use hmac::{Hmac, Mac}; use pds_store::Wal; use serde_json::{Map, Value as Json, json}; use sha2::{Digest, Sha256}; use std::collections::HashMap; use std::io::Write; use std::path::Path; use std::sync::{Arc, Mutex, MutexGuard, PoisonError, RwLock}; use std::time::{SystemTime, UNIX_EPOCH}; /// The scope of a session made with the account's password. pub(crate) const ACCESS: &str = "com.atproto.access"; /// The scope of a session made with an app password. const APP_PASS: &str = "com.atproto.appPass"; /// The scope of a session made with a privileged app password. pub(crate) const APP_PASS_PRIVILEGED: &str = "com.atproto.appPassPrivileged"; /// Every refresh token's scope. const REFRESH: &str = "com.atproto.refresh"; /// The scope of the access token a taken-down account is given (`spec/LIFECYCLE.md`). pub(crate) const TAKENDOWN: &str = "com.atproto.takendown"; /// How long an access token works, in seconds. const ACCESS_LIFE: u64 = 2 * 60 * 60; /// How long a refresh token, and the session it is of, works. const REFRESH_LIFE: u64 = 90 * 24 * 60 * 60; /// How long a refreshed session's token keeps working, from when it is first refreshed. const GRACE: u64 = 2 * 60 * 60; /// The most sessions an account keeps. pub(crate) const MAX_SESSIONS: usize = 100; /// The most app passwords an account has. pub(crate) const MAX_APP_PASSWORDS: usize = 50; /// The file in the data directory that holds the secret tokens are signed with. pub(crate) const KEY_FILE: &str = "jwt.key"; /// The kinds of `accounts.log` entry this module keeps, each naming its account by `did`. pub(crate) const ENTRIES: &[&str] = &[ "session", "refresh", "endSession", "dropSessions", "appPassword", "revokeAppPassword", "dropAppPasswords", ]; /// What a request's `Authorization` header holds. #[derive(Clone, Copy, Debug)] pub(crate) enum Bearer<'a> { None, /// A `Bearer` token, its scheme in any case. Token(&'a str), /// A `Basic` header's credentials, which only the admin's methods take. Basic(&'a str), /// A `DPoP` header, the scheme in any case: an OAuth access token, not /// yet checked, which only `scopes::look` checks. DPoP(&'a str), /// An OAuth access token whose call passed `scopes::look`: its session. OAuth(&'a crate::scopes::Grant), /// A header that is not two words separated by one space, or whose scheme /// is none of `Bearer`, `Basic` and `DPoP`. Malformed, } impl<'a> Bearer<'a> { /// What an `Authorization` header's value holds. pub fn of(header: Option<&'a str>) -> Bearer<'a> { let Some(h) = header else { return Bearer::None }; let mut words = h.split(' '); let (Some(scheme), Some(credentials), None) = (words.next(), words.next(), words.next()) else { return Bearer::Malformed; }; if scheme.is_empty() || credentials.is_empty() { Bearer::Malformed } else if scheme.eq_ignore_ascii_case("bearer") { Bearer::Token(credentials) } else if scheme.eq_ignore_ascii_case("basic") { Bearer::Basic(credentials) } else if scheme.eq_ignore_ascii_case("dpop") { Bearer::DPoP(credentials) } else { Bearer::Malformed } } } /// A token the server signed, checked, or an OAuth session's. pub(crate) struct Token { /// Its account's DID. pub did: String, /// The session's scope: an OAuth session's scope tokens, separated by spaces. pub scope: String, /// A refresh token's session. pub jti: Option, /// Whether it is an OAuth session's. pub oauth: bool, } #[derive(Clone, Copy, PartialEq, Eq)] enum Kind { Access, /// An access token, or one a taken-down account was given (`spec/LIFECYCLE.md`). AccessOrTakendown, Refresh, } /// A session the server keeps. #[derive(Clone, Debug)] struct Session { /// The name of the app password it was made with, if it was. app: Option, scope: String, /// When its refresh tokens stop working, in seconds since the epoch. exp: u64, /// The session refreshing it made, once it is refreshed. next: Option, /// Where it comes among the account's sessions in the order they were /// made, as the log has them: of two that expire at once, the older /// is dropped first. made: u64, /// Whether the app password it was made with was dropped since /// (`dropAppPasswords`): it stays, of the scope it had. dropped: bool, } /// Sessions are the same whatever their place among others. impl PartialEq for Session { fn eq(&self, o: &Session) -> bool { (&self.app, &self.scope, self.exp, &self.next, self.dropped) == (&o.app, &o.scope, o.exp, &o.next, o.dropped) } } impl Eq for Session {} /// An app password, as kept. #[derive(Clone, Debug, PartialEq, Eq)] struct AppPassword { name: String, /// `sha256$`, in hex. hash: String, created_at: String, privileged: bool, } /// A map kept as a vector in order of key: for the few sessions an account /// keeps, one allocation, not a tree's node of room for many. #[derive(Clone, Debug, PartialEq, Eq)] struct Few(Vec<(String, V)>); impl Default for Few { fn default() -> Self { Few(Vec::new()) } } impl Few { fn at(&self, k: &str) -> Result { self.0.binary_search_by(|(x, _)| x.as_str().cmp(k)) } fn get(&self, k: &str) -> Option<&V> { self.at(k).ok().map(|i| &self.0[i].1) } fn get_mut(&mut self, k: &str) -> Option<&mut V> { self.at(k).ok().map(|i| &mut self.0[i].1) } fn contains_key(&self, k: &str) -> bool { self.at(k).is_ok() } fn insert(&mut self, k: String, v: V) -> Option { match self.at(&k) { Ok(i) => Some(std::mem::replace(&mut self.0[i].1, v)), Err(i) => { self.0.insert(i, (k, v)); None } } } fn remove(&mut self, k: &str) -> Option { self.at(k).ok().map(|i| self.0.remove(i).1) } fn retain(&mut self, mut f: impl FnMut(&String, &mut V) -> bool) { self.0.retain_mut(|(k, v)| f(k, v)); } fn iter(&self) -> impl Iterator { self.0.iter().map(|(k, v)| (k, v)) } fn keys(&self) -> impl Iterator { self.0.iter().map(|(k, _)| k) } fn values_mut(&mut self) -> impl Iterator { self.0.iter_mut().map(|(_, v)| v) } fn len(&self) -> usize { self.0.len() } fn clear(&mut self) { self.0.clear(); } } /// One account's sessions and app passwords. #[derive(Clone, Debug, Default)] pub(crate) struct Keep { sessions: Few, /// In the order they were made. passwords: Vec, /// How many sessions have been made, to give the next its place. made: u64, } /// Keeps are the same whatever count of sessions made led to them. impl PartialEq for Keep { fn eq(&self, o: &Keep) -> bool { let order = |k: &Keep| { let mut ids: Vec<(&u64, &String)> = k.sessions.iter().map(|(id, s)| (&s.made, id)).collect(); ids.sort(); ids.into_iter() .map(|(_, id)| id.clone()) .collect::>() }; self.sessions == o.sessions && self.passwords == o.passwords && order(self) == order(o) } } impl Eq for Keep {} impl Keep { /// Make the change an entry says, as it is logged and as it is replayed. pub(crate) fn apply(&mut self, e: &Json) -> Result<(), String> { let text = |k: &str| { e[k].as_str() .ok_or_else(|| format!("an entry with no {k}: {e}")) }; let number = |k: &str| { e[k].as_u64() .ok_or_else(|| format!("an entry with no {k}: {e}")) }; let optional = |k: &str| match e.get(k) { None | Some(Json::Null) => Ok(None), Some(Json::String(a)) => Ok(Some(a.clone())), _ => Err(format!("an entry with a bad {k}: {e}")), }; match e["t"].as_str() { Some("session") => { let id = text("id")?; let app = optional("app")?; let dropped = e.get("dropped").is_some_and(|d| d == true); let scope = match &app { None if dropped => { return Err(format!("a session dropped with no app password: {e}")); } None => ACCESS, // Of an app password since dropped, as a compacted log keeps it. Some(_) if dropped => match text("scope")? { s @ (APP_PASS | APP_PASS_PRIVILEGED) => s, _ => return Err(format!("a session of the wrong scope: {e}")), }, Some(a) => match self.passwords.iter().find(|p| &p.name == a) { Some(p) if p.privileged => APP_PASS_PRIVILEGED, Some(_) => APP_PASS, None => { return Err(format!( "a session of app password {a:?}, which the account does not have" )); } }, }; if text("scope")? != scope { return Err(format!("a session of the wrong scope: {e}")); } if self.sessions.contains_key(id) { return Err(format!("a second session {id}")); } // A compacted log keeps a refreshed session's successor with it. let next = optional("next")?; let made = self.made_one(); self.sessions.insert( id.to_string(), Session { app, scope: scope.to_string(), exp: number("exp")?, next, made, dropped, }, ); } Some("refresh") => { let (id, next, exp, next_exp) = ( text("id")?, text("next")?, number("exp")?, number("nextExp")?, ); let Some(s) = self.sessions.get_mut(id) else { return Err(format!("a refresh of session {id}, which is not kept")); }; if s.next.as_deref().is_some_and(|n| n != next) || next == id { return Err(format!("a second successor of session {id}: {e}")); } s.next = Some(next.to_string()); s.exp = exp; let (app, scope, dropped) = (s.app.clone(), s.scope.clone(), s.dropped); if !self.sessions.contains_key(next) { let made = self.made_one(); self.sessions.insert( next.to_string(), Session { app, scope, exp: next_exp, next: None, made, dropped, }, ); } } Some("endSession") => { let id = text("id")?; if self.sessions.remove(id).is_none() { return Err(format!("the end of session {id}, which is not kept")); } } Some("dropSessions") => { let ids = e["ids"] .as_array() .ok_or_else(|| format!("an entry with no ids: {e}"))?; for id in ids { let id = id .as_str() .ok_or_else(|| format!("a session id that is not a string: {e}"))?; if self.sessions.remove(id).is_none() { return Err(format!("the drop of session {id}, which is not kept")); } } } Some("appPassword") => { let name = text("name")?; let Some(privileged) = e["privileged"].as_bool() else { return Err(format!("an app password with no privileged: {e}")); }; if self.passwords.iter().any(|p| p.name == name) { return Err(format!("a second app password {name:?}")); } self.passwords.push(AppPassword { name: name.to_string(), hash: text("hash")?.to_string(), created_at: text("createdAt")?.to_string(), privileged, }); } Some("revokeAppPassword") => { let name = text("name")?; let before = self.passwords.len(); self.passwords.retain(|p| p.name != name); if self.passwords.len() == before { return Err(format!( "a revocation of app password {name:?}, which the account does not have" )); } self.sessions.retain(|_, s| s.app.as_deref() != Some(name)); } Some("dropAppPasswords") => { if self.passwords.is_empty() { return Err(format!( "a drop of the app passwords of an account with none: {e}" )); } // The sessions made with them stay, as the reference keeps them. self.passwords.clear(); for s in self.sessions.values_mut().filter(|s| s.app.is_some()) { s.dropped = true; } } t => return Err(format!("a log entry of no known type: {t:?}")), } Ok(()) } /// Drop the sessions past their expiry at `now`. fn prune(&mut self, now: u64) { self.sessions.retain(|_, s| s.exp > now); } /// The next place in the order sessions are made. fn made_one(&mut self) -> u64 { self.made += 1; self.made } /// The sessions to drop to keep `MAX_SESSIONS`: the refreshed ones, whose /// old tokens are in their grace, first, then those that expire soonest, /// and of those that expire at once, the oldest. fn overflow(&self) -> Vec { let Some(over) = self .sessions .len() .checked_sub(MAX_SESSIONS) .filter(|n| *n > 0) else { return vec![]; }; let mut order: Vec<(&String, &Session)> = self.sessions.iter().collect(); order.sort_by_key(|(_, s)| (s.next.is_none(), s.exp, s.made)); order .into_iter() .take(over) .map(|(id, _)| id.clone()) .collect() } /// The app password whose digest this is, compared with every one the /// account has, each in constant time. fn app_password(&self, digest: &[u8; 32]) -> Option<&AppPassword> { self.passwords.iter().fold(None, |found, p| { let want = p .hash .strip_prefix("sha256$") .and_then(|h| hex::decode(h).ok()) .unwrap_or_default(); let same = want.len() == 32 && want .iter() .zip(digest) .fold(0u8, |acc, (a, b)| acc | (a ^ b)) == 0; if same { Some(p) } else { found } }) } /// The entries that make this keep again, for a compacted log: its app /// passwords, then its sessions but those that expired before `before`, /// in the order they were made. pub(crate) fn entries(&self, did: &str, before: u64) -> Vec { let passwords = self.passwords.iter().map(|p| { json!({ "t": "appPassword", "did": did, "name": p.name, "hash": p.hash, "createdAt": p.created_at, "privileged": p.privileged }) }); let mut kept: Vec<(&String, &Session)> = self .sessions .iter() .filter(|(_, s)| s.exp > before) .collect(); kept.sort_by_key(|(_, s)| s.made); let sessions = kept.into_iter().map(|(id, s)| { let mut e = json!({ "t": "session", "did": did, "id": id, "app": s.app, "scope": s.scope, "exp": s.exp, "next": s.next }); if s.dropped { e["dropped"] = json!(true); } e }); passwords.chain(sessions).collect() } } /// The sessions the server gave out, and the accounts' app passwords. pub(crate) struct Sessions { /// The secret every token is signed with. key: [u8; 32], /// The server's DID, every token's audience. aud: String, /// Each account's, by DID. keeps: RwLock>>>, /// Seconds added to the clock, for tests to see tokens expire. #[cfg(test)] pub skew: std::sync::atomic::AtomicU64, /// The time the clock stands at, for tests that need it to stand /// still; 0 while it runs. #[cfg(test)] frozen: std::sync::atomic::AtomicU64, } fn lock(k: &Mutex) -> MutexGuard<'_, Keep> { k.lock().unwrap_or_else(PoisonError::into_inner) } /// Make a change to an account's keep, under its lock, and log it: `main`, /// after `entries` in one frame, and, should it leave the account more than /// `MAX_SESSIONS`, the drop of those `Keep::overflow` names. The keep changes /// only once the frame is written. Answers the frame. fn change( log: &Wal, k: &mut Keep, did: &str, mut entries: Vec, main: Json, ) -> std::io::Result { let mut next = k.clone(); next.apply(&main) .unwrap_or_else(|why| panic!("a change made under its account's lock: {why}")); entries.push(main); let dropped = next.overflow(); if !dropped.is_empty() { let d = json!({ "t": "dropSessions", "did": did, "ids": dropped }); next.apply(&d) .unwrap_or_else(|why| panic!("dropping sessions under their account's lock: {why}")); entries.push(d); } let n = log.append(&entries)?; *k = next; Ok(n) } /// A change that could not be logged, as it is answered. fn not_logged(e: std::io::Error) -> Result { crate::ops::failed("writing accounts.log failed", e); internal() } /// A new session's id. fn new_id() -> String { hex::encode(rand::random::<[u8; 16]>()) } /// An app password: four groups of four lower case letters or digits 2 to 7. fn new_app_password() -> String { const ALPHABET: &[u8; 32] = b"abcdefghijklmnopqrstuvwxyz234567"; let chars: Vec = rand::random::<[u8; 16]>() .iter() .map(|b| char::from(ALPHABET[usize::from(b & 31)])) .collect(); chars .chunks(4) .map(|c| c.iter().collect::()) .collect::>() .join("-") } /// What an app password is kept as, and what `createSession` compares: its /// SHA-256, not scrypt, and unsalted. Each is 80 random bits, beyond /// guessing, and one digest of what `createSession` is given is compared /// with every one an account has, so a login computes one hash for them /// however many it has. pub(crate) fn app_password_digest(password: &str) -> [u8; 32] { Sha256::digest(password.as_bytes()).into() } fn hash_app_password(password: &str) -> String { format!("sha256${}", hex::encode(app_password_digest(password))) } /// The secret tokens are signed with: read from `dir`, or made there if the /// server is starting for the first time, written whole or not at all. fn secret(dir: &Path, fresh: bool) -> Result<[u8; 32], String> { let path = dir.join(KEY_FILE); match std::fs::read(&path) { Ok(bytes) => bytes .try_into() .map_err(|_| format!("{KEY_FILE} is not 32 bytes")), Err(e) if e.kind() == std::io::ErrorKind::NotFound && fresh => { let key: [u8; 32] = rand::random(); let tmp = dir.join(format!("{KEY_FILE}.tmp")); let made = (|| { let mut f = pds_store::open_private( &tmp, std::fs::OpenOptions::new() .create(true) .write(true) .truncate(true), )?; f.write_all(&key)?; pds_store::sync_file(&f)?; std::fs::rename(&tmp, &path)?; pds_store::sync_dir(dir) })(); made.map_err(|e| format!("{KEY_FILE}: {e}"))?; Ok(key) } Err(e) if e.kind() == std::io::ErrorKind::NotFound => Err(format!( "{KEY_FILE} is missing, and the sessions given out were signed with it" )), Err(e) => Err(format!("{KEY_FILE}: {e}")), } } type HmacSha256 = Hmac; impl Sessions { /// A server's sessions, with none kept yet and its key not read yet /// (`keyed`): what a start replays its sessions into before it knows /// whether the data directory is new. pub fn unkeyed(hostname: &str) -> Sessions { Sessions { key: [0; 32], aud: format!("did:web:{hostname}"), keeps: RwLock::default(), #[cfg(test)] skew: Default::default(), #[cfg(test)] frozen: Default::default(), } } /// Its secret, read from `dir`, or made if `fresh`, when the server has /// kept nothing before. pub fn keyed(&mut self, dir: &Path, fresh: bool) -> Result<(), String> { self.key = secret(dir, fresh)?; Ok(()) } /// The time, in seconds since the epoch. pub fn now(&self) -> u64 { let now = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() .as_secs(); #[cfg(test)] let now = match self.frozen.load(std::sync::atomic::Ordering::SeqCst) { 0 => now, frozen => frozen, } + self.skew.load(std::sync::atomic::Ordering::SeqCst); now } /// The time, in milliseconds since the epoch, on the clock `now` reads. pub fn now_ms(&self) -> u64 { let now = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default(); #[cfg(test)] let now = match self.frozen.load(std::sync::atomic::Ordering::SeqCst) { 0 => now, frozen => std::time::Duration::from_secs(frozen), } + std::time::Duration::from_secs(self.skew.load(std::sync::atomic::Ordering::SeqCst)); u64::try_from(now.as_millis()).unwrap_or(u64::MAX) } /// Stop the clock where it is, but for what `skew` adds: a test then /// sees a token expire at exactly the second it should. #[cfg(test)] pub fn freeze(&self) { let now = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() .as_secs(); self.frozen.store(now, std::sync::atomic::Ordering::SeqCst); } fn mac(&self, header: &str, claims: &str) -> HmacSha256 { let mut mac = HmacSha256::new_from_slice(&self.key).expect("HMAC takes a key of any length"); mac.update(header.as_bytes()); mac.update(b"."); mac.update(claims.as_bytes()); mac } fn sign(&self, typ: &str, claims: &Json) -> String { let header = B64.encode(json!({ "typ": typ, "alg": "HS256" }).to_string()); let claims = B64.encode(claims.to_string()); let sig = B64.encode(self.mac(&header, &claims).finalize().into_bytes()); format!("{header}.{claims}.{sig}") } /// The `typ` and claims of a token this server signed. fn verify(&self, token: &str) -> Option<(String, Map)> { let mut parts = token.split('.'); let (Some(header), Some(claims), Some(sig), None) = (parts.next(), parts.next(), parts.next(), parts.next()) else { return None; }; self.mac(header, claims) .verify_slice(&B64.decode(sig).ok()?) .ok()?; let header: Json = serde_json::from_slice(&B64.decode(header).ok()?).ok()?; if header["alg"] != "HS256" { return None; } let Json::Object(claims) = serde_json::from_slice(&B64.decode(claims).ok()?).ok()? else { return None; }; Some((header["typ"].as_str()?.to_string(), claims)) } /// A token of `kind`: `InvalidToken` if the server did not sign it or it /// is of the other kind, then `ExpiredToken` if it is past its `exp`, /// unless `expired_ok`. fn check(&self, token: &str, kind: Kind, expired_ok: bool) -> Result { let Some((typ, c)) = self.verify(token) else { return invalid_token(); }; let text = |k: &str| c.get(k).and_then(Json::as_str); let (Some(did), Some(scope), Some(exp)) = ( text("sub"), text("scope"), c.get("exp").and_then(Json::as_u64), ) else { return invalid_token(); }; let jti = text("jti").map(str::to_string); let right = match kind { Kind::Access => { typ == "at+jwt" && [ACCESS, APP_PASS, APP_PASS_PRIVILEGED].contains(&scope) && jti.is_none() } Kind::AccessOrTakendown => { typ == "at+jwt" && [ACCESS, APP_PASS, APP_PASS_PRIVILEGED, TAKENDOWN].contains(&scope) && jti.is_none() } Kind::Refresh => typ == "refresh+jwt" && scope == REFRESH && jti.is_some(), }; if !right || text("aud") != Some(self.aud.as_str()) { return invalid_token(); } if !expired_ok && self.now() >= exp { return expired(); } crate::ops::verified(did); Ok(Token { did: did.to_string(), scope: scope.to_string(), jti, oauth: false, }) } /// An access token of a session of `scope`, and a refresh token of session `jti`, made at `now`. fn tokens(&self, did: &str, scope: &str, jti: &str, now: u64) -> (String, String) { let access = json!({ "scope": scope, "sub": did, "aud": self.aud, "iat": now, "exp": now + ACCESS_LIFE }); let refresh = json!({ "scope": REFRESH, "sub": did, "aud": self.aud, "jti": jti, "iat": now, "exp": now + REFRESH_LIFE }); ( self.sign("at+jwt", &access), self.sign("refresh+jwt", &refresh), ) } /// An account's sessions and app passwords. fn keep(&self, did: &str) -> Arc> { if let Some(k) = read(&self.keeps).get(did) { return k.clone(); } write(&self.keeps) .entry(did.to_string()) .or_default() .clone() } /// An account's sessions and app passwords, as its entries of the /// service log leave them, without the sessions past their expiry at /// `now`: what an account loaded has (`directory`). pub fn put(&self, did: &str, mut keep: Keep, now: u64) { keep.prune(now); write(&self.keeps).insert(did.to_string(), Arc::new(Mutex::new(keep))); } /// Start a session of an account's, made with its password or, given /// `app_password`, the digest of what may be an app password of its: /// logged after `before`, in one frame. Answers its access and refresh /// tokens and the frame, or None if `app_password` is none of the /// account's. pub fn start( &self, log: &Wal, did: &str, app_password: Option<&[u8; 32]>, before: Vec, ) -> std::io::Result> { let (id, now) = (new_id(), self.now()); let keep = self.keep(did); let mut k = lock(&keep); k.prune(now); let (app, scope) = match app_password { None => (None, ACCESS), Some(digest) => { let Some(p) = k.app_password(digest) else { return Ok(None); }; ( Some(p.name.clone()), if p.privileged { APP_PASS_PRIVILEGED } else { APP_PASS }, ) } }; let session = json!({ "t": "session", "did": did, "id": id, "app": app, "scope": scope, "exp": now + REFRESH_LIFE }); let n = change(log, &mut k, did, before, session)?; drop(k); let (access, refresh) = self.tokens(did, scope, &id, now); Ok(Some((access, refresh, n))) } /// Whether `digest` is that of one of the account's app passwords. pub fn has_app_password(&self, did: &str, digest: &[u8; 32]) -> bool { lock(&self.keep(did)).app_password(digest).is_some() } /// End every session an account has, as `deleteSession` ends one, logged /// after `before`, in one frame. The keep changes only once the frame is /// written. Answers the frame. pub fn end_all(&self, log: &Wal, did: &str, mut before: Vec) -> std::io::Result { let keep = self.keep(did); let mut k = lock(&keep); let ended: Vec = k .sessions .keys() .map(|id| json!({ "t": "endSession", "did": did, "id": id })) .collect(); before.extend(ended); let n = log.append(&before)?; k.sessions.clear(); Ok(n) } /// Delete every app password an account has, keeping the sessions made /// with them, logged after `before`, in one frame, as a deactivation /// with an OAuth token does (`spec/LIFECYCLE.md`). The keep changes only /// once the frame is written. Answers the frame. pub fn drop_app_passwords( &self, log: &Wal, did: &str, mut before: Vec, ) -> std::io::Result { let keep = self.keep(did); let mut k = lock(&keep); if k.passwords.is_empty() { return log.append(&before); } let drop = json!({ "t": "dropAppPasswords", "did": did }); let mut next = k.clone(); next.apply(&drop) .unwrap_or_else(|why| panic!("a change made under its account's lock: {why}")); before.push(drop); let n = log.append(&before)?; *k = next; Ok(n) } /// The tokens of a taken-down account's session, which is not kept: an /// access token of scope `com.atproto.takendown`, and a refresh token /// whose session is none, so that refreshing with it ends no sooner than /// at its account's state. pub fn takendown_tokens(&self, did: &str) -> (String, String) { self.tokens(did, TAKENDOWN, &new_id(), self.now()) } /// Forget a deleted account's sessions and app passwords, logged with its deletion. pub fn forget(&self, did: &str) { write(&self.keeps).remove(did); } /// Each account's keep, to compare across restarts and compactions. #[cfg(test)] pub fn snapshot(&self) -> std::collections::BTreeMap { read(&self.keeps) .iter() .map(|(did, k)| (did.clone(), lock(k).clone())) .filter(|(_, k)| *k != Keep::default()) .collect() } /// How many sessions an account keeps. #[cfg(test)] pub fn count(&self, did: &str) -> usize { lock(&self.keep(did)).sessions.len() } } pub(crate) fn handler(nsid: &str) -> Option { Some(match nsid { "com.atproto.server.refreshSession" => { Handler::Authed(refresh_token, |s, t, _| Box::pin(refresh_session(s, t))) } "com.atproto.server.deleteSession" => { Handler::Authed(ending_token, |s, t, _| Box::pin(delete_session(s, t))) } "com.atproto.server.createAppPassword" => Handler::Authed(full_access_token, |s, t, b| { Box::pin(create_app_password(s, t, b)) }), "com.atproto.server.listAppPasswords" => Handler::Query(list_app_passwords), "com.atproto.server.revokeAppPassword" => Handler::Authed(access_token, |s, t, b| { Box::pin(revoke_app_password(s, t, b)) }), _ => return None, }) } fn auth_missing() -> Result { err(401, "AuthMissing", "Authentication Required") } pub(crate) fn expired() -> Result { err(400, "ExpiredToken", "Token has expired") } /// A token checked, its account loaded if there is one: what is kept of an /// account, its sessions, app passwords and preferences among it, is held /// from then on. fn known(s: &Service, t: Token) -> Token { s.account(&t.did); t } /// An access token, as every method that takes a token but /// `refreshSession` and `deleteSession` takes one: an OAuth access token /// too, once its call passed `scopes::look`. pub(crate) fn access_token(s: &Service, b: Bearer) -> Result { match b { Bearer::None => auth_missing(), Bearer::Token(t) => Ok(known(s, s.sessions.check(t, Kind::Access, false)?)), Bearer::OAuth(g) => Ok(known( s, Token { did: g.did.clone(), scope: g.scope.text().to_string(), jti: None, oauth: true, }, )), Bearer::Basic(_) | Bearer::DPoP(_) | Bearer::Malformed => invalid_token(), } } /// An access token, or a taken-down account's, as `deactivateAccount` and /// the sync reads of a repository's own account take. pub(crate) fn takendown_ok_token(s: &Service, b: Bearer) -> Result { match b { Bearer::None => auth_missing(), Bearer::Token(t) => Ok(known( s, s.sessions.check(t, Kind::AccessOrTakendown, false)?, )), Bearer::OAuth(_) => access_token(s, b), Bearer::Basic(_) | Bearer::DPoP(_) | Bearer::Malformed => invalid_token(), } } /// The token `deactivateAccount` takes: of a session made with the account's /// password, or of a taken-down account's; not an app password's. pub(crate) fn deactivating_token(s: &Service, b: Bearer) -> Result { let t = takendown_ok_token(s, b)?; if !matches!(b, Bearer::OAuth(_)) && t.scope != ACCESS && t.scope != TAKENDOWN { return invalid_token(); } Ok(t) } /// An access token of a session made with the account's password, not an /// app password, as `createAppPassword` and `getAccountInviteCodes` take. pub(crate) fn full_access_token(s: &Service, b: Bearer) -> Result { let t = access_token(s, b)?; if t.scope != ACCESS { return invalid_token(); } Ok(t) } /// A refresh token, by `Bearer` alone: a `Basic` or `DPoP` header is as none. fn refresh(s: &Service, b: Bearer, expired_ok: bool) -> Result { match b { Bearer::None | Bearer::Basic(_) | Bearer::DPoP(_) | Bearer::OAuth(_) => auth_missing(), Bearer::Token(t) => Ok(known(s, s.sessions.check(t, Kind::Refresh, expired_ok)?)), Bearer::Malformed => invalid_token(), } } fn refresh_token(s: &Service, b: Bearer) -> Result { refresh(s, b, false) } /// A refresh token for `deleteSession`, which takes one past its `exp` all the same. fn ending_token(s: &Service, b: Bearer) -> Result { refresh(s, b, true) } async fn refresh_session(s: Shared, t: Token) -> Result { let Some(account) = s.account(&t.did) else { return invalid_token(); }; let id = t.jti.unwrap_or_default(); let now = s.sessions.now(); let (next, scope, n) = { let keep = s.sessions.keep(&t.did); let mut k = lock(&keep); k.prune(now); let Some(old) = k.sessions.get(&id) else { return expired(); }; let next = old.next.clone().unwrap_or_else(new_id); let exp = old.exp.min(now + GRACE); let scope = old.scope.clone(); let unchanged = old.next.as_ref() == Some(&next) && old.exp == exp && k.sessions.contains_key(&next); // What this answers may have been logged by another refresh: it is // answered once that is on disk. let n = if unchanged { s.log.written() } else { let entry = json!({ "t": "refresh", "did": t.did, "id": id, "next": next, "exp": exp, "nextExp": now + REFRESH_LIFE }); change(&s.log, &mut k, &t.did, vec![], entry).or_else(not_logged)? }; (next, scope, n) }; durable(s.log.clone(), n).await?; let (access, refresh) = s.sessions.tokens(&t.did, &scope, &next, now); let mut out = session_json(&account); out["accessJwt"] = json!(access); out["refreshJwt"] = json!(refresh); Ok(Resp::Json(out)) } async fn delete_session(s: Shared, t: Token) -> Result { let id = t.jti.unwrap_or_default(); let n = { let keep = s.sessions.keep(&t.did); let mut k = lock(&keep); k.prune(s.sessions.now()); if k.sessions.contains_key(&id) { change( &s.log, &mut k, &t.did, vec![], json!({ "t": "endSession", "did": t.did, "id": id }), ) .or_else(not_logged)? } else { s.log.written() } }; durable(s.log.clone(), n).await?; Ok(Resp::Nothing) } async fn create_app_password(s: Shared, t: Token, b: Map) -> Result { let name = required(&b, "name")?.to_string(); let privileged = b.get("privileged").and_then(Json::as_bool).unwrap_or(false); let password = new_app_password(); let entry = json!({ "t": "appPassword", "did": t.did, "name": name, "hash": hash_app_password(&password), "createdAt": crate::events::timestamp(), "privileged": privileged, }); let created_at = entry["createdAt"].clone(); let n = { let keep = s.sessions.keep(&t.did); let mut k = lock(&keep); if k.passwords.len() >= MAX_APP_PASSWORDS { return err( 400, "TooManyAppPasswords", format!("Too many app passwords. Max: {MAX_APP_PASSWORDS}"), ); } // As the reference answers a name the account has already. if k.passwords.iter().any(|p| p.name == name) { return internal(); } change(&s.log, &mut k, &t.did, vec![], entry).or_else(not_logged)? }; durable(s.log.clone(), n).await?; Ok(Resp::Json( json!({ "name": name, "password": password, "createdAt": created_at, "privileged": privileged }), )) } fn list_app_passwords( s: &Service, call: &Call, shown: &mut Shown, _: &Map, ) -> Result { let t = access_token(s, call.bearer)?; let keep = s.sessions.keep(&t.did); let passwords: Vec = lock(&keep) .passwords .iter() .rev() .map(|p| json!({ "name": p.name, "createdAt": p.created_at, "privileged": p.privileged })) .collect(); shown.0.push((s.log.clone(), s.log.written())); Ok(Resp::Json(json!({ "passwords": passwords }))) } async fn revoke_app_password(s: Shared, t: Token, b: Map) -> Result { let name = required(&b, "name")?; let n = { let keep = s.sessions.keep(&t.did); let mut k = lock(&keep); k.prune(s.sessions.now()); if k.passwords.iter().any(|p| p.name == name) { change( &s.log, &mut k, &t.did, vec![], json!({ "t": "revokeAppPassword", "did": t.did, "name": name }), ) .or_else(not_logged)? } else { s.log.written() } }; durable(s.log.clone(), n).await?; Ok(Resp::Nothing) } #[cfg(test)] mod tests { use super::*; use crate::testing::*; use std::sync::atomic::Ordering::SeqCst; const LOGIN: &str = "com.atproto.server.createSession"; const GET: &str = "com.atproto.server.getSession"; const REFRESH_SESSION: &str = "com.atproto.server.refreshSession"; const DELETE: &str = "com.atproto.server.deleteSession"; const CREATE_APP: &str = "com.atproto.server.createAppPassword"; const LIST_APP: &str = "com.atproto.server.listAppPasswords"; const REVOKE_APP: &str = "com.atproto.server.revokeAppPassword"; /// A JWT's header and claims. fn decode(token: &str) -> (Json, Json) { let parts: Vec<&str> = token.split('.').collect(); assert_eq!(parts.len(), 3, "{token}"); let part = |p: &str| serde_json::from_slice::(&B64.decode(p).unwrap()).unwrap(); (part(parts[0]), part(parts[1])) } fn jti(refresh: &str) -> String { decode(refresh).1["jti"].as_str().unwrap().to_string() } fn tokens(got: &Json) -> (String, String) { ( got["accessJwt"].as_str().unwrap().to_string(), got["refreshJwt"].as_str().unwrap().to_string(), ) } async fn login(s: &Shared, id: &str, pw: &str) -> Result<(String, String), String> { Ok(tokens( &call(s, LOGIN, None, json!({ "identifier": id, "password": pw })).await?, )) } async fn refresh(s: &Shared, token: &str) -> Result<(String, String), String> { Ok(tokens( &call(s, REFRESH_SESSION, Some(token), Json::Null).await?, )) } fn put(did: &str, rkey: &str) -> Json { json!({ "repo": did, "collection": "a.b.c", "rkey": rkey, "record": record(1) }) } fn scope(access: &str) -> String { decode(access).1["scope"].as_str().unwrap().to_string() } /// Every token is a JWT with exactly the claims `SESSIONS.md` lists. #[tokio::test] async fn tokens_are_jwts() { let plc = plc().await; let dir = scratch("jwt-claims"); let s = open(&dir, &plc); let before = s.sessions.now(); let made = call( &s, "com.atproto.server.createAccount", None, json!({ "handle": "alice.test", "email": "a@mail.com", "password": "pw" }), ) .await .unwrap(); let did = made["did"].as_str().unwrap().to_string(); let from_login = login(&s, "alice.test", "pw").await.unwrap(); let refreshed = refresh(&s, &from_login.1).await.unwrap(); let after = s.sessions.now(); let mut jtis = Vec::new(); for (access, refresh) in [tokens(&made), from_login, refreshed] { let (h, c) = decode(&access); assert_eq!(h["typ"], "at+jwt"); assert_eq!(h["alg"], "HS256"); let mut keys: Vec<&String> = c.as_object().unwrap().keys().collect(); keys.sort(); assert_eq!(keys, ["aud", "exp", "iat", "scope", "sub"]); assert_eq!( (c["scope"].as_str(), c["sub"].as_str(), c["aud"].as_str()), (Some(ACCESS), Some(did.as_str()), Some("did:web:localhost")) ); let iat = c["iat"].as_u64().unwrap(); assert!((before..=after).contains(&iat)); assert_eq!(c["exp"].as_u64().unwrap() - iat, 7200); let (h, c) = decode(&refresh); assert_eq!(h["typ"], "refresh+jwt"); let mut keys: Vec<&String> = c.as_object().unwrap().keys().collect(); keys.sort(); assert_eq!(keys, ["aud", "exp", "iat", "jti", "scope", "sub"]); assert_eq!( (c["scope"].as_str(), c["sub"].as_str(), c["aud"].as_str()), (Some(REFRESH), Some(did.as_str()), Some("did:web:localhost")) ); let iat = c["iat"].as_u64().unwrap(); assert!((before..=after).contains(&iat)); assert_eq!(c["exp"].as_u64().unwrap() - iat, 7_776_000); jtis.push(jti(&refresh)); } jtis.sort(); jtis.dedup(); assert_eq!(jtis.len(), 3); let _ = std::fs::remove_dir_all(&dir); } /// The wrong token, or the wrong header, is refused, before the input is looked at. #[tokio::test] async fn wrong_tokens() { let plc = plc().await; let dir = scratch("jwt-wrong"); let s = open(&dir, &plc); let (did, access) = create(&s, "alice").await; let (_, refresh_jwt) = login(&s, "alice.test", "alice-pw").await.unwrap(); let bad = |e: &str| Err::(e.to_string()); // A refresh token where an access token is wanted, and the other way round. for (nsid, body) in [ (GET, json!({})), ("com.atproto.repo.putRecord", put(&did, "x")), (CREATE_APP, json!({ "name": "x" })), (LIST_APP, json!({})), (REVOKE_APP, json!({ "name": "x" })), ] { assert_eq!( call(&s, nsid, Some(&refresh_jwt), body).await, bad("InvalidToken"), "{nsid}" ); } for nsid in [REFRESH_SESSION, DELETE] { assert_eq!( call(&s, nsid, Some(&access), Json::Null).await, bad("InvalidToken"), "{nsid}" ); assert_eq!( call(&s, nsid, None, Json::Null).await, bad("AuthMissing"), "{nsid}" ); } // Claims changed after signing, `alg: none`, and a token never given out. let parts: Vec<&str> = access.split('.').collect(); let (_, mut claims) = decode(&access); claims["sub"] = json!("did:plc:aaaaaaaaaaaaaaaaaaaaaaaa"); let changed = format!( "{}.{}.{}", parts[0], B64.encode(claims.to_string()), parts[2] ); let none_header = B64.encode(json!({ "typ": "at+jwt", "alg": "none" }).to_string()); for forged in [ changed, format!("{none_header}.{}.", parts[1]), format!("{none_header}.{}.{}", parts[1], parts[2]), "never-given-out".into(), ] { assert_eq!( call(&s, GET, Some(&forged), json!({})).await, bad("InvalidToken"), "{forged}" ); assert_eq!( call( &s, "com.atproto.repo.putRecord", Some(&forged), put(&did, "x") ) .await, bad("InvalidToken") ); } // The header's scheme in any case; Basic, three words or another scheme. let raw = |nsid: &'static str, header: String, body: &'static str| { let s = s.clone(); async move { call_raw(&s, nsid, Bearer::of(Some(&header)), &[], body) .await .map(|_| ()) } }; assert_eq!(raw(GET, format!("bearer {access}"), "").await, Ok(())); assert_eq!(raw(LIST_APP, format!("BeArEr {access}"), "").await, Ok(())); assert_eq!( raw(GET, format!("Basic {access}"), "").await, Err("InvalidToken".into()) ); assert_eq!( raw(CREATE_APP, format!("Basic {access}"), "{}").await, Err("InvalidToken".into()) ); for nsid in [REFRESH_SESSION, DELETE] { assert_eq!( raw(nsid, format!("Basic {refresh_jwt}"), "").await, Err("AuthMissing".into()), "{nsid}" ); assert_eq!( raw(nsid, format!("DPoP {refresh_jwt}"), "").await, Err("AuthMissing".into()), "{nsid}" ); assert_eq!( raw(nsid, format!("Bearer {refresh_jwt} x"), "").await, Err("InvalidToken".into()), "{nsid}" ); assert_eq!( raw(nsid, format!("Bearer {refresh_jwt}"), "").await, Err("InvalidToken".into()), "{nsid}" ); assert_eq!( raw(nsid, format!("Token {refresh_jwt}"), "").await, Err("InvalidToken".into()), "{nsid}" ); // A body, after the token is checked. assert_eq!( raw(nsid, format!("Bearer {access}"), "{}").await, Err("InvalidToken".into()), "{nsid}" ); assert_eq!( raw(nsid, format!("Bearer {refresh_jwt}"), "{}").await, Err("InvalidRequest".into()), "{nsid}" ); } for header in [ format!("Bearer {access} x"), "Bearer".into(), String::new(), format!("DPoP {access}"), ] { assert_eq!( raw(GET, header.clone(), "").await, Err("InvalidToken".into()), "{header}" ); } assert_eq!( raw(REFRESH_SESSION, format!("bearer {refresh_jwt}"), "").await, Ok(()) ); // The token before the input. assert_eq!( call(&s, CREATE_APP, Some("forged"), json!({ "name": 5 })).await, bad("InvalidToken") ); assert_eq!( call(&s, CREATE_APP, None, json!({ "name": 5 })).await, bad("AuthMissing") ); assert_eq!( call(&s, CREATE_APP, Some(&access), json!({ "name": 5 })).await, bad("InvalidRequest") ); assert_eq!( call(&s, REVOKE_APP, Some(&refresh_jwt), json!({})).await, bad("InvalidToken") ); assert_eq!( call(&s, REVOKE_APP, Some(&access), json!({})).await, bad("InvalidRequest") ); let _ = std::fs::remove_dir_all(&dir); } /// Tokens past their `exp`: the wrong kind is `InvalidToken` first, and /// `deleteSession` takes an expired refresh token. #[tokio::test] async fn expiry() { let plc = plc().await; let dir = scratch("jwt-expiry"); let s = open(&dir, &plc); // The clock stands still but for the skew, so a token's `exp` is reached exactly. s.sessions.freeze(); let (did, access) = create(&s, "alice").await; let (_, r0) = login(&s, "alice.test", "alice-pw").await.unwrap(); s.sessions.skew.store(ACCESS_LIFE - 1, SeqCst); call(&s, GET, Some(&access), json!({})).await.unwrap(); s.sessions.skew.store(ACCESS_LIFE, SeqCst); assert_eq!( call(&s, GET, Some(&access), json!({})).await, Err("ExpiredToken".into()) ); assert_eq!( call( &s, "com.atproto.repo.putRecord", Some(&access), put(&did, "x") ) .await, Err("ExpiredToken".into()) ); assert_eq!( call(&s, LIST_APP, Some(&access), json!({})).await, Err("ExpiredToken".into()) ); assert_eq!( call(&s, REFRESH_SESSION, Some(&access), Json::Null).await, Err("InvalidToken".into()) ); let (a1, r1) = refresh(&s, &r0).await.unwrap(); call(&s, GET, Some(&a1), json!({})).await.unwrap(); // Past the refresh token's 90 days. s.sessions.skew.store(ACCESS_LIFE + REFRESH_LIFE, SeqCst); assert_eq!(refresh(&s, &r1).await, Err("ExpiredToken".into())); assert_eq!( call(&s, GET, Some(&r1), json!({})).await, Err("InvalidToken".into()) ); assert_eq!( call(&s, DELETE, Some(&r1), Json::Null).await, Ok(Json::Null) ); // That ended its session. s.sessions.skew.store(ACCESS_LIFE, SeqCst); assert_eq!(refresh(&s, &r1).await, Err("ExpiredToken".into())); let _ = std::fs::remove_dir_all(&dir); } /// A refresh answers the session's successor, the same one each time, and /// the old token works for two hours from when it was first used. #[tokio::test] async fn rotation_and_grace() { let plc = plc().await; let dir = scratch("jwt-rotation"); let s = open(&dir, &plc); s.sessions.freeze(); create(&s, "alice").await; let (_, r0) = login(&s, "alice.test", "alice-pw").await.unwrap(); let (_, r1) = refresh(&s, &r0).await.unwrap(); assert_ne!(jti(&r1), jti(&r0)); assert_eq!(jti(&refresh(&s, &r0).await.unwrap().1), jti(&r1)); let (_, r2) = refresh(&s, &r1).await.unwrap(); assert!(jti(&r2) != jti(&r0) && jti(&r2) != jti(&r1)); assert_eq!(jti(&refresh(&s, &r1).await.unwrap().1), jti(&r2)); s.sessions.skew.store(GRACE - 1, SeqCst); assert_eq!(jti(&refresh(&s, &r0).await.unwrap().1), jti(&r1)); s.sessions.skew.store(GRACE, SeqCst); assert_eq!(refresh(&s, &r0).await, Err("ExpiredToken".into())); assert_eq!(refresh(&s, &r1).await, Err("ExpiredToken".into())); let (_, r3) = refresh(&s, &r2).await.unwrap(); // Refreshing again within the grace does not lengthen it. s.sessions.skew.store(GRACE + GRACE / 2, SeqCst); assert_eq!(jti(&refresh(&s, &r2).await.unwrap().1), jti(&r3)); s.sessions.skew.store(2 * GRACE, SeqCst); assert_eq!(refresh(&s, &r2).await, Err("ExpiredToken".into())); refresh(&s, &r3).await.unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// Refreshes at once with one token all succeed, with tokens of one session. #[tokio::test(flavor = "multi_thread", worker_threads = 4)] async fn concurrent_refreshes() { let plc = plc().await; let dir = scratch("jwt-concurrent"); let s = open(&dir, &plc); let (did, _) = create(&s, "alice").await; let (_, r0) = login(&s, "alice.test", "alice-pw").await.unwrap(); let calls: Vec<_> = (0..16) .map(|_| { let (s, r0) = (s.clone(), r0.clone()); tokio::spawn(async move { refresh(&s, &r0).await }) }) .collect(); let mut jtis = Vec::new(); for c in calls { jtis.push(jti(&c.await.unwrap().unwrap().1)); } jtis.dedup(); assert_eq!(jtis.len(), 1); // The session createAccount made, the login's, and its one successor. assert_eq!(s.sessions.snapshot()[&did].sessions.len(), 3); let _ = std::fs::remove_dir_all(&dir); } /// `deleteSession` ends that session alone, whether or not it is kept. #[tokio::test] async fn delete() { let plc = plc().await; let dir = scratch("jwt-delete"); let s = open(&dir, &plc); create(&s, "alice").await; let (a0, r0) = login(&s, "alice.test", "alice-pw").await.unwrap(); let (_, other) = login(&s, "alice.test", "alice-pw").await.unwrap(); let (_, r1) = refresh(&s, &r0).await.unwrap(); assert_eq!( call(&s, DELETE, Some(&r0), Json::Null).await, Ok(Json::Null) ); assert_eq!(refresh(&s, &r0).await, Err("ExpiredToken".into())); assert_eq!( call(&s, DELETE, Some(&r0), Json::Null).await, Ok(Json::Null) ); // Its access token, its successor and other sessions carry on. call(&s, GET, Some(&a0), json!({})).await.unwrap(); let (_, r2) = refresh(&s, &r1).await.unwrap(); refresh(&s, &other).await.unwrap(); // An ended successor is kept again by its predecessor's grace. assert_eq!( call(&s, DELETE, Some(&r2), Json::Null).await, Ok(Json::Null) ); assert_eq!(refresh(&s, &r2).await, Err("ExpiredToken".into())); let (_, again) = refresh(&s, &r1).await.unwrap(); assert_eq!(jti(&again), jti(&r2)); refresh(&s, &r2).await.unwrap(); let _ = std::fs::remove_dir_all(&dir); } fn is_app_password_form(p: &str) -> bool { let groups: Vec<&str> = p.split('-').collect(); groups.len() == 4 && groups.iter().all(|g| { g.len() == 4 && g.bytes() .all(|b| b.is_ascii_lowercase() || (b'2'..=b'7').contains(&b)) }) } /// App passwords made, listed, logged in with and revoked, and what their sessions may do. #[tokio::test] async fn app_passwords() { let plc = plc().await; let dir = scratch("app-passwords"); let s = open(&dir, &plc); let (did, full) = create(&s, "alice").await; let (_, bob) = create(&s, "bob").await; let phone = call(&s, CREATE_APP, Some(&full), json!({ "name": "phone" })) .await .unwrap(); let mut keys: Vec<&String> = phone.as_object().unwrap().keys().collect(); keys.sort(); assert_eq!(keys, ["createdAt", "name", "password", "privileged"]); assert_eq!( (&phone["name"], &phone["privileged"]), (&json!("phone"), &json!(false)) ); let pw = phone["password"].as_str().unwrap().to_string(); assert!(is_app_password_form(&pw), "{pw}"); assert!(phone["createdAt"].as_str().unwrap().ends_with('Z')); let odd = call( &s, CREATE_APP, Some(&full), json!({ "name": "", "privileged": true }), ) .await .unwrap(); assert_eq!( (&odd["name"], &odd["privileged"]), (&json!(""), &json!(true)) ); assert_ne!(odd["password"], phone["password"]); assert_eq!( call(&s, CREATE_APP, Some(&full), json!({ "name": "phone" })).await, Err("InternalServerError".into()) ); call(&s, CREATE_APP, Some(&bob), json!({ "name": "phone" })) .await .unwrap(); let listed = call(&s, LIST_APP, Some(&full), json!({})).await.unwrap(); assert_eq!( listed, json!({ "passwords": [ { "name": "", "createdAt": odd["createdAt"], "privileged": true }, { "name": "phone", "createdAt": phone["createdAt"], "privileged": false }, ] }) ); // Logging in with one, by handle, email or DID, exactly as given. for id in ["alice.test", "alice@mail.com", did.as_str()] { let (access, _) = login(&s, id, &pw).await.unwrap(); assert_eq!(scope(&access), APP_PASS); } for wrong in [pw.to_uppercase(), pw.replace('-', "")] { assert_eq!( login(&s, "alice.test", &wrong).await, Err("AuthenticationRequired".into()) ); } assert_eq!( login(&s, "bob.test", &pw).await, Err("AuthenticationRequired".into()) ); let (privileged, _) = login(&s, "alice.test", odd["password"].as_str().unwrap()) .await .unwrap(); assert_eq!(scope(&privileged), APP_PASS_PRIVILEGED); // Its session does what the account's own do, but make app passwords. let (app, app_refresh) = login(&s, "alice.test", &pw).await.unwrap(); for token in [&app, &privileged] { assert_eq!( call(&s, CREATE_APP, Some(token), json!({ "name": "new" })).await, Err("InvalidToken".into()) ); assert_eq!( call(&s, CREATE_APP, Some(token), json!({})).await, Err("InvalidToken".into()) ); call(&s, LIST_APP, Some(token), json!({})).await.unwrap(); } assert_eq!( call(&s, GET, Some(&app), json!({})).await.unwrap()["did"], json!(did) ); call( &s, "com.atproto.repo.putRecord", Some(&app), put(&did, "by-app"), ) .await .unwrap(); let (app2, app_refresh2) = refresh(&s, &app_refresh).await.unwrap(); assert_eq!(scope(&app2), APP_PASS); let (_, kept) = login(&s, "alice.test", "alice-pw").await.unwrap(); // Revoked with its own session: its sessions end, those refreshed from them too. assert_eq!( call(&s, REVOKE_APP, Some(&app), json!({ "name": "phone" })).await, Ok(Json::Null) ); assert_eq!(refresh(&s, &app_refresh).await, Err("ExpiredToken".into())); assert_eq!(refresh(&s, &app_refresh2).await, Err("ExpiredToken".into())); call(&s, GET, Some(&app2), json!({})).await.unwrap(); assert_eq!( login(&s, "alice.test", &pw).await, Err("AuthenticationRequired".into()) ); refresh(&s, &kept).await.unwrap(); assert_eq!( call(&s, REVOKE_APP, Some(&full), json!({ "name": "nothing" })).await, Ok(Json::Null) ); assert_eq!( call(&s, REVOKE_APP, Some(&full), json!({ "name": "phone" })).await, Ok(Json::Null) ); assert_eq!( call(&s, LIST_APP, Some(&full), json!({})).await.unwrap()["passwords"] .as_array() .unwrap() .len(), 1 ); // Bob's of the same name is his own. assert_eq!( call(&s, LIST_APP, Some(&bob), json!({})).await.unwrap()["passwords"][0]["name"], json!("phone") ); // Made again after its revocation. call(&s, CREATE_APP, Some(&full), json!({ "name": "phone" })) .await .unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// Of several at once with the same name, one is made. #[tokio::test(flavor = "multi_thread", worker_threads = 4)] async fn concurrent_app_passwords() { let plc = plc().await; let dir = scratch("app-concurrent"); let s = open(&dir, &plc); let (_, full) = create(&s, "alice").await; let calls: Vec<_> = (0..12) .map(|_| { let (s, full) = (s.clone(), full.clone()); tokio::spawn(async move { call(&s, CREATE_APP, Some(&full), json!({ "name": "same" })).await }) }) .collect(); let mut made = 0; for c in calls { match c.await.unwrap() { Ok(_) => made += 1, Err(e) => assert_eq!(e, "InternalServerError"), } } assert_eq!(made, 1); assert_eq!( call(&s, LIST_APP, Some(&full), json!({})).await.unwrap()["passwords"] .as_array() .unwrap() .len(), 1 ); let _ = std::fs::remove_dir_all(&dir); } /// An account with no password logs in with its app passwords, by handle or DID, not email. #[tokio::test] async fn no_password_app_passwords() { let plc = plc().await; let dir = scratch("app-nopw"); let s = open(&dir, &plc); let made = call( &s, "com.atproto.server.createAccount", None, json!({ "handle": "nopw.test", "email": "nopw@mail.com" }), ) .await .unwrap(); let (did, first) = ( made["did"].as_str().unwrap(), made["accessJwt"].as_str().unwrap(), ); let pw = call(&s, CREATE_APP, Some(first), json!({ "name": "only" })) .await .unwrap()["password"] .as_str() .unwrap() .to_string(); for id in ["nopw.test", did] { let (access, _) = login(&s, id, &pw).await.unwrap(); let got = call(&s, GET, Some(&access), json!({})).await.unwrap(); assert_eq!(got["did"], json!(did)); assert!(got.get("email").is_none()); } assert_eq!( login(&s, "nopw@mail.com", &pw).await, Err("AuthenticationRequired".into()) ); let _ = std::fs::remove_dir_all(&dir); } /// Sessions, their refreshes and ends, app passwords and their /// revocations all survive a restart, and so does the secret. #[tokio::test] async fn restart_keeps_sessions() { let plc = plc().await; let dir = scratch("sessions-restart"); let s = open(&dir, &plc); let (_, full) = create(&s, "alice").await; let (_, r0) = login(&s, "alice.test", "alice-pw").await.unwrap(); let (_, r1) = refresh(&s, &r0).await.unwrap(); let (_, ended) = login(&s, "alice.test", "alice-pw").await.unwrap(); call(&s, DELETE, Some(&ended), Json::Null).await.unwrap(); let pw = call( &s, CREATE_APP, Some(&full), json!({ "name": "phone", "privileged": true }), ) .await .unwrap()["password"] .as_str() .unwrap() .to_string(); let gone = call(&s, CREATE_APP, Some(&full), json!({ "name": "gone" })) .await .unwrap()["password"] .as_str() .unwrap() .to_string(); let (_, app_refresh) = login(&s, "alice.test", &pw).await.unwrap(); let (_, revoked) = login(&s, "alice.test", &gone).await.unwrap(); call(&s, REVOKE_APP, Some(&full), json!({ "name": "gone" })) .await .unwrap(); let listed = call(&s, LIST_APP, Some(&full), json!({})).await.unwrap(); let before = s.sessions.snapshot(); drop(s); let s = open(&dir, &plc); assert_eq!(s.sessions.snapshot(), before); assert_eq!( call(&s, LIST_APP, Some(&full), json!({})).await.unwrap(), listed ); assert_eq!(jti(&refresh(&s, &r0).await.unwrap().1), jti(&r1)); assert_eq!(refresh(&s, &ended).await, Err("ExpiredToken".into())); assert_eq!(refresh(&s, &revoked).await, Err("ExpiredToken".into())); let (app, _) = refresh(&s, &app_refresh).await.unwrap(); assert_eq!(scope(&app), APP_PASS_PRIVILEGED); login(&s, "alice.test", &pw).await.unwrap(); assert_eq!( login(&s, "alice.test", &gone).await, Err("AuthenticationRequired".into()) ); // Without its secret, the server does not start. drop(s); std::fs::remove_file(dir.join(KEY_FILE)).unwrap(); assert!(try_open(&dir, &plc).err().unwrap().contains(KEY_FILE)); let _ = std::fs::remove_dir_all(&dir); } /// An app password is found by one digest of what is given, among all the /// account has, exactly as given. #[test] fn app_password_hashes() { let mut k = Keep::default(); let pws: Vec = (0..3).map(|_| new_app_password()).collect(); for (i, pw) in pws.iter().enumerate() { assert!(is_app_password_form(pw), "{pw}"); let e = json!({ "t": "appPassword", "did": "d", "name": format!("p{i}"), "hash": hash_app_password(pw), "createdAt": "c", "privileged": false }); k.apply(&e).unwrap(); } for (i, pw) in pws.iter().enumerate() { assert_eq!( k.app_password(&app_password_digest(pw)) .map(|p| p.name.clone()), Some(format!("p{i}")) ); assert!( k.app_password(&app_password_digest(&pw.to_uppercase())) .is_none() ); } assert!(k.app_password(&app_password_digest("")).is_none()); k.passwords[0].hash = "nonsense".into(); assert!(k.app_password(&app_password_digest(&pws[0])).is_none()); } /// Sessions past their expiry are dropped when the account's sessions /// are next touched, and as the account is loaded, with nothing logged /// of it. #[tokio::test] async fn expired_sessions_are_dropped() { let plc = plc().await; let dir = scratch("sessions-expire"); let s = open(&dir, &plc); let (did, _) = create(&s, "alice").await; let (_, old) = login(&s, "alice.test", "alice-pw").await.unwrap(); assert_eq!(s.sessions.count(&did), 2); s.sessions.skew.store(10 * 24 * 60 * 60, SeqCst); let (_, young) = login(&s, "alice.test", "alice-pw").await.unwrap(); assert_eq!(s.sessions.count(&did), 3); // The first two expire; the third does not. s.sessions.skew.store(REFRESH_LIFE + 60, SeqCst); assert_eq!(refresh(&s, &old).await, Err("ExpiredToken".into())); let log_len = s.log.len() as usize; // Touched: they are dropped, and only the new session is logged. login(&s, "alice.test", "alice-pw").await.unwrap(); assert_eq!(s.sessions.count(&did), 2); let logged = pds_store::scan(&std::fs::read(crate::log::accounts_log(&dir)).unwrap()[log_len..]) .unwrap() .0; assert_eq!( logged .iter() .flatten() .map(|e| e["t"].as_str().unwrap()) .collect::>(), ["session"] ); drop(s); // And as its account is loaded: the server's clock is as it was, // then moved on. let s = open(&dir, &plc); assert_eq!(s.sessions.count(&did), 4); s.sessions.skew.store(REFRESH_LIFE + 60, SeqCst); let keep = s.sessions.snapshot().remove(&did).unwrap(); s.sessions.put(&did, keep, s.sessions.now()); assert_eq!(s.sessions.count(&did), 2); refresh(&s, &young).await.unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// An account keeps at most `MAX_SESSIONS`: one more drops the refreshed /// one in its grace first, the one that expires soonest, and of those /// that expire in the same second the oldest; a dropped session's token /// is `ExpiredToken`, after a restart too. #[tokio::test] async fn sessions_are_capped() { let plc = plc().await; let dir = scratch("sessions-cap"); let s = open(&dir, &plc); let made = call( &s, "com.atproto.server.createAccount", None, json!({ "handle": "alice.test", "email": "a@mail.com", "password": "pw" }), ) .await .unwrap(); let did = made["did"].as_str().unwrap().to_string(); // The account's session, then a hundred refreshes, as fast as they go. let mut chain = vec![tokens(&made).1]; for _ in 0..MAX_SESSIONS { let next = refresh(&s, chain.last().unwrap()).await.unwrap().1; chain.push(next); } assert_eq!(s.sessions.count(&did), MAX_SESSIONS); assert_eq!(refresh(&s, &chain[0]).await, Err("ExpiredToken".into())); refresh(&s, &chain[1]).await.unwrap(); let snapshot = s.sessions.snapshot(); drop(s); let s = open(&dir, &plc); assert_eq!(s.sessions.snapshot(), snapshot); assert_eq!(refresh(&s, &chain[0]).await, Err("ExpiredToken".into())); // A new session drops the next oldest refreshed one, after a restart as before. login(&s, "alice.test", "pw").await.unwrap(); assert_eq!(refresh(&s, &chain[1]).await, Err("ExpiredToken".into())); refresh(&s, &chain[2]).await.unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// An account has at most `MAX_APP_PASSWORDS`: one more is /// `TooManyAppPasswords`, before its name is checked. #[tokio::test] async fn app_passwords_are_capped() { let plc = plc().await; let dir = scratch("app-cap"); let s = open(&dir, &plc); let (_, token) = create(&s, "alice").await; for i in 0..MAX_APP_PASSWORDS { call( &s, CREATE_APP, Some(&token), json!({ "name": format!("p{i}") }), ) .await .unwrap(); } assert_eq!( call(&s, CREATE_APP, Some(&token), json!({ "name": "one more" })).await, Err("TooManyAppPasswords".into()) ); assert_eq!( call(&s, CREATE_APP, Some(&token), json!({ "name": "p0" })).await, Err("TooManyAppPasswords".into()) ); assert_eq!( call(&s, CREATE_APP, Some(&token), json!({ "name": 5 })).await, Err("InvalidRequest".into()) ); call(&s, REVOKE_APP, Some(&token), json!({ "name": "p0" })) .await .unwrap(); call(&s, CREATE_APP, Some(&token), json!({ "name": "one more" })) .await .unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// An app password's session, privileged or not, may change the handle, /// but not make app passwords. #[tokio::test] async fn what_app_password_sessions_may_do() { let plc = crate::identity::stub::Plc::start().await; let dir = scratch("app-may"); let s = open(&dir, &plc.url); let (did, token) = create(&s, "alice").await; for (i, privileged) in [false, true].into_iter().enumerate() { let app = call( &s, CREATE_APP, Some(&token), json!({ "name": format!("a{i}"), "privileged": privileged }), ) .await .unwrap(); let (access, _) = login(&s, &did, app["password"].as_str().unwrap()) .await .unwrap(); assert_eq!( call(&s, CREATE_APP, Some(&access), json!({ "name": "x" })).await, Err("InvalidToken".into()) ); assert_eq!( call(&s, CREATE_APP, Some(&access), json!({ "name": 5 })).await, Err("InvalidToken".into()) ); let handle = format!("alice{i}.test"); call( &s, "com.atproto.identity.updateHandle", Some(&access), json!({ "handle": handle }), ) .await .unwrap(); } let _ = std::fs::remove_dir_all(&dir); } }