use crate::acl::{ApplicationAccess, TrustedApplication};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum AccessMode {
#[default]
Extended,
Native,
Hybrid,
}
impl AccessMode {
pub const fn enforces_direct(self) -> bool {
matches!(self, Self::Extended | Self::Hybrid)
}
pub const fn projects_native(self) -> bool {
matches!(self, Self::Native | Self::Hybrid)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum AccessDefault {
Allow,
#[default]
Prompt,
Deny,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AccessDecision {
Allow,
Prompt,
Deny,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AccessPolicy {
pub mode: AccessMode,
pub default: AccessDefault,
pub trusted_applications: Vec<TrustedApplication>,
}
impl Default for AccessPolicy {
fn default() -> Self {
Self {
mode: AccessMode::Extended,
default: AccessDefault::Prompt,
trusted_applications: Vec::new(),
}
}
}
impl AccessPolicy {
pub const fn direct_decision(&self) -> AccessDecision {
if !self.mode.enforces_direct() {
return AccessDecision::Allow;
}
match self.default {
AccessDefault::Allow => AccessDecision::Allow,
AccessDefault::Prompt => AccessDecision::Prompt,
AccessDefault::Deny => AccessDecision::Deny,
}
}
pub fn native_trusted_applications(&self) -> &[TrustedApplication] {
&self.trusted_applications
}
pub fn native_application_access(&self) -> ApplicationAccess {
if !self.trusted_applications.is_empty() {
return ApplicationAccess::TrustedApplications(self.trusted_applications.clone());
}
match self.default {
AccessDefault::Allow => ApplicationAccess::AllowAny,
AccessDefault::Prompt | AccessDefault::Deny => ApplicationAccess::Prompt,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn native_only_does_not_claim_to_gate_direct_reads() {
let policy = AccessPolicy {
mode: AccessMode::Native,
default: AccessDefault::Deny,
..AccessPolicy::default()
};
assert_eq!(policy.direct_decision(), AccessDecision::Allow);
assert!(policy.mode.projects_native());
}
#[test]
fn extended_and_hybrid_return_the_configured_decision() {
for mode in [AccessMode::Extended, AccessMode::Hybrid] {
let policy = AccessPolicy {
mode,
default: AccessDefault::Deny,
..AccessPolicy::default()
};
assert_eq!(policy.direct_decision(), AccessDecision::Deny);
}
}
}