use std::collections::BTreeMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use snare_interpose::{DevCall, NetResult as HostResult};
use windows_sys::Win32::Devices::DeviceAndDriverInstallation::{
CR_ACCESS_DENIED, CR_INVALID_DEVNODE, CR_SUCCESS, DICS_FLAG_CONFIGSPECIFIC, DICS_FLAG_GLOBAL,
DIGCF_ALLCLASSES, DIGCF_DEVICEINTERFACE, DIREG_DEV, DIREG_DRV, GUID_DEVCLASS_NET,
SP_DEVINFO_DATA,
};
use windows_sys::Win32::Foundation::{
ERROR_ACCESS_DENIED, ERROR_FILE_NOT_FOUND, ERROR_INVALID_FLAGS, ERROR_INVALID_PARAMETER,
ERROR_INVALID_USER_BUFFER, ERROR_KEY_DELETED, ERROR_MORE_DATA, ERROR_NO_MORE_ITEMS,
ERROR_SUCCESS, GENERIC_ALL, GENERIC_READ, GENERIC_WRITE,
};
use windows_sys::Win32::System::Registry::{
KEY_ALL_ACCESS, KEY_CREATE_LINK, KEY_CREATE_SUB_KEY, KEY_QUERY_VALUE, KEY_READ, KEY_SET_VALUE,
KEY_WRITE, REG_BINARY, REG_CREATED_NEW_KEY, REG_DWORD, REG_OPENED_EXISTING_KEY, REG_SZ,
};
use crate::HashMap;
use crate::netif::NicSnapshot;
use crate::readiness::Deadline;
use crate::scope::SimShared;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AdvancedProperty {
pub value: String,
pub max: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Adapter {
pub driver_version: String,
pub properties: BTreeMap<String, AdvancedProperty>,
pub restart_flap: Duration,
}
impl Default for Adapter {
fn default() -> Self {
Adapter::new()
}
}
impl Adapter {
pub fn new() -> Self {
Adapter {
driver_version: env!("CARGO_PKG_VERSION").to_string(),
properties: BTreeMap::new(),
restart_flap: Duration::from_secs(2),
}
.property("*ReceiveBuffers", "256", Some(4096))
.property("*TransmitBuffers", "256", Some(4096))
.property("*InterruptModeration", "1", None)
.property("*FlowControl", "3", None)
.property("*NumRssQueues", "4", Some(8))
.property("*RSS", "1", None)
.property("*SoftwareTimestamp", "0", None)
}
pub fn property(
mut self,
keyword: impl Into<String>,
value: impl Into<String>,
max: Option<u32>,
) -> Self {
self.properties.insert(
keyword.into(),
AdvancedProperty {
value: value.into(),
max,
},
);
self
}
pub fn without_property(mut self, keyword: &str) -> Self {
self.properties.remove(keyword);
self
}
pub fn driver_version(mut self, version: impl Into<String>) -> Self {
self.driver_version = version.into();
self
}
pub fn restart_flap(mut self, flap: Duration) -> Self {
self.restart_flap = flap;
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AdapterKey {
Driver,
Device,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RegValue {
Sz(String),
Dword(u32),
Binary(Vec<u8>),
Other {
ty: u32,
data: Vec<u8>,
},
}
const DEVINST_BASE: u32 = 0x736e_0000;
const HANDLE_BASE: u64 = 0x736e_6172_0000;
const DELETE: u32 = 0x0001_0000;
const WRITE_DAC: u32 = 0x0004_0000;
const WRITE_OWNER: u32 = 0x0008_0000;
const MAXIMUM_ALLOWED: u32 = 0x0200_0000;
const WRITE_ACCESS: u32 = KEY_SET_VALUE
| KEY_CREATE_SUB_KEY
| KEY_CREATE_LINK
| DELETE
| WRITE_DAC
| WRITE_OWNER
| GENERIC_WRITE
| GENERIC_ALL;
#[derive(Clone)]
struct Value {
ty: u32,
data: Vec<u8>,
}
#[derive(Default, Clone)]
struct Tree {
keys: BTreeMap<String, BTreeMap<String, Value>>,
}
impl Tree {
fn create(&mut self, path: &str) -> bool {
let mut created = false;
let mut at = String::new();
self.keys.entry(String::new()).or_default();
for part in path.split('\\').filter(|p| !p.is_empty()) {
if !at.is_empty() {
at.push('\\');
}
at.push_str(&part.to_lowercase());
if !self.keys.contains_key(&at) {
self.keys.insert(at.clone(), BTreeMap::new());
created = true;
}
}
created
}
fn set(&mut self, path: &str, name: &str, ty: u32, data: Vec<u8>) {
self.create(path);
self.keys
.get_mut(&path.to_lowercase())
.unwrap()
.insert(name.to_lowercase(), Value { ty, data });
}
fn set_sz(&mut self, path: &str, name: &str, value: &str) {
self.set(path, name, REG_SZ, sz_bytes(value));
}
}
fn sz_bytes(s: &str) -> Vec<u8> {
s.encode_utf16()
.chain(std::iter::once(0))
.flat_map(u16::to_le_bytes)
.collect()
}
fn join(base: &str, sub: &str) -> String {
base.split('\\')
.chain(sub.split('\\'))
.filter(|p| !p.is_empty())
.map(str::to_lowercase)
.collect::<Vec<_>>()
.join("\\")
}
struct Device {
nic: String,
drv: Tree,
dev: Tree,
flap: Duration,
disabled: bool,
baseline: Option<bool>,
restore: Option<Deadline>,
generation: Arc<Mutex<u64>>,
restarts: u32,
}
impl Device {
fn new(nic: &NicSnapshot, adapter: &Adapter) -> Self {
let mut drv = Tree::default();
drv.create("");
drv.set_sz(
"",
"NetCfgInstanceId",
&crate::iphlp::guid_string(&crate::iphlp::guid(nic)),
);
drv.set_sz("", "DriverDesc", &crate::iphlp::description(nic));
drv.set_sz("", "DriverVersion", &adapter.driver_version);
for (keyword, p) in &adapter.properties {
drv.set_sz("", keyword, &p.value);
let params = format!("Ndi\\Params\\{keyword}");
drv.set_sz(¶ms, "ParamDesc", keyword);
drv.set_sz(
¶ms,
"type",
if p.max.is_some() { "int" } else { "enum" },
);
drv.set_sz(¶ms, "default", &p.value);
if let Some(max) = p.max {
drv.set_sz(¶ms, "max", &max.to_string());
}
}
let mut dev = Tree::default();
dev.create("");
Device {
nic: nic.spec.name.clone(),
drv,
dev,
flap: adapter.restart_flap,
disabled: false,
baseline: None,
restore: None,
generation: Arc::new(Mutex::new(0)),
restarts: 0,
}
}
fn tree(&self, key: AdapterKey) -> &Tree {
match key {
AdapterKey::Driver => &self.drv,
AdapterKey::Device => &self.dev,
}
}
fn tree_mut(&mut self, key: AdapterKey) -> &mut Tree {
match key {
AdapterKey::Driver => &mut self.drv,
AdapterKey::Device => &mut self.dev,
}
}
}
struct OpenKey {
devinst: u32,
which: AdapterKey,
path: String,
access: u32,
}
impl OpenKey {
fn parts(&self) -> (u32, AdapterKey, String, u32) {
(self.devinst, self.which, self.path.clone(), self.access)
}
}
#[derive(Default)]
struct State {
configured: HashMap<String, Adapter>,
devices: BTreeMap<u32, Device>,
sets: HashMap<u64, Vec<u32>>,
keys: HashMap<u64, OpenKey>,
minted: u64,
}
impl State {
fn mint(&mut self) -> u64 {
self.minted += 1;
HANDLE_BASE + 4 * self.minted
}
fn device(&mut self, nic: &NicSnapshot) -> u32 {
let devinst = DEVINST_BASE + nic.index;
if !self.devices.contains_key(&devinst) {
let adapter = self
.configured
.get(&nic.spec.name)
.cloned()
.unwrap_or_default();
self.devices.insert(devinst, Device::new(nic, &adapter));
}
devinst
}
}
struct LinkChange {
nic: String,
generation: Arc<Mutex<u64>>,
epoch: u64,
restore: Option<Deadline>,
}
#[derive(Default)]
pub(crate) struct Adapters {
state: Mutex<State>,
}
fn guid_bytes(g: &windows_sys::core::GUID) -> [u8; 16] {
let mut b = [0u8; 16];
b[..4].copy_from_slice(&g.data1.to_le_bytes());
b[4..6].copy_from_slice(&g.data2.to_le_bytes());
b[6..8].copy_from_slice(&g.data3.to_le_bytes());
b[8..].copy_from_slice(&g.data4);
b
}
fn grant(access: u32, elevated: bool) -> Result<u32, u32> {
if access & WRITE_ACCESS != 0 && !elevated {
return Err(ERROR_ACCESS_DENIED);
}
let mut granted = access & KEY_ALL_ACCESS;
if access & GENERIC_READ != 0 {
granted |= KEY_READ;
}
if access & GENERIC_WRITE != 0 {
granted |= KEY_WRITE;
}
if access & GENERIC_ALL != 0 {
granted |= KEY_ALL_ACCESS;
}
if access & MAXIMUM_ALLOWED != 0 {
granted |= if elevated { KEY_ALL_ACCESS } else { KEY_READ };
}
Ok(granted)
}
unsafe fn devinfo<'a>(data: *const u8) -> Result<&'a SP_DEVINFO_DATA, u32> {
let d = unsafe { data.cast::<SP_DEVINFO_DATA>().as_ref() }.ok_or(ERROR_INVALID_USER_BUFFER)?;
if d.cbSize as usize != size_of::<SP_DEVINFO_DATA>() {
return Err(ERROR_INVALID_USER_BUFFER);
}
Ok(d)
}
impl Adapters {
pub(crate) fn configure(&self, shared: &SimShared, nic: &str, adapter: Adapter) {
let cancelled = {
let mut state = self.state.lock().unwrap();
let mut cancelled = Vec::new();
state.devices.retain(|_, device| {
if device.nic != nic {
return true;
}
let mut generation = device.generation.lock().unwrap_or_else(|e| e.into_inner());
*generation = generation.wrapping_add(1);
cancelled.push(device.generation.clone());
false
});
state.configured.insert(nic.to_string(), adapter);
cancelled
};
for generation in cancelled {
shared.cancel_adapter_link(nic, &generation);
}
}
pub(crate) fn value(
&self,
shared: &SimShared,
nic: &str,
key: AdapterKey,
path: &str,
name: &str,
) -> Option<RegValue> {
let snapshot = shared.nic(nic).filter(|n| !n.loopback)?;
let mut state = self.state.lock().unwrap();
let devinst = state.device(&snapshot);
let value = state.devices[&devinst]
.tree(key)
.keys
.get(&join("", path))?
.get(&name.to_lowercase())?
.clone();
let u16s = || {
let units: Vec<u16> = value
.data
.as_chunks::<2>()
.0
.iter()
.map(|&c| u16::from_le_bytes(c))
.collect();
let end = units.iter().position(|&u| u == 0).unwrap_or(units.len());
String::from_utf16_lossy(&units[..end])
};
Some(match value.ty {
REG_SZ => RegValue::Sz(u16s()),
REG_DWORD if value.data.len() == 4 => {
RegValue::Dword(u32::from_le_bytes(value.data[..4].try_into().unwrap()))
}
REG_BINARY => RegValue::Binary(value.data),
ty => RegValue::Other {
ty,
data: value.data,
},
})
}
pub(crate) fn restarts(&self, nic: &str) -> u32 {
let state = self.state.lock().unwrap();
state
.devices
.values()
.find(|d| d.nic == nic)
.map_or(0, |d| d.restarts)
}
pub(crate) unsafe fn call(&self, shared: &SimShared, call: DevCall<'_>) -> Option<HostResult> {
let elevated = shared.sys.privileges().root;
match call {
DevCall::GetClassDevs {
class,
enumerator,
flags,
} => {
if class != Some(&guid_bytes(&GUID_DEVCLASS_NET))
|| enumerator.is_some()
|| flags & (DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE) != 0
{
return None;
}
let mut nics: Vec<NicSnapshot> =
shared.nics().into_iter().filter(|n| !n.loopback).collect();
nics.sort_by_key(|n| n.index);
let mut state = self.state.lock().unwrap();
let devices = nics.iter().map(|n| state.device(n)).collect();
let set = state.mint();
state.sets.insert(set, devices);
Some(HostResult::Ok(set as i64))
}
DevCall::EnumDeviceInfo { set, index, data } => {
let state = self.state.lock().unwrap();
let devices = state.sets.get(&set)?;
if let Err(e) = unsafe { devinfo(data) } {
return Some(HostResult::Err(e as i32));
}
let Some(&devinst) = devices.get(index as usize) else {
return Some(HostResult::Err(ERROR_NO_MORE_ITEMS as i32));
};
let out = SP_DEVINFO_DATA {
cbSize: size_of::<SP_DEVINFO_DATA>() as u32,
ClassGuid: GUID_DEVCLASS_NET,
DevInst: devinst,
Reserved: 0,
};
unsafe { data.cast::<SP_DEVINFO_DATA>().write_unaligned(out) };
Some(HostResult::Ok(1))
}
DevCall::DestroyDeviceInfoList { set } => {
let mut state = self.state.lock().unwrap();
state.sets.remove(&set)?;
Some(HostResult::Ok(1))
}
DevCall::OpenDevRegKey {
set,
data,
scope,
key_type,
access,
..
} => {
let mut state = self.state.lock().unwrap();
let devices = state.sets.get(&set)?;
let devinst = match unsafe { devinfo(data) } {
Ok(d) => d.DevInst,
Err(e) => return Some(HostResult::Err(e as i32)),
};
if !devices.contains(&devinst) {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as i32));
}
let which = match key_type {
DIREG_DRV => AdapterKey::Driver,
DIREG_DEV => AdapterKey::Device,
_ => return Some(HostResult::Err(ERROR_INVALID_FLAGS as i32)),
};
if scope != DICS_FLAG_GLOBAL && scope != DICS_FLAG_CONFIGSPECIFIC {
return Some(HostResult::Err(ERROR_INVALID_FLAGS as i32));
}
let access = match grant(access, elevated) {
Ok(a) => a,
Err(e) => return Some(HostResult::Err(e as i32)),
};
let key = state.mint();
state.keys.insert(
key,
OpenKey {
devinst,
which,
path: String::new(),
access,
},
);
Some(HostResult::Ok(key as i64))
}
DevCall::DisableDevNode { devinst, .. } | DevCall::EnableDevNode { devinst, .. } => {
let enable = matches!(call, DevCall::EnableDevNode { .. });
let change = {
let mut state = self.state.lock().unwrap();
let device = state.devices.get_mut(&devinst)?;
if !elevated {
return Some(HostResult::Ok(CR_ACCESS_DENIED as i64));
}
let Some(nic) = shared.nic(&device.nic) else {
return Some(HostResult::Ok(CR_INVALID_DEVNODE as i64));
};
if device.restore.is_some_and(|at| at.passed()) {
device.restore = None;
device.baseline = None;
}
if enable == !device.disabled {
None
} else {
let mut generation =
device.generation.lock().unwrap_or_else(|e| e.into_inner());
*generation = generation.wrapping_add(1);
if enable {
device.disabled = false;
device.restarts += 1;
device.restore = device
.baseline
.filter(|carrier| *carrier)
.map(|_| Deadline::after(device.flap));
if device.restore.is_none() {
device.baseline = None;
}
} else {
device.baseline.get_or_insert(nic.spec.carrier);
device.disabled = true;
device.restore = None;
}
Some(LinkChange {
nic: device.nic.clone(),
generation: device.generation.clone(),
epoch: *generation,
restore: device.restore,
})
}
};
if let Some(change) = change {
let _ = shared.adapter_link(
&change.nic,
&change.generation,
change.epoch,
change.restore,
);
}
Some(HostResult::Ok(CR_SUCCESS as i64))
}
DevCall::OpenKey {
key,
subkey,
access,
result,
} => {
let mut state = self.state.lock().unwrap();
let (devinst, which, base, _) = state.keys.get(&key)?.parts();
let status = (|| {
if result.is_null() {
return Err(ERROR_INVALID_PARAMETER);
}
let path = join(&base, &String::from_utf16_lossy(subkey.unwrap_or(&[])));
let device = state.devices.get(&devinst).ok_or(ERROR_KEY_DELETED)?;
if !device.tree(which).keys.contains_key(&path) {
return Err(ERROR_FILE_NOT_FOUND);
}
let access = grant(access, elevated)?;
let handle = state.mint();
state.keys.insert(
handle,
OpenKey {
devinst,
which,
path,
access,
},
);
unsafe { result.write_unaligned(handle) };
Ok(())
})();
Some(HostResult::Ok(status.err().unwrap_or(ERROR_SUCCESS) as i64))
}
DevCall::CreateKey {
key,
subkey,
access,
result,
disposition,
} => {
let mut state = self.state.lock().unwrap();
let (devinst, which, base, _) = state.keys.get(&key)?.parts();
let status = (|| {
if result.is_null() {
return Err(ERROR_INVALID_PARAMETER);
}
if !elevated {
return Err(ERROR_ACCESS_DENIED);
}
let access = grant(access, elevated)?;
let path = join(&base, &String::from_utf16_lossy(subkey.unwrap_or(&[])));
let device = state.devices.get_mut(&devinst).ok_or(ERROR_KEY_DELETED)?;
let created = device.tree_mut(which).create(&path);
let handle = state.mint();
state.keys.insert(
handle,
OpenKey {
devinst,
which,
path,
access,
},
);
unsafe {
result.write_unaligned(handle);
if !disposition.is_null() {
disposition.write_unaligned(if created {
REG_CREATED_NEW_KEY
} else {
REG_OPENED_EXISTING_KEY
});
}
}
Ok(())
})();
Some(HostResult::Ok(status.err().unwrap_or(ERROR_SUCCESS) as i64))
}
DevCall::QueryValue {
key,
name,
ty,
data,
len,
} => {
let state = self.state.lock().unwrap();
let open = state.keys.get(&key)?;
let status = unsafe { query(&state, open, name, ty, data, len) };
Some(HostResult::Ok(status.err().unwrap_or(ERROR_SUCCESS) as i64))
}
DevCall::SetValue {
key,
name,
ty,
data,
len,
} => {
let mut state = self.state.lock().unwrap();
let (devinst, which, path, granted) = state.keys.get(&key)?.parts();
let status = (|| {
if granted & KEY_SET_VALUE == 0 {
return Err(ERROR_ACCESS_DENIED);
}
if data.is_null() && len != 0 {
return Err(ERROR_INVALID_PARAMETER);
}
let bytes = if len == 0 {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(data, len as usize) }.to_vec()
};
let name = String::from_utf16_lossy(name.unwrap_or(&[]));
let device = state.devices.get_mut(&devinst).ok_or(ERROR_KEY_DELETED)?;
device.tree_mut(which).set(&path, &name, ty, bytes);
Ok(())
})();
Some(HostResult::Ok(status.err().unwrap_or(ERROR_SUCCESS) as i64))
}
DevCall::DeleteValue { key, name } => {
let mut state = self.state.lock().unwrap();
let (devinst, which, path, granted) = state.keys.get(&key)?.parts();
let status = (|| {
if granted & KEY_SET_VALUE == 0 {
return Err(ERROR_ACCESS_DENIED);
}
let name = String::from_utf16_lossy(name.unwrap_or(&[])).to_lowercase();
let device = state.devices.get_mut(&devinst).ok_or(ERROR_KEY_DELETED)?;
let values = device
.tree_mut(which)
.keys
.get_mut(&path)
.ok_or(ERROR_KEY_DELETED)?;
values.remove(&name).map(drop).ok_or(ERROR_FILE_NOT_FOUND)
})();
Some(HostResult::Ok(status.err().unwrap_or(ERROR_SUCCESS) as i64))
}
DevCall::CloseKey { key } => {
self.state.lock().unwrap().keys.remove(&key)?;
Some(HostResult::Ok(ERROR_SUCCESS as i64))
}
}
}
}
unsafe fn query(
state: &State,
open: &OpenKey,
name: Option<&[u16]>,
ty: *mut u32,
data: *mut u8,
len: *mut u32,
) -> Result<(), u32> {
if open.access & KEY_QUERY_VALUE == 0 {
return Err(ERROR_ACCESS_DENIED);
}
if !data.is_null() && len.is_null() {
return Err(ERROR_INVALID_PARAMETER);
}
let device = state.devices.get(&open.devinst).ok_or(ERROR_KEY_DELETED)?;
let name = String::from_utf16_lossy(name.unwrap_or(&[])).to_lowercase();
let value = device
.tree(open.which)
.keys
.get(&open.path)
.ok_or(ERROR_KEY_DELETED)?
.get(&name)
.ok_or(ERROR_FILE_NOT_FOUND)?;
let size = value.data.len() as u32;
unsafe {
if !ty.is_null() {
ty.write_unaligned(value.ty);
}
if len.is_null() {
return Ok(());
}
let room = len.read_unaligned();
len.write_unaligned(size);
if data.is_null() {
return Ok(());
}
if room < size {
return Err(ERROR_MORE_DATA);
}
std::ptr::copy_nonoverlapping(value.data.as_ptr(), data, value.data.len());
}
Ok(())
}