Files
GlobalProtect-openconnect/apps/gpservice/src/hip_approval.rs
T
Kevin Yue 4faa2ecb0d feat: prepare 3.1.0 with connection details and improved authentication
Add tunnel statistics and an optional CLI dashboard, native sign-in controls and recovery, and broader client certificate support. Include platform integration fixes and the approved release notes.
2026-10-19 23:47:11 +08:00

464 lines
16 KiB
Rust

use std::{
fs::{self, File, OpenOptions},
io::{Read, Write},
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
};
use anyhow::{Context, ensure};
use base64::{Engine, engine::general_purpose::STANDARD};
use gpapi::{hip::HipApprovalStatus, utils::checksum::sha256_hex};
use serde::{Deserialize, Serialize};
use tempfile::Builder;
use uuid::Uuid;
#[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_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_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_approval_ancestors(base)?;
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, true)
}
fn status_at(
base: &Path,
approval_id: &str,
desktop_uid: u32,
file_owner: u32,
validate_root_ancestors: bool,
) -> 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()
|| (validate_root_ancestors && validate_approval_ancestors(base).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_hex(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 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 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_hex(&contents) == info.sha256,
"Approved HIP script digest mismatch"
);
control.check()?;
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(())
}
/// 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::*;
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, false).unwrap(),
HipApprovalStatus::Valid
);
assert_eq!(
status_at(base.path(), &info.approval_id, 1001, owner, false).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, false).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, false).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());
}
}