Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
#![cfg(windows)]
use hiroute_platform::windows::{pipe, security};
#[path = "support/windows_junction.rs"]
mod junction;
#[test]
fn ancestor_junction_cannot_redirect_private_read_or_creation() {
let fixture = tempfile::tempdir().unwrap();
let outside = fixture.path().join("outside");
let held = security::create_owner_only_directory(&outside).unwrap();
let original = outside.join("original");
let file = security::create_owner_only_file(&original).unwrap();
drop(file);
// Child creation above must succeed while its DELETE-capable parent is held.
// Release that pin only for the independent junction fixture setup, then
// exercise rejection of the published alias.
drop(held);
let alias = fixture.path().join("alias");
junction::create(&alias, &outside).expect("owned junction fixture must be created");
assert!(security::open_owner_only(&alias.join("original"), false).is_err());
assert!(security::create_owner_only_file(&alias.join("new")).is_err());
assert!(pipe::name(&alias.join("control.sock")).is_err());
assert!(!outside.join("new").exists());
assert!(original.exists());
std::fs::remove_dir(&alias).unwrap();
}
use std::io::{Read, Write};
use std::time::Duration;
#[test]
fn private_file_identity_is_held_and_reparse_free() {
let fixture = tempfile::tempdir().unwrap();
let directory_path = fixture.path().join("held parent");
let directory = security::create_owner_only_directory(&directory_path).unwrap();
let mut child = security::create_owner_only_file_at(&directory, "child".as_ref()).unwrap();
child.write_all(b"owned-child").unwrap();
assert!(std::fs::rename(&directory_path, fixture.path().join("moved parent")).is_err());
security::delete_by_handle(&child).unwrap();
drop(child);
security::delete_by_handle(&directory).unwrap();
drop(directory);
assert!(!directory_path.exists());
// An existing traversal handle may permit rename; relative operations must
// still address that object, never a replacement at its original path.
std::fs::create_dir(&directory_path).unwrap();
let identity = security::open_identity(&directory_path, true).unwrap();
let moved_path = fixture.path().join("moved parent");
std::fs::rename(&directory_path, &moved_path).unwrap();
std::fs::create_dir(&directory_path).unwrap();
let child = security::create_owner_only_file_at(&identity, "bound-child".as_ref()).unwrap();
assert!(moved_path.join("bound-child").exists());
assert!(!directory_path.join("bound-child").exists());
drop(child);
drop(identity);
let path = fixture.path().join("私有 文件");
let mut file = security::create_owner_only_file(&path).unwrap();
file.write_all(b"synthetic-private-data").unwrap();
file.sync_all().unwrap();
security::verify_owner_only_handle(&file, false).unwrap();
let identity = security::file_identity(&file).unwrap();
assert_eq!(
identity,
security::file_identity(&file.try_clone().unwrap()).unwrap()
);
let renamed = fixture.path().join("renamed");
assert!(std::fs::rename(&path, &renamed).is_err());
let other = security::create_owner_only_file(&fixture.path().join("other")).unwrap();
assert_ne!(identity, security::file_identity(&other).unwrap());
drop(file);
let file = security::open_owner_only(&path, false).unwrap();
assert_eq!(identity, security::file_identity(&file).unwrap());
assert!(security::open_identity(fixture.path(), false).is_err());
}
#[test]
fn pipe_exclusivity_bidirectional_frames_and_peer_identity() {
let fixture = tempfile::tempdir().unwrap();
let endpoint = fixture.path().join("control.sock");
let listener = pipe::Listener::bind(&endpoint).unwrap();
assert!(pipe::Listener::bind(&endpoint).is_err());
listener.set_nonblocking(true).unwrap();
assert_eq!(
listener.accept().err().unwrap().kind(),
std::io::ErrorKind::WouldBlock
);
listener.set_nonblocking(false).unwrap();
let client_endpoint = endpoint.clone();
let client = std::thread::spawn(move || {
let mut client = pipe::Stream::connect(&client_endpoint).unwrap();
client
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
assert_eq!(pipe::peer_pid(&client, false).unwrap(), std::process::id());
client.write_all(b"hello\n").unwrap();
let mut response = [0; 6];
client.read_exact(&mut response).unwrap();
assert_eq!(&response, b"reply\n");
client.write_all(b"ack\n").unwrap();
});
let (mut stream, ()) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
assert_eq!(pipe::peer_pid(&stream, true).unwrap(), std::process::id());
let mut request = [0; 6];
stream.read_exact(&mut request).unwrap();
assert_eq!(&request, b"hello\n");
stream.write_all(b"reply\n").unwrap();
let mut ack = [0; 4];
stream.read_exact(&mut ack).unwrap();
assert_eq!(&ack, b"ack\n");
client.join().unwrap();
drop(stream);
drop(listener);
assert!(!endpoint.exists());
let _rebound = pipe::Listener::bind(&endpoint).unwrap();
}
#[test]
fn pipe_deadline_cancels_read_without_consuming_the_next_frame() {
let fixture = tempfile::tempdir().unwrap();
let endpoint = fixture.path().join("deadline.sock");
let listener = pipe::Listener::bind(&endpoint).unwrap();
let mut client = pipe::Stream::connect(&endpoint).unwrap();
let (mut server, ()) = listener.accept().unwrap();
server
.set_read_timeout(Some(Duration::from_millis(20)))
.unwrap();
let mut byte = [0];
assert_eq!(
server.read(&mut byte).unwrap_err().kind(),
std::io::ErrorKind::TimedOut
);
server
.set_read_timeout(Some(Duration::from_secs(3)))
.unwrap();
client.write_all(b"x").unwrap();
server.read_exact(&mut byte).unwrap();
assert_eq!(&byte, b"x");
}
#[test]
fn native_permissions_survive_atomic_restore_and_detect_acl_changes() {
use hiroute_platform::{durable, file_security};
let fixture = tempfile::tempdir().unwrap();
let target = fixture.path().join("native.json");
std::fs::write(&target, b"original").unwrap();
let original =
file_security::capture(&security::open_identity(&target, false).unwrap()).unwrap();
durable::write_private_atomic(&target, b"managed").unwrap();
let managed =
file_security::capture(&security::open_owner_only(&target, false).unwrap()).unwrap();
assert_eq!(managed, file_security::private_defaults(false).unwrap());
assert_ne!(managed.descriptor, original.descriptor);
durable::write_windows_atomic(&target, b"original", &original).unwrap();
assert_eq!(std::fs::read(&target).unwrap(), b"original");
assert_eq!(
file_security::capture(&security::open_identity(&target, false).unwrap()).unwrap(),
original
);
// This native component gate already runs with an administrator token.
// Observe default BA ownership of a new, known fixture; a standard
// product user does not need this fixture-creation permission.
let foreign = fixture.path().join("administrators-owned.json");
std::fs::write(&foreign, b"foreign-owner-original").unwrap();
let before =
file_security::capture(&security::open_identity(&foreign, false).unwrap()).unwrap();
assert!(
before
.descriptor
.strip_prefix("O:BA")
.is_some_and(|rest| rest.is_empty()
|| rest.starts_with("G:")
|| rest.starts_with("D:")
|| rest.starts_with("S:")),
"administrator native fixture requires actual BA owner: {}",
before.descriptor
);
assert_eq!(
security::set_owner_only(&foreign, false)
.unwrap_err()
.kind(),
std::io::ErrorKind::PermissionDenied,
"a DACL-tightening setter cannot adopt the BA-owned fixture"
);
assert_eq!(
file_security::capture(&security::open_identity(&foreign, false).unwrap()).unwrap(),
before,
"refusing a foreign owner must leave its exact native descriptor unchanged"
);
assert_eq!(std::fs::read(foreign).unwrap(), b"foreign-owner-original");
}
fn shared_native_file(path: &std::path::Path, access: u32) -> std::io::Result<std::fs::File> {
use std::os::windows::fs::OpenOptionsExt;
use windows_sys::Win32::Storage::FileSystem::{
FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
};
std::fs::OpenOptions::new()
.read(true)
.access_mode(access)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
.open(path)
}
fn held_bytes(file: &mut std::fs::File) -> Vec<u8> {
use std::io::{Seek, SeekFrom};
file.seek(SeekFrom::Start(0)).unwrap();
let mut bytes = Vec::new();
file.read_to_end(&mut bytes).unwrap();
bytes
}
// Teardown modifies attributes only through an admitted held fixture object.
// The tested publication never clears read-only by pathname.
fn unseal_fixture(file: &std::fs::File) {
set_fixture_read_only(file, false);
}
fn set_fixture_read_only(file: &std::fs::File, read_only: bool) {
use std::os::windows::io::AsRawHandle;
use windows_sys::Win32::Storage::FileSystem::{
FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_BASIC_INFO, FileBasicInfo,
SetFileInformationByHandle,
};
let information = FILE_BASIC_INFO {
FileAttributes: if read_only {
FILE_ATTRIBUTE_READONLY
} else {
FILE_ATTRIBUTE_NORMAL
},
..Default::default()
};
assert_ne!(
unsafe {
SetFileInformationByHandle(
file.as_raw_handle().cast(),
FileBasicInfo,
(&information as *const FILE_BASIC_INFO).cast(),
std::mem::size_of::<FILE_BASIC_INFO>() as u32,
)
},
0,
"owned native fixture attribute update"
);
}
fn assert_readonly_user_and_system_fixture(file: &std::fs::File, user_sid: &str) {
use std::os::windows::fs::MetadataExt;
use std::os::windows::io::AsRawHandle;
use windows_sys::Win32::Foundation::LocalFree;
use windows_sys::Win32::Security::Authorization::{
ConvertStringSidToSidW, GetSecurityInfo, SE_FILE_OBJECT,
};
use windows_sys::Win32::Security::{
ACCESS_ALLOWED_ACE, DACL_SECURITY_INFORMATION, EqualSid, GetAce,
GetSecurityDescriptorControl, OWNER_SECURITY_INFORMATION, SE_DACL_PROTECTED,
};
use windows_sys::Win32::Storage::FileSystem::{
FILE_ALL_ACCESS, FILE_ATTRIBUTE_READONLY, FILE_GENERIC_READ,
};
struct Allocation(*mut std::ffi::c_void);
impl Drop for Allocation {
fn drop(&mut self) {
// SAFETY: both SID conversion and GetSecurityInfo use LocalAlloc.
unsafe { LocalFree(self.0) };
}
}
let decode_sid = |sid: &str| {
let wide: Vec<u16> = sid.encode_utf16().chain([0]).collect();
let mut decoded = std::ptr::null_mut();
// SAFETY: bounded fixture SID and output remain live for conversion.
assert_ne!(
unsafe { ConvertStringSidToSidW(wide.as_ptr(), &mut decoded) },
0
);
Allocation(decoded)
};
let user = decode_sid(user_sid);
let system = decode_sid("S-1-5-18");
let mut owner = std::ptr::null_mut();
let mut dacl = std::ptr::null_mut();
let mut descriptor = std::ptr::null_mut();
// SAFETY: all returned pointers are retained by the descriptor allocation.
assert_eq!(
unsafe {
GetSecurityInfo(
file.as_raw_handle().cast(),
SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
&mut owner,
std::ptr::null_mut(),
&mut dacl,
std::ptr::null_mut(),
&mut descriptor,
)
},
0
);
let descriptor = Allocation(descriptor);
assert!(!owner.is_null() && !dacl.is_null());
// SAFETY: both SIDs are validated Windows outputs held above.
assert_ne!(
unsafe { EqualSid(owner, user.0) },
0,
"fixture owner must remain TokenUser"
);
let mut control = 0;
let mut revision = 0;
assert_ne!(
unsafe { GetSecurityDescriptorControl(descriptor.0, &mut control, &mut revision) },
0
);
assert_ne!(control & SE_DACL_PROTECTED, 0);
assert_eq!(
unsafe { (*dacl).AceCount },
2,
"fixture must have exactly two ACEs"
);
let mut user_full = false;
let mut system_read = false;
for index in 0..2 {
let mut ace = std::ptr::null_mut();
assert_ne!(unsafe { GetAce(dacl, index, &mut ace) }, 0);
assert!(!ace.is_null());
// SAFETY: GetSecurityInfo and GetAce supplied a native, validated ACL.
let ace = unsafe { &*ace.cast::<ACCESS_ALLOWED_ACE>() };
assert_eq!(ace.Header.AceType, 0, "ACCESS_ALLOWED_ACE_TYPE required");
assert_eq!(
ace.Header.AceFlags, 0,
"no inherited or propagating fixture ACEs"
);
let sid = (&ace.SidStart as *const u32).cast_mut().cast();
if unsafe { EqualSid(sid, user.0) } != 0 {
assert!(!user_full, "duplicate user ACE");
assert_eq!(ace.Mask, FILE_ALL_ACCESS);
user_full = true;
} else {
assert_ne!(unsafe { EqualSid(sid, system.0) }, 0, "foreign fixture ACE");
assert!(!system_read, "duplicate SYSTEM ACE");
assert_eq!(ace.Mask, FILE_GENERIC_READ);
system_read = true;
}
}
assert!(user_full && system_read);
assert_ne!(
file.metadata().unwrap().file_attributes() & FILE_ATTRIBUTE_READONLY,
0
);
}
fn set_fixture_dacl(file: &std::fs::File, sddl: &str) {
use std::os::windows::io::AsRawHandle;
use windows_sys::Win32::Foundation::LocalFree;
use windows_sys::Win32::Security::Authorization::{
ConvertStringSecurityDescriptorToSecurityDescriptorW, SE_FILE_OBJECT, SetSecurityInfo,
};
use windows_sys::Win32::Security::{
DACL_SECURITY_INFORMATION, GetSecurityDescriptorDacl, PROTECTED_DACL_SECURITY_INFORMATION,
};
let wide: Vec<u16> = sddl.encode_utf16().chain([0]).collect();
let mut descriptor = std::ptr::null_mut();
assert_ne!(
unsafe {
ConvertStringSecurityDescriptorToSecurityDescriptorW(
wide.as_ptr(),
1,
&mut descriptor,
std::ptr::null_mut(),
)
},
0
);
let mut present = 0;
let mut defaulted = 0;
let mut dacl = std::ptr::null_mut();
let decoded =
unsafe { GetSecurityDescriptorDacl(descriptor, &mut present, &mut dacl, &mut defaulted) };
let result = if decoded != 0 && present != 0 && !dacl.is_null() {
unsafe {
SetSecurityInfo(
file.as_raw_handle().cast(),
SE_FILE_OBJECT,
DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
std::ptr::null_mut(),
std::ptr::null_mut(),
dacl,
std::ptr::null_mut(),
)
}
} else {
u32::MAX
};
unsafe {
LocalFree(descriptor);
}
assert_eq!(result, 0, "explicit-owner fixture DACL update");
}
fn remove_uncommitted_fixture_stages(directory: &std::path::Path) {
use windows_sys::Win32::Storage::FileSystem::{
FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, READ_CONTROL,
};
// Definite failed publication may retain its unique uncommitted stage.
// Only clean those fixture-owned objects, after all acceptance assertions.
for entry in std::fs::read_dir(directory).unwrap() {
let entry = entry.unwrap();
let name = entry.file_name();
if name
.to_str()
.is_some_and(|name| name.starts_with(".hiroute-write-") && name.ends_with(".tmp"))
{
let file = shared_native_file(
&entry.path(),
READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
)
.unwrap();
security::verify_owner_only_handle(&file, false).unwrap();
unseal_fixture(&file);
drop(file);
std::fs::remove_file(entry.path()).unwrap();
}
}
}
#[test]
fn sealed_readonly_artifact_rename_preserves_bytes_identity_and_native_permissions() {
use hiroute_platform::{durable, file_security};
use windows_sys::Win32::Foundation::GENERIC_READ;
use windows_sys::Win32::Storage::FileSystem::FILE_WRITE_ATTRIBUTES;
let fixture = tempfile::tempdir().unwrap();
let directory = fixture.path().join("native sealed artifact");
let _parent = security::create_owner_only_directory(&directory).unwrap();
let source = directory.join("completed source");
let target = directory.join("published artifact");
let original = file_security::private_defaults(true).unwrap();
durable::write_windows_atomic(&source, b"complete-sealed-artifact", &original).unwrap();
let mut held_source = shared_native_file(&source, GENERIC_READ).unwrap();
let original_identity = security::file_identity(&held_source).unwrap();
assert_eq!(file_security::capture(&held_source).unwrap(), original);
assert!(!target.exists());
// The producer above has already synced the complete bytes and descriptor.
// A sealed source must not be reopened with GENERIC_WRITE or unsealed first.
durable::rename_windows_sealed_file(&source, &target).unwrap();
assert!(!source.exists());
let published = security::open_owner_only(&target, false).unwrap();
assert_eq!(
security::file_identity(&published).unwrap(),
original_identity
);
assert_eq!(file_security::capture(&published).unwrap(), original);
assert_eq!(std::fs::read(&target).unwrap(), b"complete-sealed-artifact");
drop(published);
durable::write_windows_atomic(
&source,
b"different-object-at-former-source",
&file_security::private_defaults(false).unwrap(),
)
.unwrap();
let replacement = security::open_owner_only(&source, false).unwrap();
assert_ne!(
security::file_identity(&replacement).unwrap(),
original_identity
);
assert_eq!(held_bytes(&mut held_source), b"complete-sealed-artifact");
assert_eq!(file_security::capture(&held_source).unwrap(), original);
assert_eq!(
std::fs::read(&source).unwrap(),
b"different-object-at-former-source"
);
drop(replacement);
drop(held_source);
unseal_fixture(&shared_native_file(&target, FILE_WRITE_ATTRIBUTES).unwrap());
drop(_parent);
fixture.close().unwrap();
}
#[test]
fn readonly_atomic_restore_preserves_permissions_and_requires_target_write_attributes() {
use hiroute_platform::{durable, file_security};
use windows_sys::Win32::Foundation::{ERROR_ACCESS_DENIED, GENERIC_READ};
use windows_sys::Win32::Storage::FileSystem::{
FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, READ_CONTROL, WRITE_DAC,
};
let fixture = tempfile::tempdir().unwrap();
let directory = fixture.path().join("native readonly restoration");
let _parent = security::create_owner_only_directory(&directory).unwrap();
let sid = hiroute_platform::windows::background::current_sid_string().unwrap();
for read_only in [false, true] {
let target = directory.join(format!("restore-{read_only}"));
// Use an actual, independently checked native descriptor as recovery
// input. Handwritten SDDL is not a promised encoder spelling: Windows
// may serialize SID aliases, rights and control bits differently.
let mut initial = security::create_owner_only_file(&target).unwrap();
initial.write_all(b"old-native-bytes").unwrap();
initial.sync_all().unwrap();
security::verify_owner_only_handle(&initial, false).unwrap();
let initial_identity = security::file_identity(&initial).unwrap();
drop(initial);
let fixture_control = shared_native_file(
&target,
READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
)
.unwrap();
assert_eq!(
security::file_identity(&fixture_control).unwrap(),
initial_identity
);
set_fixture_dacl(&fixture_control, &format!("D:P(A;;FA;;;{sid})(A;;FR;;;SY)"));
set_fixture_read_only(&fixture_control, true);
assert_readonly_user_and_system_fixture(&fixture_control, &sid);
let old_permissions = file_security::capture(&fixture_control).unwrap();
assert!(old_permissions.read_only);
drop(fixture_control);
durable::write_windows_atomic(&target, b"old-native-bytes", &old_permissions).unwrap();
let mut old_reader = shared_native_file(&target, GENERIC_READ).unwrap();
assert_readonly_user_and_system_fixture(&old_reader, &sid);
let old_identity = security::file_identity(&old_reader).unwrap();
assert_eq!(
file_security::capture(&old_reader).unwrap(),
old_permissions
);
let new_permissions = file_security::private_defaults(read_only).unwrap();
let replaced =
durable::write_windows_atomic(&target, b"new-native-bytes", &new_permissions);
if let Err(error) = &replaced {
// Ex does not enable POSIX replacement. A native sharing rejection
// must preserve the old object; releasing the witness then retries
// the exact same public operation, without clearing read-only.
assert!(matches!(error.raw_os_error(), Some(5 | 32)));
let still_old = security::open_identity(&target, false).unwrap();
assert_eq!(security::file_identity(&still_old).unwrap(), old_identity);
assert_eq!(file_security::capture(&still_old).unwrap(), old_permissions);
assert_eq!(std::fs::read(&target).unwrap(), b"old-native-bytes");
}
assert_eq!(held_bytes(&mut old_reader), b"old-native-bytes");
assert_eq!(
file_security::capture(&old_reader).unwrap(),
old_permissions
);
drop(old_reader);
if replaced.is_err() {
durable::write_windows_atomic(&target, b"new-native-bytes", &new_permissions).unwrap();
}
let published = security::open_owner_only(&target, false).unwrap();
assert_eq!(file_security::capture(&published).unwrap(), new_permissions);
assert_ne!(security::file_identity(&published).unwrap(), old_identity);
assert_ne!(new_permissions.descriptor, old_permissions.descriptor);
assert_eq!(std::fs::read(&target).unwrap(), b"new-native-bytes");
drop(published);
if read_only {
unseal_fixture(&shared_native_file(&target, FILE_WRITE_ATTRIBUTES).unwrap());
}
}
let denied = directory.join("denied-write-attributes");
let private_readonly = file_security::private_defaults(true).unwrap();
durable::write_windows_atomic(&denied, b"protected-original", &private_readonly).unwrap();
let fixture_control = shared_native_file(
&denied,
READ_CONTROL | WRITE_DAC | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
)
.unwrap();
// This object was explicitly user-owned during creation. Its retained
// fixture control handle can restore the test DACL during teardown; that
// held capability is never passed to the publication being tested.
set_fixture_dacl(
&fixture_control,
&format!("O:{sid}D:P(D;;0x100;;;{sid})(A;;FA;;;{sid})"),
);
assert_eq!(
shared_native_file(&denied, FILE_WRITE_ATTRIBUTES)
.unwrap_err()
.raw_os_error(),
Some(ERROR_ACCESS_DENIED as i32),
"the real token must lack target WRITE_ATTRIBUTES even on the admin runner"
);
let before = file_security::capture(&fixture_control).unwrap();
let before_identity = security::file_identity(&fixture_control).unwrap();
assert!(before.read_only);
assert_eq!(
durable::write_windows_atomic(
&denied,
b"unauthorized-replacement",
&file_security::private_defaults(false).unwrap(),
)
.unwrap_err()
.kind(),
std::io::ErrorKind::PermissionDenied
);
let unchanged = security::open_identity(&denied, false).unwrap();
assert_eq!(
security::file_identity(&unchanged).unwrap(),
before_identity
);
assert_eq!(file_security::capture(&unchanged).unwrap(), before);
assert_eq!(std::fs::read(&denied).unwrap(), b"protected-original");
drop(unchanged);
set_fixture_dacl(&fixture_control, &private_readonly.descriptor);
unseal_fixture(&fixture_control);
drop(fixture_control);
remove_uncommitted_fixture_stages(&directory);
drop(_parent);
fixture.close().unwrap();
}