fix(desktop): keep GUI in the user authorization session

This commit is contained in:
Kevin Yue committed 2026-10-07 14:07:17 +08:00
1 parent 94bc0f0472
commit 8d45b66660
11 files changed
+438 -281

No files matched your search

+3 -20
View File
@@ -1,4 +1,4 @@
use std::{collections::HashMap, fs, path::PathBuf};
use std::{fs, path::PathBuf};
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use std::process::{Command, ExitStatus};
@@ -11,10 +11,7 @@ use clap::Args;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use common::binary_paths;
use directories::ProjectDirs;
use gpapi::{
process::service_launcher::ServiceLauncher,
utils::{endpoint::http_endpoint, env_utils, shutdown_signal},
};
use gpapi::{process::desktop_launcher::DesktopLauncher, utils::endpoint::http_endpoint};
use log::info;
#[derive(Args)]
@@ -69,27 +66,13 @@ impl<'a> LaunchGuiHandler<'a> {
return Ok(());
}
tokio::spawn(async move {
shutdown_signal().await;
info!("Shutting down...");
});
let log_file = get_log_file()?;
let log_file_path = log_file.to_string_lossy().to_string();
info!("Log file: {}", log_file_path);
let mut extra_envs = HashMap::<String, String>::new();
extra_envs.insert("GP_LOG_FILE".into(), log_file_path.clone());
// Persist the environment variables to a file
let env_file = env_utils::persist_env_vars(Some(extra_envs))?;
let env_file = env_file.into_temp_path();
let env_file_path = env_file.to_string_lossy().to_string();
let exit_status = ServiceLauncher::new()
let exit_status = DesktopLauncher::new(env!("CARGO_PKG_VERSION"))
.minimized(self.args.minimized)
.env_file(&env_file_path)
.log_file(&log_file_path)
.launch()
.await?;
+48 -65
View File
@@ -1,11 +1,8 @@
use std::io::Write;
use std::path::PathBuf;
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use std::sync::{Arc, atomic::AtomicBool};
#[cfg(target_os = "macos")]
use std::time::Duration;
use std::{collections::HashMap, io::Write};
use anyhow::{Context, bail};
use clap::Parser;
@@ -15,9 +12,8 @@ use gpapi::logger;
#[cfg(debug_assertions)]
use gpapi::utils::lock_file::dev_service_lock_file_path;
use gpapi::{
process::gui_launcher::GuiLauncher,
service::vpn_state::VpnState,
utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal},
utils::{lock_file::LockFile, redact::Redaction, shutdown_signal},
};
#[cfg(target_os = "macos")]
use log::{Log, Metadata, Record};
@@ -64,9 +60,9 @@ impl Log for RedactingMacosLogger {
#[command(version = VERSION)]
struct Cli {
#[clap(long)]
minimized: bool,
#[clap(long)]
env_file: Option<String>,
#[cfg_attr(debug_assertions, clap(conflicts_with = "dev_standalone"))]
#[cfg_attr(target_os = "macos", clap(conflicts_with = "macos_brokered"))]
desktop_credentials: bool,
#[cfg(debug_assertions)]
#[clap(long, requires_all = ["dev_uid", "dev_bootstrap_socket"])]
dev_standalone: bool,
@@ -100,7 +96,29 @@ impl Cli {
let gui_restart_requested = Arc::new(AtomicBool::new(false));
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let externally_brokered = self.externally_brokered();
let desktop_uid = crate::runtime_user::desktop_uid();
let desktop_uid = if self.desktop_credentials {
anyhow::ensure!(
nix::unistd::Uid::effective().is_root(),
"Desktop credentials require a privileged service"
);
let uid: u32 = std::env::var("PKEXEC_UID")
.context("Desktop credentials require a pkexec-authenticated user")?
.parse()
.context("Invalid pkexec user")?;
anyhow::ensure!(uid != 0, "Desktop credentials require a non-root user");
anyhow::ensure!(
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.is_some(),
"Desktop user is unavailable"
);
Some(uid)
} else {
crate::runtime_user::desktop_uid()
};
let desktop_channel = if self.desktop_credentials {
Some(crate::desktop_client::DesktopClient::from_stdio()?)
} else {
None
};
let brokered_scripts_dir = if externally_brokered {
let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
let contents_dir = executable
@@ -182,26 +200,28 @@ impl Cli {
tokio::spawn(async move { signals::handle_signals(lifecycle, ws_ctx).await });
}
let desktop_cancel = server_token.clone();
let shutdown_token = server_token.clone();
let vpn_task_handle = tokio::spawn(async move { vpn_task.start(server_token).await });
let (ws_ready_tx, ws_ready_rx) = tokio::sync::oneshot::channel();
let ws_server_handle = tokio::spawn(async move { ws_server.start(shutdown_tx_clone, ws_ready_tx).await });
#[cfg(debug_assertions)]
let launch_managed_gui = !self.dev_standalone && !externally_brokered;
#[cfg(not(debug_assertions))]
let launch_managed_gui = !externally_brokered;
if launch_managed_gui {
let desktop_client_handle = if let Some(channel) = desktop_channel {
ws_ready_rx.await.context("WebSocket server failed to start")?;
let envs = self.env_file.as_ref().map(env_utils::load_env_vars).transpose()?;
let minimized = self.minimized;
tokio::spawn(async move {
launch_gui(envs, registry, desktop_uid, minimized, gui_restart_requested).await;
let desktop_uid = desktop_uid.context("Desktop user is unavailable")?;
Some(tokio::spawn(async move {
if let Err(err) = channel
.serve(registry, desktop_uid, gui_restart_requested, desktop_cancel)
.await
{
warn!("Desktop credential channel ended: {err}");
}
let _ = shutdown_tx.send(()).await;
});
}))
} else {
info!("Running with a separately started debug GUI");
}
info!("Running with an externally launched GUI");
None
};
tokio::select! {
_ = shutdown_signal() => {
@@ -213,7 +233,11 @@ impl Cli {
}
vpn_task_cancel_token.cancel();
shutdown_token.cancel();
let _ = tokio::join!(vpn_task_handle, ws_server_handle);
if let Some(handle) = desktop_client_handle {
let _ = handle.await;
}
lock_file.unlock()?;
@@ -363,47 +387,6 @@ mod signals {
}
}
async fn launch_gui(
envs: Option<HashMap<String, String>>,
registry: Arc<SessionRegistry>,
desktop_uid: Option<u32>,
mut minimized: bool,
restart_requested: Arc<AtomicBool>,
) {
loop {
let credential = match registry.issue(env!("CARGO_PKG_VERSION"), desktop_uid) {
Ok(credential) => credential,
Err(err) => {
warn!("Failed to issue GUI credential: {err}");
break;
}
};
let session_id = credential.session_id();
let gui_launcher = GuiLauncher::new(env!("CARGO_PKG_VERSION"), credential)
.envs(envs.clone())
.minimized(minimized);
match gui_launcher.launch().await {
Ok(exit_status) => {
registry.revoke(session_id);
let should_restart = restart_requested.swap(false, Ordering::SeqCst);
if !should_restart {
info!("GUI exited with code {:?}", exit_status.code());
break;
}
info!("GUI restart requested, restarting");
minimized = false;
}
Err(err) => {
registry.revoke(session_id);
warn!("Failed to launch GUI: {}", err);
break;
}
}
}
}
pub async fn run() {
let mut cli = Cli::parse();
+223
View File
@@ -0,0 +1,223 @@
use std::{
io,
os::fd::OwnedFd,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
use anyhow::{Context, ensure};
use nix::{
fcntl::{FcntlArg, FdFlag, OFlag, fcntl},
sys::stat::{SFlag, fstat},
unistd::{dup, read, write},
};
use tokio::io::unix::AsyncFd;
use tokio_util::sync::CancellationToken;
use crate::session_registry::SessionRegistry;
/// Private parent/service pipes; credentials never pass through argv, environment or files.
pub(crate) struct DesktopClient {
input: AsyncFd<OwnedFd>,
output: AsyncFd<OwnedFd>,
}
impl DesktopClient {
pub(crate) fn from_stdio() -> anyhow::Result<Self> {
let channel = Self::new(dup(std::io::stdin())?, dup(std::io::stdout())?)?;
// Only the owned CLOEXEC descriptors carry credentials. VPN subprocesses inherit /dev/null.
let null = std::fs::OpenOptions::new().read(true).write(true).open("/dev/null")?;
nix::unistd::dup2_stdin(&null)?;
nix::unistd::dup2_stdout(&null)?;
Ok(channel)
}
fn new(input: OwnedFd, output: OwnedFd) -> anyhow::Result<Self> {
fn pipe(fd: OwnedFd) -> anyhow::Result<AsyncFd<OwnedFd>> {
ensure!(
SFlag::from_bits_truncate(fstat(&fd)?.st_mode).contains(SFlag::S_IFIFO),
"Desktop credentials require private pipes"
);
fcntl(&fd, FcntlArg::F_SETFD(FdFlag::FD_CLOEXEC))?;
let flags = OFlag::from_bits_truncate(fcntl(&fd, FcntlArg::F_GETFL)?);
fcntl(&fd, FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK))?;
Ok(AsyncFd::new(fd)?)
}
Ok(Self {
input: pipe(input)?,
output: pipe(output)?,
})
}
pub(crate) async fn serve(
self,
registry: Arc<SessionRegistry>,
uid: u32,
restart: Arc<AtomicBool>,
cancel: CancellationToken,
) -> anyhow::Result<()> {
loop {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
let session_id = credential.session_id();
let result = tokio::select! {
_ = cancel.cancelled() => Ok(false),
result = async {
self.write_frame(&credential.encode_frame()?).await?;
self.gui_exited().await
} => result,
};
registry.revoke(session_id);
if !result? || !restart.swap(false, Ordering::SeqCst) {
return Ok(());
}
}
}
async fn write_frame(&self, mut bytes: &[u8]) -> anyhow::Result<()> {
while !bytes.is_empty() {
let mut ready = self.output.writable().await?;
match ready.try_io(|fd| write(fd.get_ref(), bytes).map_err(io::Error::from)) {
Ok(result) => {
let length = result?;
ensure!(length != 0, "Desktop credential pipe closed");
bytes = &bytes[length..];
}
Err(_) => continue,
}
}
Ok(())
}
async fn gui_exited(&self) -> anyhow::Result<bool> {
loop {
let mut ready = self.input.readable().await?;
let mut byte = [0];
match ready.try_io(|fd| read(fd.get_ref(), &mut byte).map_err(io::Error::from)) {
Ok(result) => {
if result.context("Desktop control pipe failed")? == 0 {
return Ok(false);
}
ensure!(byte[0] == 0, "Invalid desktop control message");
return Ok(true);
}
Err(_) => continue,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credential_stdio_is_not_inherited_by_subprocesses() {
let output = std::process::Command::new(std::env::current_exe().unwrap())
.args(["--ignored", "--exact", "desktop_client::tests::stdio_child"])
.stdin(std::process::Stdio::piped())
.output()
.unwrap();
assert!(output.status.success());
let text = String::from_utf8_lossy(&output.stdout);
assert!(text.contains("PRIVATE_FRAME"));
assert!(!text.contains("CHILD_OUTPUT"));
}
#[tokio::test]
#[ignore = "subprocess fixture for credential_stdio_is_not_inherited_by_subprocesses"]
async fn stdio_child() {
let channel = DesktopClient::from_stdio().unwrap();
assert!(
std::process::Command::new("/bin/sh")
.args(["-c", "printf CHILD_OUTPUT"])
.status()
.unwrap()
.success()
);
channel.write_frame(b"PRIVATE_FRAME").await.unwrap();
}
use gpapi::service::transport::SessionCredential;
use nix::unistd::pipe;
use std::{fs::File, io::Read, time::Duration};
fn pipes() -> (DesktopClient, OwnedFd, File) {
let (input, control) = pipe().unwrap();
let (credentials, output) = pipe().unwrap();
(DesktopClient::new(input, output).unwrap(), control, credentials.into())
}
async fn credential(mut reader: File) -> (File, SessionCredential) {
tokio::task::spawn_blocking(move || {
let mut header = [0; 2];
reader.read_exact(&mut header).unwrap();
let mut frame = zeroize::Zeroizing::new(vec![0; usize::from(u16::from_be_bytes(header)) + 2]);
frame[..2].copy_from_slice(&header);
reader.read_exact(&mut frame[2..]).unwrap();
let credential = SessionCredential::decode_frame(&frame).unwrap();
(reader, credential)
})
.await
.unwrap()
}
#[tokio::test]
async fn desktop_channel_revokes_and_reissues_on_restart_then_closes_on_parent_exit() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let restart = Arc::new(AtomicBool::new(false));
let task = tokio::spawn(channel.serve(registry.clone(), 1000, restart.clone(), CancellationToken::new()));
let (reader, first) = credential(reader).await;
restart.store(true, Ordering::SeqCst);
write(&control, &[0]).unwrap();
let (_, second) = credential(reader).await;
assert_ne!(first.session_id(), second.session_id());
assert!(registry.last_successful_hip_report(first.session_id()).is_err());
drop(control);
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(second.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_shutdown_cancels_pipe_wait_and_revokes_credential() {
let (channel, _control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let cancel = CancellationToken::new();
let task = tokio::spawn(channel.serve(registry.clone(), 1000, Arc::new(AtomicBool::new(false)), cancel.clone()));
let (_, issued) = credential(reader).await;
cancel.cancel();
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_rejects_invalid_control_messages_and_revokes() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let task = tokio::spawn(channel.serve(
registry.clone(),
1000,
Arc::new(AtomicBool::new(false)),
CancellationToken::new(),
));
let (_, issued) = credential(reader).await;
write(&control, &[1]).unwrap();
assert!(
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
}
}
+1
View File
@@ -1,6 +1,7 @@
mod cli;
#[cfg(all(unix, any(target_os = "macos", debug_assertions)))]
mod credential_lease;
mod desktop_client;
#[cfg(debug_assertions)]
mod dev_bootstrap;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", all(test, unix)))]