From ce97729984cef9f9b29695105a0daa15f2f27c53 Mon Sep 17 00:00:00 2001 From: Kevin Yue Date: Thu, 16 Jul 2026 20:35:46 +0800 Subject: [PATCH] refactor: authenticate service websocket transport --- Cargo.lock | 178 +++++- Cargo.toml | 2 + Makefile | 3 + apps/gpgui-helper/src-tauri/Cargo.toml | 3 + apps/gpgui-helper/src-tauri/src/app.rs | 27 +- apps/gpgui-helper/src-tauri/src/cli.rs | 80 ++- apps/gpgui-helper/src-tauri/src/updater.rs | 470 ++++++++++++++- apps/gpservice/Cargo.toml | 10 + apps/gpservice/src/cli.rs | 98 ++-- apps/gpservice/src/dev_bootstrap.rs | 244 ++++++++ apps/gpservice/src/handlers.rs | 174 +----- apps/gpservice/src/main.rs | 4 + apps/gpservice/src/request_dispatcher.rs | 280 +++++++++ apps/gpservice/src/routes.rs | 2 - apps/gpservice/src/session_registry.rs | 363 ++++++++++++ apps/gpservice/src/vpn_task.rs | 7 +- apps/gpservice/src/ws_connection.rs | 549 ++++++++++++++++-- apps/gpservice/src/ws_server.rs | 415 +++++++++---- crates/gpapi/Cargo.toml | 5 +- crates/gpapi/src/lib.rs | 3 - .../gpapi/src/process/gui_helper_launcher.rs | 18 +- crates/gpapi/src/process/gui_launcher.rs | 21 +- crates/gpapi/src/service/mod.rs | 1 + crates/gpapi/src/service/request.rs | 7 +- .../gpapi/src/service/transport/credential.rs | 164 ++++++ crates/gpapi/src/service/transport/error.rs | 118 ++++ .../gpapi/src/service/transport/handshake.rs | 85 +++ crates/gpapi/src/service/transport/message.rs | 140 +++++ crates/gpapi/src/service/transport/mod.rs | 18 + crates/gpapi/src/service/transport/noise.rs | 231 ++++++++ scripts/dev-service.sh | 25 + 31 files changed, 3304 insertions(+), 441 deletions(-) create mode 100644 apps/gpservice/src/dev_bootstrap.rs create mode 100644 apps/gpservice/src/request_dispatcher.rs create mode 100644 apps/gpservice/src/session_registry.rs create mode 100644 crates/gpapi/src/service/transport/credential.rs create mode 100644 crates/gpapi/src/service/transport/error.rs create mode 100644 crates/gpapi/src/service/transport/handshake.rs create mode 100644 crates/gpapi/src/service/transport/message.rs create mode 100644 crates/gpapi/src/service/transport/mod.rs create mode 100644 crates/gpapi/src/service/transport/noise.rs create mode 100755 scripts/dev-service.sh diff --git a/Cargo.lock b/Cargo.lock index 78f73ff..2941d4d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20,7 +20,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" dependencies = [ - "crypto-common", + "crypto-common 0.1.7", "generic-array", ] @@ -299,10 +299,10 @@ dependencies = [ "serde_json", "serde_path_to_error", "serde_urlencoded", - "sha1", + "sha1 0.10.7", "sync_wrapper", "tokio", - "tokio-tungstenite", + "tokio-tungstenite 0.29.0", "tower", "tower-layer", "tower-service", @@ -379,6 +379,15 @@ dependencies = [ "serde_core", ] +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest 0.10.7", +] + [[package]] name = "block-buffer" version = "0.10.4" @@ -388,6 +397,15 @@ dependencies = [ "generic-array", ] +[[package]] +name = "block-buffer" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa" +dependencies = [ + "hybrid-array", +] + [[package]] name = "block2" version = "0.6.2" @@ -644,7 +662,7 @@ version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" dependencies = [ - "crypto-common", + "crypto-common 0.1.7", "inout", "zeroize", ] @@ -742,6 +760,12 @@ dependencies = [ "time", ] +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + [[package]] name = "convert_case" version = "0.10.0" @@ -910,6 +934,15 @@ dependencies = [ "typenum", ] +[[package]] +name = "crypto-common" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" +dependencies = [ + "hybrid-array", +] + [[package]] name = "cssparser" version = "0.36.0" @@ -949,6 +982,31 @@ version = "0.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1" +[[package]] +name = "curve25519-dalek" +version = "4.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "curve25519-dalek-derive", + "fiat-crypto", + "rustc_version", + "subtle", +] + +[[package]] +name = "curve25519-dalek-derive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "darling" version = "0.23.0" @@ -1068,8 +1126,20 @@ version = "0.10.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ - "block-buffer", - "crypto-common", + "block-buffer 0.10.4", + "crypto-common 0.1.7", + "subtle", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "block-buffer 0.12.1", + "const-oid", + "crypto-common 0.2.2", ] [[package]] @@ -1346,6 +1416,12 @@ dependencies = [ "simd-adler32", ] +[[package]] +name = "fiat-crypto" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" + [[package]] name = "field-offset" version = "0.3.6" @@ -1805,6 +1881,7 @@ dependencies = [ "common", "dns-lookup", "env_logger", + "getrandom 0.4.3", "gtk", "humantime", "log", @@ -1822,6 +1899,7 @@ dependencies = [ "serde_json", "serde_urlencoded", "sha256", + "snow", "specta", "tauri", "tempfile", @@ -1834,6 +1912,7 @@ dependencies = [ "version-compare", "whoami", "xmltree", + "zeroize", ] [[package]] @@ -1901,6 +1980,9 @@ dependencies = [ "tauri-build", "tempfile", "tokio", + "tokio-tungstenite 0.30.0", + "uuid", + "zeroize", ] [[package]] @@ -1916,13 +1998,19 @@ dependencies = [ "futures", "gpapi", "log", + "nix", "openconnect", "serde", "serde_json", "tar", + "tempfile", + "thiserror 2.0.18", "tokio", + "tokio-tungstenite 0.29.0", "tokio-util", + "uuid", "xz2", + "zeroize", ] [[package]] @@ -2102,6 +2190,15 @@ version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "15cdd26707701c53297e2fa6afb323d55fbc1d0810c3aec078ae3ef0424c3c15" +[[package]] +name = "hybrid-array" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "818356c5132c1fede50f837ca96afbe78ff42413047f4abb886217845e1b6c8c" +dependencies = [ + "typenum", +] + [[package]] name = "hyper" version = "1.10.1" @@ -2927,6 +3024,7 @@ dependencies = [ "cfg-if", "cfg_aliases", "libc", + "memoffset", ] [[package]] @@ -4424,7 +4522,18 @@ checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8" dependencies = [ "cfg-if", "cpufeatures 0.2.17", - "digest", + "digest 0.10.7", +] + +[[package]] +name = "sha1" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "digest 0.11.3", ] [[package]] @@ -4441,7 +4550,7 @@ checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" dependencies = [ "cfg-if", "cpufeatures 0.2.17", - "digest", + "digest 0.10.7", ] [[package]] @@ -4534,6 +4643,22 @@ version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" +[[package]] +name = "snow" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "599b506ccc4aff8cf7844bc42cf783009a434c1e26c964432560fb6d6ad02d82" +dependencies = [ + "blake2", + "chacha20poly1305", + "curve25519-dalek", + "getrandom 0.3.4", + "ring", + "rustc_version", + "sha2", + "subtle", +] + [[package]] name = "socket2" version = "0.6.5" @@ -5231,7 +5356,19 @@ dependencies = [ "futures-util", "log", "tokio", - "tungstenite", + "tungstenite 0.29.0", +] + +[[package]] +name = "tokio-tungstenite" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17a073bfed563fa236697a068031408a93cd9522e08abf9933ead3e73411bd71" +dependencies = [ + "futures-util", + "log", + "tokio", + "tungstenite 0.30.0", ] [[package]] @@ -5473,7 +5610,23 @@ dependencies = [ "httparse", "log", "rand 0.9.5", - "sha1", + "sha1 0.10.7", + "thiserror 2.0.18", +] + +[[package]] +name = "tungstenite" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e48ac77174b19c110a50ab2128b24215ac9cb40e0e12e093fb602d175c569d22" +dependencies = [ + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.10.2", + "sha1 0.11.0", "thiserror 2.0.18", ] @@ -5560,7 +5713,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" dependencies = [ - "crypto-common", + "crypto-common 0.1.7", "subtle", ] @@ -6622,6 +6775,9 @@ name = "zeroize" version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" +dependencies = [ + "serde", +] [[package]] name = "zerotrie" diff --git a/Cargo.toml b/Cargo.toml index 8d4a4c8..1d65a16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -59,6 +59,8 @@ which = "8" uuid = "1" netdev = "0.40" humantime = "2" +snow = { version = "0.10", default-features = false, features = ["std", "use-getrandom", "use-curve25519", "use-chacha20poly1305", "use-sha2"] } +zeroize = "1" # Tauri dependencies tauri = { version = "2" } diff --git a/Makefile b/Makefile index 6bf9ff2..62290d3 100644 --- a/Makefile +++ b/Makefile @@ -64,6 +64,9 @@ endif default: build +dev-service: + ./scripts/dev-service.sh + version: @echo $(VERSION) diff --git a/apps/gpgui-helper/src-tauri/Cargo.toml b/apps/gpgui-helper/src-tauri/Cargo.toml index d77be92..720c66f 100644 --- a/apps/gpgui-helper/src-tauri/Cargo.toml +++ b/apps/gpgui-helper/src-tauri/Cargo.toml @@ -20,6 +20,9 @@ clap.workspace = true compile-time.workspace = true env_logger.workspace = true futures-util.workspace = true +uuid.workspace = true +zeroize.workspace = true +tokio-tungstenite = "0.30" tempfile.workspace = true reqwest = { workspace = true, features = ["stream"] } diff --git a/apps/gpgui-helper/src-tauri/src/app.rs b/apps/gpgui-helper/src-tauri/src/app.rs index f9e3703..a444c4a 100644 --- a/apps/gpgui-helper/src-tauri/src/app.rs +++ b/apps/gpgui-helper/src-tauri/src/app.rs @@ -1,26 +1,31 @@ use std::sync::Arc; +use gpapi::service::transport::SessionCredential; use log::info; use tauri::{Listener, Manager}; +use tokio::sync::watch; use crate::updater::{GuiUpdater, Installer, ProgressNotifier}; pub struct App { - api_key: Vec, + credential: Arc, + credential_lease: watch::Receiver, gui_version: String, } impl App { - pub fn new(api_key: Vec, gui_version: &str) -> Self { + pub fn new(credential: Arc, credential_lease: watch::Receiver, gui_version: &str) -> Self { Self { - api_key, + credential, + credential_lease, gui_version: gui_version.to_string(), } } pub fn run(&self) -> anyhow::Result<()> { let gui_version = self.gui_version.clone(); - let api_key = self.api_key.clone(); + let credential = Arc::clone(&self.credential); + let credential_lease = self.credential_lease.clone(); tauri::Builder::default() .setup(move |app| { @@ -28,9 +33,21 @@ impl App { let _ = win.hide_menu(); let notifier = ProgressNotifier::new(win.clone()); - let installer = Installer::new(api_key); + let installer = Installer::new(credential, credential_lease.clone()); let updater = Arc::new(GuiUpdater::new(gui_version, notifier, installer)); + let app_handle = app.handle().clone(); + let mut app_credential_lease = credential_lease; + tokio::spawn(async move { + while *app_credential_lease.borrow() { + if app_credential_lease.changed().await.is_err() { + return; + } + } + info!("Service credential lease ended"); + app_handle.exit(0); + }); + let win_clone = win.clone(); app.listen_any("app://update-done", move |_event| { info!("Update done"); diff --git a/apps/gpgui-helper/src-tauri/src/cli.rs b/apps/gpgui-helper/src-tauri/src/cli.rs index 532fb1a..7cb0c4b 100644 --- a/apps/gpgui-helper/src-tauri/src/cli.rs +++ b/apps/gpgui-helper/src-tauri/src/cli.rs @@ -1,9 +1,15 @@ use clap::Parser; +use std::{io::Read, sync::Arc}; + +use anyhow::{Context, bail}; use gpapi::{ clap::InfoLevelVerbosity, - utils::{base64, env_utils}, + service::transport::{MAX_CREDENTIAL_FRAME, SessionCredential}, + utils::env_utils, }; use log::info; +use tokio::sync::watch; +use zeroize::Zeroizing; use crate::app::App; @@ -15,13 +21,11 @@ const VERSION: &str = concat!( compile_time::date_str!(), ")" ); -const GP_API_KEY: &[u8; 32] = &[0; 32]; - #[derive(Parser)] #[command(version = VERSION)] struct Cli { - #[arg(long, help = "Read the API key from stdin")] - api_key_on_stdin: bool, + #[arg(long, help = "Read the service credential from stdin")] + service_credential_on_stdin: bool, #[arg(long, default_value = env!("CARGO_PKG_VERSION"), help = "The version of the GUI")] gui_version: String, @@ -32,28 +36,56 @@ struct Cli { impl Cli { fn run(&self) -> anyhow::Result<()> { - let api_key = self.read_api_key()?; - let app = App::new(api_key, &self.gui_version); + let credential = self.read_credential()?; + let credential_lease = monitor_credential_lease().context("Failed to monitor service credential lifetime")?; + let app = App::new(Arc::new(credential), credential_lease, &self.gui_version); env_utils::patch_gui_runtime_env(false); app.run() } - fn read_api_key(&self) -> anyhow::Result> { - if self.api_key_on_stdin { - let mut api_key = String::new(); - std::io::stdin().read_line(&mut api_key)?; - - let api_key = base64::decode_to_vec(api_key.trim())?; - - Ok(api_key) - } else { - Ok(GP_API_KEY.to_vec()) + fn read_credential(&self) -> anyhow::Result { + if !self.service_credential_on_stdin { + bail!("Service credential must be provided via --service-credential-on-stdin"); } + let stdin = std::io::stdin(); + let mut input = stdin.lock(); + let mut header = [0_u8; 2]; + input + .read_exact(&mut header) + .context("Failed to read service credential header")?; + let payload_len = u16::from_be_bytes(header) as usize; + if payload_len == 0 || payload_len + header.len() > MAX_CREDENTIAL_FRAME { + bail!("Invalid service credential length"); + } + let mut frame = Zeroizing::new(Vec::with_capacity(payload_len + header.len())); + frame.extend_from_slice(&header); + frame.resize(payload_len + header.len(), 0); + input + .read_exact(&mut frame[header.len()..]) + .context("Failed to read service credential")?; + SessionCredential::decode_frame(&frame).context("Invalid service credential") } } +fn monitor_credential_lease() -> std::io::Result> { + let (lease_tx, lease_rx) = watch::channel(true); + std::thread::Builder::new() + .name("credential-lease".to_owned()) + .spawn(move || { + let stdin = std::io::stdin(); + close_credential_lease_at_eof(stdin.lock(), lease_tx); + })?; + Ok(lease_rx) +} + +fn close_credential_lease_at_eof(mut input: impl Read, lease_tx: watch::Sender) { + let mut buffer = [0_u8; 256]; + while matches!(input.read(&mut buffer), Ok(len) if len > 0) {} + let _ = lease_tx.send(false); +} + fn init_logger(cli: &Cli) { env_logger::builder() .filter_level(cli.verbose.log_level_filter()) @@ -71,3 +103,17 @@ pub fn run() { std::process::exit(1); } } + +#[cfg(test)] +mod tests { + use std::io::Cursor; + + use super::*; + + #[test] + fn credential_lease_closes_at_eof() { + let (lease_tx, lease_rx) = watch::channel(true); + close_credential_lease_at_eof(Cursor::new(b"ignored lease bytes"), lease_tx); + assert!(!*lease_rx.borrow()); + } +} diff --git a/apps/gpgui-helper/src-tauri/src/updater.rs b/apps/gpgui-helper/src-tauri/src/updater.rs index fb311ad..dbc5a88 100644 --- a/apps/gpgui-helper/src-tauri/src/updater.rs +++ b/apps/gpgui-helper/src-tauri/src/updater.rs @@ -1,11 +1,31 @@ -use std::sync::{Arc, RwLock}; +use std::{ + error::Error, + fmt::{self, Display, Formatter}, + sync::{Arc, RwLock}, + time::Duration, +}; +use anyhow::{Context, bail}; +use futures_util::{SinkExt, StreamExt}; use gpapi::{ - service::request::UpdateGuiRequest, - utils::{checksum::verify_checksum, crypto::Crypto, endpoint::http_endpoint}, + service::{ + request::{UpdateGuiRequest, WsRequest}, + transport::{ + ClientMessage, ClientPrelude, MAX_WS_MESSAGE, NoiseInitiator, NoiseTransport, ServerMessage, ServerPrelude, + ServiceResult, SessionCredential, + }, + }, + utils::{checksum::verify_checksum, endpoint::ws_endpoint}, }; use log::{info, warn}; use tauri::{Emitter, WebviewWindow}; +use tokio::net::TcpStream; +use tokio::sync::{mpsc, oneshot, watch}; +use tokio_tungstenite::{ + MaybeTlsStream, WebSocketStream, connect_async_with_config, + tungstenite::{Message, protocol::WebSocketConfig}, +}; +use uuid::Uuid; use crate::downloader::{ChecksumFetcher, FileDownloader}; @@ -44,33 +64,282 @@ impl ProgressNotifier { } pub struct Installer { - crypto: Crypto, + command_tx: mpsc::Sender, +} + +struct InstallCommand { + request: UpdateGuiRequest, + reply: oneshot::Sender>, } impl Installer { - pub fn new(api_key: Vec) -> Self { - Self { - crypto: Crypto::new(api_key), - } + pub fn new(credential: Arc, credential_lease: watch::Receiver) -> Self { + let (command_tx, command_rx) = mpsc::channel(1); + tokio::spawn(async move { + run_installer(credential, credential_lease, command_rx).await; + }); + Self { command_tx } } async fn install(&self, path: &str, checksum: &str) -> anyhow::Result<()> { - let service_endpoint = http_endpoint().await?; - let request = UpdateGuiRequest { path: path.to_string(), checksum: checksum.to_string(), }; - let payload = self.crypto.encrypt(&request)?; + let (reply, result) = oneshot::channel(); + self + .command_tx + .send(InstallCommand { request, reply }) + .await + .context("Authenticated GUI installer is unavailable")?; + tokio::time::timeout(Duration::from_secs(60), result) + .await + .context("Service update request timed out")? + .context("Authenticated GUI installer stopped before replying")? + } +} - reqwest::Client::default() - .post(format!("{}/update-gui", service_endpoint)) - .body(payload) - .send() - .await? - .error_for_status()?; +type Socket = WebSocketStream>; - Ok(()) +#[derive(Debug)] +struct TerminalConnectError(String); + +impl Display for TerminalConnectError { + fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result { + formatter.write_str(&self.0) + } +} + +impl Error for TerminalConnectError {} + +async fn run_installer( + credential: Arc, + mut credential_lease: watch::Receiver, + mut commands: mpsc::Receiver, +) { + let mut pending = None; + + loop { + if !*credential_lease.borrow() { + return; + } + + let connection = tokio::select! { + changed = credential_lease.changed() => { + if changed.is_err() || !*credential_lease.borrow() { + return; + } + continue; + } + result = tokio::time::timeout(Duration::from_secs(5), connect_installer(&credential)) => { + match result { + Ok(result) => result, + Err(_) => Err(anyhow::anyhow!("Authenticated GUI installer handshake timed out")), + } + } + }; + + match connection { + Ok((mut socket, mut noise)) => { + info!("Authenticated GUI installer connected"); + match run_installer_connection( + &mut socket, + &mut noise, + &mut credential_lease, + &mut commands, + &mut pending, + ) + .await + { + Ok(ConnectionEnd::CredentialLeaseEnded | ConnectionEnd::CommandsClosed) => return, + Err(err) => warn!("Authenticated GUI installer connection lost: {err}"), + } + } + Err(err) if err.is::() => { + warn!("Authenticated GUI installer stopped: {err}"); + return; + } + Err(err) => warn!("Authenticated GUI installer connection failed: {err}"), + } + + tokio::select! { + changed = credential_lease.changed() => { + if changed.is_err() || !*credential_lease.borrow() { + return; + } + } + _ = tokio::time::sleep(Duration::from_millis(100)) => {} + } + } +} + +enum ConnectionEnd { + CredentialLeaseEnded, + CommandsClosed, +} + +async fn run_installer_connection( + socket: &mut Socket, + noise: &mut NoiseTransport, + credential_lease: &mut watch::Receiver, + commands: &mut mpsc::Receiver, + pending: &mut Option, +) -> anyhow::Result { + if pending.as_ref().is_some_and(|command| command.reply.is_closed()) { + pending.take(); + } + let mut pending_id = match pending.as_ref() { + Some(command) => Some(send_install_command(socket, noise, command).await?), + None => None, + }; + + loop { + tokio::select! { + changed = credential_lease.changed() => { + if changed.is_err() || !*credential_lease.borrow() { + return Ok(ConnectionEnd::CredentialLeaseEnded); + } + } + command = commands.recv() => { + let Some(command) = command else { return Ok(ConnectionEnd::CommandsClosed) }; + if command.reply.is_closed() { + continue; + } + if pending.is_some() { + let _ = command.reply.send(Err(anyhow::anyhow!("GUI installation is already pending"))); + continue; + } + *pending = Some(command); + pending_id = Some(send_install_command(socket, noise, pending.as_ref().unwrap()).await?); + } + frame = socket.next() => { + match frame.context("Service closed the authenticated GUI installer")?? { + Message::Binary(data) => match noise.decrypt::(&data)? { + ServerMessage::Reply { id, result } => { + if pending_id != Some(id) { + bail!("Service sent a mismatched GUI installation reply"); + } + let Some(command) = pending.take() else { + bail!("Service sent an unexpected GUI installation reply"); + }; + pending_id = None; + let result = match result { + ServiceResult::Accepted => Ok(()), + ServiceResult::Rejected(rejection) => Err(anyhow::anyhow!( + "Service rejected GUI installation ({:?}): {}", + rejection.code(), + rejection.message() + )), + }; + let _ = command.reply.send(result); + } + ServerMessage::Event { .. } | ServerMessage::Snapshot { .. } => {} + ServerMessage::Attached { .. } => bail!("Service sent a duplicate attach response"), + }, + Message::Ping(data) => socket.send(Message::Pong(data)).await?, + Message::Pong(_) => {} + Message::Close(_) => bail!("Service closed the authenticated GUI installer"), + _ => bail!("Service sent an unexpected WebSocket frame"), + } + } + } + } +} + +async fn send_install_command( + socket: &mut Socket, + noise: &mut NoiseTransport, + command: &InstallCommand, +) -> anyhow::Result { + let id = Uuid::new_v4(); + send_client_message( + socket, + noise, + &ClientMessage::Request { + id, + request: WsRequest::UpdateGui(command.request.clone()), + }, + ) + .await?; + Ok(id) +} + +async fn connect_installer(credential: &SessionCredential) -> anyhow::Result<(Socket, NoiseTransport)> { + let endpoint = ws_endpoint().await?; + connect_installer_at(credential, &endpoint).await +} + +async fn connect_installer_at( + credential: &SessionCredential, + endpoint: &str, +) -> anyhow::Result<(Socket, NoiseTransport)> { + if credential.product_version() != env!("CARGO_PKG_VERSION") { + return Err(TerminalConnectError("Service credential version does not match gpgui-helper".to_owned()).into()); + } + let config = WebSocketConfig::default() + .max_message_size(Some(MAX_WS_MESSAGE)) + .max_frame_size(Some(MAX_WS_MESSAGE)); + let (mut socket, _) = connect_async_with_config(endpoint, Some(config), false).await?; + let prelude = ClientPrelude { + product_version: credential.product_version().to_owned(), + service_instance_id: credential.service_instance_id(), + session_id: credential.session_id(), + }; + socket.send(Message::Binary(prelude.encode()?.into())).await?; + let server_prelude = ServerPrelude::decode(&receive_binary(&mut socket).await?) + .map_err(|err| TerminalConnectError(format!("Service sent an invalid update-session response: {err}")))?; + match server_prelude { + ServerPrelude::Ready => {} + ServerPrelude::Rejected(reason) => { + return Err(TerminalConnectError(format!("Service rejected the update session: {reason:?}")).into()); + } + } + + let mut initiator = NoiseInitiator::new( + credential.product_version(), + credential.service_instance_id(), + credential.session_id(), + credential.secret(), + )?; + socket.send(Message::Binary(initiator.write_first()?.into())).await?; + let mut noise = initiator.read_response(&receive_binary(&mut socket).await?)?; + send_client_message( + &mut socket, + &mut noise, + &ClientMessage::Attach { + last_event_revision: None, + }, + ) + .await?; + if !matches!( + receive_server_message(&mut socket, &mut noise).await?, + ServerMessage::Attached { .. } + ) { + bail!("Service did not attach the update session"); + } + + Ok((socket, noise)) +} + +async fn send_client_message( + socket: &mut Socket, + noise: &mut NoiseTransport, + message: &ClientMessage, +) -> anyhow::Result<()> { + socket.send(Message::Binary(noise.encrypt(message)?.into())).await?; + Ok(()) +} + +async fn receive_server_message(socket: &mut Socket, noise: &mut NoiseTransport) -> anyhow::Result { + Ok(noise.decrypt(&receive_binary(socket).await?)?) +} + +async fn receive_binary(socket: &mut Socket) -> anyhow::Result> { + match socket.next().await { + Some(Ok(Message::Binary(data))) => Ok(data.to_vec()), + Some(Ok(_)) => bail!("Service sent an unexpected handshake frame"), + Some(Err(err)) => Err(err.into()), + None => bail!("Service closed during handshake"), } } @@ -206,3 +475,168 @@ impl GuiUpdater { self.notifier.notify(progress); } } + +#[cfg(test)] +mod tests { + use gpapi::{ + os_profile::HostIdentity, + service::{ + transport::{ClientPrelude, NoiseResponder}, + vpn_env::{HostInfo, VpnEnv}, + vpn_state::VpnState, + }, + }; + use tokio::net::TcpListener; + use tokio_tungstenite::accept_async; + + use super::*; + + #[tokio::test] + async fn pending_install_reconnects_with_a_fresh_handshake() { + let credential = Arc::new(SessionCredential::generate(Uuid::new_v4(), env!("CARGO_PKG_VERSION")).unwrap()); + let (command_tx, mut commands) = mpsc::channel(1); + let (reply_tx, reply_rx) = oneshot::channel(); + command_tx + .send(InstallCommand { + request: UpdateGuiRequest { + path: "/tmp/gpgui-update".to_owned(), + checksum: "checksum".to_owned(), + }, + reply: reply_tx, + }) + .await + .unwrap(); + let (_lease_tx, mut credential_lease) = watch::channel(true); + let mut pending = None; + + let (first_endpoint, first_service) = spawn_test_service(Arc::clone(&credential), false).await; + let (mut socket, mut noise) = connect_installer_at(&credential, &first_endpoint).await.unwrap(); + assert!( + run_installer_connection( + &mut socket, + &mut noise, + &mut credential_lease, + &mut commands, + &mut pending, + ) + .await + .is_err() + ); + first_service.await.unwrap(); + assert!(pending.is_some()); + + let (second_endpoint, second_service) = spawn_test_service(Arc::clone(&credential), true).await; + let (mut socket, mut noise) = connect_installer_at(&credential, &second_endpoint).await.unwrap(); + assert!( + run_installer_connection( + &mut socket, + &mut noise, + &mut credential_lease, + &mut commands, + &mut pending, + ) + .await + .is_err() + ); + second_service.await.unwrap(); + assert!(pending.is_none()); + assert!(reply_rx.await.unwrap().is_ok()); + } + + #[tokio::test] + async fn credential_version_mismatch_is_terminal() { + let credential = SessionCredential::generate(Uuid::new_v4(), "different-version").unwrap(); + let Err(err) = connect_installer_at(&credential, "ws://127.0.0.1:1/ws").await else { + panic!("version mismatch should fail before connecting"); + }; + assert!(err.is::()); + } + + async fn spawn_test_service( + credential: Arc, + reply: bool, + ) -> (String, tokio::task::JoinHandle<()>) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let endpoint = format!("ws://{}/ws", listener.local_addr().unwrap()); + let service = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + let prelude = match socket.next().await.unwrap().unwrap() { + Message::Binary(data) => ClientPrelude::decode(&data).unwrap(), + frame => panic!("unexpected prelude frame: {frame:?}"), + }; + assert_eq!(prelude.service_instance_id, credential.service_instance_id()); + assert_eq!(prelude.session_id, credential.session_id()); + socket + .send(Message::Binary(ServerPrelude::Ready.encode().unwrap().into())) + .await + .unwrap(); + + let mut responder = NoiseResponder::new( + credential.product_version(), + credential.service_instance_id(), + credential.session_id(), + credential.secret(), + ) + .unwrap(); + let first = match socket.next().await.unwrap().unwrap() { + Message::Binary(data) => data, + frame => panic!("unexpected handshake frame: {frame:?}"), + }; + responder.read_first(&first).unwrap(); + let (response, mut noise) = responder.write_response().unwrap(); + socket.send(Message::Binary(response.into())).await.unwrap(); + + let attach = match socket.next().await.unwrap().unwrap() { + Message::Binary(data) => data, + frame => panic!("unexpected attach frame: {frame:?}"), + }; + assert!(matches!( + noise.decrypt::(&attach).unwrap(), + ClientMessage::Attach { .. } + )); + let attached = ServerMessage::Attached { + connection_id: Uuid::new_v4(), + current_revision: 0, + snapshot: VpnEnv { + vpn_state: VpnState::Disconnected, + vpnc_script: None, + csd_wrapper: None, + auth_executable: String::new(), + host_info: HostInfo { + host_identity: HostIdentity::collect(), + }, + }, + }; + socket + .send(Message::Binary(noise.encrypt(&attached).unwrap().into())) + .await + .unwrap(); + + let request = match socket.next().await.unwrap().unwrap() { + Message::Binary(data) => noise.decrypt::(&data).unwrap(), + frame => panic!("unexpected request frame: {frame:?}"), + }; + let ClientMessage::Request { + id, + request: WsRequest::UpdateGui(update), + } = request + else { + panic!("unexpected installer request"); + }; + assert_eq!(update.path, "/tmp/gpgui-update"); + if reply { + let message = ServerMessage::Reply { + id, + result: ServiceResult::Accepted, + }; + socket + .send(Message::Binary(noise.encrypt(&message).unwrap().into())) + .await + .unwrap(); + } + socket.close(None).await.unwrap(); + }); + (endpoint, service) + } +} diff --git a/apps/gpservice/Cargo.toml b/apps/gpservice/Cargo.toml index f3e06c6..c6175fb 100644 --- a/apps/gpservice/Cargo.toml +++ b/apps/gpservice/Cargo.toml @@ -21,3 +21,13 @@ log.workspace = true compile-time.workspace = true xz2 = "0.1" tar = "0.4" +thiserror.workspace = true +uuid = { workspace = true, features = ["v4"] } +zeroize.workspace = true +tempfile.workspace = true + +[target.'cfg(unix)'.dependencies] +nix = { version = "0.31", features = ["fs", "socket", "user"] } + +[dev-dependencies] +tokio-tungstenite = "0.29" diff --git a/apps/gpservice/src/cli.rs b/apps/gpservice/src/cli.rs index f8595e0..af31360 100644 --- a/apps/gpservice/src/cli.rs +++ b/apps/gpservice/src/cli.rs @@ -1,10 +1,12 @@ +#[cfg(debug_assertions)] +use std::path::PathBuf; use std::sync::{ Arc, atomic::{AtomicBool, Ordering}, }; use std::{collections::HashMap, io::Write}; -use anyhow::bail; +use anyhow::{Context, bail}; use clap::Parser; use common::constants::GP_SERVICE_LOCK_FILE; use gpapi::clap::InfoLevelVerbosity; @@ -12,12 +14,15 @@ use gpapi::logger; use gpapi::{ process::gui_launcher::GuiLauncher, service::{request::WsRequest, vpn_state::VpnState}, - utils::{crypto::generate_key, env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal}, + utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal}, }; use log::{info, warn}; use tokio::sync::{mpsc, watch}; +use uuid::Uuid; -use crate::{vpn_task::VpnTask, ws_server::WsServer}; +use crate::{ + request_dispatcher::RequestDispatcher, session_registry::SessionRegistry, vpn_task::VpnTask, ws_server::WsServer, +}; const VERSION: &str = concat!( env!("CARGO_PKG_VERSION"), @@ -36,9 +41,14 @@ struct Cli { #[clap(long)] env_file: Option, #[cfg(debug_assertions)] - #[clap(long)] - no_gui: bool, - + #[clap(long, requires_all = ["dev_uid", "dev_bootstrap_socket"])] + dev_standalone: bool, + #[cfg(debug_assertions)] + #[clap(long, requires = "dev_standalone")] + dev_uid: Option, + #[cfg(debug_assertions)] + #[clap(long, requires = "dev_standalone")] + dev_bootstrap_socket: Option, #[command(flatten)] verbose: InfoLevelVerbosity, } @@ -55,22 +65,25 @@ impl Cli { bail!("Another instance of the service is already running"); } - let api_key = self.prepare_api_key(); - // Channel for sending requests to the VPN task let (ws_req_tx, ws_req_rx) = mpsc::channel::(32); // Channel for receiving the VPN state from the VPN task let (vpn_state_tx, vpn_state_rx) = watch::channel(VpnState::Disconnected); let gui_restart_requested = Arc::new(AtomicBool::new(false)); + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let dispatcher = Arc::new(RequestDispatcher::new( + ws_req_tx.clone(), + Arc::clone(&gui_restart_requested), + Arc::clone(&redaction), + )); let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx); let ws_server = WsServer::new( - api_key.clone(), - ws_req_tx, - Arc::clone(&gui_restart_requested), + env!("CARGO_PKG_VERSION"), + Arc::clone(®istry), + dispatcher, vpn_state_rx, lock_file.clone(), - redaction, ); let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(4); @@ -78,6 +91,25 @@ impl Cli { let vpn_task_cancel_token = vpn_task.cancel_token(); let server_token = ws_server.cancel_token(); + #[cfg(debug_assertions)] + if self.dev_standalone { + let Some(dev_bootstrap_socket) = self.dev_bootstrap_socket.clone() else { + bail!("--dev-bootstrap-socket is required with --dev-standalone"); + }; + let Some(dev_uid) = self.dev_uid else { + bail!("--dev-uid is required with --dev-standalone"); + }; + let bootstrap = crate::dev_bootstrap::DevBootstrap::new(dev_bootstrap_socket, dev_uid, Arc::clone(®istry)); + let bootstrap_token = server_token.clone(); + let bootstrap_shutdown = shutdown_tx.clone(); + tokio::spawn(async move { + if let Err(err) = bootstrap.start(bootstrap_token).await { + warn!("Debug bootstrap stopped: {err}"); + let _ = bootstrap_shutdown.send(()).await; + } + }); + } + #[cfg(unix)] { let vpn_ctx = vpn_task.context(); @@ -87,25 +119,24 @@ impl Cli { } let vpn_task_handle = tokio::spawn(async move { vpn_task.start(server_token).await }); - let ws_server_handle = tokio::spawn(async move { ws_server.start(shutdown_tx_clone).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 no_gui = self.no_gui; - + let launch_managed_gui = !self.dev_standalone; #[cfg(not(debug_assertions))] - let no_gui = false; + let launch_managed_gui = true; - if no_gui { - info!("GUI is disabled"); - } else { + if launch_managed_gui { + 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, api_key, minimized, gui_restart_requested).await; + launch_gui(envs, registry, minimized, gui_restart_requested).await; let _ = shutdown_tx.send(()).await; }); + } else { + info!("Running with a separately started debug GUI"); } tokio::select! { @@ -153,15 +184,6 @@ impl Cli { redaction } - - fn prepare_api_key(&self) -> Vec { - #[cfg(debug_assertions)] - if self.no_gui { - return gpapi::GP_API_KEY.to_vec(); - } - - generate_key().to_vec() - } } #[cfg(unix)] @@ -214,17 +236,26 @@ mod signals { async fn launch_gui( envs: Option>, - api_key: Vec, + registry: Arc, mut minimized: bool, restart_requested: Arc, ) { loop { - let gui_launcher = GuiLauncher::new(env!("CARGO_PKG_VERSION"), &api_key) + let credential = match registry.issue(env!("CARGO_PKG_VERSION")) { + 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()); @@ -235,6 +266,7 @@ async fn launch_gui( minimized = false; } Err(err) => { + registry.revoke(session_id); warn!("Failed to launch GUI: {}", err); break; } diff --git a/apps/gpservice/src/dev_bootstrap.rs b/apps/gpservice/src/dev_bootstrap.rs new file mode 100644 index 0000000..f421782 --- /dev/null +++ b/apps/gpservice/src/dev_bootstrap.rs @@ -0,0 +1,244 @@ +use std::{ + os::unix::fs::{FileTypeExt, MetadataExt, PermissionsExt}, + path::{Path, PathBuf}, + sync::Arc, +}; + +use anyhow::{Context, bail}; +use log::{info, warn}; +use nix::unistd::{Uid, chown}; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + net::{UnixListener, UnixStream}, +}; +use tokio_util::sync::CancellationToken; + +use crate::session_registry::SessionRegistry; + +pub struct DevBootstrap { + path: PathBuf, + allowed_uid: u32, + registry: Arc, +} + +impl DevBootstrap { + pub fn new(path: PathBuf, allowed_uid: u32, registry: Arc) -> Self { + Self { + path, + allowed_uid, + registry, + } + } + + pub async fn start(self, cancel: CancellationToken) -> anyhow::Result<()> { + create_default_parent(&self.path, self.allowed_uid)?; + let path = prepare_socket_path(&self.path, self.allowed_uid)?; + let listener = UnixListener::bind(&path) + .with_context(|| format!("Failed to bind debug bootstrap socket at {}", path.display()))?; + chown(&path, Some(Uid::from_raw(self.allowed_uid)), None)?; + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))?; + info!("Debug credential bootstrap listening at {}", path.display()); + + loop { + tokio::select! { + _ = cancel.cancelled() => break, + accepted = listener.accept() => { + let (stream, _) = accepted?; + let peer_uid = match peer_uid(&stream) { + Ok(uid) => uid, + Err(err) => { + warn!("Could not verify debug credential client UID: {err}"); + continue; + } + }; + if peer_uid != self.allowed_uid { + warn!("Rejected debug credential client with unexpected UID"); + continue; + } + let registry = Arc::clone(&self.registry); + tokio::spawn(async move { + if let Err(err) = authorize_gui(stream, registry).await { + warn!("Debug credential client ended: {err}"); + } + }); + } + } + } + + if path.exists() { + std::fs::remove_file(&path)?; + } + Ok(()) + } +} + +fn create_default_parent(path: &Path, allowed_uid: u32) -> anyhow::Result<()> { + let default = default_socket_path(allowed_uid); + if path != default { + return Ok(()); + } + let parent = path + .parent() + .context("Debug bootstrap socket has no parent directory")?; + std::fs::create_dir_all(parent)?; + std::fs::set_permissions(parent, std::fs::Permissions::from_mode(0o711))?; + Ok(()) +} + +fn default_socket_path(allowed_uid: u32) -> PathBuf { + PathBuf::from(format!("/var/run/gpservice-dev-{allowed_uid}/dev-bootstrap.sock")) +} + +fn prepare_socket_path(path: &Path, allowed_uid: u32) -> anyhow::Result { + let parent = path + .parent() + .context("Debug bootstrap socket has no parent directory")?; + let parent = std::fs::canonicalize(parent) + .with_context(|| format!("Debug bootstrap directory does not exist: {}", parent.display()))?; + let metadata = std::fs::symlink_metadata(&parent)?; + if metadata.file_type().is_symlink() || !metadata.is_dir() { + bail!("Debug bootstrap parent must be a real directory"); + } + if metadata.uid() != 0 || metadata.permissions().mode() & 0o777 != 0o711 { + bail!("Debug bootstrap parent must be owned by root with mode 0711"); + } + + let file_name = path.file_name().context("Debug bootstrap socket has no file name")?; + let path = parent.join(file_name); + + match std::fs::symlink_metadata(&path) { + Ok(metadata) => { + if metadata.file_type().is_symlink() + || !metadata.file_type().is_socket() + || metadata.uid() != allowed_uid + || metadata.permissions().mode() & 0o777 != 0o600 + { + bail!("Refusing unsafe existing debug bootstrap path"); + } + std::fs::remove_file(&path)?; + } + Err(err) if err.kind() == std::io::ErrorKind::NotFound => {} + Err(err) => return Err(err.into()), + } + Ok(path) +} + +async fn authorize_gui(mut stream: UnixStream, registry: Arc) -> anyhow::Result<()> { + let credential = registry.issue(env!("CARGO_PKG_VERSION"))?; + let session_id = credential.session_id(); + let result = async { + let frame = credential.encode_frame()?; + stream.write_all(&frame).await?; + + let mut buffer = [0_u8; 1]; + loop { + match stream.read(&mut buffer).await { + Ok(0) => break, + Ok(_) => continue, + Err(err) => return Err(err.into()), + } + } + Ok(()) + } + .await; + registry.revoke(session_id); + result +} + +#[cfg(target_os = "linux")] +fn peer_uid(stream: &UnixStream) -> anyhow::Result { + use nix::sys::socket::{getsockopt, sockopt}; + + let credentials = getsockopt(stream, sockopt::PeerCredentials)?; + Ok(credentials.uid()) +} + +#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "openbsd"))] +fn peer_uid(stream: &UnixStream) -> anyhow::Result { + let (uid, _) = nix::unistd::getpeereid(stream)?; + Ok(uid.as_raw()) +} + +#[cfg(test)] +mod tests { + use std::os::unix::fs::{PermissionsExt, symlink}; + + use gpapi::service::transport::{MAX_CREDENTIAL_FRAME, SessionCredential}; + use tokio::io::AsyncReadExt; + use uuid::Uuid; + + use super::*; + + #[test] + fn rejects_developer_owned_parent() { + let temp = tempfile::tempdir().unwrap(); + std::fs::set_permissions(temp.path(), std::fs::Permissions::from_mode(0o700)).unwrap(); + let socket = temp.path().join("bootstrap.sock"); + + assert!(prepare_socket_path(&socket, Uid::current().as_raw()).is_err()); + } + + #[test] + fn rejects_symlink_socket_path() { + let temp = tempfile::tempdir().unwrap(); + std::fs::set_permissions(temp.path(), std::fs::Permissions::from_mode(0o700)).unwrap(); + let target = temp.path().join("target"); + std::fs::write(&target, "not a socket").unwrap(); + let socket = temp.path().join("bootstrap.sock"); + symlink(target, &socket).unwrap(); + + assert!(prepare_socket_path(&socket, Uid::current().as_raw()).is_err()); + } + + #[test] + fn custom_parent_is_not_created_by_the_service() { + let temp = tempfile::tempdir().unwrap(); + let parent = temp.path().join("missing"); + let socket = parent.join("bootstrap.sock"); + + create_default_parent(&socket, Uid::current().as_raw()).unwrap(); + + assert!(!parent.exists()); + } + + #[test] + fn default_socket_path_is_stable() { + assert_eq!( + default_socket_path(1234), + PathBuf::from("/var/run/gpservice-dev-1234/dev-bootstrap.sock") + ); + } + + #[tokio::test] + async fn anchor_eof_revokes_issued_credential() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let (service, mut client) = UnixStream::pair().unwrap(); + let task = tokio::spawn(authorize_gui(service, Arc::clone(®istry))); + + let mut header = [0_u8; 2]; + client.read_exact(&mut header).await.unwrap(); + let payload_len = u16::from_be_bytes(header) as usize; + assert!(payload_len + 2 <= MAX_CREDENTIAL_FRAME); + let mut frame = vec![0_u8; payload_len + 2]; + frame[..2].copy_from_slice(&header); + client.read_exact(&mut frame[2..]).await.unwrap(); + let credential = SessionCredential::decode_frame(&frame).unwrap(); + drop(client); + task.await.unwrap().unwrap(); + + assert!(matches!( + registry.begin_handshake( + credential.service_instance_id(), + credential.session_id(), + credential.product_version() + ), + Err(crate::session_registry::SessionError::Unauthorized) + )); + } + + #[tokio::test] + async fn peer_uid_matches_current_process() { + let (stream, _peer) = UnixStream::pair().unwrap(); + assert_eq!(peer_uid(&stream).unwrap(), Uid::current().as_raw()); + } +} diff --git a/apps/gpservice/src/handlers.rs b/apps/gpservice/src/handlers.rs index 9830bbb..403ccec 100644 --- a/apps/gpservice/src/handlers.rs +++ b/apps/gpservice/src/handlers.rs @@ -1,36 +1,12 @@ -use std::{ - fs::{File, Permissions}, - io::BufReader, - ops::ControlFlow, - os::unix::fs::PermissionsExt, - sync::Arc, -}; +use std::sync::Arc; -use anyhow::bail; use axum::{ - body::Bytes, - extract::{ - State, WebSocketUpgrade, - ws::{self, CloseFrame, Message, Utf8Bytes, WebSocket}, - }, - http::StatusCode, + extract::{State, WebSocketUpgrade}, response::IntoResponse, }; -use common::binary_paths; -use futures::{SinkExt, StreamExt}; -use gpapi::{ - service::{ - event::WsEvent, - request::{RestartGuiRequest, UpdateGuiRequest}, - }, - utils::checksum::verify_checksum, -}; -use log::{info, warn}; -use tar::Archive; -use tokio::fs; -use xz2::read::XzDecoder; +use gpapi::service::{event::WsEvent, transport::MAX_WS_MESSAGE}; -use crate::ws_server::WsServerContext; +use crate::{ws_connection::WsConnection, ws_server::WsServerContext}; pub(crate) async fn health() -> impl IntoResponse { "OK" @@ -40,144 +16,8 @@ pub(crate) async fn active_gui(State(ctx): State>) -> impl ctx.send_event(WsEvent::ActiveGui).await; } -pub(crate) async fn restart_gui(State(ctx): State>, body: Bytes) -> Result<(), StatusCode> { - if let Err(err) = ctx.decrypt::(body.to_vec()) { - warn!("Failed to decrypt restart GUI payload: {}", err); - return Err(StatusCode::BAD_REQUEST); - } - - ctx.request_gui_restart(); - - Ok(()) -} - -pub async fn update_gui(State(ctx): State>, body: Bytes) -> Result<(), StatusCode> { - let payload = match ctx.decrypt::(body.to_vec()) { - Ok(payload) => payload, - Err(err) => { - warn!("Failed to decrypt update payload: {}", err); - return Err(StatusCode::BAD_REQUEST); - } - }; - - info!("Update GUI: {:?}", payload); - let UpdateGuiRequest { path, checksum } = payload; - - info!("Verifying checksum"); - verify_checksum(&path, &checksum).map_err(|err| { - warn!("Failed to verify checksum: {}", err); - StatusCode::BAD_REQUEST - })?; - - info!("Installing GUI"); - install_gui(&path).await.map_err(|err| { - warn!("Failed to install GUI: {}", err); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(()) -} - -// Unpack GPGUI archive, gpgui_2.0.0_{arch}.bin.tar.xz and install it -async fn install_gui(src: &str) -> anyhow::Result<()> { - let target = binary_paths::gpgui(); - let Some(dir) = target.parent() else { - bail!("Failed to get parent directory of GUI binary"); - }; - - fs::create_dir_all(dir).await?; - - // Unpack the archive - info!("Unpacking GUI archive"); - let tar = XzDecoder::new(BufReader::new(File::open(src)?)); - let mut ar = Archive::new(tar); - - for entry in ar.entries()? { - let mut entry = entry?; - let entry_path = entry.path()?; - - if let Some(name) = entry_path.file_name() { - let name = name.to_string_lossy(); - - if name == "gpgui" { - let mut file = File::create(&target)?; - std::io::copy(&mut entry, &mut file)?; - break; - } - } - } - - // Make the binary executable - fs::set_permissions(target, Permissions::from_mode(0o755)).await?; - - Ok(()) -} - pub(crate) async fn ws_handler(ws: WebSocketUpgrade, State(ctx): State>) -> impl IntoResponse { - ws.on_upgrade(move |socket| handle_socket(socket, ctx)) -} - -async fn handle_socket(mut socket: WebSocket, ctx: Arc) { - // Send ping message - if let Err(err) = socket.send(Message::Ping("Hi".into())).await { - warn!("Failed to send ping: {}", err); - return; - } - - // Wait for pong message - if socket.recv().await.is_none() { - warn!("Failed to receive pong"); - return; - } - - info!("New client connected"); - - let (mut sender, mut receiver) = socket.split(); - let (connection, mut msg_rx) = ctx.add_connection().await; - - let send_task = tokio::spawn(async move { - while let Some(msg) = msg_rx.recv().await { - if let Err(err) = sender.send(msg).await { - info!("Failed to send message: {}", err); - break; - } - } - - let close_msg = Message::Close(Some(CloseFrame { - code: ws::close_code::NORMAL, - reason: Utf8Bytes::from("Goodbye"), - })); - - if let Err(err) = sender.send(close_msg).await { - warn!("Failed to close socket: {}", err); - } - }); - - let conn = Arc::clone(&connection); - let ctx_clone = Arc::clone(&ctx); - let recv_task = tokio::spawn(async move { - while let Some(Ok(msg)) = receiver.next().await { - let ControlFlow::Continue(ws_req) = conn.recv_msg(msg) else { - break; - }; - - if let Err(err) = ctx_clone.forward_req(ws_req).await { - info!("Failed to forward request: {}", err); - break; - } - } - }); - - tokio::select! { - _ = send_task => { - info!("WS server send task completed"); - }, - _ = recv_task => { - info!("WS server recv task completed"); - } - } - - info!("Client disconnected"); - - ctx.remove_connection(connection).await; + ws.max_message_size(MAX_WS_MESSAGE) + .max_frame_size(MAX_WS_MESSAGE) + .on_upgrade(move |socket| WsConnection::accept(socket, ctx)) } diff --git a/apps/gpservice/src/main.rs b/apps/gpservice/src/main.rs index 88602aa..53ee924 100644 --- a/apps/gpservice/src/main.rs +++ b/apps/gpservice/src/main.rs @@ -1,6 +1,10 @@ mod cli; +#[cfg(debug_assertions)] +mod dev_bootstrap; mod handlers; +mod request_dispatcher; mod routes; +mod session_registry; mod vpn_task; mod ws_connection; mod ws_server; diff --git a/apps/gpservice/src/request_dispatcher.rs b/apps/gpservice/src/request_dispatcher.rs new file mode 100644 index 0000000..d32d7bb --- /dev/null +++ b/apps/gpservice/src/request_dispatcher.rs @@ -0,0 +1,280 @@ +use std::{ + fs::{self, File, OpenOptions, Permissions}, + io::{BufReader, Read, Write}, + os::unix::fs::{OpenOptionsExt, PermissionsExt}, + path::Path, + sync::{Arc, atomic::AtomicBool}, +}; + +use common::binary_paths; +use gpapi::{ + service::{ + request::{UpdateGuiRequest, WsRequest}, + transport::{ServiceErrorCode, ServiceResult}, + }, + utils::{checksum::verify_checksum, redact::Redaction}, +}; +use log::{info, warn}; +use tar::Archive; +use tempfile::NamedTempFile; +use tokio::sync::{Mutex, mpsc}; +use xz2::read::XzDecoder; + +const MAX_GUI_ARCHIVE_SIZE: u64 = 256 * 1024 * 1024; +const MAX_GUI_ARCHIVE_CONTENT_SIZE: u64 = 512 * 1024 * 1024; +const MAX_GUI_BINARY_SIZE: u64 = 256 * 1024 * 1024; + +pub struct RequestDispatcher { + ws_req_tx: mpsc::Sender, + gui_restart_requested: Arc, + redaction: Arc, + install_lock: Mutex<()>, +} + +impl RequestDispatcher { + pub fn new( + ws_req_tx: mpsc::Sender, + gui_restart_requested: Arc, + redaction: Arc, + ) -> Self { + Self { + ws_req_tx, + gui_restart_requested, + redaction, + install_lock: Mutex::new(()), + } + } + + pub async fn dispatch(&self, request: WsRequest) -> ServiceResult { + match request { + WsRequest::RestartGui => { + info!("GUI restart requested"); + self + .gui_restart_requested + .store(true, std::sync::atomic::Ordering::SeqCst); + ServiceResult::Accepted + } + WsRequest::UpdateGui(request) => self.update_gui(request).await, + request => { + if let WsRequest::Connect(ref connect) = request + && let Err(err) = self + .redaction + .add_values(&[connect.gateway().server(), connect.args().cookie()]) + { + warn!("Failed to update log redaction: {err}"); + return ServiceResult::rejected(ServiceErrorCode::Internal, "Request could not be accepted"); + } + + match self.ws_req_tx.try_send(request) { + Ok(()) => ServiceResult::Accepted, + Err(mpsc::error::TrySendError::Full(_)) => { + ServiceResult::rejected(ServiceErrorCode::Busy, "Service request queue is full") + } + Err(mpsc::error::TrySendError::Closed(_)) => { + ServiceResult::rejected(ServiceErrorCode::Internal, "VPN task is unavailable") + } + } + } + } + } + + async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult { + let _install = self.install_lock.lock().await; + let path = request.path; + let checksum = request.checksum; + let installed = tokio::task::spawn_blocking(move || install_gui(&path, &checksum)).await; + match installed { + Ok(Ok(())) => ServiceResult::Accepted, + Ok(Err(GuiInstallError::Checksum(err))) => { + warn!("Failed to verify GUI update checksum: {err}"); + ServiceResult::rejected(ServiceErrorCode::ChecksumFailed, "GUI update checksum failed") + } + Ok(Err(GuiInstallError::Install(err))) => { + warn!("Failed to install GUI update: {err}"); + ServiceResult::rejected(ServiceErrorCode::InstallFailed, "GUI update installation failed") + } + Err(err) => { + warn!("GUI update task failed: {err}"); + ServiceResult::rejected(ServiceErrorCode::InstallFailed, "GUI update installation failed") + } + } + } +} + +#[derive(Debug)] +enum GuiInstallError { + Checksum(anyhow::Error), + Install(anyhow::Error), +} + +fn install_gui(src: &str, checksum: &str) -> Result<(), GuiInstallError> { + let target = binary_paths::gpgui(); + let Some(dir) = target.parent() else { + return Err(GuiInstallError::Install(anyhow::anyhow!( + "Failed to get parent directory of GUI binary" + ))); + }; + fs::create_dir_all(dir).map_err(|err| GuiInstallError::Install(err.into()))?; + + let staged_archive = stage_gui_archive(Path::new(src), dir)?; + let archive_path = staged_archive.path().to_string_lossy(); + verify_checksum(&archive_path, checksum).map_err(GuiInstallError::Checksum)?; + + let tar = XzDecoder::new(BufReader::new( + staged_archive + .reopen() + .map_err(|err| GuiInstallError::Install(err.into()))?, + )) + .take(MAX_GUI_ARCHIVE_CONTENT_SIZE); + let mut archive = Archive::new(tar); + let file = extract_gui_binary(&mut archive, dir)?; + file + .as_file() + .set_permissions(Permissions::from_mode(0o755)) + .map_err(|err| GuiInstallError::Install(err.into()))?; + file + .as_file() + .sync_all() + .map_err(|err| GuiInstallError::Install(err.into()))?; + file + .persist(&target) + .map_err(|err| GuiInstallError::Install(err.into()))?; + File::open(dir) + .and_then(|directory| directory.sync_all()) + .map_err(|err| GuiInstallError::Install(err.into()))?; + Ok(()) +} + +fn stage_gui_archive(src: &Path, dir: &Path) -> Result { + let mut source = OpenOptions::new() + .read(true) + .custom_flags(nix::libc::O_NONBLOCK | nix::libc::O_NOFOLLOW) + .open(src) + .map_err(|err| GuiInstallError::Install(err.into()))?; + let metadata = source.metadata().map_err(|err| GuiInstallError::Install(err.into()))?; + let source_size = metadata.len(); + if !metadata.file_type().is_file() || source_size == 0 || source_size > MAX_GUI_ARCHIVE_SIZE { + return Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI update archive must be a non-empty regular file no larger than {MAX_GUI_ARCHIVE_SIZE} bytes" + ))); + } + + let mut staged = NamedTempFile::new_in(dir).map_err(|err| GuiInstallError::Install(err.into()))?; + let copied = std::io::copy(&mut (&mut source).take(MAX_GUI_ARCHIVE_SIZE + 1), &mut staged) + .map_err(|err| GuiInstallError::Install(err.into()))?; + if copied != source_size { + return Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI update archive changed while it was being read" + ))); + } + staged.flush().map_err(|err| GuiInstallError::Install(err.into()))?; + staged + .as_file() + .sync_all() + .map_err(|err| GuiInstallError::Install(err.into()))?; + Ok(staged) +} + +fn extract_gui_binary(archive: &mut Archive, dir: &Path) -> Result { + for entry in archive.entries().map_err(|err| GuiInstallError::Install(err.into()))? { + let mut entry = entry.map_err(|err| GuiInstallError::Install(err.into()))?; + let is_gui = entry + .path() + .map_err(|err| GuiInstallError::Install(err.into()))? + .file_name() + .is_some_and(|name| name == "gpgui"); + if is_gui && entry.header().entry_type().is_file() { + let declared_size = entry.size(); + if declared_size == 0 || declared_size > MAX_GUI_BINARY_SIZE { + return Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI binary must be non-empty and no larger than {MAX_GUI_BINARY_SIZE} bytes" + ))); + } + let mut file = NamedTempFile::new_in(dir).map_err(|err| GuiInstallError::Install(err.into()))?; + let copied = std::io::copy(&mut entry, &mut file).map_err(|err| GuiInstallError::Install(err.into()))?; + if copied != declared_size { + return Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI binary size does not match its archive header" + ))); + } + file.flush().map_err(|err| GuiInstallError::Install(err.into()))?; + return Ok(file); + } + } + Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI update archive does not contain a non-empty regular gpgui file" + ))) +} + +#[cfg(test)] +mod tests { + use std::io::Cursor; + + use tar::{Builder, EntryType, Header}; + + use super::*; + + fn archive_with_entry(entry_type: EntryType, contents: &[u8]) -> Vec { + let mut data = Vec::new(); + { + let mut builder = Builder::new(&mut data); + let mut header = Header::new_gnu(); + header.set_entry_type(entry_type); + header.set_size(contents.len() as u64); + header.set_mode(0o755); + header.set_cksum(); + builder.append_data(&mut header, "gpgui", contents).unwrap(); + builder.finish().unwrap(); + } + data + } + + #[test] + fn rejects_non_file_and_empty_gui_entries() { + let output = tempfile::tempdir().unwrap(); + for (entry_type, contents) in [(EntryType::Directory, &[][..]), (EntryType::Regular, &[][..])] { + let data = archive_with_entry(entry_type, contents); + let mut archive = Archive::new(Cursor::new(data)); + assert!(extract_gui_binary(&mut archive, output.path()).is_err()); + } + } + + #[test] + fn extracts_non_empty_regular_gui_entry() { + let output = tempfile::tempdir().unwrap(); + let data = archive_with_entry(EntryType::Regular, b"gui binary"); + let mut archive = Archive::new(Cursor::new(data)); + let extracted = extract_gui_binary(&mut archive, output.path()).unwrap(); + let contents = std::fs::read(extracted.path()).unwrap(); + assert_eq!(contents, b"gui binary"); + } + + #[test] + fn rejects_invalid_archive_sources() { + let output = tempfile::tempdir().unwrap(); + assert!(stage_gui_archive(output.path(), output.path()).is_err()); + + let oversized = output.path().join("oversized.tar.xz"); + File::create(&oversized) + .unwrap() + .set_len(MAX_GUI_ARCHIVE_SIZE + 1) + .unwrap(); + assert!(stage_gui_archive(&oversized, output.path()).is_err()); + } + + #[test] + fn rejects_oversized_gui_entry() { + let output = tempfile::tempdir().unwrap(); + let mut header = Header::new_gnu(); + header.set_entry_type(EntryType::Regular); + header.set_size(MAX_GUI_BINARY_SIZE + 1); + header.set_mode(0o755); + header.set_path("gpgui").unwrap(); + header.set_cksum(); + let mut data = header.as_bytes().to_vec(); + data.resize(512 * 3, 0); + + let mut archive = Archive::new(Cursor::new(data)); + assert!(extract_gui_binary(&mut archive, output.path()).is_err()); + } +} diff --git a/apps/gpservice/src/routes.rs b/apps/gpservice/src/routes.rs index cd01833..645f056 100644 --- a/apps/gpservice/src/routes.rs +++ b/apps/gpservice/src/routes.rs @@ -11,8 +11,6 @@ pub(crate) fn routes(ctx: Arc) -> Router { Router::new() .route("/health", get(handlers::health)) .route("/active-gui", post(handlers::active_gui)) - .route("/restart-gui", post(handlers::restart_gui)) - .route("/update-gui", post(handlers::update_gui)) .route("/ws", get(handlers::ws_handler)) .with_state(ctx) } diff --git a/apps/gpservice/src/session_registry.rs b/apps/gpservice/src/session_registry.rs new file mode 100644 index 0000000..4093281 --- /dev/null +++ b/apps/gpservice/src/session_registry.rs @@ -0,0 +1,363 @@ +use std::{ + collections::HashMap, + sync::{Arc, Mutex, Weak}, + time::{Duration, Instant}, +}; + +use gpapi::service::transport::SessionCredential; +use thiserror::Error; +use uuid::Uuid; +use zeroize::Zeroizing; + +use crate::ws_connection::ConnectionControl; + +const ACTIVATION_TIMEOUT: Duration = Duration::from_secs(15); +const MAX_PENDING_SESSIONS: usize = 16; + +pub struct HandshakePermit { + pub session_id: Uuid, + pub observed_generation: u64, + pub secret: Zeroizing<[u8; 32]>, + token: Uuid, + registry: Weak, +} + +pub struct PreparedAttach { + pub generation: u64, +} + +#[derive(Debug, Error)] +pub enum SessionError { + #[error("credential belongs to another service instance")] + ServiceRestarted { service_instance_id: Uuid }, + #[error("session is unauthorized")] + Unauthorized, + #[error("too many pending sessions")] + TooManyPending, + #[error("another reconnect completed first")] + ReconnectSuperseded, + #[error("session registry is unavailable")] + Unavailable, +} + +enum SessionStatus { + Pending { + activation_deadline: Instant, + handshake_token: Option, + }, + Active { + generation: u64, + connection: Option, + reconnect_token: Option, + }, +} + +struct SessionRecord { + secret: Zeroizing<[u8; 32]>, + product_version: String, + status: SessionStatus, +} + +pub struct SessionRegistry { + service_instance_id: Uuid, + sessions: Mutex>, +} + +impl SessionRegistry { + pub fn new(service_instance_id: Uuid) -> Self { + Self { + service_instance_id, + sessions: Mutex::new(HashMap::new()), + } + } + + pub fn issue(&self, product_version: &str) -> Result, SessionError> { + let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?; + let now = Instant::now(); + sessions.retain(|_, record| { + !matches!( + record.status, + SessionStatus::Pending { + activation_deadline, .. + } if now > activation_deadline + ) + }); + let pending = sessions + .values() + .filter(|record| matches!(record.status, SessionStatus::Pending { .. })) + .count(); + if pending >= MAX_PENDING_SESSIONS { + return Err(SessionError::TooManyPending); + } + + let credential = Arc::new( + SessionCredential::generate(self.service_instance_id, product_version).map_err(|_| SessionError::Unavailable)?, + ); + sessions.insert( + credential.session_id(), + SessionRecord { + secret: Zeroizing::new(*credential.secret()), + product_version: credential.product_version().to_owned(), + status: SessionStatus::Pending { + activation_deadline: Instant::now() + ACTIVATION_TIMEOUT, + handshake_token: None, + }, + }, + ); + Ok(credential) + } + + pub fn begin_handshake( + self: &Arc, + service_instance_id: Uuid, + session_id: Uuid, + product_version: &str, + ) -> Result { + if service_instance_id != self.service_instance_id { + return Err(SessionError::ServiceRestarted { + service_instance_id: self.service_instance_id, + }); + } + + let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?; + let Some(record) = sessions.get_mut(&session_id) else { + return Err(SessionError::Unauthorized); + }; + if record.product_version != product_version { + return Err(SessionError::Unauthorized); + } + + let token = Uuid::new_v4(); + let observed_generation = match &mut record.status { + SessionStatus::Pending { + activation_deadline, + handshake_token, + } => { + if Instant::now() > *activation_deadline { + sessions.remove(&session_id); + return Err(SessionError::Unauthorized); + } + if handshake_token.is_some() { + return Err(SessionError::ReconnectSuperseded); + } + *handshake_token = Some(token); + 0 + } + SessionStatus::Active { + generation, + reconnect_token, + .. + } => { + if reconnect_token.is_some() { + return Err(SessionError::ReconnectSuperseded); + } + *reconnect_token = Some(token); + *generation + } + }; + + let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?; + Ok(HandshakePermit { + session_id, + observed_generation, + secret: Zeroizing::new(*record.secret), + token, + registry: Arc::downgrade(self), + }) + } + + pub fn prepare_attach(&self, permit: &HandshakePermit) -> Result { + let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?; + let record = sessions.get(&permit.session_id).ok_or(SessionError::Unauthorized)?; + let generation = match &record.status { + SessionStatus::Pending { handshake_token, .. } + if permit.observed_generation == 0 && *handshake_token == Some(permit.token) => + { + 1 + } + SessionStatus::Active { + generation, + reconnect_token, + .. + } if *generation == permit.observed_generation && *reconnect_token == Some(permit.token) => { + generation.checked_add(1).ok_or(SessionError::Unavailable)? + } + _ => return Err(SessionError::ReconnectSuperseded), + }; + Ok(PreparedAttach { generation }) + } + + pub fn commit_attach( + &self, + permit: &HandshakePermit, + connection: ConnectionControl, + ) -> Result, SessionError> { + let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?; + let record = sessions.get_mut(&permit.session_id).ok_or(SessionError::Unauthorized)?; + + match &mut record.status { + SessionStatus::Pending { handshake_token, .. } + if permit.observed_generation == 0 && *handshake_token == Some(permit.token) => + { + record.status = SessionStatus::Active { + generation: 1, + connection: Some(connection), + reconnect_token: None, + }; + Ok(None) + } + SessionStatus::Active { + generation, + connection: current, + reconnect_token, + } if *generation == permit.observed_generation && *reconnect_token == Some(permit.token) => { + *generation = generation.checked_add(1).ok_or(SessionError::Unavailable)?; + *reconnect_token = None; + Ok(current.replace(connection)) + } + _ => Err(SessionError::ReconnectSuperseded), + } + } + + fn cancel_handshake(&self, session_id: Uuid, observed_generation: u64, token: Uuid) { + let Ok(mut sessions) = self.sessions.lock() else { + return; + }; + let Some(record) = sessions.get_mut(&session_id) else { + return; + }; + match &mut record.status { + SessionStatus::Pending { handshake_token, .. } if observed_generation == 0 && *handshake_token == Some(token) => { + sessions.remove(&session_id); + } + SessionStatus::Active { + generation, + reconnect_token, + .. + } if *generation == observed_generation && *reconnect_token == Some(token) => { + *reconnect_token = None; + } + _ => {} + } + } + + pub fn is_current(&self, session_id: Uuid, generation: u64) -> bool { + let Ok(sessions) = self.sessions.lock() else { + return false; + }; + matches!( + sessions.get(&session_id).map(|record| &record.status), + Some(SessionStatus::Active { generation: current, .. }) if *current == generation + ) + } + + pub fn disconnect_if_current(&self, session_id: Uuid, generation: u64) { + let Ok(mut sessions) = self.sessions.lock() else { + return; + }; + if let Some(SessionRecord { + status: SessionStatus::Active { + generation: current, + connection, + .. + }, + .. + }) = sessions.get_mut(&session_id) + && *current == generation + { + connection.take(); + } + } + + pub fn revoke(&self, session_id: Uuid) { + let connection = self + .sessions + .lock() + .ok() + .and_then(|mut sessions| sessions.remove(&session_id)) + .and_then(|record| match record.status { + SessionStatus::Active { connection, .. } => connection, + SessionStatus::Pending { .. } => None, + }); + if let Some(connection) = connection { + connection.close(gpapi::service::transport::CloseReason::Unauthorized); + } + } +} + +impl Drop for HandshakePermit { + fn drop(&mut self) { + if let Some(registry) = self.registry.upgrade() { + registry.cancel_handshake(self.session_id, self.observed_generation, self.token); + } + } +} + +#[cfg(test)] +mod tests { + use tokio::sync::mpsc; + + use super::*; + use crate::ws_connection::ConnectionCommand; + + fn control() -> ConnectionControl { + let (tx, _rx) = mpsc::channel::(1); + ConnectionControl::new(Uuid::new_v4(), tx).0 + } + + #[test] + fn reconnect_uses_generation_compare_and_swap() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue("2.6.4").unwrap(); + let first = registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .unwrap(); + assert_eq!(registry.prepare_attach(&first).unwrap().generation, 1); + registry.commit_attach(&first, control()).unwrap(); + + let candidate_a = registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .unwrap(); + assert!(matches!( + registry.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4"), + Err(SessionError::ReconnectSuperseded) + )); + assert_eq!(registry.prepare_attach(&candidate_a).unwrap().generation, 2); + registry.commit_attach(&candidate_a, control()).unwrap(); + } + + #[test] + fn failed_initial_handshake_only_revokes_its_own_reservation() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue("2.6.4").unwrap(); + let first = registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .unwrap(); + drop(first); + assert!(matches!( + registry.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4"), + Err(SessionError::Unauthorized) + )); + } + + #[test] + fn failed_reconnect_keeps_active_connection_authoritative() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue("2.6.4").unwrap(); + let first = registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .unwrap(); + registry.commit_attach(&first, control()).unwrap(); + + let reconnect = registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .unwrap(); + drop(reconnect); + assert!(registry.is_current(credential.session_id(), 1)); + assert!( + registry + .begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4") + .is_ok() + ); + } +} diff --git a/apps/gpservice/src/vpn_task.rs b/apps/gpservice/src/vpn_task.rs index 5d16528..cd9fe13 100644 --- a/apps/gpservice/src/vpn_task.rs +++ b/apps/gpservice/src/vpn_task.rs @@ -169,7 +169,7 @@ impl VpnTask { } pub fn context(&self) -> Arc { - return Arc::clone(&self.ctx); + Arc::clone(&self.ctx) } async fn recv(&mut self) { @@ -188,12 +188,15 @@ async fn process_ws_req(req: WsRequest, ctx: Arc) { ctx.disconnect().await; } WsRequest::UpdateLogLevel(UpdateLogLevelRequest(level)) => { - let level = level.parse().unwrap_or_else(|_| log::Level::Info); + let level = level.parse().unwrap_or(log::Level::Info); info!("Updating log level to: {}", level); if let Err(err) = logger::set_max_level(level) { warn!("Failed to update log level: {}", err); } } + WsRequest::RestartGui | WsRequest::UpdateGui(_) => { + warn!("Non-VPN request reached the VPN task"); + } } } diff --git a/apps/gpservice/src/ws_connection.rs b/apps/gpservice/src/ws_connection.rs index e5b3c85..fa6379a 100644 --- a/apps/gpservice/src/ws_connection.rs +++ b/apps/gpservice/src/ws_connection.rs @@ -1,53 +1,524 @@ -use std::{ops::ControlFlow, sync::Arc}; +use std::{collections::HashSet, sync::Arc, time::Duration}; -use axum::extract::ws::{CloseFrame, Message}; -use gpapi::{ - service::{event::WsEvent, request::WsRequest}, - utils::crypto::Crypto, +use axum::extract::ws::{CloseFrame, Message, Utf8Bytes, WebSocket}; +use futures::StreamExt; +use gpapi::service::transport::{ + ClientMessage, ClientPrelude, CloseReason, HandshakeRejection, NoiseResponder, NoiseTransport, ServerMessage, + ServerPrelude, ServiceResult, }; use log::{info, warn}; -use tokio::sync::mpsc; +use tokio::sync::{mpsc, watch}; +use tokio::time::Instant; +use uuid::Uuid; -pub(crate) struct WsConnection { - crypto: Arc, - tx: mpsc::Sender, +use crate::{ + session_registry::{HandshakePermit, SessionError}, + ws_server::WsServerContext, +}; + +const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5); +const WRITE_TIMEOUT: Duration = Duration::from_secs(5); +const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(15); +const PONG_TIMEOUT: Duration = Duration::from_secs(10); +const CONNECTION_QUEUE: usize = 64; +const MAX_PENDING_REQUESTS: usize = 64; + +pub(crate) enum ConnectionCommand { + Send(ServerMessage), + Reply { id: Uuid, result: ServiceResult }, } -impl WsConnection { - pub fn new(crypto: Arc, tx: mpsc::Sender) -> Self { - Self { crypto, tx } - } +#[derive(Clone)] +pub(crate) struct ConnectionControl { + connection_id: Uuid, + tx: mpsc::Sender, + close_tx: watch::Sender>, +} - pub async fn send_event(&self, event: &WsEvent) -> anyhow::Result<()> { - let encrypted = self.crypto.encrypt(event)?; - let msg = Message::Binary(encrypted.into()); - - self.tx.send(msg).await?; - - Ok(()) - } - - pub fn recv_msg(&self, msg: Message) -> ControlFlow<(), WsRequest> { - match msg { - Message::Binary(data) => match self.crypto.decrypt(data.into()) { - Ok(ws_req) => ControlFlow::Continue(ws_req), - Err(err) => { - info!("Failed to decrypt message: {}", err); - ControlFlow::Break(()) - } +impl ConnectionControl { + pub fn new(connection_id: Uuid, tx: mpsc::Sender) -> (Self, watch::Receiver>) { + let (close_tx, close_rx) = watch::channel(None); + ( + Self { + connection_id, + tx, + close_tx, }, - Message::Close(cf) => { - if let Some(CloseFrame { code, reason }) = cf { - info!("Client sent close, code {} and reason `{}`", code, reason); - } else { - info!("Client somehow sent close message without CloseFrame"); + close_rx, + ) + } + + pub fn connection_id(&self) -> Uuid { + self.connection_id + } + + pub fn send(&self, command: ConnectionCommand) -> Result<(), ()> { + self.tx.try_send(command).map_err(|_| ()) + } + + pub fn is_closed(&self) -> bool { + self.tx.is_closed() + } + + pub fn close(&self, reason: CloseReason) { + let _ = self.close_tx.send(Some(reason)); + } + + pub async fn send_reply(&self, id: Uuid, result: ServiceResult) { + let _ = self.tx.send(ConnectionCommand::Reply { id, result }).await; + } +} + +pub(crate) struct WsConnection; + +impl WsConnection { + pub async fn accept(mut socket: WebSocket, ctx: Arc) { + let Some(slot) = ctx.try_handshake_slot() else { + send_close(&mut socket, CloseReason::InternalError).await; + return; + }; + + let established = tokio::time::timeout(HANDSHAKE_TIMEOUT, establish(&mut socket, &ctx)).await; + let (mut noise, permit, control, mut command_rx, mut close_rx, generation) = match established { + Ok(Ok(established)) => established, + Ok(Err(reason)) => { + send_close(&mut socket, reason).await; + return; + } + Err(_) => { + ctx.remove_closed_connections().await; + send_close(&mut socket, CloseReason::HandshakeTimeout).await; + return; + } + }; + drop(slot); + + info!("Authenticated GUI connection {}", control.connection_id()); + let mut pending_requests = HashSet::new(); + let mut heartbeat = tokio::time::interval(Duration::from_secs(1)); + let mut last_outbound = Instant::now(); + let mut pong_deadline = None; + + loop { + tokio::select! { + command = command_rx.recv() => { + let Some(command) = command else { break }; + match command { + ConnectionCommand::Send(message) => { + if send_encrypted(&mut socket, &mut noise, &message).await.is_err() { + break; + } + last_outbound = Instant::now(); + } + ConnectionCommand::Reply { id, result } => { + if !pending_requests.remove(&id) { + send_close(&mut socket, CloseReason::MalformedMessage).await; + break; + } + let message = ServerMessage::Reply { id, result }; + if send_encrypted(&mut socket, &mut noise, &message).await.is_err() { + break; + } + last_outbound = Instant::now(); + } + } + } + changed = close_rx.changed() => { + if changed.is_err() { break; } + let reason = *close_rx.borrow_and_update(); + if let Some(reason) = reason { + send_close(&mut socket, reason).await; + break; + } + } + frame = socket.next() => { + let Some(frame) = frame else { break }; + match frame { + Ok(Message::Binary(data)) => { + let message = match noise.decrypt::(&data) { + Ok(message) => message, + Err(err) => { + warn!("Failed to authenticate WS message: {err}"); + send_close(&mut socket, CloseReason::AuthenticationFailed).await; + break; + } + }; + if handle_client_message( + message, + &ctx, + &control, + permit.session_id, + generation, + &mut pending_requests, + ).await.is_err() { + send_close(&mut socket, CloseReason::MalformedMessage).await; + break; + } + } + Ok(Message::Ping(data)) => { + if send_frame(&mut socket, Message::Pong(data)).await.is_err() { break; } + last_outbound = Instant::now(); + } + Ok(Message::Pong(_)) => pong_deadline = None, + Ok(Message::Close(_)) | Err(_) => break, + Ok(_) => { + send_close(&mut socket, CloseReason::MalformedMessage).await; + break; + } + } + } + _ = heartbeat.tick() => { + let now = Instant::now(); + if pong_deadline.is_some_and(|deadline| now >= deadline) { + send_close(&mut socket, CloseReason::HeartbeatTimeout).await; + break; + } + if pong_deadline.is_none() && now.duration_since(last_outbound) >= HEARTBEAT_INTERVAL { + if send_frame(&mut socket, Message::Ping(Vec::new().into())).await.is_err() { break; } + last_outbound = now; + pong_deadline = Some(now + PONG_TIMEOUT); + } } - ControlFlow::Break(()) } - _ => { - warn!("WS server received unexpected message: {:?}", msg); - ControlFlow::Break(()) + } + + ctx + .remove_connection(control.connection_id(), permit.session_id, generation) + .await; + info!("GUI connection {} closed", control.connection_id()); + } +} + +async fn establish( + socket: &mut WebSocket, + ctx: &Arc, +) -> Result< + ( + NoiseTransport, + HandshakePermit, + ConnectionControl, + mpsc::Receiver, + watch::Receiver>, + u64, + ), + CloseReason, +> { + let prelude = receive_prelude(socket).await?; + if prelude.product_version != ctx.product_version() { + send_server_prelude( + socket, + ServerPrelude::Rejected(HandshakeRejection::VersionMismatch { + client: prelude.product_version, + service: ctx.product_version().to_owned(), + }), + ) + .await?; + return Err(CloseReason::VersionMismatch); + } + + let permit = match ctx.registry().begin_handshake( + prelude.service_instance_id, + prelude.session_id, + &prelude.product_version, + ) { + Ok(permit) => permit, + Err(SessionError::ServiceRestarted { service_instance_id }) => { + send_server_prelude( + socket, + ServerPrelude::Rejected(HandshakeRejection::ServiceRestarted { service_instance_id }), + ) + .await?; + return Err(CloseReason::ServiceRestarted); + } + Err(SessionError::ReconnectSuperseded) => { + send_server_prelude(socket, ServerPrelude::Rejected(HandshakeRejection::ReconnectSuperseded)).await?; + return Err(CloseReason::ReconnectSuperseded); + } + Err(_) => { + send_server_prelude(socket, ServerPrelude::Rejected(HandshakeRejection::Unauthorized)).await?; + return Err(CloseReason::Unauthorized); + } + }; + + send_server_prelude(socket, ServerPrelude::Ready).await?; + let handshake = async { + let mut responder = NoiseResponder::new( + ctx.product_version(), + prelude.service_instance_id, + prelude.session_id, + &permit.secret, + ) + .map_err(|_| CloseReason::HandshakeFailed)?; + let first = receive_binary(socket).await?; + responder.read_first(&first).map_err(|_| CloseReason::HandshakeFailed)?; + let (response, mut noise) = responder.write_response().map_err(|_| CloseReason::HandshakeFailed)?; + socket + .send(Message::Binary(response.into())) + .await + .map_err(|_| CloseReason::HandshakeFailed)?; + + let attach = receive_binary(socket).await?; + match noise + .decrypt::(&attach) + .map_err(|_| CloseReason::AuthenticationFailed)? + { + ClientMessage::Attach { .. } => {} + _ => return Err(CloseReason::MalformedMessage), + } + + let (tx, mut rx) = mpsc::channel(CONNECTION_QUEUE); + let (control, close_rx) = ConnectionControl::new(Uuid::new_v4(), tx); + let prepared = ctx + .prepare_connection(&permit, control.clone()) + .await + .map_err(|err| match err { + SessionError::ReconnectSuperseded => CloseReason::ReconnectSuperseded, + SessionError::Unauthorized => CloseReason::Unauthorized, + _ => CloseReason::InternalError, + })?; + + let Some(ConnectionCommand::Send(attached @ ServerMessage::Attached { .. })) = rx.recv().await else { + ctx.abandon_connection(control.connection_id()).await; + return Err(CloseReason::InternalError); + }; + if send_encrypted(socket, &mut noise, &attached).await.is_err() { + ctx.abandon_connection(control.connection_id()).await; + return Err(CloseReason::InternalError); + } + let replaced = ctx + .commit_connection(&permit, &control) + .await + .map_err(|err| match err { + SessionError::ReconnectSuperseded => CloseReason::ReconnectSuperseded, + SessionError::Unauthorized => CloseReason::Unauthorized, + _ => CloseReason::InternalError, + })?; + if let Some(replaced) = replaced { + replaced.close(CloseReason::SessionReplaced); + } + Ok((noise, control, rx, close_rx, prepared.generation)) + } + .await; + + handshake.map(|(noise, control, rx, close_rx, generation)| (noise, permit, control, rx, close_rx, generation)) +} + +async fn handle_client_message( + message: ClientMessage, + ctx: &Arc, + control: &ConnectionControl, + session_id: Uuid, + generation: u64, + pending_requests: &mut HashSet, +) -> Result<(), ()> { + match message { + ClientMessage::Attach { .. } => Err(()), + ClientMessage::Resync { .. } => ctx.send_snapshot(control).await, + ClientMessage::Request { id, request } => { + if pending_requests.len() >= MAX_PENDING_REQUESTS || !pending_requests.insert(id) { + return Err(()); } + if !ctx.registry().is_current(session_id, generation) { + pending_requests.remove(&id); + return Err(()); + } + + let dispatcher = ctx.dispatcher(); + let control = control.clone(); + tokio::spawn(async move { + let result = dispatcher.dispatch(request).await; + control.send_reply(id, result).await; + }); + Ok(()) + } + } +} + +async fn receive_prelude(socket: &mut WebSocket) -> Result { + let data = receive_binary(socket).await?; + ClientPrelude::decode(&data).map_err(|_| CloseReason::MalformedMessage) +} + +async fn receive_binary(socket: &mut WebSocket) -> Result, CloseReason> { + match socket.next().await { + Some(Ok(Message::Binary(data))) => Ok(data.to_vec()), + Some(Ok(_)) => Err(CloseReason::MalformedMessage), + Some(Err(_)) | None => Err(CloseReason::HandshakeFailed), + } +} + +async fn send_server_prelude(socket: &mut WebSocket, prelude: ServerPrelude) -> Result<(), CloseReason> { + let data = prelude.encode().map_err(|_| CloseReason::InternalError)?; + socket + .send(Message::Binary(data.into())) + .await + .map_err(|_| CloseReason::HandshakeFailed) +} + +async fn send_encrypted( + socket: &mut WebSocket, + noise: &mut NoiseTransport, + message: &ServerMessage, +) -> anyhow::Result<()> { + let encrypted = noise.encrypt(message)?; + send_frame(socket, Message::Binary(encrypted.into())).await?; + Ok(()) +} + +async fn send_frame(socket: &mut WebSocket, frame: Message) -> anyhow::Result<()> { + tokio::time::timeout(WRITE_TIMEOUT, socket.send(frame)) + .await + .map_err(|_| anyhow::anyhow!("WebSocket write timed out"))??; + Ok(()) +} + +async fn send_close(socket: &mut WebSocket, reason: CloseReason) { + let _ = send_frame( + socket, + Message::Close(Some(CloseFrame { + code: reason.code(), + reason: Utf8Bytes::from_static(reason.reason()), + })), + ) + .await; +} + +#[cfg(test)] +mod tests { + use std::sync::{Arc, atomic::AtomicBool}; + + use futures::{SinkExt, StreamExt}; + use gpapi::{ + service::{ + request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest}, + transport::{ClientMessage, ClientPrelude, NoiseInitiator, ServerMessage, ServerPrelude, ServiceResult}, + vpn_state::VpnState, + }, + utils::redact::Redaction, + }; + use tokio::sync::{mpsc, watch}; + use tokio_tungstenite::{connect_async, tungstenite::Message as ClientFrame}; + + use super::*; + use crate::{ + request_dispatcher::RequestDispatcher, routes, session_registry::SessionRegistry, ws_server::WsServerContext, + }; + + #[tokio::test] + async fn authenticates_attaches_and_replies_to_a_request() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap(); + let (request_tx, mut request_rx) = mpsc::channel(4); + let dispatcher = Arc::new(RequestDispatcher::new( + request_tx, + Arc::new(AtomicBool::new(false)), + Arc::new(Redaction::new()), + )); + let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected); + let context = Arc::new(WsServerContext::new( + env!("CARGO_PKG_VERSION"), + Arc::clone(®istry), + dispatcher, + &state_rx, + )); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + let server = tokio::spawn(async move { + axum::serve(listener, routes::routes(context)).await.unwrap(); + }); + + let (mut socket, _) = connect_async(format!("ws://{address}/ws")).await.unwrap(); + let prelude = ClientPrelude { + product_version: env!("CARGO_PKG_VERSION").to_owned(), + service_instance_id: credential.service_instance_id(), + session_id: credential.session_id(), + }; + socket + .send(ClientFrame::Binary(prelude.encode().unwrap().into())) + .await + .unwrap(); + let ready = receive_client_binary(&mut socket).await; + assert_eq!(ServerPrelude::decode(&ready).unwrap(), ServerPrelude::Ready); + + let mut initiator = NoiseInitiator::new( + env!("CARGO_PKG_VERSION"), + credential.service_instance_id(), + credential.session_id(), + credential.secret(), + ) + .unwrap(); + socket + .send(ClientFrame::Binary(initiator.write_first().unwrap().into())) + .await + .unwrap(); + let response = receive_client_binary(&mut socket).await; + let mut noise = initiator.read_response(&response).unwrap(); + let attach = noise + .encrypt(&ClientMessage::Attach { + last_event_revision: None, + }) + .unwrap(); + socket.send(ClientFrame::Binary(attach.into())).await.unwrap(); + let attached = noise + .decrypt::(&receive_client_binary(&mut socket).await) + .unwrap(); + assert!(matches!(attached, ServerMessage::Attached { .. })); + + let request_id = Uuid::new_v4(); + let request = ClientMessage::Request { + id: request_id, + request: WsRequest::UpdateLogLevel(UpdateLogLevelRequest("info".to_owned())), + }; + socket + .send(ClientFrame::Binary(noise.encrypt(&request).unwrap().into())) + .await + .unwrap(); + assert!(matches!(request_rx.recv().await, Some(WsRequest::UpdateLogLevel(_)))); + let reply = noise + .decrypt::(&receive_client_binary(&mut socket).await) + .unwrap(); + assert!(matches!( + reply, + ServerMessage::Reply { + id, + result: ServiceResult::Accepted, + } if id == request_id + )); + + let update_id = Uuid::new_v4(); + let update_file = tempfile::NamedTempFile::new().unwrap(); + std::fs::write(update_file.path(), b"invalid archive").unwrap(); + let update = ClientMessage::Request { + id: update_id, + request: WsRequest::UpdateGui(UpdateGuiRequest { + path: update_file.path().to_string_lossy().into_owned(), + checksum: "invalid".to_owned(), + }), + }; + socket + .send(ClientFrame::Binary(noise.encrypt(&update).unwrap().into())) + .await + .unwrap(); + let reply = noise + .decrypt::(&receive_client_binary(&mut socket).await) + .unwrap(); + assert!(matches!( + reply, + ServerMessage::Reply { + id, + result: ServiceResult::Rejected(ref rejection), + } if id == update_id && rejection.code() == gpapi::service::transport::ServiceErrorCode::ChecksumFailed + )); + + server.abort(); + } + + async fn receive_client_binary( + socket: &mut tokio_tungstenite::WebSocketStream>, + ) -> Vec { + match socket.next().await.unwrap().unwrap() { + ClientFrame::Binary(data) => data.to_vec(), + frame => panic!("unexpected frame: {frame:?}"), } } } diff --git a/apps/gpservice/src/ws_server.rs b/apps/gpservice/src/ws_server.rs index 6826166..7da9b47 100644 --- a/apps/gpservice/src/ws_server.rs +++ b/apps/gpservice/src/ws_server.rs @@ -1,121 +1,185 @@ -use std::sync::{ - Arc, - atomic::{AtomicBool, Ordering}, -}; +use std::{collections::HashMap, sync::Arc}; -use axum::extract::ws::Message; use common::binary_paths; use gpapi::{ os_profile::HostIdentity, service::{ event::WsEvent, - request::WsRequest, + transport::{CloseReason, ServerMessage}, vpn_env::{HostInfo, VpnEnv}, vpn_state::VpnState, }, - utils::{crypto::Crypto, lock_file::LockFile, redact::Redaction}, + utils::lock_file::LockFile, }; use log::{info, warn}; use openconnect::{find_csd_wrapper, find_vpnc_script}; -use serde::de::DeserializeOwned; use tokio::{ net::TcpListener, - sync::{RwLock, mpsc, watch}, + sync::{Mutex, Semaphore, mpsc, oneshot, watch}, }; use tokio_util::sync::CancellationToken; +use uuid::Uuid; -use crate::{routes, ws_connection::WsConnection}; +use crate::{ + request_dispatcher::RequestDispatcher, + routes, + session_registry::{HandshakePermit, PreparedAttach, SessionError, SessionRegistry}, + ws_connection::{ConnectionCommand, ConnectionControl}, +}; + +struct ServiceState { + revision: u64, + snapshot: VpnEnv, + connections: HashMap, +} pub(crate) struct WsServerContext { - crypto: Arc, - ws_req_tx: mpsc::Sender, - gui_restart_requested: Arc, - vpn_state_rx: watch::Receiver, - redaction: Arc, - connections: RwLock>>, + product_version: &'static str, + registry: Arc, + dispatcher: Arc, + state: Mutex, + handshake_slots: Arc, } impl WsServerContext { pub fn new( - api_key: Vec, - ws_req_tx: mpsc::Sender, - gui_restart_requested: Arc, - vpn_state_rx: watch::Receiver, - redaction: Arc, + product_version: &'static str, + registry: Arc, + dispatcher: Arc, + vpn_state_rx: &watch::Receiver, ) -> Self { Self { - crypto: Arc::new(Crypto::new(api_key)), - ws_req_tx, - gui_restart_requested, - vpn_state_rx, - redaction, - connections: Default::default(), + product_version, + registry, + dispatcher, + state: Mutex::new(ServiceState { + revision: 0, + snapshot: build_snapshot(vpn_state_rx.borrow().clone()), + connections: HashMap::new(), + }), + handshake_slots: Arc::new(Semaphore::new(16)), } } - pub fn decrypt(&self, encrypted: Vec) -> anyhow::Result { - self.crypto.decrypt(encrypted) + pub fn product_version(&self) -> &'static str { + self.product_version + } + + pub fn registry(&self) -> &Arc { + &self.registry + } + + pub fn dispatcher(&self) -> Arc { + Arc::clone(&self.dispatcher) + } + + pub fn try_handshake_slot(&self) -> Option { + Arc::clone(&self.handshake_slots).try_acquire_owned().ok() + } + + pub async fn prepare_connection( + &self, + permit: &HandshakePermit, + control: ConnectionControl, + ) -> Result { + let mut state = self.state.lock().await; + let prepared = self.registry.prepare_attach(permit)?; + + control + .send(ConnectionCommand::Send(ServerMessage::Attached { + connection_id: control.connection_id(), + current_revision: state.revision, + snapshot: state.snapshot.clone(), + })) + .map_err(|_| SessionError::Unavailable)?; + state.connections.insert(control.connection_id(), control); + Ok(prepared) + } + + pub async fn commit_connection( + &self, + permit: &HandshakePermit, + connection: &ConnectionControl, + ) -> Result, SessionError> { + let mut state = self.state.lock().await; + if !state + .connections + .get(&connection.connection_id()) + .is_some_and(|candidate| !candidate.is_closed()) + { + return Err(SessionError::Unavailable); + } + match self.registry.commit_attach(permit, connection.clone()) { + Ok(replaced) => { + if let Some(replaced) = &replaced { + state.connections.remove(&replaced.connection_id()); + } + Ok(replaced) + } + Err(err) => { + state.connections.remove(&connection.connection_id()); + Err(err) + } + } + } + + pub async fn abandon_connection(&self, connection_id: Uuid) { + self.state.lock().await.connections.remove(&connection_id); + } + + pub async fn remove_closed_connections(&self) { + self + .state + .lock() + .await + .connections + .retain(|_, connection| !connection.is_closed()); + } + + pub async fn send_snapshot(&self, control: &ConnectionControl) -> Result<(), ()> { + let state = self.state.lock().await; + control.send(ConnectionCommand::Send(ServerMessage::Snapshot { + current_revision: state.revision, + snapshot: state.snapshot.clone(), + })) + } + + pub async fn remove_connection(&self, connection_id: Uuid, session_id: Uuid, generation: u64) { + self.state.lock().await.connections.remove(&connection_id); + self.registry.disconnect_if_current(session_id, generation); } pub async fn send_event(&self, event: WsEvent) { - let connections = self.connections.read().await; - - for conn in connections.iter() { - let _ = conn.send_event(&event).await; + let mut state = self.state.lock().await; + if let WsEvent::VpnEnv(env) = &event { + state.snapshot = env.clone(); + } else if let WsEvent::VpnState(vpn_state) = &event { + state.snapshot.vpn_state = vpn_state.clone(); } - } - pub async fn add_connection(&self) -> (Arc, mpsc::Receiver) { - let (tx, rx) = mpsc::channel::(32); - let conn = Arc::new(WsConnection::new(Arc::clone(&self.crypto), tx)); - - // Send current VPN state to new client - info!("Sending current environment to new client"); - let host_info = HostInfo { - host_identity: HostIdentity::collect(), + let Some(revision) = state.revision.checked_add(1) else { + for connection in state.connections.values() { + connection.close(CloseReason::InternalError); + } + state.connections.clear(); + return; }; + state.revision = revision; - let vpn_env = VpnEnv { - vpn_state: self.vpn_state_rx.borrow().clone(), - vpnc_script: find_vpnc_script().map(|s| s.to_owned()), - csd_wrapper: find_csd_wrapper().map(|s| s.to_owned()), - auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(), - host_info, - }; - - if let Err(err) = conn.send_event(&WsEvent::VpnEnv(vpn_env)).await { - warn!("Failed to send VPN state to new client: {}", err); - } - - self.connections.write().await.push(Arc::clone(&conn)); - - (conn, rx) - } - - pub async fn remove_connection(&self, conn: Arc) { - let mut connections = self.connections.write().await; - connections.retain(|c| !Arc::ptr_eq(c, &conn)); - } - - fn vpn_state_rx(&self) -> watch::Receiver { - self.vpn_state_rx.clone() - } - - pub async fn forward_req(&self, req: WsRequest) -> anyhow::Result<()> { - if let WsRequest::Connect(ref req) = req { - self - .redaction - .add_values(&[req.gateway().server(), req.args().cookie()])? - } - - self.ws_req_tx.send(req).await?; - - Ok(()) - } - - pub fn request_gui_restart(&self) { - info!("GUI restart requested"); - self.gui_restart_requested.store(true, Ordering::SeqCst); + state.connections.retain(|_, connection| { + if connection + .send(ConnectionCommand::Send(ServerMessage::Event { + revision, + event: event.clone(), + })) + .is_ok() + { + true + } else { + connection.close(CloseReason::InternalError); + false + } + }); } } @@ -123,30 +187,27 @@ pub(crate) struct WsServer { ctx: Arc, cancel_token: CancellationToken, lock_file: Arc, + vpn_state_rx: watch::Receiver, } impl WsServer { pub fn new( - api_key: Vec, - ws_req_tx: mpsc::Sender, - gui_restart_requested: Arc, + product_version: &'static str, + registry: Arc, + dispatcher: Arc, vpn_state_rx: watch::Receiver, lock_file: Arc, - redaction: Arc, ) -> Self { - let ctx = Arc::new(WsServerContext::new( - api_key, - ws_req_tx, - gui_restart_requested, - vpn_state_rx, - redaction, - )); - let cancel_token = CancellationToken::new(); - Self { - ctx, - cancel_token, + ctx: Arc::new(WsServerContext::new( + product_version, + registry, + dispatcher, + &vpn_state_rx, + )), + cancel_token: CancellationToken::new(), lock_file, + vpn_state_rx, } } @@ -158,55 +219,173 @@ impl WsServer { self.cancel_token.clone() } - pub async fn start(&self, shutdown_tx: mpsc::Sender<()>) { + pub async fn start(&self, shutdown_tx: mpsc::Sender<()>, ready_tx: oneshot::Sender<()>) { let listener = match self.start_tcp_server().await { Ok(listener) => listener, Err(err) => { - warn!("Failed to start WS server: {}", err); + warn!("Failed to start WS server: {err}"); let _ = shutdown_tx.send(()).await; return; } }; + let _ = ready_tx.send(()); tokio::select! { - _ = watch_vpn_state(self.ctx.vpn_state_rx(), Arc::clone(&self.ctx)) => { + _ = watch_vpn_state(self.vpn_state_rx.clone(), Arc::clone(&self.ctx)) => { info!("VPN state watch task completed"); } - _ = start_server(listener, self.ctx.clone()) => { - info!("WS server stopped"); + result = axum::serve(listener, routes::routes(Arc::clone(&self.ctx))) => { + if let Err(err) = result { + warn!("WS server stopped: {err}"); + } } _ = self.cancel_token.cancelled() => { info!("WS server cancelled"); } } - let _ = shutdown_tx.send(()).await; } async fn start_tcp_server(&self) -> anyhow::Result { let listener = TcpListener::bind("127.0.0.1:0").await?; - let local_addr = listener.local_addr()?; - let port = local_addr.port(); - - info!("WS server listening on port: {}", port); - + let port = listener.local_addr()?.port(); + info!("WS server listening on port: {port}"); self.lock_file.lock(&port.to_string())?; - Ok(listener) } } +fn build_snapshot(vpn_state: VpnState) -> VpnEnv { + VpnEnv { + vpn_state, + vpnc_script: find_vpnc_script().map(ToOwned::to_owned), + csd_wrapper: find_csd_wrapper().map(ToOwned::to_owned), + auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(), + host_info: HostInfo { + host_identity: HostIdentity::collect(), + }, + } +} + +#[cfg(test)] +mod tests { + use std::sync::{Arc, atomic::AtomicBool}; + + use gpapi::{ + service::{event::WsEvent, transport::ServerMessage}, + utils::redact::Redaction, + }; + use tokio::sync::{mpsc, watch}; + + use super::*; + + #[tokio::test] + async fn resync_snapshot_is_ordered_with_state_events() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap(); + let permit = registry + .begin_handshake( + credential.service_instance_id(), + credential.session_id(), + credential.product_version(), + ) + .unwrap(); + let (request_tx, _request_rx) = mpsc::channel(1); + let dispatcher = Arc::new(RequestDispatcher::new( + request_tx, + Arc::new(AtomicBool::new(false)), + Arc::new(Redaction::new()), + )); + let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected); + let context = Arc::new(WsServerContext::new( + env!("CARGO_PKG_VERSION"), + registry, + dispatcher, + &state_rx, + )); + let (tx, mut rx) = mpsc::channel(8); + let (control, _close_rx) = ConnectionControl::new(Uuid::new_v4(), tx); + context.prepare_connection(&permit, control.clone()).await.unwrap(); + assert!(matches!( + rx.recv().await, + Some(ConnectionCommand::Send(ServerMessage::Attached { .. })) + )); + + let (snapshot_result, ()) = tokio::join!( + context.send_snapshot(&control), + context.send_event(WsEvent::VpnState(VpnState::Disconnected)), + ); + snapshot_result.unwrap(); + let first = rx.recv().await.unwrap(); + let second = rx.recv().await.unwrap(); + match (first, second) { + ( + ConnectionCommand::Send(ServerMessage::Snapshot { + current_revision: 0, .. + }), + ConnectionCommand::Send(ServerMessage::Event { revision: 1, .. }), + ) + | ( + ConnectionCommand::Send(ServerMessage::Event { revision: 1, .. }), + ConnectionCommand::Send(ServerMessage::Snapshot { + current_revision: 1, .. + }), + ) => {} + _ => panic!("snapshot and event were not atomically ordered"), + } + } + + #[tokio::test] + async fn removed_prepared_candidate_cannot_commit_takeover() { + let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); + let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap(); + let (request_tx, _request_rx) = mpsc::channel(1); + let dispatcher = Arc::new(RequestDispatcher::new( + request_tx, + Arc::new(AtomicBool::new(false)), + Arc::new(Redaction::new()), + )); + let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected); + let context = Arc::new(WsServerContext::new( + env!("CARGO_PKG_VERSION"), + Arc::clone(®istry), + dispatcher, + &state_rx, + )); + + let first = registry + .begin_handshake( + credential.service_instance_id(), + credential.session_id(), + credential.product_version(), + ) + .unwrap(); + let (first_tx, mut first_rx) = mpsc::channel(4); + let (first_control, _first_close) = ConnectionControl::new(Uuid::new_v4(), first_tx); + context.prepare_connection(&first, first_control.clone()).await.unwrap(); + first_rx.recv().await.unwrap(); + context.commit_connection(&first, &first_control).await.unwrap(); + + let reconnect = registry + .begin_handshake( + credential.service_instance_id(), + credential.session_id(), + credential.product_version(), + ) + .unwrap(); + let (candidate_tx, _candidate_rx) = mpsc::channel(1); + let (candidate, _candidate_close) = ConnectionControl::new(Uuid::new_v4(), candidate_tx); + context.prepare_connection(&reconnect, candidate.clone()).await.unwrap(); + context.send_event(WsEvent::VpnState(VpnState::Disconnected)).await; + + assert!(context.commit_connection(&reconnect, &candidate).await.is_err()); + assert!(registry.is_current(credential.session_id(), 1)); + } +} + async fn watch_vpn_state(mut vpn_state_rx: watch::Receiver, ctx: Arc) { while vpn_state_rx.changed().await.is_ok() { let vpn_state = vpn_state_rx.borrow().clone(); ctx.send_event(WsEvent::VpnState(vpn_state)).await; } } - -async fn start_server(listener: TcpListener, ctx: Arc) -> anyhow::Result<()> { - let routes = routes::routes(ctx); - - axum::serve(listener, routes).await?; - - Ok(()) -} diff --git a/crates/gpapi/Cargo.toml b/crates/gpapi/Cargo.toml index 6131f12..1debd36 100644 --- a/crates/gpapi/Cargo.toml +++ b/crates/gpapi/Cargo.toml @@ -32,11 +32,14 @@ uzers.workspace = true serde_urlencoded.workspace = true md5.workspace = true sha256.workspace = true -uuid = { workspace = true, features = ["v5"] } +uuid = { workspace = true, features = ["v4", "v5", "serde"] } chrono.workspace = true humantime.workspace = true netdev.workspace = true os_info = { version = "3", default-features = false } +snow.workspace = true +zeroize = { workspace = true, features = ["serde"] } +getrandom = "0.4" # Optional dependencies for features tauri = { workspace = true, optional = true } diff --git a/crates/gpapi/src/lib.rs b/crates/gpapi/src/lib.rs index c953202..044cd89 100644 --- a/crates/gpapi/src/lib.rs +++ b/crates/gpapi/src/lib.rs @@ -17,6 +17,3 @@ pub mod logger; #[cfg(feature = "clap")] pub mod clap; - -#[cfg(debug_assertions)] -pub const GP_API_KEY: &[u8; 32] = &[0; 32]; diff --git a/crates/gpapi/src/process/gui_helper_launcher.rs b/crates/gpapi/src/process/gui_helper_launcher.rs index d59c173..8bdbf6b 100644 --- a/crates/gpapi/src/process/gui_helper_launcher.rs +++ b/crates/gpapi/src/process/gui_helper_launcher.rs @@ -5,21 +5,21 @@ use common::binary_paths; use log::info; use tokio::{io::AsyncWriteExt, process::Command}; -use crate::{process::command_traits::CommandExt, utils}; +use crate::{process::command_traits::CommandExt, service::transport::SessionCredential}; pub struct GuiHelperLauncher<'a> { program: PathBuf, envs: Option<&'a HashMap>, - api_key: &'a [u8], + credential: &'a SessionCredential, gui_version: Option<&'a str>, } impl<'a> GuiHelperLauncher<'a> { - pub fn new(api_key: &'a [u8]) -> Self { + pub fn new(credential: &'a SessionCredential) -> Self { Self { program: binary_paths::gpgui_helper(), envs: None, - api_key, + credential, gui_version: None, } } @@ -42,7 +42,7 @@ impl<'a> GuiHelperLauncher<'a> { cmd.envs(envs); } - cmd.arg("--api-key-on-stdin"); + cmd.arg("--service-credential-on-stdin"); if let Some(gui_version) = self.gui_version { cmd.arg("--gui-version").arg(gui_version); @@ -60,13 +60,11 @@ impl<'a> GuiHelperLauncher<'a> { bail!("Failed to open stdin"); }; - let api_key = utils::base64::encode(self.api_key); - tokio::spawn(async move { - stdin.write_all(api_key.as_bytes()).await.unwrap(); - drop(stdin); - }); + let frame = self.credential.encode_frame()?; + stdin.write_all(&frame).await?; let exit_status = child.wait().await?; + drop(stdin); info!("gpgui-helper exited with: {}", exit_status); Ok(()) diff --git a/crates/gpapi/src/process/gui_launcher.rs b/crates/gpapi/src/process/gui_launcher.rs index 4db52f2..735c422 100644 --- a/crates/gpapi/src/process/gui_launcher.rs +++ b/crates/gpapi/src/process/gui_launcher.rs @@ -2,6 +2,7 @@ use std::{ collections::HashMap, path::PathBuf, process::{ExitStatus, Stdio}, + sync::Arc, }; use anyhow::bail; @@ -9,24 +10,24 @@ use common::binary_paths; use log::info; use tokio::{io::AsyncWriteExt, process::Command}; -use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64}; +use crate::{process::gui_helper_launcher::GuiHelperLauncher, service::transport::SessionCredential}; use super::command_traits::CommandExt; pub struct GuiLauncher<'a> { version: &'a str, program: PathBuf, - api_key: &'a [u8], + credential: Arc, minimized: bool, envs: Option>, } impl<'a> GuiLauncher<'a> { - pub fn new(version: &'a str, api_key: &'a [u8]) -> Self { + pub fn new(version: &'a str, credential: Arc) -> Self { Self { version, program: binary_paths::gpgui(), - api_key, + credential, minimized: false, envs: None, } @@ -61,7 +62,7 @@ impl<'a> GuiLauncher<'a> { cmd.envs(envs); } - cmd.arg("--api-key-on-stdin"); + cmd.arg("--service-credential-on-stdin"); if self.minimized { cmd.arg("--minimized"); @@ -79,13 +80,11 @@ impl<'a> GuiLauncher<'a> { bail!("Failed to open stdin"); }; - let api_key = base64::encode(self.api_key); - tokio::spawn(async move { - stdin.write_all(api_key.as_bytes()).await.unwrap(); - drop(stdin); - }); + let frame = self.credential.encode_frame()?; + stdin.write_all(&frame).await?; let exit_status = child.wait().await?; + drop(stdin); Ok(exit_status) } @@ -109,7 +108,7 @@ impl<'a> GuiLauncher<'a> { } async fn download_program(&self) -> anyhow::Result<()> { - let gui_helper = GuiHelperLauncher::new(self.api_key); + let gui_helper = GuiHelperLauncher::new(&self.credential); gui_helper .envs(self.envs.as_ref()) diff --git a/crates/gpapi/src/service/mod.rs b/crates/gpapi/src/service/mod.rs index aa22051..063f395 100644 --- a/crates/gpapi/src/service/mod.rs +++ b/crates/gpapi/src/service/mod.rs @@ -1,4 +1,5 @@ pub mod event; pub mod request; +pub mod transport; pub mod vpn_env; pub mod vpn_state; diff --git a/crates/gpapi/src/service/request.rs b/crates/gpapi/src/service/request.rs index c3f52ee..15ff6e4 100644 --- a/crates/gpapi/src/service/request.rs +++ b/crates/gpapi/src/service/request.rs @@ -299,17 +299,16 @@ pub enum WsRequest { Connect(Box), Disconnect(DisconnectRequest), UpdateLogLevel(UpdateLogLevelRequest), + RestartGui, + UpdateGui(UpdateGuiRequest), } -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Clone, Deserialize, Serialize)] pub struct UpdateGuiRequest { pub path: String, pub checksum: String, } -#[derive(Debug, Deserialize, Serialize)] -pub struct RestartGuiRequest; - #[cfg(test)] mod tests { use serde_json::json; diff --git a/crates/gpapi/src/service/transport/credential.rs b/crates/gpapi/src/service/transport/credential.rs new file mode 100644 index 0000000..f6fbdfd --- /dev/null +++ b/crates/gpapi/src/service/transport/credential.rs @@ -0,0 +1,164 @@ +use std::fmt; + +use ::base64::{Engine, engine::general_purpose}; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; +use zeroize::Zeroizing; + +use crate::utils::base64; + +use super::{MAX_CREDENTIAL_FRAME, MAX_PRODUCT_VERSION, TransportError}; + +pub struct SessionCredential { + service_instance_id: Uuid, + session_id: Uuid, + secret: Zeroizing<[u8; 32]>, + product_version: String, +} + +impl SessionCredential { + pub fn generate(service_instance_id: Uuid, product_version: &str) -> Result { + if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION { + return Err(TransportError::InvalidCredential); + } + + let mut secret = Zeroizing::new([0_u8; 32]); + getrandom::fill(secret.as_mut()).map_err(|_| TransportError::InvalidState)?; + + Ok(Self { + service_instance_id, + session_id: Uuid::new_v4(), + secret, + product_version: product_version.to_owned(), + }) + } + + pub fn service_instance_id(&self) -> Uuid { + self.service_instance_id + } + + pub fn session_id(&self) -> Uuid { + self.session_id + } + + pub fn secret(&self) -> &[u8; 32] { + &self.secret + } + + pub fn product_version(&self) -> &str { + &self.product_version + } + + pub fn encode_frame(&self) -> Result>, TransportError> { + let encoded_secret = Zeroizing::new(base64::encode(self.secret())); + let dto = CredentialDtoRef { + service_instance_id: self.service_instance_id, + session_id: self.session_id, + secret: encoded_secret.as_str(), + product_version: &self.product_version, + }; + let payload = Zeroizing::new(serde_json::to_vec(&dto)?); + + if payload.len() + 2 > MAX_CREDENTIAL_FRAME || payload.len() > u16::MAX as usize { + return Err(TransportError::MessageTooLarge); + } + + let mut frame = Zeroizing::new(Vec::with_capacity(payload.len() + 2)); + frame.extend_from_slice(&(payload.len() as u16).to_be_bytes()); + frame.extend_from_slice(&payload); + Ok(frame) + } + + pub fn decode_frame(frame: &[u8]) -> Result { + if frame.len() < 2 || frame.len() > MAX_CREDENTIAL_FRAME { + return Err(TransportError::InvalidCredential); + } + + let payload_len = u16::from_be_bytes([frame[0], frame[1]]) as usize; + if payload_len == 0 || payload_len + 2 != frame.len() { + return Err(TransportError::InvalidCredential); + } + + let dto: CredentialDto = serde_json::from_slice(&frame[2..]).map_err(|_| TransportError::InvalidCredential)?; + let CredentialDto { + service_instance_id, + session_id, + secret, + product_version, + } = dto; + let encoded_secret = secret; + if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION { + return Err(TransportError::InvalidCredential); + } + + let mut secret = Zeroizing::new([0_u8; 32]); + let decoded_len = general_purpose::STANDARD + .decode_slice(encoded_secret.as_bytes(), secret.as_mut()) + .map_err(|_| TransportError::InvalidCredential)?; + if decoded_len != secret.len() { + return Err(TransportError::InvalidCredential); + } + + Ok(Self { + service_instance_id, + session_id, + secret, + product_version, + }) + } +} + +impl fmt::Debug for SessionCredential { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("SessionCredential") + .field("service_instance_id", &self.service_instance_id) + .field("session_id", &self.session_id) + .field("secret", &"[REDACTED]") + .field("product_version", &self.product_version) + .finish() + } +} + +#[derive(Serialize)] +#[serde(deny_unknown_fields)] +struct CredentialDtoRef<'a> { + service_instance_id: Uuid, + session_id: Uuid, + secret: &'a str, + product_version: &'a str, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct CredentialDto { + service_instance_id: Uuid, + session_id: Uuid, + secret: Zeroizing, + product_version: String, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn credential_round_trips_without_debugging_secret() { + let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.4").unwrap(); + let frame = credential.encode_frame().unwrap(); + let decoded = SessionCredential::decode_frame(&frame).unwrap(); + + assert_eq!(decoded.service_instance_id(), credential.service_instance_id()); + assert_eq!(decoded.session_id(), credential.session_id()); + assert_eq!(decoded.secret(), credential.secret()); + assert_eq!(decoded.product_version(), credential.product_version()); + assert!(!format!("{credential:?}").contains(&base64::encode(credential.secret()))); + } + + #[test] + fn credential_rejects_malformed_lengths() { + assert!(SessionCredential::decode_frame(&[]).is_err()); + assert!(SessionCredential::decode_frame(&[0, 0]).is_err()); + assert!(SessionCredential::decode_frame(&[0, 2, b'{']).is_err()); + assert!(SessionCredential::decode_frame(&vec![0; MAX_CREDENTIAL_FRAME + 1]).is_err()); + } +} diff --git a/crates/gpapi/src/service/transport/error.rs b/crates/gpapi/src/service/transport/error.rs new file mode 100644 index 0000000..801d304 --- /dev/null +++ b/crates/gpapi/src/service/transport/error.rs @@ -0,0 +1,118 @@ +use serde::{Deserialize, Serialize}; +use thiserror::Error; +use uuid::Uuid; + +#[derive(Debug, Error)] +pub enum TransportError { + #[error("invalid credential frame")] + InvalidCredential, + #[error("invalid transport state")] + InvalidState, + #[error("message exceeds transport limit")] + MessageTooLarge, + #[error("malformed transport message")] + MalformedMessage, + #[error("Noise operation failed")] + Noise(#[from] snow::Error), + #[error("transport serialization failed")] + Serialization(#[from] serde_json::Error), +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "camelCase", deny_unknown_fields)] +pub enum HandshakeRejection { + VersionMismatch { client: String, service: String }, + ServiceRestarted { service_instance_id: Uuid }, + ReconnectSuperseded, + Unauthorized, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ServiceErrorCode { + InvalidRequest, + Busy, + ChecksumFailed, + InstallFailed, + Internal, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CloseReason { + VersionMismatch, + Unauthorized, + SessionReplaced, + HandshakeFailed, + MalformedMessage, + MessageTooLarge, + AuthenticationFailed, + HandshakeTimeout, + ReconnectSuperseded, + InternalError, + ServiceRestarted, + HeartbeatTimeout, +} + +impl CloseReason { + pub const fn code(self) -> u16 { + match self { + Self::VersionMismatch => 4001, + Self::Unauthorized => 4002, + Self::SessionReplaced => 4003, + Self::HandshakeFailed => 4004, + Self::MalformedMessage => 4005, + Self::MessageTooLarge => 4006, + Self::AuthenticationFailed => 4007, + Self::HandshakeTimeout => 4008, + Self::ReconnectSuperseded => 4009, + Self::InternalError => 4010, + Self::ServiceRestarted => 4011, + Self::HeartbeatTimeout => 4012, + } + } + + pub const fn reason(self) -> &'static str { + match self { + Self::VersionMismatch => "VersionMismatch", + Self::Unauthorized => "Unauthorized", + Self::SessionReplaced => "SessionReplaced", + Self::HandshakeFailed => "HandshakeFailed", + Self::MalformedMessage => "MalformedMessage", + Self::MessageTooLarge => "MessageTooLarge", + Self::AuthenticationFailed => "AuthenticationFailed", + Self::HandshakeTimeout => "HandshakeTimeout", + Self::ReconnectSuperseded => "ReconnectSuperseded", + Self::InternalError => "InternalError", + Self::ServiceRestarted => "ServiceRestarted", + Self::HeartbeatTimeout => "HeartbeatTimeout", + } + } +} + +#[cfg(test)] +mod tests { + use std::collections::HashSet; + + use super::*; + + #[test] + fn close_codes_are_unique_application_codes() { + let reasons = [ + CloseReason::VersionMismatch, + CloseReason::Unauthorized, + CloseReason::SessionReplaced, + CloseReason::HandshakeFailed, + CloseReason::MalformedMessage, + CloseReason::MessageTooLarge, + CloseReason::AuthenticationFailed, + CloseReason::HandshakeTimeout, + CloseReason::ReconnectSuperseded, + CloseReason::InternalError, + CloseReason::ServiceRestarted, + CloseReason::HeartbeatTimeout, + ]; + let codes: HashSet<_> = reasons.iter().map(|reason| reason.code()).collect(); + assert_eq!(codes.len(), reasons.len()); + assert!(codes.iter().all(|code| (4000..5000).contains(code))); + } +} diff --git a/crates/gpapi/src/service/transport/handshake.rs b/crates/gpapi/src/service/transport/handshake.rs new file mode 100644 index 0000000..78d3a91 --- /dev/null +++ b/crates/gpapi/src/service/transport/handshake.rs @@ -0,0 +1,85 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use super::{HandshakeRejection, MAX_PRELUDE, MAX_PRODUCT_VERSION, TransportError}; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ClientPrelude { + pub product_version: String, + pub service_instance_id: Uuid, + pub session_id: Uuid, +} + +impl ClientPrelude { + pub fn encode(&self) -> Result, TransportError> { + if self.product_version.is_empty() || self.product_version.len() > MAX_PRODUCT_VERSION { + return Err(TransportError::MalformedMessage); + } + let encoded = serde_json::to_vec(self)?; + if encoded.len() > MAX_PRELUDE { + return Err(TransportError::MessageTooLarge); + } + Ok(encoded) + } + + pub fn decode(encoded: &[u8]) -> Result { + if encoded.len() > MAX_PRELUDE { + return Err(TransportError::MessageTooLarge); + } + let prelude: Self = serde_json::from_slice(encoded)?; + if prelude.product_version.is_empty() || prelude.product_version.len() > MAX_PRODUCT_VERSION { + return Err(TransportError::MalformedMessage); + } + Ok(prelude) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)] +pub enum ServerPrelude { + Ready, + Rejected(HandshakeRejection), +} + +impl ServerPrelude { + pub fn encode(&self) -> Result, TransportError> { + let encoded = serde_json::to_vec(self)?; + if encoded.len() > MAX_PRELUDE { + return Err(TransportError::MessageTooLarge); + } + Ok(encoded) + } + + pub fn decode(encoded: &[u8]) -> Result { + if encoded.len() > MAX_PRELUDE { + return Err(TransportError::MessageTooLarge); + } + Ok(serde_json::from_slice(encoded)?) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn preludes_reject_unknown_fields_and_invalid_versions() { + let instance = Uuid::new_v4(); + let session = Uuid::new_v4(); + let unknown = format!( + r#"{{"product_version":"2.6.4","service_instance_id":"{instance}","session_id":"{session}","extra":true}}"# + ); + assert!(ClientPrelude::decode(unknown.as_bytes()).is_err()); + assert!( + ClientPrelude { + product_version: String::new(), + service_instance_id: instance, + session_id: session, + } + .encode() + .is_err() + ); + assert!(ClientPrelude::decode(&vec![b'x'; MAX_PRELUDE + 1]).is_err()); + } +} diff --git a/crates/gpapi/src/service/transport/message.rs b/crates/gpapi/src/service/transport/message.rs new file mode 100644 index 0000000..2b8d035 --- /dev/null +++ b/crates/gpapi/src/service/transport/message.rs @@ -0,0 +1,140 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::service::{event::WsEvent, request::WsRequest, vpn_env::VpnEnv}; + +use super::{MAX_PLAINTEXT, MAX_SERVICE_MESSAGE, ServiceErrorCode, TransportError}; + +#[derive(Debug, Serialize, Deserialize)] +#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)] +pub enum ClientMessage { + Attach { last_event_revision: Option }, + Request { id: Uuid, request: WsRequest }, + Resync { last_event_revision: u64 }, +} + +#[derive(Debug, Serialize, Deserialize)] +#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)] +pub enum ServerMessage { + Attached { + connection_id: Uuid, + current_revision: u64, + snapshot: VpnEnv, + }, + Reply { + id: Uuid, + result: ServiceResult, + }, + Event { + revision: u64, + event: WsEvent, + }, + Snapshot { + current_revision: u64, + snapshot: VpnEnv, + }, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)] +pub enum ServiceResult { + Accepted, + Rejected(ServiceRejection), +} + +impl ServiceResult { + pub fn rejected(code: ServiceErrorCode, message: impl Into) -> Self { + Self::Rejected(ServiceRejection::new(code, message)) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(try_from = "ServiceRejectionDto")] +pub struct ServiceRejection { + code: ServiceErrorCode, + message: String, +} + +impl ServiceRejection { + fn new(code: ServiceErrorCode, message: impl Into) -> Self { + let mut message = message.into(); + if message.len() > MAX_SERVICE_MESSAGE { + let mut boundary = MAX_SERVICE_MESSAGE; + while !message.is_char_boundary(boundary) { + boundary -= 1; + } + message.truncate(boundary); + } + Self { code, message } + } + + pub fn code(&self) -> ServiceErrorCode { + self.code + } + + pub fn message(&self) -> &str { + &self.message + } +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct ServiceRejectionDto { + code: ServiceErrorCode, + message: String, +} + +impl TryFrom for ServiceRejection { + type Error = &'static str; + + fn try_from(value: ServiceRejectionDto) -> Result { + if value.message.len() > MAX_SERVICE_MESSAGE { + return Err("service rejection message is too long"); + } + Ok(Self { + code: value.code, + message: value.message, + }) + } +} + +pub(crate) fn encode(message: &T) -> Result, TransportError> { + let encoded = serde_json::to_vec(message)?; + if encoded.len() > MAX_PLAINTEXT { + return Err(TransportError::MessageTooLarge); + } + Ok(encoded) +} + +pub(crate) fn decode Deserialize<'de>>(encoded: &[u8]) -> Result { + if encoded.len() > MAX_PLAINTEXT { + return Err(TransportError::MessageTooLarge); + } + Ok(serde_json::from_slice(encoded)?) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_oversized_messages() { + assert!(encode(&"x".repeat(MAX_PLAINTEXT)).is_err()); + assert!(decode::(&vec![b'x'; MAX_PLAINTEXT + 1]).is_err()); + } + + #[test] + fn rejection_messages_are_utf8_safely_bounded() { + let ServiceResult::Rejected(rejection) = ServiceResult::rejected(ServiceErrorCode::Internal, "界".repeat(100)) + else { + panic!("expected rejection"); + }; + assert!(rejection.message().len() <= MAX_SERVICE_MESSAGE); + + let oversized = format!( + r#"{{"type":"rejected","data":{{"code":"internal","message":"{}"}}}}"#, + "x".repeat(MAX_SERVICE_MESSAGE + 1) + ); + assert!(serde_json::from_str::(&oversized).is_err()); + } +} diff --git a/crates/gpapi/src/service/transport/mod.rs b/crates/gpapi/src/service/transport/mod.rs new file mode 100644 index 0000000..741448e --- /dev/null +++ b/crates/gpapi/src/service/transport/mod.rs @@ -0,0 +1,18 @@ +mod credential; +mod error; +mod handshake; +mod message; +mod noise; + +pub use credential::SessionCredential; +pub use error::{CloseReason, HandshakeRejection, ServiceErrorCode, TransportError}; +pub use handshake::{ClientPrelude, ServerPrelude}; +pub use message::{ClientMessage, ServerMessage, ServiceRejection, ServiceResult}; +pub use noise::{NoiseInitiator, NoiseResponder, NoiseTransport}; + +pub const MAX_CREDENTIAL_FRAME: usize = 512; +pub const MAX_PRELUDE: usize = 256; +pub const MAX_PRODUCT_VERSION: usize = 64; +pub const MAX_PLAINTEXT: usize = 60 * 1024; +pub const MAX_WS_MESSAGE: usize = u16::MAX as usize; +pub const MAX_SERVICE_MESSAGE: usize = 256; diff --git a/crates/gpapi/src/service/transport/noise.rs b/crates/gpapi/src/service/transport/noise.rs new file mode 100644 index 0000000..3baa5d3 --- /dev/null +++ b/crates/gpapi/src/service/transport/noise.rs @@ -0,0 +1,231 @@ +use snow::{Builder, HandshakeState, TransportState, params::NoiseParams}; +use zeroize::Zeroizing; + +use super::{MAX_PLAINTEXT, MAX_PRODUCT_VERSION, MAX_WS_MESSAGE, TransportError}; + +const NOISE_PATTERN: &str = "Noise_NNpsk0_25519_ChaChaPoly_SHA256"; +const NOISE_TAG_SIZE: usize = 16; + +pub struct NoiseInitiator { + state: Option, +} + +impl NoiseInitiator { + pub fn new( + product_version: &str, + service_instance_id: uuid::Uuid, + session_id: uuid::Uuid, + psk: &[u8; 32], + ) -> Result { + let params = noise_params()?; + let prologue = prologue(product_version, service_instance_id, session_id)?; + Ok(Self { + state: Some( + Builder::new(params) + .prologue(&prologue)? + .psk(0, psk)? + .build_initiator()?, + ), + }) + } + + pub fn write_first(&mut self) -> Result, TransportError> { + let state = self.state.as_mut().ok_or(TransportError::InvalidState)?; + let mut output = vec![0_u8; 128]; + let len = state.write_message(&[], &mut output)?; + output.truncate(len); + Ok(output) + } + + pub fn read_response(mut self, message: &[u8]) -> Result { + if message.len() > MAX_WS_MESSAGE { + return Err(TransportError::MessageTooLarge); + } + let mut state = self.state.take().ok_or(TransportError::InvalidState)?; + let mut output = vec![0_u8; 128]; + state.read_message(message, &mut output)?; + Ok(NoiseTransport::new(state.into_transport_mode()?)) + } +} + +pub struct NoiseResponder { + state: Option, +} + +impl NoiseResponder { + pub fn new( + product_version: &str, + service_instance_id: uuid::Uuid, + session_id: uuid::Uuid, + psk: &[u8; 32], + ) -> Result { + let params = noise_params()?; + let prologue = prologue(product_version, service_instance_id, session_id)?; + Ok(Self { + state: Some( + Builder::new(params) + .prologue(&prologue)? + .psk(0, psk)? + .build_responder()?, + ), + }) + } + + pub fn read_first(&mut self, message: &[u8]) -> Result<(), TransportError> { + if message.len() > MAX_WS_MESSAGE { + return Err(TransportError::MessageTooLarge); + } + let state = self.state.as_mut().ok_or(TransportError::InvalidState)?; + let mut output = vec![0_u8; 128]; + state.read_message(message, &mut output)?; + Ok(()) + } + + pub fn write_response(mut self) -> Result<(Vec, NoiseTransport), TransportError> { + let mut state = self.state.take().ok_or(TransportError::InvalidState)?; + let mut output = vec![0_u8; 128]; + let len = state.write_message(&[], &mut output)?; + output.truncate(len); + let transport = NoiseTransport::new(state.into_transport_mode()?); + Ok((output, transport)) + } +} + +pub struct NoiseTransport { + state: TransportState, +} + +impl NoiseTransport { + fn new(state: TransportState) -> Self { + Self { state } + } + + pub fn encrypt(&mut self, message: &T) -> Result, TransportError> { + let plaintext = Zeroizing::new(super::message::encode(message)?); + let mut output = vec![0_u8; plaintext.len() + NOISE_TAG_SIZE]; + let len = self.state.write_message(&plaintext, &mut output)?; + output.truncate(len); + Ok(output) + } + + pub fn decrypt serde::Deserialize<'de>>(&mut self, message: &[u8]) -> Result { + if message.len() > MAX_WS_MESSAGE || message.len() < NOISE_TAG_SIZE { + return Err(if message.len() > MAX_WS_MESSAGE { + TransportError::MessageTooLarge + } else { + TransportError::MalformedMessage + }); + } + let mut plaintext = Zeroizing::new(vec![0_u8; message.len()]); + let len = self.state.read_message(message, &mut plaintext)?; + plaintext.truncate(len); + if plaintext.len() > MAX_PLAINTEXT { + return Err(TransportError::MessageTooLarge); + } + super::message::decode(&plaintext) + } +} + +fn noise_params() -> Result { + NOISE_PATTERN.parse().map_err(|_| TransportError::InvalidState) +} + +fn prologue( + product_version: &str, + service_instance_id: uuid::Uuid, + session_id: uuid::Uuid, +) -> Result, TransportError> { + if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION { + return Err(TransportError::MessageTooLarge); + } + let mut value = Vec::with_capacity(5 + 2 + product_version.len() + 32); + value.extend_from_slice(b"GPWS\0"); + value.extend_from_slice(&(product_version.len() as u16).to_be_bytes()); + value.extend_from_slice(product_version.as_bytes()); + value.extend_from_slice(service_instance_id.as_bytes()); + value.extend_from_slice(session_id.as_bytes()); + Ok(value) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)] + struct Payload(String); + + #[test] + fn peers_exchange_directional_messages() { + let instance = uuid::Uuid::new_v4(); + let session = uuid::Uuid::new_v4(); + let psk = [7_u8; 32]; + let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap(); + let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap(); + + let first = initiator.write_first().unwrap(); + responder.read_first(&first).unwrap(); + let (response, mut server) = responder.write_response().unwrap(); + let mut client = initiator.read_response(&response).unwrap(); + + let encrypted = client.encrypt(&Payload("hello".into())).unwrap(); + assert_eq!(server.decrypt::(&encrypted).unwrap(), Payload("hello".into())); + assert!(server.decrypt::(&encrypted).is_err()); + + let response = server.encrypt(&Payload("world".into())).unwrap(); + assert_eq!(client.decrypt::(&response).unwrap(), Payload("world".into())); + } + + #[test] + fn wrong_psk_fails_handshake() { + let instance = uuid::Uuid::new_v4(); + let session = uuid::Uuid::new_v4(); + let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &[1; 32]).unwrap(); + let mut responder = NoiseResponder::new("2.6.4", instance, session, &[2; 32]).unwrap(); + let first = initiator.write_first().unwrap(); + assert!(responder.read_first(&first).is_err()); + } + + #[test] + fn transcript_identity_mismatch_fails_handshake() { + let instance = uuid::Uuid::new_v4(); + let session = uuid::Uuid::new_v4(); + let psk = [3_u8; 32]; + for mut responder in [ + NoiseResponder::new("2.6.5", instance, session, &psk).unwrap(), + NoiseResponder::new("2.6.4", uuid::Uuid::new_v4(), session, &psk).unwrap(), + NoiseResponder::new("2.6.4", instance, uuid::Uuid::new_v4(), &psk).unwrap(), + ] { + let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap(); + let first = initiator.write_first().unwrap(); + assert!(responder.read_first(&first).is_err()); + } + } + + #[test] + fn transport_rejects_tampering_truncation_and_reordering() { + let instance = uuid::Uuid::new_v4(); + let session = uuid::Uuid::new_v4(); + let psk = [9_u8; 32]; + let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap(); + let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap(); + let first = initiator.write_first().unwrap(); + responder.read_first(&first).unwrap(); + let (response, mut server) = responder.write_response().unwrap(); + let mut client = initiator.read_response(&response).unwrap(); + + let first = client.encrypt(&Payload("first".into())).unwrap(); + let second = client.encrypt(&Payload("second".into())).unwrap(); + assert!(server.decrypt::(&second).is_err()); + + let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap(); + let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap(); + let handshake = initiator.write_first().unwrap(); + responder.read_first(&handshake).unwrap(); + let (response, mut server) = responder.write_response().unwrap(); + let mut client = initiator.read_response(&response).unwrap(); + let mut tampered = client.encrypt(&Payload("value".into())).unwrap(); + tampered[0] ^= 1; + assert!(server.decrypt::(&tampered).is_err()); + assert!(server.decrypt::(&first[..NOISE_TAG_SIZE - 1]).is_err()); + } +} diff --git a/scripts/dev-service.sh b/scripts/dev-service.sh new file mode 100755 index 0000000..3a14074 --- /dev/null +++ b/scripts/dev-service.sh @@ -0,0 +1,25 @@ +#!/bin/sh +set -eu + +repo=$(CDPATH= cd "$(dirname "$0")/.." && pwd) +cd "$repo" + +if [ "$(id -u)" -eq 0 ]; then + echo "Run this script as the desktop user; it invokes sudo only for gpservice." >&2 + exit 1 +fi + +uid=$(id -u) +if [ -n "${GP_DEV_BOOTSTRAP_SOCKET:-}" ]; then + socket=$GP_DEV_BOOTSTRAP_SOCKET +else + socket=/var/run/gpservice-dev-$uid/dev-bootstrap.sock +fi + +cargo build -p gpservice +echo "Debug credential socket: $socket" +exec sudo target/debug/gpservice \ + --dev-standalone \ + --dev-uid "$uid" \ + --dev-bootstrap-socket "$socket" \ + "$@"