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

+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(())
}