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

@@ -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()
);
}
}