feat: persist VPN script installation metadata

This commit is contained in:
Kevin Yue committed 2026-07-30 22:06:18 +08:00
1 parent 6999b2725e
commit 40b35804e7
10 files changed
+276 -39

No files matched your search

@@ -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);
}
@@ -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(),
}
}
+16
View File
@@ -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) {
+1 -1
View File
@@ -289,7 +289,7 @@ async fn process_ws_req(req: WsRequest, ctx: Arc<VpnTaskContext>) {
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");
}
}
+155 -35
View File
@@ -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<Option<PathBuf>> {
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<Option<PathBuf>> {
}
}
pub fn install(input: impl Read) -> anyhow::Result<()> {
pub fn metadata() -> anyhow::Result<Option<VpncScriptMetadata>> {
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<Option<VpncScriptMetadata>> {
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()
);
}
}
+4
View File
@@ -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";
+1
View File
@@ -3,3 +3,4 @@ pub mod request;
pub mod transport;
pub mod vpn_env;
pub mod vpn_state;
pub mod vpnc_script;
+1
View File
@@ -374,6 +374,7 @@ pub enum WsRequest {
UpdateLogLevel(UpdateLogLevelRequest),
RestartGui,
UpdateGui(UpdateGuiRequest),
GetVpncScriptMetadata,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
@@ -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<VpncScriptMetadata>),
Rejected(ServiceRejection),
}
+84
View File
@@ -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<Self> {
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<Vec<u8>> {
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());
}
}