chadtmiller.com/monolith
An atproto PDS
0
0
//! Invite codes, as `spec/LIMITS.md` says: the admin's `createInviteCode`
//! and `createInviteCodes`, an account's `getAccountInviteCodes`, and the
//! codes `createAccount` uses.
//!
//! Each code made is an `invite` entry in `accounts.log`, and each use of
//! one an `inviteUse` entry in the frame of the account it made, so a code
//! and its uses survive as accounts do. A `createAccount` holds a use of its
//! code from when it checks it until its account is logged or refused, so
//! several at once with one code make no more accounts than it has uses left.
use crate::sessions::{Bearer, Token, full_access_token};
use crate::{Call, Handler, Resp, Service, Shared, Shown, XrpcError, durable, err, internal};
use base64::Engine;
use serde_json::{Map, Value as Json, json};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
use std::sync::{Mutex, MutexGuard, PoisonError};
/// The kinds of `accounts.log` entry this module keeps.
pub(crate) const ENTRIES: &[&str] = &["invite", "inviteUse"];
/// Who the admin is, as a code made by or for the admin names it.
const ADMIN: &str = "admin";
pub(crate) fn handler(nsid: &str) -> Option<Handler> {
Some(match nsid {
"com.atproto.server.createInviteCode" => {
Handler::Authed(admin, |s, _, b| Box::pin(create_invite_code(s, b)))
}
"com.atproto.server.createInviteCodes" => {
Handler::Authed(admin, |s, _, b| Box::pin(create_invite_codes(s, b)))
}
"com.atproto.server.getAccountInviteCodes" => Handler::Query(get_account_invite_codes),
_ => return None,
})
}
/// A code, as kept.
#[derive(Debug, PartialEq, Eq)]
struct Code {
for_account: String,
created_by: String,
/// How many accounts may be created with it.
available: i64,
created_at: String,
/// Each use, `(usedBy, usedAt)`, oldest first.
uses: Vec<(String, String)>,
/// Uses held by `createAccount`s under way.
held: i64,
}
#[derive(Default)]
struct State {
codes: HashMap<String, Code>,
/// Every code, in the order made.
order: Vec<String>,
/// Each account's codes, in the order made.
by_account: HashMap<String, Vec<String>>,
}
impl State {
fn apply(&mut self, e: &Json) -> Result<(), String> {
let text = |k: &str| {
e[k].as_str()
.map(str::to_string)
.ok_or_else(|| format!("an entry with no {k}: {e}"))
};
match e["t"].as_str() {
Some("invite") => {
let code = text("code")?;
if self.codes.contains_key(&code) {
return Err(format!("a second invite code {code}"));
}
let available = e["available"]
.as_i64()
.ok_or_else(|| format!("an invite code with no available: {e}"))?;
let c = Code {
for_account: text("forAccount")?,
created_by: text("createdBy")?,
available,
created_at: text("createdAt")?,
uses: vec![],
held: 0,
};
self.by_account
.entry(c.for_account.clone())
.or_default()
.push(code.clone());
self.order.push(code.clone());
self.codes.insert(code, c);
}
Some("inviteUse") => {
let code = text("code")?;
let c = self
.codes
.get_mut(&code)
.ok_or_else(|| format!("a use of invite code {code}, which was not made"))?;
c.uses.push((text("usedBy")?, text("usedAt")?));
}
t => return Err(format!("a log entry of no known type: {t:?}")),
}
Ok(())
}
}
/// The invite codes the server made, and their uses.
#[derive(Default)]
pub(crate) struct Invites(Mutex<State>);
impl Invites {
fn lock(&self) -> MutexGuard<'_, State> {
self.0.lock().unwrap_or_else(PoisonError::into_inner)
}
/// Replay an entry of `accounts.log` of the kinds in `ENTRIES`.
pub fn replay(&self, e: &Json) -> Result<(), String> {
self.lock().apply(e)
}
/// The entries that make these codes again, for a compacted log.
pub fn entries(&self) -> Vec<Json> {
let st = self.lock();
let codes = st.order.iter().map(|code| (code, &st.codes[code]));
let made = codes.clone().map(|(code, c)| {
json!({ "t": "invite", "code": code, "forAccount": c.for_account, "createdBy": c.created_by, "available": c.available, "createdAt": c.created_at })
});
let used = codes.flat_map(|(code, c)| c.uses.iter().map(move |(by, at)| json!({ "t": "inviteUse", "code": code, "usedBy": by, "usedAt": at })));
made.collect::<Vec<_>>()
.into_iter()
.chain(used.collect::<Vec<_>>())
.collect()
}
/// Hold a use of `code`, if the server made it, exactly as given, and
/// fewer accounts were made or are being made with it than its `available`.
pub fn hold(s: &Shared, code: &str) -> Option<Held> {
let mut st = s.invites.lock();
let c = st.codes.get_mut(code)?;
if c.uses.len() as i64 + c.held >= c.available {
return None;
}
c.held += 1;
Some(Held {
s: s.clone(),
code: code.to_string(),
used: false,
})
}
/// Every code, to compare across restarts.
#[cfg(test)]
pub fn snapshot(&self) -> Vec<String> {
let st = self.lock();
st.order
.iter()
.map(|code| format!("{code} {:?}", st.codes[code]))
.collect()
}
}
/// A use of a code held for an account being created; let go when dropped,
/// unless the account was made with it.
pub(crate) struct Held {
s: Shared,
code: String,
used: bool,
}
impl Held {
/// The entry of its use by `did`, at `at`, to log with the account.
pub fn entry(&self, did: &str, at: &str) -> Json {
json!({ "t": "inviteUse", "code": self.code, "usedBy": did, "usedAt": at })
}
/// The account is logged: the use is its.
pub fn used(mut self, did: &str, at: &str) {
let mut st = self.s.invites.lock();
if let Some(c) = st.codes.get_mut(&self.code) {
c.held -= 1;
c.uses.push((did.to_string(), at.to_string()));
}
self.used = true;
}
}
impl Drop for Held {
fn drop(&mut self) {
if !self.used
&& let Some(c) = self.s.invites.lock().codes.get_mut(&self.code)
{
c.held -= 1;
}
}
}
/// The admin's `Basic` auth, `admin` and `PDS_ADMIN_PASSWORD`, compared in
/// constant time; anything else, and anything at all with no password set,
/// is `401 AuthenticationRequired`.
pub(crate) fn admin(s: &Service, b: Bearer) -> Result<Token, XrpcError> {
let refuse = || err(401, "AuthenticationRequired", "Authentication Required");
let (Bearer::Basic(credentials), Some(password)) = (
b,
s.config.admin_password.as_ref().filter(|p| !p.is_empty()),
) else {
return refuse();
};
let Ok(given) = base64::engine::general_purpose::STANDARD.decode(credentials) else {
return refuse();
};
// Digests compared, so that not even the length shows.
let (given, want) = (
Sha256::digest(&given),
Sha256::digest(format!("{ADMIN}:{password}").as_bytes()),
);
if given
.iter()
.zip(want.iter())
.fold(0u8, |acc, (a, b)| acc | (a ^ b))
!= 0
{
return refuse();
}
Ok(Token {
did: ADMIN.to_string(),
scope: ADMIN.to_string(),
jti: None,
oauth: false,
})
}
/// A new code: the server's hostname with each `.` made `-`, then two groups
/// of five lower case letters or digits 2 to 7.
fn new_code(hostname: &str) -> String {
const ALPHABET: &[u8; 32] = b"abcdefghijklmnopqrstuvwxyz234567";
let chars: String = rand::random::<[u8; 10]>()
.iter()
.map(|b| char::from(ALPHABET[usize::from(b & 31)]))
.collect();
format!(
"{}-{}-{}",
hostname.replace('.', "-"),
&chars[..5],
&chars[5..]
)
}
/// Make codes for each account given, `count` each, of `uses` uses: logged in
/// one frame, and on disk before they are answered. Answers each account's codes.
async fn make(
s: &Shared,
accounts: &[String],
count: i64,
uses: i64,
) -> Result<Vec<Vec<String>>, XrpcError> {
let at = crate::events::timestamp();
let n = {
let mut st = s.invites.lock();
let mut made: Vec<Vec<String>> = Vec::with_capacity(accounts.len());
let mut entries = Vec::new();
for account in accounts {
let mut codes = Vec::new();
for _ in 0..count.max(0) {
let code = std::iter::repeat_with(|| new_code(&s.config.hostname))
.find(|c| !st.codes.contains_key(c) && !codes.contains(c))
.expect("a code");
entries.push(json!({ "t": "invite", "code": code, "forAccount": account, "createdBy": ADMIN, "available": uses, "createdAt": at }));
codes.push(code);
}
made.push(codes);
}
if entries.is_empty() {
return Ok(made);
}
let n = match s.log.append(&entries) {
Ok(n) => n,
Err(e) => {
crate::ops::failed("writing accounts.log failed", e);
return internal();
}
};
for e in &entries {
st.apply(e).map_err(|why| XrpcError {
status: 500,
name: "InternalServerError",
message: why,
})?;
}
(n, made)
};
durable(s.log.clone(), n.0).await?;
Ok(n.1)
}
async fn create_invite_code(s: Shared, b: Map<String, Json>) -> Result<Resp, XrpcError> {
let uses = b.get("useCount").and_then(Json::as_i64).unwrap_or(0);
let account = b
.get("forAccount")
.and_then(Json::as_str)
.unwrap_or(ADMIN)
.to_string();
let made = make(&s, &[account], 1, uses).await?;
Ok(Resp::Json(json!({ "code": made[0][0] })))
}
async fn create_invite_codes(s: Shared, b: Map<String, Json>) -> Result<Resp, XrpcError> {
let count = b.get("codeCount").and_then(Json::as_i64).unwrap_or(1);
let uses = b.get("useCount").and_then(Json::as_i64).unwrap_or(0);
let accounts: Vec<String> = match b.get("forAccounts").and_then(Json::as_array) {
Some(a) => a
.iter()
.filter_map(Json::as_str)
.map(str::to_string)
.collect(),
None => vec![ADMIN.to_string()],
};
let made = make(&s, &accounts, count, uses).await?;
let codes: Vec<Json> = accounts
.iter()
.zip(made)
.map(|(account, codes)| json!({ "account": account, "codes": codes }))
.collect();
Ok(Resp::Json(json!({ "codes": codes })))
}
/// The codes for the token's account, a session of its own password's.
fn get_account_invite_codes(
s: &Service,
call: &Call,
shown: &mut Shown,
p: &Map<String, Json>,
) -> Result<Resp, XrpcError> {
let t = full_access_token(s, call.bearer)?;
crate::lifecycle::gate(s, call.nsid, &t.did)?;
let include_used = p.get("includeUsed").and_then(Json::as_bool).unwrap_or(true);
let st = s.invites.lock();
let codes: Vec<Json> = st
.by_account
.get(&t.did)
.into_iter()
.flatten()
.map(|code| (code, &st.codes[code]))
.filter(|(_, c)| include_used || (c.uses.len() as i64) < c.available)
.map(|(code, c)| {
let uses: Vec<Json> = c.uses.iter().rev().map(|(by, at)| json!({ "usedBy": by, "usedAt": at })).collect();
json!({
"code": code, "available": c.available, "disabled": false, "forAccount": c.for_account,
"createdBy": c.created_by, "createdAt": c.created_at, "uses": uses,
})
})
.collect();
drop(st);
shown.0.push((s.log.clone(), s.log.written()));
Ok(Resp::Json(json!({ "codes": codes })))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testing::*;
const CREATE_CODE: &str = "com.atproto.server.createInviteCode";
const CREATE_CODES: &str = "com.atproto.server.createInviteCodes";
const LIST: &str = "com.atproto.server.getAccountInviteCodes";
const CREATE: &str = "com.atproto.server.createAccount";
fn basic(user_password: &str) -> String {
format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(user_password)
)
}
async fn as_admin(s: &Shared, nsid: &str, body: Json) -> Result<Json, String> {
let h = basic(&format!("admin:{ADMIN_PASSWORD}"));
call_raw(s, nsid, Bearer::of(Some(&h)), &[], &body.to_string()).await
}
fn account(name: &str, code: Option<&str>) -> Json {
let mut b = json!({ "handle": format!("{name}.test"), "email": format!("{name}@mail.com"), "password": "pw" });
if let Some(c) = code {
b["inviteCode"] = json!(c);
}
b
}
/// Only the admin's `Basic` auth makes codes, checked before the input.
#[tokio::test]
async fn only_the_admin_makes_codes() {
let plc = plc().await;
let dir = scratch("invite-admin");
let s = open(&dir, &plc);
let (_, token) = create(&s, "alice").await;
let wrong = [
Bearer::None,
Bearer::Token(&token),
Bearer::Basic("not base64!"),
Bearer::Basic(&basic("admin:wrong")["Basic ".len()..]),
Bearer::Basic(&basic(&format!("root:{ADMIN_PASSWORD}"))["Basic ".len()..]),
];
for b in wrong {
for body in [r#"{"useCount":1}"#, r#"{"useCount":"x"}"#] {
assert_eq!(
call_raw(&s, CREATE_CODE, b, &[], body).await,
Err("AuthenticationRequired".into()),
"{b:?}"
);
}
}
assert_eq!(
as_admin(&s, CREATE_CODE, json!({ "useCount": "x" })).await,
Err("InvalidRequest".into())
);
let code = as_admin(&s, CREATE_CODE, json!({ "useCount": 1 }))
.await
.unwrap()["code"]
.as_str()
.unwrap()
.to_string();
let (prefix, rest) = code.split_at("localhost-".len());
assert_eq!(prefix, "localhost-");
assert!(
rest.len() == 11
&& rest.as_bytes()[5] == b'-'
&& rest
.bytes()
.filter(|c| *c != b'-')
.all(|c| matches!(c, b'a'..=b'z' | b'2'..=b'7')),
"{code}"
);
// With no admin password set, no request is the admin.
drop(s);
let s = open_with(&dir, &plc, |c| c.admin_password = None);
assert_eq!(
as_admin(&s, CREATE_CODE, json!({ "useCount": 1 })).await,
Err("AuthenticationRequired".into())
);
// An empty one is none: neither `admin:` nor the usual password is the admin.
drop(s);
let s = open_with(&dir, &plc, |c| c.admin_password = Some(String::new()));
assert_eq!(
call_raw(
&s,
CREATE_CODE,
Bearer::of(Some(&basic("admin:"))),
&[],
r#"{"useCount":1}"#
)
.await,
Err("AuthenticationRequired".into())
);
assert_eq!(
as_admin(&s, CREATE_CODE, json!({ "useCount": 1 })).await,
Err("AuthenticationRequired".into())
);
let _ = std::fs::remove_dir_all(&dir);
}
/// Codes for accounts, used by `createAccount`, listed by the account
/// they are for, newest use first, and all of it after a restart.
#[tokio::test]
async fn codes_are_made_used_and_listed() {
let plc = plc().await;
let dir = scratch("invite-use");
let s = open(&dir, &plc);
let (alice, token) = create(&s, "alice").await;
let got = as_admin(
&s,
CREATE_CODES,
json!({ "codeCount": 2, "useCount": 2, "forAccounts": [alice, "did:plc:elsewhere"] }),
)
.await
.unwrap();
let codes = got["codes"].as_array().unwrap();
assert_eq!(
(codes.len(), &codes[0]["account"], &codes[1]["account"]),
(2, &json!(alice), &json!("did:plc:elsewhere"))
);
let mine: Vec<String> = codes[0]["codes"]
.as_array()
.unwrap()
.iter()
.map(|c| c.as_str().unwrap().to_string())
.collect();
assert_eq!(mine.len(), 2);
assert_eq!(
as_admin(
&s,
CREATE_CODES,
json!({ "codeCount": 2, "useCount": 1, "forAccounts": [] })
)
.await
.unwrap(),
json!({ "codes": [] })
);
assert_eq!(
as_admin(&s, CREATE_CODES, json!({ "codeCount": 0, "useCount": 1 }))
.await
.unwrap(),
json!({ "codes": [{ "account": "admin", "codes": [] }] })
);
let none = as_admin(&s, CREATE_CODE, json!({ "useCount": 0 }))
.await
.unwrap()["code"]
.as_str()
.unwrap()
.to_string();
// Not required: none, or an empty one, is none; one not available is refused.
create(&s, "bob").await;
call(&s, CREATE, None, account("carol", Some("")))
.await
.unwrap();
for bad in [none.as_str(), "nope", &mine[0].to_uppercase()] {
assert_eq!(
call(&s, CREATE, None, account("dave", Some(bad))).await,
Err("InvalidInviteCode".into()),
"{bad}"
);
}
let dave = call(&s, CREATE, None, account("dave", Some(&mine[0])))
.await
.unwrap();
let erin = call(&s, CREATE, None, account("erin", Some(&mine[0])))
.await
.unwrap();
assert_eq!(
call(&s, CREATE, None, account("fred", Some(&mine[0]))).await,
Err("InvalidInviteCode".into())
);
let list = |s: &Shared, include: Option<bool>| {
let (s, token) = (s.clone(), token.clone());
async move {
let p: Vec<(String, String)> = include
.map(|i| ("includeUsed".to_string(), i.to_string()))
.into_iter()
.collect();
call_with(&s, LIST, Some(&token), &p, Json::Null)
.await
.unwrap()["codes"]
.as_array()
.unwrap()
.clone()
}
};
let all = list(&s, None).await;
assert_eq!(all.len(), 2);
let used = all.iter().find(|c| c["code"] == json!(mine[0])).unwrap();
assert_eq!(
(
&used["available"],
&used["disabled"],
&used["forAccount"],
&used["createdBy"]
),
(&json!(2), &json!(false), &json!(alice), &json!("admin"))
);
let by: Vec<&Json> = used["uses"]
.as_array()
.unwrap()
.iter()
.map(|u| &u["usedBy"])
.collect();
assert_eq!(by, [&erin["did"], &dave["did"]]);
assert_eq!(list(&s, Some(false)).await.len(), 1);
// A restart has the same codes and uses.
let before = s.invites.snapshot();
drop(s);
let s = open(&dir, &plc);
assert_eq!(s.invites.snapshot(), before);
assert_eq!(list(&s, None).await, all);
let _ = std::fs::remove_dir_all(&dir);
}
/// An app password's session, a refresh token, a `Basic` header: each is
/// `InvalidToken` to `getAccountInviteCodes`; none is `AuthMissing`.
#[tokio::test]
async fn listing_takes_the_accounts_own_session() {
let plc = plc().await;
let dir = scratch("invite-list");
let s = open(&dir, &plc);
let (_, token) = create(&s, "alice").await;
let app = call(
&s,
"com.atproto.server.createAppPassword",
Some(&token),
json!({ "name": "x", "privileged": true }),
)
.await
.unwrap();
let login = json!({ "identifier": "alice.test", "password": app["password"] });
let session = call(&s, "com.atproto.server.createSession", None, login)
.await
.unwrap();
for t in [
session["accessJwt"].as_str().unwrap(),
session["refreshJwt"].as_str().unwrap(),
] {
assert_eq!(
call_with(&s, LIST, Some(t), &[], Json::Null).await,
Err("InvalidToken".into())
);
}
let h = basic(&format!("admin:{ADMIN_PASSWORD}"));
assert_eq!(
call_raw(&s, LIST, Bearer::of(Some(&h)), &[], "").await,
Err("InvalidToken".into())
);
assert_eq!(
call_with(&s, LIST, None, &[], Json::Null).await,
Err("AuthMissing".into())
);
assert_eq!(
call_with(&s, LIST, Some(&token), &[], Json::Null)
.await
.unwrap(),
json!({ "codes": [] })
);
let _ = std::fs::remove_dir_all(&dir);
}
/// With codes required: none or an empty one is refused before the email
/// is checked; one not available after the handle, before a handle taken.
/// Many at once with a code of one use make one account.
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn codes_required() {
let plc = plc().await;
let dir = scratch("invite-required");
let s = open_with(&dir, &plc, |c| c.invite_required = true);
let described = call(&s, "com.atproto.server.describeServer", None, json!({}))
.await
.unwrap();
assert_eq!(described["inviteCodeRequired"], json!(true));
let code = |n: i64| {
let s = s.clone();
async move {
as_admin(&s, CREATE_CODE, json!({ "useCount": n }))
.await
.unwrap()["code"]
.as_str()
.unwrap()
.to_string()
}
};
let first = code(1).await;
call(&s, CREATE, None, account("alice", Some(&first)))
.await
.unwrap();
let cases = [
(
json!({ "handle": "x.test", "password": "x".repeat(257) }),
"InvalidRequest",
),
(
json!({ "handle": "bob.test", "email": "bad", "password": "pw" }),
"InvalidInviteCode",
),
(
json!({ "handle": "bob.test", "email": "bad", "password": "pw", "inviteCode": "" }),
"InvalidInviteCode",
),
(
json!({ "handle": "bob.test", "email": "bad", "password": "pw", "inviteCode": "nope" }),
"InvalidRequest",
),
(
json!({ "handle": "ab.test", "email": "b@mail.com", "password": "pw", "inviteCode": "nope" }),
"InvalidHandle",
),
(
json!({ "handle": "alice.test", "email": "b@mail.com", "password": "pw", "inviteCode": "nope" }),
"InvalidInviteCode",
),
(
json!({ "handle": "alice.test", "email": "b@mail.com", "password": "pw", "inviteCode": first }),
"InvalidInviteCode",
),
];
for (body, want) in cases {
assert_eq!(
call(&s, CREATE, None, body.clone()).await,
Err(want.to_string()),
"{body}"
);
}
let one = code(1).await;
let tries: Vec<_> = (0..8)
.map(|i| {
let (s, one) = (s.clone(), one.clone());
tokio::spawn(async move {
call(&s, CREATE, None, account(&format!("racer{i}"), Some(&one))).await
})
})
.collect();
let mut made = 0;
for t in tries {
if t.await.unwrap().is_ok() {
made += 1;
}
}
assert_eq!(made, 1);
// A refused createAccount uses nothing.
let two = code(1).await;
assert_eq!(call(&s, CREATE, None, json!({ "handle": "alice.test", "email": "z@mail.com", "password": "pw", "inviteCode": two })).await, Err("InvalidRequest".into()));
call(&s, CREATE, None, account("zed", Some(&two)))
.await
.unwrap();
let _ = std::fs::remove_dir_all(&dir);
}
}