openmoat-core 0.4.0

Policy model and decision engine for OpenMoat. Pure: no I/O, no OS calls.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Evaluating the IR on atomic actions: the reference semantics every OS
//! backend must reproduce, and what the consistency tests compare with the engine.

use super::{Access, Effect, Enforcement};
use crate::action::AtomicAction;
use crate::kind::Kind;
use crate::pattern::{GlobPattern, any_match};
use crate::policy::PolicyError;

/// An [`Enforcement`] with its globs compiled.
#[derive(Debug)]
pub struct Checker {
    /// The read allowances, every one an `fs.read` [`super::Allowance`].
    read_allowances: Vec<GlobPattern>,
    read: CompiledAccess,
    write: CompiledAccess,
    net: CompiledAccess,
    fetch: CompiledAccess,
}

#[derive(Debug)]
struct CompiledAccess {
    default: Effect,
    deny: Vec<Vec<GlobPattern>>,
    allow: Vec<Vec<GlobPattern>>,
}

impl Enforcement {
    /// Compile the IR's globs for [`Checker::check`].
    pub fn checker(&self) -> Result<Checker, PolicyError> {
        let paths = self.fs.case_insensitive;
        Ok(Checker {
            read_allowances: self
                .allowances
                .iter()
                .filter(|a| a.kind == Kind::FsRead)
                .flat_map(|a| &a.patterns)
                .map(|p| GlobPattern::compile(p, paths))
                .collect::<Result<_, _>>()?,
            read: CompiledAccess::compile(&self.fs.read, paths)?,
            write: CompiledAccess::compile(&self.fs.write, paths)?,
            net: CompiledAccess::compile(&self.egress.net, true)?,
            fetch: CompiledAccess::compile(&self.egress.fetch, true)?,
        })
    }
}

impl Checker {
    /// What an OS layer does with `atom`: `None` for a decide-only kind.
    #[must_use]
    pub fn check(&self, atom: &AtomicAction) -> Option<Effect> {
        let access = match atom.kind() {
            Kind::FsRead => &self.read,
            Kind::FsWrite => &self.write,
            Kind::Net => &self.net,
            Kind::Fetch => &self.fetch,
            Kind::Shell | Kind::WebSearch | Kind::EnvRead | Kind::EnvSet | Kind::Mcp => {
                return None;
            }
        };
        Some(access.effect(atom.subject()?))
    }

    /// What an OS layer does with `atom` once the [`super::Allowance`]s apply:
    /// a deny rule still denies, then an allowance allows, then [`Self::check`].
    #[must_use]
    pub fn check_os(&self, atom: &AtomicAction) -> Option<Effect> {
        let effect = self.check(atom)?;
        let allowed = atom.kind() == Kind::FsRead
            && !self.read.denies(atom.subject()?)
            && any_match(&self.read_allowances, atom.subject()?);
        Some(if allowed { Effect::Allow } else { effect })
    }
}

impl CompiledAccess {
    fn compile(access: &Access, case_insensitive: bool) -> Result<Self, PolicyError> {
        let compile = |rules: &[super::Rule]| {
            rules
                .iter()
                .map(|rule| {
                    rule.patterns
                        .iter()
                        .map(|p| GlobPattern::compile(p, case_insensitive))
                        .collect::<Result<Vec<_>, _>>()
                })
                .collect::<Result<Vec<_>, _>>()
        };
        Ok(Self {
            default: access.default,
            deny: compile(&access.deny)?,
            allow: compile(&access.allow)?,
        })
    }

    fn denies(&self, subject: &str) -> bool {
        self.deny.iter().any(|r| any_match(r, subject))
    }

    fn effect(&self, subject: &str) -> Effect {
        let hit = |rules: &[Vec<GlobPattern>]| rules.iter().any(|r| any_match(r, subject));
        if self.denies(subject) {
            Effect::Deny
        } else if hit(&self.allow) {
            Effect::Allow
        } else {
            self.default
        }
    }
}