use std::path::{Path, PathBuf};
#[cfg(unix)]
use super::paths::absolutize;
pub(super) fn events_db_targets(db_path: &Path) -> [PathBuf; 3] {
["", "-wal", "-shm"].map(|suffix| {
let mut name = db_path.as_os_str().to_os_string();
name.push(suffix);
PathBuf::from(name)
})
}
pub(super) fn refuse_events_db_symlinks(db_path: &Path) -> anyhow::Result<()> {
for path in events_db_targets(db_path) {
match std::fs::symlink_metadata(&path) {
Ok(meta) if meta.file_type().is_symlink() => anyhow::bail!(
"refusing to serve events: {} is a symlink; the events database and its \
sidecars must be regular files",
path.display()
),
Ok(_) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => anyhow::bail!(
"refusing to serve events: cannot inspect {}: {e}",
path.display()
),
}
}
Ok(())
}
#[cfg(unix)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct EventsFileIdentity {
pub(super) device: u64,
pub(super) inode: u64,
}
#[cfg(unix)]
impl EventsFileIdentity {
pub(super) fn from_metadata(metadata: &std::fs::Metadata) -> Self {
use std::os::unix::fs::MetadataExt;
Self {
device: metadata.dev(),
inode: metadata.ino(),
}
}
}
#[cfg(unix)]
pub(super) type EventsDbIdentities = [Option<EventsFileIdentity>; 3];
#[cfg(unix)]
pub(super) fn ensure_events_db_parent_trusted(db_path: &Path) -> anyhow::Result<()> {
let db_path = absolutize(db_path);
let parent = db_path.parent().filter(|p| !p.as_os_str().is_empty());
match parent {
Some(dir) => crate::daemon::ensure_store_dir_is_trusted(dir, &db_path).map_err(|e| {
anyhow::anyhow!("refusing to serve events from an untrusted directory: {e}")
}),
None => Ok(()),
}
}
#[cfg(unix)]
pub(super) fn ensure_events_db_owner_only(db_path: &Path) -> anyhow::Result<()> {
use std::os::unix::fs::OpenOptionsExt;
refuse_events_db_symlinks(db_path)?;
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent)?;
}
ensure_events_db_parent_trusted(db_path)?;
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(db_path)
{
Ok(_created) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(()),
Err(e) => Err(anyhow::anyhow!(
"refusing to serve events: cannot create {} owner-only: {e}",
db_path.display()
)),
}
}
#[cfg(unix)]
pub(super) fn harden_events_db_sidecars(db_path: &Path) -> anyhow::Result<EventsDbIdentities> {
use khive_fs::opened_file::ContainedOpenError;
use std::os::unix::fs::PermissionsExt;
let mut identities = [None; 3];
for (index, path) in events_db_targets(db_path).into_iter().enumerate() {
let file = match khive_fs::opened_file::open_regular_file_nofollow(&path) {
Ok(file) => file,
Err(ContainedOpenError::Open(e)) if e.kind() == std::io::ErrorKind::NotFound => {
continue;
}
Err(ContainedOpenError::Open(e)) => anyhow::bail!(
"refusing to serve events: cannot open {} without following symlinks: \
{e}. The events database and its sidecars must be regular files.",
path.display()
),
Err(ContainedOpenError::Metadata(e)) => return Err(e.into()),
Err(_) => anyhow::bail!(
"refusing to serve events: {} is not a regular file. The events \
database and its sidecars must be regular files.",
path.display()
),
};
let metadata = file.metadata()?;
if !metadata.file_type().is_file() {
anyhow::bail!(
"refusing to serve events: {} is not a regular file. The events \
database and its sidecars must be regular files.",
path.display()
);
}
file.set_permissions(std::fs::Permissions::from_mode(0o600))
.map_err(|e| {
anyhow::anyhow!(
"refusing to serve events: cannot chmod 0600 {}: {e}. The events \
database and its sidecars must be owner-only.",
path.display()
)
})?;
identities[index] = Some(EventsFileIdentity::from_metadata(&metadata));
}
Ok(identities)
}
#[cfg(unix)]
pub(super) fn verify_events_db_owner_only_unopened(
db_path: &Path,
before: &EventsDbIdentities,
) -> anyhow::Result<()> {
use std::os::unix::fs::PermissionsExt;
for (index, path) in events_db_targets(db_path).into_iter().enumerate() {
let metadata = match std::fs::symlink_metadata(&path) {
Ok(metadata) => metadata,
Err(e) if e.kind() == std::io::ErrorKind::NotFound && index != 0 => continue,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => anyhow::bail!(
"refusing to serve events: main database {} disappeared after SQLite open; \
refusing to serve an unlinked database",
path.display()
),
Err(e) => {
anyhow::bail!(
"refusing to serve events: cannot stat {}: {e}",
path.display()
)
}
};
if !metadata.file_type().is_file() {
anyhow::bail!(
"refusing to serve events: {} is not a regular file. The events database \
and its sidecars must be regular files.",
path.display()
);
}
let mode = metadata.permissions().mode() & 0o777;
if mode & 0o077 != 0 {
anyhow::bail!(
"refusing to serve events: {} is mode {mode:03o}, not owner-only. The events \
database and its sidecars must be owner-only.",
path.display()
);
}
if before[index]
.is_some_and(|identity| identity != EventsFileIdentity::from_metadata(&metadata))
{
anyhow::bail!(
"refusing to serve events: {} changed identity between pre-open hardening \
and post-open verification",
path.display()
);
}
}
Ok(())
}