| ... | ... | @@ -309,7 +309,7 @@ async fn exchange( |
| 309 | 309 | code: &str, |
| 310 | 310 | callback: &str, |
| 311 | 311 | flow: &Value, |
| 312 | | ) -> Result<(String, String, Option<String>)> { |
| 312 | ) -> Result<(String, String, Option<String>, Option<String>)> { |
| 313 | 313 | let form = [ |
| 314 | 314 | ("client_id", client), |
| 315 | 315 | ("client_secret", secret), |
| ... | ... | @@ -366,7 +366,7 @@ async fn exchange( |
| 366 | 366 | "GitHub couldn't verify your account. Return to Shale and try again.", |
| 367 | 367 | ) |
| 368 | 368 | })?; |
| 369 | | return Ok((id.to_string(), login.to_owned(), None)); |
| 369 | return Ok((id.to_string(), login.to_owned(), None, None)); |
| 370 | 370 | } |
| 371 | 371 | let mut form = form.to_vec(); |
| 372 | 372 | form.push(("state", "none")); |
| ... | ... | @@ -451,7 +451,42 @@ async fn exchange( |
| 451 | 451 | && url.password().is_none() |
| 452 | 452 | }) |
| 453 | 453 | .map(String::from); |
| 454 | | Ok((string(&profile["sub"]).to_owned(), name, picture)) |
| 454 | Ok(( |
| 455 | string(&profile["sub"]).to_owned(), |
| 456 | name, |
| 457 | picture, |
| 458 | profile["preferred_username"] |
| 459 | .as_str() |
| 460 | .map(str::to_lowercase), |
| 461 | )) |
| 462 | } |
| 463 | |
| 464 | fn username(provider: &str, subject: &str) -> String { |
| 465 | let suffix = if provider == "github" { |
| 466 | subject.to_owned() |
| 467 | } else { |
| 468 | mcp::hash(subject)[..24].to_owned() |
| 469 | }; |
| 470 | format!("guest-{provider}-{suffix}") |
| 471 | } |
| 472 | |
| 473 | fn create( |
| 474 | db: &Connection, |
| 475 | provider: &str, |
| 476 | username: &str, |
| 477 | name: &str, |
| 478 | picture: Option<&str>, |
| 479 | ) -> Result<String> { |
| 480 | let id = uuid::Uuid::new_v4().to_string(); |
| 481 | let mut profile = json!({"kind":"guest","guestProvider":provider,"username":username,"enabled":true,"email":null,"emailVerified":false,"firstName":name,"lastName":null,"requiredActions":[],"attributes":{},"createdTimestamp":(now()*1000.0) as i64}); |
| 482 | if let Some(picture) = picture { |
| 483 | profile["attributes"]["picture"] = json!([picture]); |
| 484 | } |
| 485 | db.execute( |
| 486 | "INSERT INTO users(id,profile) VALUES (?,?)", |
| 487 | sql![id, profile.to_string()], |
| 488 | )?; |
| 489 | Ok(id) |
| 455 | 490 | } |
| 456 | 491 | |
| 457 | 492 | fn account( |
| ... | ... | @@ -485,20 +520,7 @@ fn account( |
| 485 | 520 | tx.commit()?; |
| 486 | 521 | return Ok(id); |
| 487 | 522 | } |
| 488 | | let id = uuid::Uuid::new_v4().to_string(); |
| 489 | | let suffix = if provider == "github" { |
| 490 | | subject.to_owned() |
| 491 | | } else { |
| 492 | | mcp::hash(subject)[..24].to_owned() |
| 493 | | }; |
| 494 | | let mut profile = json!({"kind":"guest","guestProvider":provider,"username":format!("guest-{provider}-{suffix}"),"enabled":true,"email":null,"emailVerified":false,"firstName":name,"lastName":null,"requiredActions":[],"attributes":{},"createdTimestamp":(now()*1000.0) as i64}); |
| 495 | | if let Some(picture) = picture { |
| 496 | | profile["attributes"]["picture"] = json!([picture]); |
| 497 | | } |
| 498 | | tx.execute( |
| 499 | | "INSERT INTO users(id,profile) VALUES (?,?)", |
| 500 | | sql![id, profile.to_string()], |
| 501 | | )?; |
| 523 | let id = create(&tx, provider, &username(provider, subject), name, picture)?; |
| 502 | 524 | tx.execute( |
| 503 | 525 | "INSERT INTO external_identities VALUES (?,?,?)", |
| 504 | 526 | sql![provider, subject, id], |
| ... | ... | @@ -507,6 +529,138 @@ fn account( |
| 507 | 529 | Ok(id) |
| 508 | 530 | } |
| 509 | 531 | |
| 532 | /// Astheno's per-client subjects require binding reserved names at verified sign-in. |
| 533 | fn claim(auth: &auth::Store, subject: &str, username: &str) -> Result<()> { |
| 534 | auth.db.lock().unwrap().execute( |
| 535 | "INSERT OR IGNORE INTO external_identities SELECT 'astheno',?,id FROM users WHERE username=? AND id NOT IN (SELECT user_id FROM external_identities)", |
| 536 | sql![subject, format!("guest-astheno-{username}")], |
| 537 | )?; |
| 538 | Ok(()) |
| 539 | } |
| 540 | |
| 541 | fn grant(auth: &auth::Store, provider: &str, subject: Option<&str>, name: &str) -> Result<Value> { |
| 542 | let mut db = auth.db.lock().unwrap(); |
| 543 | let tx = db.transaction()?; |
| 544 | let known: Vec<String> = match subject { |
| 545 | Some(subject) => vec![subject.to_owned()], |
| 546 | None => tx |
| 547 | .prepare("SELECT subject FROM external_identities JOIN users ON users.id=user_id WHERE provider=? AND lower(json_extract(profile,'$.firstName'))=?")? |
| 548 | .query_map(sql![provider, name], |r| r.get(0))? |
| 549 | .collect::<std::result::Result<_, _>>()?, |
| 550 | }; |
| 551 | if known.len() > 1 { |
| 552 | return Err(Error::new( |
| 553 | 409, |
| 554 | "Several accounts have signed in with that name. Open the right one under guests and join it to knife-native.", |
| 555 | )); |
| 556 | } |
| 557 | let username = match known.first() { |
| 558 | Some(subject) => username(provider, subject), |
| 559 | None => format!("guest-{provider}-{name}"), |
| 560 | }; |
| 561 | let existing: Option<String> = tx |
| 562 | .query_row("SELECT id FROM users WHERE username=?", [&username], |r| r.get(0)) |
| 563 | .optional()?; |
| 564 | let id = match &existing { |
| 565 | Some(id) => id.clone(), |
| 566 | None => { |
| 567 | let id = create(&tx, provider, &username, name, None)?; |
| 568 | if let Some(subject) = subject { |
| 569 | tx.execute( |
| 570 | "INSERT INTO external_identities VALUES (?,?,?)", |
| 571 | sql![provider, subject, id], |
| 572 | )?; |
| 573 | } |
| 574 | id |
| 575 | } |
| 576 | }; |
| 577 | tx.execute( |
| 578 | "INSERT OR IGNORE INTO memberships SELECT ?,id FROM roles WHERE name='knife-native'", |
| 579 | [&id], |
| 580 | )?; |
| 581 | tx.commit()?; |
| 582 | Ok(json!({"id":id,"created":existing.is_none()})) |
| 583 | } |
| 584 | |
| 585 | async fn github_user(http: &reqwest::Client, login: &str) -> Result<(u64, String)> { |
| 586 | if login.is_empty() |
| 587 | || login.len() > 39 |
| 588 | || login.starts_with('-') |
| 589 | || !login.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') |
| 590 | { |
| 591 | return Err(Error::new(400, "Enter a GitHub username.")); |
| 592 | } |
| 593 | let unavailable = || Error::new(502, "GitHub didn't answer. Try again in a minute."); |
| 594 | let response = http |
| 595 | .get(format!("https://api.github.com/users/{login}")) |
| 596 | .send() |
| 597 | .await |
| 598 | .map_err(|_| unavailable())?; |
| 599 | if response.status() == StatusCode::NOT_FOUND { |
| 600 | return Err(Error::new(404, format!("GitHub has no user named {login}."))); |
| 601 | } |
| 602 | let profile = json_bytes(&response_bytes(response).await.map_err(|_| unavailable())?) |
| 603 | .map_err(|_| unavailable())?; |
| 604 | match (profile["id"].as_u64(), profile["login"].as_str()) { |
| 605 | (Some(id), Some(name)) if id > 0 && name.eq_ignore_ascii_case(login) => { |
| 606 | Ok((id, name.to_owned())) |
| 607 | } |
| 608 | _ => Err(unavailable()), |
| 609 | } |
| 610 | } |
| 611 | |
| 612 | pub async fn add(auth: &auth::Store, provider: &str, handle: &str) -> Result<Value> { |
| 613 | let label = known(provider)?; |
| 614 | let registered: bool = auth.db.lock().unwrap().query_row( |
| 615 | "SELECT ?1='atproto' OR EXISTS(SELECT 1 FROM guest_providers WHERE id=?1)", |
| 616 | [provider], |
| 617 | |r| r.get(0), |
| 618 | )?; |
| 619 | if !registered { |
| 620 | return Err(Error::new( |
| 621 | 409, |
| 622 | format!("{label} sign-in isn't set up. Register it with tools/guest-provider.py {provider}."), |
| 623 | )); |
| 624 | } |
| 625 | let handle = handle.trim().trim_start_matches('@'); |
| 626 | match provider { |
| 627 | "github" => { |
| 628 | let (id, login) = github_user(&http()?, handle).await?; |
| 629 | grant(auth, provider, Some(&id.to_string()), &login) |
| 630 | } |
| 631 | "atproto" => { |
| 632 | let (did, _, handle) = atproto::resolve(handle).await.map_err(|_| { |
| 633 | Error::new(404, "Couldn't find that AT handle. Check the spelling.") |
| 634 | })?; |
| 635 | let name = handle.unwrap_or_else(|| did.clone()); |
| 636 | grant(auth, provider, Some(&did), &name) |
| 637 | } |
| 638 | _ => { |
| 639 | let name = handle.to_lowercase(); |
| 640 | if name.len() > 16 |
| 641 | || !name.starts_with(|c: char| c.is_ascii_alphanumeric()) |
| 642 | || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b"._-".contains(&b)) |
| 643 | { |
| 644 | return Err(Error::new(400, "Enter an Astheno username.")); |
| 645 | } |
| 646 | grant(auth, provider, None, &name) |
| 647 | } |
| 648 | } |
| 649 | } |
| 650 | |
| 651 | fn http() -> Result<reqwest::Client> { |
| 652 | Ok(reqwest::Client::builder() |
| 653 | .timeout(Duration::from_secs(10)) |
| 654 | .redirect(reqwest::redirect::Policy::none()) |
| 655 | .user_agent("Snow Globe guest sign-in") |
| 656 | .default_headers({ |
| 657 | let mut headers = HeaderMap::new(); |
| 658 | headers.insert("accept", "application/json".parse().unwrap()); |
| 659 | headers |
| 660 | }) |
| 661 | .build()?) |
| 662 | } |
| 663 | |
| 510 | 664 | fn fields(query: &str) -> Result<HashMap<String, String>> { |
| 511 | 665 | let mut map = HashMap::new(); |
| 512 | 666 | for (k, v) in url::form_urlencoded::parse(query.as_bytes()) { |
| ... | ... | @@ -709,18 +863,11 @@ async fn handle(app: &App, request: Request) -> Result<Response> { |
| 709 | 863 | return auth.create_session(&id, "dashboard", headers, None); |
| 710 | 864 | } |
| 711 | 865 | let (client, secret) = registration(auth, provider)?; |
| 712 | | let http = reqwest::Client::builder() |
| 713 | | .timeout(Duration::from_secs(10)) |
| 714 | | .redirect(reqwest::redirect::Policy::none()) |
| 715 | | .user_agent("Snow Globe guest sign-in") |
| 716 | | .default_headers({ |
| 717 | | let mut headers = HeaderMap::new(); |
| 718 | | headers.insert("accept", "application/json".parse().unwrap()); |
| 719 | | headers |
| 720 | | }) |
| 721 | | .build()?; |
| 722 | | let (subject, name, picture) = |
| 723 | | exchange(&http, provider, &client, &secret, code, &callback, &flow).await?; |
| 866 | let (subject, name, picture, handle) = |
| 867 | exchange(&http()?, provider, &client, &secret, code, &callback, &flow).await?; |
| 868 | if let Some(handle) = handle { |
| 869 | claim(auth, &subject, &handle)?; |
| 870 | } |
| 724 | 871 | let id = account(auth, provider, &subject, &name, picture.as_deref())?; |
| 725 | 872 | auth.create_session(&id, "dashboard", headers, None) |
| 726 | 873 | } |
| ... | ... | @@ -1011,4 +1158,82 @@ mod tests { |
| 1011 | 1158 | drop(auth); |
| 1012 | 1159 | std::fs::remove_dir_all(path).unwrap(); |
| 1013 | 1160 | } |
| 1161 | |
| 1162 | fn members(auth: &auth::Store, id: &str) -> Value { |
| 1163 | auth::user(&auth.db.lock().unwrap(), id).unwrap()["groups"].clone() |
| 1164 | } |
| 1165 | |
| 1166 | #[test] |
| 1167 | fn added_guests_are_the_accounts_their_first_sign_in_finds() { |
| 1168 | let path = std::env::temp_dir().join(format!("guest-add-test-{}", uuid::Uuid::new_v4())); |
| 1169 | let auth = auth::Store::new( |
| 1170 | &path, |
| 1171 | "https://snowglobe.paperclover.net", |
| 1172 | "https://file.paperclover.net", |
| 1173 | "auth.paperclover.net", |
| 1174 | ) |
| 1175 | .unwrap(); |
| 1176 | for (provider, subject) in [("github", "123"), ("atproto", "did:plc:ewvi7nxzyoun6zhxrhs64oiz")] { |
| 1177 | let added = grant(&auth, provider, Some(subject), "octo").unwrap(); |
| 1178 | let id = string(&added["id"]); |
| 1179 | assert_eq!(added["created"], true); |
| 1180 | assert_eq!(members(&auth, id)[0]["name"], "knife-native"); |
| 1181 | assert_eq!(account(&auth, provider, subject, "renamed", None).unwrap(), id); |
| 1182 | assert_eq!(grant(&auth, provider, Some(subject), "octo").unwrap()["created"], false); |
| 1183 | assert_eq!(members(&auth, id).as_array().unwrap().len(), 1); |
| 1184 | } |
| 1185 | |
| 1186 | let reserved = string(&grant(&auth, "astheno", None, "alice").unwrap()["id"]).to_owned(); |
| 1187 | let identities = |id: &str| -> i64 { |
| 1188 | auth.db.lock().unwrap().query_row("SELECT count(*) FROM external_identities WHERE user_id=?", [id], |r| r.get(0)).unwrap() |
| 1189 | }; |
| 1190 | assert_eq!(identities(&reserved), 0); |
| 1191 | claim(&auth, "sub-2", "mallory").unwrap(); |
| 1192 | assert_eq!(identities(&reserved), 0); |
| 1193 | let stranger = account(&auth, "astheno", "sub-2", "mallory", None).unwrap(); |
| 1194 | assert_ne!(stranger, reserved); |
| 1195 | assert_eq!(members(&auth, &stranger), json!([])); |
| 1196 | claim(&auth, "sub-1", "alice").unwrap(); |
| 1197 | assert_eq!(account(&auth, "astheno", "sub-1", "alice", None).unwrap(), reserved); |
| 1198 | assert_eq!(members(&auth, &reserved)[0]["name"], "knife-native"); |
| 1199 | claim(&auth, "sub-3", "alice").unwrap(); |
| 1200 | let impostor = account(&auth, "astheno", "sub-3", "alice", None).unwrap(); |
| 1201 | assert_ne!(impostor, reserved); |
| 1202 | assert_eq!(members(&auth, &impostor), json!([])); |
| 1203 | |
| 1204 | let earlier = account(&auth, "astheno", "sub-9", "carol", None).unwrap(); |
| 1205 | let added = grant(&auth, "astheno", None, "carol").unwrap(); |
| 1206 | assert_eq!((string(&added["id"]), &added["created"]), (earlier.as_str(), &json!(false))); |
| 1207 | assert_eq!(members(&auth, &earlier)[0]["name"], "knife-native"); |
| 1208 | account(&auth, "astheno", "sub-5", "dave", None).unwrap(); |
| 1209 | account(&auth, "astheno", "sub-6", "dave", None).unwrap(); |
| 1210 | assert_eq!(grant(&auth, "astheno", None, "dave").unwrap_err().status, 409); |
| 1211 | drop(auth); |
| 1212 | std::fs::remove_dir_all(path).unwrap(); |
| 1213 | } |
| 1214 | |
| 1215 | #[tokio::test] |
| 1216 | async fn adding_needs_a_registered_provider_and_a_plausible_name() { |
| 1217 | let path = std::env::temp_dir().join(format!("guest-add-test-{}", uuid::Uuid::new_v4())); |
| 1218 | let auth = auth::Store::new( |
| 1219 | &path, |
| 1220 | "https://snowglobe.paperclover.net", |
| 1221 | "https://file.paperclover.net", |
| 1222 | "auth.paperclover.net", |
| 1223 | ) |
| 1224 | .unwrap(); |
| 1225 | assert_eq!(add(&auth, "astheno", "alice").await.unwrap_err().status, 409); |
| 1226 | assert_eq!(add(&auth, "gitlab", "alice").await.unwrap_err().status, 404); |
| 1227 | provision(&auth, json!({"provider":"astheno","enabled":true,"clientId":"client","clientSecret":"0123456789abcdef"})).unwrap(); |
| 1228 | for name in ["", "has space", "-alice", "a-name-over-sixteen"] { |
| 1229 | assert_eq!(add(&auth, "astheno", name).await.unwrap_err().status, 400, "{name}"); |
| 1230 | } |
| 1231 | let added = add(&auth, "astheno", " @Alice ").await.unwrap(); |
| 1232 | assert_eq!( |
| 1233 | auth::user(&auth.db.lock().unwrap(), string(&added["id"])).unwrap()["username"], |
| 1234 | "guest-astheno-alice" |
| 1235 | ); |
| 1236 | drop(auth); |
| 1237 | std::fs::remove_dir_all(path).unwrap(); |
| 1238 | } |
| 1014 | 1239 | } |