| 1 | use crate::*; |
| 2 | use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; |
| 3 | use openssl::{ |
| 4 | bn::{BigNum, BigNumContext}, |
| 5 | ec::{EcGroup, EcKey}, |
| 6 | ecdsa::EcdsaSig, |
| 7 | nid::Nid, |
| 8 | }; |
| 9 | use sha2::{Digest, Sha256}; |
| 10 | use std::net::{IpAddr, SocketAddr}; |
| 11 | use url::Url; |
| 12 | |
| 13 | fn 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 | |
| 20 | fn 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 | |
| 48 | fn 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 | |
| 69 | fn 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 | |
| 77 | fn 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. |
| 106 | async 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 | |
| 141 | async 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 | |
| 155 | async 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 | |
| 169 | async 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 | |
| 226 | fn 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 | |
| 245 | async 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 | |
| 276 | async 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 | |
| 297 | fn 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 | |
| 330 | pub 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 | |
| 338 | fn 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 | |
| 368 | async 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. |
| 412 | pub 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 | |
| 429 | pub 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 | |
| 489 | pub struct Profile { |
| 490 | pub did: String, |
| 491 | pub name: String, |
| 492 | pub picture: Option<String>, |
| 493 | pub url: Option<String>, |
| 494 | } |
| 495 | |
| 496 | pub 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)] |
| 618 | mod 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 | } |