//! SMH-SPEC-SPEC0001, SMH-SPEC-PLUG0001: OAuth identity and storage boundaries. use super::*; use serde_json::json; fn policy() -> LoginPolicy { LoginPolicy { flow: super::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), token_origin: "https://issuer.example".into(), issuer: "https://issuer.example".into(), resource: "https://resource.example/v1".into(), 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()], } } fn pending() -> PendingLogin { PendingLogin { state: "attempt-state".into(), nonce: "attempt-nonce".into(), verifier: "fixture-verifier".into(), redirect: "http://127.0.0.1:1234/auth/callback".into(), } } fn callback(query: &str) -> String { format!("GET /auth/callback?{query} HTTP/1.1\r\nHost: 127.0.0.1:1234\r\n\r\n") } #[test] fn callback_requires_exact_state_host_path_and_issued_identity() { let attempt = pending(); let valid = callback("state=attempt-state&code=fixture-code&client_id=oaiapp_fixture"); assert_eq!( attempt.callback(&valid, "oaiapp_", None).unwrap().client_id, "oaiapp_fixture" ); for invalid in [ valid.replace("attempt-state", "foreign-state"), valid.replace("127.0.0.1", "localhost"), valid.replace("/auth/callback?", "/callback?"), valid.replace("oaiapp_fixture", "dynamic_agent_client"), callback( "state=attempt-state&state=attempt-state&code=fixture-code&client_id=oaiapp_fixture", ), callback( "state=attempt-state&error=access_denied&code=fixture-code&client_id=oaiapp_fixture", ), valid.replace("fixture-code", "%0Acredential"), valid.replace("fixture-code", "%ZZ"), ] { assert!(attempt.callback(&invalid, "oaiapp_", None).is_err()); } } #[test] fn returning_callback_uses_selected_client_and_rejects_rebinding() { let attempt = pending(); let request = callback("state=attempt-state&code=fixture-code"); assert_eq!( attempt .callback(&request, "oaiapp_", Some("oaiapp_saved")) .unwrap() .client_id, "oaiapp_saved" ); assert!( attempt .callback( &callback("state=attempt-state&code=fixture-code&client_id=oaiapp_foreign"), "oaiapp_", Some("oaiapp_saved") ) .is_err() ); } #[test] fn discovery_rejects_origin_confusion_and_remote_jwks() { for url in [ "https://evil.example/keys", "https://issuer.example.evil/keys", "https://issuer.example@evil/keys", "https://issuer.example//evil/keys", "https://issuer.example/keys#x", "http://issuer.example/keys", ] { assert!( endpoint( &json!({"jwks_uri":url}), "jwks_uri", "https://issuer.example" ) .is_err(), "{url}" ); } assert_eq!( endpoint( &json!({"jwks_uri":"https://issuer.example/keys"}), "jwks_uri", "https://issuer.example" ) .unwrap(), "https://issuer.example/keys" ); } #[test] fn atomic_profile_store_keeps_stable_host_and_metadata_only_reopen() { let root = std::env::temp_dir().join(format!("oauth-store-{}", smith::id::SessionId::new())); let store = ProfileStore::at(root.clone()); let host = store.host_id().unwrap(); assert!( host.starts_with("urn:uuid:"), "host identity must be a UUID URI" ); assert_eq!(host.len(), 45); assert_eq!(ProfileStore::at(root.clone()).host_id().unwrap(), host); let metadata = ProfileMetadata { flow: super::LoginFlow::DynamicOidc, connection_id: "openai-chatgpt-plan".into(), id: "a".repeat(64), issuer: policy().issuer, subject: "fixture-subject".into(), client_id: "oaiapp_fixture".into(), workspace: None, code_assist_project: None, label: "fixture@example.test".into(), scopes: policy().scopes, expires_at: 1000, }; store .save(Profile { metadata: metadata.clone(), tokens: Some(TokenSet { access: "fixture-access".into(), refresh: "fixture-refresh".into(), identity: "fixture-id-token".into(), }), refresh_pending: false, }) .unwrap(); assert_eq!( ProfileStore::at(root.clone()).list().unwrap(), vec![metadata] ); let listing = serde_json::to_string(&store.list().unwrap()).unwrap(); for secret in ["fixture-access", "fixture-refresh", "fixture-id-token"] { assert!(!listing.contains(secret)); } #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; assert_eq!( std::fs::metadata(root.join("profiles.json")) .unwrap() .permissions() .mode() & 0o777, 0o600 ); } std::fs::remove_dir_all(root).unwrap(); } fn token_response(claims: &Value) -> (Value, Value) { let (identity, keys) = crate::oauth_crypto::tests::signed(claims); ( json!({"access_token":"fixture-access", "refresh_token":"fixture-refresh", "id_token":identity, "token_type":"Bearer", "expires_in":3600, "scope":"openid chatgpt.tokens.use.direct"}), keys, ) } fn valid_claims() -> Value { json!({"iss":policy().issuer, "sub":"fixture-subject", "aud":"oaiapp_fixture", "nonce":pending().nonce, "exp":2000, "email":"fixture@example.test"}) } #[test] fn signed_identity_requires_issuer_audience_nonce_expiry_and_grant() { let claims = valid_claims(); let (response, keys) = token_response(&claims); assert!( validated_profile( &policy(), Some(&pending().nonce), "oaiapp_fixture", &response, &keys, 1000 ) .is_ok() ); for (field, invalid) in [ ("iss", json!("https://foreign.example")), ("aud", json!("oaiapp_foreign")), ("nonce", json!("foreign-attempt")), ("exp", json!(1000)), ("nbf", json!(1001)), ("iat", json!(1001)), ("sub", json!(null)), ] { let mut invalid_claims = claims.clone(); invalid_claims[field] = invalid; let (response, keys) = token_response(&invalid_claims); assert!( validated_profile( &policy(), Some(&pending().nonce), "oaiapp_fixture", &response, &keys, 1000 ) .is_err(), "{field}" ); } for scope in [ "openid", "chatgpt.tokens.use.direct", "openid chatgpt.tokens.use.direct unauthorized", ] { let mut invalid_response = response.clone(); invalid_response["scope"] = json!(scope); assert!( validated_profile( &policy(), Some(&pending().nonce), "oaiapp_fixture", &invalid_response, &keys, 1000 ) .is_err() ); } } #[test] fn signed_metadata_cannot_echo_credentials_into_listing() { for access in [ "fixture-access", r#"fixture-\"quoted\"-access"#, r"fixture-\-access", ] { let mut claims = valid_claims(); claims["email"] = json!(access); let (mut response, keys) = token_response(&claims); response["access_token"] = json!(access); assert!( validated_profile( &policy(), Some(&pending().nonce), "oaiapp_fixture", &response, &keys, 1000 ) .is_err() ); } } #[test] fn cancelling_an_accepted_trickling_callback_terminates_before_read_gap() { let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap(); let address = listener.local_addr().unwrap(); let cancel = CancelHandle::new(); let client_cancel = cancel.clone(); let (release, released) = std::sync::mpsc::sync_channel(1); let client = std::thread::spawn(move || { let mut stream = TcpStream::connect(address).unwrap(); stream.write_all(b"GET /auth/callback?").unwrap(); client_cancel.cancel(); released.recv().unwrap(); }); let start = Instant::now(); let error = receive_callback(listener, start + LOGIN_TIMEOUT, &cancel).unwrap_err(); release.send(()).unwrap(); client.join().unwrap(); assert_eq!(error, "OAuth login cancelled"); assert!( start.elapsed() < Duration::from_secs(1), "cancellation must not wait for callback read gap" ); } #[test] fn cancelled_and_expired_callback_waits_join_without_publishing_profiles() { for cancelled in [false, true] { let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap(); let cancel = CancelHandle::new(); if cancelled { cancel.cancel(); } let deadline = Instant::now(); let error = receive_callback(listener, deadline, &cancel).unwrap_err(); assert!(error.contains(if cancelled { "cancelled" } else { "deadline" })); } #[cfg(target_arch = "x86_64")] { assert_eq!(std::mem::size_of::(), 96); assert_eq!(std::mem::size_of::(), 48); } } #[test] fn profile_listing_rejects_corrupt_and_oversized_protected_store() { let root = std::env::temp_dir().join(format!("oauth-corrupt-{}", smith::id::SessionId::new())); let store = ProfileStore::at(root.clone()); store.host_id().unwrap(); let file = root.join("profiles.json"); for corrupt in [ b"".to_vec(), b"{}".to_vec(), b"not-json".to_vec(), vec![b'x'; 512 * 1024 + 1], ] { std::fs::write(&file, corrupt).unwrap(); assert!(store.list().is_err()); } std::fs::remove_dir_all(root).unwrap(); } #[test] fn form_roundtrip_preserves_encoding_and_equal_key_value() { for pair in [("same", "same"), ("code", "spaces + % = & ☃"), ("", "")] { assert_eq!( parse_form(&form(&[pair])).unwrap(), vec![(pair.0.into(), pair.1.into())] ); } } fn opaque_policy() -> LoginPolicy { let mut policy = policy(); policy.flow = LoginFlow::FixedClientPkceOpaque; policy.connection_id = "anthropic-claude-plan".into(); policy.initial_client = "fixture-fixed-client".into(); policy.issued_prefix.clear(); policy.scopes = vec!["user:inference".into(), "user:profile".into()]; policy.required_scopes = vec!["user:inference".into()]; policy } #[test] fn opaque_profiles_have_only_local_identity_and_require_exact_selected_authority() { let policy = opaque_policy(); let response = json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600}); let first = opaque_profile(&policy, None, &response, 100).unwrap(); let second = opaque_profile(&policy, None, &response, 100).unwrap(); assert_ne!(first.metadata.id, second.metadata.id); assert_eq!(first.metadata.id.len(), 64); assert!(first.metadata.subject.is_empty()); assert!(first.metadata.workspace.is_none()); assert!(first.tokens.as_ref().unwrap().identity.is_empty()); let reduced = json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600,"scope":"user:inference"}); let first = opaque_profile(&policy, None, &reduced, 100).unwrap(); assert_eq!(first.metadata.scopes, ["user:inference"]); let renewed = opaque_profile(&policy, Some(&first.metadata), &response, 200).unwrap(); assert_eq!(renewed.metadata.id, first.metadata.id); assert_eq!(renewed.metadata.scopes, ["user:inference"]); let fresh = opaque_profile(&policy, None, &response, 200).unwrap(); assert_eq!(fresh.metadata.scopes, policy.scopes); assert_eq!(renewed.metadata.expires_at, 3800); for mismatch in ["flow", "connection", "issuer", "client"] { let mut wrong = policy.clone(); match mismatch { "flow" => wrong.flow = LoginFlow::DynamicOidc, "connection" => wrong.connection_id = "openai-chatgpt-plan".into(), "issuer" => wrong.issuer = "https://foreign.example".into(), _ => wrong.initial_client = "foreign-client".into(), } assert!( opaque_profile(&wrong, Some(&first.metadata), &response, 100).is_err(), "{mismatch}" ); } assert!( validated_profile( &policy, None, "fixture-fixed-client", &response, &json!({}), 100 ) .is_err() ); } #[test] fn opaque_credentials_enforce_bounds_without_relaxing_oidc_identity_requirement() { let policy = opaque_policy(); let valid = json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600}); for (name, value) in [ ("access_token", json!("")), ("refresh_token", json!(null)), ("expires_in", json!(0)), ("expires_in", json!(86401)), ("token_type", json!("Basic")), ("scope", json!("foreign-scope")), ("access_token", json!("line\nbreak")), ("refresh_token", json!("x".repeat(32769))), ] { let mut invalid = valid.clone(); invalid[name] = value; assert!( opaque_profile(&policy, None, &invalid, 100).is_err(), "{name}" ); } let mut oidc_response = valid; oidc_response["scope"] = json!("openid chatgpt.tokens.use.direct"); oidc_response["token_type"] = json!("Bearer"); assert!( validated_profile( &self::policy(), None, "oaiapp_fixture", &oidc_response, &json!({}), 100 ) .is_err() ); } #[test] fn opaque_profile_namespace_rejects_cross_vendor_selection_and_renewal_before_io() { let root = std::env::temp_dir().join(format!("opaque-boundary-{}", smith::id::SessionId::new())); let store = ProfileStore::at(root.clone()); store.host_id().unwrap(); let policy = opaque_policy(); let profile = opaque_profile(&policy, None, &json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600}), 100).unwrap(); let id = profile.metadata.id.clone(); store.save(profile).unwrap(); let mut wrong = policy.clone(); wrong.connection_id = "openai-chatgpt-plan".into(); assert!( LoginAuthority::new(wrong.clone(), store.clone()) .unwrap() .select_profile(&id) .is_err() ); assert!(matches!( store.renew(&id, &wrong, &CancelHandle::new()), Err(AuthorizationFault::Authority) )); std::fs::remove_dir_all(root).unwrap(); } #[test] fn login_flow_tag_fits_one_byte() { assert_eq!(std::mem::size_of::(), 1); assert_eq!(std::mem::size_of::(), 1); } #[test] fn fixed_client_callback_accepts_exact_public_identity_with_dots() { let attempt = pending(); let client = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"; let request = callback("state=attempt-state&code=fixture-code"); assert_eq!( attempt .callback(&request, "", Some(client)) .unwrap() .client_id, client ); let rebound = callback( "state=attempt-state&code=fixture-code&client_id=other.apps.googleusercontent.com", ); assert!(attempt.callback(&rebound, "", Some(client)).is_err()); } #[test] fn google_refresh_retains_only_omitted_token_and_keeps_profile_project_and_scopes() { let mut policy = opaque_policy(); policy.flow = LoginFlow::GoogleInstalledPkce; policy.connection_id = "google-gemini-cli-plan".into(); let valid = json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600,"scope":"user:inference"}); let mut first = opaque_profile(&policy, None, &valid, 100).unwrap(); first.metadata.code_assist_project = Some(google::CodeAssistProject::new("managed-project").unwrap()); let mut omitted = json!({"access_token":"rotated-access","expires_in":3600}); assert!( opaque_profile(&policy, None, &omitted, 100).is_err(), "initial login needs refresh token" ); google::retain_refresh(&mut omitted, "fixture-refresh").unwrap(); let renewed = opaque_profile(&policy, Some(&first.metadata), &omitted, 200).unwrap(); assert_eq!(renewed.tokens.unwrap().refresh, "fixture-refresh"); assert_eq!( renewed.metadata.code_assist_project, first.metadata.code_assist_project ); assert_eq!(renewed.metadata.scopes, ["user:inference"]); for replacement in [json!(""), json!(null), json!(123), json!("bad token")] { let mut invalid = omitted.clone(); invalid["refresh_token"] = replacement; google::retain_refresh(&mut invalid, "fixture-refresh").unwrap(); assert!(opaque_profile(&policy, Some(&first.metadata), &invalid, 200).is_err()); } let mut valid_replacement = omitted; valid_replacement["refresh_token"] = json!("replacement-refresh"); google::retain_refresh(&mut valid_replacement, "fixture-refresh").unwrap(); assert_eq!( opaque_profile(&policy, Some(&first.metadata), &valid_replacement, 200) .unwrap() .tokens .unwrap() .refresh, "replacement-refresh" ); let mut wrong = policy; wrong.connection_id = "anthropic-claude-plan".into(); assert!(opaque_profile(&wrong, Some(&first.metadata), &valid_replacement, 200).is_err()); } #[test] fn google_profile_cannot_silently_rebind_its_admitted_project() { let root = std::env::temp_dir().join(format!( "google-project-binding-{}", smith::id::SessionId::new() )); let store = ProfileStore::at(root.clone()); store.host_id().unwrap(); let mut policy = opaque_policy(); policy.flow = LoginFlow::GoogleInstalledPkce; policy.connection_id = "google-gemini-cli-plan".into(); let response = json!({"access_token":"fixture-access","refresh_token":"fixture-refresh","expires_in":3600}); let mut first = opaque_profile(&policy, None, &response, 100).unwrap(); first.metadata.code_assist_project = Some(google::CodeAssistProject::new("first-project").unwrap()); let selected = store.save(first).unwrap(); assert!( LoginAuthority::new(policy.clone(), store.clone()) .unwrap() .select_profile(&selected.id) .unwrap() .with_google_project("other-project") .is_err(), "selected Google profile must reject a different configured project before any effect" ); assert!( LoginAuthority::new(policy.clone(), store.clone()) .unwrap() .select_profile(&selected.id) .unwrap() .with_google_project("first-project") .is_ok() ); let mut rebound = opaque_profile(&policy, Some(&selected), &response, 200).unwrap(); rebound.metadata.code_assist_project = Some(google::CodeAssistProject::new("other-project").unwrap()); assert!(store.save(rebound).is_err()); assert_eq!( store.list().unwrap()[0].code_assist_project, selected.code_assist_project ); std::fs::remove_dir_all(root).unwrap(); }