feat(hip): manage reports and script execution

This commit is contained in:
Kevin Yue committed 2026-09-29 11:43:54 +08:00
1 parent 24d935ea61
commit 739cf7234b
54 files changed
+3122 -967

No files matched your search

+1 -6
View File
@@ -9,11 +9,10 @@ license.workspace = true
[dependencies]
common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap"] }
gphip = { path = "../../crates/gphip" }
openconnect = { path = "../../crates/openconnect" }
anyhow.workspace = true
askama.workspace = true
chrono.workspace = true
clap.workspace = true
env_logger.workspace = true
inquire = "0.9"
@@ -22,15 +21,11 @@ tokio = { workspace = true, features = ["rt-multi-thread"] }
sysinfo.workspace = true
serde.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
uuid = { workspace = true, features = ["v5"] }
uzers.workspace = true
[features]
+19 -2
View File
@@ -15,7 +15,7 @@ use gpapi::{
gp_params::GpParams,
os_profile::OsProfile,
portal::prelogin,
process::users::{get_non_root_user, get_user_by_name},
process::users::get_user_by_name,
utils::shutdown_signal,
};
use inquire::Text;
@@ -499,7 +499,7 @@ fn get_uid(user: &Option<String>) -> anyhow::Result<u32> {
if let Some(user) = user {
get_user_by_name(user).map(|user| user.uid())
} else {
get_non_root_user().map_or_else(|_| Ok(0), |user| Ok(user.uid()))
Ok(uzers::get_effective_uid())
}
}
@@ -516,6 +516,23 @@ fn apply_os_profile(builder: VpnBuilder, profile: &OsProfile) -> VpnBuilder {
mod tests {
use super::*;
#[test]
fn hip_script_defaults_to_process_effective_uid() {
assert_eq!(get_uid(&None).unwrap(), uzers::get_effective_uid());
}
#[test]
fn explicit_hip_user_must_exist() {
assert!(get_uid(&Some("gpclient-nonexistent-hip-user".to_string())).is_err());
}
#[test]
fn explicit_hip_user_resolves_to_the_selected_account() {
let current = uzers::get_user_by_uid(uzers::get_effective_uid()).unwrap();
let name = current.name().to_string_lossy().into_owned();
assert_eq!(get_uid(&Some(name)).unwrap(), current.uid());
}
#[test]
fn openconnect_success_is_not_a_gateway_failure() {
assert!(classify_openconnect_result(0, false, false).is_ok());
+18 -720
View File
@@ -1,137 +1,9 @@
use askama::Template;
use clap::Args;
use gpapi::{
clap::args::Os,
os_profile::{ClientOs, OsProfile, OsProfileBuilder},
os_profile::{ClientOs, OsProfileBuilder},
};
use log::debug;
use serde::Deserialize;
use std::collections::HashMap;
use std::process::Command;
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,
md5: &'a str,
}
#[derive(Debug, Clone, Deserialize)]
struct DefenderInfo {
#[serde(rename = "appVersion")]
app_version: String,
#[serde(rename = "engineVersion")]
engine_version: String,
#[serde(rename = "definitionsVersion")]
definitions_version: String,
#[serde(rename = "realTimeProtectionEnabled")]
real_time_protection_enabled: RealTimeProtection,
}
#[derive(Debug, Clone, Deserialize)]
struct RealTimeProtection {
value: bool,
}
#[derive(Debug, Clone)]
struct UfwInfo {
version: String,
is_enabled: bool,
}
#[derive(Debug, Clone)]
struct ClamAvInfo {
version: String,
definitions_version: Option<String>,
real_time_protection: bool,
}
/// Host information for HIP reporting
struct HostInfo {
/// Common for all OSes, e.g., "Apple", "Microsoft", "Linux"
os_vendor: String,
/// Common for all OSes, e.g., "Linux Ubuntu 20.04", "Apple Mac OS X 10.15.7", etc.
os_version: String,
/// Per-OS machine identifier (UUID for Linux/Windows, MAC for macOS)
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: String,
domain: String,
network_interfaces: Vec<NetworkInterface>,
defender: Option<DefenderInfo>,
clamav: Option<ClamAvInfo>,
ufw: Option<UfwInfo>,
}
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
}
}
use gphip::{ReportContext, ReportInput, generate_report};
#[derive(Args)]
pub(crate) struct HipArgs {
@@ -162,603 +34,29 @@ pub(crate) struct HipArgs {
pub(crate) struct HipHandler<'a> {
args: &'a HipArgs,
profile: OsProfile,
}
impl<'a> HipHandler<'a> {
pub(crate) fn new(args: &'a HipArgs) -> Self {
let profile = build_os_profile(args);
Self { args, profile }
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);
let client_os = ClientOs::from(self.args.client_os);
let mut builder = OsProfileBuilder::new(client_os).client_version(self.args.client_version.clone());
if let Some(host_id) = self.args.host_id.as_deref() {
builder = builder.host_id_override(host_id);
}
let input = ReportInput {
profile: builder.build(),
context: ReportContext::Connected {
cookie: self.args.cookie.clone(),
client_ip: self.args.client_ip.clone(),
client_ipv6: self.args.client_ipv6.clone(),
md5: self.args.md5.clone(),
},
};
println!("{}", generate_report(&input)?);
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 using the configured OsProfile.
fn collect_host_info(&self, cookie_params: &'a HashMap<String, String>) -> HostInfo {
HostInfoCollector::new(&self.profile, self.args, cookie_params).collect()
}
}
/// Construct an `OsProfile` from CLI args, falling back to per-OS defaults
/// for any value not supplied on the command line.
fn build_os_profile(args: &HipArgs) -> OsProfile {
let client_os = ClientOs::from(args.client_os);
let mut builder = OsProfileBuilder::new(client_os).client_version(args.client_version.clone());
if let Some(host_id) = args.host_id.as_deref() {
debug!("HIP host-id override supplied: {}", host_id);
builder = builder.host_id_override(host_id);
}
let profile = builder.build();
debug!(
"HIP OS profile host-id: runtime={}, projected={}, client_os={}",
profile.host_identity().host_id(),
profile.host_id(),
client_os.as_str()
);
profile
}
// ============================================================================
// Host Information Collector
// ============================================================================
/// Helper struct for collecting host information.
///
/// Identity values (vendor, host_id, computer name, software version) come
/// from the configured `OsProfile`, while runtime state (network interfaces,
/// IP addresses) is enumerated here from the underlying machine.
struct HostInfoCollector<'p, 'a> {
profile: &'p OsProfile,
args: &'a HipArgs,
cookie_params: &'a HashMap<String, String>,
}
impl<'p, 'a> HostInfoCollector<'p, 'a> {
fn new(profile: &'p OsProfile, args: &'a HipArgs, cookie_params: &'a HashMap<String, String>) -> Self {
Self {
profile,
args,
cookie_params,
}
}
/// Domain belongs to the runtime user/session, not the simulated OS, so
/// it is sourced from the auth cookie when available.
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()),
}
}
/// Single entry point for collecting host info — dispatches per-OS
/// behavior via `OsProfile` methods rather than `#[cfg(target_os)]`.
fn collect(&self) -> HostInfo {
let runtime_iface = self.collect_network_interface();
let primary = self.adapt_primary_interface(&runtime_iface);
let mut interfaces = vec![primary.clone()];
interfaces.extend(self.extra_interfaces(&primary));
HostInfo {
os_vendor: self.profile.os_vendor().to_string(),
os_version: self.profile.os_version().to_string(),
host_id: self.profile.host_id().to_string(),
host_name: self.profile.computer().to_string(),
software_version: self.profile.software_version().to_string(),
domain: self.domain_for_profile(),
network_interfaces: interfaces,
defender: self.defender_for_profile(),
clamav: self.clamav_for_profile(),
ufw: self.ufw_for_profile(),
}
}
/// Build the primary network interface with OS-appropriate naming and
/// MAC formatting. When emulating a different OS, the runtime interface
/// name/description are replaced with the canonical placeholder for the
/// target OS.
fn adapt_primary_interface(&self, runtime: &NetworkInterface) -> NetworkInterface {
let (name, description) = if self.profile.is_native() {
(runtime.name.clone(), runtime.description.clone())
} else {
placeholder_interface_for(self.profile, runtime)
};
NetworkInterface {
name,
description,
mac_address: format_mac_for(self.profile, runtime.mac_address.clone()),
ipv4: runtime.ipv4.clone(),
ipv6: runtime.ipv6.clone(),
}
}
/// Additional interfaces appended after the primary. Only Windows
/// emits the software loopback interface in HIP reports.
fn extra_interfaces(&self, primary: &NetworkInterface) -> Vec<NetworkInterface> {
match self.profile.client_os() {
ClientOs::Windows => vec![NetworkInterface {
name: derive_windows_network_name(self.profile.host_id(), primary),
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()),
}],
ClientOs::Linux | ClientOs::Mac => vec![],
}
}
/// Linux HIP reports omit the domain field; macOS/Windows include it
/// from the auth cookie.
fn domain_for_profile(&self) -> String {
match self.profile.client_os() {
ClientOs::Linux => String::new(),
ClientOs::Mac | ClientOs::Windows => self.get_domain(),
}
}
fn defender_for_profile(&self) -> Option<DefenderInfo> {
match self.profile.client_os() {
ClientOs::Linux => detect_microsoft_defender_blocking(),
ClientOs::Mac | ClientOs::Windows => None,
}
}
fn clamav_for_profile(&self) -> Option<ClamAvInfo> {
match self.profile.client_os() {
ClientOs::Linux => detect_clamav(),
ClientOs::Mac | ClientOs::Windows => None,
}
}
fn ufw_for_profile(&self) -> Option<UfwInfo> {
match self.profile.client_os() {
ClientOs::Linux => detect_ufw(),
ClientOs::Mac | ClientOs::Windows => None,
}
}
}
fn detect_clamav() -> Option<ClamAvInfo> {
let version_out = Command::new("clamscan").arg("--version").output().ok()?;
if !version_out.status.success() {
debug!("clamscan not found or failed");
return None;
}
let version_str = String::from_utf8(version_out.stdout).ok()?;
let (version, definitions_version) = parse_clamav_version(&version_str)?;
let rtp_out = Command::new("systemctl")
.args(["is-active", "clamav-onaccess.service"])
.output()
.ok()?;
let real_time_protection = rtp_out.status.success();
Some(ClamAvInfo {
version,
definitions_version,
real_time_protection,
})
}
fn detect_ufw() -> Option<UfwInfo> {
let version_out = Command::new("ufw").arg("version").output().ok()?;
if !version_out.status.success() {
debug!("ufw not found or failed");
return None;
}
let version_str = String::from_utf8(version_out.stdout).ok()?;
let version = parse_ufw_version(&version_str)?;
let is_root = uzers::get_effective_uid() == 0;
let status_out = ufw_status_command(is_root).output().ok()?;
if !status_out.status.success() {
if is_root {
log::warn!("ufw status failed while running as root");
} else {
log::warn!("sudo -n ufw status failed. You may need to configure sudoers to allow execution without a password.");
}
return None;
}
let status_str = String::from_utf8(status_out.stdout).ok()?;
let is_enabled = parse_ufw_status(&status_str)?;
Some(UfwInfo { version, is_enabled })
}
fn ufw_status_command(is_root: bool) -> Command {
let mut command = if is_root {
Command::new("ufw")
} else {
let mut command = Command::new("sudo");
command.args(["-n", "ufw"]);
command
};
command.arg("status").env("LC_ALL", "C");
command
}
fn parse_clamav_version(output: &str) -> Option<(String, Option<String>)> {
let mut output_parts = output.split_whitespace();
if output_parts.next()? != "ClamAV" {
return None;
}
let mut version_parts = output_parts.next()?.split('/');
let version = version_parts.next()?;
if version.is_empty() {
return None;
}
let definitions_version = version_parts
.next()
.filter(|definitions_version| !definitions_version.is_empty())
.map(str::to_string);
Some((version.to_string(), definitions_version))
}
fn parse_ufw_version(output: &str) -> Option<String> {
let mut output_parts = output.split_whitespace();
if output_parts.next()? != "ufw" {
return None;
}
output_parts.next().map(str::to_string)
}
fn parse_ufw_status(output: &str) -> Option<bool> {
let status = output
.lines()
.find_map(|line| line.trim().strip_prefix("Status:"))?
.trim();
match status {
"active" => Some(true),
"inactive" => Some(false),
_ => None,
}
}
fn detect_microsoft_defender_blocking() -> Option<DefenderInfo> {
let output = Command::new("mdatp")
.arg("health")
.arg("--output")
.arg("json")
.output()
.ok()?;
if !output.status.success() {
debug!("mdatp health command failed");
return None;
}
let json = String::from_utf8(output.stdout).ok()?;
let defender = parse_defender_info(&json)?;
debug!("Detected Microsoft Defender: {:?}", defender);
Some(defender)
}
fn parse_defender_info(json: &str) -> Option<DefenderInfo> {
serde_json::from_str(json).ok()
}
// ============================================================================
// Per-OS interface helpers (selected via OsProfile, not cfg)
// ============================================================================
/// Canonical interface name/description for the target OS when the runtime
/// is a different OS (i.e. emulation).
fn placeholder_interface_for(profile: &OsProfile, runtime: &NetworkInterface) -> (String, String) {
match profile.client_os() {
ClientOs::Linux => ("enp1s0f0".to_string(), "enp1s0f0".to_string()),
ClientOs::Mac => ("en0".to_string(), "en0".to_string()),
ClientOs::Windows => (
derive_windows_network_name(profile.host_id(), runtime),
"PANGP Virtual Ethernet Adapter Secure".to_string(),
),
}
}
/// MAC address formatting per target OS. Windows uses hyphen separators;
/// Linux and macOS preserve the colon-separated form returned by the
/// platform.
fn format_mac_for(profile: &OsProfile, mac: Option<String>) -> Option<String> {
match profile.client_os() {
ClientOs::Windows => mac.map(|m| m.replace(':', "-")),
ClientOs::Linux | ClientOs::Mac => mac,
}
}
// ============================================================================
// 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(host_id: &str, iface: &NetworkInterface) -> String {
let seed = format!(
"{}-{}-{}",
host_id,
iface.mac_address.as_deref().unwrap_or("00:00:00:00:00:00"),
iface.name
);
format!(
"{{{}}}",
uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_DNS, seed.as_bytes())
.to_string()
.to_uppercase()
)
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::runtime_client_os;
use std::ffi::OsStr;
fn make_hip_args(client_os: Os) -> HipArgs {
HipArgs {
client_version: "6.2.4-49".to_string(),
client_os,
os_version: Some("test-os-version".to_string()),
host_id: None,
cookie: String::new(),
client_ip: None,
client_ipv6: None,
md5: "deadbeef".to_string(),
}
}
fn make_profile(client_os: ClientOs) -> OsProfile {
OsProfileBuilder::new(client_os).build()
}
#[test]
fn host_info_os_vendor_is_linux_for_linux_profile() {
let args = make_hip_args(Os::Linux);
let profile = make_profile(ClientOs::Linux);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Linux");
}
#[test]
fn host_info_os_vendor_is_apple_for_mac_profile() {
let args = make_hip_args(Os::Mac);
let profile = make_profile(ClientOs::Mac);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Apple");
}
#[test]
fn host_info_os_vendor_is_microsoft_for_windows_profile() {
let args = make_hip_args(Os::Windows);
let profile = make_profile(ClientOs::Windows);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Microsoft");
}
#[test]
fn host_info_host_id_comes_from_os_profile() {
let args = make_hip_args(Os::Linux);
let profile = make_profile(ClientOs::Linux);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.host_id, profile.host_id());
}
#[test]
fn host_info_host_id_independent_of_runtime_for_each_os() {
// host_id should reflect the OsProfile's machine identity for every
// simulated OS, regardless of the runtime platform.
for (client_os, os_arg) in [
(ClientOs::Linux, Os::Linux),
(ClientOs::Mac, Os::Mac),
(ClientOs::Windows, Os::Windows),
] {
let args = make_hip_args(os_arg);
let profile = make_profile(client_os);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.host_id, profile.host_id());
}
}
#[test]
fn hip_os_version_argument_is_ignored() {
let args = make_hip_args(Os::Linux);
let profile = build_os_profile(&args);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_version, profile.os_version());
assert_ne!(info.os_version, "test-os-version");
}
#[test]
fn host_id_argument_sets_profile_runtime_identity() {
let mut args = make_hip_args(Os::default());
args.host_id = Some("auth-host-id".to_string());
let profile = build_os_profile(&args);
assert_eq!(profile.client_os(), runtime_client_os());
assert_eq!(profile.host_identity().host_id(), "auth-host-id");
}
#[test]
fn host_info_uses_host_id_argument_for_native_profile() {
let mut args = make_hip_args(Os::default());
args.host_id = Some("auth-host-id".to_string());
let profile = build_os_profile(&args);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(profile.host_identity().host_id(), "auth-host-id");
assert_eq!(info.host_id, profile.host_id());
}
#[test]
fn parses_microsoft_defender_health_json() {
let defender = parse_defender_info(
r#"{
"appVersion": "101.25042.0000",
"engineVersion": "1.1.25040.2",
"definitionsVersion": "1.429.201.0",
"realTimeProtectionEnabled": { "value": true }
}"#,
)
.expect("defender health json should parse");
assert_eq!(defender.app_version, "101.25042.0000");
assert_eq!(defender.engine_version, "1.1.25040.2");
assert_eq!(defender.definitions_version, "1.429.201.0");
assert!(defender.real_time_protection_enabled.value);
}
#[test]
fn rejects_invalid_microsoft_defender_health_json() {
assert!(parse_defender_info("{}").is_none());
}
#[test]
fn parses_clamav_version() {
let version =
parse_clamav_version("ClamAV 1.4.3/27562/Sun Aug 31 10:23:42 2026").expect("ClamAV version should parse");
assert_eq!(version, ("1.4.3".to_string(), Some("27562".to_string())));
}
#[test]
fn parses_clamav_version_without_definitions_version() {
assert_eq!(parse_clamav_version("ClamAV 1.4.3"), Some(("1.4.3".to_string(), None)));
}
#[test]
fn parses_ufw_version() {
assert_eq!(parse_ufw_version("ufw 0.36.2\n"), Some("0.36.2".to_string()));
assert_eq!(parse_ufw_version("unexpected output\n"), None);
}
#[test]
fn parses_ufw_status() {
assert_eq!(parse_ufw_status("Status: active\n"), Some(true));
assert_eq!(parse_ufw_status("Status: inactive\n"), Some(false));
assert_eq!(parse_ufw_status("Status: unknown\n"), None);
}
#[test]
fn runs_ufw_status_directly_as_root() {
let command = ufw_status_command(true);
assert_eq!(command.get_program(), OsStr::new("ufw"));
assert!(command.get_args().eq(["status"].into_iter().map(OsStr::new)));
}
#[test]
fn runs_ufw_status_through_non_interactive_sudo_as_non_root() {
let command = ufw_status_command(false);
assert_eq!(command.get_program(), OsStr::new("sudo"));
assert!(
command
.get_args()
.eq(["-n", "ufw", "status"].into_iter().map(OsStr::new))
);
}
}
-305
View File
@@ -1,305 +0,0 @@
<?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_version }}</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.software_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.software_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.22621.4830" 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.software_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.software_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.software_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.software_version }}"/>
<is-enabled>yes</is-enabled>
</ProductInfo>
</entry>
<entry>
<ProductInfo>
<Prod vendor="OpenBSD" name="Packet Filter" version="{{ host_info.software_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>
{% if let Some(defender) = &host_info.defender %}
<entry>
<ProductInfo>
<Prod name="Microsoft Defender ATP" version="{{ defender.app_version }}" defver="{{ defender.definitions_version }}" prodType="3" engver="{{ defender.engine_version }}" osType="1" vendor="Microsoft Corporation" dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
</Prod>
<real-time-protection>{% if defender.real_time_protection_enabled.value %}yes{% else %}no{% endif %}</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
{% if let Some(clamav) = &host_info.clamav %}
<entry>
<ProductInfo>
<Prod vendor="Cisco Systems, Inc." name="ClamAV" version="{{ clamav.version }}"{% if let Some(definitions_version) = &clamav.definitions_version %} defver="{{ definitions_version }}"{% endif %} engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="1"/>
<real-time-protection>{% if clamav.real_time_protection %}yes{% else %}no{% endif %}</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
</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>
{% if let Some(ufw) = &host_info.ufw %}
<entry>
<ProductInfo>
<Prod vendor="Canonical Ltd." name="UFW" version="{{ ufw.version }}"/>
<is-enabled>{% if ufw.is_enabled %}yes{% else %}no{% endif %}</is-enabled>
</ProductInfo>
</entry>
{% endif -%}
<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>
+2 -4
View File
@@ -246,9 +246,7 @@ async fn run_installer_connection(
rejection.code(),
rejection.message()
)),
ServiceResult::VpncScriptMetadata(_) => {
Err(anyhow::anyhow!("Service sent an unexpected VPNC script metadata reply"))
}
_ => Err(anyhow::anyhow!("Service sent an unexpected GUI installation reply")),
};
let _ = command.reply.send(result);
}
@@ -301,6 +299,7 @@ async fn connect_installer_at(
let (mut socket, _) = connect_async_with_config(endpoint, Some(config), false).await?;
let prelude = ClientPrelude {
product_version: credential.product_version().to_owned(),
hip_protocol_version: gpapi::service::transport::HIP_PROTOCOL_VERSION,
service_instance_id: credential.service_instance_id(),
session_id: credential.session_id(),
};
@@ -633,7 +632,6 @@ mod tests {
snapshot: VpnEnv {
vpn_state: VpnState::Disconnected,
vpnc_script: None,
csd_wrapper: None,
auth_executable: String::new(),
host_info: HostInfo {
host_identity: HostIdentity::collect(),
+3 -1
View File
@@ -7,6 +7,9 @@ license.workspace = true
[dependencies]
common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] }
gphip = { path = "../../crates/gphip" }
base64.workspace = true
sha256.workspace = true
openconnect = { path = "../../crates/openconnect" }
clap.workspace = true
anyhow.workspace = true
@@ -31,4 +34,3 @@ nix = { version = "0.31", features = ["fs", "socket", "user"] }
[dev-dependencies]
tokio-tungstenite = "0.29"
sha256.workspace = true
+137
View File
@@ -0,0 +1,137 @@
use std::{
env, fs,
io::{self, Write},
};
use anyhow::{Context, ensure};
use clap::Parser;
use gpapi::{
clap::args::Os,
os_profile::{ClientOs, OsProfileBuilder},
};
use gphip::{ReportContext, ReportInput, generate_report, refresh_edited_report};
use gpservice::hip_runner_state::{MAX_STATE_BYTES, RunnerReport, STATE_NAME, validate_root_owned_path};
#[derive(Parser)]
struct Args {
#[arg(long)]
client_version: String,
#[arg(long, value_enum)]
client_os: Os,
#[arg(long)]
os_version: Option<String>,
#[arg(long)]
host_id: Option<String>,
#[arg(long)]
cookie: Option<String>,
#[arg(long)]
client_ip: Option<String>,
#[arg(long)]
client_ipv6: Option<String>,
#[arg(long)]
md5: Option<String>,
#[arg(long)]
preview: bool,
}
fn main() {
if let Err(err) = run() {
eprintln!("HIP report generation failed: {err:#}");
std::process::exit(1);
}
}
fn run() -> anyhow::Result<()> {
let args = Args::parse();
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
let original_args: Vec<_> = env::args_os().skip(1).collect();
let executable = env::current_exe().context("Cannot locate HIP runner")?;
validate_root_owned_path(&executable, true)?;
let state = executable
.parent()
.context("HIP runner has no parent")?
.join(STATE_NAME);
let metadata = fs::symlink_metadata(&state).context("Cannot inspect HIP report state")?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink(),
"Invalid HIP report state"
);
use std::os::unix::fs::{MetadataExt, PermissionsExt};
ensure!(
metadata.uid() == 0 && metadata.permissions().mode() & 0o077 == 0,
"HIP report state is not private"
);
ensure!(
metadata.len() <= MAX_STATE_BYTES as u64,
"HIP report state is too large"
);
let bytes = fs::read(&state).context("Cannot read HIP report state")?;
ensure!(bytes.len() <= MAX_STATE_BYTES, "HIP report state is too large");
let report: RunnerReport = serde_json::from_slice(&bytes).context("Invalid HIP report state")?;
// This binary is single-threaded. Clear the VPN and desktop environment
// before host collectors invoke any external system utilities.
for (key, _) in env::vars_os() {
unsafe { env::remove_var(key) };
}
unsafe {
env::set_var("PATH", "/usr/bin:/bin:/usr/sbin:/sbin");
env::set_var("LC_ALL", "C");
env::set_var(
"HOME",
if cfg!(target_os = "macos") {
"/var/root"
} else {
"/root"
},
);
}
let report = match report {
RunnerReport::ApprovedRootScript { approval_id, owner_uid } => {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
let approved = gpservice::hip_approval::resolve(&approval_id, owner_uid)?;
let script_args = original_args.into_iter().filter(|arg| arg != "--preview");
let status = std::process::Command::new(approved.path)
.args(script_args)
.status()
.context("Approved HIP script did not start")?;
ensure!(status.success(), "Approved HIP script failed");
return Ok(());
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
let _ = (approval_id, owner_uid);
anyhow::bail!("Root HIP script approvals are unavailable on this platform");
}
}
report => report,
};
let mut builder = OsProfileBuilder::new(ClientOs::from(args.client_os)).client_version(args.client_version);
if let Some(host_id) = args.host_id {
builder = builder.host_id_override(host_id);
}
let context = if args.preview {
ReportContext::Preview
} else {
ReportContext::Connected {
cookie: args.cookie.context("Missing HIP cookie")?,
client_ip: args.client_ip,
client_ipv6: args.client_ipv6,
md5: args.md5.context("Missing HIP digest")?,
}
};
let input = ReportInput {
profile: builder.build(),
context,
};
let xml = match report {
RunnerReport::Generated => generate_report(&input)?,
RunnerReport::Edited { xml } => refresh_edited_report(&xml, &input)?,
RunnerReport::ApprovedRootScript { .. } => unreachable!("approved script returned before report generation"),
};
io::stdout().write_all(xml.as_bytes())?;
Ok(())
}
@@ -0,0 +1,10 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[path = "privileged_unix.rs"]
mod platform;
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
#[path = "unsupported.rs"]
mod platform;
fn main() {
platform::run();
}
@@ -0,0 +1,56 @@
use std::io::Read;
use anyhow::{Context, ensure};
use clap::{Parser, Subcommand};
use gpservice::hip_approval::{self, InstallRequest};
use nix::unistd::Uid;
const MAX_INSTALL_REQUEST_SIZE: u64 = 2 * 1024 * 1024;
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
command: Command,
}
#[derive(Subcommand)]
enum Command {
Install,
Revoke { approval_id: String },
}
fn try_run() -> anyhow::Result<()> {
ensure!(Uid::effective().is_root(), "HIP script installer must run as root");
let approving_uid = std::env::var("PKEXEC_UID")
.context("HIP script installer requires pkexec authorization")?
.parse::<u32>()
.context("Invalid pkexec user identity")?;
ensure!(approving_uid != 0, "HIP script installer requires a desktop user");
match Cli::parse().command {
Command::Install => {
let mut input = Vec::new();
std::io::stdin()
.lock()
.take(MAX_INSTALL_REQUEST_SIZE + 1)
.read_to_end(&mut input)?;
ensure!(
input.len() as u64 <= MAX_INSTALL_REQUEST_SIZE,
"HIP install request is too large"
);
let request: InstallRequest = serde_json::from_slice(&input).context("Invalid HIP install request")?;
let info = hip_approval::install(request, approving_uid)?;
serde_json::to_writer(std::io::stdout().lock(), &info)?;
println!();
}
Command::Revoke { approval_id } => hip_approval::revoke(&approval_id, approving_uid)?,
}
Ok(())
}
pub(super) fn run() {
if let Err(err) = try_run() {
eprintln!("HIP approval failed: {err:#}");
std::process::exit(1);
}
}
@@ -0,0 +1,4 @@
pub(super) fn run() {
eprintln!("Root HIP script approvals are unavailable on this platform");
std::process::exit(1);
}
+5 -4
View File
@@ -100,7 +100,7 @@ impl Cli {
let gui_restart_requested = Arc::new(AtomicBool::new(false));
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let externally_brokered = self.externally_brokered();
let trusted_csd_uid = crate::runtime_user::trusted_csd_uid()?;
let desktop_uid = crate::runtime_user::desktop_uid();
let brokered_scripts_dir = if externally_brokered {
let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
let contents_dir = executable
@@ -111,7 +111,7 @@ impl Cli {
} else {
None
};
let (mut vpn_task, lifecycle) = VpnTask::new(vpn_state_tx, externally_brokered, trusted_csd_uid);
let (mut vpn_task, lifecycle) = VpnTask::new(vpn_state_tx, externally_brokered, Arc::clone(&registry));
let dispatcher = Arc::new(RequestDispatcher::new(
lifecycle.clone(),
Arc::clone(&gui_restart_requested),
@@ -196,7 +196,7 @@ impl Cli {
let envs = self.env_file.as_ref().map(env_utils::load_env_vars).transpose()?;
let minimized = self.minimized;
tokio::spawn(async move {
launch_gui(envs, registry, minimized, gui_restart_requested).await;
launch_gui(envs, registry, desktop_uid, minimized, gui_restart_requested).await;
let _ = shutdown_tx.send(()).await;
});
} else {
@@ -366,11 +366,12 @@ mod signals {
async fn launch_gui(
envs: Option<HashMap<String, String>>,
registry: Arc<SessionRegistry>,
desktop_uid: Option<u32>,
mut minimized: bool,
restart_requested: Arc<AtomicBool>,
) {
loop {
let credential = match registry.issue(env!("CARGO_PKG_VERSION")) {
let credential = match registry.issue(env!("CARGO_PKG_VERSION"), desktop_uid) {
Ok(credential) => credential,
Err(err) => {
warn!("Failed to issue GUI credential: {err}");
+6 -2
View File
@@ -7,8 +7,12 @@ use tokio::{
use crate::session_registry::SessionRegistry;
pub(crate) async fn serve(mut stream: UnixStream, registry: Arc<SessionRegistry>) -> anyhow::Result<()> {
let credential = registry.issue(env!("CARGO_PKG_VERSION"))?;
pub(crate) async fn serve(
mut stream: UnixStream,
registry: Arc<SessionRegistry>,
desktop_uid: Option<u32>,
) -> anyhow::Result<()> {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), desktop_uid)?;
let session_id = credential.session_id();
let result = async {
stream.write_all(&credential.encode_frame()?).await?;
+2 -2
View File
@@ -54,7 +54,7 @@ impl DevBootstrap {
}
let registry = Arc::clone(&self.registry);
tokio::spawn(async move {
if let Err(err) = credential_lease::serve(stream, registry).await {
if let Err(err) = credential_lease::serve(stream, registry, Some(self.allowed_uid)).await {
warn!("Debug credential client ended: {err}");
}
});
@@ -188,7 +188,7 @@ mod tests {
async fn anchor_eof_revokes_issued_credential() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let (service, mut client) = UnixStream::pair().unwrap();
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(&registry)));
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(&registry), Some(1234)));
let mut header = [0_u8; 2];
client.read_exact(&mut header).await.unwrap();
+400
View File
@@ -0,0 +1,400 @@
use std::{
fs::{self, File, OpenOptions},
io::Write,
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
};
use anyhow::{Context, ensure};
use base64::{Engine, engine::general_purpose::STANDARD};
use gpapi::service::hip::HipApprovalStatus;
use serde::{Deserialize, Serialize};
use tempfile::Builder;
use uuid::Uuid;
use crate::hip_runner_state::validate_root_owned_path;
#[cfg(target_os = "linux")]
pub const APPROVAL_DIRECTORY: &str = "/var/lib/gpclient/hip-approvals";
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
pub const APPROVAL_DIRECTORY: &str = "/var/db/gpclient/hip-approvals";
pub const MAX_SCRIPT_SIZE: usize = common::constants::MAX_HIP_SCRIPT_SIZE;
const MAX_METADATA_SIZE: u64 = 8 * 1024;
const METADATA_VERSION: u8 = 1;
const SCRIPT_NAME: &str = "script";
const METADATA_NAME: &str = "metadata.json";
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InstallRequest {
pub original_path: String,
pub contents_base64: String,
}
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct ApprovalInfo {
pub approval_id: String,
pub owner_uid: u32,
pub sha256: String,
pub original_path: String,
}
#[derive(Clone, Debug)]
pub struct ApprovedScript {
pub info: ApprovalInfo,
pub path: PathBuf,
}
#[derive(Deserialize, Serialize)]
struct StoredMetadata {
version: u8,
info: ApprovalInfo,
}
impl InstallRequest {
fn contents(&self) -> anyhow::Result<Vec<u8>> {
ensure!(self.original_path.len() <= 4096, "HIP script path is too long");
ensure!(
Path::new(&self.original_path).is_absolute(),
"HIP script path must be absolute"
);
ensure!(
!self.original_path.contains('\0'),
"HIP script path contains a NUL byte"
);
ensure!(
self.contents_base64.len() <= (MAX_SCRIPT_SIZE + 2).div_ceil(3) * 4,
"HIP script exceeds 1 MiB"
);
let contents = STANDARD
.decode(&self.contents_base64)
.context("Invalid HIP script content encoding")?;
ensure!(
!contents.is_empty() && contents.len() <= MAX_SCRIPT_SIZE,
"HIP script must be 1 MiB or smaller"
);
Ok(contents)
}
}
pub fn install(request: InstallRequest, approving_uid: u32) -> anyhow::Result<ApprovalInfo> {
ensure!(approving_uid != 0, "Root cannot approve a desktop HIP script");
let contents = request.contents()?;
let base = Path::new(APPROVAL_DIRECTORY);
fs::create_dir_all(base).context("Cannot create HIP approval directory")?;
validate_root_owned_path(base, false)?;
fs::set_permissions(base, fs::Permissions::from_mode(0o700))?;
install_at(base, &contents, request.original_path, approving_uid, 0)
}
pub fn resolve(approval_id: &str, desktop_uid: u32) -> anyhow::Result<ApprovedScript> {
ensure!(desktop_uid != 0, "Root is not a desktop HIP approval owner");
let base = Path::new(APPROVAL_DIRECTORY);
validate_root_owned_path(base, false)?;
resolve_at(base, approval_id, desktop_uid, 0)
}
pub fn revoke(approval_id: &str, approving_uid: u32) -> anyhow::Result<()> {
ensure!(approving_uid != 0, "Root cannot revoke another user's HIP approval");
let base = Path::new(APPROVAL_DIRECTORY);
validate_root_owned_path(base, false)?;
revoke_at(base, approval_id, approving_uid, 0)
}
pub fn status(approval_id: &str, desktop_uid: u32) -> anyhow::Result<HipApprovalStatus> {
status_at(Path::new(APPROVAL_DIRECTORY), approval_id, desktop_uid, 0)
}
fn status_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<HipApprovalStatus> {
ensure!(desktop_uid != 0, "HIP approval status requires a desktop user");
validate_id(approval_id)?;
for path in [
base.to_path_buf(),
base.join(approval_id),
base.join(approval_id).join(METADATA_NAME),
] {
match fs::symlink_metadata(&path) {
Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(HipApprovalStatus::Revoked),
Err(_) => return Ok(HipApprovalStatus::Corrupt),
Ok(_) => {}
}
}
if validate_private_dir(base, file_owner).is_err()
|| (file_owner == 0 && validate_root_owned_path(base, false).is_err())
{
return Ok(HipApprovalStatus::Corrupt);
}
let info = match read_metadata_unbound_at(base, approval_id, file_owner) {
Ok(info) => info,
Err(_) => return Ok(HipApprovalStatus::Corrupt),
};
if info.owner_uid != desktop_uid {
return Ok(HipApprovalStatus::OtherUser);
}
Ok(if resolve_at(base, approval_id, desktop_uid, file_owner).is_ok() {
HipApprovalStatus::Valid
} else {
HipApprovalStatus::Corrupt
})
}
fn install_at(
base: &Path,
contents: &[u8],
original_path: String,
approving_uid: u32,
file_owner: u32,
) -> anyhow::Result<ApprovalInfo> {
validate_private_dir(base, file_owner)?;
ensure!(
!contents.is_empty() && contents.len() <= MAX_SCRIPT_SIZE,
"HIP script must be 1 MiB or smaller"
);
let approval_id = Uuid::new_v4().to_string();
let info = ApprovalInfo {
approval_id: approval_id.clone(),
owner_uid: approving_uid,
sha256: sha256::digest(contents),
original_path,
};
let staged = Builder::new().prefix(".install-").tempdir_in(base)?;
fs::set_permissions(staged.path(), fs::Permissions::from_mode(0o700))?;
validate_private_dir(staged.path(), file_owner)?;
let script = staged.path().join(SCRIPT_NAME);
write_new(&script, contents, 0o500)?;
let metadata = staged.path().join(METADATA_NAME);
let stored = StoredMetadata {
version: METADATA_VERSION,
info: info.clone(),
};
let encoded = serde_json::to_vec(&stored)?;
ensure!(
encoded.len() as u64 <= MAX_METADATA_SIZE,
"HIP approval metadata is too large"
);
write_new(&metadata, &encoded, 0o600)?;
File::open(staged.path())?.sync_all()?;
let target = base.join(&approval_id);
ensure!(!target.exists(), "HIP approval ID collision");
fs::rename(staged.path(), &target).context("Cannot publish HIP approval")?;
File::open(base)?.sync_all()?;
Ok(info)
}
fn resolve_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovedScript> {
let info = read_metadata_at(base, approval_id, desktop_uid, file_owner)?;
let script = base.join(approval_id).join(SCRIPT_NAME);
validate_file(&script, file_owner, 0o500, MAX_SCRIPT_SIZE as u64)?;
let contents = fs::read(&script)?;
ensure!(!contents.is_empty(), "Approved HIP script is empty");
ensure!(
sha256::digest(&contents) == info.sha256,
"Approved HIP script digest mismatch"
);
Ok(ApprovedScript { info, path: script })
}
fn read_metadata_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovalInfo> {
let info = read_metadata_unbound_at(base, approval_id, file_owner)?;
ensure!(info.owner_uid == desktop_uid, "HIP approval belongs to another user");
Ok(info)
}
fn read_metadata_unbound_at(base: &Path, approval_id: &str, file_owner: u32) -> anyhow::Result<ApprovalInfo> {
validate_id(approval_id)?;
validate_private_dir(base, file_owner)?;
let directory = base.join(approval_id);
validate_private_dir(&directory, file_owner)?;
let metadata_path = directory.join(METADATA_NAME);
validate_file(&metadata_path, file_owner, 0o600, MAX_METADATA_SIZE)?;
let stored: StoredMetadata = serde_json::from_slice(&fs::read(metadata_path)?)?;
ensure!(stored.version == METADATA_VERSION, "Unsupported HIP approval version");
ensure!(stored.info.approval_id == approval_id, "HIP approval ID mismatch");
ensure!(
stored.info.sha256.len() == 64 && stored.info.sha256.bytes().all(|byte| byte.is_ascii_hexdigit()),
"Invalid HIP approval digest"
);
Ok(stored.info)
}
fn revoke_at(base: &Path, approval_id: &str, approving_uid: u32, file_owner: u32) -> anyhow::Result<()> {
validate_id(approval_id)?;
let directory = base.join(approval_id);
// The GUI may retry after removal succeeds but saving its settings fails.
if let Err(err) = fs::symlink_metadata(&directory) {
if err.kind() == std::io::ErrorKind::NotFound {
return Ok(());
}
return Err(err).context("Cannot inspect HIP approval directory");
}
read_metadata_at(base, approval_id, approving_uid, file_owner)?;
// Renaming first makes revocation atomic for the runner. Cleanup is separate:
// a failed cleanup cannot make this approval executable again.
let revoked = base.join(format!(".revoked-{approval_id}"));
fs::rename(&directory, &revoked).context("Cannot revoke HIP approval")?;
File::open(base)?.sync_all()?;
if let Err(err) = fs::remove_dir_all(&revoked) {
log::warn!("HIP approval was revoked but its snapshot could not be removed: {err}");
} else {
File::open(base)?.sync_all()?;
}
Ok(())
}
fn write_new(path: &Path, bytes: &[u8], mode: u32) -> anyhow::Result<()> {
let mut file = OpenOptions::new().write(true).create_new(true).mode(mode).open(path)?;
file.write_all(bytes)?;
file.sync_all()?;
Ok(())
}
fn validate_id(value: &str) -> anyhow::Result<()> {
let parsed = Uuid::parse_str(value).context("Invalid HIP approval ID")?;
ensure!(parsed.to_string() == value, "HIP approval ID must use canonical form");
Ok(())
}
fn validate_private_dir(path: &Path, owner_uid: u32) -> anyhow::Result<()> {
let metadata = fs::symlink_metadata(path).with_context(|| format!("Cannot inspect {}", path.display()))?;
ensure!(
metadata.is_dir() && !metadata.file_type().is_symlink(),
"HIP approval directory is not a directory"
);
ensure!(
metadata.uid() == owner_uid && metadata.permissions().mode() & 0o077 == 0,
"HIP approval directory {} is not private (owner {}, mode {:o})",
path.display(),
metadata.uid(),
metadata.permissions().mode() & 0o777
);
Ok(())
}
fn validate_file(path: &Path, owner_uid: u32, mode: u32, max_size: u64) -> anyhow::Result<()> {
let metadata = fs::symlink_metadata(path).with_context(|| format!("Cannot inspect {}", path.display()))?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink(),
"HIP approval file is not regular"
);
ensure!(
metadata.uid() == owner_uid && metadata.permissions().mode() & 0o777 == mode,
"HIP approval file has unsafe ownership or mode"
);
ensure!(metadata.len() <= max_size, "HIP approval file is too large");
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture() -> (tempfile::TempDir, u32) {
let base = tempfile::tempdir().unwrap();
fs::set_permissions(base.path(), fs::Permissions::from_mode(0o700)).unwrap();
let owner = fs::symlink_metadata(base.path()).unwrap().uid();
(base, owner)
}
#[test]
fn install_request_rejects_oversized_or_relative_script() {
let request = InstallRequest {
original_path: "hip.sh".into(),
contents_base64: STANDARD.encode(b"#!/bin/sh\n"),
};
assert!(request.contents().is_err());
let oversized = InstallRequest {
original_path: "/home/user/hip.sh".into(),
contents_base64: STANDARD.encode(vec![b'x'; MAX_SCRIPT_SIZE + 1]),
};
assert!(oversized.contents().is_err());
}
#[test]
fn approval_binds_owner_and_exact_script_digest() {
let (base, owner) = fixture();
let info = install_at(
base.path(),
b"#!/bin/sh\necho ok\n",
"/home/user/hip.sh".into(),
1000,
owner,
)
.unwrap();
let approved = resolve_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert_eq!(approved.info.sha256, info.sha256);
assert!(resolve_at(base.path(), &info.approval_id, 1001, owner).is_err());
fs::set_permissions(&approved.path, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(&approved.path, b"#!/bin/sh\necho changed\n").unwrap();
fs::set_permissions(&approved.path, fs::Permissions::from_mode(0o500)).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
#[test]
fn revoked_approval_is_unavailable() {
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
assert!(revoke_at(base.path(), &info.approval_id, 1001, owner).is_err());
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
#[test]
fn status_distinguishes_owner_corruption_and_revocation() {
let (base, owner) = fixture();
let info = install_at(
base.path(),
b"#!/bin/sh\necho ok\n",
"/home/user/hip.sh".into(),
1000,
owner,
)
.unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner).unwrap(),
HipApprovalStatus::Valid
);
assert_eq!(
status_at(base.path(), &info.approval_id, 1001, owner).unwrap(),
HipApprovalStatus::OtherUser
);
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::set_permissions(&script, fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner).unwrap(),
HipApprovalStatus::Corrupt
);
fs::remove_file(base.path().join(&info.approval_id).join(METADATA_NAME)).unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner).unwrap(),
HipApprovalStatus::Revoked
);
}
#[test]
fn revoke_succeeds_if_script_was_corrupted() {
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::set_permissions(&script, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(&script, b"changed").unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert!(!base.path().join(&info.approval_id).exists());
}
#[test]
fn rejects_symlinked_script() {
use std::os::unix::fs::symlink;
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::remove_file(&script).unwrap();
symlink("/bin/sh", &script).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
}
+275
View File
@@ -0,0 +1,275 @@
use std::{os::unix::process::CommandExt, process::Stdio, sync::Arc, time::Duration};
use anyhow::{Context, bail, ensure};
use gpapi::service::{hip::HipSource, request::PreviewHipReportRequest};
use tokio::{io::AsyncReadExt, process::Command};
const MAX_PREVIEW_BYTES: u64 = 1024 * 1024;
const PREVIEW_TIMEOUT: Duration = Duration::from_secs(60);
const PREVIEW_COOKIE: &str = "user=preview&domain=preview&computer=preview";
const PREVIEW_IP: &str = "192.0.2.1";
const PREVIEW_MD5: &str = "00000000000000000000000000000000";
pub(crate) async fn generate(
request: PreviewHipReportRequest,
edited_report: Option<Arc<str>>,
desktop_uid: Option<u32>,
) -> anyhow::Result<String> {
ensure!(request.client_version.len() <= 64, "Invalid HIP client version");
ensure!(
request.host_id.as_ref().is_none_or(|id| id.len() <= 256),
"Invalid HIP host ID"
);
let source = &request.source;
let execution = match source {
HipSource::Disabled => bail!("HIP is disabled"),
HipSource::Generated | HipSource::Edited { .. } => crate::hip_source::preview_runner(edited_report)?,
HipSource::UserScript { .. } | HipSource::ApprovedRootScript { .. } => {
crate::hip_source::resolve(source, desktop_uid, false, None)?
}
};
let script = execution
.wrapper
.as_deref()
.context("HIP preview script is unavailable")?;
let is_runner = !matches!(source, HipSource::UserScript { .. });
let mut command = Command::new(script);
command
.arg("--client-version")
.arg(&request.client_version)
.arg("--client-os")
.arg(request.client_os.as_str())
.arg("--os-version")
.arg(request.client_os.default_os_version());
if let Some(host_id) = request.host_id {
command.arg("--host-id").arg(host_id);
}
if is_runner {
command.arg("--preview");
}
command
.arg("--cookie")
.arg(PREVIEW_COOKIE)
.arg("--client-ip")
.arg(PREVIEW_IP)
.arg("--md5")
.arg(PREVIEW_MD5)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null());
command.as_std_mut().process_group(0);
configure_identity(&mut command, execution.uid, &request.client_version)?;
command.kill_on_drop(true);
let mut child = command.spawn().context("Failed to launch HIP preview")?;
let mut process_group = ProcessGroupGuard::new(child.id());
let mut stdout = child
.stdout
.take()
.context("HIP preview has no output stream")?
.take(MAX_PREVIEW_BYTES + 1);
let output = tokio::time::timeout(PREVIEW_TIMEOUT, async {
let mut bytes = Vec::new();
stdout.read_to_end(&mut bytes).await?;
ensure!(bytes.len() as u64 <= MAX_PREVIEW_BYTES, "HIP preview exceeds 1 MiB");
let status = child.wait().await?;
process_group.disarm();
ensure!(status.success(), "HIP preview generator failed");
Ok::<_, anyhow::Error>(String::from_utf8(bytes)?)
})
.await;
match output {
Ok(Ok(xml)) => {
if matches!(
source,
HipSource::UserScript { .. } | HipSource::ApprovedRootScript { .. }
) {
gphip::validate_edited_report(&xml).context("Custom HIP script did not emit a valid HIP report")?;
}
Ok(xml)
}
Ok(Err(error)) => {
terminate_group(&mut child, &mut process_group).await;
Err(error)
}
Err(_) => {
terminate_group(&mut child, &mut process_group).await;
anyhow::bail!("HIP preview timed out")
}
}
}
fn configure_identity(command: &mut Command, uid: u32, app_version: &str) -> anyhow::Result<()> {
command
.as_std_mut()
.env_clear()
.env("PATH", "/usr/bin:/bin:/usr/sbin:/sbin")
.env("LC_ALL", "C")
.env("APP_VERSION", app_version);
if uid == 0 {
command.as_std_mut().env("HOME", "/root");
return Ok(());
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
use nix::unistd::{Uid, User};
let user = User::from_uid(Uid::from_raw(uid))?.context("Desktop user is unavailable")?;
command
.as_std_mut()
.env("HOME", &user.dir)
.env("USER", &user.name)
.env("LOGNAME", &user.name)
.current_dir(&user.dir);
if Uid::effective().as_raw() == uid {
return Ok(());
}
// Match OpenConnect's CSD child: a single primary group, then the desktop UID.
unsafe {
command.as_std_mut().pre_exec(move || {
nix::unistd::setgid(user.gid).map_err(std::io::Error::from)?;
nix::unistd::setgroups(&[user.gid]).map_err(std::io::Error::from)?;
nix::unistd::setuid(Uid::from_raw(uid)).map_err(std::io::Error::from)?;
Ok(())
});
}
Ok(())
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
bail!("Custom HIP previews are unavailable on this platform")
}
}
struct ProcessGroupGuard(Option<u32>);
impl ProcessGroupGuard {
fn new(pid: Option<u32>) -> Self {
Self(pid)
}
fn kill(&mut self) {
if let Some(pid) = self.0.take() {
unsafe { nix::libc::kill(-(pid as i32), nix::libc::SIGKILL) };
}
}
fn disarm(&mut self) {
self.0 = None;
}
}
impl Drop for ProcessGroupGuard {
fn drop(&mut self) {
self.kill();
}
}
async fn terminate_group(child: &mut tokio::process::Child, process_group: &mut ProcessGroupGuard) {
process_group.kill();
let _ = child.start_kill();
let _ = child.wait().await;
}
#[cfg(all(test, any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
mod tests {
use super::*;
use gpapi::os_profile::ClientOs;
use std::{fs, os::unix::fs::PermissionsExt};
fn request(path: &std::path::Path) -> PreviewHipReportRequest {
PreviewHipReportRequest {
source: HipSource::UserScript {
path: path.to_string_lossy().into_owned(),
},
client_os: ClientOs::Linux,
client_version: "6.3.3".into(),
host_id: Some("host-test".into()),
}
}
fn script(path: &std::path::Path, body: &str) {
fs::write(path, format!("#!/bin/sh\n{body}\n")).unwrap();
fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap();
}
#[tokio::test]
async fn user_script_preview_receives_placeholders_and_validates_output() {
let uid = nix::unistd::Uid::effective().as_raw();
if uid == 0 {
return;
}
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("hip.sh");
script(
&path,
r#"
test "$1" = --client-version && test "$2" = 6.3.3 || exit 2
test "$3" = --client-os && test "$4" = Linux || exit 2
test "$5" = --os-version || exit 2
test "$7" = --host-id && test "$8" = host-test || exit 2
test "$9" = --cookie && test "${10}" = 'user=preview&domain=preview&computer=preview' || exit 2
test "${11}" = --client-ip && test "${12}" = 192.0.2.1 || exit 2
test "${13}" = --md5 && test "${14}" = 00000000000000000000000000000000 || exit 2
test "$#" = 14 || exit 2
test "$APP_VERSION" = 6.3.3 || exit 2
printf '%s' '<hip-report><md5-sum/><user-name/><domain/><host-name/><host-id/><ip-address/><ipv6-address/><generate-time/><hip-report-version/><categories><entry name="host-info"><client-version/><os/><os-vendor/><domain/><host-name/><host-id/></entry></categories></hip-report>'
"#,
);
let xml = generate(request(&path), None, Some(uid)).await.unwrap();
assert!(xml.starts_with("<hip-report>"));
script(&path, "printf '%s' '<not-hip/>'");
assert!(generate(request(&path), None, Some(uid)).await.is_err());
script(&path, "head -c 1048577 /dev/zero");
let err = generate(request(&path), None, Some(uid)).await.unwrap_err();
assert!(err.to_string().contains("exceeds 1 MiB"));
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn cancelling_preview_stops_its_process_group() {
let uid = nix::unistd::Uid::effective().as_raw();
if uid == 0 {
return;
}
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("hip.sh");
let pid_file = dir.path().join("pids");
script(
&path,
&format!(
"sleep 30 & child=$!; echo \"$$ $child\" > \"{}\"; wait",
pid_file.display()
),
);
let preview = tokio::spawn(generate(request(&path), None, Some(uid)));
let pids = tokio::time::timeout(Duration::from_secs(3), async {
loop {
if let Ok(pids) = fs::read_to_string(&pid_file) {
break pids;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let child_pid = pids.split_whitespace().nth(1).unwrap().parse::<u32>().unwrap();
preview.abort();
assert!(preview.await.unwrap_err().is_cancelled());
tokio::time::timeout(Duration::from_secs(3), async {
loop {
let state = fs::read_to_string(format!("/proc/{child_pid}/stat"))
.ok()
.and_then(|stat| stat.rsplit_once(") ").and_then(|(_, fields)| fields.chars().next()));
if state.is_none_or(|state| state == 'Z') {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
}
}
+59
View File
@@ -0,0 +1,59 @@
use std::{
fs,
os::unix::fs::{MetadataExt, PermissionsExt},
path::Path,
};
use anyhow::{Context, ensure};
use serde::{Deserialize, Serialize};
pub const RUNNER_NAME: &str = "gp-hip-runner";
pub const STATE_NAME: &str = "report.json";
pub const MAX_STATE_BYTES: usize = 512 * 1024;
#[derive(Deserialize, Serialize)]
#[serde(tag = "source", rename_all = "camelCase")]
pub enum RunnerReport {
Generated,
Edited { xml: String },
ApprovedRootScript { approval_id: String, owner_uid: u32 },
}
/// Check every component because a trusted file below a writable parent can
/// be replaced before a later HIP refresh.
pub fn validate_root_owned_path(path: &Path, file: bool) -> anyhow::Result<()> {
ensure!(path.is_absolute(), "HIP runner path must be absolute");
for component in path.ancestors().take_while(|part| part.as_os_str() != "/") {
let metadata =
fs::symlink_metadata(component).with_context(|| format!("Cannot inspect {}", component.display()))?;
ensure!(!metadata.file_type().is_symlink(), "HIP runner path contains a symlink");
ensure!(metadata.uid() == 0, "HIP runner path is not root-owned");
ensure!(
metadata.permissions().mode() & 0o022 == 0,
"HIP runner path is writable by another user"
);
if component == path && file {
ensure!(metadata.is_file(), "HIP runner is not a regular file");
ensure!(
metadata.permissions().mode() & 0o111 != 0,
"HIP runner is not executable"
);
} else {
ensure!(metadata.is_dir(), "HIP runner parent is not a directory");
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_user_owned_runner_directory() {
let temp = tempfile::tempdir().unwrap();
if unsafe { nix::libc::geteuid() } != 0 {
assert!(validate_root_owned_path(temp.path(), false).is_err());
}
}
}
+291
View File
@@ -0,0 +1,291 @@
use std::{
fs::{self, OpenOptions},
io::Write,
os::unix::fs::{OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
sync::Arc,
};
use anyhow::{Context, bail, ensure};
use gpapi::service::hip::HipSource;
use gpservice::hip_runner_state::{MAX_STATE_BYTES, RUNNER_NAME, RunnerReport, STATE_NAME, validate_root_owned_path};
use tempfile::{Builder, TempDir};
pub(crate) struct HipExecution {
pub enabled: bool,
pub uid: u32,
pub wrapper: Option<String>,
_state_dir: Option<TempDir>,
approval: Option<(String, u32)>,
}
impl HipExecution {
fn disabled() -> Self {
Self {
enabled: false,
uid: 0,
wrapper: None,
_state_dir: None,
approval: None,
}
}
fn script(uid: u32, wrapper: PathBuf, state_dir: Option<TempDir>) -> Self {
Self {
enabled: true,
uid,
wrapper: Some(wrapper.to_string_lossy().into_owned()),
_state_dir: state_dir,
approval: None,
}
}
pub(crate) fn approval_id(&self) -> Option<&str> {
self.approval.as_ref().map(|(id, _)| id.as_str())
}
pub(crate) fn approval_is_valid(&self) -> bool {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
if let Some((id, uid)) = &self.approval {
return gpservice::hip_approval::resolve(id, *uid).is_ok();
}
true
}
}
pub(crate) fn resolve(
source: &HipSource,
desktop_uid: Option<u32>,
brokered_macos: bool,
edited_report: Option<Arc<str>>,
) -> anyhow::Result<HipExecution> {
match source {
HipSource::Disabled => Ok(HipExecution::disabled()),
HipSource::Generated => stage_runner(RunnerReport::Generated),
HipSource::Edited { .. } => {
let xml = edited_report.context("Edited HIP report was not uploaded for this connection")?;
gphip::validate_edited_report(&xml)?;
stage_runner(RunnerReport::Edited { xml: xml.to_string() })
}
HipSource::UserScript { path } => {
if cfg!(target_os = "macos") || brokered_macos {
bail!("Custom HIP scripts are unavailable on macOS");
}
let uid = desktop_uid.context("HIP custom scripts require a verified desktop user")?;
ensure!(uid != 0, "HIP custom scripts require a non-root desktop user");
let path = PathBuf::from(path);
let metadata = fs::symlink_metadata(&path).context("Failed to inspect the HIP script")?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o111 != 0,
"HIP custom script must be an executable regular file"
);
Ok(HipExecution::script(uid, path, None))
}
HipSource::ApprovedRootScript { approval_id } => {
if cfg!(target_os = "macos") || brokered_macos {
bail!("Custom HIP scripts are unavailable on macOS");
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
let owner_uid = desktop_uid.context("Root HIP scripts require a verified desktop user")?;
gpservice::hip_approval::resolve(approval_id, owner_uid)?;
let mut execution = stage_runner(RunnerReport::ApprovedRootScript {
approval_id: approval_id.clone(),
owner_uid,
})?;
execution.approval = Some((approval_id.clone(), owner_uid));
Ok(execution)
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
let _ = (approval_id, desktop_uid);
bail!("Root HIP script approvals are unavailable on this platform")
}
}
}
}
pub(crate) fn preview_runner(edited_report: Option<Arc<str>>) -> anyhow::Result<HipExecution> {
let report = if let Some(xml) = edited_report {
gphip::validate_edited_report(&xml)?;
RunnerReport::Edited { xml: xml.to_string() }
} else {
RunnerReport::Generated
};
stage_runner(report)
}
fn stage_runner(report: RunnerReport) -> anyhow::Result<HipExecution> {
let source = packaged_runner()?;
let base = runner_state_base();
fs::create_dir_all(base).context("Cannot create HIP runtime directory")?;
validate_root_owned_path(base, false)?;
fs::set_permissions(base, fs::Permissions::from_mode(0o700))?;
let state_dir = Builder::new().prefix("session-").tempdir_in(base)?;
fs::set_permissions(state_dir.path(), fs::Permissions::from_mode(0o700))?;
validate_root_owned_path(state_dir.path(), false)?;
let runner = state_dir.path().join(RUNNER_NAME);
fs::copy(&source, &runner).context("Cannot stage HIP runner")?;
fs::set_permissions(&runner, fs::Permissions::from_mode(0o500))?;
validate_root_owned_path(&runner, true)?;
verify_staged_runner(&runner)?;
let encoded_state = serde_json::to_vec(&report)?;
ensure!(
encoded_state.len() <= MAX_STATE_BYTES,
"HIP runner state exceeds its size limit"
);
let state = state_dir.path().join(STATE_NAME);
let mut state_file = OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&state)?;
state_file.write_all(&encoded_state)?;
state_file.flush()?;
Ok(HipExecution::script(0, runner, Some(state_dir)))
}
fn runner_state_base() -> &'static Path {
#[cfg(target_os = "macos")]
{
Path::new("/private/var/db/gpclient/hip")
}
#[cfg(target_os = "linux")]
{
Path::new("/var/lib/gpclient/hip")
}
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
{
Path::new("/var/db/gpclient/hip")
}
}
fn packaged_runner() -> anyhow::Result<PathBuf> {
#[cfg(target_os = "macos")]
let path = std::env::current_exe()
.context("Cannot locate HIP runner")?
.with_file_name(RUNNER_NAME);
#[cfg(target_os = "linux")]
let path = PathBuf::from("/usr/libexec/gpclient/gp-hip-runner");
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
let path = PathBuf::from("/usr/local/libexec/gpclient/gp-hip-runner");
#[cfg(not(target_os = "macos"))]
validate_root_owned_path(&path, true)?;
#[cfg(target_os = "macos")]
verify_packaged_macos_runner(&path)?;
ensure!(path.is_file(), "Bundled HIP runner is missing");
Ok(path)
}
#[cfg(target_os = "macos")]
fn verify_packaged_macos_runner(path: &Path) -> anyhow::Result<()> {
use std::process::Command;
let service = std::env::current_exe()?;
let app = service
.parent()
.and_then(Path::parent)
.and_then(Path::parent)
.context("gpservice is not in an app bundle")?;
ensure!(
path.parent() == service.parent(),
"HIP runner is outside the app Helpers directory"
);
let status = Command::new("/usr/bin/codesign")
.args(["--verify", "--deep", "--strict"])
.arg(app)
.status()?;
ensure!(status.success(), "HIP application bundle signature is invalid");
Ok(())
}
#[cfg(target_os = "macos")]
fn verify_staged_runner(path: &Path) -> anyhow::Result<()> {
use std::process::Command;
let status = Command::new("/usr/bin/codesign")
.args(["--verify", "--strict"])
.arg(path)
.status()?;
ensure!(status.success(), "Staged HIP runner signature is invalid");
let service = std::env::current_exe()?;
ensure!(
signing_team(path)? == signing_team(&service)?,
"HIP runner and service have different signing teams"
);
// The staged runner has no app Frameworks directory. Reject any library
// reference that could resolve through a writable bundle or search path.
let output = Command::new("/usr/bin/otool").arg("-L").arg(path).output()?;
ensure!(output.status.success(), "Cannot inspect HIP runner libraries");
for library in String::from_utf8(output.stdout)?
.lines()
.skip(1)
.filter_map(|line| line.trim().split_whitespace().next())
{
ensure!(
library.starts_with("/usr/lib/") || library.starts_with("/System/Library/"),
"HIP runner loads a library outside the trusted system paths"
);
}
Ok(())
}
#[cfg(target_os = "macos")]
fn signing_team(path: &Path) -> anyhow::Result<String> {
let output = std::process::Command::new("/usr/bin/codesign")
.args(["-d", "--verbose=4"])
.arg(path)
.output()?;
ensure!(output.status.success(), "Cannot inspect code signature");
let details = String::from_utf8(output.stderr)?;
details
.lines()
.find_map(|line| line.strip_prefix("TeamIdentifier="))
.filter(|team| !team.is_empty() && *team != "not set")
.map(str::to_owned)
.context("Signed HIP binary has no team identifier")
}
#[cfg(not(target_os = "macos"))]
fn verify_staged_runner(_path: &Path) -> anyhow::Result<()> {
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn disabled_has_no_script_on_both_gui_platforms() {
for brokered_macos in [false, true] {
let execution = resolve(&HipSource::Disabled, None, brokered_macos, None).unwrap();
assert!(!execution.enabled);
assert!(execution.wrapper.is_none());
}
}
#[test]
fn custom_source_cannot_choose_root_or_run_on_macos() {
let source = HipSource::UserScript {
path: "/tmp/hip.sh".into(),
};
assert!(resolve(&source, None, false, None).is_err());
assert!(resolve(&source, Some(0), false, None).is_err());
assert!(resolve(&source, Some(1000), true, None).is_err());
#[cfg(target_os = "macos")]
assert!(resolve(&source, Some(1000), false, None).is_err());
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[test]
fn root_source_requires_a_bound_user_and_installed_approval() {
let source = HipSource::ApprovedRootScript {
approval_id: "00000000-0000-4000-8000-000000000000".into(),
};
assert!(resolve(&source, None, false, None).is_err());
assert!(resolve(&source, Some(0), false, None).is_err());
assert!(resolve(&source, Some(1000), false, None).is_err());
}
}
+3
View File
@@ -1,2 +1,5 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub mod hip_approval;
pub mod hip_runner_state;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub mod vpnc_script;
+1 -1
View File
@@ -45,7 +45,7 @@ impl CredentialServer {
}
let registry = Arc::clone(&self.registry);
tokio::spawn(async move {
if let Err(err) = credential_lease::serve(stream, registry).await {
if let Err(err) = credential_lease::serve(stream, registry, None).await {
warn!("Broker credential lease ended: {err}");
}
});
+2
View File
@@ -6,6 +6,8 @@ mod dev_bootstrap;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", all(test, unix)))]
mod device_anchor;
mod handlers;
mod hip_preview;
mod hip_source;
#[cfg(target_os = "macos")]
mod macos_broker;
mod request_dispatcher;
+40 -13
View File
@@ -51,7 +51,13 @@ impl RequestDispatcher {
}
}
pub fn dispatch_lifecycle(&self, request: WsRequest) -> Result<WsRequest, ServiceResult> {
pub fn dispatch_lifecycle(
&self,
request: WsRequest,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
session_id: Option<uuid::Uuid>,
) -> Result<WsRequest, ServiceResult> {
match request {
WsRequest::Connect(request) => {
if let Err(message) = self.validate_connect_paths(&request) {
@@ -67,7 +73,11 @@ impl RequestDispatcher {
"Request could not be accepted",
));
}
Err(self.lifecycle.submit_connect(*request))
Err(
self
.lifecycle
.submit_connect(*request, desktop_uid, edited_report, session_id),
)
}
WsRequest::Disconnect(_) => Err(self.lifecycle.request_disconnect()),
request => Ok(request),
@@ -75,7 +85,7 @@ impl RequestDispatcher {
}
pub async fn dispatch(&self, request: WsRequest) -> ServiceResult {
let request = match self.dispatch_lifecycle(request) {
let request = match self.dispatch_lifecycle(request, None, None, None) {
Ok(request) => request,
Err(result) => return result,
};
@@ -121,7 +131,15 @@ impl RequestDispatcher {
}
ServiceResult::Accepted
}
WsRequest::Connect(_) | WsRequest::Disconnect(_) => unreachable!("lifecycle request was already dispatched"),
WsRequest::Connect(_)
| WsRequest::Disconnect(_)
| WsRequest::StoreEditedHipReportChunk(_)
| WsRequest::PreviewHipReport(_)
| WsRequest::GetHipApprovalStatus { .. }
| WsRequest::ReadHipPreviewChunk(_)
| WsRequest::GetLastSubmittedHipReport => {
unreachable!("session-bound request was already dispatched")
}
}
}
@@ -130,12 +148,14 @@ impl RequestDispatcher {
return Ok(());
};
let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned();
let expected_wrapper = scripts.join("hipreport.sh").to_string_lossy().into_owned();
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
return Err("macOS VPN script must be the bundled script");
}
if request.args().csd_wrapper().as_deref() != Some(expected_wrapper.as_str()) {
return Err("macOS HIP wrapper must be the bundled wrapper");
if matches!(
request.args().hip_source(),
gpapi::service::hip::HipSource::UserScript { .. } | gpapi::service::hip::HipSource::ApprovedRootScript { .. }
) {
return Err("macOS does not support custom HIP scripts");
}
if request.args().certificate().is_some() || request.args().sslkey().is_some() {
return Err("macOS client identity must be provided as protected data, not root-readable paths");
@@ -408,7 +428,6 @@ mod tests {
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let request = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()))
.with_certificate(Some("/Users/example/client.pem".to_string()));
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
panic!("brokered mode accepted a root-readable identity path");
@@ -428,16 +447,24 @@ mod tests {
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let bundled = ConnectRequest::new(info.clone(), "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()));
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
let old_layout = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string()));
let old_layout = ConnectRequest::new(info.clone(), "cookie".into())
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
assert_eq!(
dispatcher.validate_connect_paths(&old_layout),
Err("macOS VPN script must be the bundled script")
);
let custom = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_hip_source(gpapi::service::hip::HipSource::UserScript {
path: "/tmp/hip.sh".into(),
});
assert_eq!(
dispatcher.validate_connect_paths(&custom),
Err("macOS does not support custom HIP scripts")
);
}
}
+2 -2
View File
@@ -1,3 +1,3 @@
pub(crate) fn trusted_csd_uid() -> anyhow::Result<Option<u32>> {
Ok(None)
pub(crate) fn desktop_uid() -> Option<u32> {
None
}
+1 -1
View File
@@ -5,4 +5,4 @@ mod platform;
#[path = "default.rs"]
mod platform;
pub(crate) use platform::trusted_csd_uid;
pub(crate) use platform::desktop_uid;
@@ -1,7 +1,9 @@
pub(crate) fn trusted_csd_uid() -> anyhow::Result<Option<u32>> {
let uid = gpapi::process::users::get_non_root_user()?.uid();
if uid == 0 {
anyhow::bail!("The HIP script user must not be root");
pub(crate) fn desktop_uid() -> Option<u32> {
match gpapi::process::users::get_non_root_user() {
Ok(user) => Some(user.uid()),
Err(err) => {
log::warn!("No verified desktop user is available for custom HIP scripts: {err}");
None
}
}
Ok(Some(uid))
}
+274 -4
View File
@@ -13,9 +13,11 @@ use crate::ws_connection::ConnectionControl;
const ACTIVATION_TIMEOUT: Duration = Duration::from_secs(15);
const MAX_PENDING_SESSIONS: usize = 16;
const HIP_PREVIEW_CHUNK_BYTES: usize = 16 * 1024;
pub struct HandshakePermit {
pub session_id: Uuid,
pub desktop_uid: Option<u32>,
pub observed_generation: u64,
pub secret: Zeroizing<[u8; 32]>,
token: Uuid,
@@ -38,6 +40,13 @@ pub enum SessionError {
ReconnectSuperseded,
#[error("session registry is unavailable")]
Unavailable,
#[error("invalid HIP report upload")]
InvalidHipUpload,
}
pub enum HipUploadResult {
Progress(Uuid),
Stored(Uuid),
}
enum SessionStatus {
@@ -55,6 +64,11 @@ enum SessionStatus {
struct SessionRecord {
secret: Zeroizing<[u8; 32]>,
product_version: String,
desktop_uid: Option<u32>,
edited_hip_report: Option<(Uuid, Arc<str>)>,
edited_hip_upload: Option<(Uuid, String)>,
hip_preview: Option<(Uuid, Arc<str>)>,
last_successful_hip_report: Option<Arc<str>>,
status: SessionStatus,
}
@@ -71,7 +85,7 @@ impl SessionRegistry {
}
}
pub fn issue(&self, product_version: &str) -> Result<Arc<SessionCredential>, SessionError> {
pub fn issue(&self, product_version: &str, desktop_uid: Option<u32>) -> Result<Arc<SessionCredential>, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let now = Instant::now();
sessions.retain(|_, record| {
@@ -108,6 +122,11 @@ impl SessionRegistry {
SessionRecord {
secret: Zeroizing::new(*credential.secret()),
product_version: credential.product_version().to_owned(),
desktop_uid,
edited_hip_report: None,
edited_hip_upload: None,
hip_preview: None,
last_successful_hip_report: None,
status: SessionStatus::Pending {
activation_deadline: Instant::now() + ACTIVATION_TIMEOUT,
handshake_token: None,
@@ -186,6 +205,7 @@ impl SessionRegistry {
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
Ok(HandshakePermit {
session_id,
desktop_uid: record.desktop_uid,
observed_generation,
secret: Zeroizing::new(*record.secret),
token,
@@ -278,6 +298,122 @@ impl SessionRegistry {
)
}
pub fn append_edited_hip_report_chunk(
&self,
session_id: Uuid,
upload_id: Option<Uuid>,
offset: usize,
chunk: String,
complete: bool,
) -> Result<HipUploadResult, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
if upload_id.is_none() {
if offset != 0 {
return Err(SessionError::InvalidHipUpload);
}
record.edited_hip_upload = Some((Uuid::new_v4(), String::new()));
}
let (current_id, xml) = record
.edited_hip_upload
.as_mut()
.ok_or(SessionError::InvalidHipUpload)?;
if upload_id.is_some_and(|id| id != *current_id) || offset != xml.len() || chunk.len() > 8 * 1024 {
return Err(SessionError::InvalidHipUpload);
}
if xml.len() + chunk.len() > gphip::MAX_EDITED_REPORT_BYTES {
record.edited_hip_upload = None;
return Err(SessionError::InvalidHipUpload);
}
xml.push_str(&chunk);
if !complete {
return Ok(HipUploadResult::Progress(*current_id));
}
if gphip::validate_edited_report(xml).is_err() {
record.edited_hip_upload = None;
return Err(SessionError::InvalidHipUpload);
}
let (_, xml) = record.edited_hip_upload.take().ok_or(SessionError::InvalidHipUpload)?;
let report_id = Uuid::new_v4();
record.edited_hip_report = Some((report_id, Arc::from(xml)));
Ok(HipUploadResult::Stored(report_id))
}
pub fn edited_hip_report(&self, session_id: Uuid, report_id: Uuid) -> Result<Arc<str>, SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
record
.edited_hip_report
.as_ref()
.filter(|(id, _)| *id == report_id)
.map(|(_, xml)| Arc::clone(xml))
.ok_or(SessionError::Unauthorized)
}
pub fn store_hip_preview(&self, session_id: Uuid, xml: String) -> Result<Uuid, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
let preview_id = Uuid::new_v4();
record.hip_preview = Some((preview_id, Arc::from(xml)));
Ok(preview_id)
}
pub fn hip_preview_chunk(
&self,
session_id: Uuid,
preview_id: Uuid,
offset: usize,
) -> Result<(String, bool), SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
let (_, xml) = record
.hip_preview
.as_ref()
.filter(|(id, _)| *id == preview_id)
.ok_or(SessionError::Unauthorized)?;
if offset > xml.len() || !xml.is_char_boundary(offset) {
return Err(SessionError::Unauthorized);
}
let mut end = (offset + HIP_PREVIEW_CHUNK_BYTES).min(xml.len());
while !xml.is_char_boundary(end) {
end -= 1;
}
Ok((xml[offset..end].to_owned(), end == xml.len()))
}
pub fn store_successful_hip_report(&self, session_id: Uuid, xml: &str) -> Result<(), SessionError> {
if xml.len() > 1024 * 1024 {
return Err(SessionError::Unavailable);
}
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
record.last_successful_hip_report = Some(Arc::from(xml));
Ok(())
}
pub fn last_successful_hip_report(&self, session_id: Uuid) -> Result<Option<Arc<str>>, SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
Ok(record.last_successful_hip_report.as_ref().map(Arc::clone))
}
pub fn clear_successful_hip_report(&self, session_id: Uuid) {
if let Ok(mut sessions) = self.sessions.lock()
&& let Some(record) = sessions.get_mut(&session_id)
{
record.last_successful_hip_report = None;
}
}
pub fn disconnect_if_current(&self, session_id: Uuid, generation: u64) {
let Ok(mut sessions) = self.sessions.lock() else {
return;
@@ -332,10 +468,144 @@ mod tests {
ConnectionControl::new(Uuid::new_v4(), tx).0
}
#[test]
fn credential_retains_verified_desktop_user_across_reconnect() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
assert_eq!(first.desktop_uid, Some(1000));
registry.commit_attach(&first, control()).unwrap();
let reconnect = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
assert_eq!(reconnect.desktop_uid, Some(1000));
}
#[test]
fn edited_hip_report_is_session_bound_and_replaced_without_affecting_pinned_content() {
fn upload(registry: &SessionRegistry, session_id: Uuid, xml: &str) -> Uuid {
let mut upload_id = None;
let mut offset = 0;
while offset < xml.len() {
let mut end = (offset + 8 * 1024).min(xml.len());
while !xml.is_char_boundary(end) {
end -= 1;
}
let complete = end == xml.len();
match registry
.append_edited_hip_report_chunk(session_id, upload_id, offset, xml[offset..end].into(), complete)
.unwrap()
{
HipUploadResult::Progress(id) => upload_id = Some(id),
HipUploadResult::Stored(id) => return id,
}
offset = end;
}
panic!("upload did not complete")
}
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let first_credential = registry.issue("2.6.4", Some(1000)).unwrap();
let second_credential = registry.issue("2.6.4", Some(1001)).unwrap();
for credential in [&first_credential, &second_credential] {
let permit = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
registry.commit_attach(&permit, control()).unwrap();
}
let valid = gphip::generate_report(&gphip::ReportInput {
profile: gpapi::os_profile::OsProfile::builder(gpapi::os_profile::ClientOs::Linux).build(),
context: gphip::ReportContext::Preview,
})
.unwrap();
let first_id = upload(&registry, first_credential.session_id(), &valid);
let pinned = registry
.edited_hip_report(first_credential.session_id(), first_id)
.unwrap();
assert!(matches!(
registry.edited_hip_report(second_credential.session_id(), first_id),
Err(SessionError::Unauthorized)
));
let second_id = upload(&registry, first_credential.session_id(), &valid);
assert!(matches!(
registry.edited_hip_report(first_credential.session_id(), first_id),
Err(SessionError::Unauthorized)
));
assert_eq!(
&*registry
.edited_hip_report(first_credential.session_id(), second_id)
.unwrap(),
valid
);
assert_eq!(&*pinned, valid);
registry.revoke(first_credential.session_id());
assert!(matches!(
registry.edited_hip_report(first_credential.session_id(), second_id),
Err(SessionError::Unauthorized)
));
}
#[test]
fn submitted_report_changes_only_after_success_callback_and_is_session_bound() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let permit = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
registry.commit_attach(&permit, control()).unwrap();
assert!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.is_none()
);
registry
.store_successful_hip_report(credential.session_id(), "first")
.unwrap();
assert_eq!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.as_deref(),
Some("first")
);
let preview_id = registry
.store_hip_preview(credential.session_id(), "é".repeat(8193))
.unwrap();
let (first_chunk, complete) = registry
.hip_preview_chunk(credential.session_id(), preview_id, 0)
.unwrap();
assert!(!complete);
assert!(first_chunk.len() <= HIP_PREVIEW_CHUNK_BYTES);
assert!(
registry
.hip_preview_chunk(credential.session_id(), preview_id, 1)
.is_err()
);
assert_eq!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.as_deref(),
Some("first")
);
registry.clear_successful_hip_report(credential.session_id());
assert!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.is_none()
);
}
#[test]
fn reconnect_uses_generation_compare_and_swap() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4").unwrap();
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
@@ -356,7 +626,7 @@ mod tests {
#[test]
fn failed_initial_handshake_only_revokes_its_own_reservation() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4").unwrap();
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
@@ -370,7 +640,7 @@ mod tests {
#[test]
fn failed_reconnect_keeps_active_connection_authoritative() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4").unwrap();
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
+117 -48
View File
@@ -20,6 +20,7 @@ use log::{info, warn};
use openconnect::{Vpn, VpnSessionInfo};
use tokio::sync::{Notify, mpsc, watch};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use zeroize::Zeroizing;
#[derive(Clone)]
@@ -29,7 +30,13 @@ pub(crate) struct LifecycleHandle {
}
impl LifecycleHandle {
pub fn submit_connect(&self, request: ConnectRequest) -> ServiceResult {
pub fn submit_connect(
&self,
request: ConnectRequest,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
session_id: Option<Uuid>,
) -> ServiceResult {
let attempt = {
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
if admissions.current.is_some() {
@@ -46,7 +53,13 @@ impl LifecycleHandle {
attempt
};
match self.events.try_send(LifecycleEvent::Start { attempt, request }) {
match self.events.try_send(LifecycleEvent::Start {
attempt,
request,
desktop_uid,
edited_report,
session_id,
}) {
Ok(()) => ServiceResult::Accepted,
Err(mpsc::error::TrySendError::Full(_)) => {
self.clear_attempt(attempt);
@@ -169,7 +182,8 @@ impl LifecycleHandle {
#[cfg(test)]
pub(crate) fn for_tests() -> Self {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let registry = Arc::new(crate::session_registry::SessionRegistry::new(Uuid::new_v4()));
let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry);
lifecycle
}
}
@@ -202,18 +216,33 @@ enum AdmissionPhase {
}
enum LifecycleEvent {
Start { attempt: u64, request: ConnectRequest },
Stop { attempt: u64 },
Established { attempt: u64, session: VpnSessionInfo },
Ended { attempt: u64 },
Start {
attempt: u64,
request: ConnectRequest,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
session_id: Option<Uuid>,
},
Stop {
attempt: u64,
},
Established {
attempt: u64,
session: VpnSessionInfo,
},
Ended {
attempt: u64,
},
}
struct ActiveAttempt {
attempt: u64,
session_id: Option<Uuid>,
vpn: Arc<Vpn>,
info: ConnectInfo,
allow_extend_session: bool,
_identity_files: Vec<tempfile::NamedTempFile>,
_hip_execution: crate::hip_source::HipExecution,
}
pub(crate) struct VpnTask {
@@ -221,7 +250,7 @@ pub(crate) struct VpnTask {
lifecycle: LifecycleHandle,
vpn_state_tx: watch::Sender<VpnState>,
brokered_macos: bool,
trusted_csd_uid: Option<u32>,
registry: Arc<crate::session_registry::SessionRegistry>,
active: Option<ActiveAttempt>,
cancel_token: CancellationToken,
}
@@ -230,7 +259,7 @@ impl VpnTask {
pub fn new(
vpn_state_tx: watch::Sender<VpnState>,
brokered_macos: bool,
trusted_csd_uid: Option<u32>,
registry: Arc<crate::session_registry::SessionRegistry>,
) -> (Self, LifecycleHandle) {
let (events_tx, events) = mpsc::channel(4);
let lifecycle = LifecycleHandle {
@@ -242,7 +271,7 @@ impl VpnTask {
lifecycle: lifecycle.clone(),
vpn_state_tx,
brokered_macos,
trusted_csd_uid,
registry,
active: None,
cancel_token: CancellationToken::new(),
};
@@ -256,6 +285,7 @@ impl VpnTask {
pub async fn start(&mut self, server_cancel_token: CancellationToken) {
let cancel_token = self.cancel_token.clone();
let mut shutting_down = false;
let mut approval_poll = tokio::time::interval(std::time::Duration::from_secs(1));
loop {
if shutting_down {
@@ -277,6 +307,14 @@ impl VpnTask {
shutting_down = true;
self.lifecycle.request_disconnect();
}
_ = approval_poll.tick() => {
if self.active.as_ref().is_some_and(|active| {
active._hip_execution.approval_id().is_some() && !active._hip_execution.approval_is_valid()
}) {
warn!("Active HIP script approval is no longer valid; disconnecting VPN");
self.lifecycle.request_disconnect();
}
}
}
}
@@ -296,14 +334,27 @@ impl VpnTask {
fn handle_event(&mut self, event: LifecycleEvent) {
match event {
LifecycleEvent::Start { attempt, request } => self.start_attempt(attempt, request),
LifecycleEvent::Start {
attempt,
request,
desktop_uid,
edited_report,
session_id,
} => self.start_attempt(attempt, request, desktop_uid, edited_report, session_id),
LifecycleEvent::Stop { attempt } => self.stop_attempt(attempt),
LifecycleEvent::Established { attempt, session } => self.establish_attempt(attempt, session),
LifecycleEvent::Ended { attempt } => self.end_attempt(attempt),
}
}
fn start_attempt(&mut self, attempt: u64, request: ConnectRequest) {
fn start_attempt(
&mut self,
attempt: u64,
request: ConnectRequest,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
session_id: Option<Uuid>,
) {
if !self.lifecycle.activate_attempt(attempt) {
self.finish_attempt(attempt);
return;
@@ -328,8 +379,8 @@ impl VpnTask {
return;
}
};
let csd_uid = match resolve_csd_uid(self.trusted_csd_uid, args.csd_uid(), args.hip()) {
Ok(uid) => uid,
let hip = match crate::hip_source::resolve(args.hip_source(), desktop_uid, self.brokered_macos, edited_report) {
Ok(execution) => execution,
Err(err) => {
warn!("Failed to select the HIP script user: {err}");
self.finish_attempt(attempt);
@@ -345,9 +396,9 @@ impl VpnTask {
.certificate(identity.certificate.clone())
.sslkey(identity.sslkey.clone())
.key_password(args.key_password())
.hip(args.hip())
.csd_uid(csd_uid)
.csd_wrapper(args.csd_wrapper())
.hip(hip.enabled)
.csd_uid(hip.uid)
.csd_wrapper(hip.wrapper.clone())
.reconnect_timeout(args.reconnect_timeout())
.mtu(args.mtu())
.disable_ipv6(args.disable_ipv6())
@@ -365,6 +416,15 @@ impl VpnTask {
}
};
if let Some(session_id) = session_id {
let registry = Arc::clone(&self.registry);
vpn.set_hip_report_callback(move |xml| {
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
warn!("Could not retain the submitted HIP report: {error}");
}
});
}
if self.lifecycle.is_stop_requested(attempt) {
self.finish_attempt(attempt);
return;
@@ -385,10 +445,12 @@ impl VpnTask {
} else {
self.active = Some(ActiveAttempt {
attempt,
session_id,
vpn: Arc::clone(&vpn),
info: info.clone(),
allow_extend_session,
_identity_files: identity.files,
_hip_execution: hip,
});
self.send_state(VpnState::Connecting(Box::new(info)));
thread::spawn(move || {
@@ -460,6 +522,9 @@ impl VpnTask {
if self.active.as_ref().is_none_or(|active| active.attempt != attempt) {
return;
}
if let Some(session_id) = self.active.as_ref().and_then(|active| active.session_id) {
self.registry.clear_successful_hip_report(session_id);
}
self.active = None;
self.finish_attempt(attempt);
}
@@ -474,14 +539,6 @@ impl VpnTask {
}
}
fn resolve_csd_uid(trusted_uid: Option<u32>, requested_uid: u32, hip_enabled: bool) -> anyhow::Result<u32> {
let uid = trusted_uid.unwrap_or(requested_uid);
if hip_enabled && uid == 0 {
anyhow::bail!("HIP scripts must not run as root");
}
Ok(uid)
}
struct PreparedIdentity {
certificate: Option<String>,
sslkey: Option<String>,
@@ -534,11 +591,16 @@ fn write_identity_file(
#[cfg(test)]
mod tests {
use super::*;
use crate::session_registry::SessionRegistry;
fn registry() -> Arc<SessionRegistry> {
Arc::new(SessionRegistry::new(Uuid::new_v4()))
}
#[test]
fn disconnect_before_start_discards_the_pending_attempt() {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry());
let request = ConnectRequest::new(
ConnectInfo::new(
"portal.example.com".to_string(),
@@ -548,7 +610,10 @@ mod tests {
"cookie".to_string(),
);
assert!(matches!(lifecycle.submit_connect(request), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request, None, None, None),
ServiceResult::Accepted
));
assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted));
let start = task.events.try_recv().unwrap();
task.handle_event(start);
@@ -561,7 +626,7 @@ mod tests {
fn late_established_event_is_ignored_after_disconnect_is_accepted() {
let (vpn_state_tx, vpn_state_rx) = watch::channel(VpnState::Disconnected);
let state_rx = vpn_state_rx.clone();
let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry());
let info = ConnectInfo::new(
"portal.example.com".to_string(),
gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()),
@@ -569,7 +634,10 @@ mod tests {
);
let request = ConnectRequest::new(info.clone(), "cookie".to_string());
assert!(matches!(lifecycle.submit_connect(request), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request, None, None, None),
ServiceResult::Accepted
));
assert!(lifecycle.activate_attempt(0));
assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted));
task.publish_connected(0, info, SessionInfo::default());
@@ -580,7 +648,7 @@ mod tests {
#[tokio::test]
async fn disconnect_waiter_completes_for_its_attempt_before_a_later_connect() {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry());
let request = || {
ConnectRequest::new(
ConnectInfo::new(
@@ -592,7 +660,10 @@ mod tests {
)
};
assert!(matches!(lifecycle.submit_connect(request()), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request(), None, None, None),
ServiceResult::Accepted
));
let waiter_lifecycle = lifecycle.clone();
let waiter = tokio::spawn(async move { waiter_lifecycle.disconnect_and_wait().await });
while !lifecycle.is_stop_requested(0) {
@@ -600,7 +671,10 @@ mod tests {
}
task.finish_attempt(0);
assert!(matches!(lifecycle.submit_connect(request()), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request(), None, None, None),
ServiceResult::Accepted
));
assert!(
tokio::time::timeout(std::time::Duration::from_secs(1), waiter)
.await
@@ -612,7 +686,7 @@ mod tests {
#[test]
fn repeated_disconnects_enqueue_one_stop_for_an_attempt() {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry());
let request = ConnectRequest::new(
ConnectInfo::new(
"portal.example.com".to_string(),
@@ -622,7 +696,10 @@ mod tests {
"cookie".to_string(),
);
assert!(matches!(lifecycle.submit_connect(request), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request, None, None, None),
ServiceResult::Accepted
));
assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted));
assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted));
assert!(matches!(task.events.try_recv(), Ok(LifecycleEvent::Start { .. })));
@@ -633,7 +710,7 @@ mod tests {
#[test]
fn second_connect_is_rejected_while_an_attempt_is_admitted() {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, None);
let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry());
let request = || {
ConnectRequest::new(
ConnectInfo::new(
@@ -645,24 +722,16 @@ mod tests {
)
};
assert!(matches!(lifecycle.submit_connect(request()), ServiceResult::Accepted));
assert!(matches!(
lifecycle.submit_connect(request()),
lifecycle.submit_connect(request(), None, None, None),
ServiceResult::Accepted
));
assert!(matches!(
lifecycle.submit_connect(request(), None, None, None),
ServiceResult::Rejected(rejection) if rejection.code() == ServiceErrorCode::Busy
));
}
#[test]
fn trusted_csd_uid_overrides_request_uid() {
assert_eq!(resolve_csd_uid(Some(1000), 0, true).unwrap(), 1000);
}
#[test]
fn root_csd_uid_is_rejected_when_hip_is_enabled() {
assert!(resolve_csd_uid(None, 0, true).is_err());
assert_eq!(resolve_csd_uid(None, 0, false).unwrap(), 0);
}
#[test]
fn maps_openconnect_session_metadata_to_service_session_info() {
let info = SessionInfo::from_vpn_session_fields(
+202 -3
View File
@@ -4,8 +4,9 @@ use axum::extract::ws::{CloseFrame, Message, Utf8Bytes, WebSocket};
use futures::StreamExt;
use gpapi::service::transport::{
ClientMessage, ClientPrelude, CloseReason, HandshakeRejection, NoiseResponder, NoiseTransport, ServerMessage,
ServerPrelude, ServiceResult,
ServerPrelude, ServiceErrorCode, ServiceResult,
};
use gpapi::service::{hip::HipSource, request::WsRequest};
use log::{info, warn};
use tokio::sync::{mpsc, watch};
use tokio::time::Instant;
@@ -148,6 +149,7 @@ impl WsConnection {
&ctx,
&control,
permit.session_id,
permit.desktop_uid,
generation,
&mut pending_requests,
).await.is_err() {
@@ -215,6 +217,17 @@ async fn establish(
.await?;
return Err(CloseReason::VersionMismatch);
}
if prelude.hip_protocol_version != gpapi::service::transport::HIP_PROTOCOL_VERSION {
send_server_prelude(
socket,
ServerPrelude::Rejected(HandshakeRejection::HipProtocolMismatch {
client: prelude.hip_protocol_version,
service: gpapi::service::transport::HIP_PROTOCOL_VERSION,
}),
)
.await?;
return Err(CloseReason::VersionMismatch);
}
let permit = match ctx.registry().begin_handshake(
prelude.service_instance_id,
@@ -308,6 +321,7 @@ async fn handle_client_message(
ctx: &Arc<WsServerContext>,
control: &ConnectionControl,
session_id: Uuid,
desktop_uid: Option<u32>,
generation: u64,
pending_requests: &mut HashSet<Uuid>,
) -> Result<(), ()> {
@@ -323,8 +337,192 @@ async fn handle_client_message(
return Err(());
}
if let WsRequest::StoreEditedHipReportChunk(report) = request {
let upload_id = report.upload_id.as_deref().and_then(|id| Uuid::parse_str(id).ok());
let result = if report.upload_id.is_some() && upload_id.is_none() {
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP upload ID")
} else {
match ctx.registry().append_edited_hip_report_chunk(
session_id,
upload_id,
report.offset,
report.xml,
report.complete,
) {
Ok(crate::session_registry::HipUploadResult::Progress(upload_id)) => ServiceResult::HipUploadProgress {
upload_id: upload_id.to_string(),
},
Ok(crate::session_registry::HipUploadResult::Stored(report_id)) => ServiceResult::StoredHipReport {
report_id: report_id.to_string(),
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report upload"),
}
};
if control.send(ConnectionCommand::Reply { id, result }).is_err() {
pending_requests.remove(&id);
control.close(CloseReason::InternalError);
}
return Ok(());
}
if let WsRequest::ReadHipPreviewChunk(chunk) = request {
let result = Uuid::parse_str(&chunk.preview_id)
.ok()
.and_then(|preview_id| {
ctx
.registry()
.hip_preview_chunk(session_id, preview_id, chunk.offset)
.ok()
.map(|(xml, complete)| ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: chunk.offset,
xml,
complete,
})
})
.unwrap_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "HIP preview is unavailable"));
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::GetLastSubmittedHipReport = request {
let result = match ctx.registry().last_successful_hip_report(session_id) {
Ok(Some(report)) => match ctx.registry().store_hip_preview(session_id, report.to_string()) {
Ok(preview_id) => match ctx.registry().hip_preview_chunk(session_id, preview_id, 0) {
Ok((xml, complete)) => ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: 0,
xml,
complete,
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "Submitted HIP report is unavailable"),
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "Submitted HIP report is unavailable"),
},
Ok(None) => ServiceResult::NoSubmittedHipReport,
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Session is unavailable"),
};
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::GetHipApprovalStatus { approval_id } = request {
let result = if let Some(uid) = desktop_uid.filter(|uid| *uid != 0) {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
match gpservice::hip_approval::status(&approval_id, uid) {
Ok(status) => ServiceResult::HipApprovalStatus(status),
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP approval ID"),
}
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
let _ = (uid, approval_id);
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "HIP script approvals are unavailable")
}
} else {
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Desktop user is unavailable")
};
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::PreviewHipReport(preview) = request {
let edited_report = if let HipSource::Edited { report_id } = &preview.source {
let report_id = match Uuid::parse_str(report_id) {
Ok(id) => id,
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"),
})
.map_err(|_| ())?;
return Ok(());
}
};
match ctx.registry().edited_hip_report(session_id, report_id) {
Ok(report) => Some(report),
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"HIP report is unavailable for this session",
),
})
.map_err(|_| ())?;
return Ok(());
}
}
} else {
None
};
let registry = Arc::clone(ctx.registry());
let control = control.clone();
tokio::spawn(async move {
let result = match crate::hip_preview::generate(preview, edited_report, desktop_uid).await {
Ok(xml) => match registry.store_hip_preview(session_id, xml) {
Ok(preview_id) => match registry.hip_preview_chunk(session_id, preview_id, 0) {
Ok((xml, complete)) => ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: 0,
xml,
complete,
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview is unavailable"),
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview is unavailable"),
},
Err(error) => {
warn!("HIP preview failed: {error:#}");
ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview failed")
}
};
control.send_reply(id, result).await;
});
return Ok(());
}
let edited_report = if let WsRequest::Connect(connect) = &request {
if let HipSource::Edited { report_id } = connect.args().hip_source() {
let report_id = match Uuid::parse_str(report_id) {
Ok(id) => id,
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"),
})
.map_err(|_| ())?;
return Ok(());
}
};
match ctx.registry().edited_hip_report(session_id, report_id) {
Ok(report) => Some(report),
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"HIP report is unavailable for this session",
),
})
.map_err(|_| ())?;
return Ok(());
}
}
} else {
None
}
} else {
None
};
let dispatcher = ctx.dispatcher();
let request = match dispatcher.dispatch_lifecycle(request) {
let request = match dispatcher.dispatch_lifecycle(request, desktop_uid, edited_report, Some(session_id)) {
Ok(request) => request,
Err(result) => {
if control.send(ConnectionCommand::Reply { id, result }).is_err() {
@@ -417,7 +615,7 @@ mod tests {
#[tokio::test]
async fn authenticates_attaches_and_replies_to_a_request() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
Arc::new(AtomicBool::new(false)),
@@ -441,6 +639,7 @@ mod tests {
let (mut socket, _) = connect_async(format!("ws://{address}/ws")).await.unwrap();
let prelude = ClientPrelude {
product_version: env!("CARGO_PKG_VERSION").to_owned(),
hip_protocol_version: gpapi::service::transport::HIP_PROTOCOL_VERSION,
service_instance_id: credential.service_instance_id(),
session_id: credential.session_id(),
};
+3 -4
View File
@@ -12,7 +12,7 @@ use gpapi::{
utils::lock_file::LockFile,
};
use log::{info, warn};
use openconnect::{find_csd_wrapper, find_vpnc_script};
use openconnect::find_vpnc_script;
use tokio::{
net::TcpListener,
sync::{Mutex, Semaphore, mpsc, oneshot, watch},
@@ -259,7 +259,6 @@ fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
VpnEnv {
vpn_state,
vpnc_script: find_vpnc_script().map(ToOwned::to_owned),
csd_wrapper: find_csd_wrapper().map(ToOwned::to_owned),
auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(),
host_info: HostInfo {
host_identity: HostIdentity::collect(),
@@ -282,7 +281,7 @@ mod tests {
#[tokio::test]
async fn resync_snapshot_is_ordered_with_state_events() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let permit = registry
.begin_handshake(
credential.service_instance_id(),
@@ -339,7 +338,7 @@ mod tests {
#[tokio::test]
async fn removed_prepared_candidate_cannot_commit_takeover() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
Arc::new(AtomicBool::new(false)),