repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/oauth/tests.rs
Raw//! 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::<PendingLogin>(), 96);
assert_eq!(std::mem::size_of::<Callback>(), 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::<LoginFlow>(), 1);
assert_eq!(std::mem::size_of::<super::login::SubscriptionProvider>(), 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();
}