feat: add HIP report generation functionality and related dependencies

This commit is contained in:
Kevin Yue committed 2025-12-13 23:39:51 +08:00
1 parent f398ccadb7
commit d797c4f40e
24 files changed
+1266 -138

No files matched your search

+5
View File
@@ -12,6 +12,8 @@ gpapi = { path = "../../crates/gpapi", features = ["clap"] }
openconnect = { path = "../../crates/openconnect" }
anyhow.workspace = true
askama.workspace = true
chrono.workspace = true
clap.workspace = true
env_logger.workspace = true
inquire = "0.9"
@@ -19,11 +21,14 @@ log.workspace = true
tokio = { workspace = true, features = ["rt-multi-thread"] }
sysinfo.workspace = true
serde_json.workspace = true
serde_urlencoded.workspace = true
whoami.workspace = true
tempfile.workspace = true
reqwest.workspace = true
directories.workspace = true
compile-time.workspace = true
netdev.workspace = true
xmltree.workspace = true
[features]
default = ["webview-auth"]
+6 -2
View File
@@ -3,7 +3,7 @@ use std::{env::temp_dir, fs::File, str::FromStr};
use anyhow::bail;
use clap::{Parser, Subcommand};
use gpapi::{
clap::{handle_error, Args, InfoLevelVerbosity},
clap::{Args, InfoLevelVerbosity, handle_error},
utils::openssl,
};
use log::info;
@@ -12,10 +12,11 @@ use tempfile::NamedTempFile;
use tokio::fs;
use crate::{
GP_CLIENT_LOCK_FILE,
connect::{ConnectArgs, ConnectHandler},
disconnect::{DisconnectArgs, DisconnectHandler},
hip::{HipArgs, HipHandler},
launch_gui::{LaunchGuiArgs, LaunchGuiHandler},
GP_CLIENT_LOCK_FILE,
};
const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), " (", compile_time::date_str!(), ")");
@@ -34,6 +35,8 @@ enum CliCommand {
Disconnect(DisconnectArgs),
#[command(about = "Launch the GUI")]
LaunchGui(LaunchGuiArgs),
#[command(about = "Generate HIP report")]
Hip(HipArgs),
}
#[derive(Parser)]
@@ -132,6 +135,7 @@ impl Cli {
CliCommand::Connect(args) => ConnectHandler::new(args, &shared_args).handle().await,
CliCommand::Disconnect(args) => DisconnectHandler::new(args).handle().await,
CliCommand::LaunchGui(args) => LaunchGuiHandler::new(args).handle().await,
CliCommand::Hip(args) => HipHandler::new(args).handle().await,
}
}
}
+19 -8
View File
@@ -15,7 +15,7 @@ use gpapi::{
auth_launcher::SamlAuthLauncher,
users::{get_non_root_user, get_user_by_name},
},
utils::{request::RequestIdentityError, shutdown_signal},
utils::{host_utils, request::RequestIdentityError, shutdown_signal},
};
use inquire::{Password, PasswordDisplayMode, Select, Text};
use log::{info, warn};
@@ -130,18 +130,29 @@ pub(crate) struct ConnectArgs {
impl ConnectArgs {
fn default_os() -> Os {
if cfg!(target_os = "macos") { Os::Mac } else { Os::Linux }
#[cfg(target_os = "macos")]
{
Os::Mac
}
#[cfg(target_os = "windows")]
{
Os::Windows
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
{
Os::Linux
}
}
fn os_version(&self) -> String {
fn os_version(&self) -> &str {
if let Some(os_version) = self.os_version.as_deref() {
return os_version.to_string();
return os_version;
}
match self.os {
Os::Linux => format!("Linux {}", whoami::distro()),
Os::Windows => String::from("Microsoft Windows 11 Pro , 64-bit"),
Os::Mac => String::from("Apple Mac OS X 13.4.0"),
Os::Linux => host_utils::get_linux_os_string(),
Os::Windows => host_utils::get_windows_os_string(),
Os::Mac => host_utils::get_macos_os_string(),
}
}
}
@@ -167,7 +178,7 @@ impl<'a> ConnectHandler<'a> {
GpParams::builder()
.user_agent(&self.args.user_agent)
.client_os(ClientOs::from(&self.args.os))
.os_version(self.args.os_version())
.os_version(self.args.os_version().to_owned())
.ignore_tls_errors(self.shared_args.ignore_tls_errors)
.certificate(self.args.certificate.clone())
.sslkey(self.args.sslkey.clone())
+381
View File
@@ -0,0 +1,381 @@
use askama::Template;
use clap::Args;
use gpapi::utils::host_utils;
use log::debug;
use std::collections::HashMap;
use xmltree::Element;
#[derive(Template)]
#[template(path = "hip_report.xml")]
struct HipReportTemplate<'a> {
client_version: &'a str,
generate_time: String,
day: String,
month: String,
year: String,
md5: &'a str,
user_name: &'a str,
host_info: HostInfo,
}
/// Host information for HIP reporting
struct HostInfo {
/// Only for macOS and Windows
host_id: String,
/// Common for all OSes
host_name: String,
os: &'static str,
/// Only for macOS and Windows
os_version: &'static str,
os_vendor: &'static str,
domain: String,
network_interfaces: Vec<NetworkInterface>,
}
impl HostInfo {
/// Get the first available IPv4 address from network interfaces
pub fn default_ipv4(&self) -> &str {
self
.network_interfaces
.first()
.and_then(|iface| iface.ipv4.as_deref())
.unwrap_or_default()
}
/// Get the first available IPv6 address from network interfaces
pub fn default_ipv6(&self) -> &str {
self
.network_interfaces
.first()
.and_then(|iface| iface.ipv6.as_deref())
.unwrap_or_default()
}
}
/// Network interface information
#[derive(Clone)]
struct NetworkInterface {
name: String,
description: String,
mac_address: Option<String>,
ipv4: Option<String>,
ipv6: Option<String>,
}
impl NetworkInterface {
/// Create a new network interface with basic information
fn new(name: String, description: String) -> Self {
Self {
name,
description,
mac_address: None,
ipv4: None,
ipv6: None,
}
}
/// Set MAC address
fn with_mac(mut self, mac: Option<String>) -> Self {
self.mac_address = mac;
self
}
/// Set IPv4 address
fn with_ipv4(mut self, ipv4: Option<String>) -> Self {
self.ipv4 = ipv4;
self
}
/// Set IPv6 address
fn with_ipv6(mut self, ipv6: Option<String>) -> Self {
self.ipv6 = ipv6;
self
}
}
#[derive(Args)]
pub(crate) struct HipArgs {
#[arg(long, help = "The authentication cookie")]
cookie: String,
#[arg(long, help = "The client IPv4 address")]
client_ip: Option<String>,
#[arg(long, help = "The client IPv6 address")]
client_ipv6: Option<String>,
#[arg(long, help = "The MD5 digest to encode into the HIP report")]
md5: String,
#[arg(long, default_value = "Windows", help = "The client OS (Linux, Mac, or Windows)")]
client_os: String,
#[arg(long, default_value = "", help = "The client software version")]
client_version: String,
}
pub(crate) struct HipHandler<'a> {
args: &'a HipArgs,
}
impl<'a> HipHandler<'a> {
pub(crate) fn new(args: &'a HipArgs) -> Self {
Self { args }
}
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
self.validate_args()?;
let cookie_params = self.parse_cookie();
let report = self.generate_hip_report(&cookie_params)?;
debug!("Generated HIP report:\n{}", report);
println!("{}", report);
Ok(())
}
/// Validate that at least one IP address is provided
fn validate_args(&self) -> anyhow::Result<()> {
if self.args.client_ip.is_none() && self.args.client_ipv6.is_none() {
anyhow::bail!("At least one of --client-ip or --client-ipv6 must be provided");
}
Ok(())
}
fn parse_cookie(&self) -> HashMap<String, String> {
// Parse URL-encoded cookie string using serde_urlencoded
serde_urlencoded::from_str(&self.args.cookie).unwrap_or_default()
}
/// Generate the complete HIP report XML
fn generate_hip_report(&self, cookie_params: &HashMap<String, String>) -> anyhow::Result<String> {
let (generate_time, day, month, year) = get_current_time_components();
let user_name = cookie_params.get("user").map(|s| s.as_str()).unwrap_or("");
let host_info = self.collect_host_info(cookie_params);
let client_version = std::env::var("APP_VERSION")
.map(|v| v.leak() as &'a str)
.unwrap_or(&self.args.client_version);
let template = HipReportTemplate {
client_version,
generate_time,
day,
month,
year,
md5: &self.args.md5,
user_name,
host_info,
};
let report = template.render()?;
format_xml(&report)
}
/// Collect host information based on the client OS
fn collect_host_info(&self, cookie_params: &HashMap<String, String>) -> HostInfo {
let collector = HostInfoCollector::new(self.args, cookie_params);
match self.args.client_os.as_str() {
"Linux" => collector.collect_linux(),
"Mac" => collector.collect_macos(),
_ => collector.collect_windows(),
}
}
}
// ============================================================================
// Host Information Collector
// ============================================================================
/// Helper struct for collecting host information
struct HostInfoCollector<'a> {
args: &'a HipArgs,
cookie_params: &'a HashMap<String, String>,
}
impl<'a> HostInfoCollector<'a> {
fn new(args: &'a HipArgs, cookie_params: &'a HashMap<String, String>) -> Self {
Self { args, cookie_params }
}
/// Get domain from cookie parameters
fn get_domain(&self) -> String {
self
.cookie_params
.get("domain")
.map(|s| s.to_string())
.unwrap_or_default()
}
/// Collect network interface information with fallback
fn collect_network_interface(&self) -> NetworkInterface {
match netdev::get_default_interface() {
Ok(iface) => NetworkInterface::new(
iface.name.clone(),
iface.description.unwrap_or_else(|| iface.name.clone()),
)
.with_mac(iface.mac_addr.map(|mac| mac.address()))
.with_ipv4(iface.ipv4.first().map(|ip| ip.addr().to_string()))
.with_ipv6(iface.ipv6.first().map(|ip| ip.addr().to_string())),
Err(_) => NetworkInterface::new("unknown".to_string(), "unknown".to_string())
.with_ipv4(self.args.client_ip.clone())
.with_ipv6(self.args.client_ipv6.clone()),
}
}
/// Collect Linux-specific host information
fn collect_linux(&self) -> HostInfo {
let iface = self.collect_network_interface();
// Use the fixed interface name enp1s0f0 for Linux if it is not on Linux
let iface = NetworkInterface {
#[cfg(target_os = "linux")]
name: iface.name,
#[cfg(target_os = "linux")]
description: iface.description,
#[cfg(not(target_os = "linux"))]
name: "enp1s0f0".to_string(),
#[cfg(not(target_os = "linux"))]
description: "enp1s0f0".to_string(),
mac_address: iface.mac_address,
ipv4: iface.ipv4,
ipv6: iface.ipv6,
};
HostInfo {
os_vendor: "Linux",
host_id: host_utils::derive_uuid(&[]),
os: host_utils::get_linux_os_string(),
host_name: whoami::devicename(),
os_version: "",
domain: String::new(),
network_interfaces: vec![iface],
}
}
/// Collect macOS-specific host information
fn collect_macos(&self) -> HostInfo {
let iface = self.collect_network_interface();
// macOS use the mac address as host ID
let host_id = iface
.mac_address
.as_ref()
.map(|s| s.to_string())
.unwrap_or_else(|| "00:00:00:00:00:00".to_string());
// Use the fixed interface name en0 for macOS if it is not on macOS
let iface = NetworkInterface {
#[cfg(target_os = "macos")]
name: iface.name,
#[cfg(target_os = "macos")]
description: iface.description,
#[cfg(not(target_os = "macos"))]
name: "en0".to_string(),
#[cfg(not(target_os = "macos"))]
description: "en0".to_string(),
mac_address: iface.mac_address,
ipv4: iface.ipv4,
ipv6: iface.ipv6,
};
HostInfo {
os_vendor: "Apple",
host_id,
os: host_utils::get_macos_os_string(),
host_name: whoami::devicename(),
os_version: host_utils::get_macos_version(),
domain: self.get_domain(),
network_interfaces: vec![iface],
}
}
/// Collect Windows-specific host information
fn collect_windows(&self) -> HostInfo {
// Use the actual machine ID on Windows
#[cfg(target_os = "windows")]
let host_id = host_utils::get_machine_id().to_string();
#[cfg(not(target_os = "windows"))]
let host_id = host_utils::derive_uuid(&[]);
let iface = self.collect_network_interface();
// Use the fixed interface name if it is not on Windows
let iface = NetworkInterface {
#[cfg(target_os = "windows")]
name: iface.name,
#[cfg(target_os = "windows")]
description: iface.description,
#[cfg(not(target_os = "windows"))]
name: derive_windows_network_name(&iface),
#[cfg(not(target_os = "windows"))]
description: "PANGP Virtual Ethernet Adapter Secure".to_string(),
// mac address on windows should replace ':' with '-'
mac_address: iface.mac_address.map(|mac| mac.replace(':', "-")),
ipv4: iface.ipv4,
ipv6: iface.ipv6,
};
// Add the local loopback interface
let loopback_iface = NetworkInterface {
name: derive_windows_network_name(&iface),
description: "Software Loopback Interface 1".to_string(),
mac_address: Some(String::new()),
ipv4: Some("127.0.0.1".to_string()),
ipv6: Some("::1".to_string()),
};
let ifaces = vec![iface, loopback_iface];
HostInfo {
os_vendor: "Microsoft",
host_id,
os: host_utils::get_windows_os_string(),
host_name: whoami::devicename(),
os_version: host_utils::get_windows_version(),
domain: self.get_domain(),
network_interfaces: ifaces,
}
}
}
// ============================================================================
// Utility Functions
// ============================================================================
/// Get current time components for HIP report
fn get_current_time_components() -> (String, String, String, String) {
let now = chrono::Local::now();
(
now.format("%m/%d/%Y %H:%M:%S").to_string(),
now.format("%d").to_string(),
now.format("%m").to_string(),
now.format("%Y").to_string(),
)
}
/// Format XML string with proper indentation
fn format_xml(xml_str: &str) -> anyhow::Result<String> {
let xml = Element::parse(xml_str.as_bytes())?;
let config = xmltree::EmitterConfig::new().perform_indent(true);
let mut xml_buf = Vec::new();
xml.write_with_config(&mut xml_buf, config)?;
Ok(String::from_utf8(xml_buf)?)
}
fn derive_windows_network_name(iface: &NetworkInterface) -> String {
let seeds = [
iface.mac_address.as_deref().unwrap_or("00:00:00:00:00:00"),
iface.name.as_str(),
];
format!("{{{}}}", host_utils::derive_uuid(&seeds).to_uppercase())
}
+1
View File
@@ -1,6 +1,7 @@
mod cli;
mod connect;
mod disconnect;
mod hip;
mod launch_gui;
pub(crate) const GP_CLIENT_LOCK_FILE: &str = "/var/run/gpclient.lock";
+277
View File
@@ -0,0 +1,277 @@
<?xml version="1.0" encoding="UTF-8"?>
<hip-report name="hip-report">
<md5-sum>{{ md5 }}</md5-sum>
<user-name>{{ user_name }}</user-name>
<domain>{{ host_info.domain }}.internal</domain>
<host-name>{{ host_info.host_name }}</host-name>
<host-id>{{ host_info.host_id }}</host-id>
<ip-address>{{ host_info.default_ipv4() }}</ip-address>
<ipv6-address>{{ host_info.default_ipv6() }}</ipv6-address>
<generate-time>{{ generate_time }}</generate-time>
<hip-report-version>4</hip-report-version>
<categories>
<entry name="host-info">
<client-version>{{ client_version }}</client-version>
<os>{{ host_info.os }}</os>
<os-vendor>{{ host_info.os_vendor }}</os-vendor>
<domain>{{ host_info.domain }}.internal</domain>
<host-name>{{ host_info.host_name }}</host-name>
<host-id>{{ host_info.host_id }}</host-id>
<network-interface>
{% for iface in host_info.network_interfaces.iter() -%}
<entry name="{{ iface.name }}">
<description>{{ iface.description }}</description>
{% if let Some(mac) = iface.mac_address -%}
<mac-address>{{ mac }}</mac-address>
{% endif -%}
{% if let Some(ipv4) = iface.ipv4 -%}
<ip-address>
<entry name="{{ ipv4 }}"/>
</ip-address>
{% endif -%}
{% if let Some(ipv6) = iface.ipv6 -%}
<ipv6-address>
<entry name="{{ ipv6 }}"/>
</ipv6-address>
{% endif -%}
</entry>
{% endfor -%}
</network-interface>
</entry>
{% if host_info.os_vendor == "Microsoft" -%}
<entry name="antivirus">
<list>
<entry>
<ProductInfo>
<Prod name="McAfee VirusScan Enterprise" version="8.8.0.1804" defver="8682.0" prodType="1" engver="5900.7806" osType="1" vendor="McAfee, Inc." dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
</Prod>
<real-time-protection>yes</real-time-protection>
<last-full-scan-time>{{ generate_time }}</last-full-scan-time>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod name="Windows Defender" version="4.11.15063.332" defver="1.245.683.0" prodType="1" engver="1.1.13804.0" osType="1" vendor="Microsoft Corp." dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
</Prod>
<real-time-protection>no</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="anti-spyware">
<list>
<entry>
<ProductInfo>
<Prod name="McAfee VirusScan Enterprise" version="8.8.0.1804" defver="8682.0" prodType="2" engver="5900.7806" osType="1" vendor="McAfee, Inc." dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
</Prod>
<real-time-protection>yes</real-time-protection>
<last-full-scan-time>{{ generate_time }}</last-full-scan-time>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod name="Windows Defender" version="4.11.15063.332" defver="1.245.683.0" prodType="2" engver="1.1.13804.0" osType="1" vendor="Microsoft Corp." dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
</Prod>
<real-time-protection>no</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="disk-backup">
<list>
<entry>
<ProductInfo>
<Prod name="Windows Backup and Restore" version="{{ host_info.os_version }}" vendor="Microsoft Corp.">
</Prod>
<last-backup-time>n/a</last-backup-time>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="disk-encryption">
<list>
<entry>
<ProductInfo>
<Prod name="Windows Drive Encryption" version="{{ host_info.os_version }}" vendor="Microsoft Corp.">
</Prod>
<drives>
<entry>
<drive-name>C:\\</drive-name>
<enc-state>full</enc-state>
</entry>
</drives>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="firewall">
<list>
<entry>
<ProductInfo>
<Prod name="Microsoft Windows Firewall" version="10.0" vendor="Microsoft Corp.">
</Prod>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="patch-management">
<list>
<entry>
<ProductInfo>
<Prod name="McAfee ePolicy Orchestrator Agent" version="5.0.5.658" vendor="McAfee, Inc.">
</Prod>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod name="Microsoft Windows Update Agent" version="{{ host_info.os_version }}" vendor="Microsoft Corp.">
</Prod>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
</list>
<missing-patches/>
</entry>
{% elif host_info.os_vendor == "Apple" -%}
<entry name="anti-malware">
<list>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Xprotect" version="2167" defver="235000000000000" engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="4"/>
<real-time-protection>yes</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Gatekeeper" version="{{ host_info.os_version }}" defver="" engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="4"/>
<real-time-protection>yes</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="disk-backup">
<list>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Time Machine" version="1.3"/>
<last-backup-time>n/a</last-backup-time>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="disk-encryption">
<list>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="FileVault" version="{{ host_info.os_version }}"/>
<drives>
<entry>
<drive-name>Macintosh HD</drive-name>
<enc-state>encrypted</enc-state>
</entry>
<entry>
<drive-name>Data</drive-name>
<enc-state>encrypted</enc-state>
</entry>
<entry>
<drive-name>All</drive-name>
<enc-state>encrypted</enc-state>
</entry>
</drives>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="firewall">
<list>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Mac OS X Builtin Firewall" version="{{ host_info.os_version }}"/>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod vendor="OpenBSD" name="Packet Filter" version="{{ host_info.os_version }}"/>
<is-enabled>no</is-enabled>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="patch-management">
<list>
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Software Update" version="3.0"/>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
</list>
<missing-patches>
</missing-patches>
</entry>
{% elif host_info.os_vendor == "Linux" -%}
<entry name="anti-malware">
<list/>
</entry>
<entry name="disk-backup">
<list/>
</entry>
<entry name="disk-encryption">
<list>
<entry>
<ProductInfo>
<Prod name="cryptsetup" version="2.3.3" vendor="GitLab Inc.">
</Prod>
<drives>
<entry>
<drive-name>/</drive-name>
<enc-state>encrypted</enc-state>
</entry>
</drives>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="firewall">
<list>
<entry>
<ProductInfo>
<Prod name="IPTables" version="1.8.4" vendor="IPTables">
</Prod>
<is-enabled>no</is-enabled>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod name="nftables" version="0.9.3" vendor="The Netfilter Project">
</Prod>
<is-enabled>n/a</is-enabled>
</ProductInfo>
</entry>
</list>
</entry>
<entry name="patch-management">
<list>
<entry>
<ProductInfo>
<Prod name="Dandified Yum" version="4.2.23" vendor="Red Hat, Inc.">
</Prod>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
</list>
<missing-patches/>
</entry>
{% endif -%}
<entry name="data-loss-prevention">
<list/>
</entry>
</categories>
</hip-report>