//! The PLC directory: a new account's `did:plc`, by the genesis operation //! `atproto/did-plc.md` describes, registered with the directory at //! `PDS_PLC_URL` (`spec/ACCOUNTS.md`); and the update operations that change //! an account's handle (`spec/IDENTITY.md`). use crate::Config; use crate::ops::Target; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use k256::ecdsa::signature::hazmat::PrehashSigner; use k256::ecdsa::{Signature, VerifyingKey}; use pds_repo::data::*; use serde_json::Value as Json; use sha2::{Digest, Sha256}; /// The multicodec of a secp256k1 public key, as a varint. const SECP256K1_PUB: [u8; 2] = [0xe7, 0x01]; /// A secp256k1 public key as a `did:key`: its multicodec and compressed point, in base58btc. pub fn did_key(key: &VerifyingKey) -> String { let mut bytes = SECP256K1_PUB.to_vec(); bytes.extend_from_slice(key.to_sec1_point(true).as_bytes()); format!("did:key:z{}", bs58::encode(bytes).into_string()) } /// A signed genesis operation and the DID it makes. pub struct Genesis { pub did: String, /// The signed operation, as JSON, as it is posted. pub op: Json, } /// The rotation keys of the DIDs the server creates: `PDS_RECOVERY_DID_KEY` /// if set, then its own rotation key, each a `did:key`. pub fn rotation_keys(config: &Config) -> Vec { let rotation = did_key(config.rotation_key.verifying_key()); let mut keys: Vec = config .recovery_did_key .iter() .filter(|k| **k != rotation) .cloned() .collect(); keys.push(rotation); keys } /// Sign an operation's fields with the server's rotation key: the DAG-CBOR /// of the operation without `sig`, signed in low-S form, as base64url. fn sign(config: &Config, mut fields: Vec<(String, V)>) -> V { let unsigned = encode(&V::Map(fields.clone())); let sig: Signature = config .rotation_key .sign_prehash(&Sha256::digest(&unsigned)) .expect("signing a 32-byte digest"); let sig = sig.normalize_s(); fields.push(( "sig".to_string(), V::Str(URL_SAFE_NO_PAD.encode(sig.to_bytes())), )); V::Map(fields) } /// The genesis operation of an account with this handle, signing key and /// KEM key (`spec/SPACES.md`), signed with the server's rotation key. pub fn genesis( config: &Config, signing: &VerifyingKey, kem: &pds_space::PublicKey, handle: &str, ) -> Genesis { let s = |x: &str| V::Str(x.to_string()); let fields = vec![ ("type".to_string(), s("plc_operation")), ( "rotationKeys".to_string(), V::Arr(rotation_keys(config).iter().map(|k| s(k)).collect()), ), ( "verificationMethods".to_string(), V::Map(vec![ ("atproto".to_string(), s(&did_key(signing))), ("atproto_kem".to_string(), s(&kem.did_key())), ]), ), ( "alsoKnownAs".to_string(), V::Arr(vec![s(&format!("at://{handle}"))]), ), ( "services".to_string(), V::Map(vec![( "atproto_pds".to_string(), V::Map(vec![ ("type".to_string(), s("AtprotoPersonalDataServer")), ("endpoint".to_string(), s(&config.public_url)), ]), )]), ), ("prev".to_string(), V::Null), ]; let signed = sign(config, fields); Genesis { did: did_of(&encode(&signed)), op: to_json(&signed), } } /// The CID of an operation as the directory has it: of its DAG-CBOR, as /// `atproto/did-plc.md` makes `prev`. pub fn cid(op: &Json) -> Result { Ok(cid_string(&cid_of(0x71, &encode(&from_json(op)?)))) } /// The update operation that gives a DID `handle`, built on `last`, the /// DID's last operation: its fields, with `prev` its CID and `alsoKnownAs` /// changed and nothing else, its first `at://` entry `at://` (or, /// with none, `at://` first); signed with the server's rotation key. pub fn update(config: &Config, last: &Json, handle: &str) -> Result { if last["type"] != "plc_operation" { return Err(format!( "the DID's last operation is not a plc_operation: {last}" )); } let prev = cid(last)?; let V::Map(fields) = from_json(last)? else { return Err("an operation that is not an object".into()); }; let at = V::Str(format!("at://{handle}")); let mut out = Vec::with_capacity(fields.len()); for (k, v) in fields { match (k.as_str(), v) { ("sig", _) => {} ("prev", _) => out.push((k, V::Str(prev.clone()))), ("alsoKnownAs", V::Arr(mut aka)) => { match aka .iter() .position(|u| matches!(u, V::Str(u) if u.starts_with("at://"))) { Some(i) => aka[i] = at.clone(), None => aka.insert(0, at.clone()), } out.push((k, V::Arr(aka))); } ("alsoKnownAs", _) => { return Err(format!( "an operation whose alsoKnownAs is not a list: {last}" )); } (_, v) => out.push((k, v)), } } if !out.iter().any(|(k, _)| k == "alsoKnownAs") { out.push(("alsoKnownAs".to_string(), V::Arr(vec![at]))); } if !out.iter().any(|(k, _)| k == "prev") { out.push(("prev".to_string(), V::Str(prev))); } Ok(to_json(&sign(config, out))) } /// The fields of a DID's operation `signPlcOperation` may set (`spec/MIGRATION.md`). pub const FIELDS: [&str; 4] = [ "rotationKeys", "alsoKnownAs", "verificationMethods", "services", ]; /// The update operation built on `last`, the DID's last operation: its /// fields, each of `FIELDS` `given`'s where it gives it, whole, with `prev` /// its CID, signed with the server's rotation key. pub fn update_with( config: &Config, last: &Json, given: &serde_json::Map, ) -> Result { let prev = cid(last)?; let V::Map(fields) = from_json(last)? else { return Err("an operation that is not an object".into()); }; let mut out: Vec<(String, V)> = fields .into_iter() .filter(|(k, _)| { k != "sig" && k != "prev" && !(FIELDS.contains(&k.as_str()) && given.contains_key(k)) }) .collect(); for k in FIELDS { if let Some(v) = given.get(k) { out.push((k.to_string(), from_json(v)?)); } } out.push(("prev".to_string(), V::Str(prev))); Ok(to_json(&sign(config, out))) } /// The DID a signed genesis operation, as DAG-CBOR, makes. fn did_of(signed: &[u8]) -> String { format!("did:plc:{}", &base32_encode(&Sha256::digest(signed))[..24]) } /// The HTTP client the server posts to the PLC directory with. It keeps no /// idle connection: a server may close one it holds idle (Node's HTTP server /// does after 5 seconds) just as the next request goes out on it, which then /// fails, perhaps after the server has read it. Each post takes a /// connection of its own, and none waits for ever (`spec/LIMITS.md`, "The /// PLC directory"). pub fn client() -> reqwest::Result { reqwest::Client::builder() .no_proxy() .pool_max_idle_per_host(0) .connect_timeout(std::time::Duration::from_secs(5)) .timeout(std::time::Duration::from_secs(15)) .build() } /// The HTTP client the server reads from the directory with: as `client`, /// but keeping a connection unused for up to 90 seconds, so that a read /// after another needs no new connection and TLS handshake. A read changes /// nothing, so one that fails over a connection the directory closed is /// sent again over one of its own (`document`). Built as `client` is, so it /// fails only where that did first, and the server would not have started. static READS: std::sync::LazyLock> = std::sync::LazyLock::new(|| { reqwest::Client::builder() .no_proxy() .pool_idle_timeout(std::time::Duration::from_secs(90)) .connect_timeout(std::time::Duration::from_secs(5)) .timeout(std::time::Duration::from_secs(15)) .build() }); /// The most requests to the directory in flight at once, of every kind. const AT_ONCE: usize = 8; /// How long a request waits for its turn before it is answered as if the /// directory could not be reached. const TURN_WAIT: std::time::Duration = std::time::Duration::from_secs(15); static TURNS: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(AT_ONCE); /// A request's turn to go to the directory, held while it is in flight. async fn turn() -> Result, String> { match tokio::time::timeout(TURN_WAIT, TURNS.acquire()).await { Ok(Ok(p)) => Ok(p), _ => Err("the PLC directory has too many requests in flight".into()), } } /// The JSON the directory serves at `url`, or None if it serves none (404): /// read over a connection kept from an earlier read, if one is open. /// Reading changes nothing, so a read that failed on its way is sent once /// more, with `http`, over a connection of its own. pub(crate) async fn document(http: &reqwest::Client, url: &str) -> Result, String> { let turn = turn().await?; let reads = READS.as_ref().unwrap_or(http); let res = match crate::ops::send(Target::Plc, reads.get(url)).await { Ok(res) => res, Err(e) if !e.is_timeout() => crate::ops::send(Target::Plc, http.get(url)) .await .map_err(|e| format!("reading {url}: {e}"))?, Err(e) => return Err(format!("reading {url}: {e}")), }; if res.status() == reqwest::StatusCode::NOT_FOUND { return Ok(None); } if !res.status().is_success() { return Err(format!("{url} answered {}", res.status())); } let bytes = res .bytes() .await .map_err(|e| format!("reading {url}: {e}"))?; drop(turn); serde_json::from_slice(&bytes) .map(Some) .map_err(|e| format!("the JSON at {url}: {e}")) } /// Why the directory did not take an update operation. pub enum Upstream { /// It answered, refusing it, with this message. Refused(String), /// It could not be reached; `sent` if the request may have reached it. Unreachable { why: String, sent: bool }, } fn url_of(plc_url: &str, did: &str) -> String { format!("{}/{did}", plc_url.trim_end_matches('/')) } /// The DID's last operation, as `GET //log/last` answers it. pub async fn last_operation( http: &reqwest::Client, plc_url: &str, did: &str, ) -> Result { let url = format!("{}/log/last", url_of(plc_url, did)); match document(http, &url).await { Ok(Some(op)) => Ok(op), Ok(None) => Err(Upstream::Refused(format!( "the directory has no operation for {did}" ))), Err(why) => Err(Upstream::Unreachable { why, sent: false }), } } /// Post an update operation for `did`. pub async fn post( http: &reqwest::Client, plc_url: &str, did: &str, op: &Json, ) -> Result<(), Upstream> { let url = url_of(plc_url, did); let _turn = turn() .await .map_err(|why| Upstream::Unreachable { why, sent: false })?; match crate::ops::send( Target::Plc, http.post(&url) .header(reqwest::header::CONTENT_TYPE, "application/json") .body(op.to_string()), ) .await { Ok(res) if res.status().is_success() => Ok(()), Ok(res) => { let status = res.status(); let text = res.text().await.unwrap_or_default(); // The directory says why as `{message}`. let message = serde_json::from_str::(&text) .ok() .and_then(|j| j["message"].as_str().map(str::to_string)); Err(Upstream::Refused( message.unwrap_or_else(|| format!("{status} {text}")), )) } Err(e) => Err(Upstream::Unreachable { why: format!("posting to {url}: {e}"), sent: !e.is_connect(), }), } } /// Whether the directory's log of `did` holds the operation with this CID, /// as `GET //log/audit` lists them. pub async fn holds( http: &reqwest::Client, plc_url: &str, did: &str, cid: &str, ) -> Result { let url = format!("{}/log/audit", url_of(plc_url, did)); let log = document(http, &url).await?.unwrap_or_default(); let entries = log .as_array() .ok_or_else(|| format!("{url} is not a list: {log}"))?; Ok(entries.iter().any(|e| e["cid"] == cid)) } /// Register a genesis operation with the directory, and answer the DID /// document it then serves for the DID. /// /// A post that fails on its way may or may not have reached the directory. /// The DID is the hash of this very operation, so no other operation can /// have made it: a document served for it means the directory took this /// one, and none means it has no operation for the DID, so posting this one /// again is its first genesis, not a second. pub async fn register(http: &reqwest::Client, plc_url: &str, g: &Genesis) -> Result { async fn refused(url: &str, res: reqwest::Response) -> Result { let status = res.status(); Err(format!( "{url} refused the operation: {status} {}", res.text().await.unwrap_or_default() )) } let url = format!("{}/{}", plc_url.trim_end_matches('/'), g.did); // Each post in its turn, given up before the next request takes its own. let post = || async { let _turn = turn().await?; Ok::<_, String>( crate::ops::send( Target::Plc, http.post(&url) .header(reqwest::header::CONTENT_TYPE, "application/json") .body(g.op.to_string()), ) .await, ) }; match post().await? { Ok(res) if res.status().is_success() => {} Ok(res) => return refused(&url, res).await, Err(e) => { crate::ops::failed_for( crate::ops::Level::Warn, "registering a DID failed, asking whether it was taken", &g.did, e, ); if document(http, &url).await?.is_none() { match post().await? { Ok(res) if res.status().is_success() => {} Ok(res) => return refused(&url, res).await, Err(e) => return Err(format!("posting to {url}: {e}")), } } } } document(http, &url) .await? .ok_or_else(|| format!("{url} serves no DID document for the operation it took")) } /// The public key of a secp256k1 `did:key`. #[cfg(test)] pub fn parse_did_key(k: &str) -> Option { let bytes = bs58::decode(k.strip_prefix("did:key:z")?).into_vec().ok()?; VerifyingKey::from_sec1_bytes(bytes.strip_prefix(&SECP256K1_PUB[..])?).ok() } /// Check a genesis operation as a directory would: signed, in low-S form, /// by one of its rotation keys, and making `did`. #[cfg(test)] pub fn verify(did: &str, op: &Json) -> Result<(), String> { if did_of(&encode(&from_json(op)?)) != did { return Err(format!("the operation does not make {did}")); } signer(op, &op["rotationKeys"]).map(|_| ()) } /// Check an update operation as a directory would: its `prev` the CID of /// `last`, and signed, in low-S form, by one of `last`'s rotation keys. /// Answers the `did:key` that signed it. #[cfg(test)] pub fn verify_update(last: &Json, op: &Json) -> Result { if op["prev"] != cid(last)? { return Err(format!( "prev is {}, not the CID of the last operation", op["prev"] )); } signer(op, &last["rotationKeys"]) } /// An operation signed again with the server's rotation key, as a test /// posts one of its own. #[cfg(test)] pub fn signed(config: &Config, op: &Json) -> Json { let V::Map(fields) = from_json(op).expect("an operation in the data model") else { panic!("an operation that is not an object") }; to_json(&sign( config, fields.into_iter().filter(|(k, _)| k != "sig").collect(), )) } /// Which of `keys` signed `op`, as `atproto/did-plc.md` asks: the DAG-CBOR /// of the operation without `sig`, and a low-S signature in base64url. #[cfg(test)] fn signer(op: &Json, keys: &Json) -> Result { use k256::ecdsa::signature::hazmat::PrehashVerifier; let V::Map(mut fields) = from_json(op)? else { return Err("not an object".into()); }; let at = fields .iter() .position(|(k, _)| k == "sig") .ok_or("no sig")?; let V::Str(sig) = fields.remove(at).1 else { return Err("sig is not a string".into()); }; let sig = URL_SAFE_NO_PAD.decode(&sig).map_err(|e| e.to_string())?; let sig = Signature::from_slice(&sig).map_err(|e| e.to_string())?; if sig.normalize_s() != sig { return Err("a high-S signature".into()); } let hash = Sha256::digest(encode(&V::Map(fields))); let keys = keys.as_array().ok_or("no rotationKeys")?; keys.iter() .filter_map(Json::as_str) .find(|k| parse_did_key(k).is_some_and(|key| key.verify_prehash(&hash, &sig).is_ok())) .map(str::to_string) .ok_or_else(|| "no rotation key signed it".into()) } #[cfg(test)] mod tests { use super::*; use crate::testing::config; use k256::ecdsa::SigningKey; use serde_json::json; /// A fixed KEM key. fn kem() -> pds_space::PublicKey { pds_space::KemKey::from_bytes(&[4u8; 32]).unwrap().public() } /// `did:key`s as the interop vectors have them. #[test] fn did_keys() { let text = std::fs::read_to_string(concat!( env!("CARGO_MANIFEST_DIR"), "/../../spec/interop/crypto/w3c_didkey_K256.json" )) .unwrap(); let vectors: Vec = serde_json::from_str(&text).unwrap(); assert!(!vectors.is_empty()); for v in vectors { let key = SigningKey::from_slice( &hex::decode(v["privateKeyBytesHex"].as_str().unwrap()).unwrap(), ) .unwrap(); assert_eq!( did_key(key.verifying_key()), v["publicDidKey"].as_str().unwrap() ); } } /// No more than `AT_ONCE` requests are in flight to the directory, however /// many are asked for at once. #[tokio::test(flavor = "multi_thread", worker_threads = 4)] async fn few_requests_at_once() { use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; type Counts = Arc<(AtomicUsize, AtomicUsize)>; async fn slow(axum::extract::State(c): axum::extract::State) -> &'static str { let n = c.0.fetch_add(1, Ordering::SeqCst) + 1; c.1.fetch_max(n, Ordering::SeqCst); tokio::time::sleep(std::time::Duration::from_millis(100)).await; c.0.fetch_sub(1, Ordering::SeqCst); "{}" } let counts = Counts::default(); let app = axum::Router::new() .route("/{did}", axum::routing::get(slow)) .with_state(counts.clone()); let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)) .await .unwrap(); let url = format!("http://{}", listener.local_addr().unwrap()); tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }); let http = client().unwrap(); let asks: Vec<_> = (0..24) .map(|i| { let (http, url) = (http.clone(), format!("{url}/did{i}")); tokio::spawn(async move { document(&http, &url).await }) }) .collect(); for a in asks { assert_eq!(a.await.unwrap().unwrap(), Some(json!({}))); } let most = counts.1.load(Ordering::SeqCst); assert!((1..=AT_ONCE).contains(&most), "{most} at once"); } /// A genesis operation as `atproto/did-plc.md` says, with fixed keys, /// the KEM key beside the signing key (`spec/SPACES.md`). #[test] fn genesis_operation() { let config = config("http://plc.invalid"); let signing = SigningKey::from_slice(&[3u8; 32]).unwrap(); let g = genesis(&config, signing.verifying_key(), &kem(), "alice.test"); let rotation = did_key(config.rotation_key.verifying_key()); let sig = g.op["sig"].as_str().unwrap().to_string(); assert_eq!( g.op, json!({ "type": "plc_operation", "rotationKeys": [config.recovery_did_key.clone().unwrap(), rotation], "verificationMethods": { "atproto": did_key(signing.verifying_key()), "atproto_kem": kem().did_key() }, "alsoKnownAs": ["at://alice.test"], "services": { "atproto_pds": { "type": "AtprotoPersonalDataServer", "endpoint": "http://127.0.0.1:2583" } }, "prev": null, "sig": sig, }) ); // The signature: 64 bytes, base64url without padding. assert_eq!(sig.len(), 86); assert!( sig.bytes() .all(|c| c.is_ascii_alphanumeric() || c == b'-' || c == b'_') ); // The DID: 24 characters of base32, lower case, without 0, 1, 8 or 9. let id = g.did.strip_prefix("did:plc:").unwrap(); assert_eq!(id.len(), 24); assert!( id.bytes() .all(|c| c.is_ascii_lowercase() || (b'2'..=b'7').contains(&c)) ); verify(&g.did, &g.op).unwrap(); let kem_key = g.op["verificationMethods"]["atproto_kem"].as_str().unwrap(); assert!(kem_key.starts_with("did:key:zDn")); assert_eq!(pds_space::PublicKey::from_did_key(kem_key).unwrap(), kem()); // The same keys and handle make the same DID; signing is deterministic. assert_eq!( genesis(&config, signing.verifying_key(), &kem(), "alice.test").did, g.did ); assert_ne!( genesis(&config, signing.verifying_key(), &kem(), "bob.test").did, g.did ); let other_kem = pds_space::KemKey::from_bytes(&[5u8; 32]).unwrap().public(); assert_ne!( genesis(&config, signing.verifying_key(), &other_kem, "alice.test").did, g.did ); // Changing any field breaks it. let mut tampered = g.op.clone(); tampered["alsoKnownAs"] = json!(["at://mallory.test"]); assert!(verify(&g.did, &tampered).is_err()); // Without a recovery key, the server's own is the only rotation key. let mut alone = config; alone.recovery_did_key = None; assert_eq!( genesis(&alone, signing.verifying_key(), &kem(), "alice.test").op["rotationKeys"], json!([rotation]) ); } /// An update operation as `atproto/did-plc.md` says: the last /// operation's fields, `prev` its CID, `alsoKnownAs` changed and nothing /// else, signed by the server's rotation key. #[test] fn update_operation() { let config = config("http://plc.invalid"); let signing = SigningKey::from_slice(&[3u8; 32]).unwrap(); let g = genesis(&config, signing.verifying_key(), &kem(), "alice.test"); let op = update(&config, &g.op, "carol.test").unwrap(); // `prev`: CIDv1, dag-cbor, sha-256 of the last operation's DAG-CBOR, in base32. let prev = op["prev"].as_str().unwrap(); let bytes = parse_cid(prev).unwrap(); assert_eq!(bytes[..4], [1, 0x71, 0x12, 0x20]); assert_eq!( bytes[4..], Sha256::digest(encode(&from_json(&g.op).unwrap()))[..] ); let mut want = g.op.clone(); want["prev"] = json!(prev); want["alsoKnownAs"] = json!(["at://carol.test"]); want["sig"] = op["sig"].clone(); assert_eq!(op, want); assert_eq!( verify_update(&g.op, &op).unwrap(), did_key(config.rotation_key.verifying_key()) ); // Built on it again, `prev` is its CID; a change to any field breaks the signature. let next = update(&config, &op, "dave.test").unwrap(); assert_eq!(next["prev"], json!(cid(&op).unwrap())); verify_update(&op, &next).unwrap(); assert!(verify_update(&g.op, &next).is_err()); let mut tampered = op.clone(); tampered["services"]["atproto_pds"]["endpoint"] = json!("https://elsewhere.test"); assert!(verify_update(&g.op, &tampered).is_err()); // The first `at://` entry changes, wherever it is; with none, one goes first. for (aka, after) in [ ( json!(["at://alice.test", "https://alice.example.com"]), json!(["at://carol.test", "https://alice.example.com"]), ), ( json!([ "https://alice.example.com", "at://alice.test", "at://old.test" ]), json!([ "https://alice.example.com", "at://carol.test", "at://old.test" ]), ), ( json!(["https://alice.example.com"]), json!(["at://carol.test", "https://alice.example.com"]), ), (json!([]), json!(["at://carol.test"])), ] { let mut last = g.op.clone(); last["alsoKnownAs"] = aka; last["prev"] = json!(cid(&g.op).unwrap()); let op = update(&config, &last, "carol.test").unwrap(); assert_eq!(op["alsoKnownAs"], after); assert_eq!(op["rotationKeys"], last["rotationKeys"]); assert_eq!(op["verificationMethods"], last["verificationMethods"]); assert_eq!(op["services"], last["services"]); assert_eq!(op["prev"], json!(cid(&last).unwrap())); } // A tombstone cannot be built on. assert!( update( &config, &json!({ "type": "plc_tombstone", "prev": prev, "sig": "x" }), "carol.test" ) .is_err() ); } /// How the stub directory loses the first operation posted to it. #[derive(Clone, Copy, PartialEq)] enum Lose { Nothing, /// It closes the connection having read the post, before taking it. Request, /// It takes the operation, then closes the connection unanswered. Answer, } /// A directory that, like a server closing a connection it held idle just /// as a request arrives on it, answers only the first request on each /// connection and closes it on reading the next. It takes any operation, /// serving `{id}` as its DID's document. Answers its URL. async fn closing_plc(lose: Lose) -> String { use std::collections::HashMap; use std::sync::{Arc, Mutex}; use tokio::io::{AsyncReadExt, AsyncWriteExt}; let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)) .await .unwrap(); let url = format!("http://{}", listener.local_addr().unwrap()); let ops: Arc, bool)>> = Arc::default(); tokio::spawn(async move { loop { let (mut conn, _) = listener.accept().await.unwrap(); let ops = ops.clone(); tokio::spawn(async move { let mut buf = Vec::new(); for served in 0.. { // Read one request: its head, then a body as long as it says. let head_end = loop { if let Some(i) = buf.windows(4).position(|w| w == b"\r\n\r\n") { break i + 4; } let mut chunk = [0u8; 4096]; match conn.read(&mut chunk).await { Ok(0) | Err(_) => return, Ok(n) => buf.extend_from_slice(&chunk[..n]), } }; let head = String::from_utf8_lossy(&buf[..head_end]).to_lowercase(); let len = head .lines() .find_map(|l| l.strip_prefix("content-length:")) .map_or(0, |n| n.trim().parse().unwrap()); while buf.len() < head_end + len { let mut chunk = [0u8; 4096]; match conn.read(&mut chunk).await { Ok(0) | Err(_) => return, Ok(n) => buf.extend_from_slice(&chunk[..n]), } } let body: Vec = buf.drain(..head_end + len).skip(head_end).collect(); if served > 0 { return; } let did = head .split_whitespace() .nth(1) .unwrap() .trim_start_matches('/') .to_string(); let answer = if head.starts_with("post") { let mut ops = ops.lock().unwrap(); let first = !std::mem::replace(&mut ops.1, true); if first && lose == Lose::Request { return; } ops.0.insert(did, serde_json::from_slice(&body).unwrap()); if first && lose == Lose::Answer { return; } "HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n" .to_string() } else if ops.lock().unwrap().0.contains_key(&did) { let doc = json!({ "id": did }).to_string(); format!( "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: keep-alive\r\n\r\n{doc}", doc.len() ) } else { "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n".to_string() }; if conn.write_all(answer.as_bytes()).await.is_err() { return; } } }); } }); url } fn op(handle: &str) -> Genesis { genesis( &config("http://plc.invalid"), SigningKey::from_slice(&[3u8; 32]).unwrap().verifying_key(), &kem(), handle, ) } /// A pooled connection the directory closes as the next request arrives /// fails that request; the server's client keeps none, so requests and /// registrations one after another each succeed. #[tokio::test] async fn no_idle_connection_is_reused() { let plc = closing_plc(Lose::Nothing).await; let url = format!("{plc}/did:plc:nobody"); let pooled = reqwest::Client::builder().no_proxy().build().unwrap(); assert_eq!(pooled.get(&url).send().await.unwrap().status(), 404); let e = pooled.get(&url).send().await.unwrap_err(); assert!(!e.is_timeout() && !e.is_connect(), "{e:?}"); let http = client().unwrap(); for _ in 0..3 { assert_eq!(http.get(&url).send().await.unwrap().status(), 404); } for h in ["a.test", "b.test", "c.test"] { let g = op(h); assert_eq!( register(&http, &plc, &g).await.unwrap(), json!({ "id": g.did }) ); } } /// A post lost on its way is found taken, or posted again if it was not. #[tokio::test] async fn a_lost_post_is_settled() { for lose in [Lose::Request, Lose::Answer] { let plc = closing_plc(lose).await; let g = op("lost.test"); assert_eq!( register(&client().unwrap(), &plc, &g).await.unwrap(), json!({ "id": g.did }) ); } } }