mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 22:46:14 -05:00
feat: generate HIP reports through OpenConnect callbacks
This commit is contained in:
46 files changed
+2511
-1184
No files matched your search
+204
-214
@@ -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());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user