use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use crate::capabilities::{NseCapabilityContext, NseCapabilityKind, NseCapabilityRequest};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseProviderError {
pub kind: &'static str,
pub message: String,
}
impl NseProviderError {
pub fn new(kind: &'static str, message: impl Into<String>) -> Self {
Self {
kind,
message: message.into(),
}
}
}
impl std::fmt::Display for NseProviderError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "NSE {} provider failed: {}", self.kind, self.message)
}
}
impl std::error::Error for NseProviderError {}
pub trait NseClockProvider: Send + Sync {
fn unix_timestamp(&self) -> Result<i64, NseProviderError>;
}
pub trait NseRandomProvider: Send + Sync {
fn fill_bytes(&self, out: &mut [u8]) -> Result<(), NseProviderError>;
fn random_u32(&self) -> Result<u32, NseProviderError> {
let mut buf = [0u8; 4];
self.fill_bytes(&mut buf)?;
Ok(u32::from_le_bytes(buf))
}
fn random_f64(&self) -> Result<f64, NseProviderError> {
let mut buf = [0u8; 8];
self.fill_bytes(&mut buf)?;
let v = u64::from_le_bytes(buf) >> 11;
Ok((v as f64) / ((1u64 << 53) as f64))
}
}
pub trait NseEnvironmentProvider: Send + Sync {
fn var(&self, name: &str) -> Result<Option<String>, NseProviderError>;
fn temp_dir(&self) -> Result<PathBuf, NseProviderError>;
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeClockProvider;
impl NseClockProvider for NativeClockProvider {
fn unix_timestamp(&self) -> Result<i64, NseProviderError> {
Ok(chrono::Utc::now().timestamp())
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeRandomProvider;
impl NseRandomProvider for NativeRandomProvider {
fn fill_bytes(&self, out: &mut [u8]) -> Result<(), NseProviderError> {
for b in out.iter_mut() {
*b = rand::random::<u8>();
}
Ok(())
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeEnvironmentProvider;
impl NseEnvironmentProvider for NativeEnvironmentProvider {
fn var(&self, name: &str) -> Result<Option<String>, NseProviderError> {
Ok(std::env::var(name).ok())
}
fn temp_dir(&self) -> Result<PathBuf, NseProviderError> {
Ok(std::env::temp_dir())
}
}
#[derive(Clone)]
pub struct NseHostServices {
clock: Arc<dyn NseClockProvider>,
random: Arc<dyn NseRandomProvider>,
environment: Arc<dyn NseEnvironmentProvider>,
dns: Arc<dyn NseDnsProvider>,
tcp: Arc<dyn NseTcpSocketProvider>,
udp: Arc<dyn NseUdpSocketProvider>,
fs: Arc<dyn NseFilesystemProvider>,
process: Arc<dyn NseProcessProvider>,
http: Arc<dyn NseHttpProvider>,
http_authority_bound: bool,
}
impl std::fmt::Debug for NseHostServices {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NseHostServices")
.field("has_clock", &true)
.field("has_random", &true)
.field("has_environment", &true)
.field("has_dns", &true)
.field("has_tcp", &true)
.field("has_udp", &true)
.field("has_fs", &true)
.field("has_process", &true)
.field("has_http", &true)
.field("http_authority_bound", &self.http_authority_bound)
.finish()
}
}
impl Default for NseHostServices {
fn default() -> Self {
Self::native()
}
}
impl NseHostServices {
pub fn native() -> Self {
Self {
clock: Arc::new(NativeClockProvider),
random: Arc::new(NativeRandomProvider),
environment: Arc::new(NativeEnvironmentProvider),
dns: Arc::new(NativeDnsProvider::new()),
tcp: Arc::new(NativeTcpSocketProvider),
udp: Arc::new(NativeUdpSocketProvider),
fs: Arc::new(NativeFilesystemProvider::new()),
process: Arc::new(NativeProcessProvider),
http: Arc::new(NativeHttpProvider::new()),
http_authority_bound: false,
}
}
pub fn new(
clock: Arc<dyn NseClockProvider>,
random: Arc<dyn NseRandomProvider>,
environment: Arc<dyn NseEnvironmentProvider>,
) -> Self {
Self {
clock,
random,
environment,
dns: Arc::new(NativeDnsProvider::new()),
tcp: Arc::new(NativeTcpSocketProvider),
udp: Arc::new(NativeUdpSocketProvider),
fs: Arc::new(NativeFilesystemProvider::new()),
process: Arc::new(NativeProcessProvider),
http: Arc::new(NativeHttpProvider::new()),
http_authority_bound: false,
}
}
pub fn new_full(
clock: Arc<dyn NseClockProvider>,
random: Arc<dyn NseRandomProvider>,
environment: Arc<dyn NseEnvironmentProvider>,
dns: Arc<dyn NseDnsProvider>,
tcp: Arc<dyn NseTcpSocketProvider>,
udp: Arc<dyn NseUdpSocketProvider>,
) -> Self {
Self {
clock,
random,
environment,
dns,
tcp,
udp,
fs: Arc::new(NativeFilesystemProvider::new()),
process: Arc::new(NativeProcessProvider),
http: Arc::new(NativeHttpProvider::new()),
http_authority_bound: false,
}
}
pub fn with_clock(mut self, provider: Arc<dyn NseClockProvider>) -> Self {
self.clock = provider;
self
}
pub fn with_random(mut self, provider: Arc<dyn NseRandomProvider>) -> Self {
self.random = provider;
self
}
pub fn with_environment(mut self, provider: Arc<dyn NseEnvironmentProvider>) -> Self {
self.environment = provider;
self
}
pub fn with_dns(mut self, provider: Arc<dyn NseDnsProvider>) -> Self {
self.dns = provider;
self
}
pub fn with_tcp(mut self, provider: Arc<dyn NseTcpSocketProvider>) -> Self {
self.tcp = provider;
self
}
pub fn with_udp(mut self, provider: Arc<dyn NseUdpSocketProvider>) -> Self {
self.udp = provider;
self
}
pub fn with_fs(mut self, provider: Arc<dyn NseFilesystemProvider>) -> Self {
self.fs = provider;
self
}
pub fn with_process(mut self, provider: Arc<dyn NseProcessProvider>) -> Self {
self.process = provider;
self
}
pub fn with_http(mut self, provider: Arc<dyn NseHttpProvider>) -> Self {
self.http = provider;
self
}
pub fn with_authority_bound_http(mut self) -> Self {
self.http_authority_bound = true;
self
}
pub fn clock(&self) -> &Arc<dyn NseClockProvider> {
&self.clock
}
pub fn random(&self) -> &Arc<dyn NseRandomProvider> {
&self.random
}
pub fn environment(&self) -> &Arc<dyn NseEnvironmentProvider> {
&self.environment
}
pub fn dns(&self) -> &Arc<dyn NseDnsProvider> {
&self.dns
}
pub fn tcp(&self) -> &Arc<dyn NseTcpSocketProvider> {
&self.tcp
}
pub fn udp(&self) -> &Arc<dyn NseUdpSocketProvider> {
&self.udp
}
pub fn fs(&self) -> &Arc<dyn NseFilesystemProvider> {
&self.fs
}
pub fn process(&self) -> &Arc<dyn NseProcessProvider> {
&self.process
}
pub fn http(&self) -> &Arc<dyn NseHttpProvider> {
&self.http
}
pub fn is_http_authority_bound(&self) -> bool {
self.http_authority_bound
}
}
pub struct FixedClockProvider {
timestamp: AtomicI64,
}
impl FixedClockProvider {
pub fn new(timestamp: i64) -> Self {
Self {
timestamp: AtomicI64::new(timestamp),
}
}
}
impl NseClockProvider for FixedClockProvider {
fn unix_timestamp(&self) -> Result<i64, NseProviderError> {
Ok(self.timestamp.load(Ordering::SeqCst))
}
}
pub struct DeterministicRandomProvider {
pattern: Vec<u8>,
cursor: Mutex<usize>,
}
impl DeterministicRandomProvider {
pub fn new(pattern: Vec<u8>) -> Self {
Self {
pattern,
cursor: Mutex::new(0),
}
}
}
impl NseRandomProvider for DeterministicRandomProvider {
fn fill_bytes(&self, out: &mut [u8]) -> Result<(), NseProviderError> {
let mut cursor = self.cursor.lock().map_err(|e| {
NseProviderError::new("random", format!("deterministic RNG lock failed: {e}"))
})?;
for (i, slot) in out.iter_mut().enumerate() {
if self.pattern.is_empty() {
*slot = ((*cursor + i) % 256) as u8;
} else {
*slot = self.pattern[(*cursor + i) % self.pattern.len()];
}
}
*cursor = cursor.wrapping_add(out.len());
Ok(())
}
}
pub struct MapEnvironmentProvider {
vars: HashMap<String, String>,
temp_dir: PathBuf,
}
impl MapEnvironmentProvider {
pub fn new(vars: HashMap<String, String>, temp_dir: PathBuf) -> Self {
Self { vars, temp_dir }
}
}
impl NseEnvironmentProvider for MapEnvironmentProvider {
fn var(&self, name: &str) -> Result<Option<String>, NseProviderError> {
Ok(self.vars.get(name).cloned())
}
fn temp_dir(&self) -> Result<PathBuf, NseProviderError> {
Ok(self.temp_dir.clone())
}
}
pub struct CountingClockProvider {
inner: FixedClockProvider,
calls: AtomicU64,
}
impl CountingClockProvider {
pub fn new(timestamp: i64) -> Self {
Self {
inner: FixedClockProvider::new(timestamp),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl NseClockProvider for CountingClockProvider {
fn unix_timestamp(&self) -> Result<i64, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.unix_timestamp()
}
}
pub struct CountingRandomProvider {
inner: DeterministicRandomProvider,
calls: AtomicU64,
}
impl CountingRandomProvider {
pub fn new(pattern: Vec<u8>) -> Self {
Self {
inner: DeterministicRandomProvider::new(pattern),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl NseRandomProvider for CountingRandomProvider {
fn fill_bytes(&self, out: &mut [u8]) -> Result<(), NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.fill_bytes(out)
}
}
pub struct CountingEnvironmentProvider {
inner: MapEnvironmentProvider,
calls: AtomicU64,
}
impl CountingEnvironmentProvider {
pub fn new(vars: HashMap<String, String>, temp_dir: PathBuf) -> Self {
Self {
inner: MapEnvironmentProvider::new(vars, temp_dir),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl NseEnvironmentProvider for CountingEnvironmentProvider {
fn var(&self, name: &str) -> Result<Option<String>, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.var(name)
}
fn temp_dir(&self) -> Result<PathBuf, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.temp_dir()
}
}
fn broker_request(
kind: NseCapabilityKind,
target: Option<String>,
bytes_hint: Option<u64>,
operation: &'static str,
) -> NseCapabilityRequest {
NseCapabilityRequest {
kind,
target,
bytes_hint,
operation,
}
}
fn deny_message(decision: &crate::capabilities::NseCapabilityDecision, fallback: &str) -> String {
decision.deny_reason().unwrap_or(fallback).to_string()
}
pub fn broker_unix_timestamp(
ctx: &NseCapabilityContext,
services: &NseHostServices,
operation: &'static str,
) -> Result<i64, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(NseCapabilityKind::TimeClock, None, None, operation);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "time clock access denied"));
}
ctx.before_blocking_operation(&request)?;
let value = services
.clock()
.unix_timestamp()
.map_err(|e| format!("clock provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(value)
}
pub fn broker_random_fill(
ctx: &NseCapabilityContext,
services: &NseHostServices,
out: &mut [u8],
operation: &'static str,
) -> Result<(), String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::Randomness,
None,
Some(out.len() as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "randomness generation denied"));
}
ctx.before_blocking_operation(&request)?;
services
.random()
.fill_bytes(out)
.map_err(|e| format!("random provider failed: {e}"))?;
ctx.after_blocking_operation(&request, Some(out.len() as u64));
Ok(())
}
pub fn broker_random_f64(
ctx: &NseCapabilityContext,
services: &NseHostServices,
operation: &'static str,
) -> Result<f64, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(NseCapabilityKind::Randomness, None, None, operation);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "randomness generation denied"));
}
ctx.before_blocking_operation(&request)?;
let value = services
.random()
.random_f64()
.map_err(|e| format!("random provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(value)
}
pub fn broker_random_u32(
ctx: &NseCapabilityContext,
services: &NseHostServices,
operation: &'static str,
) -> Result<u32, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(NseCapabilityKind::Randomness, None, None, operation);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "randomness generation denied"));
}
ctx.before_blocking_operation(&request)?;
let value = services
.random()
.random_u32()
.map_err(|e| format!("random provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(value)
}
pub fn broker_env_var(
ctx: &NseCapabilityContext,
services: &NseHostServices,
name: &str,
operation: &'static str,
) -> Result<Option<String>, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::Environment,
Some(name.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "environment access denied"));
}
ctx.before_blocking_operation(&request)?;
let value = services
.environment()
.var(name)
.map_err(|e| format!("environment provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(value)
}
pub fn broker_temp_dir(
ctx: &NseCapabilityContext,
services: &NseHostServices,
operation: &'static str,
) -> Result<PathBuf, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::Environment,
Some("TMPDIR".to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "environment access denied"));
}
ctx.before_blocking_operation(&request)?;
let value = services
.environment()
.temp_dir()
.map_err(|e| format!("environment provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::limits::{NseCancellationToken, NseExecutionLimits, NseResourceCounters};
use crate::profile::{
NseExecutionProfileKind, NseModulePolicy, NseNetworkPolicy, NseScriptPolicy,
};
use crate::SandboxConfig;
use std::sync::Arc;
fn test_context(kind: NseExecutionProfileKind) -> NseCapabilityContext {
NseCapabilityContext::new(
kind,
NseNetworkPolicy::AllowAllManual,
NseScriptPolicy {
allow_builtin_scripts: true,
allow_script_files: false,
allowed_script_roots: Vec::new(),
allow_conventional_nmap_paths: false,
max_script_bytes: None,
},
NseModulePolicy {
allow_builtin_modules: true,
allow_filesystem_modules: false,
allowed_module_roots: Vec::new(),
max_module_bytes: None,
},
SandboxConfig::default(),
NseExecutionLimits::default(),
NseCancellationToken::new(),
Arc::new(NseResourceCounters::default()),
)
}
#[test]
fn native_services_preserve_behavior() {
let services = NseHostServices::native();
let before = chrono::Utc::now().timestamp();
let now = services.clock().unix_timestamp().expect("native clock");
let after = chrono::Utc::now().timestamp();
assert!(
(before..=after + 1).contains(&now),
"native clock sane: {now}"
);
let mut buf = [0u8; 32];
services
.random()
.fill_bytes(&mut buf)
.expect("native random");
let native_var = std::env::var("PATH").ok();
let provided = services.environment().var("PATH").expect("native env");
assert_eq!(provided, native_var);
}
#[test]
fn bundle_clones_share_providers() {
let services = NseHostServices::native();
let cloned = services.clone();
assert!(Arc::ptr_eq(services.clock(), cloned.clock()));
assert!(Arc::ptr_eq(services.random(), cloned.random()));
assert!(Arc::ptr_eq(services.environment(), cloned.environment()));
assert!(Arc::ptr_eq(services.dns(), cloned.dns()));
assert!(Arc::ptr_eq(services.tcp(), cloned.tcp()));
assert!(Arc::ptr_eq(services.udp(), cloned.udp()));
assert!(Arc::ptr_eq(services.fs(), cloned.fs()));
assert!(Arc::ptr_eq(services.process(), cloned.process()));
assert!(Arc::ptr_eq(services.http(), cloned.http()));
}
#[test]
fn deterministic_providers_are_stable() {
let clock = FixedClockProvider::new(1_700_000_000);
assert_eq!(clock.unix_timestamp().unwrap(), 1_700_000_000);
let random = DeterministicRandomProvider::new(vec![7u8]);
let mut a = [0u8; 4];
let mut b = [0u8; 4];
let other = DeterministicRandomProvider::new(vec![7u8]);
random.fill_bytes(&mut a).unwrap();
other.fill_bytes(&mut b).unwrap();
assert_eq!(a, b);
let mut vars = HashMap::new();
vars.insert("EGGSEC_TEST".to_string(), "yes".to_string());
let env = MapEnvironmentProvider::new(vars, PathBuf::from("/tmp/eggsec-test"));
assert_eq!(env.var("EGGSEC_TEST").unwrap(), Some("yes".to_string()));
assert_eq!(env.var("MISSING").unwrap(), None);
}
#[test]
fn ci_safe_random_denied_before_provider_call() {
let ctx = test_context(NseExecutionProfileKind::CiSafe);
let counting = Arc::new(CountingRandomProvider::new(vec![1u8]));
let services = NseHostServices::native().with_random(counting.clone());
let mut out = [0u8; 8];
let err = broker_random_fill(&ctx, &services, &mut out, "test.random").unwrap_err();
assert!(err.contains("CI safe") || err.contains("denied"), "{err}");
assert_eq!(
counting.calls(),
0,
"denied operation must not touch provider"
);
}
#[test]
fn ci_safe_environment_denied_before_provider_call() {
let ctx = test_context(NseExecutionProfileKind::CiSafe);
let counting = Arc::new(CountingEnvironmentProvider::new(
HashMap::new(),
PathBuf::from("/tmp"),
));
let services = NseHostServices::native().with_environment(counting.clone());
let err = broker_env_var(&ctx, &services, "HOME", "test.getenv").unwrap_err();
assert!(err.contains("CI safe") || err.contains("denied"), "{err}");
assert_eq!(
counting.calls(),
0,
"denied operation must not touch provider"
);
}
#[test]
fn agent_safe_environment_denied_before_provider_call() {
let ctx = test_context(NseExecutionProfileKind::AgentSafe);
let counting = Arc::new(CountingEnvironmentProvider::new(
HashMap::new(),
PathBuf::from("/tmp"),
));
let services = NseHostServices::native().with_environment(counting.clone());
let err = broker_env_var(&ctx, &services, "HOME", "test.getenv").unwrap_err();
assert!(
err.contains("agent safe") || err.contains("denied"),
"{err}"
);
assert_eq!(counting.calls(), 0);
}
#[test]
fn cancellation_prevents_provider_call() {
let token = NseCancellationToken::new();
token.cancel();
let ctx = NseCapabilityContext::new(
NseExecutionProfileKind::ManualPermissive,
NseNetworkPolicy::AllowAllManual,
NseScriptPolicy {
allow_builtin_scripts: true,
allow_script_files: false,
allowed_script_roots: Vec::new(),
allow_conventional_nmap_paths: false,
max_script_bytes: None,
},
NseModulePolicy {
allow_builtin_modules: true,
allow_filesystem_modules: false,
allowed_module_roots: Vec::new(),
max_module_bytes: None,
},
SandboxConfig::default(),
NseExecutionLimits::default(),
token,
Arc::new(NseResourceCounters::default()),
);
let counting = Arc::new(CountingClockProvider::new(42));
let services = NseHostServices::native().with_clock(counting.clone());
assert!(broker_unix_timestamp(&ctx, &services, "test.clock").is_err());
assert_eq!(counting.calls(), 0);
}
}
use std::collections::VecDeque;
use std::sync::OnceLock;
use hickory_resolver::proto::rr::{RData, RecordType};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NseTransportProtocol {
Tcp,
Udp,
}
impl NseTransportProtocol {
fn capability_kind(self) -> NseCapabilityKind {
match self {
Self::Tcp => NseCapabilityKind::NetworkTcp,
Self::Udp => NseCapabilityKind::NetworkUdp,
}
}
pub fn name(self) -> &'static str {
match self {
Self::Tcp => "tcp",
Self::Udp => "udp",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NseIpAddress {
V4([u8; 4]),
V6([u8; 16]),
}
impl NseIpAddress {
pub fn parse(literal: &str) -> Option<Self> {
match literal.parse::<std::net::IpAddr>().ok()? {
std::net::IpAddr::V4(v4) => Some(Self::V4(v4.octets())),
std::net::IpAddr::V6(v6) => Some(Self::V6(v6.octets())),
}
}
pub fn is_loopback(&self) -> bool {
match *self {
Self::V4(o) => o[0] == 127,
Self::V6(o) => o == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
}
}
pub fn is_v4(&self) -> bool {
matches!(self, Self::V4(_))
}
pub fn reverse_dns_name(&self) -> String {
match *self {
Self::V4(o) => format!("{}.{}.{}.{}.in-addr.arpa", o[3], o[2], o[1], o[0]),
Self::V6(o) => {
let mut nibbles = Vec::with_capacity(32);
for byte in o.iter().rev() {
nibbles.push(format!("{:x}", byte & 0x0f));
nibbles.push(format!("{:x}", byte >> 4));
}
format!("{}.ip6.arpa", nibbles.join("."))
}
}
}
pub(crate) fn to_std(&self) -> std::net::IpAddr {
match *self {
Self::V4(o) => std::net::IpAddr::V4(std::net::Ipv4Addr::from(o)),
Self::V6(o) => std::net::IpAddr::V6(std::net::Ipv6Addr::from(o)),
}
}
}
impl std::fmt::Display for NseIpAddress {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.to_std())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct NseResolvedEndpoint {
pub hostname: String,
pub address: NseIpAddress,
pub port: u16,
pub protocol: NseTransportProtocol,
}
impl NseResolvedEndpoint {
pub fn new(
hostname: impl Into<String>,
address: NseIpAddress,
port: u16,
protocol: NseTransportProtocol,
) -> Self {
Self {
hostname: hostname.into(),
address,
port,
protocol,
}
}
pub fn describe(&self) -> String {
format!("{}:{} ({})", self.address, self.port, self.protocol.name())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum NseDnsRecordType {
A,
Aaaa,
Mx,
Txt,
Ns,
Soa,
Ptr,
Cname,
Any,
}
impl NseDnsRecordType {
pub fn parse(label: &str) -> Self {
match label.to_uppercase().as_str() {
"AAAA" => Self::Aaaa,
"MX" => Self::Mx,
"TXT" => Self::Txt,
"NS" => Self::Ns,
"SOA" => Self::Soa,
"PTR" => Self::Ptr,
"CNAME" => Self::Cname,
"ANY" => Self::Any,
_ => Self::A,
}
}
pub fn name(&self) -> &'static str {
match self {
Self::A => "A",
Self::Aaaa => "AAAA",
Self::Mx => "MX",
Self::Txt => "TXT",
Self::Ns => "NS",
Self::Soa => "SOA",
Self::Ptr => "PTR",
Self::Cname => "CNAME",
Self::Any => "ANY",
}
}
pub fn is_address_query(&self) -> bool {
matches!(self, Self::A | Self::Aaaa)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NseDnsRecord {
Address(NseIpAddress),
Text(String),
}
impl NseDnsRecord {
pub fn display(&self) -> String {
match self {
Self::Address(addr) => addr.to_string(),
Self::Text(text) => text.clone(),
}
}
pub fn address(&self) -> Option<NseIpAddress> {
match *self {
Self::Address(addr) => Some(addr),
Self::Text(_) => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseDnsQuery {
pub name: String,
pub record_type: NseDnsRecordType,
}
impl NseDnsQuery {
pub fn new(name: impl Into<String>, record_type: NseDnsRecordType) -> Self {
Self {
name: name.into(),
record_type,
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct NseDnsAnswer {
pub records: Vec<NseDnsRecord>,
}
impl NseDnsAnswer {
pub fn new(records: Vec<NseDnsRecord>) -> Self {
Self { records }
}
pub fn addresses(&self) -> Vec<NseIpAddress> {
self.records
.iter()
.filter_map(NseDnsRecord::address)
.collect()
}
pub fn displays(&self) -> Vec<String> {
self.records.iter().map(NseDnsRecord::display).collect()
}
}
pub trait NseDnsProvider: Send + Sync {
fn lookup(&self, query: &NseDnsQuery) -> Result<NseDnsAnswer, NseProviderError>;
}
pub trait NseTcpConnection: Send + Sync {
fn endpoint(&self) -> &NseResolvedEndpoint;
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError>;
fn receive(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError>;
fn set_timeouts(&mut self, timeout: std::time::Duration) -> Result<(), NseProviderError>;
fn local_port(&self) -> Option<u16>;
fn is_alive(&self) -> bool;
fn close(&mut self);
}
pub trait NseTcpSocketProvider: Send + Sync {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseTcpConnection>, NseProviderError>;
}
pub trait NseUdpSocket: Send + Sync {
fn endpoint(&self) -> &NseResolvedEndpoint;
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError>;
fn receive(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError>;
fn set_timeouts(&mut self, timeout: std::time::Duration) -> Result<(), NseProviderError>;
fn local_port(&self) -> Option<u16>;
fn is_alive(&self) -> bool;
fn close(&mut self);
}
pub trait NseUdpSocketProvider: Send + Sync {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseUdpSocket>, NseProviderError>;
}
fn hickory_record_type(record_type: &NseDnsRecordType) -> RecordType {
match record_type {
NseDnsRecordType::A => RecordType::A,
NseDnsRecordType::Aaaa => RecordType::AAAA,
NseDnsRecordType::Mx => RecordType::MX,
NseDnsRecordType::Txt => RecordType::TXT,
NseDnsRecordType::Ns => RecordType::NS,
NseDnsRecordType::Soa => RecordType::SOA,
NseDnsRecordType::Ptr => RecordType::PTR,
NseDnsRecordType::Cname => RecordType::CNAME,
NseDnsRecordType::Any => RecordType::ANY,
}
}
pub struct NativeDnsProvider {
resolver: OnceLock<hickory_resolver::TokioResolver>,
}
impl Default for NativeDnsProvider {
fn default() -> Self {
Self {
resolver: OnceLock::new(),
}
}
}
impl NativeDnsProvider {
pub fn new() -> Self {
Self::default()
}
fn resolver(&self) -> Result<&hickory_resolver::TokioResolver, NseProviderError> {
if let Some(resolver) = self.resolver.get() {
return Ok(resolver);
}
let built = hickory_resolver::TokioResolver::builder_with_config(
hickory_resolver::config::ResolverConfig::default(),
hickory_resolver::net::runtime::TokioRuntimeProvider::default(),
)
.with_options({
let mut opts = hickory_resolver::config::ResolverOpts::default();
opts.timeout = std::time::Duration::from_secs(5);
opts.attempts = 2;
opts
})
.build()
.map_err(|e| {
tracing::warn!("failed to initialize native DNS resolver: {e}");
NseProviderError::new("dns", format!("DNS resolver unavailable: {e}"))
})?;
let _ = self.resolver.set(built);
self.resolver
.get()
.ok_or_else(|| NseProviderError::new("dns", "DNS resolver unavailable after init"))
}
}
impl NseDnsProvider for NativeDnsProvider {
fn lookup(&self, query: &NseDnsQuery) -> Result<NseDnsAnswer, NseProviderError> {
let resolver = self.resolver()?;
let record_type = hickory_record_type(&query.record_type);
let name = query.name.clone();
let lookup = crate::libraries::runtime_bridge::try_block_on_async(
resolver.lookup(name, record_type),
)
.map_err(|e| NseProviderError::new("dns", format!("DNS bridge failed: {e}")))?
.map_err(|e| NseProviderError::new("dns", format!("DNS lookup failed: {e}")))?;
let records = lookup
.answers()
.iter()
.map(|record| match &record.data {
RData::A(v4) => NseDnsRecord::Address(NseIpAddress::V4(v4.0.octets())),
RData::AAAA(v6) => NseDnsRecord::Address(NseIpAddress::V6(v6.0.octets())),
other => NseDnsRecord::Text(other.to_string()),
})
.collect();
Ok(NseDnsAnswer::new(records))
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeTcpSocketProvider;
impl NativeTcpSocketProvider {
pub fn connect_std(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<std::net::TcpStream, NseProviderError> {
let addr = std::net::SocketAddr::new(endpoint.address.to_std(), endpoint.port);
let stream = std::net::TcpStream::connect_timeout(&addr, timeout).map_err(|e| {
NseProviderError::new(
"tcp",
format!("TCP connect to {} failed: {e}", endpoint.describe()),
)
})?;
stream
.set_read_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set TCP read timeout: {e}"));
stream
.set_write_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set TCP write timeout: {e}"));
Ok(stream)
}
}
impl NseTcpSocketProvider for NativeTcpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseTcpConnection>, NseProviderError> {
Ok(Box::new(NativeTcpConnection {
stream: Some(self.connect_std(endpoint, timeout)?),
endpoint: endpoint.clone(),
}))
}
}
pub struct NativeTcpConnection {
stream: Option<std::net::TcpStream>,
endpoint: NseResolvedEndpoint,
}
impl NativeTcpConnection {
pub fn from_std(stream: std::net::TcpStream, endpoint: NseResolvedEndpoint) -> Self {
Self {
stream: Some(stream),
endpoint,
}
}
pub fn into_std(self) -> Option<std::net::TcpStream> {
self.stream
}
}
impl NseTcpConnection for NativeTcpConnection {
fn endpoint(&self) -> &NseResolvedEndpoint {
&self.endpoint
}
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError> {
use std::io::Write;
let stream = self
.stream
.as_mut()
.ok_or_else(|| NseProviderError::new("tcp", "TCP handle is closed"))?;
stream
.write(data)
.map_err(|e| NseProviderError::new("tcp", format!("TCP send failed: {e}")))
}
fn receive(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError> {
use std::io::Read;
let stream = self
.stream
.as_mut()
.ok_or_else(|| NseProviderError::new("tcp", "TCP handle is closed"))?;
let size = max_bytes.clamp(1, 65536);
let mut buffer = vec![0u8; size];
let n = stream
.read(&mut buffer)
.map_err(|e| NseProviderError::new("tcp", format!("TCP receive failed: {e}")))?;
buffer.truncate(n);
Ok(buffer)
}
fn set_timeouts(&mut self, timeout: std::time::Duration) -> Result<(), NseProviderError> {
if let Some(stream) = self.stream.as_mut() {
stream
.set_read_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set TCP read timeout: {e}"));
stream
.set_write_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set TCP write timeout: {e}"));
}
Ok(())
}
fn local_port(&self) -> Option<u16> {
self.stream
.as_ref()
.and_then(|s| s.local_addr().ok())
.map(|a| a.port())
}
fn is_alive(&self) -> bool {
match self.stream.as_ref() {
None => false,
Some(stream) => match stream.peek(&mut [0u8; 1]) {
Ok(0) => false,
Ok(_) => true,
Err(e) => {
use std::io::ErrorKind;
e.kind() != ErrorKind::ConnectionReset
&& e.kind() != ErrorKind::ConnectionAborted
&& e.kind() != ErrorKind::BrokenPipe
}
},
}
}
fn close(&mut self) {
self.stream = None;
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeUdpSocketProvider;
impl NativeUdpSocketProvider {
pub fn connect_std(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<std::net::UdpSocket, NseProviderError> {
let socket = std::net::UdpSocket::bind("0.0.0.0:0")
.map_err(|e| NseProviderError::new("udp", format!("failed to bind UDP socket: {e}")))?;
socket
.set_read_timeout(Some(timeout))
.map_err(|e| NseProviderError::new("udp", format!("failed to set UDP timeout: {e}")))?;
socket
.set_write_timeout(Some(timeout))
.map_err(|e| NseProviderError::new("udp", format!("failed to set UDP timeout: {e}")))?;
let addr = std::net::SocketAddr::new(endpoint.address.to_std(), endpoint.port);
socket.connect(addr).map_err(|e| {
NseProviderError::new(
"udp",
format!("UDP connect to {} failed: {e}", endpoint.describe()),
)
})?;
Ok(socket)
}
pub fn recv_once_native(
&self,
_endpoint: &NseResolvedEndpoint,
max_bytes: usize,
timeout: std::time::Duration,
) -> Result<(Vec<u8>, std::net::SocketAddr), NseProviderError> {
let socket = std::net::UdpSocket::bind("0.0.0.0:0")
.map_err(|e| NseProviderError::new("udp", format!("failed to bind UDP socket: {e}")))?;
socket
.set_read_timeout(Some(timeout))
.map_err(|e| NseProviderError::new("udp", format!("failed to set UDP timeout: {e}")))?;
let mut buffer = vec![0u8; max_bytes.clamp(1, 65536)];
socket
.recv_from(&mut buffer)
.map(|(n, from)| {
buffer.truncate(n);
(buffer, from)
})
.map_err(|e| NseProviderError::new("udp", format!("UDP receive failed: {e}")))
}
}
impl NseUdpSocketProvider for NativeUdpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseUdpSocket>, NseProviderError> {
Ok(Box::new(NativeUdpSocket {
socket: Some(self.connect_std(endpoint, timeout)?),
endpoint: endpoint.clone(),
}))
}
}
pub struct NativeUdpSocket {
socket: Option<std::net::UdpSocket>,
endpoint: NseResolvedEndpoint,
}
impl NativeUdpSocket {
pub fn from_std(socket: std::net::UdpSocket, endpoint: NseResolvedEndpoint) -> Self {
Self {
socket: Some(socket),
endpoint,
}
}
pub fn into_std(self) -> Option<std::net::UdpSocket> {
self.socket
}
}
impl NseUdpSocket for NativeUdpSocket {
fn endpoint(&self) -> &NseResolvedEndpoint {
&self.endpoint
}
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError> {
let socket = self
.socket
.as_mut()
.ok_or_else(|| NseProviderError::new("udp", "UDP handle is closed"))?;
socket
.send(data)
.map_err(|e| NseProviderError::new("udp", format!("UDP send failed: {e}")))
}
fn receive(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError> {
let socket = self
.socket
.as_mut()
.ok_or_else(|| NseProviderError::new("udp", "UDP handle is closed"))?;
let size = max_bytes.clamp(1, 65536);
let mut buffer = vec![0u8; size];
match socket.recv(&mut buffer) {
Ok(n) => {
buffer.truncate(n);
Ok(buffer)
}
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => Ok(Vec::new()),
Err(e) => Err(NseProviderError::new(
"udp",
format!("UDP receive failed: {e}"),
)),
}
}
fn set_timeouts(&mut self, timeout: std::time::Duration) -> Result<(), NseProviderError> {
if let Some(socket) = self.socket.as_mut() {
socket
.set_read_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set UDP read timeout: {e}"));
socket
.set_write_timeout(Some(timeout))
.unwrap_or_else(|e| tracing::warn!("failed to set UDP write timeout: {e}"));
}
Ok(())
}
fn local_port(&self) -> Option<u16> {
self.socket
.as_ref()
.and_then(|s| s.local_addr().ok())
.map(|a| a.port())
}
fn is_alive(&self) -> bool {
self.socket.is_some()
}
fn close(&mut self) {
self.socket = None;
}
}
pub struct MapDnsProvider {
answers: HashMap<(String, String), NseDnsAnswer>,
lookups: AtomicU64,
}
impl MapDnsProvider {
pub fn new(answers: HashMap<(String, String), NseDnsAnswer>) -> Self {
Self {
answers,
lookups: AtomicU64::new(0),
}
}
pub fn with_addresses(name: &str, addresses: Vec<NseIpAddress>) -> Self {
let mut answers = HashMap::new();
answers.insert(
(name.to_lowercase(), NseDnsRecordType::A.name().to_string()),
NseDnsAnswer::new(addresses.into_iter().map(NseDnsRecord::Address).collect()),
);
Self::new(answers)
}
pub fn lookups(&self) -> u64 {
self.lookups.load(Ordering::SeqCst)
}
}
impl NseDnsProvider for MapDnsProvider {
fn lookup(&self, query: &NseDnsQuery) -> Result<NseDnsAnswer, NseProviderError> {
self.lookups.fetch_add(1, Ordering::SeqCst);
Ok(self
.answers
.get(&(
query.name.to_lowercase(),
query.record_type.name().to_string(),
))
.cloned()
.unwrap_or_default())
}
}
pub struct ScriptedDnsProvider {
script: Mutex<VecDeque<NseDnsAnswer>>,
lookups: AtomicU64,
}
impl ScriptedDnsProvider {
pub fn new(script: Vec<NseDnsAnswer>) -> Self {
Self {
script: Mutex::new(script.into()),
lookups: AtomicU64::new(0),
}
}
pub fn lookups(&self) -> u64 {
self.lookups.load(Ordering::SeqCst)
}
}
impl NseDnsProvider for ScriptedDnsProvider {
fn lookup(&self, _query: &NseDnsQuery) -> Result<NseDnsAnswer, NseProviderError> {
self.lookups.fetch_add(1, Ordering::SeqCst);
let mut script = self
.script
.lock()
.map_err(|e| NseProviderError::new("dns", format!("scripted DNS lock failed: {e}")))?;
Ok(script.pop_front().unwrap_or_default())
}
}
pub struct MemoryTcpConnection {
endpoint: NseResolvedEndpoint,
sent: Mutex<Vec<u8>>,
recv_queue: Mutex<VecDeque<Vec<u8>>>,
closed: AtomicU64,
local: Option<u16>,
}
impl MemoryTcpConnection {
pub fn new(endpoint: NseResolvedEndpoint, replay: Vec<Vec<u8>>) -> Self {
Self {
endpoint,
sent: Mutex::new(Vec::new()),
recv_queue: Mutex::new(replay.into()),
closed: AtomicU64::new(0),
local: None,
}
}
pub fn sent_bytes(&self) -> Vec<u8> {
self.sent.lock().map(|g| g.clone()).unwrap_or_default()
}
}
impl NseTcpConnection for MemoryTcpConnection {
fn endpoint(&self) -> &NseResolvedEndpoint {
&self.endpoint
}
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError> {
if self.closed.load(Ordering::SeqCst) != 0 {
return Err(NseProviderError::new("tcp", "TCP handle is closed"));
}
let mut sent = self
.sent
.lock()
.map_err(|e| NseProviderError::new("tcp", format!("memory TCP lock failed: {e}")))?;
sent.extend_from_slice(data);
Ok(data.len())
}
fn receive(&mut self, _max_bytes: usize) -> Result<Vec<u8>, NseProviderError> {
if self.closed.load(Ordering::SeqCst) != 0 {
return Err(NseProviderError::new("tcp", "TCP handle is closed"));
}
let mut queue = self
.recv_queue
.lock()
.map_err(|e| NseProviderError::new("tcp", format!("memory TCP lock failed: {e}")))?;
Ok(queue.pop_front().unwrap_or_default())
}
fn set_timeouts(&mut self, _timeout: std::time::Duration) -> Result<(), NseProviderError> {
Ok(())
}
fn local_port(&self) -> Option<u16> {
self.local
}
fn is_alive(&self) -> bool {
self.closed.load(Ordering::SeqCst) == 0
}
fn close(&mut self) {
self.closed.store(1, Ordering::SeqCst);
}
}
pub struct MemoryTcpSocketProvider {
connects: Mutex<Vec<NseResolvedEndpoint>>,
replay: Mutex<VecDeque<Vec<u8>>>,
}
impl MemoryTcpSocketProvider {
pub fn new(replay: Vec<Vec<u8>>) -> Self {
Self {
connects: Mutex::new(Vec::new()),
replay: Mutex::new(replay.into()),
}
}
pub fn connects(&self) -> Vec<NseResolvedEndpoint> {
self.connects.lock().map(|g| g.clone()).unwrap_or_default()
}
}
impl NseTcpSocketProvider for MemoryTcpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
_timeout: std::time::Duration,
) -> Result<Box<dyn NseTcpConnection>, NseProviderError> {
self.connects
.lock()
.map_err(|e| NseProviderError::new("tcp", format!("memory TCP lock failed: {e}")))?
.push(endpoint.clone());
let replay = self
.replay
.lock()
.map(|g| g.clone().into())
.unwrap_or_default();
Ok(Box::new(MemoryTcpConnection::new(endpoint.clone(), replay)))
}
}
pub struct MemoryUdpSocket {
endpoint: NseResolvedEndpoint,
sent: Mutex<Vec<u8>>,
recv_queue: Mutex<VecDeque<Vec<u8>>>,
closed: AtomicU64,
}
impl MemoryUdpSocket {
pub fn new(endpoint: NseResolvedEndpoint, replay: Vec<Vec<u8>>) -> Self {
Self {
endpoint,
sent: Mutex::new(Vec::new()),
recv_queue: Mutex::new(replay.into()),
closed: AtomicU64::new(0),
}
}
pub fn sent_bytes(&self) -> Vec<u8> {
self.sent.lock().map(|g| g.clone()).unwrap_or_default()
}
}
impl NseUdpSocket for MemoryUdpSocket {
fn endpoint(&self) -> &NseResolvedEndpoint {
&self.endpoint
}
fn send(&mut self, data: &[u8]) -> Result<usize, NseProviderError> {
if self.closed.load(Ordering::SeqCst) != 0 {
return Err(NseProviderError::new("udp", "UDP handle is closed"));
}
let mut sent = self
.sent
.lock()
.map_err(|e| NseProviderError::new("udp", format!("memory UDP lock failed: {e}")))?;
sent.extend_from_slice(data);
Ok(data.len())
}
fn receive(&mut self, _max_bytes: usize) -> Result<Vec<u8>, NseProviderError> {
if self.closed.load(Ordering::SeqCst) != 0 {
return Err(NseProviderError::new("udp", "UDP handle is closed"));
}
let mut queue = self
.recv_queue
.lock()
.map_err(|e| NseProviderError::new("udp", format!("memory UDP lock failed: {e}")))?;
Ok(queue.pop_front().unwrap_or_default())
}
fn set_timeouts(&mut self, _timeout: std::time::Duration) -> Result<(), NseProviderError> {
Ok(())
}
fn local_port(&self) -> Option<u16> {
None
}
fn is_alive(&self) -> bool {
self.closed.load(Ordering::SeqCst) == 0
}
fn close(&mut self) {
self.closed.store(1, Ordering::SeqCst);
}
}
pub struct MemoryUdpSocketProvider {
connects: Mutex<Vec<NseResolvedEndpoint>>,
replay: Mutex<VecDeque<Vec<u8>>>,
}
impl MemoryUdpSocketProvider {
pub fn new(replay: Vec<Vec<u8>>) -> Self {
Self {
connects: Mutex::new(Vec::new()),
replay: Mutex::new(replay.into()),
}
}
pub fn connects(&self) -> Vec<NseResolvedEndpoint> {
self.connects.lock().map(|g| g.clone()).unwrap_or_default()
}
}
impl NseUdpSocketProvider for MemoryUdpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
_timeout: std::time::Duration,
) -> Result<Box<dyn NseUdpSocket>, NseProviderError> {
self.connects
.lock()
.map_err(|e| NseProviderError::new("udp", format!("memory UDP lock failed: {e}")))?
.push(endpoint.clone());
let replay = self
.replay
.lock()
.map(|g| g.clone().into())
.unwrap_or_default();
Ok(Box::new(MemoryUdpSocket::new(endpoint.clone(), replay)))
}
}
pub struct CountingDnsProvider {
inner: MapDnsProvider,
calls: AtomicU64,
}
impl CountingDnsProvider {
pub fn new(answers: HashMap<(String, String), NseDnsAnswer>) -> Self {
Self {
inner: MapDnsProvider::new(answers),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl NseDnsProvider for CountingDnsProvider {
fn lookup(&self, query: &NseDnsQuery) -> Result<NseDnsAnswer, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.lookup(query)
}
}
pub struct CountingTcpSocketProvider {
inner: MemoryTcpSocketProvider,
calls: AtomicU64,
}
impl CountingTcpSocketProvider {
pub fn new(replay: Vec<Vec<u8>>) -> Self {
Self {
inner: MemoryTcpSocketProvider::new(replay),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
pub fn connects(&self) -> Vec<NseResolvedEndpoint> {
self.inner.connects()
}
}
impl NseTcpSocketProvider for CountingTcpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseTcpConnection>, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.connect(endpoint, timeout)
}
}
pub struct CountingUdpSocketProvider {
inner: MemoryUdpSocketProvider,
calls: AtomicU64,
}
impl CountingUdpSocketProvider {
pub fn new(replay: Vec<Vec<u8>>) -> Self {
Self {
inner: MemoryUdpSocketProvider::new(replay),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
pub fn connects(&self) -> Vec<NseResolvedEndpoint> {
self.inner.connects()
}
}
impl NseUdpSocketProvider for CountingUdpSocketProvider {
fn connect(
&self,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
) -> Result<Box<dyn NseUdpSocket>, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.connect(endpoint, timeout)
}
}
pub fn broker_dns_lookup(
ctx: &NseCapabilityContext,
services: &NseHostServices,
name: &str,
record_type: NseDnsRecordType,
operation: &'static str,
) -> Result<NseDnsAnswer, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::DnsResolution,
Some(name.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "DNS resolution denied"));
}
ctx.before_blocking_operation(&request)?;
let answer = services
.dns()
.lookup(&NseDnsQuery::new(name, record_type))
.map_err(|e| format!("DNS provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(answer)
}
pub fn broker_resolve_and_select(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
protocol: NseTransportProtocol,
operation: &'static str,
) -> Result<NseResolvedEndpoint, String> {
ctx.check_cancelled(operation)?;
let kind = protocol.capability_kind();
let mut candidates: Vec<NseIpAddress> = Vec::new();
if let Some(literal) = NseIpAddress::parse(host) {
candidates.push(literal);
} else {
let dns_request = broker_request(
NseCapabilityKind::DnsResolution,
Some(host.to_string()),
None,
operation,
);
let dns_decision = ctx.check_capability(&dns_request);
if !dns_decision.is_allowed() {
return Err(deny_message(&dns_decision, "DNS resolution denied"));
}
ctx.before_blocking_operation(&dns_request)?;
let mut answer = services
.dns()
.lookup(&NseDnsQuery::new(host, NseDnsRecordType::A))
.map_err(|e| format!("DNS provider failed: {e}"))?;
let aaaa = services
.dns()
.lookup(&NseDnsQuery::new(host, NseDnsRecordType::Aaaa))
.map_err(|e| format!("DNS provider failed: {e}"))?;
answer.records.extend(aaaa.records);
ctx.after_blocking_operation(&dns_request, None);
candidates = answer.addresses();
if candidates.is_empty() {
return Err(format!("DNS resolution for '{host}' returned no addresses"));
}
}
for address in candidates {
let endpoint = NseResolvedEndpoint::new(host, address, port, protocol);
let decision = ctx.check_capability(&broker_request(
kind,
Some(address.to_string()),
None,
operation,
));
if decision.is_allowed() {
return Ok(endpoint);
}
}
Err(format!(
"network {} access denied: no approved concrete endpoint for '{host}:{port}'",
protocol.name()
))
}
pub fn broker_tcp_connect_endpoint(
ctx: &NseCapabilityContext,
services: &NseHostServices,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
operation: &'static str,
) -> Result<Box<dyn NseTcpConnection>, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkTcp,
Some(endpoint.address.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network TCP connect denied"));
}
ctx.before_blocking_operation(&request)?;
let handle = services
.tcp()
.connect(endpoint, timeout)
.map_err(|e| format!("TCP connect to {} failed: {e}", endpoint.describe()))?;
ctx.after_blocking_operation(&request, None);
Ok(handle)
}
pub fn broker_tcp_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
timeout: std::time::Duration,
operation: &'static str,
) -> Result<(Box<dyn NseTcpConnection>, NseResolvedEndpoint), String> {
let endpoint = broker_resolve_and_select(
ctx,
services,
host,
port,
NseTransportProtocol::Tcp,
operation,
)?;
let handle = broker_tcp_connect_endpoint(ctx, services, &endpoint, timeout, operation)?;
Ok((handle, endpoint))
}
pub fn broker_tcp_send(
ctx: &NseCapabilityContext,
handle: &mut dyn NseTcpConnection,
data: &[u8],
operation: &'static str,
) -> Result<usize, String> {
let target = handle.endpoint().address.to_string();
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkTcp,
Some(target),
Some(data.len() as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network TCP send denied"));
}
ctx.before_blocking_send(&request)?;
let n = handle
.send(data)
.map_err(|e| format!("TCP send failed: {e}"))?;
ctx.after_blocking_send(&request, Some(n as u64));
Ok(n)
}
pub fn broker_tcp_receive(
ctx: &NseCapabilityContext,
handle: &mut dyn NseTcpConnection,
max_bytes: usize,
operation: &'static str,
) -> Result<Vec<u8>, String> {
let target = handle.endpoint().address.to_string();
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkTcp,
Some(target),
Some(max_bytes as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network TCP receive denied"));
}
ctx.before_blocking_operation(&request)?;
let data = handle
.receive(max_bytes)
.map_err(|e| format!("TCP receive failed: {e}"))?;
let n = data.len();
ctx.after_blocking_operation(&request, Some(n as u64));
Ok(data)
}
pub fn broker_udp_connect_endpoint(
ctx: &NseCapabilityContext,
services: &NseHostServices,
endpoint: &NseResolvedEndpoint,
timeout: std::time::Duration,
operation: &'static str,
) -> Result<Box<dyn NseUdpSocket>, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkUdp,
Some(endpoint.address.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network UDP connect denied"));
}
ctx.before_blocking_operation(&request)?;
let handle = services
.udp()
.connect(endpoint, timeout)
.map_err(|e| format!("UDP connect to {} failed: {e}", endpoint.describe()))?;
ctx.after_blocking_operation(&request, None);
Ok(handle)
}
pub fn broker_udp_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
timeout: std::time::Duration,
operation: &'static str,
) -> Result<(Box<dyn NseUdpSocket>, NseResolvedEndpoint), String> {
let endpoint = broker_resolve_and_select(
ctx,
services,
host,
port,
NseTransportProtocol::Udp,
operation,
)?;
let handle = broker_udp_connect_endpoint(ctx, services, &endpoint, timeout, operation)?;
Ok((handle, endpoint))
}
pub fn broker_udp_send(
ctx: &NseCapabilityContext,
handle: &mut dyn NseUdpSocket,
data: &[u8],
operation: &'static str,
) -> Result<usize, String> {
let target = handle.endpoint().address.to_string();
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkUdp,
Some(target),
Some(data.len() as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network UDP send denied"));
}
ctx.before_blocking_send(&request)?;
let n = handle
.send(data)
.map_err(|e| format!("UDP send failed: {e}"))?;
ctx.after_blocking_send(&request, Some(n as u64));
Ok(n)
}
pub fn broker_udp_receive(
ctx: &NseCapabilityContext,
handle: &mut dyn NseUdpSocket,
max_bytes: usize,
operation: &'static str,
) -> Result<Vec<u8>, String> {
let target = handle.endpoint().address.to_string();
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::NetworkUdp,
Some(target),
Some(max_bytes as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "network UDP receive denied"));
}
ctx.before_blocking_operation(&request)?;
let data = handle
.receive(max_bytes)
.map_err(|e| format!("UDP receive failed: {e}"))?;
let n = data.len();
ctx.after_blocking_operation(&request, Some(n as u64));
Ok(data)
}
pub(crate) fn endpoint_in_networks(
endpoint: &NseResolvedEndpoint,
nets: &[ipnetwork::IpNetwork],
) -> bool {
if nets.is_empty() {
return true;
}
let ip = endpoint.address.to_std();
nets.iter().any(|net| net.contains(ip))
}
use std::path::{Path, PathBuf as FsPathBuf};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseFileMetadata {
pub len: u64,
pub is_dir: bool,
pub is_file: bool,
pub is_symlink: bool,
pub readonly: bool,
pub modified_secs: Option<u64>,
pub accessed_secs: Option<u64>,
pub created_secs: Option<u64>,
pub unix_mode: Option<u32>,
}
impl NseFileMetadata {
pub fn from_std(meta: &std::fs::Metadata) -> Self {
fn secs(t: std::io::Result<std::time::SystemTime>) -> Option<u64> {
t.ok()?
.duration_since(std::time::UNIX_EPOCH)
.ok()
.map(|d| d.as_secs())
}
Self {
len: meta.len(),
is_dir: meta.is_dir(),
is_file: meta.is_file(),
is_symlink: meta.is_symlink(),
readonly: meta.permissions().readonly(),
modified_secs: secs(meta.modified()),
accessed_secs: secs(meta.accessed()),
created_secs: secs(meta.created()),
unix_mode: unix_mode_of(meta),
}
}
}
#[cfg(unix)]
fn unix_mode_of(meta: &std::fs::Metadata) -> Option<u32> {
use std::os::unix::fs::PermissionsExt;
Some(meta.permissions().mode())
}
#[cfg(not(unix))]
fn unix_mode_of(_meta: &std::fs::Metadata) -> Option<u32> {
None
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NseFileType {
File,
Dir,
Symlink,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseDirEntry {
pub name: String,
pub file_type: NseFileType,
}
impl NseDirEntry {
pub fn new(name: impl Into<String>, file_type: NseFileType) -> Self {
Self {
name: name.into(),
file_type,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NseOpenMode {
Read,
Write,
Append,
ReadWrite,
WriteRead,
AppendRead,
}
impl NseOpenMode {
pub fn parse(mode: &str) -> Self {
match mode {
"w" => Self::Write,
"a" => Self::Append,
"r+" => Self::ReadWrite,
"w+" => Self::WriteRead,
"a+" => Self::AppendRead,
_ => Self::Read,
}
}
pub fn is_write(&self) -> bool {
!matches!(self, Self::Read)
}
}
pub trait NseFileHandle: Send + Sync {
fn read(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError>;
fn write(&mut self, data: &[u8]) -> Result<usize, NseProviderError>;
fn flush(&mut self) -> Result<(), NseProviderError>;
fn seek_from_start(&mut self, pos: u64) -> Result<u64, NseProviderError>;
fn close(&mut self);
fn is_open(&self) -> bool;
}
pub trait NseFilesystemProvider: Send + Sync {
fn read_to_string(&self, path: &Path) -> Result<String, NseProviderError>;
fn read(&self, path: &Path) -> Result<Vec<u8>, NseProviderError>;
fn write(&self, path: &Path, bytes: &[u8]) -> Result<(), NseProviderError>;
fn metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError>;
fn symlink_metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError>;
fn read_dir(&self, path: &Path) -> Result<Vec<NseDirEntry>, NseProviderError>;
fn remove_file(&self, path: &Path) -> Result<(), NseProviderError>;
fn rename(&self, from: &Path, to: &Path) -> Result<(), NseProviderError>;
fn create_dir_all(&self, path: &Path) -> Result<(), NseProviderError>;
fn remove_dir(&self, path: &Path) -> Result<(), NseProviderError>;
fn hard_link(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError>;
fn symlink(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError>;
fn read_link(&self, path: &Path) -> Result<FsPathBuf, NseProviderError>;
fn set_unix_mode(&self, path: &Path, mode: u32) -> Result<(), NseProviderError>;
fn set_readonly(&self, path: &Path, readonly: bool) -> Result<(), NseProviderError>;
fn exists(&self, path: &Path) -> bool;
fn open(
&self,
path: &Path,
mode: NseOpenMode,
) -> Result<Box<dyn NseFileHandle>, NseProviderError>;
fn current_dir(&self) -> Result<FsPathBuf, NseProviderError>;
fn set_current_dir(&self, path: &Path) -> Result<(), NseProviderError>;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseProcessSpec {
pub program: String,
pub args: Vec<String>,
pub timeout: std::time::Duration,
}
impl NseProcessSpec {
pub fn new(
program: impl Into<String>,
args: Vec<String>,
timeout: std::time::Duration,
) -> Self {
Self {
program: program.into(),
args,
timeout,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseProcessResult {
pub code: Option<i32>,
pub success: bool,
pub stdout: Vec<u8>,
pub stderr: Vec<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseNetworkInterface {
pub name: String,
pub addresses: Vec<NseIpAddress>,
}
impl NseNetworkInterface {
pub fn new(name: impl Into<String>, addresses: Vec<NseIpAddress>) -> Self {
Self {
name: name.into(),
addresses,
}
}
}
pub trait NseProcessProvider: Send + Sync {
fn run(&self, spec: &NseProcessSpec) -> Result<NseProcessResult, NseProviderError>;
fn spawn(&self, spec: &NseProcessSpec) -> Result<Box<dyn NseChildProcess>, NseProviderError>;
fn is_privileged(&self) -> Result<bool, NseProviderError>;
fn network_interfaces(&self) -> Result<Vec<NseNetworkInterface>, NseProviderError>;
}
pub trait NseChildProcess: Send {
fn id(&self) -> Option<u32>;
fn is_running(&mut self) -> bool;
fn kill(&mut self);
}
pub struct NativeFileHandle {
file: Option<std::fs::File>,
}
impl NativeFileHandle {
pub fn from_std(file: std::fs::File) -> Self {
Self { file: Some(file) }
}
}
impl NseFileHandle for NativeFileHandle {
fn read(&mut self, max_bytes: usize) -> Result<Vec<u8>, NseProviderError> {
use std::io::Read;
let file = self
.file
.as_mut()
.ok_or_else(|| NseProviderError::new("fs", "file handle is closed"))?;
let size = max_bytes.clamp(1, 16 * 1024 * 1024);
let mut buffer = vec![0u8; size];
let n = file
.read(&mut buffer)
.map_err(|e| NseProviderError::new("fs", format!("file read failed: {e}")))?;
buffer.truncate(n);
Ok(buffer)
}
fn write(&mut self, data: &[u8]) -> Result<usize, NseProviderError> {
use std::io::Write;
let file = self
.file
.as_mut()
.ok_or_else(|| NseProviderError::new("fs", "file handle is closed"))?;
file.write_all(data)
.map_err(|e| NseProviderError::new("fs", format!("file write failed: {e}")))?;
Ok(data.len())
}
fn flush(&mut self) -> Result<(), NseProviderError> {
use std::io::Write;
let file = self
.file
.as_mut()
.ok_or_else(|| NseProviderError::new("fs", "file handle is closed"))?;
file.flush()
.map_err(|e| NseProviderError::new("fs", format!("file flush failed: {e}")))?;
Ok(())
}
fn seek_from_start(&mut self, pos: u64) -> Result<u64, NseProviderError> {
use std::io::Seek;
let file = self
.file
.as_mut()
.ok_or_else(|| NseProviderError::new("fs", "file handle is closed"))?;
file.seek(std::io::SeekFrom::Start(pos))
.map_err(|e| NseProviderError::new("fs", format!("file seek failed: {e}")))
}
fn close(&mut self) {
if let Some(file) = self.file.take() {
if let Err(e) = file.sync_all() {
tracing::warn!("failed to sync file on close: {e}");
}
}
}
fn is_open(&self) -> bool {
self.file.is_some()
}
}
impl Drop for NativeFileHandle {
fn drop(&mut self) {
self.close();
}
}
pub struct NativeFilesystemProvider {
cwd_override: Mutex<Option<FsPathBuf>>,
}
impl NativeFilesystemProvider {
pub fn new() -> Self {
Self {
cwd_override: Mutex::new(None),
}
}
}
impl Default for NativeFilesystemProvider {
fn default() -> Self {
Self::new()
}
}
impl NseFilesystemProvider for NativeFilesystemProvider {
fn read_to_string(&self, path: &Path) -> Result<String, NseProviderError> {
std::fs::read_to_string(path)
.map_err(|e| NseProviderError::new("fs", format!("read failed: {e}")))
}
fn read(&self, path: &Path) -> Result<Vec<u8>, NseProviderError> {
std::fs::read(path).map_err(|e| NseProviderError::new("fs", format!("read failed: {e}")))
}
fn write(&self, path: &Path, bytes: &[u8]) -> Result<(), NseProviderError> {
std::fs::write(path, bytes)
.map_err(|e| NseProviderError::new("fs", format!("write failed: {e}")))
}
fn metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError> {
std::fs::metadata(path)
.map(|m| NseFileMetadata::from_std(&m))
.map_err(|e| NseProviderError::new("fs", format!("stat failed: {e}")))
}
fn symlink_metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError> {
std::fs::symlink_metadata(path)
.map(|m| NseFileMetadata::from_std(&m))
.map_err(|e| NseProviderError::new("fs", format!("lstat failed: {e}")))
}
fn read_dir(&self, path: &Path) -> Result<Vec<NseDirEntry>, NseProviderError> {
let dir = std::fs::read_dir(path)
.map_err(|e| NseProviderError::new("fs", format!("read_dir failed: {e}")))?;
let mut entries = Vec::new();
for entry in dir {
let entry =
entry.map_err(|e| NseProviderError::new("fs", format!("dir entry failed: {e}")))?;
let file_type = entry
.file_type()
.map(|t| {
if t.is_dir() {
NseFileType::Dir
} else if t.is_file() {
NseFileType::File
} else if t.is_symlink() {
NseFileType::Symlink
} else {
NseFileType::Unknown
}
})
.unwrap_or(NseFileType::Unknown);
entries.push(NseDirEntry::new(
entry.file_name().to_string_lossy(),
file_type,
));
}
Ok(entries)
}
fn remove_file(&self, path: &Path) -> Result<(), NseProviderError> {
std::fs::remove_file(path)
.map_err(|e| NseProviderError::new("fs", format!("remove failed: {e}")))
}
fn rename(&self, from: &Path, to: &Path) -> Result<(), NseProviderError> {
std::fs::rename(from, to)
.map_err(|e| NseProviderError::new("fs", format!("rename failed: {e}")))
}
fn create_dir_all(&self, path: &Path) -> Result<(), NseProviderError> {
std::fs::create_dir_all(path)
.map_err(|e| NseProviderError::new("fs", format!("mkdir failed: {e}")))
}
fn remove_dir(&self, path: &Path) -> Result<(), NseProviderError> {
std::fs::remove_dir(path)
.map_err(|e| NseProviderError::new("fs", format!("rmdir failed: {e}")))
}
fn hard_link(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError> {
std::fs::hard_link(src, dst)
.map_err(|e| NseProviderError::new("fs", format!("hard link failed: {e}")))
}
fn symlink(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError> {
symlink_native(src, dst)
}
fn read_link(&self, path: &Path) -> Result<FsPathBuf, NseProviderError> {
std::fs::read_link(path)
.map_err(|e| NseProviderError::new("fs", format!("read_link failed: {e}")))
}
fn set_unix_mode(&self, path: &Path, mode: u32) -> Result<(), NseProviderError> {
set_unix_mode_native(path, mode)
}
fn set_readonly(&self, path: &Path, readonly: bool) -> Result<(), NseProviderError> {
let meta = std::fs::symlink_metadata(path)
.map_err(|e| NseProviderError::new("fs", format!("stat failed: {e}")))?;
let mut perms = meta.permissions();
perms.set_readonly(readonly);
std::fs::set_permissions(path, perms)
.map_err(|e| NseProviderError::new("fs", format!("set permissions failed: {e}")))
}
fn exists(&self, path: &Path) -> bool {
path.exists()
}
fn open(
&self,
path: &Path,
mode: NseOpenMode,
) -> Result<Box<dyn NseFileHandle>, NseProviderError> {
use std::fs::OpenOptions;
let file = match mode {
NseOpenMode::Read => OpenOptions::new().read(true).open(path),
NseOpenMode::Write => OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.open(path),
NseOpenMode::Append => OpenOptions::new().append(true).create(true).open(path),
NseOpenMode::ReadWrite => OpenOptions::new().read(true).write(true).open(path),
NseOpenMode::WriteRead => OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(true)
.open(path),
NseOpenMode::AppendRead => OpenOptions::new()
.read(true)
.append(true)
.create(true)
.open(path),
}
.map_err(|e| NseProviderError::new("fs", format!("open failed: {e}")))?;
Ok(Box::new(NativeFileHandle::from_std(file)))
}
fn current_dir(&self) -> Result<FsPathBuf, NseProviderError> {
if let Some(dir) = self
.cwd_override
.lock()
.map_err(|e| NseProviderError::new("fs", format!("CWD lock failed: {e}")))?
.clone()
{
return Ok(dir);
}
std::env::current_dir()
.map_err(|e| NseProviderError::new("fs", format!("current_dir failed: {e}")))
}
fn set_current_dir(&self, path: &Path) -> Result<(), NseProviderError> {
if !path.is_dir() {
return Err(NseProviderError::new(
"fs",
"chdir target is not a directory",
));
}
*self
.cwd_override
.lock()
.map_err(|e| NseProviderError::new("fs", format!("CWD lock failed: {e}")))? =
Some(path.to_path_buf());
Ok(())
}
}
#[cfg(unix)]
fn symlink_native(src: &Path, dst: &Path) -> Result<(), NseProviderError> {
std::os::unix::fs::symlink(src, dst)
.map_err(|e| NseProviderError::new("fs", format!("symlink failed: {e}")))
}
#[cfg(windows)]
fn symlink_native(src: &Path, dst: &Path) -> Result<(), NseProviderError> {
if src.is_dir() {
return Err(NseProviderError::new(
"fs",
"directory symlinks are unsupported on Windows",
));
}
std::os::windows::fs::symlink_file(src, dst)
.map_err(|e| NseProviderError::new("fs", format!("symlink failed: {e}")))
}
#[cfg(not(unix))]
#[cfg(not(windows))]
fn symlink_native(_src: &Path, _dst: &Path) -> Result<(), NseProviderError> {
Err(NseProviderError::new(
"fs",
"symlinks are unsupported on this platform",
))
}
#[cfg(unix)]
fn set_unix_mode_native(path: &Path, mode: u32) -> Result<(), NseProviderError> {
use std::os::unix::fs::PermissionsExt;
let permissions = std::fs::Permissions::from_mode(mode);
std::fs::set_permissions(path, permissions)
.map_err(|e| NseProviderError::new("fs", format!("set mode failed: {e}")))
}
#[cfg(not(unix))]
fn set_unix_mode_native(_path: &Path, _mode: u32) -> Result<(), NseProviderError> {
Err(NseProviderError::new(
"fs",
"Unix permission bits are unsupported on this platform (use set_readonly)",
))
}
pub fn shell_command(cmd: &str) -> NseProcessSpec {
#[cfg(unix)]
{
NseProcessSpec::new(
"sh",
vec!["-c".to_string(), cmd.to_string()],
PROCESS_TIMEOUT,
)
}
#[cfg(windows)]
{
NseProcessSpec::new(
"cmd",
vec!["/C".to_string(), cmd.to_string()],
PROCESS_TIMEOUT,
)
}
#[cfg(not(unix))]
#[cfg(not(windows))]
{
let _ = cmd;
NseProcessSpec::new("", Vec::new(), PROCESS_TIMEOUT)
}
}
const PROCESS_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(60);
pub struct NativeChildProcess {
child: Option<std::process::Child>,
}
impl NativeChildProcess {
pub fn from_std(child: std::process::Child) -> Self {
Self { child: Some(child) }
}
}
impl NseChildProcess for NativeChildProcess {
fn id(&self) -> Option<u32> {
self.child.as_ref().map(|c| c.id())
}
fn is_running(&mut self) -> bool {
match self.child.as_mut() {
None => false,
Some(child) => match child.try_wait() {
Ok(None) => true,
_ => false,
},
}
}
fn kill(&mut self) {
if let Some(mut child) = self.child.take() {
let _ = child.kill();
let _ = child.wait();
}
}
}
impl Drop for NativeChildProcess {
fn drop(&mut self) {
self.kill();
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NativeProcessProvider;
impl NativeProcessProvider {
fn spawn_native(spec: &NseProcessSpec) -> Result<std::process::Child, NseProviderError> {
if spec.program.is_empty() {
return Err(NseProviderError::new(
"process",
"process execution is unsupported on this platform",
));
}
std::process::Command::new(&spec.program)
.args(&spec.args)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()
.map_err(|e| NseProviderError::new("process", format!("spawn failed: {e}")))
}
}
impl NseProcessProvider for NativeProcessProvider {
fn run(&self, spec: &NseProcessSpec) -> Result<NseProcessResult, NseProviderError> {
use std::io::Read;
let mut child = Self::spawn_native(spec)?;
let deadline = std::time::Instant::now() + spec.timeout;
loop {
match child
.try_wait()
.map_err(|e| NseProviderError::new("process", format!("wait failed: {e}")))?
{
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut out) = child.stdout.take() {
let _ = out.read_to_end(&mut stdout);
}
if let Some(mut err) = child.stderr.take() {
let _ = err.read_to_end(&mut stderr);
}
return Ok(NseProcessResult {
code: status.code(),
success: status.success(),
stdout,
stderr,
});
}
None => {
if std::time::Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
return Err(NseProviderError::new(
"process",
"process execution timed out",
));
}
std::thread::sleep(std::time::Duration::from_millis(25));
}
}
}
}
fn spawn(&self, spec: &NseProcessSpec) -> Result<Box<dyn NseChildProcess>, NseProviderError> {
Ok(Box::new(NativeChildProcess::from_std(Self::spawn_native(
spec,
)?)))
}
fn is_privileged(&self) -> Result<bool, NseProviderError> {
is_privileged_native()
}
fn network_interfaces(&self) -> Result<Vec<NseNetworkInterface>, NseProviderError> {
network_interfaces_native()
}
}
#[cfg(unix)]
fn is_privileged_native() -> Result<bool, NseProviderError> {
match std::process::Command::new("id").arg("-u").output() {
Ok(output) => Ok(output.stdout == b"0\n"),
Err(e) => Err(NseProviderError::new(
"process",
format!("privilege probe failed: {e}"),
)),
}
}
#[cfg(not(unix))]
fn is_privileged_native() -> Result<bool, NseProviderError> {
Ok(false)
}
#[cfg(unix)]
fn network_interfaces_native() -> Result<Vec<NseNetworkInterface>, NseProviderError> {
match std::process::Command::new("ip").arg("addr").output() {
Ok(output) => Ok(parse_ip_addr_output(&String::from_utf8_lossy(
&output.stdout,
))),
Err(e) => Err(NseProviderError::new(
"process",
format!("interface enumeration failed: {e}"),
)),
}
}
#[cfg(windows)]
fn network_interfaces_native() -> Result<Vec<NseNetworkInterface>, NseProviderError> {
match std::process::Command::new("ipconfig").output() {
Ok(output) => Ok(parse_ipconfig_output(&String::from_utf8_lossy(
&output.stdout,
))),
Err(e) => Err(NseProviderError::new(
"process",
format!("interface enumeration failed: {e}"),
)),
}
}
#[cfg(not(unix))]
#[cfg(not(windows))]
fn network_interfaces_native() -> Result<Vec<NseNetworkInterface>, NseProviderError> {
Ok(vec![NseNetworkInterface::new(
"lo",
vec![NseIpAddress::V4([127, 0, 0, 1])],
)])
}
pub struct CountingFilesystemProvider {
calls: AtomicU64,
}
impl CountingFilesystemProvider {
pub fn new() -> Self {
Self {
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl Default for CountingFilesystemProvider {
fn default() -> Self {
Self::new()
}
}
macro_rules! counted_fs {
($self:ident, $native:expr) => {{
$self.calls.fetch_add(1, Ordering::SeqCst);
$native
}};
}
impl NseFilesystemProvider for CountingFilesystemProvider {
fn read_to_string(&self, path: &Path) -> Result<String, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().read_to_string(path))
}
fn read(&self, path: &Path) -> Result<Vec<u8>, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().read(path))
}
fn write(&self, path: &Path, bytes: &[u8]) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().write(path, bytes))
}
fn metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().metadata(path))
}
fn symlink_metadata(&self, path: &Path) -> Result<NseFileMetadata, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().symlink_metadata(path))
}
fn read_dir(&self, path: &Path) -> Result<Vec<NseDirEntry>, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().read_dir(path))
}
fn remove_file(&self, path: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().remove_file(path))
}
fn rename(&self, from: &Path, to: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().rename(from, to))
}
fn create_dir_all(&self, path: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().create_dir_all(path))
}
fn remove_dir(&self, path: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().remove_dir(path))
}
fn hard_link(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().hard_link(src, dst))
}
fn symlink(&self, src: &Path, dst: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().symlink(src, dst))
}
fn read_link(&self, path: &Path) -> Result<FsPathBuf, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().read_link(path))
}
fn set_unix_mode(&self, path: &Path, mode: u32) -> Result<(), NseProviderError> {
counted_fs!(
self,
NativeFilesystemProvider::new().set_unix_mode(path, mode)
)
}
fn set_readonly(&self, path: &Path, readonly: bool) -> Result<(), NseProviderError> {
counted_fs!(
self,
NativeFilesystemProvider::new().set_readonly(path, readonly)
)
}
fn exists(&self, path: &Path) -> bool {
self.calls.fetch_add(1, Ordering::SeqCst);
NativeFilesystemProvider::new().exists(path)
}
fn open(
&self,
path: &Path,
mode: NseOpenMode,
) -> Result<Box<dyn NseFileHandle>, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().open(path, mode))
}
fn current_dir(&self) -> Result<FsPathBuf, NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().current_dir())
}
fn set_current_dir(&self, path: &Path) -> Result<(), NseProviderError> {
counted_fs!(self, NativeFilesystemProvider::new().set_current_dir(path))
}
}
pub struct DenyFilesystemProvider {
message: String,
}
impl DenyFilesystemProvider {
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
fn deny(&self) -> NseProviderError {
NseProviderError::new("fs", self.message.clone())
}
}
impl NseFilesystemProvider for DenyFilesystemProvider {
fn read_to_string(&self, _path: &Path) -> Result<String, NseProviderError> {
Err(self.deny())
}
fn read(&self, _path: &Path) -> Result<Vec<u8>, NseProviderError> {
Err(self.deny())
}
fn write(&self, _path: &Path, _bytes: &[u8]) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn metadata(&self, _path: &Path) -> Result<NseFileMetadata, NseProviderError> {
Err(self.deny())
}
fn symlink_metadata(&self, _path: &Path) -> Result<NseFileMetadata, NseProviderError> {
Err(self.deny())
}
fn read_dir(&self, _path: &Path) -> Result<Vec<NseDirEntry>, NseProviderError> {
Err(self.deny())
}
fn remove_file(&self, _path: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn rename(&self, _from: &Path, _to: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn create_dir_all(&self, _path: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn remove_dir(&self, _path: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn hard_link(&self, _src: &Path, _dst: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn symlink(&self, _src: &Path, _dst: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn read_link(&self, _path: &Path) -> Result<FsPathBuf, NseProviderError> {
Err(self.deny())
}
fn set_unix_mode(&self, _path: &Path, _mode: u32) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn set_readonly(&self, _path: &Path, _readonly: bool) -> Result<(), NseProviderError> {
Err(self.deny())
}
fn exists(&self, _path: &Path) -> bool {
false
}
fn open(
&self,
_path: &Path,
_mode: NseOpenMode,
) -> Result<Box<dyn NseFileHandle>, NseProviderError> {
Err(self.deny())
}
fn current_dir(&self) -> Result<FsPathBuf, NseProviderError> {
Err(self.deny())
}
fn set_current_dir(&self, _path: &Path) -> Result<(), NseProviderError> {
Err(self.deny())
}
}
pub struct CountingProcessProvider {
calls: AtomicU64,
}
impl CountingProcessProvider {
pub fn new() -> Self {
Self {
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
}
impl Default for CountingProcessProvider {
fn default() -> Self {
Self::new()
}
}
impl NseProcessProvider for CountingProcessProvider {
fn run(&self, spec: &NseProcessSpec) -> Result<NseProcessResult, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
NativeProcessProvider.run(spec)
}
fn spawn(&self, spec: &NseProcessSpec) -> Result<Box<dyn NseChildProcess>, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
NativeProcessProvider.spawn(spec)
}
fn is_privileged(&self) -> Result<bool, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
NativeProcessProvider.is_privileged()
}
fn network_interfaces(&self) -> Result<Vec<NseNetworkInterface>, NseProviderError> {
self.calls.fetch_add(1, Ordering::SeqCst);
NativeProcessProvider.network_interfaces()
}
}
pub struct DenyProcessProvider {
message: String,
}
impl DenyProcessProvider {
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
fn deny(&self) -> NseProviderError {
NseProviderError::new("process", self.message.clone())
}
}
impl NseProcessProvider for DenyProcessProvider {
fn run(&self, _spec: &NseProcessSpec) -> Result<NseProcessResult, NseProviderError> {
Err(self.deny())
}
fn spawn(&self, _spec: &NseProcessSpec) -> Result<Box<dyn NseChildProcess>, NseProviderError> {
Err(self.deny())
}
fn is_privileged(&self) -> Result<bool, NseProviderError> {
Err(self.deny())
}
fn network_interfaces(&self) -> Result<Vec<NseNetworkInterface>, NseProviderError> {
Err(self.deny())
}
}
pub fn broker_fs_resolve(
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<FsPathBuf, String> {
let candidate = FsPathBuf::from(path);
if candidate.is_absolute() {
return Ok(candidate);
}
let cwd = services
.fs()
.current_dir()
.map_err(|e| format!("{operation}: working directory unavailable: {e}"))?;
Ok(cwd.join(candidate))
}
fn fs_approved_path(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
kind: NseCapabilityKind,
operation: &'static str,
) -> Result<(NseCapabilityRequest, FsPathBuf), String> {
ctx.check_cancelled(operation)?;
let resolved = broker_fs_resolve(services, path, operation)?;
let request = broker_request(
kind,
Some(resolved.to_string_lossy().to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem access denied"));
}
match ctx.sandbox.get_allowed_path(&resolved.to_string_lossy()) {
Some(approved) => Ok((request, approved)),
None => Err(format!(
"{operation}: path '{}' blocked by sandbox",
resolved.display()
)),
}
}
pub fn broker_fs_read_to_string(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<String, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let content = services
.fs()
.read_to_string(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, Some(content.len() as u64));
Ok(content)
}
pub fn broker_fs_read(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<Vec<u8>, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let bytes = services
.fs()
.read(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, Some(bytes.len() as u64));
Ok(bytes)
}
pub fn broker_fs_write(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
bytes: &[u8],
operation: &'static str,
) -> Result<(), String> {
ctx.check_cancelled(operation)?;
let resolved = broker_fs_resolve(services, path, operation)?;
let request = broker_request(
NseCapabilityKind::FilesystemWrite,
Some(resolved.to_string_lossy().to_string()),
Some(bytes.len() as u64),
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem write denied"));
}
let approved = match ctx.sandbox.get_allowed_path(&resolved.to_string_lossy()) {
Some(approved) => approved,
None => {
return Err(format!(
"{operation}: path '{}' blocked by sandbox",
resolved.display()
))
}
};
ctx.before_blocking_operation(&request)?;
services
.fs()
.write(&approved, bytes)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, Some(bytes.len() as u64));
Ok(())
}
pub fn broker_fs_metadata(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<NseFileMetadata, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let meta = services
.fs()
.metadata(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(meta)
}
pub fn broker_fs_symlink_metadata(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<NseFileMetadata, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let meta = services
.fs()
.symlink_metadata(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(meta)
}
pub fn broker_fs_read_dir(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<Vec<NseDirEntry>, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let entries = services
.fs()
.read_dir(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(entries)
}
pub fn broker_fs_remove_file(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.remove_file(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_rename(
ctx: &NseCapabilityContext,
services: &NseHostServices,
from: &str,
to: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved_from) = fs_approved_path(
ctx,
services,
from,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
let resolved_to = broker_fs_resolve(services, to, operation)?;
let request_to = broker_request(
NseCapabilityKind::FilesystemWrite,
Some(resolved_to.to_string_lossy().to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request_to);
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem write denied"));
}
let approved_to = match ctx.sandbox.get_allowed_path(&resolved_to.to_string_lossy()) {
Some(approved) => approved,
None => {
return Err(format!(
"{operation}: path '{}' blocked by sandbox",
resolved_to.display()
))
}
};
ctx.before_blocking_operation(&request)?;
services
.fs()
.rename(&approved_from, &approved_to)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_create_dir_all(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.create_dir_all(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_remove_dir(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.remove_dir(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_hard_link(
ctx: &NseCapabilityContext,
services: &NseHostServices,
src: &str,
dst: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved_src) = fs_approved_path(
ctx,
services,
src,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
let resolved_dst = broker_fs_resolve(services, dst, operation)?;
let decision = ctx.check_capability(&broker_request(
NseCapabilityKind::FilesystemWrite,
Some(resolved_dst.to_string_lossy().to_string()),
None,
operation,
));
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem write denied"));
}
let approved_dst = match ctx
.sandbox
.get_allowed_path(&resolved_dst.to_string_lossy())
{
Some(approved) => approved,
None => {
return Err(format!(
"{operation}: path '{}' blocked by sandbox",
resolved_dst.display()
))
}
};
ctx.before_blocking_operation(&request)?;
services
.fs()
.hard_link(&approved_src, &approved_dst)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_symlink(
ctx: &NseCapabilityContext,
services: &NseHostServices,
src: &str,
dst: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved_src) = fs_approved_path(
ctx,
services,
src,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
let resolved_dst = broker_fs_resolve(services, dst, operation)?;
let decision = ctx.check_capability(&broker_request(
NseCapabilityKind::FilesystemWrite,
Some(resolved_dst.to_string_lossy().to_string()),
None,
operation,
));
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem write denied"));
}
let approved_dst = match ctx
.sandbox
.get_allowed_path(&resolved_dst.to_string_lossy())
{
Some(approved) => approved,
None => {
return Err(format!(
"{operation}: path '{}' blocked by sandbox",
resolved_dst.display()
))
}
};
ctx.before_blocking_operation(&request)?;
services
.fs()
.symlink(&approved_src, &approved_dst)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_read_link(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<FsPathBuf, String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
let target = services
.fs()
.read_link(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(target)
}
pub fn broker_fs_set_unix_mode(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
mode: u32,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.set_unix_mode(&approved, mode)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_set_readonly(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
readonly: bool,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemWrite,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.set_readonly(&approved, readonly)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_fs_exists(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> bool {
if ctx.check_cancelled(operation).is_err() {
return false;
}
let Ok(resolved) = broker_fs_resolve(services, path, operation) else {
return false;
};
let decision = ctx.check_capability(&broker_request(
NseCapabilityKind::FilesystemRead,
Some(resolved.to_string_lossy().to_string()),
None,
operation,
));
if !decision.is_allowed() {
return false;
}
if ctx
.sandbox
.get_allowed_path(&resolved.to_string_lossy())
.is_none()
{
return false;
}
services.fs().exists(&resolved)
}
pub fn broker_fs_open(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
mode: NseOpenMode,
operation: &'static str,
) -> Result<Box<dyn NseFileHandle>, String> {
let kind = if mode.is_write() {
NseCapabilityKind::FilesystemWrite
} else {
NseCapabilityKind::FilesystemRead
};
let (request, approved) = fs_approved_path(ctx, services, path, kind, operation)?;
ctx.before_blocking_operation(&request)?;
let handle = services
.fs()
.open(&approved, mode)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(handle)
}
pub fn broker_fs_current_dir(
ctx: &NseCapabilityContext,
services: &NseHostServices,
operation: &'static str,
) -> Result<FsPathBuf, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(NseCapabilityKind::FilesystemRead, None, None, operation);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "filesystem access denied"));
}
ctx.before_blocking_operation(&request)?;
let dir = services
.fs()
.current_dir()
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(dir)
}
pub fn broker_fs_set_current_dir(
ctx: &NseCapabilityContext,
services: &NseHostServices,
path: &str,
operation: &'static str,
) -> Result<(), String> {
let (request, approved) = fs_approved_path(
ctx,
services,
path,
NseCapabilityKind::FilesystemRead,
operation,
)?;
ctx.before_blocking_operation(&request)?;
services
.fs()
.set_current_dir(&approved)
.map_err(|e| format!("filesystem provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(())
}
pub fn broker_process_run(
ctx: &NseCapabilityContext,
services: &NseHostServices,
spec: &NseProcessSpec,
operation: &'static str,
) -> Result<NseProcessResult, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::ProcessExec,
Some(spec.program.clone()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "process execution denied"));
}
ctx.before_blocking_operation(&request)?;
let result = services
.process()
.run(spec)
.map_err(|e| format!("process provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(result)
}
pub fn broker_process_spawn(
ctx: &NseCapabilityContext,
services: &NseHostServices,
spec: &NseProcessSpec,
operation: &'static str,
) -> Result<Box<dyn NseChildProcess>, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::ProcessExec,
Some(spec.program.clone()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "process execution denied"));
}
ctx.before_blocking_operation(&request)?;
let child = services
.process()
.spawn(spec)
.map_err(|e| format!("process provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(child)
}
pub fn broker_is_privileged(
ctx: &NseCapabilityContext,
services: &NseHostServices,
program_label: &str,
operation: &'static str,
) -> Result<bool, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::ProcessExec,
Some(program_label.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "process execution denied"));
}
ctx.before_blocking_operation(&request)?;
let privileged = services
.process()
.is_privileged()
.map_err(|e| format!("process provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(privileged)
}
pub fn broker_network_interfaces(
ctx: &NseCapabilityContext,
services: &NseHostServices,
program_label: &str,
operation: &'static str,
) -> Result<Vec<NseNetworkInterface>, String> {
ctx.check_cancelled(operation)?;
let request = broker_request(
NseCapabilityKind::ProcessExec,
Some(program_label.to_string()),
None,
operation,
);
let decision = ctx.check_capability(&request);
if !decision.is_allowed() {
return Err(deny_message(&decision, "process execution denied"));
}
ctx.before_blocking_operation(&request)?;
let interfaces = services
.process()
.network_interfaces()
.map_err(|e| format!("process provider failed: {e}"))?;
ctx.after_blocking_operation(&request, None);
Ok(interfaces)
}
fn parse_ip_addr_output(output: &str) -> Vec<NseNetworkInterface> {
let mut interfaces: Vec<NseNetworkInterface> = Vec::new();
let mut current: Option<NseNetworkInterface> = None;
for line in output.lines() {
if line
.split(':')
.nth(1)
.map(|name| !name.trim().is_empty())
.unwrap_or(false)
&& line.starts_with(|c: char| c.is_ascii_digit())
{
if let Some(iface) = current.take() {
interfaces.push(iface);
}
let name = line
.split(':')
.nth(1)
.unwrap_or("unknown")
.trim()
.split('@')
.next()
.unwrap_or("unknown")
.to_string();
current = Some(NseNetworkInterface::new(name, Vec::new()));
} else if line.trim().starts_with("inet ") {
if let Some(ref mut iface) = current {
if let Some(addr) = line.trim().split_whitespace().nth(1) {
let ip = addr.split('/').next().unwrap_or(addr);
if let Some(parsed) = NseIpAddress::parse(ip) {
iface.addresses.push(parsed);
}
}
}
}
}
if let Some(iface) = current.take() {
interfaces.push(iface);
}
if interfaces.is_empty() {
interfaces.push(NseNetworkInterface::new(
"lo",
vec![NseIpAddress::V4([127, 0, 0, 1])],
));
}
interfaces
}
#[cfg(windows)]
fn parse_ipconfig_output(output: &str) -> Vec<NseNetworkInterface> {
let mut interfaces: Vec<NseNetworkInterface> = Vec::new();
let mut current: Option<NseNetworkInterface> = None;
for line in output.lines() {
let trimmed = line.trim();
if trimmed.ends_with(':') && !trimmed.contains("adapter") && !trimmed.is_empty() {
if let Some(iface) = current.take() {
if !iface.addresses.is_empty() || !iface.name.is_empty() {
interfaces.push(iface);
}
}
current = Some(NseNetworkInterface::new(
trimmed.trim_end_matches(':').trim(),
Vec::new(),
));
} else if trimmed.to_lowercase().starts_with("ipv4") {
if let Some(ref mut iface) = current {
if let Some(addr) = trimmed.split(':').nth(1) {
if let Some(parsed) = NseIpAddress::parse(addr.trim()) {
iface.addresses.push(parsed);
}
}
}
}
}
if let Some(iface) = current.take() {
if !iface.addresses.is_empty() || !iface.name.is_empty() {
interfaces.push(iface);
}
}
if interfaces.is_empty() {
interfaces.push(NseNetworkInterface::new(
"lo",
vec![NseIpAddress::V4([127, 0, 0, 1])],
));
}
interfaces
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NseHttpMethod {
Get,
Post,
Put,
Delete,
Patch,
Head,
Options,
Trace,
}
impl NseHttpMethod {
pub fn parse(name: &str) -> Result<Self, NseProviderError> {
match name.trim().to_ascii_uppercase().as_str() {
"GET" => Ok(Self::Get),
"POST" => Ok(Self::Post),
"PUT" => Ok(Self::Put),
"DELETE" => Ok(Self::Delete),
"PATCH" => Ok(Self::Patch),
"HEAD" => Ok(Self::Head),
"OPTIONS" => Ok(Self::Options),
"TRACE" => Ok(Self::Trace),
other => Err(NseProviderError::new(
"http",
format!("unsupported NSE HTTP method '{other}'"),
)),
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::Get => "GET",
Self::Post => "POST",
Self::Put => "PUT",
Self::Delete => "DELETE",
Self::Patch => "PATCH",
Self::Head => "HEAD",
Self::Options => "OPTIONS",
Self::Trace => "TRACE",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseHttpRequest {
pub method: NseHttpMethod,
pub url: String,
pub host: String,
pub headers: Vec<(String, String)>,
pub body: Vec<u8>,
pub timeout: std::time::Duration,
pub connect_timeout: std::time::Duration,
pub insecure_tls: bool,
}
impl NseHttpRequest {
pub fn get(url: impl Into<String>, host: impl Into<String>) -> Self {
Self {
method: NseHttpMethod::Get,
url: url.into(),
host: host.into(),
headers: Vec::new(),
body: Vec::new(),
timeout: std::time::Duration::from_secs(30),
connect_timeout: std::time::Duration::from_secs(10),
insecure_tls: false,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NseHttpResponse {
pub status: u16,
pub headers: Vec<(String, String)>,
pub body: Vec<u8>,
pub final_url: String,
pub version: String,
}
impl NseHttpResponse {
pub fn header(&self, name: &str) -> Option<&str> {
self.headers
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case(name))
.map(|(_, v)| v.as_str())
}
pub fn body_text(&self) -> String {
String::from_utf8_lossy(&self.body).to_string()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NseHttpError {
Denied(String),
Cancelled(String),
Timeout,
Connection(String),
Request(String),
}
impl NseHttpError {
pub fn reason(&self) -> &'static str {
match self {
Self::Denied(_) => "denied",
Self::Cancelled(_) => "cancelled",
Self::Timeout => "timeout",
Self::Connection(_) => "connection",
Self::Request(_) => "request",
}
}
pub fn detail(&self) -> String {
match self {
Self::Denied(m) | Self::Cancelled(m) | Self::Connection(m) | Self::Request(m) => {
m.clone()
}
Self::Timeout => "HTTP request timed out".to_string(),
}
}
}
impl std::fmt::Display for NseHttpError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.detail())
}
}
impl std::error::Error for NseHttpError {}
pub trait NseHttpProvider: Send + Sync {
fn request(&self, req: &NseHttpRequest) -> Result<NseHttpResponse, NseHttpError>;
}
pub struct NativeHttpProvider {
clients: Mutex<HashMap<(bool, u64, u64), reqwest::blocking::Client>>,
}
impl NativeHttpProvider {
pub fn new() -> Self {
Self {
clients: Mutex::new(HashMap::new()),
}
}
fn client_for(&self, req: &NseHttpRequest) -> Result<reqwest::blocking::Client, NseHttpError> {
let key = (
req.insecure_tls,
req.timeout.as_secs(),
req.connect_timeout.as_secs(),
);
let mut clients = self
.clients
.lock()
.map_err(|e| NseHttpError::Request(format!("HTTP client cache lock failed: {e}")))?;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
crate::install_tls_provider();
let mut builder = reqwest::blocking::Client::builder()
.timeout(req.timeout.max(std::time::Duration::from_secs(1)))
.connect_timeout(req.connect_timeout)
.pool_max_idle_per_host(10)
.pool_idle_timeout(std::time::Duration::from_secs(30));
if req.insecure_tls {
builder = builder.danger_accept_invalid_certs(true);
}
let client = builder
.build()
.map_err(|e| NseHttpError::Request(format!("HTTP client build failed: {e}")))?;
clients.insert(key, client.clone());
Ok(client)
}
}
impl Default for NativeHttpProvider {
fn default() -> Self {
Self::new()
}
}
fn native_http_method(method: NseHttpMethod) -> reqwest::Method {
match method {
NseHttpMethod::Get => reqwest::Method::GET,
NseHttpMethod::Post => reqwest::Method::POST,
NseHttpMethod::Put => reqwest::Method::PUT,
NseHttpMethod::Delete => reqwest::Method::DELETE,
NseHttpMethod::Patch => reqwest::Method::PATCH,
NseHttpMethod::Head => reqwest::Method::HEAD,
NseHttpMethod::Options => reqwest::Method::OPTIONS,
NseHttpMethod::Trace => reqwest::Method::TRACE,
}
}
fn native_http_error(e: reqwest::Error) -> NseHttpError {
if e.is_timeout() {
NseHttpError::Timeout
} else if e.is_connect() {
NseHttpError::Connection(e.to_string())
} else {
NseHttpError::Request(e.to_string())
}
}
impl NseHttpProvider for NativeHttpProvider {
fn request(&self, req: &NseHttpRequest) -> Result<NseHttpResponse, NseHttpError> {
let client = self.client_for(req)?;
let mut builder = client.request(native_http_method(req.method), &req.url);
for (name, value) in &req.headers {
builder = builder.header(name.as_str(), value.as_str());
}
if !req.body.is_empty() {
builder = builder.body(req.body.clone());
}
let resp = builder.send().map_err(native_http_error)?;
let status = resp.status().as_u16();
let version = format!("{:?}", resp.version());
let final_url = resp.url().to_string();
let headers: Vec<(String, String)> = resp
.headers()
.iter()
.map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
.collect();
let body = resp.bytes().map(|b| b.to_vec()).unwrap_or_default();
Ok(NseHttpResponse {
status,
headers,
body,
final_url,
version,
})
}
}
pub struct MockHttpProvider {
script: Mutex<VecDeque<Result<NseHttpResponse, NseHttpError>>>,
requests: Mutex<Vec<NseHttpRequest>>,
}
impl MockHttpProvider {
pub fn new(script: Vec<Result<NseHttpResponse, NseHttpError>>) -> Self {
Self {
script: Mutex::new(script.into()),
requests: Mutex::new(Vec::new()),
}
}
pub fn requests(&self) -> Vec<NseHttpRequest> {
self.requests.lock().map(|g| g.clone()).unwrap_or_default()
}
}
impl NseHttpProvider for MockHttpProvider {
fn request(&self, req: &NseHttpRequest) -> Result<NseHttpResponse, NseHttpError> {
self.requests
.lock()
.map(|mut g| g.push(req.clone()))
.unwrap_or(());
self.script
.lock()
.map_err(|e| NseHttpError::Request(format!("mock HTTP lock failed: {e}")))
.and_then(|mut script| {
script.pop_front().unwrap_or(Err(NseHttpError::Request(
"mock HTTP script exhausted".to_string(),
)))
})
}
}
pub struct CountingHttpProvider {
inner: MockHttpProvider,
calls: AtomicU64,
}
impl CountingHttpProvider {
pub fn new(script: Vec<Result<NseHttpResponse, NseHttpError>>) -> Self {
Self {
inner: MockHttpProvider::new(script),
calls: AtomicU64::new(0),
}
}
pub fn calls(&self) -> u64 {
self.calls.load(Ordering::SeqCst)
}
pub fn requests(&self) -> Vec<NseHttpRequest> {
self.inner.requests()
}
}
impl NseHttpProvider for CountingHttpProvider {
fn request(&self, req: &NseHttpRequest) -> Result<NseHttpResponse, NseHttpError> {
self.calls.fetch_add(1, Ordering::SeqCst);
self.inner.request(req)
}
}
pub fn broker_http_request(
ctx: &NseCapabilityContext,
services: &NseHostServices,
request: &NseHttpRequest,
operation: &'static str,
) -> Result<NseHttpResponse, NseHttpError> {
if ctx.profile_kind == crate::profile::NseExecutionProfileKind::AgentSafe
|| ctx.profile_kind == crate::profile::NseExecutionProfileKind::CiSafe
{
if !services.is_http_authority_bound() {
return Err(NseHttpError::Denied(
"HTTP provider is not authority-bound; automated profile denies request"
.to_string(),
));
}
}
if let Err(e) = ctx.check_cancelled(operation) {
return Err(NseHttpError::Cancelled(e));
}
let broker_request = broker_request(
NseCapabilityKind::NetworkTcp,
Some(request.host.clone()),
None,
operation,
);
let decision = ctx.check_capability(&broker_request);
if !decision.is_allowed() {
return Err(NseHttpError::Denied(deny_message(
&decision,
"network HTTP request denied",
)));
}
if let Err(e) = ctx.before_blocking_operation(&broker_request) {
if e.contains("cancelled") {
return Err(NseHttpError::Cancelled(e));
}
return Err(NseHttpError::Request(e));
}
let response = services.http().request(request)?;
ctx.after_blocking_operation(&broker_request, Some(response.body.len() as u64));
ctx.counters.network_bytes_written.fetch_add(
request.body.len() as u64,
std::sync::atomic::Ordering::AcqRel,
);
Ok(response)
}