1use crate::*;
2use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
3use openssl::{
4 bn::{BigNum, BigNumContext},
5 ec::{EcGroup, EcKey},
6 ecdsa::EcdsaSig,
7 nid::Nid,
8};
9use sha2::{Digest, Sha256};
10use std::net::{IpAddr, SocketAddr};
11use url::Url;
12
13fn reject() -> Error {
14 Error::new(
15 502,
16 "Your AT Protocol provider couldn't verify sign-in. Check your handle and try again.",
17 )
18}
19
20fn public_ip(ip: IpAddr) -> bool {
21 match ip {
22 IpAddr::V4(ip) => {
23 let [a, b, c, _] = ip.octets();
24 !(a == 0
25 || a == 10
26 || a == 127
27 || a >= 224
28 || (a == 100 && (64..=127).contains(&b))
29 || (a == 169 && b == 254)
30 || (a == 172 && (16..=31).contains(&b))
31 || (a == 192
32 && ((b == 0 && (c == 0 || c == 2)) || b == 168 || (b == 88 && c == 99)))
33 || (a == 198 && (b == 18 || b == 19 || (b == 51 && c == 100)))
34 || (a == 203 && b == 0 && c == 113))
35 }
36 IpAddr::V6(ip) => {
37 let s = ip.segments();
38 // Only global unicast; exclude transition mechanisms and special-purpose ranges.
39 s[0] & 0xe000 == 0x2000
40 && !(s[0] == 0x2001 && s[1] < 0x200)
41 && !(s[0] == 0x2001 && s[1] == 0xdb8)
42 && s[0] != 0x2002
43 && !(s[0] == 0x3fff && s[1] < 0x1000)
44 }
45 }
46}
47
48fn https(value: &str) -> Result<Url> {
49 let url = Url::parse(value).map_err(|_| reject())?;
50 if value.len() > 2048
51 || url.scheme() != "https"
52 || !url.username().is_empty()
53 || url.password().is_some()
54 || url.fragment().is_some()
55 || url.host_str().is_none()
56 || value.chars().any(|c| c.is_control() || c == '\\')
57 {
58 return Err(reject());
59 }
60 match url.host() {
61 Some(url::Host::Domain(host)) if valid_handle(host) => (),
62 Some(url::Host::Ipv4(ip)) if public_ip(ip.into()) => (),
63 Some(url::Host::Ipv6(ip)) if public_ip(ip.into()) => (),
64 _ => return Err(reject()),
65 }
66 Ok(url)
67}
68
69fn origin(value: &str) -> Result<Url> {
70 let url = https(value)?;
71 if url.path() != "/" || url.query().is_some() {
72 return Err(reject());
73 }
74 Ok(url)
75}
76
77fn valid_handle(value: &str) -> bool {
78 let labels: Vec<_> = value.split('.').collect();
79 value.len() <= 253
80 && labels.len() >= 2
81 && labels.iter().all(|label| {
82 !label.is_empty()
83 && label.len() <= 63
84 && !label.starts_with('-')
85 && !label.ends_with('-')
86 && label
87 .bytes()
88 .all(|b| b.is_ascii_alphanumeric() || b == b'-')
89 })
90 && labels.last().is_some_and(|last| {
91 last.as_bytes()[0].is_ascii_alphabetic()
92 && ![
93 "local",
94 "localhost",
95 "internal",
96 "arpa",
97 "invalid",
98 "test",
99 "onion",
100 ]
101 .contains(last)
102 })
103}
104
105/// Resolve once, validate every address, and pin the connection to prevent DNS rebinding.
106async fn client(url: &Url) -> Result<reqwest::Client> {
107 let host = url.host_str().ok_or_else(reject)?;
108 #[cfg(test)]
109 if matches!(
110 host,
111 "alice.example.com" | "pds.example.com" | "issuer.example.com"
112 ) {
113 if let Ok(client) = tests::HTTP.try_with(Clone::clone) {
114 return Ok(client);
115 }
116 }
117 let addresses: Vec<SocketAddr> = tokio::time::timeout(
118 Duration::from_secs(5),
119 tokio::net::lookup_host((
120 host.trim_matches(['[', ']']),
121 url.port_or_known_default().ok_or_else(reject)?,
122 )),
123 )
124 .await
125 .map_err(|_| reject())?
126 .map_err(|_| reject())?
127 .collect();
128 if addresses.is_empty() || addresses.iter().any(|address| !public_ip(address.ip())) {
129 return Err(reject());
130 }
131 Ok(reqwest::Client::builder()
132 .no_proxy()
133 .redirect(reqwest::redirect::Policy::none())
134 .timeout(Duration::from_secs(10))
135 .connect_timeout(Duration::from_secs(5))
136 .resolve_to_addrs(host, &addresses)
137 .user_agent("Snow Globe AT Protocol sign-in")
138 .build()?)
139}
140
141async fn bytes(mut response: reqwest::Response, limit: usize) -> Result<Vec<u8>> {
142 if response.content_length().is_some_and(|n| n > limit as u64) {
143 return Err(reject());
144 }
145 let mut data = Vec::new();
146 while let Some(chunk) = response.chunk().await.map_err(|_| reject())? {
147 if data.len() + chunk.len() > limit {
148 return Err(reject());
149 }
150 data.extend_from_slice(&chunk);
151 }
152 Ok(data)
153}
154
155async fn get(url: Url) -> Result<Value> {
156 let response = client(&url)
157 .await?
158 .get(url)
159 .header("accept", "application/json")
160 .send()
161 .await
162 .map_err(|_| reject())?;
163 if response.status() != StatusCode::OK {
164 return Err(reject());
165 }
166 serde_json::from_slice(&bytes(response, 65536).await?).map_err(|_| reject())
167}
168
169async fn handle_did(handle: &str) -> Result<String> {
170 if !valid_handle(handle) {
171 return Err(reject());
172 }
173 let resolver = hickory_resolver::Resolver::builder_tokio()
174 .map_err(|_| reject())?
175 .build()
176 .map_err(|_| reject())?;
177 if let Ok(Ok(records)) = tokio::time::timeout(
178 Duration::from_secs(5),
179 resolver.txt_lookup(format!("_atproto.{handle}.")),
180 )
181 .await
182 {
183 let dids: Vec<_> = records
184 .answers()
185 .iter()
186 .filter_map(|record| {
187 let hickory_resolver::proto::rr::RData::TXT(record) = &record.data else {
188 return None;
189 };
190 let text = record
191 .txt_data
192 .iter()
193 .flat_map(|part| part.iter().copied())
194 .collect::<Vec<_>>();
195 String::from_utf8(text)
196 .ok()
197 .and_then(|s| s.strip_prefix("did=").map(str::to_owned))
198 })
199 .collect();
200 if dids.len() > 1 {
201 return Err(reject());
202 }
203 if let Some(did) = dids.into_iter().next() {
204 did_url(&did)?;
205 return Ok(did);
206 }
207 }
208 let url = https(&format!("https://{handle}/.well-known/atproto-did"))?;
209 let response = client(&url)
210 .await?
211 .get(url)
212 .send()
213 .await
214 .map_err(|_| reject())?;
215 if response.status() != StatusCode::OK {
216 return Err(reject());
217 }
218 let did = String::from_utf8(bytes(response, 65536).await?)
219 .map_err(|_| reject())?
220 .trim()
221 .to_owned();
222 did_url(&did)?;
223 Ok(did)
224}
225
226fn did_url(did: &str) -> Result<Url> {
227 if let Some(id) = did.strip_prefix("did:plc:") {
228 if id.len() == 24
229 && id
230 .bytes()
231 .all(|b| b.is_ascii_lowercase() || (b'2'..=b'7').contains(&b))
232 {
233 return https(&format!("https://plc.directory/{did}"));
234 }
235 }
236 if let Some(host) = did
237 .strip_prefix("did:web:")
238 .filter(|host| valid_handle(host))
239 {
240 return https(&format!("https://{host}/.well-known/did.json"));
241 }
242 Err(reject())
243}
244
245async fn identity(did: &str) -> Result<(Url, Option<String>)> {
246 let doc = get(did_url(did)?).await?;
247 if doc["id"] != did {
248 return Err(reject());
249 }
250 let pds = array(&doc["service"])
251 .iter()
252 .find(|service| {
253 (service["id"] == "#atproto_pds" || service["id"] == format!("{did}#atproto_pds"))
254 && service["type"] == "AtprotoPersonalDataServer"
255 })
256 .ok_or_else(reject)?;
257 let pds = origin(string(&pds["serviceEndpoint"]))?;
258 let claimed = array(&doc["alsoKnownAs"])
259 .iter()
260 .filter_map(Value::as_str)
261 .filter_map(|s| s.strip_prefix("at://"))
262 .find(|s| valid_handle(s));
263 let handle = match claimed {
264 Some(handle)
265 if handle_did(handle)
266 .await
267 .is_ok_and(|resolved| resolved == did) =>
268 {
269 Some(handle.to_owned())
270 }
271 _ => None,
272 };
273 Ok((pds, handle))
274}
275
276async fn server(pds: &Url) -> Result<Value> {
277 let resource = get(pds.join(".well-known/oauth-protected-resource")?).await?;
278 if resource["resource"]
279 .as_str()
280 .and_then(|v| origin(v).ok())
281 .as_ref()
282 != Some(pds)
283 {
284 return Err(reject());
285 }
286 let issuers = array(&resource["authorization_servers"]);
287 if issuers.len() != 1 {
288 return Err(reject());
289 }
290 let issuer = string(&issuers[0]);
291 let base = origin(issuer)?;
292 let metadata = get(base.join(".well-known/oauth-authorization-server")?).await?;
293 validate_server(&metadata, issuer)?;
294 Ok(metadata)
295}
296
297fn validate_server(metadata: &Value, issuer: &str) -> Result<()> {
298 origin(issuer)?;
299 if metadata["issuer"] != issuer
300 || metadata["authorization_response_iss_parameter_supported"] != true
301 || metadata["require_pushed_authorization_requests"] != true
302 || metadata["require_request_uri_registration"] == false
303 || metadata["client_id_metadata_document_supported"] != true
304 {
305 return Err(reject());
306 }
307 for (field, value) in [
308 ("response_types_supported", "code"),
309 ("grant_types_supported", "authorization_code"),
310 ("grant_types_supported", "refresh_token"),
311 ("code_challenge_methods_supported", "S256"),
312 ("token_endpoint_auth_methods_supported", "none"),
313 ("scopes_supported", "atproto"),
314 ("dpop_signing_alg_values_supported", "ES256"),
315 ] {
316 if !array(&metadata[field]).iter().any(|item| item == value) {
317 return Err(reject());
318 }
319 }
320 for field in [
321 "authorization_endpoint",
322 "token_endpoint",
323 "pushed_authorization_request_endpoint",
324 ] {
325 https(string(&metadata[field]))?;
326 }
327 Ok(())
328}
329
330pub fn metadata(auth: &auth::Store) -> Value {
331 json!({"client_id":format!("{}auth/guest/metadata/atproto",auth.origin),"client_name":"Shale",
332 "client_uri":auth.origin,"application_type":"web","scope":"atproto",
333 "grant_types":["authorization_code"],"response_types":["code"],
334 "redirect_uris":[format!("{}auth/guest/callback/atproto",auth.origin)],
335 "token_endpoint_auth_method":"none","dpop_bound_access_tokens":true})
336}
337
338fn proof(
339 key: &EcKey<openssl::pkey::Private>,
340 endpoint: &Url,
341 nonce: Option<&str>,
342) -> Result<String> {
343 let mut x = BigNum::new()?;
344 let mut y = BigNum::new()?;
345 let mut context = BigNumContext::new()?;
346 key.public_key()
347 .affine_coordinates_gfp(key.group(), &mut x, &mut y, &mut context)?;
348 let header = json!({"typ":"dpop+jwt","alg":"ES256","jwk":{"kty":"EC","crv":"P-256",
349 "x":URL_SAFE_NO_PAD.encode(x.to_vec_padded(32)?),"y":URL_SAFE_NO_PAD.encode(y.to_vec_padded(32)?)}});
350 let mut target = endpoint.clone();
351 target.set_query(None);
352 let mut claims =
353 json!({"jti":mcp::secret(),"htm":"POST","htu":target.as_str(),"iat":now() as i64});
354 if let Some(nonce) = nonce {
355 claims["nonce"] = json!(nonce);
356 }
357 let payload = format!(
358 "{}.{}",
359 URL_SAFE_NO_PAD.encode(header.to_string()),
360 URL_SAFE_NO_PAD.encode(claims.to_string())
361 );
362 let signature = EcdsaSig::sign(&Sha256::digest(payload.as_bytes()), key)?;
363 let mut raw = signature.r().to_vec_padded(32)?;
364 raw.extend(signature.s().to_vec_padded(32)?);
365 Ok(format!("{payload}.{}", URL_SAFE_NO_PAD.encode(raw)))
366}
367
368async fn post(
369 endpoint: &str,
370 key: &EcKey<openssl::pkey::Private>,
371 form: &[(&str, &str)],
372 nonce: &mut Option<String>,
373 expected: StatusCode,
374) -> Result<Value> {
375 let endpoint = https(endpoint)?;
376 let http = client(&endpoint).await?;
377 for attempt in 0..2 {
378 let response = http
379 .post(endpoint.clone())
380 .header("DPoP", proof(key, &endpoint, nonce.as_deref())?)
381 .header("accept", "application/json")
382 .form(form)
383 .send()
384 .await
385 .map_err(|_| reject())?;
386 let status = response.status();
387 let next_nonce = response
388 .headers()
389 .get("dpop-nonce")
390 .and_then(|n| n.to_str().ok())
391 .filter(|n| !n.is_empty() && n.len() <= 2048)
392 .ok_or_else(reject)?
393 .to_owned();
394 *nonce = Some(next_nonce);
395 let data: Value =
396 serde_json::from_slice(&bytes(response, 65536).await?).map_err(|_| reject())?;
397 if attempt == 0
398 && (status == StatusCode::BAD_REQUEST || status == StatusCode::UNAUTHORIZED)
399 && data["error"] == "use_dpop_nonce"
400 {
401 continue;
402 }
403 if status != expected {
404 return Err(reject());
405 }
406 return Ok(data);
407 }
408 Err(reject())
409}
410
411/// The DID, PDS, and bidirectionally verified handle for a handle or DID.
412pub async fn resolve(identifier: &str) -> Result<(String, Url, Option<String>)> {
413 let identifier = identifier.trim().trim_start_matches('@');
414 let did = if identifier.starts_with("did:") {
415 did_url(identifier)?;
416 identifier.to_owned()
417 } else {
418 handle_did(&identifier.to_ascii_lowercase()).await?
419 };
420 let (pds, handle) = identity(&did).await?;
421 if !identifier.starts_with("did:")
422 && handle.as_deref() != Some(identifier.to_ascii_lowercase().as_str())
423 {
424 return Err(reject());
425 }
426 Ok((did, pds, handle))
427}
428
429pub async fn start(auth: &auth::Store, identifier: &str, next: &str) -> Result<(String, String)> {
430 let (did, pds, _) = resolve(identifier).await?;
431 let server = server(&pds).await?;
432 let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1)?;
433 let key = EcKey::generate(&group)?;
434 let verifier = mcp::secret();
435 let mut flow = json!({"provider":"atproto","next":next,"did":did,"server":server,
436 "verifier":verifier,"key":URL_SAFE_NO_PAD.encode(key.private_key_to_der()?)});
437 let state = auth::issue(&auth.db.lock().unwrap(), "guest", flow.clone(), 300)?;
438 let result = async {
439 let metadata = metadata(auth);
440 let challenge = URL_SAFE_NO_PAD.encode(Sha256::digest(verifier.as_bytes()));
441 let mut nonce = None;
442 let par = post(
443 string(&server["pushed_authorization_request_endpoint"]),
444 &key,
445 &[
446 ("client_id", string(&metadata["client_id"])),
447 ("redirect_uri", string(&metadata["redirect_uris"][0])),
448 ("response_type", "code"),
449 ("scope", "atproto"),
450 ("state", &state),
451 ("code_challenge", &challenge),
452 ("code_challenge_method", "S256"),
453 ("login_hint", &did),
454 ],
455 &mut nonce,
456 StatusCode::CREATED,
457 )
458 .await?;
459 let uri = string(&par["request_uri"]);
460 if uri.is_empty() || uri.len() > 2048 || par["expires_in"].as_u64().is_none_or(|n| n == 0) {
461 return Err(reject());
462 }
463 flow["nonce"] = json!(nonce);
464 auth.db.lock().unwrap().execute(
465 "UPDATE pending SET data=? WHERE hash=? AND kind='guest'",
466 rusqlite::params![flow.to_string(), mcp::hash(&state)],
467 )?;
468 let mut target = https(string(&server["authorization_endpoint"]))?;
469 client(&target).await?;
470 if target
471 .query_pairs()
472 .any(|(key, _)| matches!(key.as_ref(), "client_id" | "request_uri"))
473 {
474 return Err(reject());
475 }
476 target.query_pairs_mut().extend_pairs([
477 ("client_id", string(&metadata["client_id"])),
478 ("request_uri", uri),
479 ]);
480 Ok((target.to_string(), state.clone()))
481 }
482 .await;
483 if result.is_err() {
484 auth::pending(&auth.db.lock().unwrap(), &state, "guest", true)?;
485 }
486 result
487}
488
489pub struct Profile {
490 pub did: String,
491 pub name: String,
492 pub picture: Option<String>,
493 pub url: Option<String>,
494}
495
496pub async fn finish(auth: &auth::Store, flow: &Value, code: &str, issuer: &str) -> Result<Profile> {
497 let server = &flow["server"];
498 if issuer != string(&server["issuer"]) {
499 return Err(reject());
500 }
501 let key = EcKey::private_key_from_der(&URL_SAFE_NO_PAD.decode(string(&flow["key"]))?)?;
502 let metadata = metadata(auth);
503 let mut nonce = flow["nonce"].as_str().map(str::to_owned);
504 let token = post(
505 string(&server["token_endpoint"]),
506 &key,
507 &[
508 ("client_id", string(&metadata["client_id"])),
509 ("grant_type", "authorization_code"),
510 ("code", code),
511 ("redirect_uri", string(&metadata["redirect_uris"][0])),
512 ("code_verifier", string(&flow["verifier"])),
513 ],
514 &mut nonce,
515 StatusCode::OK,
516 )
517 .await?;
518 if token["sub"] != flow["did"]
519 || token["token_type"]
520 .as_str()
521 .is_none_or(|s| !s.eq_ignore_ascii_case("DPoP"))
522 || string(&token["access_token"]).is_empty()
523 || string(&token["scope"]) != "atproto"
524 {
525 return Err(reject());
526 }
527 let did = string(&token["sub"]);
528 let (pds, handle) = identity(did).await?;
529 if self::server(&pds).await?["issuer"] != issuer {
530 return Err(reject());
531 }
532 let mut fallback = Url::parse("https://pdsls.dev/at://")?;
533 fallback
534 .path_segments_mut()
535 .unwrap()
536 .pop_if_empty()
537 .push(did);
538 let mut profile = Profile {
539 did: did.to_owned(),
540 name: handle.clone().unwrap_or_else(|| did.to_owned()),
541 picture: None,
542 url: Some(fallback.into()),
543 };
544 for (collection, site) in [
545 ("sh.tangled.actor.profile", "https://tangled.org/"),
546 ("app.bsky.actor.profile", "https://bsky.app/profile/"),
547 ] {
548 let mut url = pds.join("xrpc/com.atproto.repo.getRecord")?;
549 url.query_pairs_mut().extend_pairs([
550 ("repo", did),
551 ("collection", collection),
552 ("rkey", "self"),
553 ]);
554 let Ok(record) = get(url).await else {
555 continue;
556 };
557 if record["uri"] != format!("at://{did}/{collection}/self")
558 || record["value"]["$type"] != collection
559 {
560 continue;
561 }
562 let value = &record["value"];
563 if let Some(name) = value["displayName"]
564 .as_str()
565 .filter(|s| !s.trim().is_empty() && !s.chars().any(char::is_control))
566 {
567 profile.name = name.chars().take(128).collect();
568 }
569 let mut link = Url::parse(site)?;
570 link.path_segments_mut()
571 .unwrap()
572 .pop_if_empty()
573 .push(handle.as_deref().unwrap_or(did));
574 profile.url = Some(link.into());
575 let blob = &value["avatar"];
576 let cid = string(&blob["ref"]["$link"]);
577 if blob["$type"] == "blob"
578 && matches!(
579 string(&blob["mimeType"]),
580 "image/png" | "image/jpeg" | "image/webp"
581 )
582 && !cid.is_empty()
583 && cid.len() <= 256
584 && cid.bytes().all(|b| b.is_ascii_alphanumeric())
585 {
586 let mut avatar = pds.join("xrpc/com.atproto.sync.getBlob")?;
587 avatar
588 .query_pairs_mut()
589 .extend_pairs([("did", did), ("cid", cid)]);
590 if let Ok(http) = client(&avatar).await
591 && let Ok(response) = http.get(avatar).send().await
592 && response.status() == StatusCode::OK
593 && let Ok(data) = bytes(response, 262144).await
594 {
595 let mime = if data.starts_with(b"\x89PNG\r\n\x1a\n") {
596 Some("image/png")
597 } else if data.starts_with(b"\xff\xd8\xff") {
598 Some("image/jpeg")
599 } else if data.starts_with(b"RIFF") && data.get(8..12) == Some(b"WEBP") {
600 Some("image/webp")
601 } else {
602 None
603 };
604 if let Some(mime) = mime {
605 profile.picture = Some(format!(
606 "data:{mime};base64,{}",
607 base64::engine::general_purpose::STANDARD.encode(data)
608 ));
609 }
610 }
611 }
612 break;
613 }
614 Ok(profile)
615}
616
617#[cfg(test)]
618mod tests {
619 use super::*;
620 use futures::FutureExt;
621 use std::io::BufRead;
622 use std::process::{Command, Stdio};
623 tokio::task_local! { pub(super) static HTTP: reqwest::Client; }
624
625 #[test]
626 fn rejects_local_networks_and_malformed_identifiers() {
627 for ip in [
628 "0.0.0.0",
629 "10.0.0.1",
630 "100.64.0.1",
631 "127.0.0.1",
632 "169.254.169.254",
633 "172.31.0.1",
634 "192.168.1.1",
635 "192.0.0.1",
636 "198.18.0.1",
637 "224.0.0.1",
638 "255.255.255.255",
639 "::1",
640 "::ffff:127.0.0.1",
641 "64:ff9b::7f00:1",
642 "2002:7f00::1",
643 "2001:db8::1",
644 "fc00::1",
645 "fe80::1",
646 ] {
647 assert!(!public_ip(ip.parse().unwrap()), "{ip}");
648 }
649 for url in [
650 "http://example.com",
651 "https://user:pass@example.com",
652 "https://127.1",
653 "https://2130706433",
654 "https://[::1]",
655 "https://example.com/#bad",
656 "https://x.local",
657 "https://localhost",
658 "https://example.com\\@127.0.0.1",
659 ] {
660 assert!(https(url).is_err(), "{url}");
661 }
662 for did in [
663 "did:web:localhost",
664 "did:web:example.com:profile",
665 "did:web:example.com%3A443",
666 "did:web:127.0.0.1",
667 "did:plc:../oops",
668 "did:plc:aaaaaaaaaaaaaaaaaaaaaaa1",
669 ] {
670 assert!(did_url(did).is_err(), "{did}");
671 }
672 assert!(did_url("did:plc:ewvi7nxzyoun6zhxrhs64oiz").is_ok());
673 assert!(did_url("did:web:example.com").is_ok());
674 assert!(public_ip("8.8.8.8".parse().unwrap()));
675 assert!(public_ip("2606:4700:4700::1111".parse().unwrap()));
676 }
677
678 #[tokio::test]
679 async fn synthetic_https_pds_verifies_par_pkce_dpop_and_identity() {
680 let root = std::env::temp_dir().join(format!("atproto-test-{}", uuid::Uuid::new_v4()));
681 std::fs::create_dir(&root).unwrap();
682 let cert = root.join("cert.pem");
683 let key = root.join("key.pem");
684 assert!(Command::new("openssl").args(["req","-x509","-newkey","rsa:2048","-nodes","-days","1","-subj","/CN=fixture","-addext","subjectAltName=DNS:alice.example.com,DNS:pds.example.com,DNS:issuer.example.com","-addext","basicConstraints=critical,CA:FALSE","-keyout"])
685 .arg(&key).arg("-out").arg(&cert).output().unwrap().status.success());
686 let mut child = Command::new("python3")
687 .arg(concat!(
688 env!("CARGO_MANIFEST_DIR"),
689 "/tests/atproto-fixture.py"
690 ))
691 .arg(&cert)
692 .arg(&key)
693 .stdout(Stdio::piped())
694 .spawn()
695 .unwrap();
696 let mut line = String::new();
697 std::io::BufReader::new(child.stdout.take().unwrap())
698 .read_line(&mut line)
699 .unwrap();
700 let address = format!("127.0.0.1:{}", line.trim()).parse().unwrap();
701 let mut builder = reqwest::Client::builder()
702 .no_proxy()
703 .redirect(reqwest::redirect::Policy::none())
704 .timeout(Duration::from_secs(5))
705 .add_root_certificate(
706 reqwest::Certificate::from_pem(&std::fs::read(&cert).unwrap()).unwrap(),
707 );
708 for host in ["alice.example.com", "pds.example.com", "issuer.example.com"] {
709 builder = builder.resolve(host, address);
710 }
711 let http = builder.build().unwrap();
712 let result = std::panic::AssertUnwindSafe(HTTP.scope(http.clone(), async {
713 let auth = auth::Store::new(
714 &root.join("accounts"),
715 "https://snowglobe.example.com",
716 "https://files.example.com",
717 "auth.example.com",
718 )
719 .unwrap();
720 for (mode, succeeds) in [
721 ("", true),
722 ("bluesky-only", true),
723 ("no-profiles", true),
724 ("rotating-nonce", true),
725 ("endpoint-query", true),
726 ("wrong-subject", false),
727 ("changed-issuer", false),
728 ("wrong-metadata-issuer", false),
729 ("missing-nonce", false),
730 ("private-pds", false),
731 ] {
732 http.get(format!(
733 "https://issuer.example.com/fixture/mode?mode={mode}"
734 ))
735 .send()
736 .await
737 .unwrap();
738 let started = start(&auth, "did:web:alice.example.com", "/fixture").await;
739 if matches!(
740 mode,
741 "wrong-metadata-issuer" | "missing-nonce" | "private-pds"
742 ) {
743 assert!(started.is_err(), "{mode}");
744 continue;
745 }
746 let (target, state) = started.unwrap();
747 let code = Url::parse(&target)
748 .unwrap()
749 .query_pairs()
750 .find(|(key, _)| key == "request_uri")
751 .unwrap()
752 .1
753 .into_owned();
754 let flow = auth::pending(&auth.db.lock().unwrap(), &state, "guest", true).unwrap();
755 assert!(
756 auth::pending(&auth.db.lock().unwrap(), &state, "guest", true)
757 .unwrap()
758 .is_null()
759 );
760 assert!(
761 finish(&auth, &flow, &code, "https://wrong.example.com")
762 .await
763 .is_err()
764 );
765 let profile = finish(&auth, &flow, &code, "https://issuer.example.com").await;
766 assert_eq!(profile.is_ok(), succeeds, "{mode}");
767 if let Ok(profile) = profile {
768 assert_eq!(profile.did, "did:web:alice.example.com");
769 if mode == "no-profiles" {
770 assert!(profile.picture.is_none());
771 assert_eq!(profile.name, "did:web:alice.example.com");
772 assert_eq!(
773 profile.url.as_deref(),
774 Some("https://pdsls.dev/at://did:web:alice.example.com")
775 );
776 } else {
777 assert!(
778 profile
779 .picture
780 .as_deref()
781 .unwrap()
782 .starts_with("data:image/png;base64,")
783 );
784 assert_eq!(profile.name, "Fixture Alice");
785 assert!(profile.url.unwrap().starts_with(if mode == "bluesky-only" {
786 "https://bsky.app/profile/"
787 } else {
788 "https://tangled.org/"
789 }));
790 }
791 assert!(
792 finish(&auth, &flow, &code, "https://issuer.example.com")
793 .await
794 .is_err()
795 );
796 }
797 }
798 assert!(
799 get(https("https://issuer.example.com/redirect").unwrap())
800 .await
801 .is_err()
802 );
803 assert!(
804 get(https("https://issuer.example.com/oversized").unwrap())
805 .await
806 .is_err()
807 );
808 }))
809 .catch_unwind()
810 .await;
811 child.kill().unwrap();
812 child.wait().unwrap();
813 std::fs::remove_dir_all(root).unwrap();
814 if let Err(panic) = result {
815 std::panic::resume_unwind(panic);
816 }
817 }
818}