refactor: authenticate service websocket transport

This commit is contained in:
Kevin Yue committed 2026-07-16 20:35:46 +08:00
1 parent 3817227942
commit ce97729984
31 files changed
+3304 -441

No files matched your search

Generated
+167 -11
View File
@@ -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"
+2
View File
@@ -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" }
+3
View File
@@ -64,6 +64,9 @@ endif
default: build
dev-service:
./scripts/dev-service.sh
version:
@echo $(VERSION)
+3
View File
@@ -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"] }
+22 -5
View File
@@ -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<u8>,
credential: Arc<SessionCredential>,
credential_lease: watch::Receiver<bool>,
gui_version: String,
}
impl App {
pub fn new(api_key: Vec<u8>, gui_version: &str) -> Self {
pub fn new(credential: Arc<SessionCredential>, credential_lease: watch::Receiver<bool>, 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");
+63 -17
View File
@@ -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<Vec<u8>> {
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<SessionCredential> {
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<watch::Receiver<bool>> {
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<bool>) {
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());
}
}
+452 -18
View File
@@ -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<InstallCommand>,
}
struct InstallCommand {
request: UpdateGuiRequest,
reply: oneshot::Sender<anyhow::Result<()>>,
}
impl Installer {
pub fn new(api_key: Vec<u8>) -> Self {
Self {
crypto: Crypto::new(api_key),
}
pub fn new(credential: Arc<SessionCredential>, credential_lease: watch::Receiver<bool>) -> 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<MaybeTlsStream<TcpStream>>;
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<SessionCredential>,
mut credential_lease: watch::Receiver<bool>,
mut commands: mpsc::Receiver<InstallCommand>,
) {
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::<TerminalConnectError>() => {
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<bool>,
commands: &mut mpsc::Receiver<InstallCommand>,
pending: &mut Option<InstallCommand>,
) -> anyhow::Result<ConnectionEnd> {
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::<ServerMessage>(&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<Uuid> {
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<ServerMessage> {
Ok(noise.decrypt(&receive_binary(socket).await?)?)
}
async fn receive_binary(socket: &mut Socket) -> anyhow::Result<Vec<u8>> {
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::<TerminalConnectError>());
}
async fn spawn_test_service(
credential: Arc<SessionCredential>,
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::<ClientMessage>(&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::<ClientMessage>(&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)
}
}
+10
View File
@@ -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"
+65 -33
View File
@@ -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<String>,
#[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<u32>,
#[cfg(debug_assertions)]
#[clap(long, requires = "dev_standalone")]
dev_bootstrap_socket: Option<PathBuf>,
#[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::<WsRequest>(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(&registry),
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(&registry));
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<u8> {
#[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<HashMap<String, String>>,
api_key: Vec<u8>,
registry: Arc<SessionRegistry>,
mut minimized: bool,
restart_requested: Arc<AtomicBool>,
) {
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;
}
+244
View File
@@ -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<SessionRegistry>,
}
impl DevBootstrap {
pub fn new(path: PathBuf, allowed_uid: u32, registry: Arc<SessionRegistry>) -> 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<PathBuf> {
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<SessionRegistry>) -> 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<u32> {
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<u32> {
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(&registry)));
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());
}
}
+7 -167
View File
@@ -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<Arc<WsServerContext>>) -> impl
ctx.send_event(WsEvent::ActiveGui).await;
}
pub(crate) async fn restart_gui(State(ctx): State<Arc<WsServerContext>>, body: Bytes) -> Result<(), StatusCode> {
if let Err(err) = ctx.decrypt::<RestartGuiRequest>(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<Arc<WsServerContext>>, body: Bytes) -> Result<(), StatusCode> {
let payload = match ctx.decrypt::<UpdateGuiRequest>(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<Arc<WsServerContext>>) -> impl IntoResponse {
ws.on_upgrade(move |socket| handle_socket(socket, ctx))
}
async fn handle_socket(mut socket: WebSocket, ctx: Arc<WsServerContext>) {
// 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))
}
+4
View File
@@ -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;
+280
View File
@@ -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<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
install_lock: Mutex<()>,
}
impl RequestDispatcher {
pub fn new(
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
) -> 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<NamedTempFile, GuiInstallError> {
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<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<NamedTempFile, GuiInstallError> {
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<u8> {
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());
}
}
-2
View File
@@ -11,8 +11,6 @@ pub(crate) fn routes(ctx: Arc<WsServerContext>) -> 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)
}
+363
View File
@@ -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<SessionRegistry>,
}
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<Uuid>,
},
Active {
generation: u64,
connection: Option<ConnectionControl>,
reconnect_token: Option<Uuid>,
},
}
struct SessionRecord {
secret: Zeroizing<[u8; 32]>,
product_version: String,
status: SessionStatus,
}
pub struct SessionRegistry {
service_instance_id: Uuid,
sessions: Mutex<HashMap<Uuid, SessionRecord>>,
}
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<Arc<SessionCredential>, 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<Self>,
service_instance_id: Uuid,
session_id: Uuid,
product_version: &str,
) -> Result<HandshakePermit, SessionError> {
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<PreparedAttach, SessionError> {
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<Option<ConnectionControl>, 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::<ConnectionCommand>(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()
);
}
}
+5 -2
View File
@@ -169,7 +169,7 @@ impl VpnTask {
}
pub fn context(&self) -> Arc<VpnTaskContext> {
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<VpnTaskContext>) {
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");
}
}
}
+510 -39
View File
@@ -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<Crypto>,
tx: mpsc::Sender<Message>,
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<Crypto>, tx: mpsc::Sender<Message>) -> Self {
Self { crypto, tx }
}
#[derive(Clone)]
pub(crate) struct ConnectionControl {
connection_id: Uuid,
tx: mpsc::Sender<ConnectionCommand>,
close_tx: watch::Sender<Option<CloseReason>>,
}
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<ConnectionCommand>) -> (Self, watch::Receiver<Option<CloseReason>>) {
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<WsServerContext>) {
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::<ClientMessage>(&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<WsServerContext>,
) -> Result<
(
NoiseTransport,
HandshakePermit,
ConnectionControl,
mpsc::Receiver<ConnectionCommand>,
watch::Receiver<Option<CloseReason>>,
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::<ClientMessage>(&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<WsServerContext>,
control: &ConnectionControl,
session_id: Uuid,
generation: u64,
pending_requests: &mut HashSet<Uuid>,
) -> 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<ClientPrelude, CloseReason> {
let data = receive_binary(socket).await?;
ClientPrelude::decode(&data).map_err(|_| CloseReason::MalformedMessage)
}
async fn receive_binary(socket: &mut WebSocket) -> Result<Vec<u8>, 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(&registry),
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::<ServerMessage>(&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::<ServerMessage>(&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::<ServerMessage>(&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<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>,
) -> Vec<u8> {
match socket.next().await.unwrap().unwrap() {
ClientFrame::Binary(data) => data.to_vec(),
frame => panic!("unexpected frame: {frame:?}"),
}
}
}
+297 -118
View File
@@ -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<Uuid, ConnectionControl>,
}
pub(crate) struct WsServerContext {
crypto: Arc<Crypto>,
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
vpn_state_rx: watch::Receiver<VpnState>,
redaction: Arc<Redaction>,
connections: RwLock<Vec<Arc<WsConnection>>>,
product_version: &'static str,
registry: Arc<SessionRegistry>,
dispatcher: Arc<RequestDispatcher>,
state: Mutex<ServiceState>,
handshake_slots: Arc<Semaphore>,
}
impl WsServerContext {
pub fn new(
api_key: Vec<u8>,
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
vpn_state_rx: watch::Receiver<VpnState>,
redaction: Arc<Redaction>,
product_version: &'static str,
registry: Arc<SessionRegistry>,
dispatcher: Arc<RequestDispatcher>,
vpn_state_rx: &watch::Receiver<VpnState>,
) -> 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<T: DeserializeOwned>(&self, encrypted: Vec<u8>) -> anyhow::Result<T> {
self.crypto.decrypt(encrypted)
pub fn product_version(&self) -> &'static str {
self.product_version
}
pub fn registry(&self) -> &Arc<SessionRegistry> {
&self.registry
}
pub fn dispatcher(&self) -> Arc<RequestDispatcher> {
Arc::clone(&self.dispatcher)
}
pub fn try_handshake_slot(&self) -> Option<tokio::sync::OwnedSemaphorePermit> {
Arc::clone(&self.handshake_slots).try_acquire_owned().ok()
}
pub async fn prepare_connection(
&self,
permit: &HandshakePermit,
control: ConnectionControl,
) -> Result<PreparedAttach, SessionError> {
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<Option<ConnectionControl>, 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<WsConnection>, mpsc::Receiver<Message>) {
let (tx, rx) = mpsc::channel::<Message>(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<WsConnection>) {
let mut connections = self.connections.write().await;
connections.retain(|c| !Arc::ptr_eq(c, &conn));
}
fn vpn_state_rx(&self) -> watch::Receiver<VpnState> {
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<WsServerContext>,
cancel_token: CancellationToken,
lock_file: Arc<LockFile>,
vpn_state_rx: watch::Receiver<VpnState>,
}
impl WsServer {
pub fn new(
api_key: Vec<u8>,
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
product_version: &'static str,
registry: Arc<SessionRegistry>,
dispatcher: Arc<RequestDispatcher>,
vpn_state_rx: watch::Receiver<VpnState>,
lock_file: Arc<LockFile>,
redaction: Arc<Redaction>,
) -> 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<TcpListener> {
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(&registry),
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<VpnState>, ctx: Arc<WsServerContext>) {
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<WsServerContext>) -> anyhow::Result<()> {
let routes = routes::routes(ctx);
axum::serve(listener, routes).await?;
Ok(())
}
+4 -1
View File
@@ -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 }
-3
View File
@@ -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];
@@ -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<String, String>>,
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(())
+10 -11
View File
@@ -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<SessionCredential>,
minimized: bool,
envs: Option<HashMap<String, String>>,
}
impl<'a> GuiLauncher<'a> {
pub fn new(version: &'a str, api_key: &'a [u8]) -> Self {
pub fn new(version: &'a str, credential: Arc<SessionCredential>) -> 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())
+1
View File
@@ -1,4 +1,5 @@
pub mod event;
pub mod request;
pub mod transport;
pub mod vpn_env;
pub mod vpn_state;
+3 -4
View File
@@ -299,17 +299,16 @@ pub enum WsRequest {
Connect(Box<ConnectRequest>),
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;
@@ -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<Self, TransportError> {
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<Zeroizing<Vec<u8>>, 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<Self, TransportError> {
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<String>,
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());
}
}
+118
View File
@@ -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)));
}
}
@@ -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<Vec<u8>, 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<Self, TransportError> {
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<Vec<u8>, 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<Self, TransportError> {
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());
}
}
@@ -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<u64> },
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<String>) -> 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<String>) -> 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<ServiceRejectionDto> for ServiceRejection {
type Error = &'static str;
fn try_from(value: ServiceRejectionDto) -> Result<Self, Self::Error> {
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<T: Serialize>(message: &T) -> Result<Vec<u8>, TransportError> {
let encoded = serde_json::to_vec(message)?;
if encoded.len() > MAX_PLAINTEXT {
return Err(TransportError::MessageTooLarge);
}
Ok(encoded)
}
pub(crate) fn decode<T: for<'de> Deserialize<'de>>(encoded: &[u8]) -> Result<T, TransportError> {
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::<String>(&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::<ServiceResult>(&oversized).is_err());
}
}
+18
View File
@@ -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;
+231
View File
@@ -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<HandshakeState>,
}
impl NoiseInitiator {
pub fn new(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
psk: &[u8; 32],
) -> Result<Self, TransportError> {
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<Vec<u8>, 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<NoiseTransport, TransportError> {
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<HandshakeState>,
}
impl NoiseResponder {
pub fn new(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
psk: &[u8; 32],
) -> Result<Self, TransportError> {
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<u8>, 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<T: serde::Serialize>(&mut self, message: &T) -> Result<Vec<u8>, 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<T: for<'de> serde::Deserialize<'de>>(&mut self, message: &[u8]) -> Result<T, TransportError> {
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<NoiseParams, TransportError> {
NOISE_PATTERN.parse().map_err(|_| TransportError::InvalidState)
}
fn prologue(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
) -> Result<Vec<u8>, 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::<Payload>(&encrypted).unwrap(), Payload("hello".into()));
assert!(server.decrypt::<Payload>(&encrypted).is_err());
let response = server.encrypt(&Payload("world".into())).unwrap();
assert_eq!(client.decrypt::<Payload>(&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::<Payload>(&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::<Payload>(&tampered).is_err());
assert!(server.decrypt::<Payload>(&first[..NOISE_TAG_SIZE - 1]).is_err());
}
}
+25
View File
@@ -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" \
"$@"