//! Rotating refresh crash boundaries (`SMH-SPEC-SPEC0001`, `SMH-SPEC-PLUG0001`). use super::*; use serde_json::json; use std::path::PathBuf; use std::sync::mpsc; const DEADLINE: Duration = Duration::from_secs(3); fn stored(issuer: &str) -> (PathBuf, ProfileStore, LoginPolicy) { let root = std::env::temp_dir().join(format!("oauth-rotation-{}", smith::id::SessionId::new())); let store = ProfileStore::at(root.clone()); store.host_id().unwrap(); let policy = LoginPolicy { flow: super::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), token_origin: issuer.into(), issuer: issuer.into(), resource: format!("{issuer}/v1"), initial_client: "dynamic_agent_client".into(), issued_prefix: "oaiapp_".into(), authorization_path: "/authorize".into(), token_path: "/token".into(), agent_name: "Smith".into(), scopes: vec!["openid".into(), "chatgpt.tokens.use.direct".into()], required_scopes: vec!["openid".into(), "chatgpt.tokens.use.direct".into()], }; store .save(Profile { metadata: ProfileMetadata { flow: super::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), id: "a".repeat(64), issuer: issuer.into(), subject: "subject".into(), client_id: "oaiapp_fixture".into(), workspace: None, code_assist_project: None, label: "fixture".into(), scopes: policy.scopes.clone(), expires_at: 0, }, tokens: Some(TokenSet { access: "fixture-old-access".into(), refresh: "fixture-old-refresh".into(), identity: "fixture-old-identity".into(), }), refresh_pending: false, }) .unwrap(); (root, store, policy) } fn accept(listener: &TcpListener) -> (TcpStream, String) { let (mut stream, _) = listener.accept().unwrap(); stream.set_read_timeout(Some(DEADLINE)).unwrap(); stream.set_write_timeout(Some(DEADLINE)).unwrap(); let mut bytes = Vec::new(); loop { let mut byte = [0]; stream.read_exact(&mut byte).unwrap(); bytes.push(byte[0]); assert!(bytes.len() <= 8192); if bytes.ends_with(b"\r\n\r\n") { break; } } let head = String::from_utf8(bytes).unwrap(); let length = head .lines() .filter_map(|line| line.split_once(':')) .find(|(name, _)| name.eq_ignore_ascii_case("content-length")) .map_or(0, |(_, length)| length.trim().parse::().unwrap()); assert!(length <= 8192); let mut body = vec![0; length]; stream.read_exact(&mut body).unwrap(); (stream, head + &String::from_utf8(body).unwrap()) } fn respond(stream: &mut TcpStream, status: &str, value: &Value) { let bytes = serde_json::to_vec(value).unwrap(); write!( stream, "HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", bytes.len() ) .unwrap(); stream.write_all(&bytes).unwrap(); } #[test] fn refresh_pending_precedes_dispatch_serializes_parallel_calls_and_prevents_replay_after_response_loss() { for invalid_grant in [false, true] { let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap(); let issuer = format!("http://{}", listener.local_addr().unwrap()); let (root, store, policy) = stored(&issuer); let (sent, dispatched) = mpsc::sync_channel(1); let (release, released) = mpsc::sync_channel(1); let server = std::thread::spawn(move || { let (mut stream, request) = accept(&listener); assert!(request.starts_with("GET /.well-known/openid-configuration ")); respond( &mut stream, "200 OK", &json!({"issuer":issuer,"jwks_uri":format!("{issuer}/keys")}), ); drop(stream); let (mut stream, request) = accept(&listener); assert!(request.starts_with("POST /token ")); assert!(request.contains("refresh_token=fixture-old-refresh")); sent.send(()).unwrap(); released.recv_timeout(DEADLINE).unwrap(); if invalid_grant { respond( &mut stream, "400 Bad Request", &json!({"error":"invalid_grant"}), ); } drop(stream); listener }); let worker_store = store.clone(); let worker_policy = policy.clone(); let worker = std::thread::spawn(move || { worker_store.renew(&"a".repeat(64), &worker_policy, &CancelHandle::new()) }); dispatched.recv_timeout(DEADLINE).unwrap(); let bytes = std::fs::read(root.join("profiles.json")).unwrap(); let pending: Value = serde_json::from_slice(&bytes).unwrap(); assert_eq!(pending["profiles"][0]["refresh_pending"], true); assert!(matches!( store.renew(&"a".repeat(64), &policy, &CancelHandle::new()), Err(AuthorizationFault::Storage( "OAuth profile store busy; no exchange started" )) )); release.send(()).unwrap(); assert_eq!( worker.join().unwrap().err().unwrap(), if invalid_grant { AuthorizationFault::ReauthenticationRequired } else { AuthorizationFault::ExchangeUncertain } ); let listener = server.join().unwrap(); assert_eq!( store .renew(&"a".repeat(64), &policy, &CancelHandle::new()) .err() .unwrap(), AuthorizationFault::ReauthenticationRequired ); listener.set_nonblocking(true).unwrap(); assert_eq!( listener.accept().err().unwrap().kind(), std::io::ErrorKind::WouldBlock ); let reopened: Value = serde_json::from_slice(&std::fs::read(root.join("profiles.json")).unwrap()).unwrap(); assert_eq!(reopened["profiles"][0]["refresh_pending"], true); assert_eq!(reopened["profiles"][0]["tokens"].is_null(), invalid_grant); assert_eq!(store.list().unwrap().len(), 1); std::fs::remove_dir_all(root).unwrap(); } } #[test] fn renewable_module_policy_must_match_selected_host_authority_before_io() { let (root, store, policy) = stored("https://issuer.example"); let mut authority = LoginAuthority::new(policy.clone(), store) .unwrap() .select_profile(&"a".repeat(64)) .unwrap(); authority.begin_dispatch(CancelHandle::new()); let mut foreign = policy; foreign.resource = "https://foreign.example/v1".into(); assert_eq!( authority .renew_for_dispatch(&"a".repeat(64), &foreign) .unwrap_err(), AuthorizationFault::Authority ); assert!(authority.take_credential().is_none()); std::fs::remove_dir_all(root).unwrap(); } #[test] fn logout_after_preflight_still_blocks_renewal_without_network() { let (root, store, policy) = stored("https://issuer.example"); let id = "a".repeat(64); store.renewable_profile_available(&id).unwrap(); let path = root.join("profiles.json"); let mut profile: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); profile["profiles"][0]["tokens"] = Value::Null; std::fs::write(&path, serde_json::to_vec(&profile).unwrap()).unwrap(); assert!(matches!( store.renew(&id, &policy, &CancelHandle::new()), Err(AuthorizationFault::ReauthenticationRequired) )); std::fs::remove_dir_all(root).unwrap(); } #[test] fn unexpired_identity_only_profile_cannot_dispatch_plan_usage() { let (root, store, policy) = stored("https://issuer.example"); let path = root.join("profiles.json"); let mut profile: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); profile["profiles"][0]["metadata"]["expires_at"] = json!(4_102_444_800_u64); profile["profiles"][0]["metadata"]["scopes"] = json!(["openid"]); std::fs::write(&path, serde_json::to_vec(&profile).unwrap()).unwrap(); assert!(matches!( store.renew(&"a".repeat(64), &policy, &CancelHandle::new()), Err(AuthorizationFault::ReauthenticationRequired) )); std::fs::remove_dir_all(root).unwrap(); } #[test] fn malformed_or_legacy_host_identity_fails_actionably_without_replacing_host() { let (root, store, _) = stored("https://issuer.example"); let path = root.join("profiles.json"); let mut value: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); for identity in [ "12345678-1234-4234-8234-123456789012", "urn:uuid:zzzzzzzz-1234-4234-8234-123456789012", "urn:uuid:12345678-1234-1234-8234-123456789012", ] { value["host_id"] = json!(identity); let bytes = serde_json::to_vec(&value).unwrap(); std::fs::write(&path, &bytes).unwrap(); assert!( store .host_id() .err() .unwrap() .contains("restore the original store") ); assert_eq!(std::fs::read(&path).unwrap(), bytes); } #[cfg(target_arch = "x86_64")] { assert_eq!(std::mem::size_of::(), 24); assert_eq!(std::mem::size_of::(), 72); assert_eq!( std::mem::size_of::(), 72 ); } std::fs::remove_dir_all(root).unwrap(); }