feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

File diff suppressed because it is too large. Load diff
+149
View File
@@ -0,0 +1,149 @@
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);
}
}
+152
View File
@@ -0,0 +1,152 @@
use std::{
fs, io,
os::unix::fs::{MetadataExt, PermissionsExt},
path::{Path, PathBuf},
};
use gpapi::process::collection::CollectorCommands;
use super::SentinelInfo;
const SENTINEL_DIR: &str = "/opt/sentinelone";
pub(super) fn detect(commands: &CollectorCommands<'_>) -> io::Result<Option<SentinelInfo>> {
let Some(cli) = trusted_cli() else {
return Ok(None);
};
let Some(version) = run(commands, &cli, &["version"])?.as_deref().and_then(parse_version) else {
return Ok(None);
};
let Some(agent_enabled) = run(commands, &cli, &["control", "status"])?
.as_deref()
.and_then(|status| parse_enabled(status, "Agent state"))
else {
return Ok(None);
};
let real_time_protection = if agent_enabled {
let Some(policy) = run(commands, &cli, &["policy", "status"])? else {
return Ok(None);
};
let (Some(on_write), Some(on_execute)) = (
parse_enabled(&policy, "On-Write:"),
parse_enabled(&policy, "On-Execute:"),
) else {
return Ok(None);
};
on_write || on_execute
} else {
false
};
Ok(Some(SentinelInfo {
version,
real_time_protection,
firewall_enabled: None,
}))
}
fn trusted_cli() -> Option<PathBuf> {
let agent_uid = uzers::get_user_by_name("sentinelone")?.uid();
let agent_dir = Path::new(SENTINEL_DIR);
if !trusted_dir(Path::new("/opt"), 0) {
return None;
}
let link = fs::symlink_metadata(agent_dir).ok()?;
if link.file_type().is_symlink() && link.uid() != 0 {
return None;
}
let resolved_dir = fs::canonicalize(agent_dir).ok()?;
for ancestor in resolved_dir.ancestors().skip(1) {
if !trusted_dir(ancestor, 0) {
return None;
}
}
if !(trusted_dir(&resolved_dir, 0) || trusted_dir(&resolved_dir, agent_uid))
|| !trusted_dir(&resolved_dir.join("bin"), 0)
{
return None;
}
let cli = resolved_dir.join("bin/sentinelctl");
let metadata = fs::symlink_metadata(&cli).ok()?;
if !metadata.is_file()
|| metadata.uid() != 0
|| metadata.permissions().mode() & 0o022 != 0
|| metadata.permissions().mode() & 0o111 == 0
{
return None;
}
Some(cli)
}
fn trusted_dir(path: &Path, owner: u32) -> bool {
let Ok(metadata) = fs::symlink_metadata(path) else {
return false;
};
metadata.is_dir() && metadata.uid() == owner && metadata.permissions().mode() & 0o022 == 0
}
fn run(commands: &CollectorCommands<'_>, cli: &Path, args: &[&str]) -> io::Result<Option<String>> {
Ok(
commands
.run_path(cli, args)?
.filter(|output| output.status.success())
.and_then(|output| String::from_utf8(output.stdout).ok()),
)
}
fn parse_version(output: &str) -> Option<String> {
let version = value(output, "Agent version:")?;
if version.is_empty()
|| version.len() > 64
|| !version
.chars()
.all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '.' | '-' | '_'))
{
return None;
}
Some(version.to_string())
}
fn parse_enabled(output: &str, label: &str) -> Option<bool> {
match value(output, label)? {
"Enabled" => Some(true),
"Disabled" => Some(false),
_ => None,
}
}
fn value<'a>(output: &'a str, label: &str) -> Option<&'a str> {
output
.lines()
.find_map(|line| line.trim().strip_prefix(label).map(str::trim))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_observed_agent_and_policy_status() {
assert_eq!(
parse_version("Agent version: 25.2.2.14\nSentinelCTL version: 25.2.2.14\n"),
Some("25.2.2.14".into())
);
assert_eq!(parse_enabled("Agent state Enabled\n", "Agent state"), Some(true));
assert_eq!(
parse_enabled("On-Write: Enabled\nOn-Execute: Disabled\n", "On-Write:"),
Some(true)
);
assert_eq!(
parse_enabled("On-Write: Enabled\nOn-Execute: Disabled\n", "On-Execute:"),
Some(false)
);
}
#[test]
fn rejects_unknown_or_invalid_status() {
assert_eq!(parse_version("Agent version: 25.2.2.14\"/>\n"), None);
assert_eq!(parse_enabled("Agent state Unknown\n", "Agent state"), None);
assert_eq!(parse_enabled("On-Write: Unknown\n", "On-Write:"), None);
}
}