use std::collections::HashMap;
use std::ffi::{OsStr, OsString};
#[cfg(windows)]
use std::os::windows::ffi::{OsStrExt, OsStringExt};
#[cfg(windows)]
use windows::Win32::Foundation::{ERROR_MORE_DATA, ERROR_NO_MORE_ITEMS, ERROR_SUCCESS};
#[cfg(windows)]
use windows::Win32::System::Environment::ExpandEnvironmentStringsW;
#[cfg(windows)]
use windows::Win32::System::Registry::{
HKEY, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, KEY_READ, REG_EXPAND_SZ, REG_SZ, REG_VALUE_TYPE,
RegCloseKey, RegEnumValueW, RegOpenKeyExW,
};
#[cfg(windows)]
use windows::core::{PCWSTR, PWSTR};
pub fn string_map_env(
env: &HashMap<String, String>,
) -> impl Iterator<Item = (OsString, OsString)> + '_ {
env.iter()
.map(|(key, value)| (OsString::from(key), OsString::from(value)))
}
pub fn sanitized_child_env<I, K, V>(overrides: I) -> Vec<(OsString, OsString)>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
let mut env = Vec::new();
#[cfg(windows)]
append_sanitized_child_env_candidates(&mut env, windows_registry_env_vars());
for (key, value) in std::env::vars_os() {
append_sanitized_child_env_candidate(&mut env, key, value);
}
for (key, value) in overrides {
upsert_env(
&mut env,
key.as_ref().to_os_string(),
value.as_ref().to_os_string(),
);
}
#[cfg(windows)]
fill_windows_common_program_files(&mut env);
if env
.iter()
.any(|(key, _)| normalize_key(key) == "CODEWHALE_SANDBOX")
{
env.retain(|(key, _)| {
let key = normalize_key(key);
key != "RUSTC_WRAPPER" && key != "CARGO_BUILD_BUILD_DIR"
});
}
env
}
pub fn sanitized_runtime_env_from<B, K, V>(base_environment: B) -> Vec<(OsString, OsString)>
where
B: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
let mut env = Vec::new();
for (key, value) in base_environment {
if is_allowed_parent_env_key(key.as_ref()) {
upsert_env(
&mut env,
key.as_ref().to_os_string(),
value.as_ref().to_os_string(),
);
}
}
env
}
pub fn apply_to_command<I, K, V>(cmd: &mut std::process::Command, overrides: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
cmd.env_clear();
for (key, value) in sanitized_child_env(overrides) {
cmd.env(key, value);
}
}
pub fn apply_to_tokio_command<I, K, V>(cmd: &mut tokio::process::Command, overrides: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
cmd.env_clear();
for (key, value) in sanitized_child_env(overrides) {
cmd.env(key, value);
}
}
const GIT_PASSTHROUGH_KEYS: &[&str] = &[
"SSH_AUTH_SOCK",
"SSH_AGENT_PID",
"GNUPGHOME",
"XDG_CONFIG_HOME",
"GIT_SSH",
"GIT_SSH_COMMAND",
"GIT_SSH_VARIANT",
"GIT_EXEC_PATH",
"GIT_CONFIG_GLOBAL",
"GIT_CONFIG_SYSTEM",
"GIT_CONFIG_NOSYSTEM",
"GIT_CEILING_DIRECTORIES",
"GIT_SSL_CAINFO",
"GIT_SSL_CAPATH",
"GIT_AUTHOR_NAME",
"GIT_AUTHOR_EMAIL",
"GIT_COMMITTER_NAME",
"GIT_COMMITTER_EMAIL",
];
pub fn apply_to_git_command(cmd: &mut std::process::Command) {
let passthrough: Vec<(OsString, OsString)> = std::env::vars_os()
.filter(|(key, _)| {
let normalized = normalize_key(key);
GIT_PASSTHROUGH_KEYS.contains(&normalized.as_str())
})
.collect();
apply_to_command(cmd, passthrough);
}
#[cfg(not(target_env = "ohos"))]
pub fn apply_to_pty_command<I, K, V>(cmd: &mut portable_pty::CommandBuilder, overrides: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
cmd.env_clear();
for (key, value) in sanitized_child_env(overrides) {
cmd.env(key, value);
}
}
pub fn sanitized_mcp_env<I, K, V>(overrides: I) -> Vec<(OsString, OsString)>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
let mut env = Vec::new();
for (key, value) in std::env::vars_os() {
if is_allowed_mcp_env_key(&key) {
upsert_env(&mut env, key, value);
}
}
for (key, value) in overrides {
upsert_env(
&mut env,
key.as_ref().to_os_string(),
value.as_ref().to_os_string(),
);
}
env
}
#[cfg(test)]
pub fn sanitized_plugin_mcp_env<I, K, V>(overrides: I) -> Vec<(OsString, OsString)>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
sanitized_plugin_mcp_env_from(std::env::vars_os(), overrides)
}
pub fn sanitized_plugin_mcp_env_from<B, BK, BV, I, K, V>(
base_environment: B,
overrides: I,
) -> Vec<(OsString, OsString)>
where
B: IntoIterator<Item = (BK, BV)>,
BK: AsRef<OsStr>,
BV: AsRef<OsStr>,
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
let mut env = Vec::new();
for (key, value) in base_environment {
if is_allowed_parent_env_key(key.as_ref()) {
upsert_env(
&mut env,
key.as_ref().to_os_string(),
value.as_ref().to_os_string(),
);
}
}
env.retain(|(key, _)| {
!matches!(
normalize_key(key).as_str(),
"HTTP_PROXY" | "HTTPS_PROXY" | "ALL_PROXY" | "FTP_PROXY"
)
});
for (key, value) in overrides {
upsert_env(
&mut env,
key.as_ref().to_os_string(),
value.as_ref().to_os_string(),
);
}
env
}
pub fn apply_to_tokio_command_mcp<I, K, V>(cmd: &mut tokio::process::Command, overrides: I)
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
cmd.env_clear();
for (key, value) in sanitized_mcp_env(overrides) {
cmd.env(key, value);
}
}
fn is_allowed_parent_env_key(key: &OsStr) -> bool {
let key = key.to_string_lossy();
let normalized = key.to_ascii_uppercase();
matches!(
normalized.as_str(),
"PATH"
| "DISPLAY"
| "WAYLAND_DISPLAY"
| "XDG_RUNTIME_DIR"
| "XDG_SESSION_TYPE"
| "DBUS_SESSION_BUS_ADDRESS"
| "XAUTHORITY"
| "HOME"
| "USER"
| "USERNAME"
| "LOGNAME"
| "LANG"
| "LANGUAGE"
| "LC_ALL"
| "LC_CTYPE"
| "LC_COLLATE"
| "LC_MESSAGES"
| "LC_MONETARY"
| "LC_NUMERIC"
| "LC_TIME"
| "LC_PAPER"
| "LC_NAME"
| "LC_ADDRESS"
| "LC_TELEPHONE"
| "LC_MEASUREMENT"
| "LC_IDENTIFICATION"
| "LC_TERMINAL"
| "LC_TERMINAL_VERSION"
| "TERM"
| "COLORTERM"
| "NO_COLOR"
| "FORCE_COLOR"
| "SHELL"
| "TMPDIR"
| "TMP"
| "TEMP"
| "__CF_USER_TEXT_ENCODING"
| "SYSTEMROOT"
| "WINDIR"
| "COMSPEC"
| "PATHEXT"
| "USERPROFILE"
| "HOMEDRIVE"
| "HOMEPATH"
| "LIB"
| "LIBPATH"
| "INCLUDE"
| "VSINSTALLDIR"
| "VCINSTALLDIR"
| "VCTOOLSINSTALLDIR"
| "WINDOWSSDKDIR"
| "WINDOWSSDKVERSION"
| "UNIVERSALCRTSDKDIR"
| "UCRTVERSION"
| "EXTENSIONSDKDIR"
| "DEVENVDIR"
| "VISUALSTUDIOVERSION"
| "APPDATA"
| "LOCALAPPDATA"
| "PROGRAMDATA"
| "ALLUSERSPROFILE"
| "PROGRAMFILES"
| "PROGRAMFILES(X86)"
| "PROGRAMW6432"
| "COMMONPROGRAMFILES"
| "COMMONPROGRAMFILES(X86)"
| "COMMONPROGRAMW6432"
| "PROCESSOR_ARCHITECTURE"
| "NUGET_PACKAGES"
| "NUGET_HTTP_CACHE_PATH"
| "HTTP_PROXY"
| "HTTPS_PROXY"
| "NO_PROXY"
| "ALL_PROXY"
| "FTP_PROXY"
| "PYTHONIOENCODING"
| "PYTHONUTF8"
| "CARGO_HOME"
| "RUSTUP_HOME"
| "RUSTUP_TOOLCHAIN"
| "RUSTFLAGS"
| "RUSTDOCFLAGS"
| "RUSTC_WRAPPER"
| "RUST_BACKTRACE"
| "RUST_LOG"
| "RUST_MIN_STACK"
| "RUST_TEST_THREADS"
| "VIRTUAL_ENV"
| "CONDA_PREFIX"
| "CONDA_DEFAULT_ENV"
| "PYTHONPATH"
| "JAVA_HOME"
| "GOPATH"
| "GOROOT"
| "GOBIN"
| "GOFLAGS"
| "GOCACHE"
| "GOMODCACHE"
| "GOTOOLCHAIN"
| "GO111MODULE"
| "NVM_DIR"
| "NVM_BIN"
| "NVM_INC"
| "VOLTA_HOME"
| "NODE_PATH"
| "NODE_OPTIONS"
| "NODE_EXTRA_CA_CERTS"
| "SSL_CERT_FILE"
| "SSL_CERT_DIR"
| "REQUESTS_CA_BUNDLE"
| "CURL_CA_BUNDLE"
) || is_allowed_cargo_config_key(&normalized)
|| is_allowed_dotnet_child_env_key(&normalized)
|| is_allowed_platform_path_like_child_env_key(&normalized)
}
fn is_allowed_dotnet_child_env_key(normalized: &str) -> bool {
const SECRET_WORDS: [&str; 8] = [
"KEY", "CONNSTR", "PWD", "PASS", "DSN", "AUTH", "BEARER", "COOKIE",
];
const SWITCHES: &[&str] = &[
"ROOT",
"ROOT(X86)",
"HOST_PATH",
"NOLOGO",
"SKIP_FIRST_TIME_EXPERIENCE",
"MULTILEVEL_LOOKUP",
"ENVIRONMENT",
"BUNDLE_EXTRACT_BASE_DIR",
"NUGET_SIGNATURE_VERIFICATION",
"ADD_GLOBAL_TOOLS_TO_PATH",
"USE_POLLING_FILE_WATCHER",
"RUNNING_IN_CONTAINER",
"GENERATE_ASPNET_CERTIFICATE",
"TOOLS_ALLOW_MANIFEST_IN_ROOT",
"ADDITIONAL_DEPS",
"SHARED_STORE",
"STARTUP_HOOKS",
"PROCESSOR_COUNT",
"HTTPREPL_PREFERRED_EDITOR",
"SDK_VERSION",
"VERSION",
"GCSERVER",
"GCCONCURRENT",
"GCGEN0SIZE",
"GCHEAPHARDLIMIT",
"GCHEAPHARDLIMITPERCENT",
"GCHEAPCOUNT",
"GCHEAPAFFINITIZEMASK",
"GCNOAFFINITIZE",
"GCCONSERVEMEMORY",
"GCCPUGROUP",
"TIEREDCOMPILATION",
"TIEREDPGO",
"TC_QUICKJIT",
"TC_QUICKJITFORLOOPS",
"TC_ONSTACKREPLACEMENT",
"READYTORUN",
"ENABLEDIAGNOSTICS",
"ENABLEDIAGNOSTICS_IPC",
"ENABLEDIAGNOSTICS_DEBUGGER",
"ENABLEDIAGNOSTICS_PROFILER",
"DBGENABLEMINIDUMP",
"DBGMINIDUMPTYPE",
"DBGMINIDUMPNAME",
"CREATEDUMPDIAGNOSTICS",
"DIAGNOSTICPORTS",
"ENABLEEVENTPIPE",
"EVENTPIPEOUTPUTPATH",
"EVENTPIPECONFIG",
"ENABLEWRITEXOREXECUTE",
"THREAD_USEALLCPUGROUPS",
];
const FAMILIES: &[&str] = &[
"ROOT_",
"CLI_",
"SYSTEM_",
"ROLL_FORWARD",
"WATCH_",
"MSBUILD_SDK_RESOLVER_",
];
let Some(name) = normalized.strip_prefix("DOTNET_") else {
return false;
};
if !SWITCHES.contains(&name) && !FAMILIES.iter().any(|family| name.starts_with(family)) {
return false;
}
if name.contains("__") || name.contains(':') {
return false;
}
let compact: String = name.chars().filter(|c| *c != '_').collect();
!SECRET_WORDS.iter().any(|word| compact.contains(word))
&& !is_secret_like_child_env_key(normalized)
}
fn is_allowed_cargo_config_key(normalized: &str) -> bool {
normalized.starts_with("CARGO_")
&& !normalized.starts_with("CARGO_REGISTRY_")
&& !normalized.starts_with("CARGO_REGISTRIES_")
&& !is_secret_like_child_env_key(normalized)
}
fn is_proxy_url_key(normalized: &str) -> bool {
matches!(
normalized,
"HTTP_PROXY" | "HTTPS_PROXY" | "ALL_PROXY" | "FTP_PROXY" | "CARGO_HTTP_PROXY"
)
}
fn strip_proxy_userinfo(value: &OsStr) -> Option<OsString> {
let value = value.to_str()?;
let (scheme, rest) = match value.find("://") {
Some(index) => value.split_at(index + 3),
None => ("", value),
};
let authority_end = rest.find(['/', '?', '#']).unwrap_or(rest.len());
let (authority, tail) = rest.split_at(authority_end);
let host = authority
.rsplit_once('@')
.map_or(authority, |(_, host)| host);
Some(OsString::from(format!("{scheme}{host}{tail}")))
}
#[cfg(windows)]
fn is_allowed_platform_path_like_child_env_key(normalized: &str) -> bool {
is_allowed_path_like_child_env_key(normalized)
}
#[cfg(not(windows))]
fn is_allowed_platform_path_like_child_env_key(_normalized: &str) -> bool {
false
}
#[cfg(windows)]
fn is_allowed_path_like_child_env_key(normalized: &str) -> bool {
if is_secret_like_child_env_key(normalized) {
return false;
}
normalized.ends_with("_ROOT")
|| normalized.ends_with("_DIR")
|| normalized.ends_with("_HOME")
|| normalized.ends_with("_PATH")
|| normalized.ends_with("_PATHS")
|| normalized.ends_with("SDKROOT")
}
fn is_secret_like_child_env_key(normalized: &str) -> bool {
normalized.contains("SECRET")
|| normalized.contains("TOKEN")
|| normalized.contains("PASSWORD")
|| normalized.contains("PASSWD")
|| normalized.contains("CREDENTIAL")
|| normalized.contains("API_KEY")
|| normalized.contains("ACCESS_KEY")
|| normalized.contains("PRIVATE_KEY")
|| normalized.contains("CONNECTIONSTRING")
|| normalized.ends_with("_KEY")
}
fn is_allowed_mcp_env_key(key: &OsStr) -> bool {
if is_allowed_parent_env_key(key) {
return true;
}
let key_str = key.to_string_lossy();
let normalized = key_str.to_ascii_uppercase();
if matches!(
normalized.as_str(),
"NVM_DIR"
| "NVM_BIN"
| "NVM_INC"
| "VOLTA_HOME"
| "COREPACK_HOME"
| "NODE_PATH"
| "NODE_OPTIONS"
| "NODE_EXTRA_CA_CERTS"
| "PYTHONPATH"
| "PYTHONHOME"
| "PYTHONDONTWRITEBYTECODE"
| "PYTHONUNBUFFERED"
| "VIRTUAL_ENV"
| "POETRY_HOME"
| "PIPX_HOME"
| "PIPX_BIN_DIR"
| "GEM_HOME"
| "GEM_PATH"
| "BUNDLE_PATH"
| "BUNDLE_GEMFILE"
| "JAVA_HOME"
| "HTTP_PROXY"
| "HTTPS_PROXY"
| "NO_PROXY"
| "ALL_PROXY"
| "FTP_PROXY"
| "SSL_CERT_FILE"
| "SSL_CERT_DIR"
| "REQUESTS_CA_BUNDLE"
| "CURL_CA_BUNDLE"
| "AWS_PROFILE"
| "AWS_REGION"
| "AWS_DEFAULT_REGION"
| "AWS_CONFIG_FILE"
| "AWS_SHARED_CREDENTIALS_FILE"
) {
return true;
}
if normalized.starts_with("NPM_CONFIG_") || normalized.starts_with("UV_") {
return true;
}
false
}
#[cfg(windows)]
fn append_sanitized_child_env_candidates<I, K, V>(
env: &mut Vec<(OsString, OsString)>,
candidates: I,
) where
I: IntoIterator<Item = (K, V)>,
K: Into<OsString>,
V: Into<OsString>,
{
for (key, value) in candidates {
append_sanitized_child_env_candidate(env, key.into(), value.into());
}
}
fn append_sanitized_child_env_candidate(
env: &mut Vec<(OsString, OsString)>,
key: OsString,
value: OsString,
) {
if !is_allowed_parent_env_key(&key) {
return;
}
if is_proxy_url_key(&normalize_key(&key)) {
if let Some(value) = strip_proxy_userinfo(&value) {
upsert_env(env, key, value);
}
return;
}
upsert_env(env, key, value);
}
fn upsert_env(env: &mut Vec<(OsString, OsString)>, key: OsString, value: OsString) {
let normalized = normalize_key(&key);
env.retain(|(existing, _)| normalize_key(existing) != normalized);
env.push((key, value));
}
#[cfg(windows)]
fn windows_registry_env_vars() -> Vec<(OsString, OsString)> {
let mut env = Vec::new();
append_windows_registry_env_key(
&mut env,
HKEY_LOCAL_MACHINE,
r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment",
);
append_windows_registry_env_key(&mut env, HKEY_CURRENT_USER, "Environment");
env
}
#[cfg(windows)]
fn append_windows_registry_env_key(env: &mut Vec<(OsString, OsString)>, root: HKEY, subkey: &str) {
let mut key = HKEY::default();
let subkey_wide = windows_wide_null(OsStr::new(subkey));
let open =
unsafe { RegOpenKeyExW(root, PCWSTR(subkey_wide.as_ptr()), None, KEY_READ, &mut key) };
if open != ERROR_SUCCESS {
return;
}
let mut index = 0;
loop {
match read_windows_registry_env_value(key, index) {
RegistryEnvValue::Value(name, value) => {
upsert_env(env, name, value);
index += 1;
}
RegistryEnvValue::Skip => {
index += 1;
}
RegistryEnvValue::Done => break,
}
}
let _ = unsafe { RegCloseKey(key) };
}
#[cfg(windows)]
enum RegistryEnvValue {
Value(OsString, OsString),
Skip,
Done,
}
#[cfg(windows)]
fn read_windows_registry_env_value(key: HKEY, index: u32) -> RegistryEnvValue {
let mut name = vec![0u16; 32_767];
let mut data = vec![0u8; 65_536];
loop {
let mut name_len = name.len() as u32;
let mut data_len = data.len() as u32;
let mut value_type = 0u32;
let status = unsafe {
RegEnumValueW(
key,
index,
Some(PWSTR(name.as_mut_ptr())),
&mut name_len,
None,
Some(&mut value_type),
Some(data.as_mut_ptr()),
Some(&mut data_len),
)
};
if status == ERROR_NO_MORE_ITEMS {
return RegistryEnvValue::Done;
}
if status == ERROR_MORE_DATA && resize_registry_data_buffer(&mut data, data_len) {
continue;
}
if status != ERROR_SUCCESS {
return RegistryEnvValue::Skip;
}
if value_type != REG_SZ.0 && value_type != REG_EXPAND_SZ.0 {
return RegistryEnvValue::Skip;
}
let name = OsString::from_wide(&name[..name_len as usize]);
let value = registry_utf16_value_from_bytes(&data[..data_len as usize]);
let value = if REG_VALUE_TYPE(value_type) == REG_EXPAND_SZ {
expand_windows_env_string(&value).unwrap_or(value)
} else {
value
};
return RegistryEnvValue::Value(name, value);
}
}
#[cfg(windows)]
fn resize_registry_data_buffer(data: &mut Vec<u8>, required_len: u32) -> bool {
let Ok(required_len) = usize::try_from(required_len) else {
return false;
};
if required_len <= data.len() {
return false;
}
data.resize(required_len, 0);
true
}
#[cfg(windows)]
fn registry_utf16_value_from_bytes(data: &[u8]) -> OsString {
let mut wide = data
.chunks_exact(2)
.map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
.collect::<Vec<_>>();
while wide.last() == Some(&0) {
wide.pop();
}
OsString::from_wide(&wide)
}
#[cfg(windows)]
fn expand_windows_env_string(value: &OsStr) -> Option<OsString> {
let src = windows_wide_null(value);
let required_len = unsafe { ExpandEnvironmentStringsW(PCWSTR(src.as_ptr()), None) };
if required_len == 0 {
return None;
}
let mut expanded = vec![0u16; required_len as usize];
let written = unsafe { ExpandEnvironmentStringsW(PCWSTR(src.as_ptr()), Some(&mut expanded)) };
if written == 0 || written > required_len {
return None;
}
let len = usize::try_from(written).ok()?.saturating_sub(1);
Some(OsString::from_wide(&expanded[..len]))
}
#[cfg(windows)]
fn windows_wide_null(value: &OsStr) -> Vec<u16> {
value.encode_wide().chain(std::iter::once(0)).collect()
}
#[cfg(any(windows, test))]
fn fill_windows_common_program_files(env: &mut Vec<(OsString, OsString)>) {
for (key, default) in [
("CommonProgramFiles", r"C:\Program Files\Common Files"),
(
"CommonProgramFiles(x86)",
r"C:\Program Files (x86)\Common Files",
),
("CommonProgramW6432", r"C:\Program Files\Common Files"),
] {
let existing = env
.iter()
.find(|(existing, _)| normalize_key(existing) == normalize_key(OsStr::new(key)))
.map(|(_, value)| value.to_string_lossy().trim().is_empty());
if existing.unwrap_or(true) {
upsert_env(env, OsString::from(key), OsString::from(default));
}
}
}
fn normalize_key(key: &OsStr) -> String {
key.to_string_lossy().to_ascii_uppercase()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_support::EnvVarGuard;
#[test]
fn mcp_env_allowlist_inherits_base_keys() {
for key in [
"PATH",
"HOME",
"USER",
"TERM",
"LANG",
"SHELL",
"LIB",
"LIBPATH",
"INCLUDE",
"VCTOOLSINSTALLDIR",
"WINDOWSSDKDIR",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should inherit base key {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_node_bootstrap_keys() {
for key in [
"NVM_DIR",
"NVM_BIN",
"NVM_INC",
"NODE_PATH",
"NODE_OPTIONS",
"NODE_EXTRA_CA_CERTS",
"VOLTA_HOME",
"COREPACK_HOME",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_npm_config_prefix() {
for key in [
"NPM_CONFIG_PREFIX",
"NPM_CONFIG_CACHE",
"NPM_CONFIG_REGISTRY",
"NPM_CONFIG_USERCONFIG",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include npm config key {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_proxy_keys_either_case() {
for key in [
"HTTP_PROXY",
"HTTPS_PROXY",
"NO_PROXY",
"ALL_PROXY",
"http_proxy",
"https_proxy",
"no_proxy",
"all_proxy",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include proxy key {key}"
);
}
}
#[test]
fn child_env_allowlist_includes_proxy_keys_either_case() {
for key in [
"HTTP_PROXY",
"HTTPS_PROXY",
"NO_PROXY",
"ALL_PROXY",
"FTP_PROXY",
"http_proxy",
"https_proxy",
"no_proxy",
"all_proxy",
"ftp_proxy",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env allowlist should include proxy key {key}"
);
}
}
#[test]
fn child_env_allowlist_includes_dotnet_and_windows_appdata_keys() {
for key in [
"APPDATA",
"LOCALAPPDATA",
"PROGRAMDATA",
"ALLUSERSPROFILE",
"PROGRAMFILES",
"PROGRAMFILES(X86)",
"PROGRAMW6432",
"COMMONPROGRAMFILES",
"COMMONPROGRAMFILES(X86)",
"COMMONPROGRAMW6432",
"PROCESSOR_ARCHITECTURE",
"NUGET_PACKAGES",
"DOTNET_ROOT",
"DOTNET_CLI_TELEMETRY_OPTOUT",
"DOTNET_NOLOGO",
"ProgramFiles",
"dotnet_root",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env allowlist should include {key}"
);
}
assert!(
!is_allowed_parent_env_key(OsStr::new("NuGetPackageSourceCredentials_feed")),
"NuGet credential vars must not be exported to child processes"
);
}
#[test]
fn child_env_allowlist_includes_python_stdio_encoding_vars() {
for key in ["PYTHONIOENCODING", "PYTHONUTF8", "pythonioencoding"] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env allowlist should include Python stdio encoding key {key}"
);
}
}
#[test]
fn child_env_allowlist_includes_rust_toolchain_bootstrap_keys() {
for key in [
"CARGO_HOME",
"RUSTUP_HOME",
"RUSTUP_TOOLCHAIN",
"cargo_home",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env allowlist should include Rust bootstrap key {key}"
);
}
}
#[cfg(windows)]
#[test]
fn child_env_allowlist_includes_custom_path_like_vars_without_secrets() {
for key in [
"BIMRV_SDK_ROOT",
"ACME_TOOLCHAIN_HOME",
"PROJECT_SDK_DIR",
"CMAKE_PREFIX_PATH",
"ANDROID_SDKROOT",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env allowlist should include path-like key {key}"
);
}
for key in [
"OPENAI_API_KEY",
"GITHUB_TOKEN",
"MY_SECRET_ROOT",
"SERVICE_PASSWORD_DIR",
"AWS_ACCESS_KEY_ID",
"PRIVATE_KEY_PATH",
"NuGetPackageSourceCredentials_feed",
] {
assert!(
!is_allowed_parent_env_key(OsStr::new(key)),
"secret-like key {key} must not be exported to child processes"
);
}
}
#[cfg(windows)]
#[test]
fn sanitized_child_env_preserves_custom_sdk_root_vars() {
let _guard = crate::test_support::lock_test_env();
let _sdk = EnvVarGuard::set("BIMRV_SDK_ROOT", r"F:\Lib\BimRv27.5");
let _secret = EnvVarGuard::set("MY_SECRET_ROOT", r"F:\Secrets");
let env = sanitized_child_env(std::iter::empty::<(OsString, OsString)>());
assert!(
env.iter()
.any(|(key, value)| key == "BIMRV_SDK_ROOT" && value == r"F:\Lib\BimRv27.5"),
"child env should preserve custom SDK roots"
);
assert!(
env.iter().all(|(key, _)| key != "MY_SECRET_ROOT"),
"secret-like path vars must still be dropped"
);
}
#[cfg(windows)]
#[test]
fn windows_registry_env_candidates_preserve_custom_sdk_roots() {
use windows::Win32::System::Registry::{
HKEY_CURRENT_USER, REG_SZ, RegCreateKeyW, RegDeleteTreeW, RegSetValueExW,
};
let subkey = format!(r"Software\CodeWhaleTest\child_env_{}", std::process::id());
let subkey_wide = windows_wide_null(OsStr::new(&subkey));
let mut key = HKEY::default();
let created =
unsafe { RegCreateKeyW(HKEY_CURRENT_USER, PCWSTR(subkey_wide.as_ptr()), &mut key) };
assert_eq!(created, ERROR_SUCCESS);
set_registry_string_value(key, "BIMRV_SDK_ROOT", r"F:\Lib\BimRv27.5");
set_registry_string_value(key, "MY_SECRET_ROOT", r"F:\Secrets");
let _ = unsafe { RegCloseKey(key) };
let mut candidates = Vec::new();
append_windows_registry_env_key(&mut candidates, HKEY_CURRENT_USER, &subkey);
let mut env = Vec::new();
append_sanitized_child_env_candidates(&mut env, candidates);
let _ = unsafe { RegDeleteTreeW(HKEY_CURRENT_USER, PCWSTR(subkey_wide.as_ptr())) };
assert!(
env.iter()
.any(|(key, value)| key == "BIMRV_SDK_ROOT" && value == r"F:\Lib\BimRv27.5"),
"registry child env should preserve custom SDK roots"
);
assert!(
env.iter().all(|(key, _)| key != "MY_SECRET_ROOT"),
"secret-like registry vars must still be dropped"
);
fn set_registry_string_value(key: HKEY, name: &str, value: &str) {
let name_wide = windows_wide_null(OsStr::new(name));
let data = value
.encode_utf16()
.chain(std::iter::once(0))
.flat_map(u16::to_le_bytes)
.collect::<Vec<_>>();
let status = unsafe {
RegSetValueExW(key, PCWSTR(name_wide.as_ptr()), None, REG_SZ, Some(&data))
};
assert_eq!(status, ERROR_SUCCESS);
}
}
#[test]
fn windows_common_program_files_defaults_replace_empty_values() {
let mut env = vec![
(OsString::from("CommonProgramFiles"), OsString::new()),
(
OsString::from("CommonProgramFiles(x86)"),
OsString::from(" "),
),
(
OsString::from("CommonProgramW6432"),
OsString::from(r"D:\Common Files"),
),
];
fill_windows_common_program_files(&mut env);
let get = |name: &str| {
env.iter()
.find(|(key, _)| normalize_key(key) == normalize_key(OsStr::new(name)))
.map(|(_, value)| value.to_string_lossy().into_owned())
};
assert_eq!(
get("CommonProgramFiles").as_deref(),
Some(r"C:\Program Files\Common Files")
);
assert_eq!(
get("CommonProgramFiles(x86)").as_deref(),
Some(r"C:\Program Files (x86)\Common Files")
);
assert_eq!(
get("CommonProgramW6432").as_deref(),
Some(r"D:\Common Files")
);
}
#[test]
fn mcp_env_allowlist_includes_python_bootstrap_keys() {
for key in [
"PYTHONPATH",
"PYTHONHOME",
"VIRTUAL_ENV",
"PIPX_HOME",
"PIPX_BIN_DIR",
"POETRY_HOME",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include python bootstrap key {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_uv_prefixed_keys() {
for key in ["UV_CACHE_DIR", "UV_INDEX_URL", "UV_PYTHON"] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include uv prefixed key {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_ca_bundles() {
for key in [
"SSL_CERT_FILE",
"SSL_CERT_DIR",
"REQUESTS_CA_BUNDLE",
"CURL_CA_BUNDLE",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include CA bundle key {key}"
);
}
}
#[test]
fn mcp_env_allowlist_includes_aws_profile_and_region_selectors() {
for key in [
"AWS_PROFILE",
"AWS_REGION",
"AWS_DEFAULT_REGION",
"AWS_CONFIG_FILE",
"AWS_SHARED_CREDENTIALS_FILE",
] {
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist should include non-secret AWS selector {key}"
);
}
}
#[test]
fn mcp_env_allowlist_excludes_secrets_and_creds() {
for key in [
"AWS_SECRET_ACCESS_KEY",
"AWS_ACCESS_KEY_ID",
"AWS_SESSION_TOKEN",
"AWS_SECURITY_TOKEN",
"GITHUB_TOKEN",
"OPENAI_API_KEY",
"ANTHROPIC_API_KEY",
"DEEPSEEK_API_KEY",
"SLACK_TOKEN",
"MY_RANDOM_SECRET",
] {
assert!(
!is_allowed_mcp_env_key(OsStr::new(key)),
"MCP allowlist must NOT include {key}"
);
}
}
#[test]
fn sanitized_mcp_env_passes_through_node_bootstrap() {
let _guard = crate::test_support::lock_test_env();
let _nvm_dir = EnvVarGuard::set("NVM_DIR", "/tmp/test-nvm");
let env = sanitized_mcp_env(std::iter::empty::<(OsString, OsString)>());
let nvm_dir = env
.iter()
.find(|(key, _)| normalize_key(key) == "NVM_DIR")
.map(|(_, value)| value.clone());
assert_eq!(nvm_dir, Some(OsString::from("/tmp/test-nvm")));
}
#[test]
fn sanitized_mcp_env_drops_unrelated_secret_like_values() {
let _guard = crate::test_support::lock_test_env();
let _secret = EnvVarGuard::set("DEEPSEEK_MCP_TEST_SECRET", "should-not-leak");
let env = sanitized_mcp_env(std::iter::empty::<(OsString, OsString)>());
assert!(
env.iter().all(|(key, _)| key != "DEEPSEEK_MCP_TEST_SECRET"),
"MCP env should not pass arbitrary parent vars"
);
}
#[test]
fn reviewed_plugin_mcp_env_requires_explicit_proxy_provenance() {
let _guard = crate::test_support::lock_test_env();
let synthetic_proxy = format!(
"{}://{}:{}@{}",
"http", "fixture-user", "fixture-password", "127.0.0.1:9"
);
let _proxy = EnvVarGuard::set("HTTP_PROXY", synthetic_proxy);
let ambient = sanitized_plugin_mcp_env(std::iter::empty::<(OsString, OsString)>());
let explicit = sanitized_plugin_mcp_env([("HTTP_PROXY", "http://proxy.invalid")]);
assert!(
ambient
.iter()
.all(|(key, _)| normalize_key(key) != "HTTP_PROXY"),
"reviewed plugins must not inherit a credential-capable proxy URL"
);
assert!(explicit.iter().any(|(key, value)| {
normalize_key(key) == "HTTP_PROXY" && value == "http://proxy.invalid"
}));
}
#[test]
fn reviewed_plugin_mcp_env_keeps_desktop_routing_without_secret_namespaces() {
let desktop = [
("DISPLAY", ":1"),
("WAYLAND_DISPLAY", "wayland-0"),
("XDG_RUNTIME_DIR", "/run/user/1000"),
("XDG_SESSION_TYPE", "wayland"),
("DBUS_SESSION_BUS_ADDRESS", "unix:path=/run/user/1000/bus"),
("XAUTHORITY", "/run/user/1000/.Xauthority"),
];
let unexpected = [
("OPENAI_API_KEY", "provider-fixture"),
("XDG_PRIVATE_TOKEN", "xdg-fixture"),
("DBUS_PRIVATE_TOKEN", "dbus-fixture"),
("CODEWHALE_CU_APP_BUNDLE", "/stale/helper.app"),
];
let child = sanitized_plugin_mcp_env_from(
desktop.into_iter().chain(unexpected),
std::iter::empty::<(&str, &str)>(),
);
for (key, value) in desktop {
assert!(
child
.iter()
.any(|(found, content)| found == key && content == value)
);
}
for (key, _) in unexpected {
assert!(child.iter().all(|(found, _)| found != key));
}
}
#[test]
fn child_env_allowlist_keeps_build_config_but_not_credentials() {
for key in [
"CARGO_TARGET_DIR",
"CARGO_BUILD_JOBS",
"CARGO_INCREMENTAL",
"RUSTFLAGS",
"RUST_BACKTRACE",
"RUST_LOG",
"VIRTUAL_ENV",
"JAVA_HOME",
"GOPATH",
"NVM_DIR",
"NODE_OPTIONS",
"SSL_CERT_FILE",
"REQUESTS_CA_BUNDLE",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env should keep {key}"
);
}
for key in [
"CARGO_REGISTRY_TOKEN",
"CARGO_REGISTRIES_PRIVATE_TOKEN",
"CARGO_REGISTRIES_PRIVATE_CREDENTIAL_PROVIDER",
"CARGO_REGISTRY_GLOBAL_CREDENTIAL_PROVIDERS",
"CARGO_SOME_SECRET",
"CARGO_SIGNING_KEY",
"DATABASE_URL",
"OPENAI_API_KEY",
] {
assert!(
!is_allowed_parent_env_key(OsStr::new(key)),
"child env must not keep {key}"
);
}
}
#[test]
fn locale_and_dotnet_allowlists_drop_secret_shaped_names() {
for key in [
"LC_ALL",
"LC_CTYPE",
"LC_MESSAGES",
"LC_TIME",
"LC_COLLATE",
"LC_NUMERIC",
"LC_MONETARY",
"LC_PAPER",
"LC_NAME",
"LC_ADDRESS",
"LC_TELEPHONE",
"LC_MEASUREMENT",
"LC_IDENTIFICATION",
"LC_TERMINAL",
"LC_TERMINAL_VERSION",
"lc_time",
"DOTNET_ROOT",
"DOTNET_ROOT(x86)",
"DOTNET_ROOT_X64",
"DOTNET_HOST_PATH",
"DOTNET_CLI_HOME",
"DOTNET_NOLOGO",
"DOTNET_CLI_TELEMETRY_OPTOUT",
"DOTNET_SKIP_FIRST_TIME_EXPERIENCE",
"DOTNET_MULTILEVEL_LOOKUP",
"DOTNET_ROLL_FORWARD",
"DOTNET_SYSTEM_GLOBALIZATION_INVARIANT",
"DOTNET_CLI_UI_LANGUAGE",
"DOTNET_ENVIRONMENT",
"DOTNET_BUNDLE_EXTRACT_BASE_DIR",
"DOTNET_NUGET_SIGNATURE_VERIFICATION",
"DOTNET_ADD_GLOBAL_TOOLS_TO_PATH",
"DOTNET_WATCH_SUPPRESS_LAUNCH_BROWSER",
"DOTNET_USE_POLLING_FILE_WATCHER",
"DOTNET_RUNNING_IN_CONTAINER",
"DOTNET_TieredPGO",
"DOTNET_TieredCompilation",
"DOTNET_GCHeapHardLimit",
"DOTNET_EnableDiagnostics",
"dotnet_gcServer",
"DOTNET_SDK_VERSION",
"DOTNET_SYSTEM_NET_DISABLEIPV6",
"DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE",
"DOTNET_CLI_TELEMETRY_SESSIONID",
"DOTNET_WATCH_RESTART_ON_RUDE_EDIT",
"DOTNET_STARTUP_HOOKS",
"DOTNET_EventPipeOutputPath",
"DOTNET_DbgMiniDumpName",
"DOTNET_DiagnosticPorts",
] {
assert!(
is_allowed_parent_env_key(OsStr::new(key)),
"child env should keep {key}"
);
assert!(
is_allowed_mcp_env_key(OsStr::new(key)),
"mcp env should keep {key}"
);
}
for key in [
"LC_X_TOKEN",
"LC_PROBE_SECRET_TOKEN",
"lc_probe_password",
"LC_PROBE_API_KEY",
"LC_PROBE_SIGNING_KEY",
"LC_APIKEY",
"LC_ApiKey",
"LC_OPENAI_APIKEY",
"LC_GH_PAT",
"LC_PAT",
"LC_PASS",
"LC_X_PASS",
"LC_PWD",
"LC_AUTH",
"LC_X_AUTH",
"LC_BEARER",
"LC_JWT",
"LC_DB_URL",
"LC_DSN",
"LC_ACCESSKEY",
"LC_PRIVATEKEY",
"LC_SESSION_COOKIE",
"LC_TIME_EXTRA",
"DOTNET_X_API_KEY",
"DOTNET_PROBE_API_KEY",
"DOTNET_PROBE_ACCESS_KEY",
"DOTNET_CONNECTIONSTRINGS__PROBE_PASSWORD",
"DOTNET_ConnectionStrings__Default",
"DOTNET_ConnectionStrings:Default",
"DOTNET_Data__DefaultConnection__ConnectionString",
"DOTNET_ConnStr",
"DOTNET_ApiKey",
"DOTNET_OpenAI__ApiKey",
"DOTNET_OpenAI:ApiKey",
"DOTNET_Stripe__ApiKey",
"DOTNET_Jwt__SigningKey",
"DOTNET_Jwt__Key",
"DOTNET_Jwt__Keys__0",
"DOTNET_Aws__AccessKey",
"DOTNET_Signing__PrivateKey",
"DOTNET_AzureStorage__AccountKey",
"DOTNET_ApplicationInsights__InstrumentationKey",
"DOTNET_Auth__ClientSecret",
"DOTNET_Auth__Bearer",
"DOTNET_Smtp__Pass",
"DOTNET_Db__Pwd",
"DOTNET_Database__ConnStr",
"DOTNET_Database__Url",
"DOTNET_Sentry__Dsn",
"DOTNET_Redis__Configuration",
"DOTNET_Azure__SasToken",
"dotnet_probe_credential",
"DOTNET_",
"DOTNET__",
"DOTNET_GH_PAT",
"DOTNET_PAT",
"DOTNET_NUGET_PAT",
"DOTNET_AzureDevOpsPat",
"DOTNET_JWT",
"DOTNET_DATABASE_URL",
"DOTNET_DB_URL",
"DOTNET_DatabaseUrl",
"DOTNET_DefaultConnection",
"DOTNET_RedisConfiguration",
"DOTNET_SentryUrl",
"DOTNET_SlackWebhookUrl",
"DOTNET_SasUrl",
"DOTNET_Hmac",
"DOTNET_Salt",
"DOTNET_Signature",
"DOTNET_Pfx",
"DOTNET_Otp",
"DOTNET_Creds",
"DOTNET_Cred",
"DOTNET_Pw",
"DOTNET_Pin",
"DOTNET_Mnemonic",
"DOTNET_Seed",
"DOTNET_SessionId",
"DOTNET_Login",
"DOTNET_License",
"DOTNET_Api\u{212A}ey",
"DOTNET_Api\u{FF2B}ey",
"DOTNET_TieredPGO_X",
"DOTNET_ROOT__X",
] {
assert!(
!is_allowed_parent_env_key(OsStr::new(key)),
"child env must not keep {key}"
);
assert!(
!is_allowed_mcp_env_key(OsStr::new(key)),
"mcp env must not keep {key}"
);
}
}
#[test]
fn sanitized_envs_drop_secret_shaped_locale_and_dotnet_names() {
let _guard = crate::test_support::lock_test_env();
let secrets = [
"LC_PROBE_SECRET_TOKEN",
"LC_APIKEY",
"LC_GH_PAT",
"LC_PASS",
"DOTNET_PROBE_API_KEY",
"DOTNET_OpenAI__ApiKey",
"DOTNET_Jwt__SigningKey",
"DOTNET_Smtp__Pass",
"DOTNET_Db__Pwd",
"DOTNET_GH_PAT",
"DOTNET_DATABASE_URL",
"DOTNET_DefaultConnection",
"DOTNET_SlackWebhookUrl",
];
let _secret_guards: Vec<_> = secrets
.iter()
.map(|name| EnvVarGuard::set(name, "probe-fixture-value"))
.collect();
let _dotnet_root = EnvVarGuard::set("DOTNET_ROOT", "/opt/dotnet");
let _lc_time = EnvVarGuard::set("LC_TIME", "C");
let parent: Vec<(OsString, OsString)> = std::env::vars_os().collect();
for env in [
sanitized_child_env(std::iter::empty::<(OsString, OsString)>()),
sanitized_mcp_env(std::iter::empty::<(OsString, OsString)>()),
sanitized_runtime_env_from(parent.clone()),
sanitized_plugin_mcp_env_from(
parent.clone(),
std::iter::empty::<(OsString, OsString)>(),
),
] {
let has = |name: &str| env.iter().any(|(key, _)| normalize_key(key) == name);
for name in secrets {
assert!(!has(name), "{name} reached the child env");
}
assert!(
env.iter()
.all(|(_, value)| !value.to_string_lossy().contains("probe-fixture"))
);
assert!(has("DOTNET_ROOT"));
assert!(has("LC_TIME"));
}
}
#[test]
fn proxy_userinfo_is_removed_before_reaching_a_child() {
for (input, expected) in [
("http://user:secret@proxy:3128", "http://proxy:3128"),
(
"http://user:secret@proxy:3128/path?x=1",
"http://proxy:3128/path?x=1",
),
("socks5h://u:p@w@10.0.0.1:1080", "socks5h://10.0.0.1:1080"),
("user:secret@proxy:3128", "proxy:3128"),
("http://proxy:3128", "http://proxy:3128"),
("http://proxy:3128/a@b", "http://proxy:3128/a@b"),
] {
assert_eq!(
strip_proxy_userinfo(OsStr::new(input)),
Some(OsString::from(expected)),
"{input}"
);
}
}
#[test]
fn sanitized_child_env_strips_proxy_credentials() {
let _guard = crate::test_support::lock_test_env();
let _https = EnvVarGuard::set(
"HTTPS_PROXY",
"http://fixture-user:fixture-pass@proxy.invalid:3128",
);
let _cargo = EnvVarGuard::set(
"CARGO_HTTP_PROXY",
"http://fixture-user:fixture-pass@proxy.invalid:3128",
);
let _no_proxy = EnvVarGuard::set("NO_PROXY", "localhost");
let env = sanitized_child_env(std::iter::empty::<(OsString, OsString)>());
let get = |name: &str| {
env.iter()
.find(|(key, _)| normalize_key(key) == name)
.map(|(_, value)| value.clone())
};
assert_eq!(
get("HTTPS_PROXY"),
Some(OsString::from("http://proxy.invalid:3128"))
);
assert_eq!(
get("CARGO_HTTP_PROXY"),
Some(OsString::from("http://proxy.invalid:3128"))
);
assert_eq!(get("NO_PROXY"), Some(OsString::from("localhost")));
assert!(
env.iter()
.all(|(_, value)| !value.to_string_lossy().contains("fixture-pass"))
);
let explicit = sanitized_child_env([("HTTPS_PROXY", "http://a:b@proxy.invalid:1")]);
assert!(explicit.iter().any(|(key, value)| {
normalize_key(key) == "HTTPS_PROXY" && value == "http://a:b@proxy.invalid:1"
}));
}
#[test]
fn sanitized_child_env_drops_parent_secret_like_values() {
let _guard = crate::test_support::lock_test_env();
let _secret = EnvVarGuard::set("DEEPSEEK_CHILD_ENV_TEST_SECRET", "parent-secret");
let env = sanitized_child_env(std::iter::empty::<(OsString, OsString)>());
assert!(
env.iter()
.all(|(key, _)| key != "DEEPSEEK_CHILD_ENV_TEST_SECRET")
);
}
#[test]
fn sanitized_child_env_drops_rustc_wrapper_under_os_sandbox() {
let _guard = crate::test_support::lock_test_env();
let _wrapper = EnvVarGuard::set("RUSTC_WRAPPER", "sccache");
let unsandboxed = sanitized_child_env(std::iter::empty::<(OsString, OsString)>());
assert!(
unsandboxed
.iter()
.any(|(key, value)| normalize_key(key) == "RUSTC_WRAPPER" && value == "sccache"),
"unsandboxed children keep RUSTC_WRAPPER"
);
let sandboxed = sanitized_child_env([(
OsString::from("CODEWHALE_SANDBOX"),
OsString::from("seatbelt"),
)]);
assert!(
sandboxed.iter().any(
|(key, value)| normalize_key(key) == "CODEWHALE_SANDBOX" && value == "seatbelt"
),
"sandbox marker must survive"
);
assert!(
sandboxed
.iter()
.all(|(key, _)| normalize_key(key) != "RUSTC_WRAPPER"),
"OS sandbox children must not keep RUSTC_WRAPPER"
);
}
#[test]
fn explicit_child_env_values_win_over_parent_allowlist() {
assert_ne!(
std::env::var_os("PATH"),
Some(OsString::from("/explicit/bin"))
);
let env = sanitized_child_env([(OsString::from("PATH"), OsString::from("/explicit/bin"))]);
let path = env
.iter()
.find(|(key, _)| normalize_key(key) == "PATH")
.map(|(_, value)| value);
assert_eq!(path, Some(&OsString::from("/explicit/bin")));
}
#[test]
fn sanitized_child_env_preserves_windows_toolchain_vars() {
let _guard = crate::test_support::lock_test_env();
let _lib = EnvVarGuard::set("LIB", r"C:\sdk\lib");
let _include = EnvVarGuard::set("INCLUDE", r"C:\sdk\include");
let _sdk = EnvVarGuard::set("WINDOWSSDKDIR", r"C:\sdk");
let env = sanitized_child_env(std::iter::empty::<(OsString, OsString)>());
assert!(
env.iter()
.any(|(key, value)| key == "LIB" && value == r"C:\sdk\lib"),
"child env should preserve LIB"
);
assert!(
env.iter()
.any(|(key, value)| key == "INCLUDE" && value == r"C:\sdk\include"),
"child env should preserve INCLUDE"
);
assert!(
env.iter()
.any(|(key, value)| key == "WINDOWSSDKDIR" && value == r"C:\sdk"),
"child env should preserve WINDOWSSDKDIR"
);
}
}