feat: add HIP report generation functionality and related dependencies

This commit is contained in:
Kevin Yue committed 2025-12-22 23:16:31 +08:00
1 parent f398ccadb7
commit 7d87442f73
49 files changed
+2757 -1176

No files matched your search

+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,
}
}
}
+41 -16
View File
@@ -1,8 +1,8 @@
use std::{cell::RefCell, fs, sync::Arc};
use std::{borrow::Cow, cell::RefCell, fs, sync::Arc};
use anyhow::bail;
use clap::Args;
use common::constants::GP_USER_AGENT;
use common::constants::{GP_CLIENT_VERSION, GP_USER_AGENT};
use gpapi::{
auth::SamlAuthResult,
clap::{ToVerboseArg, args::Os},
@@ -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};
@@ -86,8 +86,11 @@ pub(crate) struct ConnectArgs {
#[arg(long, help = "Do not ask for IPv6 connectivity")]
disable_ipv6: bool,
#[arg(long, default_value = GP_USER_AGENT, help = "The user agent to use")]
user_agent: String,
#[arg(
long,
help = "The user agent to use, if not specified, it will be generated based on the OS and client version"
)]
user_agent: Option<String>,
#[arg(long, value_enum, default_value_t = ConnectArgs::default_os())]
os: Os,
@@ -130,18 +133,23 @@ pub(crate) struct ConnectArgs {
impl ConnectArgs {
fn default_os() -> Os {
if cfg!(target_os = "macos") { Os::Mac } else { Os::Linux }
#[cfg(target_os = "macos")]
return Os::Mac;
#[cfg(target_os = "windows")]
return Os::Windows;
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
return 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(),
}
}
}
@@ -163,11 +171,25 @@ impl<'a> ConnectHandler<'a> {
}
}
fn user_agent(&self) -> Cow<'_, str> {
if let Some(user_agent) = self.args.user_agent.as_deref() {
Cow::Borrowed(user_agent)
} else {
let client_version = self.args.client_version.as_deref().unwrap_or(GP_CLIENT_VERSION);
Cow::Owned(format!(
"{}/{} ({})",
GP_USER_AGENT,
client_version,
self.args.os_version()
))
}
}
fn build_gp_params(&self) -> GpParams {
GpParams::builder()
.user_agent(&self.args.user_agent)
.user_agent(&self.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())
@@ -331,14 +353,16 @@ impl<'a> ConnectHandler<'a> {
(false, None)
};
let os = ClientOs::from(&self.args.os).to_openconnect_os().to_string();
let os = ClientOs::from(&self.args.os).to_openconnect_os().to_owned();
let os_version = self.args.os_version().to_owned();
let client_version = client_version.map(|s| s.to_owned());
let vpn = Vpn::builder(gateway, cookie)
.script(self.args.script.clone())
.interface(self.args.interface.clone())
.script_tun(self.args.script_tun)
.user_agent(self.args.user_agent.clone())
.user_agent(self.user_agent().into_owned())
.os(Some(os))
.os_version(Some(os_version))
.client_version(client_version)
.certificate(self.args.certificate.clone())
.sslkey(self.args.sslkey.clone())
@@ -394,10 +418,11 @@ impl<'a> ConnectHandler<'a> {
let os_version = self.args.os_version();
let verbose = self.shared_args.verbose.to_verbose_arg();
let user_agent = self.user_agent();
let auth_launcher = SamlAuthLauncher::new(&self.args.server)
.gateway(is_gateway)
.saml_request(prelogin.saml_request())
.user_agent(&self.args.user_agent)
.user_agent(&user_agent)
.os(self.args.os.as_str())
.os_version(Some(&os_version))
.fix_openssl(self.shared_args.fix_openssl)
+374
View File
@@ -0,0 +1,374 @@
use askama::Template;
use clap::Args;
use gpapi::{clap::args::Os, 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,
user_name: &'a str,
host_info: HostInfo<'a>,
md5: &'a str,
}
/// Host information for HIP reporting
struct HostInfo<'a> {
/// Common for all OSes, e.g., "Apple", "Microsoft", "Linux"
os_vendor: &'a str,
/// Common for all OSes, e.g., "Linux Ubuntu 20.04", "Apple Mac OS X 10.15.7", etc.
os_version: &'a str,
/// Only for macOS and Windows
host_id: String,
/// Common for all OSes
host_name: String,
/// Only for macOS and Windows, e.g., "10.15.7", "10.0.19044.2130"
software_version: &'a str,
domain: String,
network_interfaces: Vec<NetworkInterface>,
}
impl<'a> HostInfo<'a> {
/// 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 GP client version, e.g., 6.2.4-49")]
client_version: String,
#[arg(long, value_enum, help = "The client OS")]
client_os: Os,
#[arg(long, help = "The OS version string, e.g., Apple Mac OS X 10.15.7")]
os_version: String,
#[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,
}
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<()> {
let cookie_params = self.parse_cookie();
let report = self.generate_hip_report(&cookie_params)?;
debug!("Generated HIP report:\n{}", report);
println!("{}", report);
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 template = HipReportTemplate {
client_version: &self.args.client_version,
generate_time,
day,
month,
year,
user_name,
host_info,
md5: &self.args.md5,
};
let report = template.render()?;
format_xml(&report)
}
/// Collect host information based on the client OS
fn collect_host_info(&self, cookie_params: &'a HashMap<String, String>) -> HostInfo<'a> {
let collector = HostInfoCollector::new(self.args, cookie_params);
match self.args.client_os {
Os::Linux => collector.collect_linux(),
Os::Mac => collector.collect_macos(),
Os::Windows => 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<'a> {
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",
os_version: &self.args.os_version,
host_id: host_utils::derive_uuid(&[]),
host_name: whoami::devicename(),
software_version: "",
domain: String::new(),
network_interfaces: vec![iface],
}
}
/// Collect macOS-specific host information
fn collect_macos(&self) -> HostInfo<'a> {
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",
os_version: &self.args.os_version,
host_id,
host_name: whoami::devicename(),
software_version: host_utils::get_macos_version(),
domain: self.get_domain(),
network_interfaces: vec![iface],
}
}
/// Collect Windows-specific host information
fn collect_windows(&self) -> HostInfo<'a> {
// 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",
os_version: &self.args.os_version,
host_id,
host_name: whoami::devicename(),
software_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";