use core::fmt;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct Posture {
pub secure_boot: Option<bool>,
pub tpm: Option<Tpm>,
pub disk_encryption: Option<Encryption>,
pub mandatory_access_control: Option<Mac>,
pub aslr: Option<bool>,
pub kernel_lockdown: Option<Lockdown>,
pub code_integrity: Option<bool>,
pub firewall: Option<bool>,
pub cpu_vulnerabilities: Vec<Vulnerability>,
pub elevated: Option<bool>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub struct Tpm {
pub version: TpmVersion,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum TpmVersion {
V1_2,
V2_0,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum Encryption {
Enabled {
kind: &'static str,
},
Disabled,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub struct Mac {
pub kind: &'static str,
pub enforcing: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum Lockdown {
Off,
Integrity,
Confidentiality,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct Vulnerability {
pub name: String,
pub status: VulnStatus,
pub detail: String,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum VulnStatus {
NotAffected,
Mitigated,
Vulnerable,
Unknown,
}
impl VulnStatus {
#[cfg_attr(not(any(target_os = "linux", target_os = "android")), allow(dead_code))]
pub(crate) fn of(detail: &str) -> VulnStatus {
if detail.starts_with("Not affected") {
Self::NotAffected
} else if detail.starts_with("Mitigation") {
Self::Mitigated
} else if detail.starts_with("Vulnerable") {
Self::Vulnerable
} else {
Self::Unknown
}
}
}
#[must_use]
pub fn posture() -> Posture {
let mut p = crate::sys::posture();
p.elevated = crate::process::is_elevated().ok();
p
}
impl fmt::Display for Posture {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fn flag(v: Option<bool>) -> &'static str {
match v {
Some(true) => "on",
Some(false) => "off",
None => "unknown",
}
}
writeln!(f, "{:<18}{}", "secure boot", flag(self.secure_boot))?;
let tpm = match self.tpm.map(|t| t.version) {
Some(TpmVersion::V2_0) => "2.0",
Some(TpmVersion::V1_2) => "1.2",
None => "unknown",
};
writeln!(f, "{:<18}{tpm}", "tpm")?;
let enc = match self.disk_encryption {
Some(Encryption::Enabled { kind }) => kind,
Some(Encryption::Disabled) => "off",
None => "unknown",
};
writeln!(f, "{:<18}{enc}", "disk encryption")?;
match self.mandatory_access_control {
Some(m) => writeln!(
f,
"{:<18}{} {}",
"access control",
m.kind,
if m.enforcing {
"enforcing"
} else {
"permissive"
}
)?,
None => writeln!(f, "{:<18}unknown", "access control")?,
}
writeln!(f, "{:<18}{}", "aslr", flag(self.aslr))?;
let lockdown = match self.kernel_lockdown {
Some(Lockdown::Off) => "off",
Some(Lockdown::Integrity) => "integrity",
Some(Lockdown::Confidentiality) => "confidentiality",
None => "unknown",
};
writeln!(f, "{:<18}{lockdown}", "kernel lockdown")?;
writeln!(f, "{:<18}{}", "code integrity", flag(self.code_integrity))?;
writeln!(f, "{:<18}{}", "firewall", flag(self.firewall))?;
let vulnerable = self
.cpu_vulnerabilities
.iter()
.filter(|v| v.status == VulnStatus::Vulnerable)
.count();
writeln!(
f,
"{:<18}{} known, {vulnerable} vulnerable",
"cpu issues",
self.cpu_vulnerabilities.len()
)?;
write!(f, "{:<18}{}", "elevated", flag(self.elevated))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_security_vuln_status_of() {
assert_eq!(VulnStatus::of("Not affected"), VulnStatus::NotAffected);
assert_eq!(
VulnStatus::of("Mitigation: Enhanced / Automatic IBRS"),
VulnStatus::Mitigated
);
assert_eq!(
VulnStatus::of("Vulnerable: no microcode"),
VulnStatus::Vulnerable
);
assert_eq!(
VulnStatus::of("Unknown: no mitigations"),
VulnStatus::Unknown
);
assert_eq!(VulnStatus::of(""), VulnStatus::Unknown);
}
#[test]
fn test_security_live_posture_displays() {
let p = posture();
let text = p.to_string();
assert!(text.contains("secure boot") && text.contains("elevated"));
assert_eq!(p.elevated, crate::process::is_elevated().ok());
}
}