From 40b35804e7d2fb42d5df38f623093f9ad15be49e Mon Sep 17 00:00:00 2001 From: Kevin Yue Date: Thu, 30 Jul 2026 22:06:18 +0800 Subject: [PATCH] feat: persist VPN script installation metadata --- apps/gpgui-helper/src-tauri/src/updater.rs | 3 + .../privileged_unix.rs | 11 +- apps/gpservice/src/request_dispatcher.rs | 16 ++ apps/gpservice/src/vpn_task.rs | 2 +- apps/gpservice/src/vpnc_script.rs | 190 ++++++++++++++---- crates/common/src/constants.rs | 4 + crates/gpapi/src/service/mod.rs | 1 + crates/gpapi/src/service/request.rs | 1 + crates/gpapi/src/service/transport/message.rs | 3 +- crates/gpapi/src/service/vpnc_script.rs | 84 ++++++++ 10 files changed, 276 insertions(+), 39 deletions(-) create mode 100644 crates/gpapi/src/service/vpnc_script.rs diff --git a/apps/gpgui-helper/src-tauri/src/updater.rs b/apps/gpgui-helper/src-tauri/src/updater.rs index dbc5a88..c580fc5 100644 --- a/apps/gpgui-helper/src-tauri/src/updater.rs +++ b/apps/gpgui-helper/src-tauri/src/updater.rs @@ -230,6 +230,9 @@ async fn run_installer_connection( rejection.code(), rejection.message() )), + ServiceResult::VpncScriptMetadata(_) => { + Err(anyhow::anyhow!("Service sent an unexpected VPNC script metadata reply")) + } }; let _ = command.reply.send(result); } diff --git a/apps/gpservice/src/bin/gp-vpnc-script-installer/privileged_unix.rs b/apps/gpservice/src/bin/gp-vpnc-script-installer/privileged_unix.rs index 976ddd5..2f54237 100644 --- a/apps/gpservice/src/bin/gp-vpnc-script-installer/privileged_unix.rs +++ b/apps/gpservice/src/bin/gp-vpnc-script-installer/privileged_unix.rs @@ -1,9 +1,12 @@ -use std::io; +use std::io::Read; use anyhow::bail; use clap::{Parser, Subcommand}; +use gpapi::service::vpnc_script::InstallVpncScriptRequest; use nix::unistd::Uid; +const MAX_INSTALL_REQUEST_SIZE: u64 = 2 * 1024 * 1024; + #[derive(Parser)] struct Cli { #[command(subcommand)] @@ -22,7 +25,11 @@ fn try_run() -> anyhow::Result<()> { } match Cli::parse().command { - Command::Install => gpservice::vpnc_script::install(io::stdin().lock()), + Command::Install => { + let input = std::io::stdin().lock().take(MAX_INSTALL_REQUEST_SIZE); + let request = serde_json::from_reader::<_, InstallVpncScriptRequest>(input)?; + gpservice::vpnc_script::install(request) + } Command::Remove => gpservice::vpnc_script::remove(), } } diff --git a/apps/gpservice/src/request_dispatcher.rs b/apps/gpservice/src/request_dispatcher.rs index 369eba0..b2874d6 100644 --- a/apps/gpservice/src/request_dispatcher.rs +++ b/apps/gpservice/src/request_dispatcher.rs @@ -69,6 +69,22 @@ impl RequestDispatcher { } self.update_gui(request).await } + WsRequest::GetVpncScriptMetadata => { + #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))] + { + match gpservice::vpnc_script::metadata() { + Ok(metadata) => ServiceResult::VpncScriptMetadata(metadata), + Err(err) => { + warn!("Failed to read VPNC script metadata: {err}"); + ServiceResult::rejected(ServiceErrorCode::Internal, "Failed to read VPNC script metadata") + } + } + } + #[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))] + { + ServiceResult::VpncScriptMetadata(None) + } + } request => { if let WsRequest::Connect(ref connect) = request { if let Err(message) = self.validate_connect_paths(connect) { diff --git a/apps/gpservice/src/vpn_task.rs b/apps/gpservice/src/vpn_task.rs index 521c626..d23e767 100644 --- a/apps/gpservice/src/vpn_task.rs +++ b/apps/gpservice/src/vpn_task.rs @@ -289,7 +289,7 @@ async fn process_ws_req(req: WsRequest, ctx: Arc) { warn!("Failed to update log level: {}", err); } } - WsRequest::RestartGui | WsRequest::UpdateGui(_) => { + WsRequest::RestartGui | WsRequest::UpdateGui(_) | WsRequest::GetVpncScriptMetadata => { warn!("Non-VPN request reached the VPN task"); } } diff --git a/apps/gpservice/src/vpnc_script.rs b/apps/gpservice/src/vpnc_script.rs index 2398530..4a7ac11 100644 --- a/apps/gpservice/src/vpnc_script.rs +++ b/apps/gpservice/src/vpnc_script.rs @@ -6,18 +6,29 @@ use std::{ }; use anyhow::{Context, bail}; -use common::constants::{INSTALLED_VPNC_SCRIPT, MAX_VPNC_SCRIPT_SIZE}; +use common::constants::{INSTALLED_VPNC_SCRIPT, INSTALLED_VPNC_SCRIPT_METADATA, MAX_VPNC_SCRIPT_SIZE}; +use gpapi::service::vpnc_script::{InstallVpncScriptRequest, VpncScriptMetadata}; +use serde::{Deserialize, Serialize}; use tempfile::NamedTempFile; const DIRECTORY_MODE: u32 = 0o755; const SCRIPT_MODE: u32 = 0o755; +const METADATA_MODE: u32 = 0o600; +const METADATA_VERSION: u8 = 1; +const MAX_METADATA_SIZE: u64 = 40 * 1024; const ROOT_UID: u32 = 0; +#[derive(Deserialize, Serialize)] +struct StoredMetadata { + version: u8, + metadata: VpncScriptMetadata, +} + pub fn installed_script() -> anyhow::Result> { let path = PathBuf::from(INSTALLED_VPNC_SCRIPT); match fs::symlink_metadata(&path) { Ok(metadata) => { - validate_script_metadata(&path, &metadata, ROOT_UID)?; + validate_script(&path, &metadata, ROOT_UID)?; let directory = path.parent().context("Installed VPNC script has no parent directory")?; validate_directory(directory, ROOT_UID)?; validate_directory( @@ -33,8 +44,18 @@ pub fn installed_script() -> anyhow::Result> { } } -pub fn install(input: impl Read) -> anyhow::Result<()> { +pub fn metadata() -> anyhow::Result> { + if installed_script()?.is_none() { + return Ok(None); + } + read_metadata_at(Path::new(INSTALLED_VPNC_SCRIPT_METADATA), ROOT_UID) +} + +pub fn install(request: InstallVpncScriptRequest) -> anyhow::Result<()> { + request.metadata.validate()?; + let contents = request.contents()?; let target = Path::new(INSTALLED_VPNC_SCRIPT); + let metadata_target = Path::new(INSTALLED_VPNC_SCRIPT_METADATA); let directory = target .parent() .context("Installed VPNC script has no parent directory")?; @@ -47,70 +68,122 @@ pub fn install(input: impl Read) -> anyhow::Result<()> { validate_directory(state_parent, ROOT_UID)?; ensure_directory(state_directory, ROOT_UID)?; ensure_directory(directory, ROOT_UID)?; - install_at(input, target, ROOT_UID) + install_at(&contents, &request.metadata, target, metadata_target, ROOT_UID) } pub fn remove() -> anyhow::Result<()> { - if installed_script()?.is_none() { - return Ok(()); + if installed_script()?.is_some() { + remove_at(Path::new(INSTALLED_VPNC_SCRIPT), ROOT_UID, validate_script)?; } - remove_at(Path::new(INSTALLED_VPNC_SCRIPT), ROOT_UID) + remove_at(Path::new(INSTALLED_VPNC_SCRIPT_METADATA), ROOT_UID, validate_metadata) } -fn install_at(mut input: impl Read, target: &Path, owner_uid: u32) -> anyhow::Result<()> { +fn install_at( + contents: &[u8], + metadata: &VpncScriptMetadata, + target: &Path, + metadata_target: &Path, + owner_uid: u32, +) -> anyhow::Result<()> { let directory = target .parent() .context("Installed VPNC script has no parent directory")?; ensure_directory(directory, owner_uid)?; - if let Ok(metadata) = fs::symlink_metadata(target) { - validate_script_metadata(target, &metadata, owner_uid)?; + if let Ok(existing) = fs::symlink_metadata(target) { + validate_script(target, &existing, owner_uid)?; + } + if let Ok(existing) = fs::symlink_metadata(metadata_target) { + validate_metadata(metadata_target, &existing, owner_uid)?; } - - let mut contents = Vec::new(); - input - .by_ref() - .take(MAX_VPNC_SCRIPT_SIZE as u64 + 1) - .read_to_end(&mut contents) - .context("Failed to read the VPNC script")?; if contents.is_empty() { bail!("VPNC script is empty"); } if contents.len() > MAX_VPNC_SCRIPT_SIZE { bail!("VPNC script exceeds the {} byte limit", MAX_VPNC_SCRIPT_SIZE); } + metadata.validate()?; - let mut staged = NamedTempFile::new_in(directory).context("Failed to stage the VPNC script")?; - staged + let mut staged_script = NamedTempFile::new_in(directory).context("Failed to stage the VPNC script")?; + staged_script .as_file() .set_permissions(Permissions::from_mode(SCRIPT_MODE)) .context("Failed to set VPNC script permissions")?; - staged.write_all(&contents).context("Failed to write the VPNC script")?; - staged.as_file().sync_all().context("Failed to sync the VPNC script")?; - staged + staged_script + .write_all(contents) + .context("Failed to write the VPNC script")?; + staged_script + .as_file() + .sync_all() + .context("Failed to sync the VPNC script")?; + + let stored_metadata = StoredMetadata { + version: METADATA_VERSION, + metadata: metadata.clone(), + }; + let mut staged_metadata = NamedTempFile::new_in(directory).context("Failed to stage VPNC script metadata")?; + staged_metadata + .as_file() + .set_permissions(Permissions::from_mode(METADATA_MODE)) + .context("Failed to set VPNC script metadata permissions")?; + serde_json::to_writer(&mut staged_metadata, &stored_metadata).context("Failed to write VPNC script metadata")?; + staged_metadata + .as_file() + .sync_all() + .context("Failed to sync VPNC script metadata")?; + + staged_script .persist(target) .map_err(|err| err.error) .context("Failed to install the VPNC script")?; + staged_metadata + .persist(metadata_target) + .map_err(|err| err.error) + .context("Failed to install VPNC script metadata")?; sync_directory(directory)?; - let metadata = fs::symlink_metadata(target).context("Failed to inspect the installed VPNC script")?; - validate_script_metadata(target, &metadata, owner_uid) + let script_metadata = fs::symlink_metadata(target).context("Failed to inspect the installed VPNC script")?; + validate_script(target, &script_metadata, owner_uid)?; + let installed_metadata = fs::symlink_metadata(metadata_target).context("Failed to inspect VPNC script metadata")?; + validate_metadata(metadata_target, &installed_metadata, owner_uid) } -fn remove_at(target: &Path, owner_uid: u32) -> anyhow::Result<()> { +fn read_metadata_at(target: &Path, owner_uid: u32) -> anyhow::Result> { + let metadata = match fs::symlink_metadata(target) { + Ok(metadata) => metadata, + Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(None), + Err(err) => return Err(err).context("Failed to inspect VPNC script metadata"), + }; + validate_metadata(target, &metadata, owner_uid)?; + + let file = File::open(target).context("Failed to open VPNC script metadata")?; + let stored: StoredMetadata = + serde_json::from_reader(file.take(MAX_METADATA_SIZE)).context("Failed to parse VPNC script metadata")?; + if stored.version != METADATA_VERSION { + bail!("Unsupported VPNC script metadata version {}", stored.version); + } + stored.metadata.validate()?; + Ok(Some(stored.metadata)) +} + +fn remove_at( + target: &Path, + owner_uid: u32, + validate: fn(&Path, &Metadata, u32) -> anyhow::Result<()>, +) -> anyhow::Result<()> { let directory = target .parent() - .context("Installed VPNC script has no parent directory")?; + .context("VPNC script state file has no parent directory")?; validate_directory(directory, owner_uid)?; match fs::symlink_metadata(target) { Ok(metadata) => { - validate_script_metadata(target, &metadata, owner_uid)?; - fs::remove_file(target).context("Failed to remove the installed VPNC script")?; + validate(target, &metadata, owner_uid)?; + fs::remove_file(target).context("Failed to remove VPNC script state")?; sync_directory(directory) } Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(()), - Err(err) => Err(err).context("Failed to inspect the installed VPNC script"), + Err(err) => Err(err).context("Failed to inspect VPNC script state"), } } @@ -139,7 +212,7 @@ fn validate_directory(path: &Path, owner_uid: u32) -> anyhow::Result<()> { validate_ownership_and_mode(path, &metadata, owner_uid) } -fn validate_script_metadata(path: &Path, metadata: &Metadata, owner_uid: u32) -> anyhow::Result<()> { +fn validate_script(path: &Path, metadata: &Metadata, owner_uid: u32) -> anyhow::Result<()> { if metadata.file_type().is_symlink() || !metadata.is_file() { bail!("Installed VPNC script {} is not a regular file", path.display()); } @@ -150,6 +223,20 @@ fn validate_script_metadata(path: &Path, metadata: &Metadata, owner_uid: u32) -> Ok(()) } +fn validate_metadata(path: &Path, metadata: &Metadata, owner_uid: u32) -> anyhow::Result<()> { + if metadata.file_type().is_symlink() || !metadata.is_file() { + bail!("VPNC script metadata {} is not a regular file", path.display()); + } + validate_ownership_and_mode(path, metadata, owner_uid)?; + if metadata.mode() & 0o777 != METADATA_MODE { + bail!("VPNC script metadata {} must have mode 0600", path.display()); + } + if metadata.len() > MAX_METADATA_SIZE { + bail!("VPNC script metadata {} is too large", path.display()); + } + Ok(()) +} + fn validate_ownership_and_mode(path: &Path, metadata: &Metadata, owner_uid: u32) -> anyhow::Result<()> { if metadata.uid() != owner_uid { bail!("{} must be owned by uid {}", path.display(), owner_uid); @@ -168,23 +255,45 @@ fn sync_directory(directory: &Path) -> anyhow::Result<()> { #[cfg(test)] mod tests { + use gpapi::service::vpnc_script::VpncScriptSource; + use super::*; + fn source(value: &str) -> VpncScriptMetadata { + VpncScriptMetadata::new(VpncScriptSource::Command, value.to_owned()).unwrap() + } + #[test] - fn installs_and_removes_script_atomically() { + fn installs_metadata_and_removes_both_files() { let temp = tempfile::tempdir().unwrap(); let metadata = fs::symlink_metadata(temp.path()).unwrap(); let owner_uid = metadata.uid(); let directory = temp.path().join("scripts"); let target = directory.join("vpnc-script"); + let metadata_target = directory.join("vpnc-script.metadata"); + let source = source("exit 0"); - install_at("#!/bin/sh\nexit 0\n".as_bytes(), &target, owner_uid).unwrap(); + install_at(b"#!/bin/sh\nexit 0\n", &source, &target, &metadata_target, owner_uid).unwrap(); let metadata = fs::symlink_metadata(&target).unwrap(); assert!(metadata.is_file()); assert_eq!(metadata.mode() & 0o777, SCRIPT_MODE); + assert_eq!(read_metadata_at(&metadata_target, owner_uid).unwrap(), Some(source)); - remove_at(&target, owner_uid).unwrap(); + remove_at(&target, owner_uid, validate_script).unwrap(); + remove_at(&metadata_target, owner_uid, validate_metadata).unwrap(); assert!(!target.exists()); + assert!(!metadata_target.exists()); + } + + #[test] + fn missing_metadata_is_allowed() { + let temp = tempfile::tempdir().unwrap(); + let metadata = fs::symlink_metadata(temp.path()).unwrap(); + + assert_eq!( + read_metadata_at(&temp.path().join("missing"), metadata.uid()).unwrap(), + None + ); } #[test] @@ -193,9 +302,10 @@ mod tests { let metadata = fs::symlink_metadata(temp.path()).unwrap(); let owner_uid = metadata.uid(); let target = temp.path().join("scripts/vpnc-script"); + let metadata_target = temp.path().join("scripts/vpnc-script.metadata"); let input = vec![b'x'; MAX_VPNC_SCRIPT_SIZE + 1]; - assert!(install_at(input.as_slice(), &target, owner_uid).is_err()); + assert!(install_at(&input, &source("/tmp/script"), &target, &metadata_target, owner_uid).is_err()); assert!(!target.exists()); } @@ -209,8 +319,18 @@ mod tests { let directory = temp.path().join("scripts"); fs::create_dir(&directory).unwrap(); let target = directory.join("vpnc-script"); + let metadata_target = directory.join("vpnc-script.metadata"); symlink("/bin/sh", &target).unwrap(); - assert!(install_at("exit 0\n".as_bytes(), &target, owner_uid).is_err()); + assert!( + install_at( + b"exit 0\n", + &source("/tmp/script"), + &target, + &metadata_target, + owner_uid + ) + .is_err() + ); } } diff --git a/crates/common/src/constants.rs b/crates/common/src/constants.rs index 11bfc3c..44a863d 100644 --- a/crates/common/src/constants.rs +++ b/crates/common/src/constants.rs @@ -7,10 +7,14 @@ pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock"; pub const GP_VPNC_SCRIPT_INSTALLER_BINARY: &str = "/usr/libexec/gpclient/gp-vpnc-script-installer"; #[cfg(target_os = "linux")] pub const INSTALLED_VPNC_SCRIPT: &str = "/var/lib/gpclient/scripts/vpnc-script"; +#[cfg(target_os = "linux")] +pub const INSTALLED_VPNC_SCRIPT_METADATA: &str = "/var/lib/gpclient/scripts/vpnc-script.metadata"; #[cfg(any(target_os = "freebsd", target_os = "openbsd"))] pub const GP_VPNC_SCRIPT_INSTALLER_BINARY: &str = "/usr/local/libexec/gpclient/gp-vpnc-script-installer"; #[cfg(any(target_os = "freebsd", target_os = "openbsd"))] pub const INSTALLED_VPNC_SCRIPT: &str = "/var/db/gpclient/scripts/vpnc-script"; +#[cfg(any(target_os = "freebsd", target_os = "openbsd"))] +pub const INSTALLED_VPNC_SCRIPT_METADATA: &str = "/var/db/gpclient/scripts/vpnc-script.metadata"; pub const MAX_VPNC_SCRIPT_SIZE: usize = 1024 * 1024; pub const GP_CALLBACK_PORT_FILENAME: &str = "gpcallback.port"; diff --git a/crates/gpapi/src/service/mod.rs b/crates/gpapi/src/service/mod.rs index 063f395..e5e88df 100644 --- a/crates/gpapi/src/service/mod.rs +++ b/crates/gpapi/src/service/mod.rs @@ -3,3 +3,4 @@ pub mod request; pub mod transport; pub mod vpn_env; pub mod vpn_state; +pub mod vpnc_script; diff --git a/crates/gpapi/src/service/request.rs b/crates/gpapi/src/service/request.rs index 12afe2b..4f3d9f1 100644 --- a/crates/gpapi/src/service/request.rs +++ b/crates/gpapi/src/service/request.rs @@ -374,6 +374,7 @@ pub enum WsRequest { UpdateLogLevel(UpdateLogLevelRequest), RestartGui, UpdateGui(UpdateGuiRequest), + GetVpncScriptMetadata, } #[derive(Debug, Clone, Deserialize, Serialize)] diff --git a/crates/gpapi/src/service/transport/message.rs b/crates/gpapi/src/service/transport/message.rs index a2896df..8efdbba 100644 --- a/crates/gpapi/src/service/transport/message.rs +++ b/crates/gpapi/src/service/transport/message.rs @@ -1,7 +1,7 @@ use serde::{Deserialize, Serialize}; use uuid::Uuid; -use crate::service::{event::WsEvent, request::WsRequest, vpn_env::VpnEnv}; +use crate::service::{event::WsEvent, request::WsRequest, vpn_env::VpnEnv, vpnc_script::VpncScriptMetadata}; use super::{MAX_PLAINTEXT, MAX_SERVICE_MESSAGE, ServiceErrorCode, TransportError}; @@ -39,6 +39,7 @@ pub enum ServerMessage { #[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)] pub enum ServiceResult { Accepted, + VpncScriptMetadata(Option), Rejected(ServiceRejection), } diff --git a/crates/gpapi/src/service/vpnc_script.rs b/crates/gpapi/src/service/vpnc_script.rs new file mode 100644 index 0000000..70a3e3d --- /dev/null +++ b/crates/gpapi/src/service/vpnc_script.rs @@ -0,0 +1,84 @@ +use anyhow::bail; +use serde::{Deserialize, Serialize}; +use specta::Type; + +use crate::utils::base64; + +pub const MAX_VPNC_SCRIPT_SOURCE_VALUE: usize = 32 * 1024; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Type)] +#[serde(rename_all = "camelCase")] +pub enum VpncScriptSource { + File, + Command, +} + +#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct VpncScriptMetadata { + pub source: VpncScriptSource, + pub value: String, +} + +impl VpncScriptMetadata { + pub fn new(source: VpncScriptSource, value: String) -> anyhow::Result { + if value.trim().is_empty() { + bail!("VPNC script source is empty"); + } + if value.contains('\0') { + bail!("VPNC script source contains a null character"); + } + if value.len() > MAX_VPNC_SCRIPT_SOURCE_VALUE { + bail!( + "VPNC script source exceeds the {} byte limit", + MAX_VPNC_SCRIPT_SOURCE_VALUE + ); + } + Ok(Self { source, value }) + } + + pub fn validate(&self) -> anyhow::Result<()> { + Self::new(self.source, self.value.clone()).map(|_| ()) + } +} + +#[derive(Debug, Deserialize, Serialize)] +pub struct InstallVpncScriptRequest { + pub metadata: VpncScriptMetadata, + contents: String, +} + +impl InstallVpncScriptRequest { + pub fn new(metadata: VpncScriptMetadata, contents: &[u8]) -> Self { + Self { + metadata, + contents: base64::encode(contents), + } + } + + pub fn contents(&self) -> anyhow::Result> { + base64::decode_to_vec(&self.contents) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn install_request_round_trips_binary_contents() { + let metadata = VpncScriptMetadata::new(VpncScriptSource::File, "/tmp/vpnc-script".to_owned()).unwrap(); + let request = InstallVpncScriptRequest::new(metadata, b"#!/bin/sh\n"); + let encoded = serde_json::to_vec(&request).unwrap(); + let decoded: InstallVpncScriptRequest = serde_json::from_slice(&encoded).unwrap(); + + assert_eq!(decoded.contents().unwrap(), b"#!/bin/sh\n"); + } + + #[test] + fn metadata_rejects_invalid_source_value() { + assert!(VpncScriptMetadata::new(VpncScriptSource::Command, String::new()).is_err()); + assert!(VpncScriptMetadata::new(VpncScriptSource::Command, "echo\0value".to_owned()).is_err()); + assert!(VpncScriptMetadata::new(VpncScriptSource::Command, "x".repeat(MAX_VPNC_SCRIPT_SOURCE_VALUE + 1)).is_err()); + } +}