mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
220 lines
6.9 KiB
Rust
220 lines
6.9 KiB
Rust
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::net::{UnixListener, UnixStream};
|
|
use tokio_util::sync::CancellationToken;
|
|
|
|
use crate::{credential_lease, 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) = credential_lease::serve(stream, registry, Some(self.allowed_uid)).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)
|
|
}
|
|
|
|
#[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(credential_lease::serve(service, Arc::clone(®istry), Some(1234)));
|
|
|
|
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());
|
|
}
|
|
}
|