use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::ffi::OsStr;
use std::os::fd::RawFd;
use std::os::unix::ffi::OsStrExt;
use std::os::unix::fs::MetadataExt;
use std::path::Component;
use std::path::Path;
use std::path::PathBuf;
use reverie::Error;
use reverie::Guest;
use reverie::syscalls;
use reverie::syscalls::Addr;
use reverie::syscalls::AddrMut;
use reverie::syscalls::MapFlags;
use reverie::syscalls::MemoryAccess;
use reverie::syscalls::PathPtr;
use reverie::syscalls::ProtFlags;
use reverie::syscalls::ReadAddr;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use super::rendered_procfs;
use crate::procfs::levels::ProcfsName;
use crate::procfs::levels::procfs_name;
use crate::record_or_replay::RecordOrReplay;
use crate::tool_local::Detcore;
const PATH_MAX: usize = libc::PATH_MAX as usize;
const NAME_MAX: usize = 255;
const MAXSYMLINKS: usize = 40;
const MSGHDR_SIZE: usize = std::mem::size_of::<libc::msghdr>();
const SUN_PATH_MAX: usize = 108;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum Lookups {
Paths(Vec<(Option<usize>, usize)>),
SocketAddress {
address: usize,
length: usize,
send: bool,
},
MessageAddress,
}
pub(super) fn looked_up(sysno: Sysno) -> Option<Lookups> {
let paths = match sysno {
Sysno::open
| Sysno::creat
| Sysno::stat
| Sysno::lstat
| Sysno::access
| Sysno::readlink
| Sysno::execve
| Sysno::chdir
| Sysno::chroot
| Sysno::mkdir
| Sysno::mknod
| Sysno::rmdir
| Sysno::unlink
| Sysno::truncate
| Sysno::chmod
| Sysno::chown
| Sysno::lchown
| Sysno::utime
| Sysno::utimes
| Sysno::getxattr
| Sysno::lgetxattr
| Sysno::setxattr
| Sysno::lsetxattr
| Sysno::listxattr
| Sysno::llistxattr
| Sysno::removexattr
| Sysno::lremovexattr
| Sysno::statfs => vec![(None, 0)],
Sysno::openat
| Sysno::newfstatat
| Sysno::statx
| Sysno::faccessat
| Sysno::faccessat2
| Sysno::readlinkat
| Sysno::execveat
| Sysno::mkdirat
| Sysno::mknodat
| Sysno::unlinkat
| Sysno::fchmodat
| Sysno::fchmodat2
| Sysno::fchownat
| Sysno::utimensat
| Sysno::futimesat => vec![(Some(0), 1)],
Sysno::symlink => vec![(None, 1)],
Sysno::symlinkat => vec![(Some(1), 2)],
Sysno::inotify_add_watch => vec![(None, 1)],
Sysno::rename | Sysno::link => vec![(None, 0), (None, 1)],
Sysno::renameat | Sysno::renameat2 | Sysno::linkat => {
vec![(Some(0), 1), (Some(2), 3)]
}
Sysno::bind | Sysno::connect => {
return Some(Lookups::SocketAddress {
address: 1,
length: 2,
send: false,
});
}
Sysno::sendto => {
return Some(Lookups::SocketAddress {
address: 4,
length: 5,
send: true,
});
}
Sysno::sendmsg => return Some(Lookups::MessageAddress),
_ => return None,
};
Some(Lookups::Paths(paths))
}
fn absent_prefix(path: &Path, level: detcore_model::config::ProcLevel) -> Option<PathBuf> {
let mut components = path.components();
if components.next() != Some(Component::RootDir) {
return None;
}
let mut prefix = PathBuf::from("/");
for component in components {
let name = match component {
Component::Normal(name) => name,
Component::CurDir => continue,
_ => return None,
};
if name.len() > NAME_MAX {
return None;
}
prefix.push(name);
if procfs_name(&prefix).is_some_and(|name| name.absent_at(level)) {
return Some(prefix);
}
}
None
}
fn unix_address_path(address: &[u8]) -> Option<&[u8]> {
let family_length = std::mem::size_of::<libc::sa_family_t>();
if address.len() <= family_length
|| address.len() > std::mem::size_of::<libc::sockaddr_un>()
|| libc::sa_family_t::from_ne_bytes(address[..family_length].try_into().ok()?)
!= libc::AF_UNIX as libc::sa_family_t
{
return None;
}
let path = &address[family_length..];
if path[0] == 0 {
return None;
}
let end = path
.iter()
.position(|byte| *byte == 0)
.unwrap_or(path.len());
Some(&path[..end])
}
fn unix_address(path: &[u8]) -> Option<Vec<u8>> {
if path.len() + 1 > SUN_PATH_MAX {
return None;
}
let mut address = (libc::AF_UNIX as libc::sa_family_t).to_ne_bytes().to_vec();
address.extend_from_slice(path);
address.push(0);
Some(address)
}
fn resolve_links(path: &Path) -> Option<PathBuf> {
let mut pending = path.components().map(owned).collect::<VecDeque<_>>();
let mut resolved = PathBuf::from("/");
let mut links = 0;
while let Some(component) = pending.pop_front() {
match component {
Owned::Root => resolved = PathBuf::from("/"),
Owned::Current => {}
Owned::Parent => {
resolved.pop();
}
Owned::Name(name) => {
let next = resolved.join(&name);
if next.starts_with("/proc") {
resolved = match next.to_str() {
Some("/proc/self") => PathBuf::from("/proc/1"),
Some("/proc/thread-self") => PathBuf::from("/proc/1/task/1"),
Some("/proc/net") => PathBuf::from("/proc/1/net"),
Some("/proc/mounts") => PathBuf::from("/proc/1/mounts"),
_ => next,
};
continue;
}
match std::fs::read_link(&next) {
Ok(target) => {
links += 1;
if links > MAXSYMLINKS {
return None;
}
for component in target.components().rev() {
pending.push_front(owned(component));
}
}
Err(_) => resolved = next,
}
}
}
}
Some(resolved)
}
enum Owned {
Root,
Current,
Parent,
Name(std::ffi::OsString),
}
fn owned(component: Component<'_>) -> Owned {
match component {
Component::RootDir | Component::Prefix(_) => Owned::Root,
Component::CurDir => Owned::Current,
Component::ParentDir => Owned::Parent,
Component::Normal(name) => Owned::Name(name.to_owned()),
}
}
struct Replacement {
argument: Option<usize>,
bytes: Vec<u8>,
}
pub(super) async fn map_transient<T: RecordOrReplay, G: Guest<Detcore<T>>>(
guest: &mut G,
length: usize,
) -> Option<AddrMut<'static, u8>> {
guest
.inject_with_retry(Syscall::Mmap(
syscalls::Mmap::new()
.with_addr(None)
.with_len(length)
.with_prot(ProtFlags::PROT_READ | ProtFlags::PROT_WRITE)
.with_flags(MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS)
.with_fd(-1)
.with_offset(0),
))
.await
.ok()
.and_then(|mapped| usize::try_from(mapped).ok())
.and_then(AddrMut::<u8>::from_raw)
}
pub(super) async fn unmap_transient<T: RecordOrReplay, G: Guest<Detcore<T>>>(
guest: &mut G,
page: AddrMut<'_, u8>,
length: usize,
) {
let unmapped = guest
.inject_with_retry(Syscall::Munmap(
syscalls::Munmap::new()
.with_addr(Some(page.cast::<libc::c_void>().into()))
.with_len(length),
))
.await;
if let Err(errno) = unmapped {
tracing::warn!("[detcore] could not unmap the transient procfs page: {errno}");
}
}
pub(super) fn raw_args(values: [usize; 6]) -> syscalls::SyscallArgs {
syscalls::SyscallArgs::new(
values[0], values[1], values[2], values[3], values[4], values[5],
)
}
#[derive(Debug, Default)]
struct Decision {
substituted: Option<Vec<u8>>,
decided: bool,
}
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) async fn refuse_procfs_name_outside_level<G: Guest<Self>>(
&self,
guest: &mut G,
call: &Syscall,
) -> Result<Option<i64>, Error> {
let _ = rendered_procfs::proc_device();
let (sysno, args) = call.into_parts();
let Some(lookups) = looked_up(sysno) else {
return Ok(None);
};
let Some(root) = self.guest_root_in_view(guest) else {
return Ok(None);
};
let mut values = [
args.arg0, args.arg1, args.arg2, args.arg3, args.arg4, args.arg5,
];
let mut recovered = Vec::new();
if let Lookups::Paths(operands) = &lookups {
for (dirfd, path) in operands {
let spelling = PathPtr::from_ptr(values[*path] as *const libc::c_char)
.and_then(|address| address.read(&guest.memory()).ok());
let directory = match (dirfd, &spelling) {
(Some(position), Some(spelling)) if !spelling.is_absolute() => {
self.unrecorded_procfs_directory(guest, values[*position] as i32)
.await
}
_ => None,
};
recovered.push(directory);
}
}
let recovered_paths = match &lookups {
Lookups::Paths(operands) => operands
.iter()
.zip(&recovered)
.filter_map(|((_, path), directory)| {
let spelling = PathPtr::from_ptr(values[*path] as *const libc::c_char)
.and_then(|address| address.read(&guest.memory()).ok())?;
Some(directory.as_ref()?.join(spelling))
})
.collect::<Vec<_>>(),
_ => Vec::new(),
};
let numbers = self
.parent_numbers(guest, &lookups, &values, &recovered_paths)
.await;
let mut confined = true;
let replacements = match lookups {
Lookups::Paths(operands) => {
let mut replacements = Vec::new();
for (index, (dirfd, path)) in operands.into_iter().enumerate() {
let decision = match PathPtr::from_ptr(values[path] as *const libc::c_char)
.and_then(|address| address.read(&guest.memory()).ok())
{
Some(spelling) => match recovered.get(index).cloned().flatten() {
Some(directory) => self.decide(
guest,
None,
&directory.join(&spelling),
&root,
numbers.as_ref(),
),
None => self.decide(
guest,
dirfd.map(|p| values[p] as i32),
&spelling,
&root,
numbers.as_ref(),
),
},
None => Decision::default(),
};
confined &= decision.decided;
if let Some(bytes) = decision.substituted {
replacements.push(Replacement {
argument: Some(path),
bytes,
});
}
}
replacements
}
Lookups::SocketAddress {
address,
length,
send,
} => {
let Ok(length_value) = usize::try_from(values[length] as u32 as i32) else {
return Ok(None);
};
let Some(bytes) = self.substituted_socket_address(
guest,
values[address] as u64,
length_value,
send,
&root,
numbers.as_ref(),
) else {
return Ok(None);
};
if send {
match self.socket_is_datagram(guest, values[0] as RawFd).await {
Some(false) => return Ok(None),
Some(true) => {}
None => return Err(syscalls::Errno::ENOENT.into()),
}
}
values[length] = bytes.len();
confined = false;
vec![Replacement {
argument: Some(address),
bytes,
}]
}
Lookups::MessageAddress => {
let mut header = vec![0u8; MSGHDR_SIZE];
let Some(start) = Addr::<u8>::from_raw(values[1]) else {
return Ok(None);
};
if guest.memory().read_exact(start, &mut header).is_err() {
return Ok(None);
}
let name = u64::from_ne_bytes(header[..8].try_into().expect("8 bytes"));
let length = u32::from_ne_bytes(header[8..12].try_into().expect("4 bytes"));
let bytes = (name != 0)
.then(|| {
self.substituted_socket_address(
guest,
name,
length as usize,
true,
&root,
numbers.as_ref(),
)
})
.flatten();
let Some(bytes) = bytes else {
return Ok(None);
};
match self.socket_is_datagram(guest, values[0] as RawFd).await {
Some(false) => return Ok(None),
Some(true) => {}
None => return Err(syscalls::Errno::ENOENT.into()),
}
header[8..12].copy_from_slice(&(bytes.len() as u32).to_ne_bytes());
confined = false;
vec![
Replacement {
argument: Some(1),
bytes: header,
},
Replacement {
argument: None,
bytes,
},
]
}
};
if replacements.is_empty() {
return Ok(None);
}
self.issue_substituted(guest, sysno, values, replacements, confined)
.await
.map(Some)
}
async fn parent_numbers<G: Guest<Self>>(
&self,
guest: &mut G,
lookups: &Lookups,
values: &[usize; 6],
recovered: &[PathBuf],
) -> Option<BTreeMap<i32, Option<i32>>> {
if !Self::translates_procfs_numbers(guest) {
return None;
}
let mut spellings = recovered
.iter()
.map(|path| (libc::AT_FDCWD, path.clone()))
.collect::<Vec<_>>();
match lookups {
Lookups::Paths(operands) => {
for (dirfd, path) in operands {
if let Some(spelling) = PathPtr::from_ptr(values[*path] as *const libc::c_char)
.and_then(|address| address.read(&guest.memory()).ok())
{
let dirfd =
dirfd.map_or(libc::AT_FDCWD, |position| values[position] as i32);
spellings.push((dirfd, spelling));
}
}
}
Lookups::SocketAddress {
address, length, ..
} => {
spellings.extend(
socket_address_path(guest, values[*address], values[*length] as u32 as usize)
.map(|path| (libc::AT_FDCWD, path)),
);
}
Lookups::MessageAddress => {
let mut header = [0u8; 12];
if let Some(start) = Addr::<u8>::from_raw(values[1])
&& guest.memory().read_exact(start, &mut header).is_ok()
{
let name = u64::from_ne_bytes(header[..8].try_into().expect("8 bytes"));
let length = u32::from_ne_bytes(header[8..12].try_into().expect("4 bytes"));
spellings.extend(
socket_address_path(guest, name as usize, length as usize)
.map(|path| (libc::AT_FDCWD, path)),
);
}
}
}
let named = spellings
.iter()
.filter_map(|(dirfd, spelling)| Self::observed_path(guest, *dirfd, spelling).ok())
.flat_map(|path| crate::procfs::ids::named_ids(&path))
.collect::<BTreeSet<_>>()
.into_iter()
.collect::<Vec<_>>();
if named.is_empty() {
return Some(BTreeMap::new());
}
let kernel = crate::tool_global::procfs_ids(guest, true, named.clone()).await;
Some(named.into_iter().zip(kernel).collect())
}
fn decide<G: Guest<Self>>(
&self,
guest: &G,
dirfd: Option<i32>,
spelling: &Path,
root: &Option<PathBuf>,
numbers: Option<&BTreeMap<i32, Option<i32>>>,
) -> Decision {
let bytes = spelling.as_os_str().as_bytes();
if bytes.is_empty() || bytes.len() >= PATH_MAX {
return Decision::default();
}
let dirfd = dirfd.unwrap_or(libc::AT_FDCWD);
if root.is_some() && dirfd != libc::AT_FDCWD && !spelling.is_absolute() {
return Decision::default();
}
let Some(observed) = Self::observed_path(guest, dirfd, spelling)
.ok()
.filter(|observed| observed.is_absolute())
else {
return Decision::default();
};
let in_view = match root {
None => observed.clone(),
Some(root) => root.join(observed.strip_prefix("/").unwrap_or(&observed)),
};
let guest_view = root.is_some() && procfs_name(&in_view).is_none();
let named = if guest_view { &observed } else { &in_view };
let to_tool = |path: &Path| match root {
Some(root) if guest_view => root.join(path.strip_prefix("/").unwrap_or(path)),
_ => path.to_path_buf(),
};
let decided = procfs_name(named).is_some_and(|name| name != ProcfsName::Undecided);
let substituted = absent_prefix(named, self.cfg.proc_level).and_then(|prefix| {
let parent = prefix.parent()?;
let checked = self.parent_in_tool_view(guest, &to_tool(parent), root, numbers);
let on_procfs = std::fs::metadata(&checked)
.ok()
.is_some_and(|metadata| Some(metadata.dev()) == rendered_procfs::proc_device());
if !on_procfs {
return None;
}
let parent = match root {
Some(root) if !guest_view => Path::new("/").join(parent.strip_prefix(root).ok()?),
_ => parent.to_path_buf(),
};
let name_length = prefix.file_name()?.len();
let mut substituted = parent.as_os_str().as_bytes().to_vec();
if !substituted.ends_with(b"/") {
substituted.push(b'/');
}
substituted.resize(substituted.len() + name_length, b'-');
let rest = named.strip_prefix(&prefix).ok()?;
if !rest.as_os_str().is_empty() {
substituted.push(b'/');
substituted.extend_from_slice(rest.as_os_str().as_bytes());
}
if bytes.ends_with(b"/") {
substituted.push(b'/');
}
Some(substituted)
});
Decision {
substituted,
decided,
}
}
fn parent_in_tool_view<G: Guest<Self>>(
&self,
guest: &G,
parent: &Path,
root: &Option<PathBuf>,
numbers: Option<&BTreeMap<i32, Option<i32>>>,
) -> PathBuf {
let proc_root = match root {
None => PathBuf::from("/proc"),
Some(root) => root.join("proc"),
};
let Ok(below) = parent.strip_prefix(&proc_root) else {
return parent.to_path_buf();
};
let mut components = below.components();
let Some(first) = components.next() else {
return parent.to_path_buf();
};
let first = first.as_os_str().as_bytes();
let is_process =
first == b"self" || first == b"thread-self" || first.iter().all(u8::is_ascii_digit);
if !is_process {
return parent.to_path_buf();
}
if self.cfg.backend.tool_shares_guest_descriptor_table {
return numbers
.and_then(|numbers| {
crate::procfs::ids::translate(parent, |id| numbers.get(&id).copied().flatten())
})
.unwrap_or_else(|| parent.to_path_buf());
}
if !crate::procfs_inode::tool_can_name_guest_descriptors(&self.cfg.backend) {
return proc_root;
}
let process = match first {
b"self" => proc_root.join(guest.pid().as_raw().to_string()),
b"thread-self" => proc_root.join(format!(
"{}/task/{}",
guest.pid().as_raw(),
guest.tid().as_raw()
)),
_ => proc_root.join(OsStr::from_bytes(first)),
};
process.join(components.as_path())
}
fn substituted_socket_address<G: Guest<Self>>(
&self,
guest: &G,
address: u64,
length: usize,
send: bool,
root: &Option<PathBuf>,
numbers: Option<&BTreeMap<i32, Option<i32>>>,
) -> Option<Vec<u8>> {
if length > std::mem::size_of::<libc::sockaddr_un>()
|| (send && self.cfg.recordreplay_modes)
{
return None;
}
let mut bytes = vec![0; length];
guest
.memory()
.read_exact(Addr::<u8>::from_raw(address as usize)?, &mut bytes)
.ok()?;
let path = PathBuf::from(OsStr::from_bytes(unix_address_path(&bytes)?));
let substituted = self.decide(guest, None, &path, root, numbers).substituted?;
unix_address(&substituted)
}
async fn issue_substituted<G: Guest<Self>>(
&self,
guest: &mut G,
sysno: Sysno,
mut values: [usize; 6],
mut replacements: Vec<Replacement>,
confined: bool,
) -> Result<i64, Error> {
let length: usize = replacements
.iter()
.map(|replacement| replacement.bytes.len() + 1)
.sum();
let Some(page) = map_transient(guest, length).await else {
return Err(syscalls::Errno::ENOENT.into());
};
let base = page.as_raw();
let mut offsets = Vec::with_capacity(replacements.len());
let mut offset = 0;
for replacement in &replacements {
offsets.push(offset);
offset += replacement.bytes.len() + 1;
}
for index in 1..replacements.len() {
if replacements[index].argument.is_none() {
let name = (base + offsets[index]) as u64;
replacements[index - 1].bytes[..8].copy_from_slice(&name.to_ne_bytes());
}
}
let mut contents = Vec::with_capacity(length);
for (replacement, offset) in replacements.iter().zip(&offsets) {
contents.extend_from_slice(&replacement.bytes);
contents.push(0);
if let Some(argument) = replacement.argument {
values[argument] = base + offset;
}
}
let result = match guest.memory().write_exact(page, &contents) {
Ok(()) => {
self.record_or_replay(guest, Syscall::from_raw(sysno, raw_args(values)))
.await
}
Err(_) => Err(syscalls::Errno::ENOENT),
};
unmap_transient(guest, page, length).await;
match result {
Ok(value) => {
if matches!(sysno, Sysno::open | Sysno::openat | Sysno::creat) {
let _ = self
.record_or_replay(guest, syscalls::Close::new().with_fd(value as RawFd))
.await;
}
Err(syscalls::Errno::ENOENT.into())
}
Err(syscalls::Errno::EACCES | syscalls::Errno::EPERM) if confined => {
Err(syscalls::Errno::ENOENT.into())
}
Err(error) => Err(error.into()),
}
}
async fn socket_is_datagram<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) -> Option<bool> {
const LENGTH: usize = 8;
let page = map_transient(guest, LENGTH).await?;
let base = page.as_raw();
let mut contents = [0u8; LENGTH];
contents[4..].copy_from_slice(&4u32.to_ne_bytes());
let answered = guest.memory().write_exact(page, &contents).is_ok()
&& guest
.inject(Syscall::from_raw(
Sysno::getsockopt,
raw_args([
fd as usize,
libc::SOL_SOCKET as usize,
libc::SO_TYPE as usize,
base,
base + 4,
0,
]),
))
.await
.is_ok()
&& guest.memory().read_exact(page, &mut contents).is_ok();
unmap_transient(guest, page, LENGTH).await;
Some(
answered
&& i32::from_ne_bytes(contents[..4].try_into().expect("4 bytes"))
== libc::SOCK_DGRAM,
)
}
pub(crate) fn guest_root_in_view<G: Guest<Self>>(&self, guest: &G) -> Option<Option<PathBuf>> {
if !guest
.thread_state()
.changed_root
.load(std::sync::atomic::Ordering::SeqCst)
{
return Some(None);
}
if self.cfg.recordreplay_modes {
return None;
}
std::fs::read_link(format!("{}/root", self.caller_proc_directory(guest)))
.ok()
.map(Some)
}
pub(crate) fn caller_proc_directory<G: Guest<Self>>(&self, guest: &G) -> String {
if self.cfg.backend.tool_shares_guest_descriptor_table {
String::from("/proc/thread-self")
} else {
format!("/proc/{}", guest.tid().as_raw())
}
}
pub(crate) async fn opened_procfs_name_outside_level<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
identity: Option<(u64, u64)>,
) -> bool {
if self.cfg.recordreplay_modes {
return false;
}
let link = format!("{}/fd/{fd}", self.caller_proc_directory(guest));
let visible = crate::procfs_inode::tool_can_name_guest_descriptors(&self.cfg.backend);
let entry = visible
.then(|| std::fs::metadata(&link).ok())
.flatten()
.map(|metadata| (metadata.dev(), metadata.ino()));
if let (Some(identity), Some(entry)) = (identity, entry)
&& identity != entry
{
return false;
}
let device = identity.or(entry).map(|(dev, _)| dev);
let on_procfs = match (device, rendered_procfs::proc_device()) {
(Some(device), Some(proc_device)) => device == proc_device,
_ => self.descriptor_is_on_procfs(guest, fd).await,
};
if !on_procfs {
return false;
}
match visible.then(|| std::fs::read_link(&link)) {
Some(Ok(path)) if path.is_absolute() => {
let absent = |path: &Path| {
procfs_name(path).is_some_and(|name| name.absent_at(self.cfg.proc_level))
};
absent(&path)
|| matches!(self.guest_root_in_view(guest), Some(Some(root))
if path.strip_prefix(&root).is_ok_and(|below| {
absent(&Path::new("/").join(below))
}))
}
_ => true,
}
}
pub(crate) async fn recorded_descriptor_is_on_procfs<G: Guest<Self>>(
&self,
guest: &mut G,
fd: RawFd,
) -> bool {
const LENGTH: usize = std::mem::size_of::<libc::statfs>();
let Some(page) = map_transient(guest, LENGTH).await else {
return true;
};
let mut contents = [0u8; LENGTH];
let answered = self
.record_or_replay(
guest,
Syscall::from_raw(
Sysno::fstatfs,
raw_args([fd as usize, page.as_raw(), 0, 0, 0, 0]),
),
)
.await
.is_ok()
&& guest.memory().read_exact(page, &mut contents).is_ok();
unmap_transient(guest, page, LENGTH).await;
answered
&& i64::from_ne_bytes(contents[..8].try_into().expect("8 bytes"))
== libc::PROC_SUPER_MAGIC
}
async fn descriptor_is_on_procfs<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) -> bool {
const LENGTH: usize = std::mem::size_of::<libc::statfs>();
let Some(page) = map_transient(guest, LENGTH).await else {
return false;
};
let mut contents = [0u8; LENGTH];
let answered = guest
.inject(Syscall::from_raw(
Sysno::fstatfs,
raw_args([fd as usize, page.as_raw(), 0, 0, 0, 0]),
))
.await
.is_ok()
&& guest.memory().read_exact(page, &mut contents).is_ok();
unmap_transient(guest, page, LENGTH).await;
answered
&& i64::from_ne_bytes(contents[..8].try_into().expect("8 bytes"))
== libc::PROC_SUPER_MAGIC
}
pub(crate) async fn refused_open_reaches_procfs_name_outside_level<G: Guest<Self>>(
&self,
guest: &mut G,
call: &syscalls::Openat,
) -> bool {
if self.cfg.recordreplay_modes {
return false;
}
let o_path = nix::fcntl::OFlag::O_PATH
| nix::fcntl::OFlag::O_CLOEXEC
| (call.flags() & nix::fcntl::OFlag::O_NOFOLLOW);
let probe = syscalls::Openat::new()
.with_dirfd(call.dirfd())
.with_path(call.path())
.with_flags(o_path);
match Self::inject_translated(guest, Syscall::from(probe)).await {
Ok(fd) => {
let fd = fd as RawFd;
let refused = self.opened_procfs_name_outside_level(guest, fd, None).await;
let _ = guest.inject(syscalls::Close::new().with_fd(fd)).await;
return refused;
}
Err(syscalls::Errno::EACCES | syscalls::Errno::EPERM) => {}
Err(_) => return false,
}
let level = self.cfg.proc_level;
let Some(resolved) = (match self.guest_root_in_view(guest) {
Some(None) => call
.path()
.and_then(|path| path.read(&guest.memory()).ok())
.and_then(|path| Self::observed_path(guest, call.dirfd(), &path).ok())
.filter(|observed| observed.is_absolute())
.and_then(|observed| resolve_links(&observed)),
_ => None,
}) else {
return false;
};
if !procfs_name(&resolved)
.is_some_and(|name| name != ProcfsName::Undecided && name.absent_at(level))
{
return false;
}
let path = resolved.as_os_str().as_bytes();
let Some(page) = map_transient(guest, path.len() + 1).await else {
return false;
};
let mut contents = path.to_vec();
contents.push(0);
let direct = if guest.memory().write_exact(page, &contents).is_ok() {
Self::inject_translated(
guest,
Syscall::from(
syscalls::Openat::new()
.with_dirfd(libc::AT_FDCWD)
.with_path(PathPtr::from_ptr(page.as_raw() as *const libc::c_char))
.with_flags(o_path),
),
)
.await
} else {
Err(syscalls::Errno::EFAULT)
};
unmap_transient(guest, page, path.len() + 1).await;
match direct {
Ok(fd) => {
let _ = guest
.inject(syscalls::Close::new().with_fd(fd as RawFd))
.await;
false
}
Err(error) => matches!(error, syscalls::Errno::EACCES | syscalls::Errno::EPERM),
}
}
}
fn socket_address_path<G: Guest<Detcore<T>>, T: RecordOrReplay>(
guest: &G,
address: usize,
length: usize,
) -> Option<PathBuf> {
if length > std::mem::size_of::<libc::sockaddr_un>() {
return None;
}
let mut bytes = vec![0; length];
guest
.memory()
.read_exact(Addr::<u8>::from_raw(address)?, &mut bytes)
.ok()?;
Some(PathBuf::from(OsStr::from_bytes(unix_address_path(&bytes)?)))
}
#[cfg(test)]
mod tests {
use detcore_model::config::ProcLevel;
use super::*;
#[test]
fn every_path_operand_is_found() {
assert_eq!(
looked_up(Sysno::open),
Some(Lookups::Paths(vec![(None, 0)]))
);
assert_eq!(
looked_up(Sysno::openat),
Some(Lookups::Paths(vec![(Some(0), 1)]))
);
assert_eq!(
looked_up(Sysno::symlinkat),
Some(Lookups::Paths(vec![(Some(1), 2)]))
);
assert_eq!(
looked_up(Sysno::renameat2),
Some(Lookups::Paths(vec![(Some(0), 1), (Some(2), 3)]))
);
assert_eq!(
looked_up(Sysno::sendto),
Some(Lookups::SocketAddress {
address: 4,
length: 5,
send: true
})
);
assert_eq!(looked_up(Sysno::sendmsg), Some(Lookups::MessageAddress));
assert!(looked_up(Sysno::read).is_none());
for refused in [
Sysno::mount,
Sysno::pivot_root,
Sysno::acct,
Sysno::fanotify_mark,
] {
assert!(looked_up(refused).is_none(), "{refused}");
}
}
#[test]
fn a_lookup_fails_at_its_first_absent_component() {
let level = ProcLevel::Standard;
let at = |path: &str| {
absent_prefix(Path::new(path), level).map(|prefix| prefix.display().to_string())
};
assert_eq!(at("/proc/version"), None);
assert_eq!(at("/proc/kallsyms").as_deref(), Some("/proc/kallsyms"));
assert_eq!(at("/proc/./kallsyms").as_deref(), Some("/proc/kallsyms"));
assert_eq!(
at("/proc/sys/crypto/fips_enabled").as_deref(),
Some("/proc/sys/crypto")
);
assert_eq!(at("/proc/sysvipc/shm").as_deref(), Some("/proc/sysvipc"));
assert_eq!(at("/proc/kallsyms/..").as_deref(), Some("/proc/kallsyms"));
assert_eq!(
at("/proc/sysvipc/../version").as_deref(),
Some("/proc/sysvipc")
);
assert_eq!(at("/proc/version/../kallsyms"), None);
assert_eq!(at("/proc/self/../kallsyms"), None);
assert_eq!(at("/proc/net/../status"), None);
assert_eq!(
at("/proc/self/limits").as_deref(),
Some("/proc/self/limits")
);
assert_eq!(
at("/proc/thread-self/attr/current").as_deref(),
Some("/proc/thread-self/attr")
);
assert_eq!(
at("/proc/1/task/1/limits").as_deref(),
Some("/proc/1/task/1/limits")
);
assert_eq!(at("/proc/self/mem"), None);
assert_eq!(at("/proc/1/task/1/uid_map"), None);
assert_eq!(
at("/proc/1/task/1/wchan").as_deref(),
Some("/proc/1/task/1/wchan")
);
assert_eq!(at("/proc/self/status"), None);
assert_eq!(at("/proc/self/task/1/status"), None);
assert_eq!(at("/proc/self/fd/3/x"), None);
assert_eq!(at("/proc/self/root/proc/kallsyms"), None);
assert_eq!(at("/proc/self/cwd/limits"), None);
assert_eq!(
absent_prefix(Path::new("/proc/self/io"), ProcLevel::Minimal),
Some(PathBuf::from("/proc/self/io"))
);
assert_eq!(at("/tmp/x"), None);
assert_eq!(at("proc/kallsyms"), None);
assert_eq!(at(&format!("/proc/{}", "x".repeat(NAME_MAX + 1))), None);
assert_eq!(
at(&format!("/proc/sysvipc/{}", "x".repeat(NAME_MAX + 1))).as_deref(),
Some("/proc/sysvipc")
);
assert_eq!(
absent_prefix(Path::new("/proc/interrupts"), ProcLevel::Minimal),
Some(PathBuf::from("/proc/interrupts"))
);
}
#[test]
fn only_a_pathname_unix_address_names_a_file() {
let mut address = (libc::AF_UNIX as libc::sa_family_t).to_ne_bytes().to_vec();
address.extend_from_slice(b"/proc/kallsyms\0");
assert_eq!(unix_address_path(&address), Some(&b"/proc/kallsyms"[..]));
assert_eq!(
unix_address_path(&address[..address.len() - 1]),
Some(&b"/proc/kallsyms"[..])
);
let mut abstract_address = address.clone();
abstract_address[2] = 0;
assert_eq!(unix_address_path(&abstract_address), None);
assert_eq!(unix_address_path(&address[..2]), None);
let mut inet = address.clone();
inet[..2].copy_from_slice(&(libc::AF_INET as libc::sa_family_t).to_ne_bytes());
assert_eq!(unix_address_path(&inet), None);
assert_eq!(
unix_address(b"/proc/--------")
.as_deref()
.and_then(unix_address_path),
Some(&b"/proc/--------"[..])
);
assert_eq!(unix_address(&[b'-'; SUN_PATH_MAX]), None);
}
#[test]
fn links_resolve_as_the_kernel_resolves_them() {
let directory = tempfile::tempdir().unwrap();
let link = directory.path().join("link");
std::os::unix::fs::symlink("/proc/kallsyms", &link).unwrap();
assert_eq!(resolve_links(&link), Some(PathBuf::from("/proc/kallsyms")));
let relative = directory.path().join("relative");
std::os::unix::fs::symlink("link", &relative).unwrap();
assert_eq!(
resolve_links(&relative),
Some(PathBuf::from("/proc/kallsyms"))
);
assert_eq!(
resolve_links(Path::new("/proc/self/../kallsyms")),
Some(PathBuf::from("/proc/kallsyms"))
);
assert_eq!(
resolve_links(Path::new("/proc/thread-self/../../../sysvipc")),
Some(PathBuf::from("/proc/sysvipc"))
);
assert_eq!(
resolve_links(Path::new("/proc/net/../../kallsyms")),
Some(PathBuf::from("/proc/kallsyms"))
);
assert_eq!(
resolve_links(Path::new("/proc/net/../limits")),
Some(PathBuf::from("/proc/1/limits"))
);
let looped = directory.path().join("loop");
std::os::unix::fs::symlink("loop", &looped).unwrap();
assert_eq!(resolve_links(&looped), None);
}
}