mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
150 lines
3.9 KiB
Rust
150 lines
3.9 KiB
Rust
use std::{
|
|
fs, io,
|
|
os::unix::fs::{MetadataExt, PermissionsExt},
|
|
path::Path,
|
|
};
|
|
|
|
use gpapi::process::collection::CollectorCommands;
|
|
|
|
use super::SentinelInfo;
|
|
|
|
const SENTINELCTL: &str = "/Library/Sentinel/sentinel-agent.bundle/Contents/MacOS/sentinelctl";
|
|
|
|
pub(super) fn detect(commands: &CollectorCommands<'_>) -> io::Result<Option<SentinelInfo>> {
|
|
if !trusted_cli(Path::new(SENTINELCTL)) {
|
|
return Ok(None);
|
|
}
|
|
let Some(status) = run(commands, &["status"])? else {
|
|
return Ok(None);
|
|
};
|
|
let Some(status) = parse_status(&status) else {
|
|
return Ok(None);
|
|
};
|
|
let real_time_protection = if status.active {
|
|
let Some(scan_status) = run(commands, &["scan-on-write"])? else {
|
|
return Ok(None);
|
|
};
|
|
let Some(enabled) = scan_status.trim().strip_prefix("scan-on-write:").and_then(parse_yes_no) else {
|
|
return Ok(None);
|
|
};
|
|
enabled
|
|
} else {
|
|
false
|
|
};
|
|
let firewall_enabled = run(commands, &["firewall", "enabled"])?
|
|
.as_deref()
|
|
.and_then(parse_yes_no);
|
|
Ok(Some(SentinelInfo {
|
|
version: status.version,
|
|
real_time_protection,
|
|
firewall_enabled,
|
|
}))
|
|
}
|
|
|
|
fn trusted_cli(path: &Path) -> bool {
|
|
path.ancestors().take_while(|part| part.as_os_str() != "/").all(|part| {
|
|
let Ok(metadata) = fs::symlink_metadata(part) else {
|
|
return false;
|
|
};
|
|
if metadata.uid() != 0 || metadata.permissions().mode() & 0o022 != 0 || metadata.file_type().is_symlink() {
|
|
return false;
|
|
}
|
|
if part == path {
|
|
metadata.is_file()
|
|
} else {
|
|
metadata.is_dir()
|
|
}
|
|
})
|
|
}
|
|
|
|
fn run(commands: &CollectorCommands<'_>, args: &[&str]) -> io::Result<Option<String>> {
|
|
Ok(
|
|
commands
|
|
.run_path(Path::new(SENTINELCTL), args)?
|
|
.filter(|output| output.status.success())
|
|
.and_then(|output| String::from_utf8(output.stdout).ok()),
|
|
)
|
|
}
|
|
|
|
struct AgentStatus {
|
|
version: String,
|
|
active: bool,
|
|
}
|
|
|
|
fn parse_status(output: &str) -> Option<AgentStatus> {
|
|
let version = status_value(output, "Version:")?;
|
|
if version.is_empty()
|
|
|| version.len() > 64
|
|
|| !version
|
|
.chars()
|
|
.all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '.' | '-' | '_'))
|
|
{
|
|
return None;
|
|
}
|
|
|
|
let operational = parse_status_bool(output, "Agent Operational State:", "enabled", "disabled")?;
|
|
let ready = parse_status_bool(output, "Ready:", "yes", "no")?;
|
|
let protected = parse_status_bool(output, "Protection:", "enabled", "disabled")?;
|
|
Some(AgentStatus {
|
|
version: version.to_string(),
|
|
active: operational && ready && protected,
|
|
})
|
|
}
|
|
|
|
fn status_value<'a>(output: &'a str, label: &str) -> Option<&'a str> {
|
|
output
|
|
.lines()
|
|
.find_map(|line| line.trim().strip_prefix(label).map(str::trim))
|
|
}
|
|
|
|
fn parse_status_bool(output: &str, label: &str, yes: &str, no: &str) -> Option<bool> {
|
|
match status_value(output, label)? {
|
|
value if value == yes => Some(true),
|
|
value if value == no => Some(false),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn parse_yes_no(output: &str) -> Option<bool> {
|
|
match output.trim() {
|
|
"yes" => Some(true),
|
|
"no" => Some(false),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parses_running_agent_status() {
|
|
let status = parse_status(
|
|
"Agent\n Version: 25.3.4.8365\n Agent Operational State: enabled\n Ready: yes\n Protection: enabled\n",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(status.version, "25.3.4.8365");
|
|
assert!(status.active);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_unknown_agent_state() {
|
|
assert!(parse_status("Version: 25.3.4.8365\nProtection: maybe\n").is_none());
|
|
assert!(
|
|
!parse_status("Version: 25.3.4.8365\nAgent Operational State: disabled\nReady: yes\nProtection: enabled\n")
|
|
.unwrap()
|
|
.active
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_scan_and_firewall_states() {
|
|
assert_eq!(
|
|
parse_yes_no("scan-on-write:\tyes\n".trim().strip_prefix("scan-on-write:").unwrap()),
|
|
Some(true)
|
|
);
|
|
assert_eq!(parse_yes_no("no\n"), Some(false));
|
|
assert_eq!(parse_yes_no("unknown\n"), None);
|
|
}
|
|
}
|