Files
rust-discovery/crates/updater-worker/src/census_process.rs
T
2026-11-15 11:40:53 +01:00

698 lines
24 KiB
Rust

//! Bounded kernel observations only. No command line/environment/key reads and
//! no data from unrelated processes is returned. Not admission by itself.
use anyhow::{Context, Result, ensure};
use rmm_updater_linux::{Budget, files::Identity};
use std::{
ffi::CString,
fs::File,
io::Read,
os::{
fd::{AsRawFd, FromRawFd},
unix::fs::MetadataExt,
},
};
const MAX_PIDS: usize = 16384;
const MAX_FDS: usize = 65536;
const MAX_MAPS: usize = 8 * 1024 * 1024;
const PROC_MAGIC: libc::c_long = 0x9fa0;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct Namespace {
pub device: u64,
pub inode: u64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct Stamp {
pub pid: u32,
pub birth: u64,
pub tgid: u32,
pub uid: u32,
pub gid: u32,
pub image: Option<(u64, u64, i64, i64, i64, i64)>,
pub cgroup: Vec<String>,
pub user_ns: Namespace,
pub pid_ns: Namespace,
pub cgroup_ns: Namespace,
}
pub(crate) struct Process {
pidfd: File,
directory: File,
pub stamp: Stamp,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct Hits {
pub stamp: Stamp,
pub descriptors: Vec<usize>,
pub mappings: Vec<usize>,
pub fd_count: usize,
pub task_cgroups: Vec<String>,
pub map_count: usize,
}
pub(crate) struct Proc {
directory: File,
user_ns: Namespace,
pid_ns: Namespace,
cgroup_ns: Namespace,
}
impl Proc {
pub fn context(&self) -> Result<crate::census::HostContext> {
let meta = self.directory.metadata()?;
Ok(crate::census::HostContext {
proc_device: meta.dev(),
proc_inode: meta.ino(),
user_namespace_device: self.user_ns.device,
user_namespace_inode: self.user_ns.inode,
pid_namespace_device: self.pid_ns.device,
pid_namespace_inode: self.pid_ns.inode,
cgroup_namespace_device: self.cgroup_ns.device,
cgroup_namespace_inode: self.cgroup_ns.inode,
})
}
pub fn open() -> Result<Self> {
ensure!(
unsafe { libc::geteuid() } == 0,
"UPDATE_CENSUS_HOST_ROOT_REQUIRED"
);
let path = CString::new("/proc")?;
let fd = unsafe {
libc::open(
path.as_ptr(),
libc::O_RDONLY | libc::O_DIRECTORY | libc::O_NOFOLLOW | libc::O_CLOEXEC,
)
};
ensure!(fd >= 0, "UPDATE_CENSUS_PROC_OPEN");
let directory = unsafe { File::from_raw_fd(fd) };
let mut info = std::mem::MaybeUninit::<libc::statfs>::zeroed();
ensure!(
unsafe { libc::fstatfs(directory.as_raw_fd(), info.as_mut_ptr()) } == 0
&& unsafe { info.assume_init() }.f_type == PROC_MAGIC,
"UPDATE_CENSUS_PROC_FILESYSTEM"
);
ensure!(
directory.metadata()?.uid() == 0 && directory.metadata()?.mode() & 0o022 == 0,
"UPDATE_CENSUS_PROC_OWNER"
);
let group = open_dir(&directory, &std::process::id().to_string())?;
let tasks = open_dir(&group, "task")?;
let tid = unsafe { libc::syscall(libc::SYS_gettid) };
ensure!(tid > 0, "UPDATE_CENSUS_CURRENT_TASK");
let own = open_dir(&tasks, &tid.to_string())?;
let own_stamp = stamp(&own, u32::try_from(tid)?)?;
ensure!(
own_stamp.tgid == std::process::id() && own_stamp.uid == 0,
"UPDATE_CENSUS_CURRENT_TASK_NOT_HOST_ROOT"
);
let init = open_dir(&directory, "1")?;
let user_ns = namespace(&own, "user")?;
let pid_ns = namespace(&own, "pid")?;
let cgroup_ns = namespace(&own, "cgroup")?;
ensure!(
namespace(&init, "user")? == user_ns && namespace(&init, "pid")? == pid_ns,
"UPDATE_CENSUS_NAMESPACE_NOT_HOST_VIEW"
);
// A hidden/subset proc mount cannot prove a complete PID enumeration.
// Paths are examined only in memory; no mountinfo content is exported.
let raw = read(&own, "mountinfo", 256 * 1024)?;
let text = std::str::from_utf8(&raw)?;
let mut count = 0;
for row in text.lines() {
let (left, right) = row.split_once(" - ").context("UPDATE_CENSUS_MOUNTINFO")?;
let left = left.split_ascii_whitespace().collect::<Vec<_>>();
let right = right.split_ascii_whitespace().collect::<Vec<_>>();
ensure!(
left.len() >= 6 && right.len() >= 3,
"UPDATE_CENSUS_MOUNTINFO"
);
if left[4] == "/proc" {
count += 1;
ensure!(
left[3] == "/"
&& right[0] == "proc"
&& left[5]
.split(',')
.chain(right[2].split(','))
.all(|v| matches!(
v,
"rw" | "ro"
| "nosuid"
| "nodev"
| "noexec"
| "relatime"
| "strictatime"
| "noatime"
| "nodiratime"
| "hidepid=0"
| "hidepid=off"
)),
"UPDATE_CENSUS_HIDDEN_OR_UNKNOWN_PROC_OPTIONS"
);
}
}
ensure!(count == 1, "UPDATE_CENSUS_PROC_MOUNT_AMBIGUOUS");
Ok(Self {
directory,
user_ns,
pid_ns,
cgroup_ns,
})
}
pub fn pids(&self, budget: &Budget) -> Result<Vec<u32>> {
let mut pids = Vec::new();
for entry in std::fs::read_dir(format!(
"/proc/thread-self/fd/{}",
self.directory.as_raw_fd()
))? {
budget.check()?;
let name = entry?.file_name();
let Some(name) = name.to_str() else {
anyhow::bail!("UPDATE_CENSUS_PROC_ENTRY")
};
if name.bytes().all(|v| v.is_ascii_digit()) {
let pid: u32 = name.parse()?;
ensure!(pid > 0 && pids.len() < MAX_PIDS, "UPDATE_CENSUS_PID_LIMIT");
pids.push(pid);
}
}
pids.sort_unstable();
ensure!(
!pids.is_empty() && !pids.windows(2).any(|w| w[0] == w[1]),
"UPDATE_CENSUS_PID_SET"
);
Ok(pids)
}
pub fn process(&self, pid: u32) -> Result<Process> {
ensure!(pid > 0, "UPDATE_CENSUS_PID");
let fd = unsafe { libc::syscall(libc::SYS_pidfd_open, pid, 0) };
ensure!(fd >= 0, "UPDATE_CENSUS_PIDFD_UNAVAILABLE");
let pidfd = unsafe { File::from_raw_fd(fd as i32) };
let directory = open_dir(&self.directory, &pid.to_string())?;
let stamp = stamp(&directory, pid)?;
let result = Process {
pidfd,
directory,
stamp,
};
result.verify()?;
Ok(result)
}
pub fn verify_known_namespace(&self, stamp: &Stamp) -> Result<()> {
ensure!(
stamp.user_ns == self.user_ns
&& stamp.pid_ns == self.pid_ns
&& stamp.cgroup_ns == self.cgroup_ns,
"UPDATE_CENSUS_READER_NAMESPACE_CHANGED"
);
Ok(())
}
}
impl Process {
pub fn verify(&self) -> Result<()> {
let mut poll = libc::pollfd {
fd: self.pidfd.as_raw_fd(),
events: libc::POLLIN,
revents: 0,
};
ensure!(
unsafe { libc::poll(&mut poll, 1, 0) } == 0
&& poll.revents == 0
&& stamp(&self.directory, self.stamp.pid)? == self.stamp,
"UPDATE_CENSUS_PROCESS_CHANGED"
);
Ok(())
}
pub fn inspect(&self, targets: &[Identity], budget: &Budget) -> Result<Hits> {
self.verify()?;
let task_dir = open_dir(&self.directory, "task")?;
let tids = task_ids(&task_dir, budget)?;
let mut held_tasks = Vec::new();
let mut descriptors = Vec::new();
let mut fd_count = 0;
let mut task_cgroups = Vec::new();
for tid in &tids {
self.verify()?;
let directory = open_dir(&task_dir, &tid.to_string())?;
let before = stamp(&directory, *tid)?;
ensure!(
before.tgid == self.stamp.pid,
"UPDATE_CENSUS_TASK_GROUP_CHANGED"
);
let (hits, count) = inspect_fds(&directory, targets, budget)?;
fd_count += count;
ensure!(fd_count <= MAX_FDS, "UPDATE_CENSUS_TOTAL_FD_LIMIT");
if !hits.is_empty() {
ensure!(
before.uid == self.stamp.uid
&& before.gid == self.stamp.gid
&& before.user_ns == self.stamp.user_ns
&& before.pid_ns == self.stamp.pid_ns
&& before.cgroup_ns == self.stamp.cgroup_ns,
"UPDATE_CENSUS_READER_TASK_CONTEXT_CHANGED"
);
}
descriptors.extend(hits);
task_cgroups.extend(before.cgroup.iter().cloned());
ensure!(
stamp(&directory, *tid)? == before,
"UPDATE_CENSUS_TASK_CHANGED"
);
// Retain each actual task directory until the complete probe ends;
// a same-TID replacement cannot substitute a new task directory.
held_tasks.push((directory, before));
}
let raw = read(&self.directory, "maps", MAX_MAPS)?;
let text = std::str::from_utf8(&raw)?;
let mut mappings = Vec::new();
let mut map_count = 0;
for row in text.lines() {
budget.check()?;
map_count += 1;
ensure!(map_count <= 65536, "UPDATE_CENSUS_MAP_LIMIT");
let mut fields = row.split_ascii_whitespace();
for _ in 0..3 {
fields.next().context("UPDATE_CENSUS_MAP_FIELDS")?;
}
let (major, minor) = fields
.next()
.context("UPDATE_CENSUS_MAP_DEVICE")?
.split_once(':')
.context("UPDATE_CENSUS_MAP_DEVICE")?;
let device = libc::makedev(
u32::from_str_radix(major, 16)?,
u32::from_str_radix(minor, 16)?,
);
let inode: u64 = fields.next().context("UPDATE_CENSUS_MAP_INODE")?.parse()?;
if inode != 0 {
for (index, target) in targets.iter().enumerate() {
if device == target.device && inode == target.inode {
mappings.push(index);
}
}
}
}
descriptors.sort_unstable();
descriptors.dedup();
mappings.sort_unstable();
mappings.dedup();
ensure!(
task_ids(&task_dir, budget)? == tids,
"UPDATE_CENSUS_TASK_SET_CHANGED"
);
for (directory, before) in held_tasks {
ensure!(
stamp(&directory, before.pid)? == before,
"UPDATE_CENSUS_TASK_CHANGED"
);
}
task_cgroups.sort();
task_cgroups.dedup();
self.verify()?;
Ok(Hits {
stamp: self.stamp.clone(),
descriptors,
mappings,
fd_count,
task_cgroups,
map_count,
})
}
}
fn inspect_fds(
directory: &File,
targets: &[Identity],
budget: &Budget,
) -> Result<(Vec<usize>, usize)> {
let fd_dir = open_dir(directory, "fd")?;
let mut descriptors = Vec::new();
let mut fd_count = 0;
// Keep read_dir's descriptor alive while inspecting every magic link;
// this also handles enumeration of our own descriptor without a gap.
for entry in std::fs::read_dir(format!("/proc/thread-self/fd/{}", fd_dir.as_raw_fd()))? {
budget.check()?;
fd_count += 1;
ensure!(fd_count <= MAX_FDS, "UPDATE_CENSUS_FD_LIMIT");
let entry = entry?;
let name = entry.file_name();
let name = name.to_str().context("UPDATE_CENSUS_FD_NAME")?;
ensure!(
!name.is_empty() && name.bytes().all(|v| v.is_ascii_digit()),
"UPDATE_CENSUS_FD_NAME"
);
let name = CString::new(name)?;
let mut info = std::mem::MaybeUninit::<libc::stat>::zeroed();
ensure!(
unsafe { libc::fstatat(fd_dir.as_raw_fd(), name.as_ptr(), info.as_mut_ptr(), 0) } == 0,
"UPDATE_CENSUS_INCOMPLETE_FD"
);
let info = unsafe { info.assume_init() };
for (index, target) in targets.iter().enumerate() {
if info.st_dev == target.device && info.st_ino == target.inode {
descriptors.push(index);
}
}
}
Ok((descriptors, fd_count))
}
fn task_ids(directory: &File, budget: &Budget) -> Result<Vec<u32>> {
let mut ids = Vec::new();
for entry in std::fs::read_dir(format!("/proc/thread-self/fd/{}", directory.as_raw_fd()))? {
budget.check()?;
let name = entry?.file_name();
let text = name.to_str().context("UPDATE_CENSUS_TASK_NAME")?;
ensure!(
!text.is_empty() && text.bytes().all(|v| v.is_ascii_digit()) && ids.len() < 4096,
"UPDATE_CENSUS_TASK_LIMIT"
);
ids.push(text.parse()?);
}
ids.sort_unstable();
ensure!(
!ids.is_empty() && !ids.windows(2).any(|w| w[0] == w[1]),
"UPDATE_CENSUS_TASK_SET"
);
Ok(ids)
}
fn open_dir(parent: &File, name: &str) -> Result<File> {
let name = CString::new(name)?;
let fd = unsafe {
libc::openat(
parent.as_raw_fd(),
name.as_ptr(),
libc::O_RDONLY | libc::O_DIRECTORY | libc::O_NOFOLLOW | libc::O_CLOEXEC,
)
};
ensure!(fd >= 0, "UPDATE_CENSUS_DIRECTORY_UNAVAILABLE");
Ok(unsafe { File::from_raw_fd(fd) })
}
fn read(parent: &File, name: &str, max: usize) -> Result<Vec<u8>> {
let name = CString::new(name)?;
let fd = unsafe {
libc::openat(
parent.as_raw_fd(),
name.as_ptr(),
libc::O_RDONLY | libc::O_NOFOLLOW | libc::O_CLOEXEC,
)
};
ensure!(fd >= 0, "UPDATE_CENSUS_PROC_DATA_UNAVAILABLE");
let mut raw = Vec::new();
unsafe { File::from_raw_fd(fd) }
.take((max + 1) as u64)
.read_to_end(&mut raw)?;
ensure!(raw.len() <= max, "UPDATE_CENSUS_PROC_DATA_LIMIT");
Ok(raw)
}
fn namespace(parent: &File, kind: &str) -> Result<Namespace> {
let name = CString::new(format!("ns/{kind}"))?;
let mut info = std::mem::MaybeUninit::<libc::stat>::zeroed();
ensure!(
unsafe { libc::fstatat(parent.as_raw_fd(), name.as_ptr(), info.as_mut_ptr(), 0) } == 0,
"UPDATE_CENSUS_NAMESPACE_UNAVAILABLE"
);
let info = unsafe { info.assume_init() };
Ok(Namespace {
device: info.st_dev,
inode: info.st_ino,
})
}
fn stamp(parent: &File, pid: u32) -> Result<Stamp> {
let raw = read(parent, "stat", 65536)?;
let raw = std::str::from_utf8(&raw)?;
let (_, fields) = raw.rsplit_once(") ").context("UPDATE_CENSUS_STAT")?;
let fields = fields.split_ascii_whitespace().collect::<Vec<_>>();
ensure!(fields.len() >= 20, "UPDATE_CENSUS_STAT");
let birth = fields[19].parse()?;
let flags: u64 = fields[6].parse()?;
let raw = read(parent, "status", 65536)?;
let text = std::str::from_utf8(&raw)?;
let id = |label: &str| -> Result<u32> {
let mut rows = text.lines().filter_map(|r| r.strip_prefix(label));
let row = rows.next().context("UPDATE_CENSUS_CREDENTIALS")?;
ensure!(rows.next().is_none(), "UPDATE_CENSUS_CREDENTIALS");
let fields = row
.split_ascii_whitespace()
.map(str::parse)
.collect::<std::result::Result<Vec<u32>, _>>()?;
ensure!(
fields.len() == 4 && fields.iter().all(|v| *v == fields[0]),
"UPDATE_CENSUS_CHANGING_CREDENTIALS"
);
Ok(fields[0])
};
let uid = id("Uid:")?;
let gid = id("Gid:")?;
let mut tgids = text.lines().filter_map(|r| r.strip_prefix("Tgid:"));
let tgid = tgids
.next()
.context("UPDATE_CENSUS_TASK_GROUP")?
.trim()
.parse()?;
ensure!(tgids.next().is_none(), "UPDATE_CENSUS_TASK_GROUP");
let name = CString::new("exe")?;
let fd = unsafe {
libc::openat(
parent.as_raw_fd(),
name.as_ptr(),
libc::O_PATH | libc::O_CLOEXEC,
)
};
let image = if fd >= 0 {
let file = unsafe { File::from_raw_fd(fd) };
let meta = file.metadata()?;
ensure!(meta.is_file(), "UPDATE_CENSUS_PROCESS_IMAGE");
Some((
meta.dev(),
meta.ino(),
meta.mtime(),
meta.mtime_nsec(),
meta.ctime(),
meta.ctime_nsec(),
))
} else {
ensure!(
std::io::Error::last_os_error().raw_os_error() == Some(libc::ENOENT)
&& flags & 0x0020_0000 != 0,
"UPDATE_CENSUS_PROCESS_IMAGE_UNAVAILABLE"
);
None
};
let raw = read(parent, "cgroup", 65536)?;
let text = std::str::from_utf8(&raw)?;
let mut cgroup = Vec::new();
for line in text.lines() {
let mut fields = line.splitn(3, ':');
fields.next().context("UPDATE_CENSUS_CGROUP")?;
fields.next().context("UPDATE_CENSUS_CGROUP")?;
let path = fields.next().context("UPDATE_CENSUS_CGROUP")?;
// Kernel cgroup paths are compared only as bounded opaque strings;
// they are never used as filesystem paths. Host namespace authority
// comes separately from the protected bootstrap registry.
ensure!(
path.starts_with('/') && path.len() <= 4096,
"UPDATE_CENSUS_CGROUP"
);
cgroup.push(path.to_owned());
}
ensure!(
!cgroup.is_empty() && cgroup.len() <= 64,
"UPDATE_CENSUS_CGROUP"
);
Ok(Stamp {
pid,
birth,
tgid,
uid,
gid,
image,
cgroup,
user_ns: namespace(parent, "user")?,
pid_ns: namespace(parent, "pid")?,
cgroup_ns: namespace(parent, "cgroup")?,
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::{
fs::{self, OpenOptions},
os::unix::fs::OpenOptionsExt,
time::Duration,
};
#[test]
fn private_thread_fd_table_cannot_hide_a_reader_from_the_group_probe() {
assert_eq!(unsafe { libc::geteuid() }, 0);
let path = std::path::Path::new("/run")
.join(format!("rmm-census-thread-{}", uuid::Uuid::new_v4()));
let file = OpenOptions::new()
.read(true)
.write(true)
.create_new(true)
.mode(0o600)
.open(&path)
.unwrap();
struct Cleanup(std::path::PathBuf);
impl Drop for Cleanup {
fn drop(&mut self) {
fs::remove_file(&self.0).unwrap();
}
}
let _cleanup = Cleanup(path.clone());
let meta = file.metadata().unwrap();
let target = Identity {
device: meta.dev(),
inode: meta.ino(),
uid: meta.uid(),
gid: meta.gid(),
mode: meta.mode(),
links: meta.nlink(),
};
let (ready, wait_ready) = std::sync::mpsc::channel();
let (release, wait_release) = std::sync::mpsc::channel();
let thread = std::thread::spawn(move || {
// Only this owned fixture thread separates its descriptor table.
// close_range(UNSHARE) is the same files-table operation without
// Docker's unrelated unshare syscall gate. UINT_MAX cannot name
// an open Linux fd, so no descriptor is closed. No namespace,
// mount, machine policy, seccomp profile or service is changed.
if unsafe {
libc::syscall(
libc::SYS_close_range,
u32::MAX,
u32::MAX,
libc::CLOSE_RANGE_UNSHARE,
)
} != 0
{
ready
.send(Err(std::io::Error::last_os_error().raw_os_error()))
.unwrap();
return;
}
let private = File::open(path).unwrap();
ready.send(Ok(())).unwrap();
let _ = wait_release.recv();
drop(private);
});
struct Thread {
release: Option<std::sync::mpsc::Sender<()>>,
thread: Option<std::thread::JoinHandle<()>>,
}
impl Drop for Thread {
fn drop(&mut self) {
if let Some(tx) = self.release.take() {
let _ = tx.send(());
}
if let Some(thread) = self.thread.take() {
thread.join().unwrap();
}
}
}
let thread = Thread {
release: Some(release),
thread: Some(thread),
};
assert_eq!(
wait_ready.recv().unwrap(),
Ok(()),
"fixture requires close_range private-files-table support"
);
drop(file);
let budget = Budget::new(
fs::read_to_string("/proc/sys/kernel/random/boot_id")
.unwrap()
.trim()
.parse()
.unwrap(),
Duration::from_secs(5),
)
.unwrap();
let proc = Proc::open().unwrap();
let process = proc.process(std::process::id()).unwrap();
// Reproduces the incomplete TGID-only algorithm: no matching FD.
assert!(
inspect_fds(&process.directory, std::slice::from_ref(&target), &budget)
.unwrap()
.0
.is_empty()
);
// The real complete probe must still find the reader's task table.
let hits = process.inspect(&[target], &budget).unwrap();
assert_eq!(hits.descriptors, [0]);
assert!(hits.mappings.is_empty());
drop(thread);
}
#[test]
fn actual_proc_probe_detects_existing_descriptors_and_mapped_inode_without_exporting_paths() {
// An isolated network-none container process, not a host-wide scan,
// service/namespace qualification or admission-positive fixture.
assert_eq!(unsafe { libc::geteuid() }, 0);
let path =
std::path::Path::new("/run").join(format!("rmm-census-probe-{}", uuid::Uuid::new_v4()));
let file = OpenOptions::new()
.read(true)
.write(true)
.create_new(true)
.mode(0o600)
.open(&path)
.unwrap();
file.set_len(4096).unwrap();
struct Cleanup(std::path::PathBuf);
impl Drop for Cleanup {
fn drop(&mut self) {
fs::remove_file(&self.0).unwrap();
}
}
let _cleanup = Cleanup(path);
let meta = file.metadata().unwrap();
let target = Identity {
device: meta.dev(),
inode: meta.ino(),
uid: meta.uid(),
gid: meta.gid(),
mode: meta.mode(),
links: meta.nlink(),
};
let budget = Budget::new(
fs::read_to_string("/proc/sys/kernel/random/boot_id")
.unwrap()
.trim()
.parse()
.unwrap(),
Duration::from_secs(5),
)
.unwrap();
let proc = Proc::open().unwrap();
let process = proc.process(std::process::id()).unwrap();
let before = process
.inspect(std::slice::from_ref(&target), &budget)
.unwrap();
assert_eq!(before.descriptors, [0]);
assert!(before.mappings.is_empty());
let pointer = unsafe {
libc::mmap(
std::ptr::null_mut(),
4096,
libc::PROT_READ,
libc::MAP_PRIVATE,
file.as_raw_fd(),
0,
)
};
assert_ne!(pointer, libc::MAP_FAILED);
struct Mapping(*mut libc::c_void);
impl Drop for Mapping {
fn drop(&mut self) {
assert_eq!(unsafe { libc::munmap(self.0, 4096) }, 0);
}
}
let _mapping = Mapping(pointer);
drop(file);
let mapped = process.inspect(&[target], &budget).unwrap();
assert!(mapped.descriptors.is_empty());
assert_eq!(mapped.mappings, [0]);
assert_eq!(before.stamp, mapped.stamp);
}
}