Luigit
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();
}