Lightweight coding agent that runs in your terminal
Rust
Repair rejected Windows sandbox credentials during provisioning (#47695)
zm-oai17cd2834e3d3
diff --git a/codex-rs/windows-sandbox-rs/src/identity.rs b/codex-rs/windows-sandbox-rs/src/identity.rsindex 33b2eb9609..1472249759 100644--- a/codex-rs/windows-sandbox-rs/src/identity.rs+++ b/codex-rs/windows-sandbox-rs/src/identity.rs@@ -29,10 +29,14 @@ use base64::Engine;use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;use std::collections::HashMap;use std::fs;+use std::io;use std::os::windows::io::FromRawHandle;use std::os::windows::io::OwnedHandle;use std::path::Path;use std::path::PathBuf;+use windows_sys::Win32::Foundation::ERROR_LOGON_FAILURE;+use windows_sys::Win32::Foundation::ERROR_PASSWORD_EXPIRED;+use windows_sys::Win32::Foundation::ERROR_PASSWORD_MUST_CHANGE;use windows_sys::Win32::NetworkManagement::NetManagement::UF_ACCOUNTDISABLE;use windows_sys::Win32::NetworkManagement::NetManagement::UF_PASSWORD_EXPIRED;use windows_sys::Win32::Security::LOGON32_LOGON_INTERACTIVE;@@ -55,6 +59,18 @@ pub struct SandboxCreds {pub password: String,}+/// Windows rejected the stored sandbox password; credential-file and policy errors are distinct.+#[derive(Debug)]+pub struct SandboxAccountCredentialMismatch;++impl std::fmt::Display for SandboxAccountCredentialMismatch {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ formatter.write_str("Windows rejected the stored sandbox account password")+ }+}++impl std::error::Error for SandboxAccountCredentialMismatch {}+/// Returns true when the on-disk setup artifacts exist and match the current/// setup version.///@@ -206,11 +222,24 @@ pub fn logon_existing_sandbox_account()} == 0{- return Err(std::io::Error::last_os_error()).context("log on existing sandbox account");+ return Err(account_logon_error(io::Error::last_os_error()));}Ok(unsafe { OwnedHandle::from_raw_handle(token as _) })}+fn account_logon_error(error: io::Error) -> anyhow::Error {+ let bad_password = matches!(+ error.raw_os_error().map(|code| code as u32),+ Some(ERROR_LOGON_FAILURE | ERROR_PASSWORD_EXPIRED | ERROR_PASSWORD_MUST_CHANGE)+ );+ let error = anyhow::Error::new(error);+ if bad_password {+ error.context(SandboxAccountCredentialMismatch)+ } else {+ error.context("log on existing sandbox account")+ }+}+fn select_identity(network_identity: SandboxNetworkIdentity,codex_home: &Path,diff --git a/codex-rs/windows-sandbox-rs/src/identity_integration_tests.rs b/codex-rs/windows-sandbox-rs/src/identity_integration_tests.rsindex 7e0f78e998..9e9bfe4c2c 100644--- a/codex-rs/windows-sandbox-rs/src/identity_integration_tests.rs+++ b/codex-rs/windows-sandbox-rs/src/identity_integration_tests.rs@@ -3,8 +3,12 @@//! the public wrapper, native account queries, payload serialization, singleflight,//! or helper launches.+use super::SandboxAccountCredentialMismatch;+use super::account_logon_error;+use super::logon_existing_sandbox_account;use super::require_sandbox_account_with_setup;use super::sandbox_setup_is_complete_with_settings;+use crate::SandboxRuntimeAccount;use crate::WindowsSandboxProvisioningSettings;use crate::WindowsSandboxProxySettingsMode;use crate::resolved_permissions::ResolvedWindowsSandboxPermissions;@@ -25,10 +29,41 @@ use pretty_assertions::assert_eq;use std::cell::Cell;use std::collections::HashMap;use std::fs;+use std::io;+use windows_sys::Win32::Foundation as win32;use windows_sys::Win32::NetworkManagement::NetManagement::UF_ACCOUNTDISABLE;use windows_sys::Win32::NetworkManagement::NetManagement::UF_NORMAL_ACCOUNT;use windows_sys::Win32::NetworkManagement::NetManagement::UF_PASSWORD_EXPIRED;+#[test]+fn only_native_bad_or_expired_passwords_trigger_credential_repair() -> Result<()> {+ for code in [+ win32::ERROR_LOGON_FAILURE,+ win32::ERROR_PASSWORD_EXPIRED,+ win32::ERROR_PASSWORD_MUST_CHANGE,+ ] {+ let error = account_logon_error(io::Error::from_raw_os_error(code as i32));+ assert!(error.is::<SandboxAccountCredentialMismatch>());+ assert_eq!(+ error.downcast_ref::<io::Error>().unwrap().raw_os_error(),+ Some(code as i32)+ );+ }+ for code in [+ win32::ERROR_ACCESS_DENIED,+ win32::ERROR_ACCOUNT_RESTRICTION,+ win32::ERROR_LOGON_TYPE_NOT_GRANTED,+ ] {+ let error = account_logon_error(io::Error::from_raw_os_error(code as i32));+ assert!(!error.is::<SandboxAccountCredentialMismatch>());+ }+ let home = tempfile::tempdir()?;+ let error =+ logon_existing_sandbox_account(home.path(), SandboxRuntimeAccount::Offline).unwrap_err();+ assert!(!error.is::<SandboxAccountCredentialMismatch>());+ Ok(())+}+#[test]fn credential_setup_repairs_expired_accounts_once_and_reloads_credentials() -> Result<()> {let permissions = ResolvedWindowsSandboxPermissions::try_from_permission_profile(diff --git a/codex-rs/windows-sandbox-rs/src/lib.rs b/codex-rs/windows-sandbox-rs/src/lib.rsindex 46f9710b4c..fa9c07d640 100644--- a/codex-rs/windows-sandbox-rs/src/lib.rs+++ b/codex-rs/windows-sandbox-rs/src/lib.rs@@ -279,6 +279,8 @@ pub use hide_users::hide_current_user_profile_dir;#[cfg(target_os = "windows")]pub use hide_users::hide_newly_created_users;#[cfg(target_os = "windows")]+pub use identity::SandboxAccountCredentialMismatch;+#[cfg(target_os = "windows")]pub use identity::logon_existing_sandbox_account;#[cfg(target_os = "windows")]pub use identity::require_logon_sandbox_creds;diff --git a/codex-rs/windows-sandbox-service/src/provisioning/registered.rs b/codex-rs/windows-sandbox-service/src/provisioning/registered.rsindex 43e958b2e8..0d5f4fe762 100644--- a/codex-rs/windows-sandbox-service/src/provisioning/registered.rs+++ b/codex-rs/windows-sandbox-service/src/provisioning/registered.rs@@ -5,7 +5,11 @@ use std::sync::atomic::AtomicBool;use anyhow::Context;use anyhow::Result;use anyhow::ensure;+use codex_windows_sandbox::SandboxAccountCredentialMismatch;use codex_windows_sandbox::SandboxProvisioningResponse;+use codex_windows_sandbox::SandboxRuntimeAccount;+use codex_windows_sandbox::logon_existing_sandbox_account;+use codex_windows_sandbox::sandbox_secrets_dir;use crate::ipc::ProvisioningRequest;use codex_windows_sandbox::string_from_sid_bytes;@@ -18,6 +22,10 @@ use crate::installation_record::RuntimeRegistration;use crate::ipc::ClientIdentity;use crate::ipc::OwnedHandle;+#[cfg(test)]+#[path = "registered_tests.rs"]+mod tests;+pub(super) fn run(identity: &ClientIdentity,request: ProvisioningRequest,@@ -79,7 +87,7 @@ pub(super) fn run(// Persist the authenticated owner before setup can rotate shared credentials.crate::installation_record::save_runtime(&installation).context("persist registered sandbox owner")?;- // Expired passwords require full setup to rotate and persist credentials before logon.+ // Missing, disabled, or expired accounts require full setup before runtime logon.for account in [codex_windows_sandbox::OFFLINE_USERNAME,codex_windows_sandbox::ONLINE_USERNAME,@@ -88,6 +96,32 @@ pub(super) fn run(.with_context(|| format!("inspect registered sandbox account {account}"))?.is_some_and(|flags| flags & (UF_ACCOUNTDISABLE | UF_PASSWORD_EXPIRED) == 0);}+ if setup_complete && !request.refresh_only {+ setup_complete = !credentials_need_repair(+ |account| {+ crate::package_lifecycle::with_owner_impersonation(identity.token.0, || {+ let mut pins = Vec::new();+ crate::ipc::pin_existing_ancestors(+ &sandbox_secrets_dir(&identity.codex_home),+ &mut pins,+ )?;+ logon_existing_sandbox_account(&identity.codex_home, account).map(drop)+ })+ .with_context(|| format!("check registered sandbox account {account:?}"))+ },+ || {+ for entry in &installation.runtime()?.accounts {+ let sid = codex_windows_sandbox::resolve_sid(entry.account.username())?;+ ensure!(+ string_from_sid_bytes(&sid).map_err(anyhow::Error::msg)?+ == entry.user_sid,+ "managed runtime account was replaced"+ );+ }+ Ok(())+ },+ )?;+ }if !setup_complete {// Account state can change outside our setup lock; refresh must never repair it.ensure!(@@ -134,3 +168,25 @@ pub(super) fn run();Ok(SandboxProvisioningResponse::Ok)}++fn credentials_need_repair(+ mut logon: impl FnMut(SandboxRuntimeAccount) -> Result<()>,+ validate_ownership: impl FnOnce() -> Result<()>,+) -> Result<bool> {+ let mut needs_repair = false;+ for account in [+ SandboxRuntimeAccount::Offline,+ SandboxRuntimeAccount::Online,+ ] {+ match logon(account) {+ Ok(()) => {}+ Err(error) if error.is::<SandboxAccountCredentialMismatch>() => needs_repair = true,+ Err(error) => return Err(error),+ }+ }+ if needs_repair {+ // Full setup rotates both passwords; never rotate a recreated local account.+ validate_ownership()?;+ }+ Ok(needs_repair)+}diff --git a/codex-rs/windows-sandbox-service/src/provisioning/registered_tests.rs b/codex-rs/windows-sandbox-service/src/provisioning/registered_tests.rsnew file mode 100644index 0000000000..bae7763070--- /dev/null+++ b/codex-rs/windows-sandbox-service/src/provisioning/registered_tests.rs@@ -0,0 +1,46 @@+//! Checks which credential failures may trigger a full setup repair.++use super::credentials_need_repair;+use anyhow::anyhow;+use codex_windows_sandbox::SandboxAccountCredentialMismatch;+use pretty_assertions::assert_eq;++#[test]+fn only_password_failures_on_owned_accounts_allow_repair() {+ enum Logon {+ Healthy,+ Password,+ Policy,+ }+ use Logon::Healthy;+ use Logon::Password;+ use Logon::Policy;+ for (errors, ownership_ok, expected, ownership_checked) in [+ ([Healthy, Healthy], true, Ok(false), false),+ ([Password, Healthy], true, Ok(true), true),+ ([Healthy, Password], true, Ok(true), true),+ ([Password, Policy], true, Err("policy"), false),+ ([Policy, Password], true, Err("policy"), false),+ ([Password, Healthy], false, Err("replacement"), true),+ ] {+ let mut errors = errors.into_iter();+ let mut checked = false;+ let result = credentials_need_repair(+ |_| match errors.next().unwrap() {+ Healthy => Ok(()),+ Password => Err(anyhow!(SandboxAccountCredentialMismatch)),+ Policy => Err(anyhow!("policy")),+ },+ || {+ checked = true;+ anyhow::ensure!(ownership_ok, "replacement");+ Ok(())+ },+ )+ .map_err(|error| error.to_string());+ assert_eq!(+ (result, checked),+ (expected.map_err(str::to_owned), ownership_checked)+ );+ }+}