Lightweight coding agent that runs in your terminal
Rust
Forward workload identity context during token exchange (#38767)
cooper-oai12933b695513
diff --git a/codex-rs/login/src/auth/workload_identity.rs b/codex-rs/login/src/auth/workload_identity.rsindex f5f16ab906..e71a57b836 100644--- a/codex-rs/login/src/auth/workload_identity.rs+++ b/codex-rs/login/src/auth/workload_identity.rs@@ -11,6 +11,7 @@ use codex_http_client::HttpClientFactory;use codex_protocol::config_types::ForcedLoginMethod;use codex_protocol::shell_environment::OPENAI_FEDERATION_RULE_ID_ENV_VAR;use codex_protocol::shell_environment::OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR;+use codex_protocol::shell_environment::OPENAI_WORKLOAD_IDENTITY_CONTEXT_ENV_VAR;use codex_workload_identity::WorkloadIdentityConfig;use codex_workload_identity::WorkloadIdentityError;use codex_workload_identity::WorkloadIdentityExchange;@@ -47,13 +48,34 @@ impl WorkloadIdentityEnvironment {}}-#[derive(Clone, Debug)]+#[derive(Clone)]struct WorkloadIdentitySessionConfig {assertion_file: PathBuf,environment: WorkloadIdentityEnvironment,federation_rule_id: String,http_client_factory: HttpClientFactory,token_url: Url,+ workload_identity_context: Option<String>,+}++impl std::fmt::Debug for WorkloadIdentitySessionConfig {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ formatter+ .debug_struct("WorkloadIdentitySessionConfig")+ .field("assertion_file", &self.assertion_file)+ .field("environment", &self.environment)+ .field("federation_rule_id", &self.federation_rule_id)+ .field("http_client_factory", &self.http_client_factory)+ .field("token_url", &self.token_url)+ .field(+ "workload_identity_context",+ &self+ .workload_identity_context+ .as_ref()+ .map(|_| "[redacted]"),+ )+ .finish()+ }}impl WorkloadIdentitySessionConfig {@@ -63,15 +85,17 @@ impl WorkloadIdentitySessionConfig {environment: self.environment,federation_rule_id: self.federation_rule_id.trim().to_string(),token_url: self.token_url.to_string(),+ workload_identity_context: self.workload_identity_context.clone(),}}fn into_exchange(self) -> Result<WorkloadIdentityExchange, WorkloadIdentityError> {- WorkloadIdentityExchange::new(- WorkloadIdentityConfig::new(self.federation_rule_id, self.assertion_file)?,- self.token_url,- self.http_client_factory,- )+ let config = WorkloadIdentityConfig::new(+ self.federation_rule_id,+ self.assertion_file,+ self.workload_identity_context,+ )?;+ WorkloadIdentityExchange::new(config, self.token_url, self.http_client_factory)}}@@ -81,6 +105,7 @@ struct WorkloadIdentityFingerprint {environment: WorkloadIdentityEnvironment,federation_rule_id: String,token_url: String,+ workload_identity_context: Option<String>,}#[derive(Debug, Error)]@@ -126,6 +151,10 @@ fn resolve_config(environment.identity_token_file,OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR,)?;+ let workload_identity_context = optional_unicode(+ environment.workload_identity_context,+ OPENAI_WORKLOAD_IDENTITY_CONTEXT_ENV_VAR,+ )?;let auth_environment = classify_auth_environment(chatgpt_base_url)?;Ok(Some(WorkloadIdentitySessionConfig {@@ -134,6 +163,7 @@ fn resolve_config(federation_rule_id,http_client_factory: auth_route_config.http_client_factory().clone(),token_url: auth_environment.token_url()?,+ workload_identity_context,}))}@@ -169,6 +199,19 @@ fn required_unicode(Ok(value.to_string())}+fn optional_unicode(+ value: Option<OsString>,+ variable: &'static str,+) -> Result<Option<String>, WorkloadIdentitySessionError> {+ value+ .map(|value| {+ value.into_string().map_err(|_| {+ invalid_config(format!("workload identity variable {variable} is invalid"))+ })+ })+ .transpose()+}+fn classify_auth_environment(base_url: &str,) -> Result<WorkloadIdentityEnvironment, WorkloadIdentitySessionError> {@@ -203,6 +246,7 @@ fn invalid_config(message: impl Into<String>) -> WorkloadIdentitySessionError {struct ProcessEnvironment {federation_rule_id: Option<OsString>,identity_token_file: Option<OsString>,+ workload_identity_context: Option<OsString>,}impl ProcessEnvironment {@@ -210,6 +254,7 @@ impl ProcessEnvironment {Self {federation_rule_id: std::env::var_os(OPENAI_FEDERATION_RULE_ID_ENV_VAR),identity_token_file: std::env::var_os(OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR),+ workload_identity_context: std::env::var_os(OPENAI_WORKLOAD_IDENTITY_CONTEXT_ENV_VAR),}}diff --git a/codex-rs/login/src/auth/workload_identity_tests.rs b/codex-rs/login/src/auth/workload_identity_tests.rsindex 15d5115553..e11eca1116 100644--- a/codex-rs/login/src/auth/workload_identity_tests.rs+++ b/codex-rs/login/src/auth/workload_identity_tests.rs@@ -21,6 +21,7 @@ fn complete_environment() -> ProcessEnvironment {ProcessEnvironment {federation_rule_id: Some("rule-one".into()),identity_token_file: Some(std::env::temp_dir().join("identity-token").into_os_string()),+ workload_identity_context: None,}}@@ -48,6 +49,18 @@ fn markers_select_wif_and_partial_configuration_fails_closed() {.expect("no markers").is_none());+ assert!(+ resolve_for_test(+ ProcessEnvironment {+ workload_identity_context: Some(r#"{"instance_id":"box-one"}"#.into()),+ ..ProcessEnvironment::default()+ },+ /*chatgpt_login_allowed*/ true,+ "https://chatgpt.com/backend-api",+ )+ .expect("context alone is not a WIF marker")+ .is_none()+ );for (environment, missing) in [(ProcessEnvironment {@@ -131,6 +144,24 @@ fn auth_policy_and_app_environment_are_enforced() {assert!(error.to_string().contains("app routing"));}+#[test]+fn workload_context_is_preserved_without_logging_its_value() {+ let context = r#"{"instance_id":"box-one"}"#;+ let config = resolve_for_test(+ ProcessEnvironment {+ workload_identity_context: Some(context.into()),+ ..complete_environment()+ },+ /*chatgpt_login_allowed*/ true,+ "https://chatgpt.com/backend-api",+ )+ .expect("valid configuration")+ .expect("WIF selected");++ assert_eq!(config.workload_identity_context.as_deref(), Some(context));+ assert!(!format!("{config:?}").contains(context));+}+fn session_config(directory: &Path, server: &MockServer) -> WorkloadIdentitySessionConfig {let assertion_file = directory.join("identity-token");std::fs::write(&assertion_file, "assertion-one").expect("write assertion");@@ -140,6 +171,7 @@ fn session_config(directory: &Path, server: &MockServer) -> WorkloadIdentitySessfederation_rule_id: "rule-one".to_string(),http_client_factory: HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),token_url: Url::parse(&format!("{}/oauth/token", server.uri())).expect("token URL"),+ workload_identity_context: None,}}@@ -189,7 +221,9 @@ async fn compatible_adapters_share_exchange() {.mount(&server).await;let registry = WorkloadIdentitySessionRegistry::default();- let first_config = session_config(temp_dir.path(), &server);+ let context = r#"{"instance_id":"box-one"}"#;+ let mut first_config = session_config(temp_dir.path(), &server);+ first_config.workload_identity_context = Some(context.into());let second_config = first_config.clone();let first = WorkloadIdentityExternalAuth::from_config_with_registry(first_config, ®istry).expect("first adapter");@@ -211,6 +245,15 @@ async fn compatible_adapters_share_exchange() {.get_token().expect("second token"));++ let requests = server.received_requests().await.expect("requests");+ assert_eq!(requests.len(), 1);+ assert_eq!(+ url::form_urlencoded::parse(&requests[0].body)+ .find(|(name, _)| name == "workload_identity_context")+ .map(|(_, value)| value.into_owned()),+ Some(context.to_string())+ );}#[tokio::test]@@ -229,6 +272,8 @@ async fn incompatible_process_session_settings_are_rejected() {std::fs::write(&different_file.assertion_file, "assertion-two").expect("write assertion");let mut different_environment = base.clone();different_environment.environment = WorkloadIdentityEnvironment::Production;+ let mut different_context = base.clone();+ different_context.workload_identity_context = Some(r#"{"instance_id":"box-two"}"#.into());let mut different_route = base;different_route.http_client_factory =HttpClientFactory::new(OutboundProxyPolicy::RespectSystemProxy);@@ -241,7 +286,12 @@ async fn incompatible_process_session_settings_are_rejected() {&different_route_adapter.session));- for config in [different_rule, different_file, different_environment] {+ for config in [+ different_rule,+ different_file,+ different_environment,+ different_context,+ ] {assert!(matches!(WorkloadIdentityExternalAuth::from_config_with_registry(config, ®istry),Err(WorkloadIdentitySessionError::ConflictingConfiguration)diff --git a/codex-rs/protocol/src/shell_environment.rs b/codex-rs/protocol/src/shell_environment.rsindex c19a21989e..ae3ccb2251 100644--- a/codex-rs/protocol/src/shell_environment.rs+++ b/codex-rs/protocol/src/shell_environment.rs@@ -7,11 +7,13 @@ pub const CODEX_SESSION_ID_ENV_VAR: &str = "CODEX_SESSION_ID";pub const CODEX_THREAD_ID_ENV_VAR: &str = "CODEX_THREAD_ID";pub const OPENAI_FEDERATION_RULE_ID_ENV_VAR: &str = "OPENAI_FEDERATION_RULE_ID";pub const OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR: &str = "OPENAI_IDENTITY_TOKEN_FILE";+pub const OPENAI_WORKLOAD_IDENTITY_CONTEXT_ENV_VAR: &str = "OPENAI_WORKLOAD_IDENTITY_CONTEXT";/// Environment variables that model-reachable child processes must not inherit.pub const NON_INHERITABLE_ENV_VARS: &[&str] = &[OPENAI_FEDERATION_RULE_ID_ENV_VAR,OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR,+ OPENAI_WORKLOAD_IDENTITY_CONTEXT_ENV_VAR,];pub fn is_non_inheritable_env_var(name: &str) -> bool {diff --git a/codex-rs/protocol/src/shell_environment_tests.rs b/codex-rs/protocol/src/shell_environment_tests.rsindex 3b7c5831cc..d6c4009909 100644--- a/codex-rs/protocol/src/shell_environment_tests.rs+++ b/codex-rs/protocol/src/shell_environment_tests.rs@@ -17,6 +17,10 @@ fn non_inheritable_environment_is_removed_after_policy_overrides() {"openai_federation_rule_id".to_string(),"inherited-rule".to_string(),),+ (+ "OPENAI_WORKLOAD_IDENTITY_CONTEXT".to_string(),+ r#"{"instance_id":"box-one"}"#.to_string(),+ ),];let policy = ShellEnvironmentPolicy {inherit: ShellEnvironmentPolicyInherit::All,@@ -44,6 +48,10 @@ fn command_scrubber_removes_names_from_real_child_environment() {.args([TEST_NAME, "--exact", "--nocapture"]).env(CHILD_MODE_ENV_VAR, "1").env("OpenAI_Federation_Rule_Id", "inherited-rule")+ .env(+ "OpenAI_Workload_Identity_Context",+ r#"{"instance_id":"box-one"}"#,+ ).output().expect("run inherited-environment test process");assert!(diff --git a/codex-rs/workload-identity/src/exchange.rs b/codex-rs/workload-identity/src/exchange.rsindex bd9606385a..018a1e12c5 100644--- a/codex-rs/workload-identity/src/exchange.rs+++ b/codex-rs/workload-identity/src/exchange.rs@@ -171,11 +171,17 @@ impl WorkloadIdentityExchange {async fn exchange_uncached(&self) -> Result<WorkloadIdentityToken, WorkloadIdentityError> {let assertion = read_assertion(&self.config.assertion_file).await?;- let body = url::form_urlencoded::Serializer::new(String::new())- .append_pair("grant_type", JWT_BEARER_GRANT_TYPE)- .append_pair("assertion", &assertion)- .append_pair("federation_rule_id", &self.config.federation_rule_id)- .finish();+ let body = {+ let mut serializer = url::form_urlencoded::Serializer::new(String::new());+ serializer+ .append_pair("grant_type", JWT_BEARER_GRANT_TYPE)+ .append_pair("assertion", &assertion)+ .append_pair("federation_rule_id", &self.config.federation_rule_id);+ if let Some(context) = &self.config.workload_identity_context {+ serializer.append_pair("workload_identity_context", context);+ }+ serializer.finish()+ };let response = self.client.post(self.token_url.as_str())diff --git a/codex-rs/workload-identity/src/lib.rs b/codex-rs/workload-identity/src/lib.rsindex a75c9decdb..252d8e8d61 100644--- a/codex-rs/workload-identity/src/lib.rs+++ b/codex-rs/workload-identity/src/lib.rs@@ -13,12 +13,14 @@ use thiserror::Error;pub struct WorkloadIdentityConfig {pub(crate) assertion_file: PathBuf,pub(crate) federation_rule_id: String,+ pub(crate) workload_identity_context: Option<String>,}impl WorkloadIdentityConfig {pub fn new(federation_rule_id: String,assertion_file: PathBuf,+ workload_identity_context: Option<String>,) -> Result<Self, WorkloadIdentityError> {let federation_rule_id = federation_rule_id.trim();if federation_rule_id.is_empty() {@@ -30,6 +32,7 @@ impl WorkloadIdentityConfig {Ok(Self {assertion_file,federation_rule_id: federation_rule_id.to_string(),+ workload_identity_context,})}}diff --git a/codex-rs/workload-identity/src/workload_identity_tests.rs b/codex-rs/workload-identity/src/workload_identity_tests.rsindex da587e2706..8ebd5ce481 100644--- a/codex-rs/workload-identity/src/workload_identity_tests.rs+++ b/codex-rs/workload-identity/src/workload_identity_tests.rs@@ -32,7 +32,12 @@ fn assertion_file(assertion: &str) -> (TempDir, PathBuf) {fn make_exchange(path: PathBuf, server: &MockServer) -> WorkloadIdentityExchange {WorkloadIdentityExchange::new(- WorkloadIdentityConfig::new("idpm_rule_one".to_string(), path).expect("valid config"),+ WorkloadIdentityConfig::new(+ "idpm_rule_one".to_string(),+ path,+ /*workload_identity_context*/ None,+ )+ .expect("valid config"),Url::parse(&format!("{}/oauth/token", server.uri())).expect("valid token URL"),HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),)@@ -97,6 +102,50 @@ async fn exchange_sends_three_field_contract_and_caches_valid_response() {);}+#[tokio::test]+async fn exchange_forwards_optional_workload_context_without_parsing() {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path("/oauth/token"))+ .and(header("content-type", "application/x-www-form-urlencoded"))+ .respond_with(success("sensitive-access-token", /*expires_in*/ 600))+ .mount(&server)+ .await;+ let (_temp_dir, assertion_path) = assertion_file("assertion-one");+ let context = "server-validates-this-raw-value";+ let config = WorkloadIdentityConfig::new(+ "idpm_rule_one".to_string(),+ assertion_path,+ /*workload_identity_context*/ Some(context.to_string()),+ )+ .expect("valid config");+ let exchange = WorkloadIdentityExchange::new(+ config,+ Url::parse(&format!("{}/oauth/token", server.uri())).expect("valid token URL"),+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ )+ .expect("valid exchange");++ exchange.resolve().await.expect("exchange");++ let requests = server.received_requests().await.expect("requests");+ assert_eq!(requests.len(), 1);+ assert_eq!(+ url::form_urlencoded::parse(&requests[0].body)+ .into_owned()+ .collect::<Vec<_>>(),+ vec![+ ("grant_type".to_string(), JWT_BEARER_GRANT_TYPE.to_string()),+ ("assertion".to_string(), "assertion-one".to_string()),+ (+ "federation_rule_id".to_string(),+ "idpm_rule_one".to_string()+ ),+ ("workload_identity_context".to_string(), context.to_string()),+ ]+ );+}+#[tokio::test]async fn concurrent_resolve_and_rejected_token_refresh_are_single_flight() {let server = MockServer::start().await;@@ -264,13 +313,21 @@ async fn transient_proactive_refresh_failure_uses_still_valid_token() {#[test]fn configuration_requires_an_absolute_file_and_secure_token_url() {assert!(matches!(- WorkloadIdentityConfig::new("idpm_rule_one".to_string(), PathBuf::from("relative.jwt")),+ WorkloadIdentityConfig::new(+ "idpm_rule_one".to_string(),+ PathBuf::from("relative.jwt"),+ /*workload_identity_context*/ None,+ ),Err(WorkloadIdentityError::AssertionFileMustBeAbsolute)));let (_temp_dir, assertion_path) = assertion_file("assertion-one");- let config = WorkloadIdentityConfig::new("idpm_rule_one".to_string(), assertion_path)- .expect("valid config");+ let config = WorkloadIdentityConfig::new(+ "idpm_rule_one".to_string(),+ assertion_path,+ /*workload_identity_context*/ None,+ )+ .expect("valid config");assert!(matches!(WorkloadIdentityExchange::new(config,