use std::sync::OnceLock;
use anyhow::Context;
use hermit::Error;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct HostSeccomp {
pub(crate) mode: u32,
pub(crate) filters: Option<u32>,
}
impl HostSeccomp {
pub(crate) fn from_status(status: &str) -> Result<Option<HostSeccomp>, Error> {
let field = |name: &str| -> Result<Option<u32>, Error> {
status
.lines()
.find_map(|line| line.strip_prefix(name)?.strip_prefix(':'))
.map(|value| {
value.trim().parse::<u32>().with_context(|| {
format!("the {name} field of /proc/self/status is not a number: {value:?}")
})
})
.transpose()
};
let mode = field("Seccomp")?;
let filters = field("Seccomp_filters")?;
Ok(match mode {
None | Some(0) => None,
Some(mode) => Some(HostSeccomp { mode, filters }),
})
}
fn read() -> Result<Option<HostSeccomp>, Error> {
let status = std::fs::read_to_string("/proc/self/status")
.context("cannot read /proc/self/status to check for an inherited seccomp filter")?;
Self::from_status(&status)
}
pub(crate) fn describe(&self) -> String {
let mode = match self.mode {
1 => " (strict mode)",
2 => " (filter mode)",
_ => "",
};
let filters = match self.filters {
Some(filters) => format!(", Seccomp_filters: {filters}"),
None => String::new(),
};
format!("Seccomp: {}{mode}{filters}", self.mode)
}
}
static UNVERIFIED: OnceLock<HostSeccomp> = OnceLock::new();
pub(crate) fn unverified() -> Option<HostSeccomp> {
UNVERIFIED.get().copied()
}
pub(crate) fn admit(unsafe_ignore: bool) -> Result<(), Error> {
if let Some(host) = decide(HostSeccomp::read()?, unsafe_ignore)? {
crate::tracing::write_stderr_diagnostic(&format!(
"WARNING: --unsafe-ignore-host-seccomp: hermit is starting the guest under a seccomp \
filter it inherited ({}). Hermit neither records nor enforces that filter, so this \
run may not reproduce wherever the filter differs, for example on a host without \
it.\n",
host.describe()
));
let _ = UNVERIFIED.set(host);
}
Ok(())
}
fn decide(host: Option<HostSeccomp>, unsafe_ignore: bool) -> Result<Option<HostSeccomp>, Error> {
match host {
None => Ok(None),
Some(host) if unsafe_ignore => Ok(Some(host)),
Some(host) => Err(Error::new(crate::container::PolicyRefusal).context(format!(
"hermit inherited a seccomp filter ({}) from whatever launched it, for example a \
container runtime's default profile, and refuses to start the guest. The filter is \
an input hermit does not record: it can make system calls fail in ways the guest \
observes, so the run would not reproduce wherever the filter differs. Run hermit \
where no filter is inherited; a filter cannot be removed from inside a running \
container, so for Docker create the container with \
`--security-opt seccomp=unconfined`. Or accept a run that may not reproduce by \
passing --unsafe-ignore-host-seccomp (in a run config: \
`global: {{unsafe-ignore-host-seccomp: true}}`).",
host.describe()
))),
}
}
#[cfg(test)]
mod tests {
use super::*;
const STATUS: &str = "Name:\thermit\nNoNewPrivs:\t1\nSeccomp:\t2\nSeccomp_filters:\t3\n";
#[test]
fn the_status_fields_are_read() {
assert_eq!(
HostSeccomp::from_status(STATUS).unwrap(),
Some(HostSeccomp {
mode: 2,
filters: Some(3)
})
);
assert_eq!(
HostSeccomp::from_status("Seccomp:\t0\nSeccomp_filters:\t0\n").unwrap(),
None
);
assert_eq!(HostSeccomp::from_status("Name:\thermit\n").unwrap(), None);
assert_eq!(
HostSeccomp::from_status("Seccomp:\t1\n").unwrap(),
Some(HostSeccomp {
mode: 1,
filters: None
})
);
let error = HostSeccomp::from_status("Seccomp:\tfilter\n").unwrap_err();
assert!(format!("{error:#}").contains("not a number"), "{error:#}");
}
#[test]
fn an_inherited_filter_is_a_policy_refusal_that_names_the_remedies() {
let host = HostSeccomp::from_status(STATUS).unwrap();
let error = decide(host, false).unwrap_err();
assert!(
error.root_cause().is::<crate::container::PolicyRefusal>(),
"{error:#}"
);
let message = format!("{error:#}");
for expected in [
"Seccomp: 2 (filter mode), Seccomp_filters: 3",
"an input hermit does not record",
"--security-opt seccomp=unconfined",
"--unsafe-ignore-host-seccomp",
"global: {unsafe-ignore-host-seccomp: true}",
] {
assert!(message.contains(expected), "{expected:?} in {message}");
}
}
#[test]
fn the_unsafe_override_admits_and_reports_the_filter() {
let host = HostSeccomp::from_status(STATUS).unwrap();
assert_eq!(decide(host, true).unwrap(), host);
assert_eq!(decide(None, false).unwrap(), None);
assert_eq!(decide(None, true).unwrap(), None);
}
}