diff --git a/crates/gphip/src/lib.rs b/crates/gphip/src/lib.rs
index 35c4c3f..c6be5d8 100644
--- a/crates/gphip/src/lib.rs
+++ b/crates/gphip/src/lib.rs
@@ -9,6 +9,8 @@ use xmltree::Element;
#[cfg(target_os = "macos")]
mod sentinel_macos;
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+mod sentinel_unix;
pub const MAX_EDITED_REPORT_BYTES: usize = 48 * 1024;
@@ -487,6 +489,10 @@ impl<'p, 'a> HostInfoCollector<'p, 'a> {
if self.profile.client_os() == ClientOs::Mac && self.profile.is_native() {
return sentinel_macos::detect();
}
+ #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+ if self.profile.client_os() == ClientOs::Linux && self.profile.is_native() {
+ return sentinel_unix::detect();
+ }
None
}
}
@@ -821,6 +827,37 @@ mod tests {
assert_eq!(report.matches("name=\"Sentinel Agent\"").count(), 2);
}
+ #[test]
+ fn linux_report_renders_detected_sentinel_antimalware() {
+ let input = make_input(make_profile(ClientOs::Linux));
+ let cookie_params = HashMap::new();
+ let mut host_info = HostInfoCollector::new(&input.profile, &input, &cookie_params).collect();
+ host_info.sentinel = Some(SentinelInfo {
+ version: "25.2.2.14".to_string(),
+ real_time_protection: true,
+ firewall_enabled: None,
+ });
+ let (generate_time, day, month, year) = get_current_time_components();
+ let report = HipReportTemplate {
+ client_version: input.profile.client_version(),
+ generate_time,
+ day,
+ month,
+ year,
+ user_name: "test-user",
+ host_info,
+ md5: "test-digest",
+ }
+ .render()
+ .unwrap();
+ let report = format_xml(&report).unwrap();
+ validate_edited_report(&report).unwrap();
+ assert!(report.contains("vendor=\"SentinelOne\" name=\"Sentinel Agent\" version=\"25.2.2.14\""));
+ assert!(report.contains("osType=\"1\""));
+ assert!(report.contains("yes"));
+ assert_eq!(report.matches("name=\"Sentinel Agent\"").count(), 1);
+ }
+
#[test]
fn preview_uses_explicit_pending_digest() {
let input = ReportInput {
diff --git a/crates/gphip/src/sentinel_unix.rs b/crates/gphip/src/sentinel_unix.rs
new file mode 100644
index 0000000..a710493
--- /dev/null
+++ b/crates/gphip/src/sentinel_unix.rs
@@ -0,0 +1,142 @@
+use std::{
+ fs,
+ os::unix::fs::{MetadataExt, PermissionsExt},
+ path::{Path, PathBuf},
+ process::Command,
+};
+
+use super::SentinelInfo;
+
+const SENTINEL_DIR: &str = "/opt/sentinelone";
+
+pub(super) fn detect() -> Option {
+ let cli = trusted_cli()?;
+
+ let version = parse_version(&run(&cli, &["version"])?)?;
+ let agent_enabled = parse_enabled(&run(&cli, &["control", "status"])?, "Agent state")?;
+ let real_time_protection = if agent_enabled {
+ let policy = run(&cli, &["policy", "status"])?;
+ let on_write = parse_enabled(&policy, "On-Write:")?;
+ let on_execute = parse_enabled(&policy, "On-Execute:")?;
+ on_write || on_execute
+ } else {
+ false
+ };
+
+ Some(SentinelInfo {
+ version,
+ real_time_protection,
+ firewall_enabled: None,
+ })
+}
+
+fn trusted_cli() -> Option {
+ 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(cli: &Path, args: &[&str]) -> Option {
+ let output = Command::new(cli)
+ .args(args)
+ .env("LC_ALL", "C")
+ .env_remove("SENTINEL_OUTPUT_JSON")
+ .output()
+ .ok()?;
+ if !output.status.success() {
+ return None;
+ }
+ String::from_utf8(output.stdout).ok()
+}
+
+fn parse_version(output: &str) -> Option {
+ 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 {
+ 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);
+ }
+}
diff --git a/crates/gphip/templates/hip_report.xml b/crates/gphip/templates/hip_report.xml
index 55c556c..795f546 100644
--- a/crates/gphip/templates/hip_report.xml
+++ b/crates/gphip/templates/hip_report.xml
@@ -238,6 +238,15 @@
{% elif host_info.os_vendor == "Linux" -%}
+ {% if let Some(sentinel) = &host_info.sentinel %}
+
+
+
+ {% if sentinel.real_time_protection %}yes{% else %}no{% endif %}
+ n/a
+
+
+ {% endif -%}
{% if let Some(defender) = &host_info.defender %}