use crate::profile::{config_dir, ConfigLock, Profile};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::fs;
use std::io::{self, Read, Write};
use std::path::Path;
use uuid::{Uuid, Version};
const POLICY_SCHEMA: u32 = 1;
const POLICY_BYTES_LIMIT: u64 = 16 * 1024;
const POLICY_OVERRIDE_LIMIT: usize = 128;
const POLICY_FILE_NAME: &str = "access-policy.json";
const POLICY_REQUIRED_FILE_NAME: &str = "policy-required";
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct AccessPolicy {
all_read_only: bool,
overrides: BTreeMap<Uuid, bool>,
present: bool,
}
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct StoredPolicy {
schema: u32,
all_read_only: bool,
overrides: BTreeMap<Uuid, bool>,
}
impl AccessPolicy {
pub fn load() -> io::Result<Self> {
Self::load_in(&config_dir())
}
pub fn all_read_only(&self) -> bool {
self.all_read_only
}
pub fn read_only(&self, profile_id: Uuid) -> bool {
self.overrides
.get(&profile_id)
.copied()
.unwrap_or(self.all_read_only)
}
pub(crate) fn requires_profile_marker(&self, profile_id: Uuid) -> bool {
self.all_read_only || self.overrides.contains_key(&profile_id)
}
pub(crate) fn load_locked(lock: &ConfigLock) -> io::Result<Self> {
load_from_directory_checked(lock.directory())
}
pub fn read_only_checked(&self, profile_id: Uuid, policy_required: bool) -> io::Result<bool> {
if policy_required && !self.present {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"this profile requires a read-only policy, but the policy file is missing",
));
}
Ok(self.read_only(profile_id))
}
pub fn set_profile(profile_id: Uuid, read_only: bool) -> io::Result<Self> {
validate_profile_id(profile_id)?;
let lock = ConfigLock::acquire()?;
let mut profile = Profile::load(profile_id)?;
let policy = load_from_directory_checked(lock.directory())?;
if !policy.present && Profile::list()?.iter().any(|(_, _, required)| *required) {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"policy state is missing for protected profiles; recover with `read-only --all`",
));
}
ensure_required_marker(lock.directory())?;
profile.require_policy_locked(&lock)?;
update_directory(lock.directory(), |policy| {
policy.overrides.insert(profile_id, read_only);
})
}
pub fn set_all(read_only: bool) -> io::Result<Self> {
let lock = ConfigLock::acquire()?;
let profile_ids = Profile::list()?
.into_iter()
.map(|(profile_id, _, _)| profile_id)
.collect::<Vec<_>>();
ensure_required_marker(lock.directory())?;
if read_only {
for profile_id in profile_ids {
Profile::load(profile_id)?.require_policy_locked(&lock)?;
}
}
update_directory(lock.directory(), |policy| {
policy.all_read_only = read_only;
policy.overrides.clear();
})
}
fn load_in(directory_path: &Path) -> io::Result<Self> {
let directory = match open_policy_directory(directory_path, false) {
Ok(directory) => directory,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(Self::default()),
Err(error) => return Err(error),
};
load_from_directory_checked(&directory)
}
#[cfg(test)]
fn update_in(
directory_path: &Path,
update: impl FnOnce(&mut AccessPolicy),
) -> io::Result<Self> {
let directory = open_policy_directory(directory_path, true)?;
rustix::fs::flock(
&directory,
rustix::fs::FlockOperation::NonBlockingLockExclusive,
)
.map_err(|error| {
if error == rustix::io::Errno::WOULDBLOCK {
io::Error::new(
io::ErrorKind::WouldBlock,
"another Guth Sync policy update is running",
)
} else {
errno_error(error)
}
})?;
ensure_required_marker(&directory)?;
update_directory(&directory, update)
}
}
fn update_directory(
directory: &fs::File,
update: impl FnOnce(&mut AccessPolicy),
) -> io::Result<AccessPolicy> {
let mut policy = load_from_directory(directory)?;
update(&mut policy);
if policy.overrides.len() > POLICY_OVERRIDE_LIMIT {
return Err(invalid_data("access policy override limit reached"));
}
let stored = StoredPolicy {
schema: POLICY_SCHEMA,
all_read_only: policy.all_read_only,
overrides: policy.overrides.clone(),
};
let mut content = serde_json::to_vec_pretty(&stored)
.map_err(|error| invalid_data(format!("could not encode access policy: {error}")))?;
content.push(b'\n');
if content.len() as u64 > POLICY_BYTES_LIMIT {
return Err(invalid_data("access policy is too large"));
}
let temporary_name = format!(".access-policy.{}.tmp", Uuid::now_v7());
let commit_result = (|| {
let owned_fd = rustix::fs::openat(
directory,
temporary_name.as_str(),
rustix::fs::OFlags::WRONLY
| rustix::fs::OFlags::CREATE
| rustix::fs::OFlags::EXCL
| rustix::fs::OFlags::NOFOLLOW
| rustix::fs::OFlags::CLOEXEC,
rustix::fs::Mode::RUSR | rustix::fs::Mode::WUSR,
)
.map_err(errno_error)?;
let mut file = fs::File::from(owned_fd);
file.write_all(&content)?;
file.sync_all()?;
drop(file);
rustix::fs::renameat(
directory,
temporary_name.as_str(),
directory,
POLICY_FILE_NAME,
)
.map_err(errno_error)
})();
if commit_result.is_err() {
let _ = rustix::fs::unlinkat(
directory,
temporary_name.as_str(),
rustix::fs::AtFlags::empty(),
);
}
commit_result?;
policy.present = true;
if directory.sync_all().is_err() {
let effective = load_from_directory(directory)?;
if effective != policy {
return Err(io::Error::other(
"access policy commit could not be verified",
));
}
}
Ok(policy)
}
fn load_from_directory_checked(directory: &fs::File) -> io::Result<AccessPolicy> {
let policy = load_from_directory(directory)?;
if !policy.present && required_marker_exists(directory)? {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Guth Sync policy is required but the policy file is missing",
));
}
Ok(policy)
}
fn required_marker_exists(directory: &fs::File) -> io::Result<bool> {
let owned_fd = match rustix::fs::openat(
directory,
POLICY_REQUIRED_FILE_NAME,
rustix::fs::OFlags::RDONLY
| rustix::fs::OFlags::CLOEXEC
| rustix::fs::OFlags::NOFOLLOW
| rustix::fs::OFlags::NONBLOCK,
rustix::fs::Mode::empty(),
) {
Ok(file) => file,
Err(rustix::io::Errno::NOENT) => return Ok(false),
Err(error) => return Err(errno_error(error)),
};
let file = fs::File::from(owned_fd);
validate_policy_metadata(&file.metadata()?)?;
Ok(true)
}
fn ensure_required_marker(directory: &fs::File) -> io::Result<()> {
if required_marker_exists(directory)? {
return Ok(());
}
let owned_fd = rustix::fs::openat(
directory,
POLICY_REQUIRED_FILE_NAME,
rustix::fs::OFlags::WRONLY
| rustix::fs::OFlags::CREATE
| rustix::fs::OFlags::EXCL
| rustix::fs::OFlags::NOFOLLOW
| rustix::fs::OFlags::CLOEXEC,
rustix::fs::Mode::RUSR | rustix::fs::Mode::WUSR,
)
.map_err(errno_error)?;
let mut file = fs::File::from(owned_fd);
file.write_all(b"policy-required-v1\n")?;
file.sync_all()?;
directory.sync_all()
}
fn load_from_directory(directory: &fs::File) -> io::Result<AccessPolicy> {
let owned_fd = match rustix::fs::openat(
directory,
POLICY_FILE_NAME,
rustix::fs::OFlags::RDONLY
| rustix::fs::OFlags::CLOEXEC
| rustix::fs::OFlags::NOFOLLOW
| rustix::fs::OFlags::NONBLOCK,
rustix::fs::Mode::empty(),
) {
Ok(file) => file,
Err(rustix::io::Errno::NOENT) => return Ok(AccessPolicy::default()),
Err(error) => return Err(errno_error(error)),
};
let file = fs::File::from(owned_fd);
let metadata = file.metadata()?;
validate_policy_metadata(&metadata)?;
if metadata.len() > POLICY_BYTES_LIMIT {
return Err(invalid_data("access policy is too large"));
}
let mut bytes = Vec::with_capacity(metadata.len() as usize);
file.take(POLICY_BYTES_LIMIT + 1).read_to_end(&mut bytes)?;
let stored: StoredPolicy = serde_json::from_slice(&bytes)
.map_err(|error| invalid_data(format!("invalid access policy: {error}")))?;
if stored.schema != POLICY_SCHEMA || stored.overrides.len() > POLICY_OVERRIDE_LIMIT {
return Err(invalid_data("unsupported access policy"));
}
for profile_id in stored.overrides.keys() {
validate_profile_id(*profile_id)?;
}
Ok(AccessPolicy {
all_read_only: stored.all_read_only,
overrides: stored.overrides,
present: true,
})
}
fn open_policy_directory(path: &Path, create: bool) -> io::Result<fs::File> {
if create {
fs::create_dir_all(path)?;
}
let owned_fd = rustix::fs::open(
path,
rustix::fs::OFlags::RDONLY
| rustix::fs::OFlags::DIRECTORY
| rustix::fs::OFlags::NOFOLLOW
| rustix::fs::OFlags::CLOEXEC,
rustix::fs::Mode::empty(),
)
.map_err(errno_error)?;
let directory = fs::File::from(owned_fd);
#[cfg(unix)]
{
use std::os::unix::fs::MetadataExt;
let metadata = directory.metadata()?;
if !metadata.is_dir() || metadata.uid() != rustix::process::geteuid().as_raw() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"access policy directory has an unexpected owner or type",
));
}
if create {
rustix::fs::fchmod(&directory, rustix::fs::Mode::RWXU).map_err(errno_error)?;
} else if metadata.mode() & 0o077 != 0 {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"access policy directory permissions must be 0700",
));
}
}
Ok(directory)
}
fn validate_policy_metadata(metadata: &fs::Metadata) -> io::Result<()> {
if !metadata.is_file() {
return Err(invalid_data("access policy must be a regular file"));
}
#[cfg(unix)]
{
use std::os::unix::fs::MetadataExt;
if metadata.uid() != rustix::process::geteuid().as_raw()
|| metadata.mode() & 0o077 != 0
|| metadata.nlink() != 1
{
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"access policy must be private and owned by the current user",
));
}
}
Ok(())
}
fn validate_profile_id(id: Uuid) -> io::Result<()> {
if id.get_version() != Some(Version::SortRand) {
return Err(invalid_data(
"access policy contains an invalid profile UUID",
));
}
Ok(())
}
fn errno_error(error: rustix::io::Errno) -> io::Error {
io::Error::from_raw_os_error(error.raw_os_error())
}
fn invalid_data(message: impl Into<String>) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message.into())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn all_policy_and_profile_overrides_round_trip() {
let root = tempfile::tempdir().unwrap();
let first = Uuid::now_v7();
let second = Uuid::now_v7();
let policy = AccessPolicy::update_in(root.path(), |policy| {
policy.all_read_only = true;
policy.overrides.insert(first, false);
})
.unwrap();
assert!(policy.all_read_only());
assert!(!policy.read_only(first));
assert!(policy.read_only(second));
assert_eq!(AccessPolicy::load_in(root.path()).unwrap(), policy);
}
#[test]
fn all_policy_clears_existing_overrides() {
let root = tempfile::tempdir().unwrap();
let profile_id = Uuid::now_v7();
AccessPolicy::update_in(root.path(), |policy| {
policy.overrides.insert(profile_id, true);
})
.unwrap();
let policy = AccessPolicy::update_in(root.path(), |policy| {
policy.all_read_only = false;
policy.overrides.clear();
})
.unwrap();
assert!(!policy.read_only(profile_id));
assert!(policy.overrides.is_empty());
}
#[test]
fn malformed_policy_fails_closed() {
let root = tempfile::tempdir().unwrap();
fs::write(root.path().join(POLICY_FILE_NAME), b"not json").unwrap();
assert!(AccessPolicy::load_in(root.path()).is_err());
}
#[test]
fn missing_policy_fails_closed_for_marked_profiles() {
let profile_id = Uuid::now_v7();
let policy = AccessPolicy::default();
assert_eq!(
policy
.read_only_checked(profile_id, true)
.unwrap_err()
.kind(),
io::ErrorKind::PermissionDenied
);
assert!(!policy.read_only_checked(profile_id, false).unwrap());
}
#[test]
fn required_marker_rejects_a_deleted_policy_file() {
let root = tempfile::tempdir().unwrap();
AccessPolicy::update_in(root.path(), |policy| {
policy.all_read_only = true;
})
.unwrap();
fs::remove_file(root.path().join(POLICY_FILE_NAME)).unwrap();
assert_eq!(
AccessPolicy::load_in(root.path()).unwrap_err().kind(),
io::ErrorKind::PermissionDenied
);
}
}