use std::ffi::CString;
use std::path::Path;
use nix::errno::Errno;
use reverie::Guest;
use reverie::syscalls::Syscall;
use reverie::syscalls::SyscallArgs;
use reverie::syscalls::SyscallInfo;
use reverie::syscalls::Sysno;
use serde::Deserialize;
use serde::Serialize;
use tracing::info;
use crate::fd::FdType;
use crate::procfs::ProcfsFile;
use crate::record_or_replay::RecordOrReplay;
use crate::resources::Device;
use crate::resources::ResourceID;
use crate::tool_local::Detcore;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct FdFacts {
pub ty: FdType,
pub container_stdin: bool,
pub container_output: bool,
pub mode: Option<u32>,
pub safe_snapshot: bool,
pub pseudo_fs: bool,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct Phase1Provenance {
pub pseudo_fs: bool,
pub safe_snapshot: bool,
}
pub(crate) fn kernel_provenance(pid: i32, fd: i32) -> Phase1Provenance {
let link = format!("/proc/{pid}/fd/{fd}");
let resolved = std::fs::read_link(&link)
.ok()
.filter(|path| path.is_absolute());
let mountinfo = std::fs::read_to_string(format!("/proc/{pid}/mountinfo")).ok();
let mount = std::fs::read_to_string(format!("/proc/{pid}/fdinfo/{fd}"))
.ok()
.and_then(|fdinfo| fdinfo_mount_id(&fdinfo))
.and_then(|mount_id| mount_root_and_point(mountinfo.as_deref()?, mount_id));
provenance_from(statfs_type(&link), mount, resolved.as_deref())
}
pub(crate) fn link_is_signalfd(target: &Path) -> bool {
target.as_os_str() == "anon_inode:[signalfd]"
}
pub(crate) fn process_holds_signalfd(pid: i32) -> bool {
let directory = std::path::PathBuf::from(format!("/proc/{pid}/fd"));
crate::util::find_in_directory(&directory, |name| {
std::fs::read_link(directory.join(name))
.is_ok_and(|target| link_is_signalfd(&target))
.then_some(())
})
.map_or(true, |found| found.is_some())
}
fn provenance_from(
fs_type: Option<libc::c_long>,
mount: Option<(&str, &str)>,
resolved: Option<&Path>,
) -> Phase1Provenance {
let sysfs = fs_type == Some(libc::SYSFS_MAGIC);
let pseudo_fs = sysfs || fs_type == Some(libc::PROC_SUPER_MAGIC);
let whole_mount = mount == Some(("/", if sysfs { "/sys" } else { "/proc" }));
let safe_snapshot = pseudo_fs
&& whole_mount
&& resolved.is_some_and(|path| {
ProcfsFile::from_path(path).is_some_and(|file| file.capture_cannot_wait())
|| (sysfs && is_canonical_block_stat(path))
});
Phase1Provenance {
pseudo_fs,
safe_snapshot,
}
}
fn fdinfo_mount_id(fdinfo: &str) -> Option<u64> {
fdinfo
.lines()
.find_map(|line| line.strip_prefix("mnt_id:"))
.and_then(|id| id.trim().parse().ok())
}
fn mount_root_and_point(mountinfo: &str, mount_id: u64) -> Option<(&str, &str)> {
mountinfo.lines().find_map(|line| {
let mut fields = line.split(' ');
let id: u64 = fields.next()?.parse().ok()?;
let _parent = fields.next()?;
let _device = fields.next()?;
let root = fields.next()?;
let point = fields.next()?;
(id == mount_id).then_some((root, point))
})
}
fn statfs_type(path: &str) -> Option<libc::c_long> {
let path = CString::new(path).ok()?;
let mut buf = std::mem::MaybeUninit::<libc::statfs>::uninit();
let rc = unsafe { libc::statfs(path.as_ptr(), buf.as_mut_ptr()) };
(rc == 0).then(|| unsafe { buf.assume_init() }.f_type)
}
fn is_canonical_block_stat(path: &Path) -> bool {
let components: Vec<_> = path.components().collect();
path.starts_with("/sys/devices")
&& matches!(
components.as_slice(),
[.., block, _, stat] if block.as_os_str() == "block" && stat.as_os_str() == "stat"
)
}
pub(crate) const ALWAYS_ALLOWED: &[Sysno] = &[
Sysno::fstat,
Sysno::newfstatat,
#[cfg(not(target_arch = "aarch64"))]
Sysno::access,
Sysno::getdents64,
Sysno::brk,
Sysno::munmap,
Sysno::rt_sigaction,
Sysno::rt_sigreturn,
#[cfg(not(target_arch = "aarch64"))]
Sysno::alarm,
#[cfg(not(target_arch = "aarch64"))]
Sysno::pause,
Sysno::exit_group,
Sysno::faccessat,
Sysno::mmap,
Sysno::mprotect,
Sysno::rt_sigprocmask,
Sysno::setitimer,
Sysno::getitimer,
Sysno::exit,
Sysno::getpid,
Sysno::gettid,
Sysno::getuid,
Sysno::geteuid,
Sysno::getgid,
Sysno::getegid,
Sysno::clock_gettime,
Sysno::clock_getres,
Sysno::gettimeofday,
#[cfg(not(target_arch = "aarch64"))]
Sysno::time,
];
pub(crate) const DESCRIPTOR_IO: &[Sysno] = &[Sysno::read, Sysno::write];
pub(crate) const OPENS: &[Sysno] = &[
#[cfg(not(target_arch = "aarch64"))]
Sysno::open,
Sysno::openat,
#[cfg(not(target_arch = "aarch64"))]
Sysno::creat,
];
pub(crate) const CONDITIONAL: &[Sysno] = &[Sysno::close, Sysno::lseek];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Phase1Class {
Allowed,
Refused(&'static str),
}
pub(crate) fn classify(
sysno: Sysno,
args: &SyscallArgs,
facts: impl FnOnce(i32) -> Option<FdFacts>,
) -> Phase1Class {
if ALWAYS_ALLOWED.contains(&sysno) || OPENS.contains(&sysno) {
return Phase1Class::Allowed;
}
if DESCRIPTOR_IO.contains(&sysno) {
return descriptor_class(sysno == Sysno::write, facts(args.arg0 as i32));
}
if !CONDITIONAL.contains(&sysno) {
return Phase1Class::Refused("a syscall phase 1 has not placed");
}
match sysno {
Sysno::close => close_class(facts(args.arg0 as i32)),
Sysno::lseek => descriptor_class(false, facts(args.arg0 as i32)),
_ => unreachable!("{sysno} is not in CONDITIONAL"),
}
}
pub(crate) fn close_class(facts: Option<FdFacts>) -> Phase1Class {
let Some(facts) = facts else {
return Phase1Class::Refused("closing a descriptor Detcore does not model");
};
if facts.container_stdin || facts.container_output {
return Phase1Class::Refused("closing the container's stdio, which may be a socket");
}
if facts.ty == FdType::Memfd || facts.pseudo_fs {
Phase1Class::Allowed
} else {
Phase1Class::Refused("closing a descriptor whose last close may wait")
}
}
pub(crate) fn open_refused(lookup: Result<libc::stat, reverie::Errno>, nonblocking: bool) -> bool {
match lookup {
Ok(stat) => match stat.st_mode & libc::S_IFMT {
libc::S_IFIFO => !nonblocking,
libc::S_IFCHR | libc::S_IFBLK => true,
_ => false,
},
Err(
reverie::Errno::ENOENT
| reverie::Errno::ENOTDIR
| reverie::Errno::ELOOP
| reverie::Errno::ENAMETOOLONG
| reverie::Errno::EFAULT,
) => false,
Err(_) => true,
}
}
pub(crate) fn descriptor_class(write: bool, facts: Option<FdFacts>) -> Phase1Class {
let Some(facts) = facts else {
return Phase1Class::Refused("I/O on a descriptor Detcore does not model");
};
if facts.container_output && write {
return Phase1Class::Allowed;
}
if facts.container_stdin || facts.container_output {
return Phase1Class::Refused("I/O on the container's stdio that may wait");
}
match facts.ty {
FdType::Memfd => Phase1Class::Allowed,
FdType::Regular if facts.safe_snapshot => Phase1Class::Allowed,
_ => Phase1Class::Refused("I/O on a descriptor that may sleep interruptibly"),
}
}
pub(crate) fn is_container_output(resource: &ResourceID) -> bool {
matches!(
resource,
ResourceID::Device(Device::ContainerStdout | Device::ContainerStderr)
)
}
impl<T: RecordOrReplay> Detcore<T> {
pub(crate) fn sigalrm_phase1_gate<G: Guest<Self>>(
&self,
guest: &G,
call: Syscall,
) -> Option<Errno> {
let (sysno, args) = call.into_parts();
let class = classify(sysno, &args, |fd| {
guest
.thread_state()
.with_detfd(fd, |detfd| FdFacts {
ty: if detfd.procfs_rendered_path().is_some() {
FdType::Memfd
} else {
detfd.ty()
},
container_stdin: matches!(
detfd.resource(),
Some(ResourceID::Device(Device::ContainerStdin))
),
container_output: detfd.resource().as_ref().is_some_and(is_container_output),
mode: detfd.stat().map(|stat| stat.mode),
safe_snapshot: detfd.procfs_serves_snapshot()
&& detfd.procfs_capture_cannot_wait()
&& detfd
.sigalrm_phase1_provenance()
.is_some_and(|provenance| provenance.safe_snapshot),
pseudo_fs: detfd
.sigalrm_phase1_provenance()
.is_some_and(|provenance| provenance.pseudo_fs),
})
.ok()
});
let Phase1Class::Refused(why) = class else {
return None;
};
info!(
"[dtid {}] {} refused (EOPNOTSUPP) in a process that handles SIGALRM: {} (signal phase 1).",
guest.thread_state().dettid,
sysno,
why
);
Some(Errno::EOPNOTSUPP)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::syscall_classification::all_pinned_syscalls;
fn args(values: [usize; 6]) -> SyscallArgs {
SyscallArgs::new(
values[0], values[1], values[2], values[3], values[4], values[5],
)
}
fn no_fd(_: i32) -> Option<FdFacts> {
None
}
fn names(list: &[Sysno]) -> Vec<&'static str> {
let mut names: Vec<_> = list.iter().map(|sysno| sysno.name()).collect();
names.sort_unstable();
names
}
#[test]
fn a_signalfd_in_the_kernels_table_is_found() {
use std::os::fd::FromRawFd;
use std::os::fd::OwnedFd;
assert!(link_is_signalfd(Path::new("anon_inode:[signalfd]")));
assert!(!link_is_signalfd(Path::new("anon_inode:[eventfd]")));
assert!(!link_is_signalfd(Path::new("/dev/null")));
let pid = std::process::id() as i32;
let mut mask: libc::sigset_t = unsafe { std::mem::zeroed() };
unsafe { libc::sigemptyset(&mut mask) };
unsafe { libc::sigaddset(&mut mask, libc::SIGUSR2) };
let raw = unsafe { libc::signalfd(-1, &mask, libc::SFD_CLOEXEC) };
assert!(raw >= 0);
let signalfd = unsafe { OwnedFd::from_raw_fd(raw) };
assert!(process_holds_signalfd(pid));
drop(signalfd);
assert!(process_holds_signalfd(-1));
}
#[cfg(target_arch = "x86_64")]
#[test]
fn the_sigalrm_phase1_table_admits_exactly_its_pinned_members() {
assert_eq!(
names(ALWAYS_ALLOWED),
[
"access",
"alarm",
"brk",
"clock_getres",
"clock_gettime",
"exit",
"exit_group",
"faccessat",
"fstat",
"getdents64",
"getegid",
"geteuid",
"getgid",
"getitimer",
"getpid",
"gettid",
"gettimeofday",
"getuid",
"mmap",
"mprotect",
"munmap",
"newfstatat",
"pause",
"rt_sigaction",
"rt_sigprocmask",
"rt_sigreturn",
"setitimer",
"time",
]
);
assert_eq!(names(DESCRIPTOR_IO), ["read", "write"]);
assert_eq!(names(OPENS), ["creat", "open", "openat"]);
assert_eq!(names(CONDITIONAL), ["close", "lseek"]);
let placed: Vec<Sysno> = [ALWAYS_ALLOWED, DESCRIPTOR_IO, OPENS, CONDITIONAL].concat();
let mut refused = 0;
for sysno in all_pinned_syscalls() {
if placed.contains(&sysno) {
continue;
}
assert_eq!(
classify(sysno, &args([0; 6]), no_fd),
Phase1Class::Refused("a syscall phase 1 has not placed"),
"{sysno}"
);
refused += 1;
}
assert_eq!(refused + placed.len(), all_pinned_syscalls().count());
}
#[cfg(target_arch = "x86_64")]
#[test]
fn sigalrm_phase1_scalar_identity_keeps_neighboring_refusals() {
for sysno in [Sysno::getuid, Sysno::geteuid, Sysno::getgid, Sysno::getegid] {
assert_eq!(
classify(sysno, &args([0; 6]), |_| panic!(
"no descriptor for {sysno}"
)),
Phase1Class::Allowed,
"{sysno}"
);
}
for sysno in [
Sysno::getresuid,
Sysno::getresgid,
Sysno::getgroups,
Sysno::getppid,
Sysno::getpgrp,
Sysno::getpgid,
Sysno::getsid,
Sysno::uname,
Sysno::getrandom,
Sysno::stat,
Sysno::lstat,
Sysno::statx,
Sysno::readlink,
Sysno::readlinkat,
] {
assert_eq!(
classify(sysno, &args([0; 6]), |_| panic!(
"no descriptor for {sysno}"
)),
Phase1Class::Refused("a syscall phase 1 has not placed"),
"{sysno}"
);
}
}
#[test]
#[allow(clippy::disallowed_methods)] fn sigalrm_phase1_provenance_comes_from_the_kernel() {
use std::os::fd::AsRawFd;
let pid = std::process::id() as i32;
let uptime = std::fs::File::open("/proc/uptime").unwrap();
assert_eq!(
kernel_provenance(pid, uptime.as_raw_fd()),
Phase1Provenance {
pseudo_fs: true,
safe_snapshot: true,
}
);
let dir = std::env::temp_dir().join(format!("sigalrm-phase1-{pid}"));
let inner = dir.join("p/q");
std::fs::create_dir_all(&inner).unwrap();
let ordinary = std::fs::File::create(dir.join("ordinary")).unwrap();
assert_eq!(
kernel_provenance(pid, ordinary.as_raw_fd()),
Phase1Provenance::default()
);
std::os::unix::fs::symlink("/proc/meminfo", dir.join("schedstat")).unwrap();
let held = std::fs::File::open(&inner).unwrap();
let alias = format!("/proc/self/fd/{}/../../schedstat", held.as_raw_fd());
let aliased = std::fs::File::open(&alias).unwrap();
assert_eq!(
kernel_provenance(pid, aliased.as_raw_fd()),
Phase1Provenance {
pseudo_fs: true,
safe_snapshot: false,
}
);
std::fs::remove_dir_all(&dir).unwrap();
if let Some(disk) =
crate::util::find_in_directory(std::path::Path::new("/sys/block"), |name| {
Some(std::path::Path::new("/sys/block").join(name))
})
.ok()
.flatten()
{
let stat = std::fs::File::open(disk.join("stat")).unwrap();
assert!(kernel_provenance(pid, stat.as_raw_fd()).safe_snapshot);
}
}
#[test]
fn sigalrm_phase1_mount_provenance_parses_fdinfo_and_mountinfo() {
assert_eq!(
fdinfo_mount_id("pos:\t0\nflags:\t0100000\nmnt_id:\t15570\nino:\t4026\n"),
Some(15570)
);
assert_eq!(fdinfo_mount_id("pos:\t0\n"), None);
let mountinfo = "\
15522 1 253:1 / / rw,relatime shared:1 - xfs /dev/root rw
15532 15522 0:23 / /sys rw,nosuid,nodev,noexec,relatime shared:5 - sysfs sysfs rw
15570 15522 0:22 / /proc rw,nosuid,nodev,noexec,relatime shared:12 - proc proc rw
15601 15570 0:22 /driver/rtc /proc/uptime rw,relatime shared:12 - proc proc rw
";
assert_eq!(mount_root_and_point(mountinfo, 15570), Some(("/", "/proc")));
assert_eq!(mount_root_and_point(mountinfo, 15532), Some(("/", "/sys")));
assert_eq!(
mount_root_and_point(mountinfo, 15601),
Some(("/driver/rtc", "/proc/uptime"))
);
assert_eq!(mount_root_and_point(mountinfo, 9), None);
let proc = Some(libc::PROC_SUPER_MAGIC);
let uptime = Some(Path::new("/proc/uptime"));
assert!(provenance_from(proc, Some(("/", "/proc")), uptime).safe_snapshot);
let bound = provenance_from(proc, Some(("/driver/rtc", "/proc/uptime")), uptime);
assert!(bound.pseudo_fs && !bound.safe_snapshot);
assert!(!provenance_from(proc, Some(("/", "/mnt/proc")), uptime).safe_snapshot);
assert!(!provenance_from(proc, None, uptime).safe_snapshot);
let sysfs = Some(libc::SYSFS_MAGIC);
let disk = Some(Path::new(
"/sys/devices/pci0000:00/0000:00:1f.2/block/sda/stat",
));
assert!(provenance_from(sysfs, Some(("/", "/sys")), disk).safe_snapshot);
assert!(
!provenance_from(sysfs, Some(("/class/rtc/rtc0", "/sys/devices")), disk).safe_snapshot
);
}
#[test]
fn sigalrm_phase1_safe_snapshots_are_the_cells_files() {
use std::path::Path;
use crate::procfs::ProcfsFile;
let safe = |path: &str| {
ProcfsFile::from_path(Path::new(path)).map(|file| file.capture_cannot_wait())
};
for cells_file in [
"/proc/uptime",
"/proc/stat",
"/proc/softirqs",
"/proc/1/stat",
"/proc/1/status",
"/proc/1/schedstat",
"/sys/block/sda/stat",
] {
assert_eq!(safe(cells_file), Some(true), "{cells_file}");
}
for waits in ["/proc/driver/rtc", "/sys/class/rtc/rtc0/time"] {
assert_eq!(safe(waits), Some(false), "{waits}");
}
assert_eq!(safe("/proc/kmsg"), None);
}
#[test]
fn sigalrm_phase1_descriptor_and_argument_conditions() {
let facts = |ty, stdio: Option<Device>, mode, safe_snapshot| {
Some(FdFacts {
ty,
container_stdin: matches!(stdio, Some(Device::ContainerStdin)),
container_output: matches!(
stdio,
Some(Device::ContainerStdout | Device::ContainerStderr)
),
mode,
safe_snapshot,
pseudo_fs: safe_snapshot,
})
};
let on_pseudo_fs = |stdio: Option<Device>, mode| {
Some(FdFacts {
ty: FdType::Regular,
container_stdin: matches!(stdio, Some(Device::ContainerStdin)),
container_output: matches!(
stdio,
Some(Device::ContainerStdout | Device::ContainerStderr)
),
mode,
safe_snapshot: false,
pseudo_fs: true,
})
};
let reg = Some(libc::S_IFREG | 0o644);
let dir = Some(libc::S_IFDIR | 0o755);
let chr = Some(libc::S_IFCHR | 0o666);
for (case, write, allowed) in [
(facts(FdType::Memfd, None, None, false), true, true),
(facts(FdType::Regular, None, reg, true), false, true),
(facts(FdType::Regular, None, reg, false), false, false),
(facts(FdType::Regular, None, dir, false), false, false),
(facts(FdType::Regular, None, chr, false), true, false),
(facts(FdType::Regular, None, None, false), false, false),
(facts(FdType::Pipe, None, None, false), false, false),
(facts(FdType::Socket, None, None, false), true, false),
(facts(FdType::Signalfd, None, None, false), false, false),
(facts(FdType::Eventfd, None, None, false), false, false),
(facts(FdType::Timerfd, None, None, false), false, false),
(facts(FdType::Inotify, None, None, false), false, false),
(facts(FdType::Userfaultfd, None, None, false), false, false),
(facts(FdType::Pidfd, None, None, false), false, false),
(facts(FdType::Epoll, None, None, false), false, false),
(
facts(FdType::Regular, Some(Device::ContainerStdout), None, false),
true,
true,
),
(
facts(FdType::Regular, Some(Device::ContainerStderr), None, false),
true,
true,
),
(
facts(FdType::Regular, Some(Device::ContainerStdout), reg, true),
false,
false,
),
(
facts(FdType::Regular, Some(Device::ContainerStdin), reg, true),
false,
false,
),
(None, true, false),
] {
let class = descriptor_class(write, case);
assert_eq!(
class == Phase1Class::Allowed,
allowed,
"{case:?} write={write}: {class:?}"
);
}
let class = |sysno, values, fd| classify(sysno, &args(values), move |_| fd);
assert!(matches!(
class(
Sysno::read,
[7, 0, 0, 0, 0, 0],
facts(FdType::Signalfd, None, None, false)
),
Phase1Class::Refused(_)
));
assert_eq!(
class(
Sysno::lseek,
[3, 1, 0, 0, 0, 0],
facts(FdType::Regular, None, reg, true)
),
Phase1Class::Allowed
);
assert!(matches!(
class(
Sysno::lseek,
[3, 1, 0, 0, 0, 0],
facts(FdType::Regular, None, reg, false)
),
Phase1Class::Refused(_)
));
for (case, allowed) in [
(facts(FdType::Memfd, None, None, false), true),
(on_pseudo_fs(None, reg), true),
(on_pseudo_fs(None, dir), true),
(facts(FdType::Regular, None, reg, true), true),
(facts(FdType::Regular, None, reg, false), false),
(facts(FdType::Regular, None, dir, false), false),
(facts(FdType::Regular, None, chr, false), false),
(facts(FdType::Regular, None, None, false), false),
(on_pseudo_fs(Some(Device::ContainerStdout), reg), false),
(on_pseudo_fs(Some(Device::ContainerStdin), reg), false),
(facts(FdType::Socket, None, None, false), false),
(facts(FdType::Pipe, None, None, false), false),
(None, false),
] {
assert_eq!(
close_class(case) == Phase1Class::Allowed,
allowed,
"{case:?}"
);
}
for request in [
libc::TCGETS,
libc::TIOCGWINSZ,
libc::TCSETSW,
libc::TCSETSF,
libc::TCSBRK,
libc::FIONREAD,
] {
assert_eq!(
class(Sysno::ioctl, [1, request as usize, 0, 0, 0, 0], None),
Phase1Class::Refused("a syscall phase 1 has not placed"),
"{request:#x}"
);
}
let stat_with = |mode| {
let mut stat: libc::stat = unsafe { std::mem::zeroed() };
stat.st_mode = mode;
stat
};
for nonblocking in [false, true] {
for device in [libc::S_IFCHR, libc::S_IFBLK] {
assert!(open_refused(Ok(stat_with(device | 0o666)), nonblocking));
}
for never in [libc::S_IFREG, libc::S_IFDIR, libc::S_IFSOCK] {
assert!(!open_refused(Ok(stat_with(never | 0o644)), nonblocking));
}
}
assert!(open_refused(Ok(stat_with(libc::S_IFIFO | 0o644)), false));
assert!(!open_refused(Ok(stat_with(libc::S_IFIFO | 0o644)), true));
for passes in [
reverie::Errno::ENOENT,
reverie::Errno::ENOTDIR,
reverie::Errno::ELOOP,
reverie::Errno::ENAMETOOLONG,
reverie::Errno::EFAULT,
] {
assert!(!open_refused(Err(passes), false), "{passes}");
}
for unknown in [
reverie::Errno::EACCES,
reverie::Errno::ENOMEM,
reverie::Errno::EINTR,
reverie::Errno::EIO,
reverie::Errno::EOVERFLOW,
] {
assert!(open_refused(Err(unknown), false), "{unknown}");
}
assert!(is_container_output(&ResourceID::Device(
Device::ContainerStdout
)));
assert!(is_container_output(&ResourceID::Device(
Device::ContainerStderr
)));
assert!(!is_container_output(&ResourceID::Device(
Device::ContainerStdin
)));
}
}