//! Google Code Assist project admission (SMH-SPEC-PLUG0001). use super::{AuthorizationFault, LoginPolicy}; use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use smith::tool::CancelHandle; use std::time::{Duration, Instant}; const OPERATION_NAME_BYTES_MAX: usize = 512; const OPERATION_OBSERVATIONS_MAX: usize = 32; /// Public installed-app protocol identity, not a user credential. pub(super) const CLIENT_SECRET: &str = "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"; /// Validated noncredential project identifier; cold profile-owned metadata. #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(try_from = "String", into = "String")] pub struct CodeAssistProject(String); impl CodeAssistProject { pub(super) fn new(project: &str) -> Result { if !(6..=63).contains(&project.len()) || !project.as_bytes()[0].is_ascii_lowercase() || !project.as_bytes()[project.len() - 1].is_ascii_alphanumeric() || !project .bytes() .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-') { return Err("invalid Google Code Assist project ID"); } Ok(Self(project.into())) } /// Bounded project ID, safe to pass as immutable request context. #[must_use] pub fn as_str(&self) -> &str { &self.0 } } impl TryFrom for CodeAssistProject { type Error = &'static str; fn try_from(value: String) -> Result { Self::new(&value) } } impl From for String { fn from(value: CodeAssistProject) -> Self { value.0 } } fn project( value: Option<&Value>, configured: Option<&CodeAssistProject>, ) -> Result { match value { Some(value) => CodeAssistProject::new( value .as_str() .ok_or(AuthorizationFault::Rejected("invalid Code Assist project"))?, ) .map_err(AuthorizationFault::Rejected), None => configured.cloned().ok_or(AuthorizationFault::Rejected( "Code Assist requires --project or eligible managed project", )), } } const OPERATION_POLL_INTERVAL: Duration = Duration::from_secs(5); const OPERATION_WAIT_CHECK_INTERVAL: Duration = Duration::from_millis(50); trait OperationWait { fn wait(&self, deadline: Instant, cancel: &CancelHandle) -> Result<(), AuthorizationFault>; } struct DeadlineOperationWait; impl OperationWait for DeadlineOperationWait { fn wait(&self, deadline: Instant, cancel: &CancelHandle) -> Result<(), AuthorizationFault> { let wait_deadline = Instant::now() .checked_add(OPERATION_POLL_INTERVAL) .unwrap_or(deadline) .min(deadline); loop { if cancel.is_cancelled() { return Err(AuthorizationFault::Cancelled); } let remaining = wait_deadline.saturating_duration_since(Instant::now()); if remaining.is_zero() { return if Instant::now() >= deadline { Err(AuthorizationFault::Deadline) } else { Ok(()) }; } std::thread::sleep(remaining.min(OPERATION_WAIT_CHECK_INTERVAL)); } } } fn observe_operation( mut operation: Value, deadline: Instant, cancel: &CancelHandle, waiter: &W, mut observe: F, ) -> Result where W: OperationWait, F: FnMut() -> Result, { for _ in 0..OPERATION_OBSERVATIONS_MAX { if operation["done"] == true { return Ok(operation); } waiter.wait(deadline, cancel)?; if cancel.is_cancelled() { return Err(AuthorizationFault::Cancelled); } if Instant::now() >= deadline { return Err(AuthorizationFault::Deadline); } operation = observe()?; } Ok(operation) } fn operation_path(name: &str) -> Result { if name.len() > OPERATION_NAME_BYTES_MAX { return Err(AuthorizationFault::Rejected( "Code Assist operation path bound exceeded", )); } let segments: Vec<_> = name.split('/').collect(); let valid = matches!( segments.as_slice(), ["operations", _] | ["projects", _, "locations", _, "operations", _] ); if !valid || segments.iter().any(|segment| { segment.is_empty() || !segment .bytes() .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_')) }) { return Err(AuthorizationFault::Rejected( "unauthorized Code Assist operation path", )); } Ok(format!("/v1internal/{name}")) } pub(super) fn setup( policy: &LoginPolicy, access: &str, configured: Option<&CodeAssistProject>, deadline: Instant, cancel: &CancelHandle, ) -> Result { let origin = policy .resource .strip_suffix("/v1internal") .ok_or(AuthorizationFault::Authority)?; if origin != "https://cloudcode-pa.googleapis.com" && !(origin == policy.issuer && origin.starts_with("http://127.0.0.1:")) { return Err(AuthorizationFault::Authority); } let metadata = json!({"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}); let mut load = json!({"metadata":metadata}); if let Some(configured) = configured { load["cloudaicompanionProject"] = json!(configured.as_str()); load["metadata"]["duetProject"] = json!(configured.as_str()); } let loaded = crate::http::CredentialHttp::control( &format!("{origin}/v1internal:loadCodeAssist"), Some(&load), access, deadline, cancel, )?; let onboard = match setup_decision(&loaded, configured, &metadata)? { SetupDecision::Ready(project) => return Ok(project), SetupDecision::Onboard(request) => request, }; // One onboarding POST only: an uncertain response never replays this effect. let operation = crate::http::CredentialHttp::control( &format!("{origin}/v1internal:onboardUser"), Some(&onboard), access, deadline, cancel, )?; let path = if operation["done"] == true { None } else { Some(operation_path(operation["name"].as_str().ok_or( AuthorizationFault::Rejected("missing Code Assist operation"), )?)?) }; // Bounded observations, no automatic re-onboarding or untrusted URL following. let operation = observe_operation(operation, deadline, cancel, &DeadlineOperationWait, || { let path = path.as_deref().ok_or(AuthorizationFault::Authority)?; crate::http::CredentialHttp::control( &format!("{origin}{path}"), None, access, deadline, cancel, ) .map_err(AuthorizationFault::from) })?; if operation["done"] != true { return Err(AuthorizationFault::Rejected( "Code Assist operation observation bound exceeded", )); } if operation.get("error").is_some() { return Err(AuthorizationFault::Rejected( "Code Assist onboarding rejected", )); } project( operation.pointer("/response/cloudaicompanionProject/id"), configured, ) } enum SetupDecision { Ready(CodeAssistProject), Onboard(Value), } fn setup_decision( loaded: &Value, configured: Option<&CodeAssistProject>, metadata: &Value, ) -> Result { if loaded.get("currentTier").is_some_and(Value::is_object) { return project(loaded.get("cloudaicompanionProject"), configured) .map(SetupDecision::Ready); } if loaded .get("ineligibleTiers") .and_then(Value::as_array) .is_some_and(|tiers| { tiers .iter() .any(|tier| tier["reasonCode"] == "VALIDATION_REQUIRED") }) { return Err(AuthorizationFault::Rejected( "Code Assist setup requires unsupported validation", )); } let tiers = loaded.get("allowedTiers").and_then(Value::as_array); if tiers.is_some_and(|tiers| tiers.len() > 16) { return Err(AuthorizationFault::Rejected( "Code Assist tier bound exceeded", )); } let tier = tiers .and_then(|tiers| tiers.iter().find(|tier| tier["isDefault"] == true)) .and_then(|tier| tier["id"].as_str()) .unwrap_or("legacy-tier"); if !matches!(tier, "free-tier" | "standard-tier" | "legacy-tier") { return Err(AuthorizationFault::Rejected("unsupported Code Assist tier")); } let mut onboard = json!({"tierId":tier,"metadata":metadata}); if tier != "free-tier" { let configured = configured.ok_or(AuthorizationFault::Rejected( "nonfree Code Assist setup requires --project", ))?; onboard["cloudaicompanionProject"] = json!(configured.as_str()); onboard["metadata"]["duetProject"] = json!(configured.as_str()); } Ok(SetupDecision::Onboard(onboard)) } pub(super) fn retain_refresh( response: &mut Value, previous: &str, ) -> Result<(), AuthorizationFault> { let response = response .as_object_mut() .ok_or(AuthorizationFault::Rejected("invalid OAuth token response"))?; if !response.contains_key("refresh_token") { response.insert("refresh_token".into(), Value::String(previous.into())); } Ok(()) } #[cfg(test)] mod tests { use super::*; use std::cell::Cell; struct ImmediateWait { calls: Cell, outcome: Result<(), AuthorizationFault>, } impl OperationWait for ImmediateWait { fn wait(&self, _: Instant, _: &CancelHandle) -> Result<(), AuthorizationFault> { self.calls.set(self.calls.get() + 1); self.outcome } } #[test] fn operation_waits_before_get_and_blocks_cancel_or_deadline_dispatch() { let waiter = ImmediateWait { calls: Cell::new(0), outcome: Ok(()), }; let dispatched = Cell::new(0); let operation = observe_operation( json!({"done":false}), Instant::now() + Duration::from_secs(1), &CancelHandle::new(), &waiter, || { dispatched.set(dispatched.get() + 1); Ok(json!({"done":true})) }, ) .unwrap(); assert_eq!(operation["done"], true); assert_eq!(waiter.calls.get(), 1); assert_eq!(dispatched.get(), 1); for (deadline, outcome, expected) in [ ( Instant::now() + Duration::from_secs(1), Err(AuthorizationFault::Cancelled), AuthorizationFault::Cancelled, ), (Instant::now(), Ok(()), AuthorizationFault::Deadline), ] { let waiter = ImmediateWait { calls: Cell::new(0), outcome, }; let dispatched = Cell::new(0); let result = observe_operation( json!({"done":false}), deadline, &CancelHandle::new(), &waiter, || { dispatched.set(dispatched.get() + 1); Ok(json!({"done":true})) }, ); assert_eq!(result, Err(expected)); assert_eq!(dispatched.get(), 0); } } #[test] fn setup_admits_returned_project_prefers_it_over_config_and_requires_project_for_nonfree() { let configured = CodeAssistProject::new("configured-project").unwrap(); for (loaded, expected) in [ ( json!({"currentTier":{"id":"standard-tier"},"cloudaicompanionProject":"returned-project"}), "returned-project", ), ( json!({"currentTier":{"id":"standard-tier"}}), "configured-project", ), ] { let SetupDecision::Ready(project) = setup_decision(&loaded, Some(&configured), &json!({})).unwrap() else { panic!("existing tier should not onboard") }; assert_eq!(project.as_str(), expected); } for loaded in [ json!({"currentTier":{"id":"standard-tier"}}), json!({"allowedTiers":[{"id":"standard-tier","isDefault":true}]}), json!({"ineligibleTiers":[{"reasonCode":"VALIDATION_REQUIRED","validationUrl":"https://untrusted"}]}), json!({"allowedTiers":[{"id":"unknown-tier","isDefault":true}]}), json!({"currentTier":{},"cloudaicompanionProject":"not/a/project"}), ] { assert!( setup_decision(&loaded, None, &json!({})).is_err(), "{loaded}" ); } let SetupDecision::Onboard(request) = setup_decision( &json!({"allowedTiers":[{"id":"free-tier","isDefault":true}]}), Some(&configured), &json!({"pluginType":"GEMINI"}), ) .unwrap() else { panic!("free tier should onboard") }; assert_eq!( request, json!({"tierId":"free-tier","metadata":{"pluginType":"GEMINI"}}) ); let SetupDecision::Onboard(request) = setup_decision( &json!({}), Some(&configured), &json!({"pluginType":"GEMINI"}), ) .unwrap() else { panic!("legacy tier should onboard") }; assert_eq!( request, json!({"tierId":"legacy-tier","cloudaicompanionProject":"configured-project","metadata":{"pluginType":"GEMINI","duetProject":"configured-project"}}) ); } #[test] fn operation_authority_rejects_urls_traversal_and_other_methods() { for name in [ "https://evil/operations/one", "../operations/one", "operations/%2e%2e", "operations/a?alt=json", "v1internal:loadCodeAssist", "operations/", "projects/p/operations/o", ] { assert!(operation_path(name).is_err(), "{name}"); } assert_eq!( operation_path("operations/one").unwrap(), "/v1internal/operations/one" ); assert!(operation_path("projects/project/locations/global/operations/one").is_ok()); } #[test] fn setup_allows_configured_standard_tier_despite_unrelated_ineligibility() { let configured = CodeAssistProject::new("configured-project").unwrap(); let SetupDecision::Onboard(request) = setup_decision( &json!({ "allowedTiers":[{"id":"standard-tier","isDefault":true}], "ineligibleTiers":[{"id":"free-tier","reasonCode":"INELIGIBLE"}] }), Some(&configured), &json!({"pluginType":"GEMINI"}), ) .unwrap() else { panic!("configured standard tier should onboard") }; assert_eq!(request["tierId"], "standard-tier"); } #[test] fn retain_refresh_rejects_nonobject_renewal_responses_without_panicking() { for mut response in [ json!([]), json!(true), json!(7), json!("token"), json!(null), ] { let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { retain_refresh(&mut response, "previous-refresh") })); assert!( matches!( outcome, Ok(Err(AuthorizationFault::Rejected( "invalid OAuth token response" ))) ), "{response}" ); } } #[test] fn project_metadata_validates_deserialization_and_size() { assert_eq!(size_of::(), size_of::()); for value in [ "", "123456", "UPPER-project", "has/slash", "bad-project-", "short", ] { assert!(CodeAssistProject::new(value).is_err()); assert!(serde_json::from_value::(json!(value)).is_err()); } assert_eq!( CodeAssistProject::new("managed-project").unwrap().as_str(), "managed-project" ); } }