mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 14:36:15 -05:00
feat: add brokered macOS service mode
This commit is contained in:
21 files changed
+642
-1426
No files matched your search
@@ -4,6 +4,8 @@ use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
#[cfg(target_os = "macos")]
|
||||
use std::time::Duration;
|
||||
use std::{collections::HashMap, io::Write};
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
@@ -49,6 +51,9 @@ struct Cli {
|
||||
#[cfg(debug_assertions)]
|
||||
#[clap(long, requires = "dev_standalone")]
|
||||
dev_bootstrap_socket: Option<PathBuf>,
|
||||
#[cfg(target_os = "macos")]
|
||||
#[clap(long, conflicts_with = "dev_standalone")]
|
||||
macos_brokered: bool,
|
||||
#[command(flatten)]
|
||||
verbose: InfoLevelVerbosity,
|
||||
}
|
||||
@@ -71,13 +76,20 @@ impl Cli {
|
||||
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 externally_brokered = self.externally_brokered();
|
||||
let brokered_helpers_dir = externally_brokered
|
||||
.then(|| std::env::current_exe().ok()?.parent().map(ToOwned::to_owned))
|
||||
.flatten();
|
||||
let dispatcher = Arc::new(RequestDispatcher::new(
|
||||
ws_req_tx.clone(),
|
||||
Arc::clone(&gui_restart_requested),
|
||||
Arc::clone(&redaction),
|
||||
!externally_brokered,
|
||||
brokered_helpers_dir,
|
||||
));
|
||||
|
||||
let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx);
|
||||
let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx, externally_brokered);
|
||||
let idle_vpn_state_rx = vpn_state_rx.clone();
|
||||
let ws_server = WsServer::new(
|
||||
env!("CARGO_PKG_VERSION"),
|
||||
Arc::clone(®istry),
|
||||
@@ -91,6 +103,27 @@ impl Cli {
|
||||
let vpn_task_cancel_token = vpn_task.cancel_token();
|
||||
let server_token = ws_server.cancel_token();
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
if externally_brokered {
|
||||
let credential_server = crate::macos_broker::CredentialServer::new(Arc::clone(®istry));
|
||||
let credential_token = server_token.clone();
|
||||
let credential_shutdown = shutdown_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = credential_server.start(credential_token).await {
|
||||
warn!("Broker credential server stopped: {err}");
|
||||
let _ = credential_shutdown.send(()).await;
|
||||
}
|
||||
});
|
||||
|
||||
let idle_registry = Arc::clone(®istry);
|
||||
let idle_shutdown = shutdown_tx.clone();
|
||||
let idle_token = server_token.clone();
|
||||
tokio::spawn(async move {
|
||||
wait_for_brokered_idle(idle_vpn_state_rx, idle_registry, idle_token).await;
|
||||
let _ = idle_shutdown.send(()).await;
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
if self.dev_standalone {
|
||||
let Some(dev_bootstrap_socket) = self.dev_bootstrap_socket.clone() else {
|
||||
@@ -123,9 +156,9 @@ impl Cli {
|
||||
let ws_server_handle = tokio::spawn(async move { ws_server.start(shutdown_tx_clone, ws_ready_tx).await });
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
let launch_managed_gui = !self.dev_standalone;
|
||||
let launch_managed_gui = !self.dev_standalone && !externally_brokered;
|
||||
#[cfg(not(debug_assertions))]
|
||||
let launch_managed_gui = true;
|
||||
let launch_managed_gui = !externally_brokered;
|
||||
|
||||
if launch_managed_gui {
|
||||
ws_ready_rx.await.context("WebSocket server failed to start")?;
|
||||
@@ -158,6 +191,14 @@ impl Cli {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn externally_brokered(&self) -> bool {
|
||||
#[cfg(target_os = "macos")]
|
||||
return self.macos_brokered;
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
false
|
||||
}
|
||||
|
||||
fn init_logger(&self) -> Arc<Redaction> {
|
||||
let redaction = Arc::new(Redaction::new());
|
||||
let redaction_clone = Arc::clone(&redaction);
|
||||
@@ -186,6 +227,38 @@ impl Cli {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
async fn wait_for_brokered_idle(
|
||||
mut vpn_state_rx: watch::Receiver<VpnState>,
|
||||
registry: Arc<SessionRegistry>,
|
||||
cancel: tokio_util::sync::CancellationToken,
|
||||
) {
|
||||
const IDLE_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
const CHECK_INTERVAL: Duration = Duration::from_secs(1);
|
||||
|
||||
let mut idle_since = None;
|
||||
let mut interval = tokio::time::interval(CHECK_INTERVAL);
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => return,
|
||||
_ = vpn_state_rx.changed() => {},
|
||||
_ = interval.tick() => {},
|
||||
}
|
||||
|
||||
let idle = matches!(*vpn_state_rx.borrow(), VpnState::Disconnected) && registry.is_empty();
|
||||
if !idle {
|
||||
idle_since = None;
|
||||
continue;
|
||||
}
|
||||
|
||||
let started = idle_since.get_or_insert_with(tokio::time::Instant::now);
|
||||
if started.elapsed() >= IDLE_TIMEOUT {
|
||||
info!("Brokered service idle timeout reached");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
mod signals {
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::UnixStream,
|
||||
};
|
||||
|
||||
use crate::session_registry::SessionRegistry;
|
||||
|
||||
pub(crate) async fn serve(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 {
|
||||
stream.write_all(&credential.encode_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
|
||||
}
|
||||
@@ -7,13 +7,10 @@ use std::{
|
||||
use anyhow::{Context, bail};
|
||||
use log::{info, warn};
|
||||
use nix::unistd::{Uid, chown};
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::{UnixListener, UnixStream},
|
||||
};
|
||||
use tokio::net::{UnixListener, UnixStream};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::session_registry::SessionRegistry;
|
||||
use crate::{credential_lease, session_registry::SessionRegistry};
|
||||
|
||||
pub struct DevBootstrap {
|
||||
path: PathBuf,
|
||||
@@ -57,7 +54,7 @@ impl DevBootstrap {
|
||||
}
|
||||
let registry = Arc::clone(&self.registry);
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = authorize_gui(stream, registry).await {
|
||||
if let Err(err) = credential_lease::serve(stream, registry).await {
|
||||
warn!("Debug credential client ended: {err}");
|
||||
}
|
||||
});
|
||||
@@ -123,28 +120,6 @@ fn prepare_socket_path(path: &Path, allowed_uid: u32) -> anyhow::Result<PathBuf>
|
||||
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};
|
||||
@@ -213,7 +188,7 @@ mod tests {
|
||||
async fn anchor_eof_revokes_issued_credential() {
|
||||
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
|
||||
let (service, mut client) = UnixStream::pair().unwrap();
|
||||
let task = tokio::spawn(authorize_gui(service, Arc::clone(®istry)));
|
||||
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(®istry)));
|
||||
|
||||
let mut header = [0_u8; 2];
|
||||
client.read_exact(&mut header).await.unwrap();
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
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;
|
||||
use tokio::net::{UnixListener, UnixStream};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::{credential_lease, session_registry::SessionRegistry};
|
||||
|
||||
pub(crate) const CREDENTIAL_SOCKET: &str = "/var/run/com.yuezk.gpgui/credential.sock";
|
||||
|
||||
pub(crate) struct CredentialServer {
|
||||
registry: Arc<SessionRegistry>,
|
||||
}
|
||||
|
||||
impl CredentialServer {
|
||||
pub(crate) fn new(registry: Arc<SessionRegistry>) -> Self {
|
||||
Self { registry }
|
||||
}
|
||||
|
||||
pub(crate) async fn start(self, cancel: CancellationToken) -> anyhow::Result<()> {
|
||||
if !Uid::effective().is_root() {
|
||||
bail!("macOS brokered mode requires root privileges");
|
||||
}
|
||||
|
||||
let path = prepare_socket(Path::new(CREDENTIAL_SOCKET), 0)?;
|
||||
let listener = UnixListener::bind(&path)
|
||||
.with_context(|| format!("Failed to bind broker credential socket at {}", path.display()))?;
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))?;
|
||||
info!("Broker credential socket listening at {}", path.display());
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => break,
|
||||
accepted = listener.accept() => {
|
||||
let (stream, _) = accepted?;
|
||||
if peer_uid(&stream)? != 0 {
|
||||
warn!("Rejected non-root broker credential client");
|
||||
continue;
|
||||
}
|
||||
let registry = Arc::clone(&self.registry);
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = credential_lease::serve(stream, registry).await {
|
||||
warn!("Broker credential lease ended: {err}");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
drop(listener);
|
||||
remove_socket(&path, 0)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare_socket(path: &Path, owner_uid: u32) -> anyhow::Result<PathBuf> {
|
||||
let parent = path
|
||||
.parent()
|
||||
.context("Broker credential socket has no parent directory")?;
|
||||
if !parent.exists() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
|
||||
let metadata = std::fs::symlink_metadata(parent)?;
|
||||
if metadata.file_type().is_symlink() || !metadata.is_dir() || metadata.uid() != owner_uid {
|
||||
bail!("Broker credential directory must be a real root-owned directory");
|
||||
}
|
||||
if metadata.permissions().mode() & 0o077 != 0 {
|
||||
std::fs::set_permissions(parent, std::fs::Permissions::from_mode(0o700))?;
|
||||
}
|
||||
|
||||
remove_socket(path, owner_uid)?;
|
||||
Ok(path.to_path_buf())
|
||||
}
|
||||
|
||||
fn remove_socket(path: &Path, owner_uid: u32) -> anyhow::Result<()> {
|
||||
match std::fs::symlink_metadata(path) {
|
||||
Ok(metadata) if metadata.file_type().is_socket() && metadata.uid() == owner_uid => {
|
||||
std::fs::remove_file(path)?;
|
||||
}
|
||||
Ok(_) => bail!("Refusing to replace an unsafe broker credential path"),
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(err) => return Err(err.into()),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn peer_uid(stream: &UnixStream) -> anyhow::Result<u32> {
|
||||
let (uid, _) = nix::unistd::getpeereid(stream)?;
|
||||
Ok(uid.as_raw())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn prepares_private_owner_directory_and_removes_owned_socket_only() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let owner = Uid::current().as_raw();
|
||||
let parent = temp.path().join("runtime");
|
||||
let socket = parent.join("credential.sock");
|
||||
|
||||
assert_eq!(prepare_socket(&socket, owner).unwrap(), socket);
|
||||
assert_eq!(std::fs::metadata(&parent).unwrap().permissions().mode() & 0o777, 0o700);
|
||||
|
||||
std::fs::write(&socket, "not a socket").unwrap();
|
||||
assert!(prepare_socket(&socket, owner).is_err());
|
||||
}
|
||||
|
||||
#[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());
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,11 @@
|
||||
mod cli;
|
||||
#[cfg(unix)]
|
||||
mod credential_lease;
|
||||
#[cfg(debug_assertions)]
|
||||
mod dev_bootstrap;
|
||||
mod handlers;
|
||||
#[cfg(target_os = "macos")]
|
||||
mod macos_broker;
|
||||
mod request_dispatcher;
|
||||
mod routes;
|
||||
mod session_registry;
|
||||
|
||||
@@ -29,6 +29,8 @@ pub struct RequestDispatcher {
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
redaction: Arc<Redaction>,
|
||||
install_lock: Mutex<()>,
|
||||
gui_management_enabled: bool,
|
||||
brokered_helpers_dir: Option<std::path::PathBuf>,
|
||||
}
|
||||
|
||||
impl RequestDispatcher {
|
||||
@@ -36,33 +38,49 @@ impl RequestDispatcher {
|
||||
ws_req_tx: mpsc::Sender<WsRequest>,
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
redaction: Arc<Redaction>,
|
||||
gui_management_enabled: bool,
|
||||
brokered_helpers_dir: Option<std::path::PathBuf>,
|
||||
) -> Self {
|
||||
Self {
|
||||
ws_req_tx,
|
||||
gui_restart_requested,
|
||||
redaction,
|
||||
install_lock: Mutex::new(()),
|
||||
gui_management_enabled,
|
||||
brokered_helpers_dir,
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn dispatch(&self, request: WsRequest) -> ServiceResult {
|
||||
match request {
|
||||
WsRequest::RestartGui => {
|
||||
if !self.gui_management_enabled {
|
||||
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "GUI restart is unavailable on macOS");
|
||||
}
|
||||
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,
|
||||
WsRequest::UpdateGui(request) => {
|
||||
if !self.gui_management_enabled {
|
||||
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "GUI update is unavailable on macOS");
|
||||
}
|
||||
self.update_gui(request).await
|
||||
}
|
||||
request => {
|
||||
if let WsRequest::Connect(ref connect) = request
|
||||
&& let Err(err) = self
|
||||
if let WsRequest::Connect(ref connect) = request {
|
||||
if let Err(message) = self.validate_connect_paths(connect) {
|
||||
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message);
|
||||
}
|
||||
if 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");
|
||||
{
|
||||
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) {
|
||||
@@ -78,6 +96,24 @@ impl RequestDispatcher {
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
|
||||
let Some(helpers) = &self.brokered_helpers_dir else {
|
||||
return Ok(());
|
||||
};
|
||||
let expected_script = helpers.join("vpnc-script").to_string_lossy().into_owned();
|
||||
let expected_wrapper = helpers.join("hipreport.sh").to_string_lossy().into_owned();
|
||||
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
|
||||
return Err("macOS VPN script must be the bundled script");
|
||||
}
|
||||
if request.args().csd_wrapper().as_deref() != Some(expected_wrapper.as_str()) {
|
||||
return Err("macOS HIP wrapper must be the bundled wrapper");
|
||||
}
|
||||
if request.args().certificate().is_some() || request.args().sslkey().is_some() {
|
||||
return Err("macOS client identity must be provided as protected data, not root-readable paths");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult {
|
||||
let _install = self.install_lock.lock().await;
|
||||
let path = request.path;
|
||||
@@ -210,6 +246,13 @@ fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<N
|
||||
mod tests {
|
||||
use std::io::Cursor;
|
||||
|
||||
use gpapi::{
|
||||
gateway::Gateway,
|
||||
service::{
|
||||
request::ConnectRequest,
|
||||
transport::{ServiceErrorCode, ServiceResult},
|
||||
},
|
||||
};
|
||||
use tar::{Builder, EntryType, Header};
|
||||
|
||||
use super::*;
|
||||
@@ -277,4 +320,31 @@ mod tests {
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path()).is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn brokered_mode_rejects_gui_management_and_root_readable_identity_paths() {
|
||||
let (request_tx, _request_rx) = mpsc::channel(1);
|
||||
let dispatcher = RequestDispatcher::new(
|
||||
request_tx,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
false,
|
||||
Some(std::path::PathBuf::from("/app/Contents/Helpers")),
|
||||
);
|
||||
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else {
|
||||
panic!("brokered mode accepted GUI restart");
|
||||
};
|
||||
assert_eq!(rejection.code(), ServiceErrorCode::InvalidRequest);
|
||||
|
||||
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
|
||||
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
|
||||
let request = ConnectRequest::new(info, "cookie".into())
|
||||
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()))
|
||||
.with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string()))
|
||||
.with_certificate(Some("/Users/example/client.pem".to_string()));
|
||||
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
|
||||
panic!("brokered mode accepted a root-readable identity path");
|
||||
};
|
||||
assert_eq!(rejection.code(), ServiceErrorCode::InvalidRequest);
|
||||
}
|
||||
}
|
||||
@@ -107,6 +107,22 @@ impl SessionRegistry {
|
||||
Ok(credential)
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
let Ok(mut sessions) = self.sessions.lock() else {
|
||||
return false;
|
||||
};
|
||||
let now = Instant::now();
|
||||
sessions.retain(|_, record| {
|
||||
!matches!(
|
||||
record.status,
|
||||
SessionStatus::Pending {
|
||||
activation_deadline, ..
|
||||
} if now > activation_deadline
|
||||
)
|
||||
});
|
||||
sessions.is_empty()
|
||||
}
|
||||
|
||||
pub fn begin_handshake(
|
||||
self: &Arc<Self>,
|
||||
service_instance_id: Uuid,
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
use std::{sync::Arc, thread};
|
||||
use std::{io::Write, os::unix::fs::PermissionsExt, sync::Arc, thread};
|
||||
|
||||
use gpapi::{
|
||||
logger,
|
||||
service::{
|
||||
request::{ConnectRequest, UpdateLogLevelRequest, WsRequest},
|
||||
request::{ConnectRequest, MAX_CLIENT_IDENTITY_DATA, UpdateLogLevelRequest, WsRequest},
|
||||
vpn_state::{ConnectedInfo, VpnState},
|
||||
},
|
||||
session::{SessionInfo, SessionWarning},
|
||||
@@ -12,19 +12,24 @@ use log::{info, warn};
|
||||
use openconnect::Vpn;
|
||||
use tokio::sync::{RwLock, mpsc, oneshot, watch};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
pub(crate) struct VpnTaskContext {
|
||||
vpn_handle: Arc<RwLock<Option<Vpn>>>,
|
||||
vpn_state_tx: Arc<watch::Sender<VpnState>>,
|
||||
disconnect_rx: RwLock<Option<oneshot::Receiver<()>>>,
|
||||
brokered_macos: bool,
|
||||
identity_files: Arc<RwLock<Vec<tempfile::NamedTempFile>>>,
|
||||
}
|
||||
|
||||
impl VpnTaskContext {
|
||||
pub fn new(vpn_state_tx: watch::Sender<VpnState>) -> Self {
|
||||
pub fn new(vpn_state_tx: watch::Sender<VpnState>, brokered_macos: bool) -> Self {
|
||||
Self {
|
||||
vpn_handle: Default::default(),
|
||||
vpn_state_tx: Arc::new(vpn_state_tx),
|
||||
disconnect_rx: Default::default(),
|
||||
brokered_macos,
|
||||
identity_files: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -39,6 +44,14 @@ impl VpnTaskContext {
|
||||
let info = req.info().clone();
|
||||
let vpn_handle = Arc::clone(&self.vpn_handle);
|
||||
let args = req.args();
|
||||
let identity = match prepare_identity(args, self.brokered_macos) {
|
||||
Ok(identity) => identity,
|
||||
Err(err) => {
|
||||
warn!("Failed to prepare client identity: {err}");
|
||||
vpn_state_tx.send(VpnState::Disconnected).ok();
|
||||
return;
|
||||
}
|
||||
};
|
||||
let allow_extend_session = args.allow_extend_session();
|
||||
let vpn = match Vpn::builder(req.gateway().server(), args.cookie())
|
||||
.script(args.vpnc_script())
|
||||
@@ -47,8 +60,8 @@ impl VpnTaskContext {
|
||||
.os_version(args.os_version())
|
||||
.client_version(args.client_version())
|
||||
.host_id(args.host_id())
|
||||
.certificate(args.certificate())
|
||||
.sslkey(args.sslkey())
|
||||
.certificate(identity.certificate.clone())
|
||||
.sslkey(identity.sslkey.clone())
|
||||
.key_password(args.key_password())
|
||||
.hip(args.hip())
|
||||
.csd_uid(args.csd_uid())
|
||||
@@ -72,11 +85,13 @@ impl VpnTaskContext {
|
||||
|
||||
// Save the VPN handle
|
||||
vpn_handle.write().await.replace(vpn);
|
||||
*self.identity_files.write().await = identity.files;
|
||||
let connect_info = Box::new(info.clone());
|
||||
vpn_state_tx.send(VpnState::Connecting(connect_info)).ok();
|
||||
|
||||
let (disconnect_tx, disconnect_rx) = oneshot::channel::<()>();
|
||||
self.disconnect_rx.write().await.replace(disconnect_rx);
|
||||
let identity_files = Arc::clone(&self.identity_files);
|
||||
|
||||
// Spawn a new thread to process the VPN connection, cannot use tokio::spawn here.
|
||||
// Otherwise, it will block the tokio runtime and cannot send the VPN state to the channel
|
||||
@@ -104,6 +119,7 @@ impl VpnTaskContext {
|
||||
vpn_state_tx_clone.send(VpnState::Disconnected).ok();
|
||||
// Remove the VPN handle
|
||||
vpn_handle.blocking_write().take();
|
||||
identity_files.blocking_write().clear();
|
||||
|
||||
disconnect_tx.send(()).ok();
|
||||
});
|
||||
@@ -137,8 +153,12 @@ pub(crate) struct VpnTask {
|
||||
}
|
||||
|
||||
impl VpnTask {
|
||||
pub fn new(ws_req_rx: mpsc::Receiver<WsRequest>, vpn_state_tx: watch::Sender<VpnState>) -> Self {
|
||||
let ctx = Arc::new(VpnTaskContext::new(vpn_state_tx));
|
||||
pub fn new(
|
||||
ws_req_rx: mpsc::Receiver<WsRequest>,
|
||||
vpn_state_tx: watch::Sender<VpnState>,
|
||||
brokered_macos: bool,
|
||||
) -> Self {
|
||||
let ctx = Arc::new(VpnTaskContext::new(vpn_state_tx, brokered_macos));
|
||||
let cancel_token = CancellationToken::new();
|
||||
|
||||
Self {
|
||||
@@ -179,6 +199,55 @@ impl VpnTask {
|
||||
}
|
||||
}
|
||||
|
||||
struct PreparedIdentity {
|
||||
certificate: Option<String>,
|
||||
sslkey: Option<String>,
|
||||
files: Vec<tempfile::NamedTempFile>,
|
||||
}
|
||||
|
||||
fn prepare_identity(
|
||||
args: &gpapi::service::request::ConnectArgs,
|
||||
brokered_macos: bool,
|
||||
) -> anyhow::Result<PreparedIdentity> {
|
||||
if !brokered_macos {
|
||||
return Ok(PreparedIdentity {
|
||||
certificate: args.certificate(),
|
||||
sslkey: args.sslkey(),
|
||||
files: vec![],
|
||||
});
|
||||
}
|
||||
|
||||
let certificate = args.certificate_data()?.map(Zeroizing::new);
|
||||
let sslkey = args.sslkey_data()?.map(Zeroizing::new);
|
||||
let total_size = certificate.as_ref().map_or(0, |data| data.len()) + sslkey.as_ref().map_or(0, |data| data.len());
|
||||
if total_size > MAX_CLIENT_IDENTITY_DATA {
|
||||
anyhow::bail!("Client certificate and key exceed the macOS size limit");
|
||||
}
|
||||
|
||||
let mut files = Vec::new();
|
||||
let certificate = write_identity_file(certificate, &mut files)?;
|
||||
let sslkey = write_identity_file(sslkey, &mut files)?;
|
||||
Ok(PreparedIdentity {
|
||||
certificate,
|
||||
sslkey,
|
||||
files,
|
||||
})
|
||||
}
|
||||
|
||||
fn write_identity_file(
|
||||
data: Option<Zeroizing<Vec<u8>>>,
|
||||
files: &mut Vec<tempfile::NamedTempFile>,
|
||||
) -> anyhow::Result<Option<String>> {
|
||||
let Some(data) = data else { return Ok(None) };
|
||||
let mut file = tempfile::NamedTempFile::new_in("/var/run/com.yuezk.gpgui")?;
|
||||
file.as_file().set_permissions(std::fs::Permissions::from_mode(0o600))?;
|
||||
file.write_all(&data)?;
|
||||
file.flush()?;
|
||||
let path = file.path().to_string_lossy().into_owned();
|
||||
files.push(file);
|
||||
Ok(Some(path))
|
||||
}
|
||||
|
||||
async fn process_ws_req(req: WsRequest, ctx: Arc<VpnTaskContext>) {
|
||||
match req {
|
||||
WsRequest::Connect(req) => {
|
||||
|
||||
@@ -413,6 +413,8 @@ mod tests {
|
||||
request_tx,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
|
||||
@@ -295,6 +295,8 @@ mod tests {
|
||||
request_tx,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
@@ -344,6 +346,8 @@ mod tests {
|
||||
request_tx,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
|
||||
Reference in new issue
Block a user