pub use crate::glob::FileRulePattern;
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Policy {
pub items: Vec<PolicyItem>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum PolicyItem {
Variable(VariableAssignment),
Alias(AliasRule),
Include(IncludeRule),
Abi(AbiRule),
Profile(Profile),
Raw(RawItem),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VariableAssignment {
pub name: String,
pub append: bool,
pub values: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AliasRule {
pub oldname: String,
pub newname: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IncludeRule {
pub if_exists: bool,
pub magic: bool,
pub path: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AbiRule {
pub magic: bool,
pub path: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Profile {
pub name: String,
pub attachment: Option<FileRulePattern>,
pub flags: Vec<Flag>,
pub variables: Vec<VariableAssignment>,
pub includes: Vec<IncludeRule>,
pub aliases: Vec<AliasRule>,
pub rules: Vec<Rule>,
pub hats: Vec<Hat>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Hat {
pub is_subprofile: bool,
pub name: String,
pub attachment: Option<FileRulePattern>,
pub flags: Vec<Flag>,
pub variables: Vec<VariableAssignment>,
pub includes: Vec<IncludeRule>,
pub aliases: Vec<AliasRule>,
pub rules: Vec<Rule>,
pub hats: Vec<Hat>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Flag {
pub name: String,
pub value: Option<String>,
}
impl Flag {
pub fn new(name: impl Into<String>) -> Self {
Flag {
name: name.into(),
value: None,
}
}
pub fn with_value(name: impl Into<String>, value: impl Into<String>) -> Self {
Flag {
name: name.into(),
value: Some(value.into()),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Rule {
File(FileRule),
Capability(CapabilityRule),
Network(NetworkRule),
Mount(MountRule),
PivotRoot(PivotRootRule),
Link(LinkRule),
ChangeProfile(ChangeProfileRule),
Rlimit(RlimitRule),
Dbus(DbusRule),
Unix(UnixRule),
Mqueue(MqueueRule),
Userns(UsernsRule),
IoUring(IoUringRule),
Signal(SignalRule),
Ptrace(PtraceRule),
All(AllRule),
Raw(RawRule),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Qualifiers {
pub priority: Option<u64>,
pub audit: bool,
pub deny: bool,
pub allow: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FileRule {
pub qualifiers: Qualifiers,
pub owner: bool,
pub group: Option<String>,
pub path: Option<FileRulePattern>,
pub access: Vec<FileAccess>,
pub exec_target: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum FileAccess {
Read,
Write,
Append,
Link,
Lock,
MemoryMap,
Exec(ExecTransition),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ExecTransition {
Inherit,
Unconstrained,
UnconstrainedSafe,
Profile,
ProfileSafe,
Child,
ChildSafe,
ProfileInherit,
ProfileInheritSafe,
ChildInherit,
ChildInheritSafe,
ProfileUnconstrained,
ProfileUnconstrainedSafe,
ChildUnconstrained,
ChildUnconstrainedSafe,
BareX,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CapabilityRule {
pub qualifiers: Qualifiers,
pub capabilities: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum NetworkAccess {
Create,
Bind,
Listen,
Accept,
Connect,
Shutdown,
GetAttr,
SetAttr,
GetOpt,
SetOpt,
Send,
Receive,
Read,
Write,
ReadWrite,
Other(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NetworkRule {
pub qualifiers: Qualifiers,
pub access: Vec<NetworkAccess>,
pub domain: Option<String>,
pub network_type: Option<String>,
pub protocol: Option<String>,
pub conditions: Vec<(String, String)>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MountRule {
pub qualifiers: Qualifiers,
pub operation: MountOp,
pub fstype: Option<ValueCondition>,
pub options: Option<ValueCondition>,
pub source: Option<FileRulePattern>,
pub mount_point: Option<FileRulePattern>,
pub target: Option<ProfileTarget>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum MountOp {
Mount,
Remount,
Umount,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ValueCondition {
pub name: String,
pub in_list: bool,
pub values: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PivotRootRule {
pub qualifiers: Qualifiers,
pub old_root: Option<FileRulePattern>,
pub new_root: Option<FileRulePattern>,
pub target: Option<ProfileTarget>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LinkRule {
pub qualifiers: Qualifiers,
pub owner: bool,
pub subset: bool,
pub oldname: FileRulePattern,
pub newname: FileRulePattern,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ChangeProfileRule {
pub qualifiers: Qualifiers,
pub safe: Option<bool>,
pub executable: FileRulePattern,
pub target: Option<ProfileTarget>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RlimitRule {
pub qualifiers: Qualifiers,
pub rlimit: String,
pub op: Option<RelOp>,
pub value: Option<LimitValue>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RelOp {
LessEqual,
Less,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LimitValue {
pub number: i64,
pub unit: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DbusRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub bus: Option<String>,
pub path: Option<FileRulePattern>,
pub interface: Option<String>,
pub member: Option<String>,
pub peer: Option<PeerCondition>,
pub label: Option<FileRulePattern>,
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnixRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub type_cond: Option<String>,
pub protocol: Option<String>,
pub addr: Option<FileRulePattern>,
pub label: Option<FileRulePattern>,
pub attr: Option<FileRulePattern>,
pub opt: Option<FileRulePattern>,
pub peer: Option<PeerCondition>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MqueueRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub mq_type: Option<String>,
pub label: Option<FileRulePattern>,
pub name: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UsernsRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IoUringRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub label: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SignalRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub set: Option<Vec<String>>,
pub peer: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PtraceRule {
pub qualifiers: Qualifiers,
pub access: Vec<String>,
pub peer: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AllRule {
pub qualifiers: Qualifiers,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct PeerCondition {
pub name: Option<String>,
pub label: Option<String>,
pub addr: Option<FileRulePattern>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProfileTarget {
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RawRule {
pub text: String,
pub line: usize,
pub col: usize,
pub note: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RawItem {
pub text: String,
pub line: usize,
pub col: usize,
}
impl Profile {
pub fn variables_map(&self) -> BTreeMap<&str, Vec<&str>> {
let mut map: BTreeMap<&str, Vec<&str>> = BTreeMap::new();
for v in &self.variables {
let entry = map.entry(v.name.as_str()).or_default();
if v.append {
entry.extend(v.values.iter().map(String::as_str));
} else {
*entry = v.values.iter().map(String::as_str).collect();
}
}
map
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn variables_map_respects_append() {
let p = Profile {
name: "foo".into(),
attachment: None,
flags: vec![],
variables: vec![
VariableAssignment {
name: "A".into(),
append: false,
values: vec!["1".into(), "2".into()],
},
VariableAssignment {
name: "A".into(),
append: true,
values: vec!["3".into()],
},
VariableAssignment {
name: "B".into(),
append: true,
values: vec!["x".into()],
},
],
includes: vec![],
aliases: vec![],
rules: vec![],
hats: vec![],
};
let map = p.variables_map();
assert_eq!(map["A"], vec!["1", "2", "3"]);
assert_eq!(map["B"], vec!["x"]);
}
#[test]
fn flag_accessors() {
let f = Flag::with_value("kill.signal", "HUP");
assert_eq!(f.name, "kill.signal");
assert_eq!(f.value.as_deref(), Some("HUP"));
let g = Flag::new("complain");
assert_eq!(g.value, None);
}
}