feat: generate HIP reports through OpenConnect callbacks

This commit is contained in:
Kevin Yue committed 2026-10-02 01:38:20 +08:00
1 parent 05814e9da7
commit b750cfbf16
46 files changed
+2511 -1184

No files matched your search

+5 -2
View File
@@ -54,13 +54,16 @@ pub(crate) struct ConnectArgs {
#[arg(
long,
help = "Use HIP (Host Integrity Protection) extension, optionally specify the HIP script path",
help = "Enable HIP (Host Information Profile), optionally specify a custom executable",
default_missing_value = "",
num_args=0..=1
)]
pub(super) hip: Option<String>,
#[arg(long, help = "The user used to run the HIP script")]
#[arg(
long,
help = "Run a custom HIP executable as this user; otherwise inherit the process user"
)]
pub(super) hip_user: Option<String>,
#[arg(
+38 -25
View File
@@ -20,7 +20,7 @@ use gpapi::{
};
use inquire::Text;
use log::{Level, info, warn};
use openconnect::{Vpn, VpnBuilder};
use openconnect::{HipScript, HipSource, Vpn, VpnBuilder};
use tokio::{runtime::Handle, task::JoinHandle};
use crate::session::{
@@ -352,10 +352,10 @@ impl ConnectHandler<'_> {
}
let mtu = self.args.mtu.unwrap_or(0);
let (hip, csd_wrapper) = self.determine_hip_script();
let hip_user = self.determine_hip_user();
let csd_uid = get_uid(&hip_user).map_err(GatewayConnectError::before_tunnel)?;
let os_profile = self.os_profile.borrow().clone();
let hip_source = self
.hip_source(os_profile.clone())
.map_err(GatewayConnectError::before_tunnel)?;
let session_ctx = build_session_context(SessionContextInput {
portal: portal.to_string(),
@@ -375,9 +375,7 @@ impl ConnectHandler<'_> {
.certificate(self.args.certificate.clone())
.sslkey(self.args.sslkey.clone())
.key_password(self.latest_key_password.borrow().clone())
.hip(hip)
.csd_uid(csd_uid)
.csd_wrapper(csd_wrapper)
.hip_source(hip_source)
.reconnect_timeout(self.args.reconnect_timeout)
.mtu(mtu)
.disable_ipv6(self.args.disable_ipv6)
@@ -439,16 +437,32 @@ impl ConnectHandler<'_> {
classify_openconnect_result(connect_result, tunnel_established, disconnect_requested)
}
fn determine_hip_script(&self) -> (bool, Option<String>) {
if let Some(hip) = &self.args.hip {
return if hip.is_empty() {
(true, None)
} else {
(true, Some(hip.clone()))
};
fn hip_source(&self, profile: OsProfile) -> anyhow::Result<HipSource> {
let user = self.determine_hip_user();
let script = self.args.hip.as_ref().or(self.args.csd_wrapper.as_ref());
match script {
Some(path) if !path.is_empty() => Ok(HipSource::Script(HipScript::new(path.clone(), get_uid(&user)?)?)),
Some(_) => {
anyhow::ensure!(user.is_none(), "--hip-user requires an explicit HIP script");
Ok(HipSource::Generator(Arc::new(move |request, control| {
let input = gphip::ReportInput {
profile: profile.clone(),
context: gphip::ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
},
};
gphip::generate_report_with_control(&input, &|| control.check())
.map_err(|error| error.downcast::<std::io::Error>().unwrap_or_else(std::io::Error::other))
})))
}
None => {
anyhow::ensure!(user.is_none(), "--hip-user requires an explicit HIP script");
Ok(HipSource::Disabled)
}
}
(self.args.csd_wrapper.is_some(), self.args.csd_wrapper.clone())
}
fn determine_hip_user(&self) -> Option<String> {
@@ -495,12 +509,11 @@ fn write_pid_file(lock_file: &Path) {
}
}
fn get_uid(user: &Option<String>) -> anyhow::Result<u32> {
if let Some(user) = user {
get_user_by_name(user).map(|user| user.uid())
} else {
Ok(uzers::get_effective_uid())
}
fn get_uid(user: &Option<String>) -> anyhow::Result<Option<u32>> {
user
.as_ref()
.map(|user| get_user_by_name(user).map(|user| user.uid()))
.transpose()
}
fn apply_os_profile(builder: VpnBuilder, profile: &OsProfile) -> VpnBuilder {
@@ -517,8 +530,8 @@ mod tests {
use super::*;
#[test]
fn hip_script_defaults_to_process_effective_uid() {
assert_eq!(get_uid(&None).unwrap(), uzers::get_effective_uid());
fn hip_script_defaults_to_inherited_process_identity() {
assert_eq!(get_uid(&None).unwrap(), None);
}
#[test]
@@ -530,7 +543,7 @@ mod tests {
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());
assert_eq!(get_uid(&Some(name)).unwrap(), Some(current.uid()));
}
#[test]
+10 -3
View File
@@ -1,9 +1,12 @@
use std::time::Duration;
use clap::Args;
use gpapi::{
clap::args::Os,
os_profile::{ClientOs, OsProfileBuilder},
process::collection::CollectionBudget,
};
use gphip::{ReportContext, ReportInput, generate_report};
use gphip::{ReportContext, ReportInput, generate_report_with_control};
#[derive(Args)]
pub(crate) struct HipArgs {
@@ -42,13 +45,17 @@ impl<'a> HipHandler<'a> {
}
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
let budget = CollectionBudget::new(Duration::from_secs(60));
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(os_version) = self.args.os_version.as_deref() {
builder = builder.os_version(os_version);
}
if let Some(host_id) = self.args.host_id.as_deref() {
builder = builder.host_id_override(host_id);
}
let input = ReportInput {
profile: builder.build(),
profile: builder.build_with_control(&budget)?,
context: ReportContext::Connected {
cookie: self.args.cookie.clone(),
client_ip: self.args.client_ip.clone(),
@@ -56,7 +63,7 @@ impl<'a> HipHandler<'a> {
md5: self.args.md5.clone(),
},
};
println!("{}", generate_report(&input)?);
println!("{}", generate_report_with_control(&input, &budget)?);
Ok(())
}
}
-137
View File
@@ -1,137 +0,0 @@
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(())
}
+66 -9
View File
@@ -1,6 +1,6 @@
use std::{
fs::{self, File, OpenOptions},
io::Write,
io::{Read, Write},
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
};
@@ -12,8 +12,6 @@ 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"))]
@@ -83,22 +81,32 @@ pub fn install(request: InstallRequest, approving_uid: u32) -> anyhow::Result<Ap
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)?;
validate_approval_ancestors(base)?;
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> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_with_control(approval_id, desktop_uid, &budget)
}
pub fn resolve_with_control(
approval_id: &str,
desktop_uid: u32,
control: &dyn gpapi::process::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
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)
validate_approval_ancestors(base)?;
resolve_at_with_control(base, approval_id, desktop_uid, 0, control)
}
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)?;
validate_approval_ancestors(base)?;
revoke_at(base, approval_id, approving_uid, 0)
}
@@ -127,7 +135,7 @@ fn status_at(
}
}
if validate_private_dir(base, file_owner).is_err()
|| (validate_root_ancestors && validate_root_owned_path(base, false).is_err())
|| (validate_root_ancestors && validate_approval_ancestors(base).is_err())
{
return Ok(HipApprovalStatus::Corrupt);
}
@@ -191,15 +199,43 @@ fn install_at(
}
fn resolve_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovedScript> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_at_with_control(base, approval_id, desktop_uid, file_owner, &budget)
}
fn resolve_at_with_control(
base: &Path,
approval_id: &str,
desktop_uid: u32,
file_owner: u32,
control: &dyn gpapi::process::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
let info = read_metadata_at(base, approval_id, desktop_uid, file_owner)?;
control.check()?;
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)?;
let mut file = File::open(&script)?;
let mut contents = Vec::new();
let mut chunk = [0_u8; 8192];
loop {
control.check()?;
let read = file.read(&mut chunk)?;
if read == 0 {
break;
}
ensure!(
contents.len() + read <= MAX_SCRIPT_SIZE,
"Approved HIP script is too large"
);
contents.extend_from_slice(&chunk[..read]);
}
ensure!(!contents.is_empty(), "Approved HIP script is empty");
ensure!(
sha256::digest(&contents) == info.sha256,
"Approved HIP script digest mismatch"
);
control.check()?;
Ok(ApprovedScript { info, path: script })
}
@@ -294,6 +330,27 @@ fn validate_file(path: &Path, owner_uid: u32, mode: u32, max_size: u64) -> anyho
Ok(())
}
/// Check every component because a trusted file below a writable parent can
/// be replaced before a later HIP refresh.
fn validate_approval_ancestors(path: &Path) -> anyhow::Result<()> {
ensure!(path.is_absolute(), "HIP approval 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 approval path contains a symlink"
);
ensure!(metadata.uid() == 0, "HIP approval path is not root-owned");
ensure!(
metadata.permissions().mode() & 0o022 == 0,
"HIP approval path is writable by another user"
);
ensure!(metadata.is_dir(), "HIP approval parent is not a directory");
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
+281 -247
View File
@@ -1,275 +1,309 @@
use std::{os::unix::process::CommandExt, process::Stdio, sync::Arc, time::Duration};
use std::{collections::HashMap, io, sync::Arc, time::Duration};
use anyhow::{Context, bail, ensure};
use gpapi::{hip::HipSource, service::request::PreviewHipReportRequest};
use tokio::{io::AsyncReadExt, process::Command};
use gpapi::{
hip::HipSource,
os_profile::HostIdentity,
service::{
request::PreviewHipReportRequest,
transport::{ServiceErrorCode, ServiceResult},
},
};
use openconnect::HipRequest;
use tokio::{
sync::{Mutex, Semaphore},
task::JoinHandle,
};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use crate::{session_registry::SessionRegistry, ws_connection::ConnectionControl};
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";
const MAX_ACTIVE_PREVIEWS: usize = 4;
pub(crate) async fn generate(
struct PreviewTask {
connection_id: Uuid,
cancellation: CancellationToken,
worker: JoinHandle<()>,
}
pub(crate) struct PreviewJob {
pub session_id: Uuid,
pub request_id: Uuid,
pub request: PreviewHipReportRequest,
pub edited_report: Option<Arc<str>>,
pub desktop_uid: Option<u32>,
pub identity: HostIdentity,
pub registry: Arc<SessionRegistry>,
pub connection: ConnectionControl,
}
pub(crate) struct HipPreviews {
tasks: Mutex<HashMap<Uuid, PreviewTask>>,
slots: Arc<Semaphore>,
shutdown: CancellationToken,
}
impl HipPreviews {
pub(crate) fn new() -> Self {
Self {
tasks: Mutex::new(HashMap::new()),
slots: Arc::new(Semaphore::new(MAX_ACTIVE_PREVIEWS)),
shutdown: CancellationToken::new(),
}
}
pub(crate) async fn start(&self, job: PreviewJob) -> bool {
let PreviewJob {
session_id,
request_id,
request,
edited_report,
desktop_uid,
identity,
registry,
connection,
} = job;
let mut tasks = self.tasks.lock().await;
if self.shutdown.is_cancelled() || tasks.get(&session_id).is_some_and(|task| !task.worker.is_finished()) {
return false;
}
if let Some(completed) = tasks.remove(&session_id) {
let _ = completed.worker.await;
}
let Ok(slot) = Arc::clone(&self.slots).try_acquire_owned() else {
return false;
};
let cancellation = self.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let connection_id = connection.connection_id();
let worker = tokio::spawn(async move {
let _slot = slot;
let generated = tokio::task::spawn_blocking(move || {
generate(request, edited_report, desktop_uid, identity, worker_cancellation)
})
.await;
let result = match generated {
Ok(Ok(xml)) => preview_result(&registry, session_id, xml),
Ok(Err(error)) => {
log::warn!("HIP preview failed: {error:#}");
ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview failed")
}
Err(error) => {
log::warn!("HIP preview worker failed: {error}");
ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview failed")
}
};
// A bounded connection queue must not prevent preview teardown.
let _ = connection.send(crate::ws_connection::ConnectionCommand::Reply { id: request_id, result });
});
tasks.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
true
}
pub(crate) async fn cancel_connection(&self, session_id: Uuid, connection_id: Uuid) {
let mut tasks = self.tasks.lock().await;
if !tasks
.get(&session_id)
.is_some_and(|task| task.connection_id == connection_id)
{
return;
}
if let Some(task) = tasks.remove(&session_id) {
task.cancellation.cancel();
let _ = task.worker.await;
}
}
pub(crate) async fn shutdown(&self) {
self.shutdown.cancel();
let tasks = std::mem::take(&mut *self.tasks.lock().await);
for task in tasks.into_values() {
let _ = task.worker.await;
}
}
}
fn preview_result(registry: &SessionRegistry, session_id: Uuid, xml: String) -> ServiceResult {
let result = registry.store_hip_preview(session_id, xml).and_then(|preview_id| {
registry
.hip_preview_chunk(session_id, preview_id, 0)
.map(|(xml, complete)| ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: 0,
xml,
complete,
})
});
result.unwrap_or_else(|_| ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview is unavailable"))
}
fn generate(
request: PreviewHipReportRequest,
edited_report: Option<Arc<str>>,
desktop_uid: Option<u32>,
identity: HostIdentity,
cancellation: CancellationToken,
) -> 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 {
let budget = gpapi::process::collection::CollectionBudget::new(PREVIEW_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(io::ErrorKind::Interrupted, "HIP preview cancelled"));
}
gpapi::process::collection::CollectionControl::check(&budget)
};
check()?;
let profile = crate::hip_source::profile(
&identity,
request.client_os,
Some(request.client_version.clone()),
None,
request.host_id.clone(),
None,
&check,
)?;
let input = HipRequest {
cookie: "user=preview&domain=preview&computer=preview".into(),
client_ip: Some("192.0.2.1".into()),
client_ipv6: None,
md5: "00000000000000000000000000000000".into(),
client_version: request.client_version,
client_os: request.client_os.as_str().into(),
os_version: profile.os_version().into(),
host_id: request.host_id,
local_hostname: Some(profile.computer().into()),
};
let xml = match &request.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)?
HipSource::Generated => crate::hip_source::generate(&profile, None, &input, &check, true)?,
HipSource::Edited { .. } => {
let xml = edited_report.context("Edited HIP report is unavailable")?;
crate::hip_source::generate(&profile, Some(&xml), &input, &check, true)?
}
source => {
let execution = crate::hip_source::resolve(source, desktop_uid, false, None, Some(profile))?;
let openconnect::HipSource::Script(script) = execution.source else {
bail!("HIP preview executable is unavailable");
};
let xml = script.preview(&input, &check)?;
gphip::validate_edited_report(&xml).context("Custom HIP script did not emit a valid HIP report")?;
xml
}
};
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")
}
}
check()?;
Ok(xml)
}
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")))]
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::ClientOs;
use std::{fs, os::unix::fs::PermissionsExt};
use std::sync::atomic::{AtomicBool, Ordering};
fn request(path: &std::path::Path) -> PreviewHipReportRequest {
PreviewHipReportRequest {
source: HipSource::UserScript {
path: path.to_string_lossy().into_owned(),
fn job(session_id: Uuid) -> PreviewJob {
let (tx, _) = tokio::sync::mpsc::channel(1);
let (connection, _) = ConnectionControl::new(Uuid::new_v4(), tx);
PreviewJob {
session_id,
request_id: Uuid::new_v4(),
request: PreviewHipReportRequest {
source: HipSource::Generated,
client_os: ClientOs::Linux,
client_version: "6.3.3".into(),
host_id: None,
},
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()
edited_report: None,
desktop_uid: None,
identity: HostIdentity::from_parts(
"device".into(),
"host".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
),
registry: Arc::new(SessionRegistry::new(Uuid::new_v4())),
connection,
}
}
#[tokio::test]
async fn preview_admission_rejects_duplicate_session_and_global_capacity() {
let previews = HipPreviews::new();
let session_id = Uuid::new_v4();
let cancellation = previews.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let worker = tokio::spawn(async move { worker_cancellation.cancelled().await });
let connection_id = Uuid::new_v4();
previews.tasks.lock().await.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
assert!(!previews.start(job(session_id)).await);
previews.cancel_connection(session_id, connection_id).await;
let _all_slots = Arc::clone(&previews.slots)
.acquire_many_owned(MAX_ACTIVE_PREVIEWS as u32)
.await
.unwrap();
assert!(!previews.start(job(Uuid::new_v4())).await);
previews.shutdown().await;
}
#[tokio::test]
async fn closing_preview_owner_waits_for_worker_teardown() {
let previews = HipPreviews::new();
let session_id = Uuid::new_v4();
let connection_id = Uuid::new_v4();
let cancellation = previews.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let stopped = Arc::new(AtomicBool::new(false));
let worker_stopped = Arc::clone(&stopped);
let worker = tokio::spawn(async move {
worker_cancellation.cancelled().await;
tokio::task::yield_now().await;
worker_stopped.store(true, Ordering::SeqCst);
});
previews.tasks.lock().await.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
previews.cancel_connection(session_id, Uuid::new_v4()).await;
assert!(!stopped.load(Ordering::SeqCst));
previews.cancel_connection(session_id, connection_id).await;
assert!(stopped.load(Ordering::SeqCst));
assert!(previews.tasks.lock().await.is_empty());
previews.shutdown().await;
assert!(!previews.start(job(session_id)).await);
}
#[test]
fn cancelled_preview_does_not_start_collection() {
let preview = job(Uuid::new_v4());
let cancelled = CancellationToken::new();
cancelled.cancel();
let error = generate(preview.request, None, None, preview.identity, cancelled).unwrap_err();
assert_eq!(
error.downcast_ref::<io::Error>().unwrap().kind(),
io::ErrorKind::Interrupted
);
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
@@ -1,59 +0,0 @@
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());
}
}
}
+204 -214
View File
@@ -1,52 +1,36 @@
use std::{
fs::{self, OpenOptions},
io::Write,
os::unix::fs::{OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
sync::Arc,
};
use std::{fs, io, os::unix::fs::PermissionsExt, path::PathBuf, sync::Arc};
use anyhow::{Context, bail, ensure};
use gpapi::hip::HipSource;
use gpservice::hip_runner_state::{MAX_STATE_BYTES, RUNNER_NAME, RunnerReport, STATE_NAME, validate_root_owned_path};
use tempfile::{Builder, TempDir};
use gpapi::{
hip::HipSource,
os_profile::{ClientOs, HostIdentity, OsProfile, OsProfileBuilder},
};
use gphip::{ReportContext, ReportInput};
use openconnect::{HipRequest, HipScript, HipScriptEnvironment};
pub(crate) struct HipExecution {
pub enabled: bool,
pub uid: u32,
pub wrapper: Option<String>,
_state_dir: Option<TempDir>,
approval: Option<(String, u32)>,
pub source: openconnect::HipSource,
approval: HipApproval,
}
impl HipExecution {
fn disabled() -> Self {
Self {
enabled: false,
uid: 0,
wrapper: None,
_state_dir: None,
approval: None,
}
pub(crate) fn into_parts(self) -> (openconnect::HipSource, HipApproval) {
(self.source, self.approval)
}
}
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) struct HipApproval {
identity: Option<(String, u32)>,
}
impl HipApproval {
pub(crate) fn approval_id(&self) -> Option<&str> {
self.approval.as_ref().map(|(id, _)| id.as_str())
self.identity.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 {
if let Some((id, uid)) = &self.identity {
return gpservice::hip_approval::resolve(id, *uid).is_ok();
}
true
@@ -58,43 +42,67 @@ pub(crate) fn resolve(
desktop_uid: Option<u32>,
brokered_macos: bool,
edited_report: Option<Arc<str>>,
profile: Option<OsProfile>,
) -> 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() })
let approval;
let source = match source {
HipSource::Disabled => {
approval = None;
openconnect::HipSource::Disabled
}
HipSource::Generated | HipSource::Edited { .. } => {
let profile = profile.context("HIP generator identity is unavailable")?;
approval = None;
let xml = match source {
HipSource::Edited { .. } => {
let xml = edited_report.context("Edited HIP report was not uploaded for this connection")?;
gphip::validate_edited_report(&xml)?;
Some(xml)
}
_ => None,
};
openconnect::HipSource::Generator(Arc::new(move |request, control| {
generate(&profile, xml.as_deref(), request, &|| control.check(), false).map_err(generation_error)
}))
}
HipSource::UserScript { path } => {
if cfg!(target_os = "macos") || brokered_macos {
bail!("Custom HIP scripts are unavailable on macOS");
}
approval = None;
ensure_custom_available(brokered_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);
ensure!(path.is_absolute(), "HIP custom script path must be absolute");
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))
let script =
HipScript::new(path.to_string_lossy().into_owned(), Some(uid))?.with_environment(script_environment(uid)?)?;
openconnect::HipSource::Script(script)
}
HipSource::ApprovedRootScript { approval_id } => {
if cfg!(target_os = "macos") || brokered_macos {
bail!("Custom HIP scripts are unavailable on macOS");
}
ensure_custom_available(brokered_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)
let approved = gpservice::hip_approval::resolve(approval_id, owner_uid)?;
let id = approval_id.clone();
let path = approved.path;
let expected = path.clone();
let script = HipScript::new(path.to_string_lossy().into_owned(), Some(0))?
.with_environment(script_environment(0)?)?
.with_validator(move |control| {
control.check()?;
let current = gpservice::hip_approval::resolve_with_control(&id, owner_uid, &|| control.check())
.map_err(generation_error)?;
if current.path != expected {
return Err(io::Error::other("Approved HIP executable changed"));
}
control.check()
});
approval = Some((approval_id.clone(), owner_uid));
openconnect::HipSource::Script(script)
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
@@ -102,190 +110,172 @@ pub(crate) fn resolve(
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)
Ok(HipExecution {
source,
approval: HipApproval { identity: approval },
})
}
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)?;
fn ensure_custom_available(brokered_macos: bool) -> anyhow::Result<()> {
ensure!(
encoded_state.len() <= MAX_STATE_BYTES,
"HIP runner state exceeds its size limit"
!cfg!(target_os = "macos") && !brokered_macos,
"Custom HIP scripts are unavailable on macOS"
);
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"
);
pub(crate) fn generate(
profile: &OsProfile,
edited: Option<&str>,
request: &HipRequest,
control: &dyn gpapi::process::collection::CollectionControl,
preview: bool,
) -> anyhow::Result<String> {
control.check()?;
let context = if preview {
ReportContext::Preview
} else {
ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
}
};
let input = ReportInput {
profile: profile.clone(),
context,
};
match edited {
Some(xml) => gphip::refresh_edited_report_with_control(xml, &input, control),
None => gphip::generate_report_with_control(&input, control),
}
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")
pub(crate) fn script_environment(uid: u32) -> anyhow::Result<HipScriptEnvironment> {
let user =
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.context("HIP execution user is unavailable")?;
let home = user.dir.to_string_lossy().into_owned();
Ok(HipScriptEnvironment {
variables: vec![
(
"PATH".into(),
gpapi::process::collection::command_path(uid == 0)?
.into_string()
.map_err(|_| anyhow::anyhow!("HIP command path is not valid UTF-8"))?,
),
("LC_ALL".into(), "C".into()),
("HOME".into(), home.clone()),
("USER".into(), user.name.clone()),
("LOGNAME".into(), user.name),
],
cwd: home,
})
}
#[cfg(not(target_os = "macos"))]
fn verify_staged_runner(_path: &Path) -> anyhow::Result<()> {
Ok(())
pub(crate) fn profile(
identity: &HostIdentity,
os: ClientOs,
version: Option<String>,
os_version: Option<String>,
host_id: Option<String>,
hostname: Option<String>,
control: &dyn gpapi::process::collection::CollectionControl,
) -> io::Result<OsProfile> {
let identity = HostIdentity::from_parts(
hostname.unwrap_or_else(|| identity.computer().into()),
host_id.unwrap_or_else(|| identity.host_id().into()),
identity.serialno().into(),
identity.mac_addr().into(),
);
let mut builder = OsProfileBuilder::new(os).host_identity(identity);
if let Some(version) = version {
builder = builder.client_version(version);
}
if let Some(os_version) = os_version {
builder = builder.os_version(os_version);
}
builder.build_with_control(control)
}
fn generation_error(error: anyhow::Error) -> io::Error {
match error.downcast::<io::Error>() {
Ok(error) => error,
Err(error) => io::Error::other(error),
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::ClientOs;
#[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());
}
fn fixture_profile() -> OsProfile {
profile(
&HostIdentity::from_parts(
"device".into(),
"host".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
),
ClientOs::Linux,
Some("6.3.3".into()),
Some("negotiated-version".into()),
None,
None,
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap()
}
#[test]
fn custom_source_cannot_choose_root_or_run_on_macos() {
fn callback_configuration_needs_no_files_or_root_identity() {
let generated = resolve(&HipSource::Generated, None, true, None, Some(fixture_profile())).unwrap();
assert!(matches!(generated.source, openconnect::HipSource::Generator(_)));
let disabled = resolve(&HipSource::Disabled, None, true, None, Some(fixture_profile())).unwrap();
assert!(matches!(disabled.source, openconnect::HipSource::Disabled));
}
#[test]
fn profile_retains_negotiated_identity_and_os_version() {
let identity = HostIdentity::from_parts(
"original".into(),
"original-id".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
);
let profile = profile(
&identity,
ClientOs::Mac,
Some("6.3.3".into()),
Some("negotiated-os".into()),
Some("negotiated-host".into()),
Some("negotiated-name".into()),
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap();
assert_eq!(profile.os_version(), "negotiated-os");
assert_eq!(profile.host_identity().host_id(), "negotiated-host");
assert_eq!(profile.host_identity().computer(), "negotiated-name");
assert_eq!(profile.host_identity().serialno(), "serial");
}
#[test]
fn callback_errors_preserve_cancellation() {
let error = generation_error(io::Error::new(io::ErrorKind::Interrupted, "cancelled").into());
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
}
#[test]
fn custom_source_cannot_run_on_macos_or_choose_root_without_approval() {
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());
assert!(resolve(&source, None, false, None, None).is_err());
assert!(resolve(&source, Some(0), false, None, None).is_err());
assert!(resolve(&source, Some(1000), true, None, Some(fixture_profile())).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());
assert!(resolve(&source, Some(1000), false, None, None).is_err());
}
}
-1
View File
@@ -1,5 +1,4 @@
#[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;
+49 -8
View File
@@ -242,7 +242,7 @@ struct ActiveAttempt {
info: ConnectInfo,
allow_extend_session: bool,
_identity_files: Vec<tempfile::NamedTempFile>,
_hip_execution: crate::hip_source::HipExecution,
_hip_approval: crate::hip_source::HipApproval,
}
pub(crate) struct VpnTask {
@@ -309,7 +309,7 @@ impl VpnTask {
}
_ = 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()
active._hip_approval.approval_id().is_some() && !active._hip_approval.approval_is_valid()
}) {
warn!("Active HIP script approval is no longer valid; disconnecting VPN");
self.lifecycle.request_disconnect();
@@ -379,14 +379,57 @@ impl VpnTask {
return;
}
};
let hip = match crate::hip_source::resolve(args.hip_source(), desktop_uid, self.brokered_macos, edited_report) {
let profile = if matches!(
args.hip_source(),
gpapi::hip::HipSource::Generated | gpapi::hip::HipSource::Edited { .. }
) {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
let check = || {
if self.cancel_token.is_cancelled() || self.lifecycle.is_stop_requested(attempt) {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"HIP setup cancelled",
));
}
gpapi::process::collection::CollectionControl::check(&budget)
};
let profile = gpapi::os_profile::HostIdentity::collect_with_control(&check).and_then(|identity| {
crate::hip_source::profile(
&identity,
args.os().unwrap_or(gpapi::os_profile::ClientOs::Linux),
args.client_version(),
args.os_version(),
args.host_id(),
args.local_hostname(),
&check,
)
});
match profile {
Ok(profile) => Some(profile),
Err(error) => {
warn!("Failed to collect the HIP identity: {error}");
self.finish_attempt(attempt);
return;
}
}
} else {
None
};
let hip = match crate::hip_source::resolve(
args.hip_source(),
desktop_uid,
self.brokered_macos,
edited_report,
profile,
) {
Ok(execution) => execution,
Err(err) => {
warn!("Failed to select the HIP script user: {err}");
warn!("Failed to configure the HIP report: {err}");
self.finish_attempt(attempt);
return;
}
};
let (hip_source, hip_approval) = hip.into_parts();
let vpn = match vpn_builder
.user_agent(args.user_agent())
.os(args.openconnect_os())
@@ -396,9 +439,7 @@ impl VpnTask {
.certificate(identity.certificate.clone())
.sslkey(identity.sslkey.clone())
.key_password(args.key_password())
.hip(hip.enabled)
.csd_uid(hip.uid)
.csd_wrapper(hip.wrapper.clone())
.hip_source(hip_source)
.reconnect_timeout(args.reconnect_timeout())
.mtu(args.mtu())
.disable_ipv6(args.disable_ipv6())
@@ -450,7 +491,7 @@ impl VpnTask {
info: info.clone(),
allow_extend_session,
_identity_files: identity.files,
_hip_execution: hip,
_hip_approval: hip_approval,
});
self.send_state(VpnState::Connecting(Box::new(info)));
thread::spawn(move || {
+25 -23
View File
@@ -184,6 +184,10 @@ impl WsConnection {
}
}
ctx
.hip_previews
.cancel_connection(permit.session_id, control.connection_id())
.await;
ctx
.remove_connection(control.connection_id(), permit.session_id, generation)
.await;
@@ -459,29 +463,27 @@ async fn handle_client_message(
} 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;
});
if !ctx
.hip_previews
.start(crate::hip_preview::PreviewJob {
session_id,
request_id: id,
request: preview,
edited_report,
desktop_uid,
identity: ctx.host_identity().await,
registry: Arc::clone(ctx.registry()),
connection: control.clone(),
})
.await
{
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(ServiceErrorCode::Busy, "HIP preview is already running"),
})
.map_err(|_| ())?;
}
return Ok(());
}
+7
View File
@@ -39,6 +39,7 @@ pub(crate) struct WsServerContext {
dispatcher: Arc<RequestDispatcher>,
state: Mutex<ServiceState>,
handshake_slots: Arc<Semaphore>,
pub(crate) hip_previews: crate::hip_preview::HipPreviews,
}
impl WsServerContext {
@@ -58,6 +59,7 @@ impl WsServerContext {
connections: HashMap::new(),
}),
handshake_slots: Arc::new(Semaphore::new(16)),
hip_previews: crate::hip_preview::HipPreviews::new(),
}
}
@@ -65,6 +67,10 @@ impl WsServerContext {
self.product_version
}
pub async fn host_identity(&self) -> HostIdentity {
self.state.lock().await.snapshot.host_info.host_identity.clone()
}
pub fn registry(&self) -> &Arc<SessionRegistry> {
&self.registry
}
@@ -243,6 +249,7 @@ impl WsServer {
info!("WS server cancelled");
}
}
self.ctx.hip_previews.shutdown().await;
let _ = shutdown_tx.send(()).await;
}