Compare commits

..
12 Commits
Author SHA1 Message Date
Kodiak FiresmithandKevin Yue 754b220a9d fix(gpclient): keep cookie cache when the cached login gets no answer (#712)
* fix(gpclient): keep cookie cache when the cached login gets no answer

A connect or timeout error during the cached gateway login or cached portal
discovery deleted the --cookie-cache file and fell back to SAML, although the
server never rejected the cookie. Keep the cache and return the error for
unanswered requests; only clear it when the server responds.

* fix(gpclient): preserve cached cookies for all failed requests

---------

Co-authored-by: Kevin Yue <[email protected]>
2026-11-17 13:56:19 +08:00
Kevin Yue 1072a35817 ci: publish only Windows installers and their verification files (#711) 2026-11-15 10:26:35 +08:00
Kevin Yue a43785792a fix(ci): retain the verified Unix build during macOS retry promotion (#710) 2026-11-15 09:21:23 +08:00
Kevin Yue 76310f1494 fix(ci): wait for Windows update feed propagation (#709) 2026-11-15 03:05:54 +08:00
Kevin Yue 029f292a6d fix(ci): identify the release feed publisher in HTTP requests (#708) 2026-11-15 02:56:43 +08:00
Kevin Yue dedd06366e ci: build native Windows ARM64 packages and publish paired updates (#707) 2026-11-15 02:34:19 +08:00
Kevin Yue 5031d4dcfb Merge pull request #706 from yuezk/ci/windows-source-line-endings
build: preserve LF source endings across platforms
2026-11-14 23:46:15 +08:00
Kevin Yue 1ac01081e0 build: express source line endings through Git attributes 2026-11-14 23:44:47 +08:00
Kevin Yue 594ab0ea32 ci: preserve LF endings for native Windows build inputs 2026-11-14 23:43:04 +08:00
Kevin Yue e2e762dd35 Merge pull request #705 from yuezk/ci/windows-package-release
ci: release Windows NSH packages and verified updates
2026-11-14 23:39:11 +08:00
Kevin Yue 9432f0c3e5 fix: use pinned installer package and isolate feed preservation 2026-11-14 23:38:27 +08:00
Kevin Yue fdbe3bcbba ci: add Windows package builds and verified update publication 2026-11-14 23:14:20 +08:00
109 changed files with 972 additions and 6697 deletions

No files matched your search

Generated
+1 -70
View File
@@ -297,8 +297,6 @@ dependencies = [
"anyhow",
"block2",
"browser-launcher",
"common",
"dunce",
"gpapi",
"gtk",
"html-escape",
@@ -309,7 +307,6 @@ dependencies = [
"objc2-security",
"objc2-web-kit",
"regex",
"serde_json",
"tauri",
"tempfile",
"tiny_http",
@@ -319,9 +316,6 @@ dependencies = [
"uuid",
"uzers",
"webkit2gtk",
"webview2-com",
"windows",
"winreg 0.55.0",
]
[[package]]
@@ -560,7 +554,6 @@ dependencies = [
"open",
"webbrowser",
"which",
"winreg 0.55.0",
]
[[package]]
@@ -1558,7 +1551,7 @@ dependencies = [
"rustc_version",
"toml 1.1.8+spec-1.1.0",
"vswhom",
"winreg 0.56.0",
"winreg",
]
[[package]]
@@ -1662,16 +1655,6 @@ dependencies = [
"rustc_version",
]
[[package]]
name = "file-rotate"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e8e2fa049328a1f3295991407a88585805d126dfaadf74b9fe8c194c730aafc"
dependencies = [
"chrono",
"flate2",
]
[[package]]
name = "filedescriptor"
version = "0.8.3"
@@ -2186,7 +2169,6 @@ dependencies = [
"uuid",
"uzers",
"whoami",
"windows-sys 0.61.2",
"x509-cert",
"xmltree",
"zeroize",
@@ -2291,7 +2273,6 @@ dependencies = [
"common",
"compile-time",
"env_logger",
"file-rotate",
"futures",
"getrandom 0.4.3",
"gpapi",
@@ -2312,8 +2293,6 @@ dependencies = [
"tokio-tungstenite 0.30.0",
"tokio-util",
"uuid",
"windows-service",
"windows-sys 0.61.2",
"xz2",
"zeroize",
]
@@ -2334,15 +2313,7 @@ dependencies = [
name = "gpvpnc"
version = "3.4.0"
dependencies = [
"base64 0.23.1",
"ipnet",
"log",
"serde",
"serde_json",
"tempfile",
"uuid",
"windows-sys 0.61.2",
"winreg 0.56.0",
]
[[package]]
@@ -2844,9 +2815,6 @@ name = "ipnet"
version = "2.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0"
dependencies = [
"serde",
]
[[package]]
name = "is-docker"
@@ -3867,7 +3835,6 @@ dependencies = [
"log",
"pkg-config",
"tempfile",
"windows-sys 0.61.2",
]
[[package]]
@@ -6763,12 +6730,6 @@ dependencies = [
"web-sys",
]
[[package]]
name = "widestring"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
[[package]]
name = "winapi"
version = "0.3.9"
@@ -6919,17 +6880,6 @@ dependencies = [
"windows-link",
]
[[package]]
name = "windows-service"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "857224b3b211c6f3616921f081ee54721ee3ad2ace2fac6a6337e032f7b4dcf2"
dependencies = [
"bitflags 2.13.2",
"widestring",
"windows-sys 0.61.2",
]
[[package]]
name = "windows-strings"
version = "0.5.1"
@@ -6957,15 +6907,6 @@ dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.61.2"
@@ -7132,16 +7073,6 @@ dependencies = [
"memchr",
]
[[package]]
name = "winreg"
version = "0.55.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
dependencies = [
"cfg-if",
"windows-sys 0.59.0",
]
[[package]]
name = "winreg"
version = "0.56.0"
-3
View File
@@ -16,9 +16,6 @@ fn main() {
resolve_commit(&repo_root, &source_commit)
);
#[cfg(all(windows, feature = "webview-auth"))]
println!("cargo:rerun-if-changed=icons/windows/icon.ico");
#[cfg(feature = "webview-auth")]
tauri_build::build()
}
Binary file not shown.

Before

Width:  |  Height:  |  Size: 47 KiB

+6 -6
View File
@@ -1,8 +1,8 @@
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use auth::forward_auth_callback;
use auth::{BrowserAuthenticator, auth_prelogin};
use clap::Parser;
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use clap::Subcommand;
#[cfg(feature = "webview-auth")]
use gpapi::auth::AuthWindowTheme;
@@ -49,7 +49,7 @@ See 'gpauth -h' for more information.
"
)]
struct Cli {
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[command(subcommand)]
command: Option<CliCommand>,
@@ -134,7 +134,7 @@ struct Cli {
verbose: InfoLevelVerbosity,
}
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[derive(Subcommand)]
enum CliCommand {
#[command(hide = true)]
@@ -272,7 +272,7 @@ fn init_logger(cli: &Cli) {
pub async fn run() {
let cli = Cli::parse();
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
if let Some(CliCommand::AuthCallback { callback }) = &cli.command {
if let Err(err) = forward_auth_callback(callback).await {
eprintln!("Failed to forward authentication callback: {err}");
@@ -382,7 +382,7 @@ mod tests {
}
#[test]
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn callback_arguments_parse_separately() {
let cli = Cli::try_parse_from([
"gpauth",
-5
View File
@@ -1,5 +0,0 @@
{
"bundle": {
"icon": ["icons/windows/icon.ico"]
}
}
-29
View File
@@ -1,29 +0,0 @@
#![cfg(windows)]
use auth::AuthCallbackReceiver;
use std::{process::Stdio, time::Duration};
#[tokio::test]
async fn callback_command_forwards_between_processes() {
let receiver = AuthCallbackReceiver::bind().unwrap();
let child = tokio::process::Command::new(env!("CARGO_BIN_EXE_gpauth"))
.args([
"auth-callback",
"globalprotectcallback:cas-as=1&un=windows-fixture&token=callback-command-test",
])
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true)
.spawn()
.unwrap();
let (data, output) = tokio::time::timeout(Duration::from_secs(10), async {
tokio::join!(receiver.receive(), child.wait_with_output())
})
.await
.expect("callback executable did not complete");
let output = output.unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
let data = data.unwrap();
assert_eq!(data.username(), "windows-fixture");
assert_eq!(data.token(), Some("callback-command-test"));
}
+154 -19
View File
@@ -36,6 +36,27 @@ fn login_response() -> String {
)
}
async fn read_request(stream: &mut tokio::net::TcpStream) -> String {
let mut request = Vec::new();
loop {
let mut buf = [0; 4096];
let count = stream.read(&mut buf).await.unwrap();
assert_ne!(count, 0, "Request ended before its body");
request.extend_from_slice(&buf[..count]);
if let Some(end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
let headers = String::from_utf8_lossy(&request[..end]).to_ascii_lowercase();
let length = headers
.lines()
.find_map(|line| line.strip_prefix("content-length:"))
.map(|value| value.trim().parse::<usize>().unwrap())
.unwrap_or(0);
if request.len() >= end + 4 + length {
return String::from_utf8(request).unwrap();
}
}
}
}
async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task::JoinHandle<Vec<String>>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
@@ -44,25 +65,7 @@ async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task
let mut requests = Vec::new();
for (status, body) in responses {
let (mut stream, _) = listener.accept().await.unwrap();
let mut request = Vec::new();
loop {
let mut buf = [0; 4096];
let count = stream.read(&mut buf).await.unwrap();
assert_ne!(count, 0, "Request ended before its body");
request.extend_from_slice(&buf[..count]);
if let Some(end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
let headers = String::from_utf8_lossy(&request[..end]).to_ascii_lowercase();
let length = headers
.lines()
.find_map(|line| line.strip_prefix("content-length:"))
.map(|value| value.trim().parse::<usize>().unwrap())
.unwrap_or(0);
if request.len() >= end + 4 + length {
break;
}
}
}
requests.push(String::from_utf8(request).unwrap());
requests.push(read_request(&mut stream).await);
stream
.write_all(
format!(
@@ -126,6 +129,138 @@ async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
);
}
#[tokio::test]
async fn unreachable_gateway_keeps_cached_cookie() {
// Nothing listens here: the cached gateway login gets no answer at all.
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let gateway = format!("http://{}", listener.local_addr().unwrap());
drop(listener);
let directory = tempfile::tempdir().unwrap();
let cache = directory.path().join("cookie.json");
let args = TestArgs::parse_from([
"test",
"http://unavailable-portal.invalid",
"--cookie-only",
"--cookie-cache",
cache.to_str().unwrap(),
])
.connect;
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
cookie_store::save(
&cache,
&StoredCookie::new(
args.server.clone(),
"alice".into(),
handler.os_profile.borrow().host_identity().host_id().into(),
gateway,
AuthCookieCredential::new("alice", "portal-cookie", ""),
),
)
.unwrap();
assert!(handler.handle_impl().await.is_err());
assert!(
cache.exists(),
"a login that got no answer must not delete the cookie cache"
);
}
#[tokio::test]
async fn gateway_closing_without_response_keeps_cached_cookie() {
closed_connection_keeps_cached_cookie(false).await;
}
#[tokio::test]
async fn portal_closing_without_response_keeps_cached_cookie() {
closed_connection_keeps_cached_cookie(true).await;
}
async fn closed_connection_keeps_cached_cookie(portal_discovery: bool) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
let worker = tokio::spawn(async move {
tokio::time::timeout(Duration::from_secs(5), async move {
if portal_discovery {
let (mut stream, _) = listener.accept().await.unwrap();
assert!(read_request(&mut stream).await.contains("/global-protect/prelogin.esp"));
let body = "<prelogin-response><status>Success</status></prelogin-response>";
stream
.write_all(
format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.as_bytes(),
)
.await
.unwrap();
}
let (mut stream, _) = listener.accept().await.unwrap();
// Read the complete request, then close without sending HTTP headers.
read_request(&mut stream).await
})
.await
.expect("Connection-closing fixture timed out")
});
let directory = tempfile::tempdir().unwrap();
let cache = directory.path().join("cookie.json");
let args = TestArgs::parse_from([
"test",
&origin,
"--cookie-only",
"--cookie-cache",
cache.to_str().unwrap(),
])
.connect;
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
cookie_store::save(
&cache,
&StoredCookie::new(
args.server.clone(),
"alice".into(),
handler.os_profile.borrow().host_identity().host_id().into(),
origin.clone(),
AuthCookieCredential::new("alice", "portal-cookie", ""),
),
)
.unwrap();
let result = if portal_discovery {
handler.connect_portal_with_prelogin(&origin).await
} else {
handler.handle_impl().await
};
let error = result.unwrap_err();
let Some(gpapi::error::PortalError::NetworkError(network)) = error.downcast_ref() else {
panic!("Expected a network error, got {error:?}");
};
assert!(network.is_request());
assert!(!network.is_connect());
assert!(!network.is_timeout());
assert!(cache.exists(), "an unanswered request must not delete the cookie cache");
let request = worker.await.unwrap();
assert!(request.contains("portal-cookie"));
if portal_discovery {
assert!(request.starts_with("POST /global-protect/getconfig.esp "));
} else {
assert!(request.starts_with("POST /ssl-vpn/login.esp "));
}
}
#[tokio::test]
async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_rejection() {
let (origin, worker) = gateway(vec![
+13
View File
@@ -101,6 +101,11 @@ impl ConnectHandler<'_> {
{
return Some(Err(error));
}
// A failed request does not establish that the cookie was rejected.
if is_network_error(&error) {
warn!("Cached gateway authentication request failed: {error}");
return Some(Err(error));
}
cookie_store::clear(&path);
warn!("Cached gateway authentication failed: {error}");
return None;
@@ -830,3 +835,11 @@ mod tests {
);
}
}
/// A failed request says nothing about whether a cached cookie is still valid.
pub(super) fn is_network_error(error: &anyhow::Error) -> bool {
matches!(
error.downcast_ref::<gpapi::error::PortalError>(),
Some(gpapi::error::PortalError::NetworkError(_))
)
}
+5
View File
@@ -292,6 +292,11 @@ impl<'a> ConnectHandler<'a> {
Ok(config) => Some((cred, config)),
Err(error) => {
self.check_cancelled()?;
// A failed request does not establish that the cookie was rejected.
if gateway::is_network_error(&error) {
warn!("Cached portal authentication request failed: {error}");
return Err(error);
}
warn!("Cached portal authentication failed: {error}");
self.clear_cookie_cache();
None
+2 -12
View File
@@ -30,24 +30,14 @@ uuid = { workspace = true, features = ["v4"] }
zeroize.workspace = true
tempfile.workspace = true
getrandom = "0.4"
mac_address = "1.2.1"
[target.'cfg(unix)'.dependencies]
nix = { version = "0.31", features = ["fs", "socket", "user"] }
[target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
mac_address = "1.2.1"
[target.'cfg(unix)'.dev-dependencies]
mac_address = "1.2.1"
[dev-dependencies]
openssl.workspace = true
tokio-tungstenite.workspace = true
[target.'cfg(any(target_os = "macos", windows))'.dependencies]
[target.'cfg(target_os = "macos")'.dependencies]
gpvpnc = { path = "../../crates/gpvpnc" }
[target.'cfg(windows)'.dependencies]
file-rotate = "0.8.0"
windows-service = "0.8.1"
windows-sys = { version = "0.61", features = ["Win32_System_Pipes"] }
+10 -3
View File
@@ -6,7 +6,7 @@ use std::time::Duration;
use anyhow::{Context, bail};
use clap::Parser;
use common::paths::service_lock_file;
use common::constants::GP_SERVICE_LOCK_FILE;
use gpapi::clap::InfoLevelVerbosity;
use gpapi::logger;
#[cfg(debug_assertions)]
@@ -25,7 +25,14 @@ use crate::{
request_dispatcher::RequestDispatcher, session_registry::SessionRegistry, vpn_task::VpnTask, ws_server::WsServer,
};
use crate::VERSION;
const VERSION: &str = concat!(
env!("CARGO_PKG_VERSION"),
" (",
env!("GPSERVICE_GIT_COMMIT"),
" ",
compile_time::date_str!(),
")"
);
#[cfg(target_os = "macos")]
struct RedactingMacosLogger {
@@ -264,7 +271,7 @@ impl Cli {
return Ok(dev_service_lock_file_path(socket));
}
Ok(service_lock_file())
Ok(PathBuf::from(GP_SERVICE_LOCK_FILE))
}
fn init_logger(&self) -> Arc<Redaction> {
-12
View File
@@ -1,12 +0,0 @@
use clap::Parser;
use gpapi::clap::InfoLevelVerbosity;
#[derive(Parser)]
#[command(version = crate::VERSION)]
struct Cli {
#[command(flatten)]
verbose: InfoLevelVerbosity,
}
pub fn run() -> anyhow::Result<()> {
let cli = Cli::parse();
crate::windows_service::dispatch(cli.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info))
}
+5 -2
View File
@@ -75,7 +75,7 @@ impl DesktopClient {
loop {
match self.read_control().await? {
Some(DESKTOP_GUI_INSTALLER) => {
self.write_all(&[u8::from(crate::gui_installation::installer().is_some())]).await?;
self.write_all(&[u8::from(crate::request_dispatcher::gui_installer().is_some())]).await?;
}
Some(DESKTOP_SWITCH_BEGIN) => {
ensure!(pending.is_none(), "A GUI switch is already pending");
@@ -299,7 +299,10 @@ mod tests {
let mut reader = reader;
let mut capability = [0];
reader.read_exact(&mut capability).unwrap();
assert_eq!(capability[0], u8::from(crate::gui_installation::installer().is_some()));
assert_eq!(
capability[0],
u8::from(crate::request_dispatcher::gui_installer().is_some())
);
reader
})
.await
+1 -1
View File
@@ -366,7 +366,7 @@ mod tests {
r#"{"version":1,"anchor":{"hardware_id":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","source":1}}"#
);
for source in [0, u8::MAX] {
for source in [0, 4] {
let json = serde_json::json!({
"version": 1,
"anchor": {
-359
View File
@@ -1,359 +0,0 @@
use gpapi::utils::checksum::verify_checksum;
use std::{
fs::{self, File, OpenOptions, Permissions},
io::{BufReader, Read, Write},
os::unix::fs::{OpenOptionsExt, PermissionsExt},
path::Path,
};
use tar::Archive;
use tempfile::NamedTempFile;
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;
#[derive(Debug)]
pub(crate) enum InstallError {
Checksum(anyhow::Error),
Install(anyhow::Error),
}
pub(crate) fn installer() -> Option<std::path::PathBuf> {
std::env::current_exe()
.ok()
.and_then(|executable| {
executable
.parent()?
.parent()
.map(|prefix| prefix.join("libexec/gpclient/gp-gui-installer"))
})
.filter(|path| path.is_file())
}
pub(crate) fn install(src: &Path, checksum: &str, target: &Path) -> Result<(), InstallError> {
let installer = installer();
install_gui_with_installer(src, checksum, target, installer.as_deref())
}
fn install_gui_with_installer(
src: &Path,
checksum: &str,
target: &Path,
installer: Option<&Path>,
) -> Result<(), InstallError> {
let Some(dir) = target.parent() else {
return Err(InstallError::Install(anyhow::anyhow!(
"Failed to get parent directory of GUI binary"
)));
};
fs::create_dir_all(dir).map_err(|err| InstallError::Install(err.into()))?;
let staged_archive = stage_gui_archive(src, dir)?;
let archive_path = staged_archive.path().to_string_lossy();
verify_checksum(&archive_path, checksum).map_err(InstallError::Checksum)?;
// A package may need to prepare downloaded executables for its runtime.
// Resolve this helper beside the running service, never from the request or PATH.
if let Some(installer) = installer {
let status = std::process::Command::new(installer)
.arg(staged_archive.path())
.arg(checksum)
.arg(target)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.status()
.map_err(|err| InstallError::Install(err.into()))?;
return if status.success() {
Ok(())
} else {
Err(InstallError::Install(anyhow::anyhow!(
"GUI package installation failed: {status}"
)))
};
}
let tar = XzDecoder::new(BufReader::new(
staged_archive
.reopen()
.map_err(|err| InstallError::Install(err.into()))?,
))
.take(MAX_GUI_ARCHIVE_CONTENT_SIZE);
let mut archive = Archive::new(tar);
let binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
file
.as_file()
.set_permissions(Permissions::from_mode(0o755))
.map_err(|err| InstallError::Install(err.into()))?;
file
.as_file()
.sync_all()
.map_err(|err| InstallError::Install(err.into()))?;
file.persist(&target).map_err(|err| InstallError::Install(err.into()))?;
File::open(dir)
.and_then(|directory| directory.sync_all())
.map_err(|err| InstallError::Install(err.into()))?;
Ok(())
}
fn stage_gui_archive(src: &Path, dir: &Path) -> Result<NamedTempFile, InstallError> {
let mut source = OpenOptions::new()
.read(true)
.custom_flags(nix::libc::O_NONBLOCK | nix::libc::O_NOFOLLOW)
.open(src)
.map_err(|err| InstallError::Install(err.into()))?;
let metadata = source.metadata().map_err(|err| InstallError::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(InstallError::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| InstallError::Install(err.into()))?;
let copied = std::io::copy(&mut (&mut source).take(MAX_GUI_ARCHIVE_SIZE + 1), &mut staged)
.map_err(|err| InstallError::Install(err.into()))?;
if copied != source_size {
return Err(InstallError::Install(anyhow::anyhow!(
"GUI update archive changed while it was being read"
)));
}
staged.flush().map_err(|err| InstallError::Install(err.into()))?;
staged
.as_file()
.sync_all()
.map_err(|err| InstallError::Install(err.into()))?;
Ok(staged)
}
fn extract_gui_binary<R: Read>(
archive: &mut Archive<R>,
dir: &Path,
binary_name: &str,
) -> Result<NamedTempFile, InstallError> {
for entry in archive.entries().map_err(|err| InstallError::Install(err.into()))? {
let mut entry = entry.map_err(|err| InstallError::Install(err.into()))?;
let is_gui = entry
.path()
.map_err(|err| InstallError::Install(err.into()))?
.file_name()
.is_some_and(|name| name == binary_name);
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(InstallError::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| InstallError::Install(err.into()))?;
let copied = std::io::copy(&mut entry, &mut file).map_err(|err| InstallError::Install(err.into()))?;
if copied != declared_size {
return Err(InstallError::Install(anyhow::anyhow!(
"GUI binary size does not match its archive header"
)));
}
file.flush().map_err(|err| InstallError::Install(err.into()))?;
return Ok(file);
}
}
Err(InstallError::Install(anyhow::anyhow!(
"GUI update archive does not contain a non-empty regular {binary_name} file"
)))
}
#[cfg(test)]
mod tests {
use std::{io::Cursor, os::unix::fs::PermissionsExt};
use tar::{Builder, EntryType, Header};
use xz2::write::XzEncoder;
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
}
fn compressed_gui_archive(contents: &[u8]) -> NamedTempFile {
let tar = archive_with_entry(EntryType::Regular, contents);
let mut encoder = XzEncoder::new(Vec::new(), 6);
encoder.write_all(&tar).unwrap();
let compressed = encoder.finish().unwrap();
let mut archive = NamedTempFile::new().unwrap();
archive.write_all(&compressed).unwrap();
archive.flush().unwrap();
archive
}
#[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(), "gpgui").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(), "gpgui").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(), "gpgui").is_err());
}
#[test]
fn installs_gui_at_the_supplied_target() {
let archive = compressed_gui_archive(b"gui binary");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpclient/gpgui");
install(archive.path(), &checksum, &target).unwrap();
assert_eq!(std::fs::read(&target).unwrap(), b"gui binary");
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
}
#[test]
fn installs_nsh_beside_tauri_without_replacing_it() {
let output = tempfile::tempdir().unwrap();
let tauri = output.path().join("gpgui");
std::fs::write(&tauri, b"tauri").unwrap();
let mut encoder = XzEncoder::new(Vec::new(), 1);
{
let mut archive = Builder::new(&mut encoder);
let mut header = Header::new_gnu();
header.set_size(3);
header.set_mode(0o755);
header.set_cksum();
archive
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
.unwrap();
archive.finish().unwrap();
}
let mut archive = NamedTempFile::new().unwrap();
archive.write_all(&encoder.finish().unwrap()).unwrap();
archive.flush().unwrap();
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let nsh = output.path().join("gpgui-nsh");
install(archive.path(), &checksum, &nsh).unwrap();
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
}
#[test]
fn checksum_failure_preserves_the_existing_gui() {
let archive = compressed_gui_archive(b"replacement");
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpclient/gpgui");
std::fs::create_dir_all(target.parent().unwrap()).unwrap();
std::fs::write(&target, b"existing").unwrap();
assert!(install(archive.path(), "invalid", &target).is_err());
assert_eq!(std::fs::read(target).unwrap(), b"existing");
}
#[test]
fn package_installer_receives_a_verified_staged_archive() {
let archive = compressed_gui_archive(b"gui binary");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpgui-nsh");
let installer = output.path().join("installer");
std::fs::write(
&installer,
"#!/bin/sh\nset -eu\ntest -f \"$1\"\nprintf '%s' \"$2\" > \"$3\"\n",
)
.unwrap();
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
assert!(install_gui_with_installer(archive.path(), "invalid", &target, Some(&installer)).is_err());
assert!(!target.exists());
install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).unwrap();
assert_eq!(std::fs::read_to_string(target).unwrap(), checksum);
}
#[test]
fn package_installation_failure_preserves_the_existing_gui() {
let archive = compressed_gui_archive(b"replacement");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpgui");
std::fs::write(&target, b"existing").unwrap();
let installer = output.path().join("installer");
std::fs::write(&installer, "#!/bin/sh\nexit 1\n").unwrap();
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
assert!(install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).is_err());
assert_eq!(std::fs::read(target).unwrap(), b"existing");
}
#[test]
#[ignore = "requires GP_TEST_GUI_BINARY pointing to a built gpgui"]
fn installs_single_gui_binary_for_fresh_and_upgrade_downloads() {
let binary = std::fs::read(std::env::var("GP_TEST_GUI_BINARY").expect("GP_TEST_GUI_BINARY")).unwrap();
let archive = compressed_gui_archive(&binary);
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let temporary = tempfile::tempdir().unwrap();
let output = std::env::var_os("GP_TEST_GUI_INSTALL_DIR")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| temporary.path().to_owned());
std::fs::create_dir_all(&output).unwrap();
std::fs::set_permissions(&output, std::fs::Permissions::from_mode(0o755)).unwrap();
let target = output.join("gpclient/gpgui");
for upgrade in [false, true] {
if upgrade {
std::fs::write(&target, b"old GUI").unwrap();
}
install(archive.path(), &checksum, &target).unwrap();
assert_eq!(std::fs::read_dir(target.parent().unwrap()).unwrap().count(), 1);
assert_eq!(std::fs::read(&target).unwrap(), binary);
let result = std::process::Command::new(&target).arg("--version").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
assert!(String::from_utf8_lossy(&result.stdout).contains(env!("CARGO_PKG_VERSION")));
}
}
}
+41 -19
View File
@@ -1,4 +1,4 @@
use std::{io, sync::Arc};
use std::{fs, io, os::unix::fs::PermissionsExt, path::PathBuf, sync::Arc};
use anyhow::{Context, ensure};
use gpapi::{
@@ -6,17 +6,7 @@ use gpapi::{
os_profile::{ClientOs, HostIdentity, OsProfile, OsProfileBuilder},
};
use gphip::{ReportContext, ReportInput};
use openconnect::HipRequest;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use openconnect::HipScript;
#[cfg(unix)]
#[path = "hip_source/unix.rs"]
mod scripts;
#[cfg(windows)]
#[path = "hip_source/windows.rs"]
mod scripts;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use scripts::script_environment;
use openconnect::{HipRequest, HipScript, HipScriptEnvironment};
pub(crate) struct HipExecution {
pub source: openconnect::HipSource,
@@ -46,7 +36,7 @@ impl HipApproval {
pub(crate) fn resolve(
source: &HipSource,
desktop_uid: Option<u32>,
restricted_desktop: bool,
brokered_macos: bool,
edited_report: Option<Arc<str>>,
profile: Option<OsProfile>,
) -> anyhow::Result<HipExecution> {
@@ -73,11 +63,22 @@ pub(crate) fn resolve(
}
HipSource::UserScript { path } => {
approval = None;
ensure_custom_available(restricted_desktop)?;
scripts::user_script(path, desktop_uid)?
ensure_custom_available(brokered_macos)?;
let uid = desktop_uid.context("HIP custom scripts require a verified desktop user")?;
ensure!(uid != 0, "HIP custom scripts require a non-root desktop user");
let path = PathBuf::from(path);
ensure!(path.is_absolute(), "HIP custom script path must be absolute");
let metadata = fs::symlink_metadata(&path).context("Failed to inspect the HIP script")?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o111 != 0,
"HIP custom script must be an executable regular file"
);
let script =
HipScript::new(path.to_string_lossy().into_owned(), Some(uid))?.with_environment(script_environment(uid)?)?;
openconnect::HipSource::Script(script)
}
HipSource::ApprovedRootScript { approval_id } => {
ensure_custom_available(restricted_desktop)?;
ensure_custom_available(brokered_macos)?;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
let owner_uid = desktop_uid.context("Root HIP scripts require a verified desktop user")?;
@@ -112,10 +113,10 @@ pub(crate) fn resolve(
})
}
fn ensure_custom_available(restricted_desktop: bool) -> anyhow::Result<()> {
fn ensure_custom_available(brokered_macos: bool) -> anyhow::Result<()> {
ensure!(
!cfg!(target_os = "macos") && !restricted_desktop,
"Custom HIP scripts are unavailable on this platform"
!cfg!(target_os = "macos") && !brokered_macos,
"Custom HIP scripts are unavailable on macOS"
);
Ok(())
}
@@ -148,6 +149,27 @@ pub(crate) fn generate(
}
}
pub(crate) fn script_environment(uid: u32) -> anyhow::Result<HipScriptEnvironment> {
let user =
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.context("HIP execution user is unavailable")?;
let home = user.dir.to_string_lossy().into_owned();
Ok(HipScriptEnvironment {
variables: vec![
(
"PATH".into(),
gpapi::process::collection::command_path(uid == 0)?
.into_string()
.map_err(|_| anyhow::anyhow!("HIP command path is not valid UTF-8"))?,
),
("LC_ALL".into(), "C".into()),
("HOME".into(), home.clone()),
("USER".into(), user.name.clone()),
("LOGNAME".into(), user.name),
],
cwd: home,
})
}
pub(crate) fn profile(
identity: &HostIdentity,
os: ClientOs,
-37
View File
@@ -1,37 +0,0 @@
use anyhow::{Context, ensure};
use openconnect::{HipScript, HipScriptEnvironment};
use std::{fs, os::unix::fs::PermissionsExt, path::PathBuf};
pub(super) fn user_script(path: &str, desktop_uid: Option<u32>) -> anyhow::Result<openconnect::HipSource> {
let uid = desktop_uid.context("HIP custom scripts require a verified desktop user")?;
ensure!(uid != 0, "HIP custom scripts require a non-root desktop user");
let path = PathBuf::from(path);
ensure!(path.is_absolute(), "HIP custom script path must be absolute");
let metadata = fs::symlink_metadata(&path).context("Failed to inspect the HIP script")?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o111 != 0,
"HIP custom script must be an executable regular file"
);
let script =
HipScript::new(path.to_string_lossy().into_owned(), Some(uid))?.with_environment(script_environment(uid)?)?;
Ok(openconnect::HipSource::Script(script))
}
pub(crate) fn script_environment(uid: u32) -> anyhow::Result<HipScriptEnvironment> {
let user =
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.context("HIP execution user is unavailable")?;
let home = user.dir.to_string_lossy().into_owned();
Ok(HipScriptEnvironment {
variables: vec![
(
"PATH".into(),
gpapi::process::collection::command_path(uid == 0)?
.into_string()
.map_err(|_| anyhow::anyhow!("HIP command path is not valid UTF-8"))?,
),
("LC_ALL".into(), "C".into()),
("HOME".into(), home.clone()),
("USER".into(), user.name.clone()),
("LOGNAME".into(), user.name),
],
cwd: home,
})
}
-3
View File
@@ -1,3 +0,0 @@
pub(super) fn user_script(_path: &str, _desktop_uid: Option<u32>) -> anyhow::Result<openconnect::HipSource> {
anyhow::bail!("Custom HIP scripts are unavailable on Windows")
}
+1 -30
View File
@@ -1,15 +1,11 @@
#[cfg_attr(windows, path = "cli/windows.rs")]
mod cli;
#[cfg(all(unix, any(target_os = "macos", debug_assertions)))]
mod credential_lease;
#[cfg(unix)]
mod desktop_client;
#[cfg(all(debug_assertions, unix))]
#[cfg(debug_assertions)]
mod dev_bootstrap;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", all(test, unix)))]
mod device_anchor;
#[cfg(unix)]
mod gui_installation;
mod handlers;
mod hip_preview;
mod hip_source;
@@ -17,7 +13,6 @@ mod hip_source;
mod macos_broker;
mod request_dispatcher;
mod routes;
#[cfg(unix)]
mod runtime_user;
mod session_registry;
mod vpn_script;
@@ -25,31 +20,7 @@ mod vpn_task;
mod ws_connection;
mod ws_server;
#[cfg(windows)]
mod windows_service;
const VERSION: &str = concat!(
env!("CARGO_PKG_VERSION"),
" (",
env!("GPSERVICE_GIT_COMMIT"),
" ",
compile_time::date_str!(),
")"
);
#[cfg(unix)]
#[tokio::main]
async fn main() {
cli::run().await;
}
#[cfg(windows)]
fn main() -> std::process::ExitCode {
match cli::run() {
Ok(()) => std::process::ExitCode::SUCCESS,
Err(error) => {
eprintln!("{error:#}");
std::process::ExitCode::FAILURE
}
}
}
+376 -30
View File
@@ -1,15 +1,27 @@
use std::sync::{Arc, atomic::AtomicBool};
use std::{
fs::{self, File, OpenOptions, Permissions},
io::{BufReader, Read, Write},
os::unix::fs::{OpenOptionsExt, PermissionsExt},
path::Path,
sync::{Arc, atomic::AtomicBool},
};
use gpapi::{
service::{
request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest},
transport::{ServiceErrorCode, ServiceResult},
},
utils::redact::Redaction,
utils::{checksum::verify_checksum, redact::Redaction},
};
use log::{info, warn};
#[cfg(unix)]
use tar::Archive;
use tempfile::NamedTempFile;
use tokio::sync::Mutex;
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(crate) struct SessionAuthority {
pub registry: Arc<crate::session_registry::SessionRegistry>,
@@ -63,10 +75,9 @@ pub struct RequestDispatcher {
lifecycle: crate::vpn_task::LifecycleHandle,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
#[cfg(unix)]
install_lock: Mutex<()>,
gui_management_enabled: bool,
restricted_desktop: bool,
externally_brokered: bool,
}
impl RequestDispatcher {
@@ -78,16 +89,15 @@ impl RequestDispatcher {
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
gui_management_enabled: bool,
restricted_desktop: bool,
externally_brokered: bool,
) -> Self {
Self {
lifecycle,
gui_restart_requested,
redaction,
#[cfg(unix)]
install_lock: Mutex::new(()),
gui_management_enabled,
restricted_desktop,
externally_brokered,
}
}
@@ -192,7 +202,7 @@ impl RequestDispatcher {
edited_report,
} => {
let prepared =
crate::vpn_task::prepare_connection(*request, self.restricted_desktop, preparation.cancellation()).await;
crate::vpn_task::prepare_connection(*request, self.externally_brokered, preparation.cancellation()).await;
return match prepared {
Ok(connection) => preparation.commit(connection, desktop_uid, edited_report),
Err(error) => {
@@ -269,25 +279,24 @@ impl RequestDispatcher {
}
fn validate_connect_request(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
if !self.restricted_desktop {
if !self.externally_brokered {
return Ok(());
}
if request.args().vpnc_script().is_some() {
return Err("Custom VPN scripts are unavailable on this platform");
return Err("macOS does not support custom VPN scripts");
}
if matches!(
request.args().hip_source(),
gpapi::hip::HipSource::UserScript { .. } | gpapi::hip::HipSource::ApprovedRootScript { .. }
) {
return Err("Custom HIP scripts are unavailable on this platform");
return Err("macOS does not support custom HIP scripts");
}
if request.args().certificate().is_some() || request.args().sslkey().is_some() {
return Err("Client identity must be provided as certificate data");
return Err("macOS client identity must be provided as protected data, not root-readable paths");
}
Ok(())
}
#[cfg(unix)]
async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult {
if request.variant == gpapi::gui::GuiVariant::Nsh && !cfg!(target_os = "linux") {
return ServiceResult::rejected(
@@ -299,17 +308,14 @@ impl RequestDispatcher {
let path = request.path;
let checksum = request.checksum;
let target = request.variant.update_target();
let installed = tokio::task::spawn_blocking(move || {
crate::gui_installation::install(std::path::Path::new(&path), &checksum, &target)
})
.await;
let installed = tokio::task::spawn_blocking(move || install_gui_at(Path::new(&path), &checksum, &target)).await;
match installed {
Ok(Ok(())) => ServiceResult::Accepted,
Ok(Err(crate::gui_installation::InstallError::Checksum(err))) => {
Ok(Err(GuiInstallError::Checksum(err))) => {
warn!("Failed to verify GUI update checksum: {err}");
ServiceResult::rejected(ServiceErrorCode::ChecksumFailed, "GUI update checksum failed")
}
Ok(Err(crate::gui_installation::InstallError::Install(err))) => {
Ok(Err(GuiInstallError::Install(err))) => {
warn!("Failed to install GUI update: {err}");
ServiceResult::rejected(ServiceErrorCode::InstallFailed, "GUI update installation failed")
}
@@ -319,20 +325,335 @@ impl RequestDispatcher {
}
}
}
#[cfg(windows)]
async fn update_gui(&self, _request: UpdateGuiRequest) -> ServiceResult {
ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"Use the Windows installer to update GP Connect",
)
}
#[derive(Debug)]
enum GuiInstallError {
Checksum(anyhow::Error),
Install(anyhow::Error),
}
pub(crate) fn gui_installer() -> Option<std::path::PathBuf> {
std::env::current_exe()
.ok()
.and_then(|executable| {
executable
.parent()?
.parent()
.map(|prefix| prefix.join("libexec/gpclient/gp-gui-installer"))
})
.filter(|path| path.is_file())
}
fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiInstallError> {
let installer = gui_installer();
install_gui_with_installer(src, checksum, target, installer.as_deref())
}
fn install_gui_with_installer(
src: &Path,
checksum: &str,
target: &Path,
installer: Option<&Path>,
) -> Result<(), GuiInstallError> {
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(src, dir)?;
let archive_path = staged_archive.path().to_string_lossy();
verify_checksum(&archive_path, checksum).map_err(GuiInstallError::Checksum)?;
// A package may need to prepare downloaded executables for its runtime.
// Resolve this helper beside the running service, never from the request or PATH.
if let Some(installer) = installer {
let status = std::process::Command::new(installer)
.arg(staged_archive.path())
.arg(checksum)
.arg(target)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.status()
.map_err(|err| GuiInstallError::Install(err.into()))?;
return if status.success() {
Ok(())
} else {
Err(GuiInstallError::Install(anyhow::anyhow!(
"GUI package installation failed: {status}"
)))
};
}
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 binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
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,
binary_name: &str,
) -> 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 == binary_name);
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 {binary_name} file"
)))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::vpn_task::test_connect_request as test_request;
use gpapi::gateway::Gateway;
use std::{io::Cursor, os::unix::fs::PermissionsExt};
use gpapi::{
gateway::Gateway,
service::transport::{ServiceErrorCode, ServiceResult},
};
use tar::{Builder, EntryType, Header};
use xz2::write::XzEncoder;
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
}
fn compressed_gui_archive(contents: &[u8]) -> NamedTempFile {
let tar = archive_with_entry(EntryType::Regular, contents);
let mut encoder = XzEncoder::new(Vec::new(), 6);
encoder.write_all(&tar).unwrap();
let compressed = encoder.finish().unwrap();
let mut archive = NamedTempFile::new().unwrap();
archive.write_all(&compressed).unwrap();
archive.flush().unwrap();
archive
}
#[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(), "gpgui").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(), "gpgui").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(), "gpgui").is_err());
}
#[test]
fn installs_gui_at_the_supplied_target() {
let archive = compressed_gui_archive(b"gui binary");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpclient/gpgui");
install_gui_at(archive.path(), &checksum, &target).unwrap();
assert_eq!(std::fs::read(&target).unwrap(), b"gui binary");
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
}
#[test]
fn installs_nsh_beside_tauri_without_replacing_it() {
let output = tempfile::tempdir().unwrap();
let tauri = output.path().join("gpgui");
std::fs::write(&tauri, b"tauri").unwrap();
let mut encoder = XzEncoder::new(Vec::new(), 1);
{
let mut archive = Builder::new(&mut encoder);
let mut header = Header::new_gnu();
header.set_size(3);
header.set_mode(0o755);
header.set_cksum();
archive
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
.unwrap();
archive.finish().unwrap();
}
let mut archive = NamedTempFile::new().unwrap();
archive.write_all(&encoder.finish().unwrap()).unwrap();
archive.flush().unwrap();
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let nsh = output.path().join("gpgui-nsh");
install_gui_at(archive.path(), &checksum, &nsh).unwrap();
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
}
#[test]
fn checksum_failure_preserves_the_existing_gui() {
let archive = compressed_gui_archive(b"replacement");
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpclient/gpgui");
std::fs::create_dir_all(target.parent().unwrap()).unwrap();
std::fs::write(&target, b"existing").unwrap();
assert!(install_gui_at(archive.path(), "invalid", &target).is_err());
assert_eq!(std::fs::read(target).unwrap(), b"existing");
}
#[test]
fn package_installer_receives_a_verified_staged_archive() {
let archive = compressed_gui_archive(b"gui binary");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpgui-nsh");
let installer = output.path().join("installer");
std::fs::write(
&installer,
"#!/bin/sh\nset -eu\ntest -f \"$1\"\nprintf '%s' \"$2\" > \"$3\"\n",
)
.unwrap();
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
assert!(install_gui_with_installer(archive.path(), "invalid", &target, Some(&installer)).is_err());
assert!(!target.exists());
install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).unwrap();
assert_eq!(std::fs::read_to_string(target).unwrap(), checksum);
}
#[test]
fn package_installation_failure_preserves_the_existing_gui() {
let archive = compressed_gui_archive(b"replacement");
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpgui");
std::fs::write(&target, b"existing").unwrap();
let installer = output.path().join("installer");
std::fs::write(&installer, "#!/bin/sh\nexit 1\n").unwrap();
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
assert!(install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).is_err());
assert_eq!(std::fs::read(target).unwrap(), b"existing");
}
#[tokio::test]
async fn brokered_mode_rejects_gui_management_and_root_readable_identity_paths() {
let dispatcher = RequestDispatcher::new(
@@ -379,7 +700,7 @@ mod tests {
let custom = test_request(info.clone()).with_vpnc_script(Some(script.to_string()));
assert_eq!(
dispatcher.validate_connect_request(&custom),
Err("Custom VPN scripts are unavailable on this platform")
Err("macOS does not support custom VPN scripts")
);
}
@@ -388,7 +709,32 @@ mod tests {
});
assert_eq!(
dispatcher.validate_connect_request(&custom),
Err("Custom HIP scripts are unavailable on this platform")
Err("macOS does not support custom HIP scripts")
);
}
#[test]
#[ignore = "requires GP_TEST_GUI_BINARY pointing to a built gpgui"]
fn installs_single_gui_binary_for_fresh_and_upgrade_downloads() {
let binary = std::fs::read(std::env::var("GP_TEST_GUI_BINARY").expect("GP_TEST_GUI_BINARY")).unwrap();
let archive = compressed_gui_archive(&binary);
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let temporary = tempfile::tempdir().unwrap();
let output = std::env::var_os("GP_TEST_GUI_INSTALL_DIR")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| temporary.path().to_owned());
std::fs::create_dir_all(&output).unwrap();
std::fs::set_permissions(&output, std::fs::Permissions::from_mode(0o755)).unwrap();
let target = output.join("gpclient/gpgui");
for upgrade in [false, true] {
if upgrade {
std::fs::write(&target, b"old GUI").unwrap();
}
install_gui_at(archive.path(), &checksum, &target).unwrap();
assert_eq!(std::fs::read_dir(target.parent().unwrap()).unwrap().count(), 1);
assert_eq!(std::fs::read(&target).unwrap(), binary);
let result = std::process::Command::new(&target).arg("--version").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
assert!(String::from_utf8_lossy(&result.stdout).contains(env!("CARGO_PKG_VERSION")));
}
}
}
-36
View File
@@ -62,8 +62,6 @@ enum SessionStatus {
}
struct SessionRecord {
#[cfg(windows)]
windows_identity: Option<Arc<gpapi::windows::PipeClientIdentity>>,
non_tunnel: Option<AttachmentAttempt>,
closed_attachment: Option<Uuid>,
secret: Zeroizing<[u8; 32]>,
@@ -257,8 +255,6 @@ impl SessionRegistry {
sessions.insert(
credential.session_id(),
SessionRecord {
#[cfg(windows)]
windows_identity: None,
non_tunnel: None,
closed_attachment: None,
secret: Zeroizing::new(*credential.secret()),
@@ -277,38 +273,6 @@ impl SessionRegistry {
Ok(credential)
}
#[cfg(windows)]
pub(crate) fn issue_windows(
&self,
product_version: &str,
identity: Arc<gpapi::windows::PipeClientIdentity>,
) -> Result<Arc<SessionCredential>, SessionError> {
let credential = self.issue(product_version, None)?;
// The credential is not published until its Windows owner is retained.
self
.sessions
.lock()
.map_err(|_| SessionError::Unavailable)?
.get_mut(&credential.session_id())
.ok_or(SessionError::Unauthorized)?
.windows_identity = Some(identity);
Ok(credential)
}
#[cfg(windows)]
pub(crate) fn windows_identity(
&self,
session_id: Uuid,
) -> Result<Arc<gpapi::windows::PipeClientIdentity>, SessionError> {
self
.sessions
.lock()
.map_err(|_| SessionError::Unavailable)?
.get(&session_id)
.and_then(|record| record.windows_identity.clone())
.ok_or(SessionError::Unauthorized)
}
#[cfg(target_os = "macos")]
pub fn is_empty(&self) -> bool {
let Ok(mut sessions) = self.sessions.lock() else {
+1 -7
View File
@@ -1,9 +1,6 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[path = "privileged_unix.rs"]
mod platform;
#[cfg(windows)]
#[path = "windows.rs"]
mod platform;
#[cfg(target_os = "macos")]
#[path = "macos.rs"]
mod platform;
@@ -11,8 +8,7 @@ mod platform;
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd",
target_os = "macos",
windows
target_os = "macos"
)))]
#[path = "default.rs"]
mod platform;
@@ -20,5 +16,3 @@ mod platform;
mod selection;
pub(crate) use platform::builder;
#[cfg(windows)]
pub(crate) use platform::recover_network;
-24
View File
@@ -1,24 +0,0 @@
use gpapi::service::request::ConnectArgs;
use openconnect::{Vpn, VpnBuilder};
use std::sync::Mutex;
const RECOVERY_KEY: &str = r"SOFTWARE\GP Connect\NetworkRecovery";
pub(crate) fn recover_network() -> std::io::Result<()> {
gpvpnc::windows::recover(RECOVERY_KEY)
}
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> anyhow::Result<VpnBuilder> {
anyhow::ensure!(
args.vpnc_script().is_none(),
"Windows does not support custom VPN scripts"
);
let network = Mutex::new(gpvpnc::windows::NetworkConfigurator::new(RECOVERY_KEY)?);
Ok(
Vpn::builder(server, cookie).network_configuration_handler(move |configuration| {
network
.lock()
.map_err(|_| std::io::Error::other("Windows network state is unavailable"))?
.configure(&configuration.reason, &configuration.environment)
}),
)
}
+4 -5
View File
@@ -126,7 +126,6 @@ impl LifecycleHandle {
ServiceResult::Accepted
}
#[cfg(any(unix, test))]
pub async fn disconnect_and_wait(&self) -> bool {
let completion = {
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
@@ -448,7 +447,7 @@ pub(crate) struct VpnTask {
events: mpsc::Receiver<LifecycleEvent>,
lifecycle: LifecycleHandle,
vpn_state_tx: watch::Sender<VpnState>,
restricted_desktop: bool,
brokered_macos: bool,
registry: Arc<crate::session_registry::SessionRegistry>,
active: Option<ActiveAttempt>,
cancel_token: CancellationToken,
@@ -457,7 +456,7 @@ pub(crate) struct VpnTask {
impl VpnTask {
pub fn new(
vpn_state_tx: watch::Sender<VpnState>,
restricted_desktop: bool,
brokered_macos: bool,
registry: Arc<crate::session_registry::SessionRegistry>,
) -> (Self, LifecycleHandle) {
let (events_tx, events) = mpsc::channel(4);
@@ -471,7 +470,7 @@ impl VpnTask {
events,
lifecycle: lifecycle.clone(),
vpn_state_tx,
restricted_desktop,
brokered_macos,
registry,
active: None,
cancel_token: CancellationToken::new(),
@@ -618,7 +617,7 @@ impl VpnTask {
desktop_uid,
edited_report,
session_id,
restricted_desktop: self.restricted_desktop,
brokered_macos: self.brokered_macos,
registry: self.registry.clone(),
lifecycle: self.lifecycle.clone(),
},
+7 -12
View File
@@ -30,7 +30,7 @@ pub(super) struct ConnectionResources {
/// the complete ledger and its retained identity resources to the service.
pub(crate) async fn prepare_connection(
request: ConnectRequest,
restricted_desktop: bool,
brokered_macos: bool,
cancellation: CancellationToken,
) -> anyhow::Result<PreparedConnection> {
let mode = request.args().packet_delivery().clone();
@@ -77,16 +77,11 @@ pub(crate) async fn prepare_connection(
};
check()?;
let args = setup_request.args();
let identity = super::prepare_identity(args, restricted_desktop || non_tunnel)?;
#[cfg(target_os = "macos")]
let directory = restricted_desktop.then(|| std::path::PathBuf::from("/var/run/com.yuezk.gpgui"));
#[cfg(windows)]
let directory = Some(common::paths::service_private_dir());
#[cfg(all(unix, not(target_os = "macos")))]
let directory: Option<std::path::PathBuf> = None;
let identity = super::prepare_identity(args, brokered_macos || non_tunnel)?;
let directory = brokered_macos.then(|| std::path::Path::new("/var/run/com.yuezk.gpgui"));
let identity_files = identity
.as_ref()
.map(|identity| identity.write_files(directory.as_deref()))
.map(|identity| identity.write_files(directory))
.transpose()?;
let host = args.host_identity().context("Authenticated host identity is missing")?;
let profile = crate::hip_source::profile(
@@ -186,8 +181,8 @@ mod tests {
use gpapi::{gateway::Gateway, service::vpn_state::ConnectInfo};
#[tokio::test]
async fn restricted_desktop_and_non_tunnel_identity_reject_path_handoff() {
for (restricted_desktop, non_tunnel) in [(true, false), (false, true), (true, true)] {
async fn brokered_macos_and_non_tunnel_identity_reject_path_handoff() {
for (brokered_macos, non_tunnel) in [(true, false), (false, true), (true, true)] {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_certificate(Some("/identity.pem".into()));
@@ -197,7 +192,7 @@ mod tests {
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
}
let request = serde_json::from_value(wire).unwrap();
let error = prepare_connection(request, restricted_desktop, CancellationToken::new())
let error = prepare_connection(request, brokered_macos, CancellationToken::new())
.await
.err()
.unwrap();
+8 -12
View File
@@ -20,7 +20,7 @@ pub(super) struct AttemptInput {
pub desktop_uid: Option<u32>,
pub edited_report: Option<Arc<str>>,
pub session_id: Option<Uuid>,
pub restricted_desktop: bool,
pub brokered_macos: bool,
pub registry: Arc<crate::session_registry::SessionRegistry>,
pub lifecycle: LifecycleHandle,
}
@@ -31,7 +31,6 @@ struct TunnelInput {
source: Arc<openconnect::HipSource>,
session_id: Option<Uuid>,
registry: Arc<crate::session_registry::SessionRegistry>,
#[cfg(unix)]
desktop_uid: Option<u32>,
}
@@ -56,7 +55,7 @@ pub(super) fn spawn(
let request = input.connection.request.clone();
let resources = input.connection.resources.clone();
let desktop_uid = input.desktop_uid;
let brokered = input.restricted_desktop;
let brokered = input.brokered_macos;
let edited = input.edited_report.clone();
let setup_cancel = cancellation.clone();
let execution = tokio::task::spawn_blocking(move || {
@@ -106,7 +105,6 @@ pub(super) fn spawn(
source,
session_id: input.session_id,
registry: input.registry.clone(),
#[cfg(unix)]
desktop_uid: input.desktop_uid,
};
input.connection.request.release_script_tun_bootstrap();
@@ -255,14 +253,12 @@ fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyho
),
gpapi::script_tun::PacketDelivery::ScriptTun(request) => {
ensure!(input.session_id.is_some(), "Script-tun requires a desktop session");
#[cfg(unix)]
let owner = input.desktop_uid.context("Desktop identity is unavailable")?;
#[cfg(windows)]
let owner = input
.registry
.windows_identity(input.session_id.context("Desktop session is unavailable")?)?;
let (builder, script_tun) =
super::script_tun::builder(member.gateway.server(), member.authentication.cookie(), request, owner)?;
let (builder, script_tun) = super::script_tun::builder(
member.gateway.server(),
member.authentication.cookie(),
request,
input.desktop_uid.context("Desktop identity is unavailable")?,
)?;
(builder, Some(script_tun))
}
};
+123 -143
View File
@@ -1,19 +1,40 @@
//! Supervision of an unprivileged script-tun consumer; payload semantics belong to the caller.
use super::{LifecycleEvent, LifecycleHandle};
use anyhow::{Context, bail, ensure};
use gpapi::script_tun::{Bootstrap, Identity, Message, receive, send as send_message};
use openconnect::{Vpn, tunnel::Event};
use gpapi::script_tun::{Bootstrap, Identity, Message, ScriptTunRequest, receive, send as send_message};
use openconnect::{Vpn, VpnBuilder, tunnel::Event};
use std::{sync::Arc, time::Duration};
use tokio::{sync::mpsc, time::Instant};
use tokio::{net::UnixStream, sync::mpsc, time::Instant};
use tokio_util::sync::CancellationToken;
#[cfg(unix)]
#[path = "script_tun/unix.rs"]
mod platform;
#[cfg(windows)]
#[path = "script_tun/windows.rs"]
mod platform;
pub(super) use platform::{PreparedScriptTun, builder};
pub(super) struct PreparedScriptTun {
pub control: std::os::unix::net::UnixStream,
pub bootstrap: Bootstrap,
}
pub(super) fn builder(
server: &str,
cookie: &str,
request: &ScriptTunRequest,
uid: u32,
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
request.validate()?;
ensure!(uid != 0, "Script-tun worker requires a desktop user");
let (control, child) = std::os::unix::net::UnixStream::pair()?;
let builder = Vpn::builder(server, cookie).script_tun_program(
request.program.to_str().context("Program is not UTF-8")?,
&request.args,
uid,
child.into(),
)?;
Ok((
builder,
PreparedScriptTun {
control,
bootstrap: request.bootstrap.clone(),
},
))
}
#[derive(Debug)]
pub(super) struct NetworkChanged;
@@ -32,7 +53,7 @@ enum Native {
pub(super) async fn run(
identity: Identity,
vpn: Arc<Vpn>,
mut prepared: PreparedScriptTun,
prepared: PreparedScriptTun,
approval: &crate::hip_source::HipApproval,
lifecycle: &LifecycleHandle,
cancellation: CancellationToken,
@@ -41,8 +62,6 @@ pub(super) async fn run(
registry: Arc<crate::session_registry::SessionRegistry>,
sessions: &mut gpapi::session::desktop::GatewaySessions,
) -> anyhow::Result<()> {
let channel = prepared.connect().await?;
let mut control = ConsumerControl::new(channel);
let attempt = identity.attempt;
let (native_tx, native) = mpsc::channel(64);
let observed = native_tx.clone();
@@ -58,7 +77,7 @@ pub(super) async fn run(
monitor: monitor.clone(),
})
.await;
if event_result.is_err() || cancellation.is_cancelled() {
if event_result.is_err() {
monitor.stop().await;
return Ok(());
}
@@ -72,50 +91,31 @@ pub(super) async fn run(
tokio::pin!(worker);
let mut worker_done = false;
let stop = cancellation.child_token();
let result = {
let supervisor = supervise(
identity,
&mut control,
std::mem::take(&mut prepared.bootstrap),
native,
stop.clone(),
events,
);
tokio::pin!(supervisor);
let mut supervisor_done = false;
let mut approval_poll = tokio::time::interval(Duration::from_millis(250));
let result = loop {
tokio::select! {
biased;
result = &mut supervisor => { supervisor_done = true; break result; }
result = &mut worker => { worker_done = true; break Err(anyhow::anyhow!("VPN worker ended: {:?}", result)); }
_ = approval_poll.tick() => {
if !approval.approval_is_valid() || !registry.has_session(session_id) {
super::runtime::stop_for_revoked_approval(lifecycle, &cancellation);
}
let supervisor = supervise(identity, prepared, native, stop.clone(), events);
tokio::pin!(supervisor);
let mut supervisor_done = false;
let mut approval_poll = tokio::time::interval(Duration::from_millis(250));
let result = loop {
tokio::select! {
biased;
result = &mut supervisor => { supervisor_done = true; break result; }
result = &mut worker => { worker_done = true; break Err(anyhow::anyhow!("VPN worker ended: {:?}", result)); }
_ = approval_poll.tick() => {
if !approval.approval_is_valid() || !registry.has_session(session_id) {
super::runtime::stop_for_revoked_approval(lifecycle, &cancellation);
}
}
};
stop.cancel();
// Keep the consumer's control and packet endpoints alive until OpenConnect
// consumes cancellation and logs out. Early EOF would interrupt that logout.
vpn.disconnect();
if !worker_done {
let _ = worker.await;
}
if !supervisor_done {
let _ = supervisor.await;
}
result
};
control.stop().await;
let cleanup = prepared.stop_worker();
monitor.stop().await;
if result.is_ok() {
cleanup?;
} else if let Err(error) = cleanup {
log::warn!("Could not stop packet worker: {error:#}");
stop.cancel();
if !supervisor_done {
let _ = supervisor.await;
}
vpn.disconnect();
if !worker_done {
let _ = worker.await;
}
monitor.stop().await;
result
}
@@ -128,113 +128,93 @@ enum WorkerState {
Suspending,
}
// Own the channel independently of its supervision future so run() can drain
// the native VPN before telling the consumer to stop or closing its endpoints.
struct ConsumerControl {
output: tokio::io::WriteHalf<platform::ControlStream>,
messages: mpsc::Receiver<std::io::Result<Message>>,
reader: tokio::task::JoinHandle<()>,
}
impl ConsumerControl {
fn new(channel: platform::ControlStream) -> Self {
let (mut input, output) = tokio::io::split(channel);
let (messages_tx, messages) = mpsc::channel(8);
let reader = tokio::spawn(async move {
loop {
let message = receive(&mut input).await;
let failed = message.is_err();
if messages_tx.send(message).await.is_err() || failed {
break;
}
}
});
Self {
output,
messages,
reader,
}
}
async fn stop(&mut self) {
let _ = tokio::time::timeout(Duration::from_millis(250), send(&mut self.output, &Message::Stop)).await;
self.reader.abort();
let _ = (&mut self.reader).await;
}
}
impl Drop for ConsumerControl {
fn drop(&mut self) {
self.reader.abort();
}
}
// Production and generic-consumer tests exercise this same state machine.
// The same control loop runs against native observations in production and a
// generic socket consumer in tests; VPN ownership stays in run().
async fn supervise(
identity: Identity,
control: &mut ConsumerControl,
mut bootstrap: Bootstrap,
mut prepared: PreparedScriptTun,
mut native: mpsc::Receiver<Native>,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) -> anyhow::Result<()> {
let attempt = identity.attempt;
let ConsumerControl { output, messages, .. } = control;
prepared.control.set_nonblocking(true)?;
let control = UnixStream::from_std(prepared.control)?;
let (mut input, mut output) = control.into_split();
let (messages_tx, mut messages) = mpsc::channel(8);
let reader = tokio::spawn(async move {
loop {
let message = receive(&mut input).await;
let failed = message.is_err();
if messages_tx.send(message).await.is_err() || failed {
break;
}
}
});
let mut network = None;
let mut session = None;
let mut worker = WorkerState::Preparing;
let mut online = false;
let mut was_connected = false;
let mut deadline: Option<Instant> = None;
loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => break,
_ = async { if let Some(at) = deadline { tokio::time::sleep_until(at).await } else { std::future::pending().await } } => bail!("Script-tun worker activation timed out"),
message = messages.recv() => match message.context("Script-tun control reader stopped")?? {
Message::Ready if worker == WorkerState::Preparing && network.is_some() => {
worker = WorkerState::Ready;
}
Message::Activated if worker == WorkerState::Activating => {
ensure!(online, "Script-tun activation completed while VPN was offline");
ensure!(!cancellation.is_cancelled(), "Script-tun startup cancelled");
events.send(LifecycleEvent::Established { attempt, session: session.clone().context("Native session is missing")? }).await?;
worker = WorkerState::Active; was_connected = true; deadline = None;
}
Message::Suspended if worker == WorkerState::Suspending => { worker = WorkerState::Ready; deadline = None; }
Message::Error { message } => bail!("Script-tun worker: {message}"),
_ => bail!("Unexpected script-tun consumer message"),
},
event = native.recv() => match event.context("Native event stream ended")? {
Native::Established(value) => { session = Some(value); online = true; deadline.get_or_insert(Instant::now() + Duration::from_secs(10)); }
Native::Event(Event::Configuration(config)) => {
let observed = config.context("VPN configuration is absent").and_then(observed_network);
if was_connected && (observed.is_err() || network.as_ref().is_some_and(|old| observed.as_ref().is_ok_and(|new| old != new))) { return Err(NetworkChanged.into()); }
let observed = observed?;
if let Some(old) = &network { ensure!(old == &observed, "VPN configuration changed during startup"); }
else {
send(output, &Message::Configure { identity, bootstrap: std::mem::take(&mut bootstrap), network: observed.clone() }).await?;
network = Some(observed);
deadline = Some(Instant::now() + Duration::from_secs(10));
let result = async {
loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => break,
_ = async { if let Some(at) = deadline { tokio::time::sleep_until(at).await } else { std::future::pending().await } } => bail!("Script-tun worker activation timed out"),
message = messages.recv() => match message.context("Script-tun control reader stopped")?? {
Message::Ready if worker == WorkerState::Preparing && network.is_some() => {
worker = WorkerState::Ready;
}
}
Native::Event(Event::Reconnecting) => {
ensure!(worker != WorkerState::Activating, "VPN connection interrupted during script-tun activation; reconnect the VPN");
online = false;
events.send(LifecycleEvent::ScriptTunSuspended { attempt }).await?;
if matches!(worker, WorkerState::Ready | WorkerState::Active) {
send(output, &Message::Suspend).await?; worker = WorkerState::Suspending;
deadline = Some(Instant::now() + Duration::from_secs(10));
Message::Activated if worker == WorkerState::Activating => {
ensure!(online, "Script-tun activation completed while VPN was offline");
ensure!(!cancellation.is_cancelled(), "Script-tun startup cancelled");
events.send(LifecycleEvent::Established { attempt, session: session.clone().context("Native session is missing")? }).await?;
worker = WorkerState::Active; was_connected = true; deadline = None;
}
Message::Suspended if worker == WorkerState::Suspending => { worker = WorkerState::Ready; deadline = None; }
Message::Error { message } => bail!("Script-tun worker: {message}"),
_ => bail!("Unexpected script-tun consumer message"),
},
event = native.recv() => match event.context("Native event stream ended")? {
Native::Established(value) => { session = Some(value); online = true; deadline.get_or_insert(Instant::now() + Duration::from_secs(10)); }
Native::Event(Event::Configuration(config)) => {
let observed = config.context("VPN configuration is absent").and_then(observed_network);
if was_connected && (observed.is_err() || network.as_ref().is_some_and(|old| observed.as_ref().is_ok_and(|new| old != new))) { return Err(NetworkChanged.into()); }
let observed = observed?;
if let Some(old) = &network { ensure!(old == &observed, "VPN configuration changed during startup"); }
else {
send(&mut output, &Message::Configure { identity, bootstrap: std::mem::take(&mut prepared.bootstrap), network: observed.clone() }).await?;
network = Some(observed);
deadline = Some(Instant::now() + Duration::from_secs(10));
}
}
Native::Event(Event::Reconnecting) => {
ensure!(worker != WorkerState::Activating, "VPN connection interrupted during script-tun activation; reconnect the VPN");
online = false;
events.send(LifecycleEvent::ScriptTunSuspended { attempt }).await?;
if matches!(worker, WorkerState::Ready | WorkerState::Active) {
send(&mut output, &Message::Suspend).await?; worker = WorkerState::Suspending;
deadline = Some(Instant::now() + Duration::from_secs(10));
}
}
Native::Event(Event::Reconnected) => online = true,
Native::Event(_) => {},
}
Native::Event(Event::Reconnected) => online = true,
Native::Event(_) => {},
}
if online && session.is_some() && worker == WorkerState::Ready && !cancellation.is_cancelled() {
send(&mut output, &Message::Activate).await?; worker = WorkerState::Activating;
deadline = Some(Instant::now() + Duration::from_secs(10));
}
}
if online && session.is_some() && worker == WorkerState::Ready && !cancellation.is_cancelled() {
send(output, &Message::Activate).await?;
worker = WorkerState::Activating;
deadline = Some(Instant::now() + Duration::from_secs(10));
}
}
Ok(())
Ok(())
}.await;
let _ = tokio::time::timeout(Duration::from_millis(250), send(&mut output, &Message::Stop)).await;
drop(output);
reader.abort();
let _ = reader.await;
result
}
fn observed_network(
@@ -263,5 +243,5 @@ async fn send(writer: &mut (impl tokio::io::AsyncWrite + Unpin), message: &Messa
Ok(())
}
#[cfg(all(test, unix))]
#[cfg(test)]
mod tests;
@@ -1,8 +1,6 @@
use super::*;
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
use openconnect::{VpnSessionInfo, tunnel::Configuration};
use tokio::io::AsyncWriteExt;
use tokio::net::UnixStream;
// A generic consumer, with no proxy settings or private worker protocol.
struct Consumer {
@@ -25,26 +23,16 @@ impl Consumer {
launch_id: uuid::Uuid::new_v4(),
};
let cancel = CancellationToken::new();
let stopped = cancel.clone();
let task = tokio::spawn(async move {
let mut prepared = PreparedScriptTun {
control: Some(control),
let task = tokio::spawn(supervise(
identity,
PreparedScriptTun {
control,
bootstrap: Bootstrap::new(b"consumer bootstrap").unwrap(),
};
let channel = prepared.connect().await?;
let mut control = ConsumerControl::new(channel);
let result = supervise(
identity,
&mut control,
prepared.bootstrap,
observations,
stopped,
events,
)
.await;
control.stop().await;
result
});
},
observations,
cancel.clone(),
events,
));
Self {
control: UnixStream::from_std(child).unwrap(),
native,
@@ -303,36 +291,3 @@ async fn reconnect_during_activation_returns_clear_error_without_connected() {
);
assert!(consumer.events.try_recv().is_err());
}
#[tokio::test]
async fn supervision_completion_keeps_consumer_alive_until_owner_stops_it() {
let (channel, mut peer) = UnixStream::pair().unwrap();
let mut control = ConsumerControl::new(channel);
let (_native, observations) = mpsc::channel(1);
let (events, _notifications) = mpsc::channel(1);
let cancellation = CancellationToken::new();
cancellation.cancel();
supervise(
Identity {
service_instance: uuid::Uuid::new_v4(),
attempt: 1,
launch_id: uuid::Uuid::new_v4(),
},
&mut control,
Bootstrap::default(),
observations,
cancellation,
events,
)
.await
.unwrap();
assert!(
tokio::time::timeout(Duration::from_millis(30), receive(&mut peer))
.await
.is_err()
);
control.stop().await;
assert!(matches!(receive(&mut peer).await.unwrap(), Message::Stop));
drop(control);
assert!(receive(&mut peer).await.is_err());
}
@@ -1,44 +0,0 @@
use anyhow::{Context, ensure};
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
use openconnect::{Vpn, VpnBuilder};
pub(super) type ControlStream = tokio::net::UnixStream;
pub(crate) struct PreparedScriptTun {
pub(super) control: Option<std::os::unix::net::UnixStream>,
pub bootstrap: Bootstrap,
}
pub(crate) fn builder(
server: &str,
cookie: &str,
request: &ScriptTunRequest,
uid: u32,
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
request.validate()?;
ensure!(uid != 0, "Script-tun worker requires a desktop user");
let (control, child) = std::os::unix::net::UnixStream::pair()?;
let builder = Vpn::builder(server, cookie).script_tun_program(
request.program.to_str().context("Program is not UTF-8")?,
&request.args,
uid,
child.into(),
)?;
Ok((
builder,
PreparedScriptTun {
control: Some(control),
bootstrap: request.bootstrap.clone(),
},
))
}
impl PreparedScriptTun {
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
let control = self.control.take().context("Worker control pipe is unavailable")?;
control.set_nonblocking(true)?;
Ok(tokio::net::UnixStream::from_std(control)?)
}
// The native OpenConnect Unix launcher owns/reaps its child on disconnect.
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
Ok(())
}
}
@@ -1,69 +0,0 @@
use anyhow::{Context, ensure};
use gpapi::{
process::user_process::UserProcess,
script_tun::{Bootstrap, ScriptTunRequest},
windows::PipeClientIdentity,
};
use openconnect::{Vpn, VpnBuilder};
use std::{os::windows::io::AsRawHandle, sync::Arc, time::Duration};
use tokio::net::windows::named_pipe::NamedPipeServer;
use windows_sys::Win32::System::Pipes::GetNamedPipeClientProcessId;
pub(super) type ControlStream = NamedPipeServer;
pub(crate) struct PreparedScriptTun {
control: Option<NamedPipeServer>,
worker: UserProcess,
pub(super) bootstrap: Bootstrap,
}
pub(crate) fn builder(
server: &str,
cookie: &str,
request: &ScriptTunRequest,
owner: Arc<PipeClientIdentity>,
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
request.validate()?;
let attempt = uuid::Uuid::new_v4();
let control_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Control");
let packet_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Packets");
let control = owner.create_control_pipe(&control_name)?;
let mut packets = owner.create_packet_pipe(&packet_name)?;
let worker = UserProcess::launch(
owner.primary_token(),
&request.program,
&request.args,
&[
("OPENCONNECT_SCRIPT_TUN_CONTROL_PIPE", &control_name),
("VPN_PIPE", &packet_name),
],
)
.context("Could not launch the user-session packet worker")?;
packets.connect(worker.id(), Duration::from_secs(10))?;
// PacketPipe creates only raw overlapped Win32 I/O and never registers IOCP.
let builder = unsafe { Vpn::builder(server, cookie).script_tun_pipe(packets.into_handle()) };
Ok((
builder,
PreparedScriptTun {
control: Some(control),
worker,
bootstrap: request.bootstrap.clone(),
},
))
}
impl PreparedScriptTun {
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
ensure!(!self.worker.has_exited()?, "The packet worker exited during startup");
let control = self.control.take().context("Worker control pipe is unavailable")?;
tokio::time::timeout(Duration::from_secs(10), control.connect())
.await
.context("Packet control connection timed out")??;
let mut pid = 0;
if unsafe { GetNamedPipeClientProcessId(control.as_raw_handle(), &mut pid) } == 0 {
return Err(std::io::Error::last_os_error().into());
}
ensure!(pid == self.worker.id(), "Unexpected packet control client");
Ok(control)
}
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
Ok(self.worker.stop()?)
}
}
@@ -1,92 +0,0 @@
//! A credential lease binds the existing desktop session to its Windows token.
use crate::session_registry::SessionRegistry;
use anyhow::{Context, ensure};
use gpapi::{
service::transport::WINDOWS_ADMISSION_REQUEST,
windows::{PipeClientIdentity, create_service_admission_pipe},
};
use std::{sync::Arc, time::Duration};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::windows::named_pipe::NamedPipeServer,
task::JoinSet,
};
use tokio_util::sync::CancellationToken;
pub(super) struct Admission {
listener: NamedPipeServer,
registry: Arc<SessionRegistry>,
}
struct Lease {
registry: Arc<SessionRegistry>,
session: uuid::Uuid,
}
impl Drop for Lease {
fn drop(&mut self) {
self.registry.revoke(self.session);
}
}
impl Admission {
pub fn new(registry: Arc<SessionRegistry>) -> anyhow::Result<Self> {
Ok(Self {
listener: create_service_admission_pipe(true)?,
registry,
})
}
pub async fn run(mut self, cancel: CancellationToken) -> anyhow::Result<()> {
let mut clients = JoinSet::new();
let result = loop {
tokio::select! {
_ = cancel.cancelled() => break Ok(()),
result = self.listener.connect() => {
if let Err(error) = result { break Err(error.into()); }
let next = match create_service_admission_pipe(false) { Ok(next) => next, Err(error) => break Err(error.into()) };
let pipe = std::mem::replace(&mut self.listener, next);
let registry = self.registry.clone();
let cancel = cancel.clone();
clients.spawn(async move {
if let Err(error) = serve(pipe, registry, cancel).await { log::warn!("Desktop credential lease ended: {error:#}"); }
});
}
_ = clients.join_next(), if !clients.is_empty() => {},
}
};
// Drop each lease before the shared registry and service runtime disappear.
clients.abort_all();
while clients.join_next().await.is_some() {}
result
}
}
async fn serve(
mut pipe: NamedPipeServer,
registry: Arc<SessionRegistry>,
cancel: CancellationToken,
) -> anyhow::Result<()> {
let mut request = [0; WINDOWS_ADMISSION_REQUEST.len()];
tokio::select! {
_ = cancel.cancelled() => return Ok(()),
result = tokio::time::timeout(Duration::from_secs(10), pipe.read_exact(&mut request)) => { result.context("Desktop admission timed out")??; }
}
ensure!(
request == WINDOWS_ADMISSION_REQUEST,
"Invalid desktop admission request"
);
// This synchronous call impersonates, duplicates and reverts before any await.
let identity = Arc::new(PipeClientIdentity::from_pipe(&pipe)?);
let credential = registry.issue_windows(env!("CARGO_PKG_VERSION"), identity)?;
let _lease = Lease {
registry,
session: credential.session_id(),
};
let frame = credential.encode_frame()?;
tokio::select! {
_ = cancel.cancelled() => return Ok(()),
result = tokio::time::timeout(Duration::from_secs(10), pipe.write_all(&frame)) => { result.context("Desktop credential delivery timed out")??; }
}
let mut byte = [0];
tokio::select! {
_ = cancel.cancelled() => {},
result = pipe.read(&mut byte) => { ensure!(result? == 0, "Unexpected desktop lease message"); }
}
Ok(())
}
@@ -1,72 +0,0 @@
use std::{fs::OpenOptions, io, path::Path};
use file_rotate::{ContentLimit, FileRotate, compression::Compression, suffix::AppendCount};
const ROTATE_BYTES: usize = 5 * 1024 * 1024;
const ARCHIVE_COUNT: usize = 3;
pub(super) fn writer(path: &Path) -> io::Result<FileRotate<AppendCount>> {
// Keep startup failure explicit: FileRotate's constructor suppresses open errors.
OpenOptions::new().create(true).read(true).append(true).open(path)?;
Ok(FileRotate::new(
path,
AppendCount::new(ARCHIVE_COUNT),
ContentLimit::BytesSurpassed(ROTATE_BYTES),
Compression::None,
None,
))
}
#[cfg(test)]
mod tests {
use super::*;
use std::{fs, io::Write};
#[test]
fn keeps_the_latest_three_archives_and_complete_current_entry() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("gpservice.log");
fs::write(dir.path().join("unrelated.log"), "keep").unwrap();
let mut log = writer(&path).unwrap();
for marker in b'0'..=b'5' {
log.write_all(&vec![marker; ROTATE_BYTES + 1]).unwrap();
}
log.flush().unwrap();
drop(log);
assert_eq!(fs::read(&path).unwrap(), vec![b'5'; ROTATE_BYTES + 1]);
for (suffix, marker) in [(1, b'4'), (2, b'3'), (3, b'2')] {
let archive = dir.path().join(format!("gpservice.log.{suffix}"));
assert_eq!(fs::read(archive).unwrap(), vec![marker; ROTATE_BYTES + 1]);
}
assert_eq!(fs::read_dir(dir.path()).unwrap().count(), 5);
assert_eq!(fs::read_to_string(dir.path().join("unrelated.log")).unwrap(), "keep");
}
#[test]
fn restart_appends_and_accounts_for_existing_file_size() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("gpservice.log");
fs::write(&path, "before restart\n").unwrap();
{
let mut log = writer(&path).unwrap();
log.write_all(b"after restart\n").unwrap();
}
assert_eq!(fs::read_to_string(&path).unwrap(), "before restart\nafter restart\n");
let entry = vec![b'x'; ROTATE_BYTES + 1];
fs::write(&path, &entry).unwrap();
{
let mut log = writer(&path).unwrap();
log.write_all(b"new entry\n").unwrap();
}
assert_eq!(fs::read(&path).unwrap(), b"new entry\n");
assert_eq!(fs::read(dir.path().join("gpservice.log.1")).unwrap(), entry);
}
#[test]
fn invalid_log_path_remains_a_startup_error() {
let dir = tempfile::tempdir().unwrap();
assert!(writer(dir.path()).is_err());
}
}
-159
View File
@@ -1,159 +0,0 @@
//! Service Control Manager hosting; the GUI remains in the user's desktop session.
mod admission;
mod logging;
use crate::{
request_dispatcher::RequestDispatcher, session_registry::SessionRegistry, vpn_task::VpnTask, ws_server::WsServer,
};
use anyhow::{Context, ensure};
use gpapi::{
service::vpn_state::VpnState,
utils::{lock_file::LockFile, redact::Redaction},
};
use std::{
ffi::OsString,
io::Write,
sync::{Arc, OnceLock, atomic::AtomicBool},
time::Duration,
};
use tokio::sync::{mpsc, watch};
use tokio_util::sync::CancellationToken;
use windows_service::{
define_windows_service,
service::{ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus, ServiceType},
service_control_handler::{self, ServiceControlHandlerResult, ServiceStatusHandle},
service_dispatcher,
};
const NAME: &str = common::paths::SERVICE_NAME;
static LOG_LEVEL: OnceLock<log::Level> = OnceLock::new();
define_windows_service!(ffi_service_main, service_main);
pub(crate) fn dispatch(level: log::Level) -> anyhow::Result<()> {
let _ = LOG_LEVEL.set(level);
service_dispatcher::start(NAME, ffi_service_main).context("Start GP Connect through the Windows service manager")?;
Ok(())
}
fn status(handle: &ServiceStatusHandle, state: ServiceState, failure: bool) -> windows_service::Result<()> {
let running = state == ServiceState::Running;
let pending = matches!(state, ServiceState::StartPending | ServiceState::StopPending);
handle.set_service_status(ServiceStatus {
service_type: ServiceType::OWN_PROCESS,
current_state: state,
controls_accepted: if running {
ServiceControlAccept::STOP | ServiceControlAccept::SHUTDOWN
} else {
ServiceControlAccept::empty()
},
exit_code: if failure {
ServiceExitCode::ServiceSpecific(1)
} else {
ServiceExitCode::Win32(0)
},
checkpoint: u32::from(pending),
wait_hint: if pending {
Duration::from_secs(30)
} else {
Duration::ZERO
},
process_id: None,
})
}
fn service_main(_arguments: Vec<OsString>) {
let stop = CancellationToken::new();
let requested = stop.clone();
let handle = match service_control_handler::register(NAME, move |control| match control {
ServiceControl::Stop | ServiceControl::Shutdown => {
requested.cancel();
ServiceControlHandlerResult::NoError
}
ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
_ => ServiceControlHandlerResult::NotImplemented,
}) {
Ok(handle) => handle,
Err(_) => return,
};
let result = (|| -> anyhow::Result<()> {
status(&handle, ServiceState::StartPending, false)?;
ensure!(
gpapi::windows::current_user_sid()? == "S-1-5-18",
"GP Connect must run as LocalSystem"
);
let redaction = initialize_logger()?;
log::info!("gpservice started: {}", crate::VERSION);
crate::vpn_script::recover_network()?;
let runtime = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
runtime.block_on(run(&handle, stop, redaction))
})();
if let Err(error) = &result {
log::error!("Windows service stopped: {error:#}");
}
let _ = status(&handle, ServiceState::Stopped, result.is_err());
}
fn initialize_logger() -> anyhow::Result<Arc<Redaction>> {
let state = common::paths::service_lock_file();
let directory = state.parent().context("Service state directory is unavailable")?;
// The installer provisions these directories and their machine-wide ACLs.
// Starting the daemon must not create a user-writable fallback location.
ensure!(
directory.is_dir() && common::paths::service_private_dir().is_dir(),
"Install the GP Connect Windows service before starting it"
);
let writer = logging::writer(&directory.join("gpservice.log"))?;
let redaction = Arc::new(Redaction::new());
let filter = redaction.clone();
let logger = env_logger::builder()
.filter_level(log::LevelFilter::Trace)
.target(env_logger::Target::Pipe(Box::new(writer)))
.format(move |buffer, record| {
writeln!(
buffer,
"[{} {:<5} {}] {}",
buffer.timestamp(),
record.level(),
record.module_path().unwrap_or_default(),
filter.redact_str(&record.args().to_string())
)
})
.build();
gpapi::logger::init_with_logger(*LOG_LEVEL.get().unwrap_or(&log::Level::Info), logger);
Ok(redaction)
}
async fn run(handle: &ServiceStatusHandle, stop: CancellationToken, redaction: Arc<Redaction>) -> anyhow::Result<()> {
let lock = Arc::new(LockFile::new(common::paths::service_lock_file(), std::process::id()));
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let admission = admission::Admission::new(registry.clone())?;
let (state, observed) = watch::channel(VpnState::Disconnected);
let (mut vpn, lifecycle) = VpnTask::new(state, true, registry.clone());
let dispatcher = Arc::new(RequestDispatcher::new(
lifecycle,
Arc::new(AtomicBool::new(false)),
redaction,
false,
true,
));
let websocket = WsServer::new(env!("CARGO_PKG_VERSION"), registry, dispatcher, observed, lock.clone());
let service_cancel = websocket.cancel_token();
let vpn_cancel = vpn.cancel_token();
let (shutdown_tx, mut shutdown_rx) = mpsc::channel(4);
let (ready_tx, ready_rx) = tokio::sync::oneshot::channel();
let vpn_stop = service_cancel.clone();
let vpn_handle = tokio::spawn(async move { vpn.start(vpn_stop).await });
let websocket_shutdown = shutdown_tx.clone();
let websocket_handle = tokio::spawn(async move { websocket.start(websocket_shutdown, ready_tx).await });
ready_rx.await.context("Desktop protocol listener failed to start")?;
let lease_cancel = service_cancel.clone();
let admission_handle = tokio::spawn(async move {
if let Err(error) = admission.run(lease_cancel).await {
log::error!("Desktop admission stopped: {error:#}");
let _ = shutdown_tx.send(()).await;
}
});
status(handle, ServiceState::Running, false)?;
tokio::select! { _ = stop.cancelled() => {}, _ = shutdown_rx.recv() => {} }
let _ = status(handle, ServiceState::StopPending, false);
vpn_cancel.cancel();
service_cancel.cancel();
let _ = tokio::join!(vpn_handle, websocket_handle, admission_handle);
lock.unlock()?;
log::info!("gpservice stopped");
Ok(())
}
-1
View File
@@ -344,7 +344,6 @@ impl WsServer {
}
}
#[cfg(unix)]
pub fn context(&self) -> Arc<WsServerContext> {
Arc::clone(&self.ctx)
}
+1 -16
View File
@@ -20,6 +20,7 @@ browser-launcher = { path = "../browser-launcher", default-features = false, fea
tiny_http = { version = "0.12", optional = true }
tempfile = { workspace = true, optional = true }
uuid = { version = "1", optional = true, features = ["v4"] }
uzers = { workspace = true, optional = true }
# Webview auth dependencies
tauri = { workspace = true, optional = true }
@@ -27,7 +28,6 @@ regex = { workspace = true, optional = true }
tokio-util = { workspace = true, optional = true }
html-escape = { version = "0.3", optional = true }
url = { workspace = true, optional = true }
serde_json = { workspace = true, optional = true }
[target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
webkit2gtk = { version = "2", optional = true }
@@ -60,9 +60,6 @@ webview-auth = [
"dep:tokio-util",
"dep:html-escape",
"dep:url",
"dep:serde_json",
"dep:webview2-com",
"dep:windows",
"dep:gtk",
"dep:webkit2gtk",
"dep:block2",
@@ -97,15 +94,3 @@ release-devtools = ["webview-auth", "tauri/devtools"]
[dev-dependencies]
tempfile.workspace = true
[target.'cfg(unix)'.dependencies]
uzers = { workspace = true, optional = true }
[target.'cfg(windows)'.dependencies]
# Child webviews let the Windows host own layout beside native controls.
tauri = { workspace = true, optional = true, features = ["unstable"] }
webview2-com = { version = "0.39", optional = true }
windows = { version = "0.62", optional = true, features = ["Win32_Foundation", "Win32_Graphics_Gdi", "Win32_System_Com", "Win32_UI_Controls", "Win32_UI_HiDpi", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging"] }
dunce = "1"
winreg = "0.55"
common = { path = "../common" }
+65 -4
View File
@@ -3,6 +3,7 @@ use std::{
io::ErrorKind,
os::unix::fs::{DirBuilderExt, FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
time::Duration,
};
use anyhow::{Context, bail};
@@ -13,9 +14,16 @@ use tokio::{
time::timeout,
};
mod protocol;
pub use protocol::validate_auth_callback;
use protocol::*;
const CALLBACK_SCHEME: &str = "globalprotectcallback";
const PROTOCOL_MAGIC: &[u8; 4] = b"GPAC";
const PROTOCOL_VERSION: u8 = 1;
const MAX_CALLBACK_SIZE: usize = 1024 * 1024;
const IO_TIMEOUT: Duration = Duration::from_secs(5);
// Acceptance acknowledges delivery, including an authentication failure.
const STATUS_ACCEPTED: u8 = 0;
const STATUS_INVALID_CALLBACK: u8 = 1;
const STATUS_UNSUPPORTED_VERSION: u8 = 2;
#[cfg(target_os = "macos")]
mod macos;
@@ -224,9 +232,62 @@ fn remove_stale_socket(socket_path: &Path) -> anyhow::Result<()> {
Ok(())
}
pub fn validate_auth_callback(callback: &str) -> anyhow::Result<()> {
if callback.len() > MAX_CALLBACK_SIZE {
bail!("Authentication callback exceeds the maximum supported size");
}
let Some((scheme, data)) = callback.split_once(':') else {
bail!("Authentication callback URL is invalid");
};
if scheme != CALLBACK_SCHEME || data.is_empty() {
bail!("Authentication callback URL is invalid");
}
Ok(())
}
enum CallbackReadError {
UnsupportedVersion,
Invalid,
Io,
}
async fn read_callback(stream: &mut UnixStream) -> Result<String, CallbackReadError> {
let mut magic = [0_u8; 4];
stream.read_exact(&mut magic).await.map_err(|_| CallbackReadError::Io)?;
if &magic != PROTOCOL_MAGIC {
return Err(CallbackReadError::Invalid);
}
let version = stream.read_u8().await.map_err(|_| CallbackReadError::Io)?;
if version != PROTOCOL_VERSION {
return Err(CallbackReadError::UnsupportedVersion);
}
let length = stream.read_u32().await.map_err(|_| CallbackReadError::Io)? as usize;
if length == 0 || length > MAX_CALLBACK_SIZE {
return Err(CallbackReadError::Invalid);
}
let mut payload = vec![0; length];
stream
.read_exact(&mut payload)
.await
.map_err(|_| CallbackReadError::Io)?;
let callback = String::from_utf8(payload).map_err(|_| CallbackReadError::Invalid)?;
validate_auth_callback(&callback).map_err(|_| CallbackReadError::Invalid)?;
Ok(callback)
}
async fn write_response(stream: &mut UnixStream, status: u8) -> anyhow::Result<()> {
stream.write_u8(PROTOCOL_VERSION).await?;
stream.write_u8(status).await?;
Ok(())
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use tempfile::tempdir;
use super::*;
-73
View File
@@ -1,73 +0,0 @@
//! Bounded authentication callback wire format, shared by local transports.
use anyhow::bail;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
pub(super) const CALLBACK_SCHEME: &str = "globalprotectcallback";
pub(super) const PROTOCOL_MAGIC: &[u8; 4] = b"GPAC";
pub(super) const PROTOCOL_VERSION: u8 = 1;
pub(super) const MAX_CALLBACK_SIZE: usize = 1024 * 1024;
pub(super) const IO_TIMEOUT: Duration = Duration::from_secs(5);
// Acceptance acknowledges delivery, including an authentication failure.
pub(super) const STATUS_ACCEPTED: u8 = 0;
pub(super) const STATUS_INVALID_CALLBACK: u8 = 1;
pub(super) const STATUS_UNSUPPORTED_VERSION: u8 = 2;
pub fn validate_auth_callback(callback: &str) -> anyhow::Result<()> {
if callback.len() > MAX_CALLBACK_SIZE {
bail!("Authentication callback exceeds the maximum supported size");
}
let Some((scheme, data)) = callback.split_once(':') else {
bail!("Authentication callback URL is invalid");
};
if scheme != CALLBACK_SCHEME || data.is_empty() {
bail!("Authentication callback URL is invalid");
}
Ok(())
}
pub(super) enum CallbackReadError {
UnsupportedVersion,
Invalid,
Io,
}
pub(super) async fn read_callback(
stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin),
) -> Result<String, CallbackReadError> {
let mut magic = [0_u8; 4];
stream.read_exact(&mut magic).await.map_err(|_| CallbackReadError::Io)?;
if &magic != PROTOCOL_MAGIC {
return Err(CallbackReadError::Invalid);
}
let version = stream.read_u8().await.map_err(|_| CallbackReadError::Io)?;
if version != PROTOCOL_VERSION {
return Err(CallbackReadError::UnsupportedVersion);
}
let length = stream.read_u32().await.map_err(|_| CallbackReadError::Io)? as usize;
if length == 0 || length > MAX_CALLBACK_SIZE {
return Err(CallbackReadError::Invalid);
}
let mut payload = vec![0; length];
stream
.read_exact(&mut payload)
.await
.map_err(|_| CallbackReadError::Io)?;
let callback = String::from_utf8(payload).map_err(|_| CallbackReadError::Invalid)?;
validate_auth_callback(&callback).map_err(|_| CallbackReadError::Invalid)?;
Ok(callback)
}
pub(super) async fn write_response(
stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin),
status: u8,
) -> anyhow::Result<()> {
stream.write_u8(PROTOCOL_VERSION).await?;
stream.write_u8(status).await?;
Ok(())
}
-129
View File
@@ -1,129 +0,0 @@
//! Per-user Windows named pipe for browser authentication callbacks.
use anyhow::{Context, bail};
use gpapi::{auth::SamlAuthData, error::AuthDataParseError};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::windows::named_pipe::{ClientOptions, NamedPipeServer},
time::timeout,
};
#[path = "protocol.rs"]
mod protocol;
pub use protocol::validate_auth_callback;
use protocol::*;
pub struct AuthCallbackReceiver {
listener: NamedPipeServer,
}
impl AuthCallbackReceiver {
pub fn bind() -> anyhow::Result<Self> {
Ok(Self {
listener: gpapi::windows::create_user_pipe(&pipe_name()?, true)
.context("Another browser authentication is already waiting")?,
})
}
pub async fn receive(mut self) -> anyhow::Result<SamlAuthData> {
loop {
self.listener.connect().await?;
let mut stream = &mut self.listener;
let callback = timeout(IO_TIMEOUT, read_callback(&mut stream)).await;
let result = match callback {
Ok(Ok(callback)) => match SamlAuthData::from_gpcallback(&callback) {
Ok(data) => {
let _ = write_response(&mut stream, STATUS_ACCEPTED).await;
Some(Ok(data))
}
Err(error @ AuthDataParseError::AuthenticationFailed(_)) => {
let _ = write_response(&mut stream, STATUS_ACCEPTED).await;
Some(Err(error.into()))
}
Err(_) => {
let _ = write_response(&mut stream, STATUS_INVALID_CALLBACK).await;
None
}
},
Ok(Err(CallbackReadError::UnsupportedVersion)) => {
let _ = write_response(&mut stream, STATUS_UNSUPPORTED_VERSION).await;
None
}
_ => None,
};
// DisconnectNamedPipe discards unread response bytes. Wait for the client
// to confirm it consumed the response before disconnecting this instance.
let _ = timeout(IO_TIMEOUT, stream.read_u8()).await;
self.listener.disconnect()?;
if let Some(result) = result {
return result;
}
}
}
}
fn pipe_name() -> anyhow::Result<String> {
Ok(format!(
r"\\.\pipe\GPConnect.Auth.{}",
gpapi::windows::current_user_sid()?
))
}
pub async fn forward_auth_callback(callback: &str) -> anyhow::Result<()> {
validate_auth_callback(callback)?;
timeout(IO_TIMEOUT, async {
let mut stream = ClientOptions::new()
.open(pipe_name()?)
.context("No external-browser authentication is waiting for a callback")?;
stream.write_all(PROTOCOL_MAGIC).await?;
stream.write_u8(PROTOCOL_VERSION).await?;
stream.write_u32(callback.len() as u32).await?;
stream.write_all(callback.as_bytes()).await?;
let version = stream.read_u8().await?;
let status = stream.read_u8().await?;
stream.write_u8(status).await?;
anyhow::ensure!(
version == PROTOCOL_VERSION,
"Authentication callback protocol version mismatch"
);
match status {
STATUS_ACCEPTED => Ok(()),
STATUS_INVALID_CALLBACK => bail!("Authentication callback was rejected"),
_ => bail!("Authentication callback protocol is unsupported"),
}
})
.await
.context("Timed out forwarding the authentication callback")?
}
pub fn ensure_auth_callback_handler() -> anyhow::Result<()> {
use winreg::{RegKey, enums::HKEY_CURRENT_USER};
let executable = common::binary_paths::gpauth();
anyhow::ensure!(executable.is_file(), "The authentication helper is missing");
let root = RegKey::predef(HKEY_CURRENT_USER);
let (scheme, _) = root.create_subkey(r"Software\Classes\globalprotectcallback")?;
scheme.set_value("", &"URL:GlobalProtect authentication callback")?;
scheme.set_value("URL Protocol", &"")?;
let (command, _) = scheme.create_subkey(r"shell\open\command")?;
// URL association activation requires a shell path, not Rust's verbatim
// canonical path (\\?\C:\...), even though CreateProcess accepts both.
let executable = dunce::simplified(&executable);
command.set_value("", &format!("\"{}\" auth-callback \"%1\"", executable.display()))?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn forwards_browser_callback_over_private_windows_pipe() {
let receiver = AuthCallbackReceiver::bind().unwrap();
// The first-instance flag preserves one pending browser authentication per user.
assert!(AuthCallbackReceiver::bind().is_err());
let sender = tokio::spawn(async {
forward_auth_callback("globalprotectcallback:cas-as=1&[email protected]&token=test-token").await
});
let data = timeout(std::time::Duration::from_secs(5), receiver.receive())
.await
.unwrap()
.unwrap();
sender.await.unwrap().unwrap();
assert_eq!(data.username(), "[email protected]");
assert_eq!(data.token(), Some("test-token"));
}
}
-1
View File
@@ -8,7 +8,6 @@ use gpapi::{
mod browser;
#[cfg(feature = "browser-auth")]
#[cfg_attr(windows, path = "callback/windows.rs")]
mod callback;
#[cfg(feature = "browser-auth")]
+1 -6
View File
@@ -12,17 +12,12 @@ mod platform_impl;
#[path = "webview/macos.rs"]
mod platform_impl;
#[cfg(windows)]
#[path = "webview/windows.rs"]
mod platform_impl;
#[cfg(not(any(
windows,
target_os = "macos",
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd"
)))]
compile_error!("webview-auth is only supported on Windows, macOS and GTK/WebKitGTK Unix targets");
compile_error!("webview-auth is only supported on macOS and GTK/WebKitGTK Unix targets");
pub use webview_auth::{WebviewAuthenticator, apply_auth_theme};
+2 -2
View File
@@ -9,7 +9,7 @@ use tokio_util::sync::CancellationToken;
#[derive(Debug)]
pub(crate) enum AuthDataLocation {
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
Headers,
Body,
}
@@ -155,7 +155,7 @@ impl AuthMessenger {
}
}
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub fn read_from_response(&self, auth_response: &impl super::webview_auth::GetHeader, generation: u64) {
use log::warn;
+24 -44
View File
@@ -1,8 +1,6 @@
use std::{future::Future, pin::Pin, sync::Arc, time::Duration};
use anyhow::bail;
#[cfg(not(windows))]
use gpapi::utils::window::get_title_bar_height;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use gpapi::utils::window::{WindowTypeHint, set_window_type_hint};
use gpapi::{
@@ -10,51 +8,24 @@ use gpapi::{
error::ServerTlsError,
gp_params::GpParams,
os_profile::{WebviewUserAgent, WebviewUserAgentTransform},
utils::redact::redact_uri,
utils::{redact::redact_uri, window::get_title_bar_height},
};
use log::{info, warn};
#[cfg(target_os = "macos")]
use tauri::Manager;
#[cfg(not(windows))]
use tauri::WebviewUrl;
use tauri::{AppHandle, WindowEvent};
use tauri::{AppHandle, WebviewUrl, WebviewWindow, WindowEvent};
use tokio::{sync::oneshot, time};
use crate::auth_prelogin;
#[cfg(not(windows))]
use super::address_bar::TOOLBAR_HEIGHT;
use super::auth_messenger::{AuthError, AuthEvent, AuthMessenger};
use super::recovery::{Recovery, RecoveryStatus, RetryPlan, RetrySource, RetryTiming};
#[cfg(not(windows))]
type AuthWindow = tauri::WebviewWindow;
#[cfg(windows)]
use super::platform_impl::{AuthWindow, create_auth_window};
#[cfg(not(windows))]
fn create_auth_window(app: &AppHandle, title: &str, theme: Option<tauri::Theme>) -> anyhow::Result<AuthWindow> {
let builder = AuthWindow::builder(app, "auth_window", WebviewUrl::default())
.title(title)
.theme(theme)
.devtools(cfg!(any(debug_assertions, feature = "release-devtools")));
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
let builder = builder.on_navigation(super::platform_impl::open_okta_verify);
Ok(
builder
.inner_size(900.0, 650.0 + get_title_bar_height() + TOOLBAR_HEIGHT)
.min_inner_size(400.0, 300.0)
.focused(true)
.visible(false)
.center()
.build()?,
)
}
const RESTART_TIMEOUT: Duration = Duration::from_secs(30);
pub(super) trait PlatformWebviewExt {
fn install_auth_controls(&self, window: &AuthWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()>;
pub trait PlatformWebviewExt {
fn install_auth_controls(&self, window: &WebviewWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()>;
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()>;
@@ -83,7 +54,7 @@ pub(super) trait PlatformWebviewExt {
}
}
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub trait GetHeader {
fn get_header(&self, key: &str) -> Option<String>;
}
@@ -154,7 +125,19 @@ impl<'a> WebviewAuthenticator<'a> {
pub async fn authenticate(&self, app_handle: &AppHandle) -> anyhow::Result<SamlAuthData> {
let auth_messenger = Arc::new(AuthMessenger::new());
let auth_window = create_auth_window(app_handle, self.window_title, native_theme(self.window_theme))?;
let auth_window_builder = WebviewWindow::builder(app_handle, "auth_window", WebviewUrl::default())
.title(self.window_title)
.theme(native_theme(self.window_theme))
.devtools(cfg!(any(debug_assertions, feature = "release-devtools")));
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
let auth_window_builder = auth_window_builder.on_navigation(super::platform_impl::open_okta_verify);
let auth_window = auth_window_builder
.inner_size(900.0, 650.0 + get_title_bar_height() + TOOLBAR_HEIGHT)
.min_inner_size(400.0, 300.0)
.focused(true)
.visible(false)
.center()
.build()?;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
set_window_type_hint(&auth_window, WindowTypeHint::Dialog)?;
@@ -187,7 +170,7 @@ impl<'a> WebviewAuthenticator<'a> {
async fn wait_for_auth(
&self,
auth_window: &AuthWindow,
auth_window: &WebviewWindow,
auth_messenger: Arc<AuthMessenger>,
) -> anyhow::Result<SamlAuthData> {
let mut recovery = Recovery::default();
@@ -327,16 +310,13 @@ impl<'a> WebviewAuthenticator<'a> {
async fn setup_auth_window(
&self,
auth_window: &AuthWindow,
auth_window: &WebviewWindow,
auth_messenger: Arc<AuthMessenger>,
) -> anyhow::Result<()> {
info!("Setting up auth window...");
if self.clean {
info!("Clearing all browsing data...");
#[cfg(windows)]
super::platform_impl::clear_browsing_data(auth_window).await?;
#[cfg(not(windows))]
auth_window.clear_all_browsing_data()?;
}
@@ -381,7 +361,7 @@ impl<'a> WebviewAuthenticator<'a> {
Ok(())
}
fn handle_not_found(&self, auth_window: &AuthWindow, auth_messenger: &Arc<AuthMessenger>) {
fn handle_not_found(&self, auth_window: &WebviewWindow, auth_messenger: &Arc<AuthMessenger>) {
let visible = auth_window.is_visible().unwrap_or(false);
if visible {
return;
@@ -390,7 +370,7 @@ impl<'a> WebviewAuthenticator<'a> {
auth_messenger.schedule_raise_window(2);
}
fn update_recovery(&self, auth_window: &AuthWindow, status: RecoveryStatus) -> anyhow::Result<()> {
fn update_recovery(&self, auth_window: &WebviewWindow, status: RecoveryStatus) -> anyhow::Result<()> {
if status != RecoveryStatus::Hidden {
self.raise_window(auth_window);
}
@@ -417,7 +397,7 @@ impl<'a> WebviewAuthenticator<'a> {
fn load_restarted_sign_in(
&self,
auth_window: &AuthWindow,
auth_window: &WebviewWindow,
messenger: &Arc<AuthMessenger>,
auth_request: String,
) -> anyhow::Result<()> {
@@ -435,7 +415,7 @@ impl<'a> WebviewAuthenticator<'a> {
Ok(())
}
fn raise_window(&self, auth_window: &AuthWindow) {
fn raise_window(&self, auth_window: &WebviewWindow) {
let visible = auth_window.is_visible().unwrap_or(false);
if visible {
return;
-380
View File
@@ -1,380 +0,0 @@
//! WebView2 authentication. All COM objects and native controls stay on the UI thread.
use std::{
cell::{Cell, RefCell},
collections::HashMap,
rc::Rc,
sync::Arc,
};
use super::{
auth_messenger::{AuthDataLocation, AuthError, AuthEvent, AuthMessenger},
recovery::RecoveryStatus,
webview_auth::{GetHeader, PlatformWebviewExt},
};
use anyhow::{Context, bail};
use gpapi::auth::SamlAuthData;
use tauri::{
AppHandle, LogicalPosition, Webview, WebviewBuilder, WebviewUrl, Window, WindowBuilder, webview::PlatformWebview,
};
use webview2_com::{
ClearBrowsingDataCompletedHandler, CoTaskMemPWSTR, DOMContentLoadedEventHandler, ExecuteScriptCompletedHandler,
Microsoft::Web::WebView2::Win32::*, NavigationCompletedEventHandler, NavigationStartingEventHandler,
SourceChangedEventHandler, WebResourceResponseReceivedEventHandler,
};
use windows::core::{BOOL, HSTRING, Interface, PWSTR};
#[path = "windows/controls.rs"]
mod controls;
#[path = "windows/tls.rs"]
mod tls;
/// Windows hosts native chrome and a manually sized child webview in one window.
/// Host-owned child bounds keep the page surface below the native controls
/// throughout live resizing.
#[derive(Clone)]
pub(super) struct AuthWindow {
window: Window,
webview: Webview,
}
impl std::ops::Deref for AuthWindow {
type Target = Window;
fn deref(&self) -> &Window {
&self.window
}
}
impl AuthWindow {
pub(super) fn with_webview(&self, callback: impl FnOnce(PlatformWebview) + Send + 'static) -> tauri::Result<()> {
self.webview.with_webview(callback)
}
}
impl gpapi::utils::window::WindowExt for AuthWindow {
fn raise(&self) -> anyhow::Result<()> {
self.window.show()?;
self.window.set_focus()?;
self.webview.set_focus()?;
Ok(())
}
}
pub(super) fn create_auth_window(
app: &AppHandle,
title: &str,
theme: Option<tauri::Theme>,
) -> anyhow::Result<AuthWindow> {
let window = WindowBuilder::new(app, "auth_window")
.title(title)
.theme(theme)
.inner_size(900.0, 650.0 + super::address_bar::TOOLBAR_HEIGHT)
.min_inner_size(400.0, 300.0)
.focused(true)
.visible(false)
.center()
.build()?;
let webview = window.add_child(
WebviewBuilder::new("auth_webview", WebviewUrl::default())
.devtools(cfg!(any(debug_assertions, feature = "release-devtools"))),
LogicalPosition::new(0.0, 0.0),
window.inner_size()?,
)?;
Ok(AuthWindow { window, webview })
}
thread_local! {
static STATES: RefCell<HashMap<usize, Rc<State>>> = RefCell::default();
}
struct State {
core: ICoreWebView2,
controller: ICoreWebView2Controller,
messenger: Arc<AuthMessenger>,
controls: controls::Controls,
pending: Cell<Option<u64>>,
navigations: RefCell<HashMap<u64, u64>>,
document: RefCell<(String, u64)>,
tls: RefCell<tls::Policy>,
}
fn text(get: impl FnOnce(*mut PWSTR) -> windows::core::Result<()>) -> windows::core::Result<String> {
let mut value = PWSTR::null();
let result = get(&mut value);
let value = CoTaskMemPWSTR::from(value);
result?;
Ok(value.to_string())
}
fn state(webview: &PlatformWebview) -> anyhow::Result<Rc<State>> {
let core = unsafe { webview.controller().CoreWebView2()? };
STATES
.with_borrow(|states| states.get(&(core.as_raw() as usize)).cloned())
.context("Authentication controls are unavailable")
}
impl State {
fn read_html(&self, generation: u64) -> windows::core::Result<()> {
if generation != self.messenger.generation() {
return Ok(());
}
let messenger = Arc::clone(&self.messenger);
unsafe {
self.core.ExecuteScript(
&HSTRING::from("document.documentElement.outerHTML"),
&ExecuteScriptCompletedHandler::create(Box::new(move |result, json| {
result?;
if let Ok(html) = serde_json::from_str::<String>(&json) {
messenger.read_from_html(&html, generation);
}
Ok(())
})),
)
}
}
fn listen(self: &Rc<Self>) -> windows::core::Result<()> {
let mut token = 0;
let weak = Rc::downgrade(self);
let starting = NavigationStartingEventHandler::create(Box::new(move |_, args| {
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
return Ok(());
};
unsafe {
let mut id = 0;
args.NavigationId(&mut id)?;
let generation = *state
.navigations
.borrow_mut()
.entry(id)
.or_insert_with(|| state.pending.take().unwrap_or_else(|| state.messenger.generation()));
let uri = text(|p| args.Uri(p))?;
if uri.starts_with("globalprotectcallback:") {
args.SetCancel(true)?;
match SamlAuthData::from_gpcallback(&uri) {
Ok(data) => state
.messenger
.send_auth_event(AuthEvent::Data(generation, data, AuthDataLocation::Body)),
Err(error) => state
.messenger
.send_auth_event(AuthEvent::Error(generation, AuthError::invalid_from_body(error.into()))),
}
} else if generation == state.messenger.generation() {
*state.document.borrow_mut() = (uri, generation);
state.messenger.cancel_raise_window();
}
}
Ok(())
}));
unsafe {
self.core.add_NavigationStarting(&starting, &mut token)?;
}
let weak = Rc::downgrade(self);
let loaded = DOMContentLoadedEventHandler::create(Box::new(move |_, args| {
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
return Ok(());
};
let mut id = 0;
unsafe {
args.NavigationId(&mut id)?;
}
let generation = state.navigations.borrow().get(&id).copied();
if let Some(generation) = generation {
state.read_html(generation)?;
}
Ok(())
}));
unsafe {
self
.core
.cast::<ICoreWebView2_2>()?
.add_DOMContentLoaded(&loaded, &mut token)?;
}
let weak = Rc::downgrade(self);
let completed = NavigationCompletedEventHandler::create(Box::new(move |_, args| {
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
return Ok(());
};
unsafe {
let mut id = 0;
args.NavigationId(&mut id)?;
let Some(generation) = state.navigations.borrow_mut().remove(&id) else {
return Ok(());
};
let mut success = BOOL(0);
args.IsSuccess(&mut success)?;
if success.as_bool() {
state.read_html(generation)?;
state.messenger.send_auth_event(AuthEvent::PageLoaded(generation));
} else {
let mut error = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
args.WebErrorStatus(&mut error)?;
if error != COREWEBVIEW2_WEB_ERROR_STATUS_OPERATION_CANCELED {
state.messenger.send_auth_event(AuthEvent::Error(
generation,
AuthError::LoadFailed(anyhow::anyhow!("WebView2 navigation failed ({})", error.0)),
));
}
}
}
Ok(())
}));
unsafe {
self.core.add_NavigationCompleted(&completed, &mut token)?;
}
let weak = Rc::downgrade(self);
let source = SourceChangedEventHandler::create(Box::new(move |_, _| {
if let Some(state) = weak.upgrade() {
let uri = unsafe { text(|p| state.core.Source(p))? };
state.controls.set_address(&uri)?;
}
Ok(())
}));
unsafe {
self.core.add_SourceChanged(&source, &mut token)?;
}
let weak = Rc::downgrade(self);
let response = WebResourceResponseReceivedEventHandler::create(Box::new(move |_, args| {
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
return Ok(());
};
unsafe {
let uri = text(|p| args.Request()?.Uri(p))?;
let (document, generation) = state.document.borrow().clone();
// Subresources must not supply authentication credentials for the page.
if uri == document && generation == state.messenger.generation() {
state
.messenger
.read_from_response(&Headers(args.Response()?.Headers()?), generation);
}
}
Ok(())
}));
unsafe {
self
.core
.cast::<ICoreWebView2_2>()?
.add_WebResourceResponseReceived(&response, &mut token)?;
}
tls::install(self)?;
Ok(())
}
}
struct Headers(ICoreWebView2HttpResponseHeaders);
impl GetHeader for Headers {
fn get_header(&self, key: &str) -> Option<String> {
unsafe { text(|p| self.0.GetHeader(&HSTRING::from(key), p)).ok() }
}
}
impl PlatformWebviewExt for PlatformWebview {
fn install_auth_controls(&self, window: &AuthWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
let controller = self.controller();
let core = unsafe { controller.CoreWebView2()? };
let key = core.as_raw() as usize;
let controls = controls::Controls::new(window, &controller, key)?;
let state = Rc::new(State {
core,
controller,
messenger,
controls,
pending: Cell::new(None),
navigations: RefCell::default(),
document: RefCell::new((String::new(), 0)),
tls: RefCell::default(),
});
STATES.with_borrow_mut(|states| states.insert(key, Rc::clone(&state)));
state.listen()?;
state.controls.layout(&state)?;
Ok(())
}
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()> {
let state = state(self)?;
state.controls.update(&state, status)?;
Ok(())
}
fn stop_loading(&self) {
let _ = unsafe { self.controller().CoreWebView2().and_then(|wv| wv.Stop()) };
}
fn confirm_tls_exception(&self) -> anyhow::Result<()> {
tls::confirm(state(self)?.as_ref())
}
fn ignore_tls_errors(&self) -> anyhow::Result<()> {
state(self)?.tls.borrow_mut().ignore_errors = true;
Ok(())
}
fn user_agent(&self) -> anyhow::Result<String> {
unsafe {
Ok(text(|p| {
self
.controller()
.CoreWebView2()?
.Settings()?
.cast::<ICoreWebView2Settings2>()?
.UserAgent(p)
})?)
}
}
fn set_user_agent(&self, user_agent: &str) -> anyhow::Result<()> {
unsafe {
self
.controller()
.CoreWebView2()?
.Settings()?
.cast::<ICoreWebView2Settings2>()?
.SetUserAgent(&HSTRING::from(user_agent))?;
}
Ok(())
}
fn load_url(&self, url: &str) -> anyhow::Result<()> {
let state = state(self)?;
state.pending.set(Some(state.messenger.generation()));
unsafe {
state.core.Navigate(&HSTRING::from(url))?;
}
Ok(())
}
fn load_html(&self, html: &str) -> anyhow::Result<()> {
let state = state(self)?;
state.pending.set(Some(state.messenger.generation()));
unsafe {
state.core.NavigateToString(&HSTRING::from(html))?;
}
Ok(())
}
}
/// WebView2 clears profiles asynchronously; do not navigate until cookies are gone.
pub(super) async fn clear_browsing_data(window: &AuthWindow) -> anyhow::Result<()> {
let (tx, rx) = tokio::sync::oneshot::channel();
window.with_webview(move |wv| {
let tx = Rc::new(RefCell::new(Some(tx)));
let complete = Rc::clone(&tx);
let callback = ClearBrowsingDataCompletedHandler::create(Box::new(move |result| {
if let Some(tx) = complete.borrow_mut().take() {
let _ = tx.send(result);
}
Ok(())
}));
let result = (|| unsafe {
wv.controller()
.CoreWebView2()?
.cast::<ICoreWebView2_13>()?
.Profile()?
.cast::<ICoreWebView2Profile2>()?
.ClearBrowsingDataAll(&callback)
})();
if let Err(error) = result {
if let Some(tx) = tx.borrow_mut().take() {
let _ = tx.send(Err(error));
}
}
})?;
rx.await.context("Could not clear sign-in data")??;
Ok(())
}
-334
View File
@@ -1,334 +0,0 @@
//! Native controls remain outside the identity provider's document.
use super::*;
use windows::{
Win32::{
Foundation::{COLORREF, HWND, LPARAM, LRESULT, RECT, WPARAM},
Graphics::Gdi::*,
UI::{
Controls::EM_SETRECT,
HiDpi::{GetDpiForWindow, SystemParametersInfoForDpi},
Shell::{DefSubclassProc, RemoveWindowSubclass, SetWindowSubclass},
WindowsAndMessaging::*,
},
},
core::{PCWSTR, w},
};
const SUBCLASS: usize = 0x47504155;
const ADDRESS_SUBCLASS: usize = 0x47504156;
const ADDRESS_HEIGHT: i32 = 24;
const TOOLBAR_HEIGHT: i32 = 34;
const RETRY: usize = 101;
const PROCEED: usize = 102;
const CANCEL: usize = 103;
pub(super) struct Controls {
pub(super) parent: HWND,
webview_host: HWND,
address: HWND,
message: HWND,
retry: HWND,
proceed: HWND,
cancel: HWND,
status: Cell<RecoveryStatus>,
font: Cell<Option<(u32, HFONT)>>,
}
impl Controls {
pub(super) fn new(window: &AuthWindow, controller: &ICoreWebView2Controller, key: usize) -> anyhow::Result<Self> {
// The host owns both the toolbar and the child webview's remaining area.
let parent = HWND(window.hwnd()?.0);
let mut webview_host = HWND::default();
unsafe {
controller.ParentWindow(&mut webview_host)?;
}
let child = |class: PCWSTR, title: &str, style: WINDOW_STYLE, id: usize| -> windows::core::Result<HWND> {
unsafe {
let hwnd = CreateWindowExW(
WINDOW_EX_STYLE::default(),
class,
&HSTRING::from(title),
WS_CHILD | style,
0,
0,
0,
0,
Some(parent),
Some(HMENU(id as *mut _)),
None,
None,
)?;
Ok(hwnd)
}
};
let controls = Self {
parent,
webview_host,
address: child(
w!("EDIT"),
super::super::address_bar::LOADING_ADDRESS,
WS_VISIBLE | WS_BORDER | WINDOW_STYLE(ES_READONLY as u32 | ES_MULTILINE as u32 | ES_AUTOHSCROLL as u32),
0,
)?,
message: child(w!("STATIC"), "", WINDOW_STYLE::default(), 0)?,
retry: child(w!("BUTTON"), "Try Again", WS_TABSTOP, RETRY)?,
proceed: child(w!("BUTTON"), "Continue Anyway…", WS_TABSTOP, PROCEED)?,
cancel: child(w!("BUTTON"), "Cancel", WS_TABSTOP, CANCEL)?,
status: Cell::new(RecoveryStatus::Hidden),
font: Cell::new(None),
};
unsafe {
anyhow::ensure!(
SetWindowSubclass(controls.address, Some(address_proc), ADDRESS_SUBCLASS, 0).as_bool(),
"Could not style the sign-in address"
);
anyhow::ensure!(
SetWindowSubclass(parent, Some(window_proc), SUBCLASS, key).as_bool(),
"Could not install sign-in controls"
);
}
Ok(controls)
}
pub(super) fn set_address(&self, uri: &str) -> windows::core::Result<()> {
unsafe {
SetWindowTextW(
self.address,
&HSTRING::from(super::super::address_bar::display_address(Some(uri))),
)
}
}
pub(super) fn update(&self, state: &State, status: RecoveryStatus) -> windows::core::Result<()> {
self.status.set(status);
let message = if status.detail().is_empty() {
status.message().to_owned()
} else {
format!("{}\r\n{}", status.message(), status.detail())
};
unsafe {
SetWindowTextW(self.message, &HSTRING::from(message))?;
for (hwnd, visible) in [
(self.message, status != RecoveryStatus::Hidden),
(self.retry, status.can_retry()),
(self.proceed, status.can_continue()),
(self.cancel, status.blocks_page()),
] {
let _ = ShowWindow(hwnd, if visible { SW_SHOW } else { SW_HIDE });
}
state.controller.SetIsVisible(!status.blocks_page())?;
}
self.layout(state)
}
pub(super) fn layout(&self, state: &State) -> windows::core::Result<()> {
unsafe {
let dpi = GetDpiForWindow(self.parent);
let scale = dpi as f64 / 96.0;
let px = |value: i32| (value as f64 * scale).round() as i32;
let mut bounds = RECT::default();
GetClientRect(self.parent, &mut bounds)?;
let width = bounds.right;
if self.font.get().is_none_or(|(current_dpi, _)| current_dpi != dpi) {
let mut metrics = NONCLIENTMETRICSW {
cbSize: std::mem::size_of::<NONCLIENTMETRICSW>() as u32,
..Default::default()
};
SystemParametersInfoForDpi(
SPI_GETNONCLIENTMETRICS.0,
metrics.cbSize,
Some(&mut metrics as *mut _ as *mut _),
0,
dpi,
)?;
metrics.lfMessageFont.lfHeight = -px(13);
let font = CreateFontIndirectW(&metrics.lfMessageFont);
if font.is_invalid() {
return Err(windows::core::Error::from_thread());
}
for control in [self.address, self.message, self.retry, self.proceed, self.cancel] {
SendMessageW(control, WM_SETFONT, Some(WPARAM(font.0 as usize)), Some(LPARAM(1)));
}
if let Some((_, old)) = self.font.replace(Some((dpi, font))) {
let _ = DeleteObject(old.into());
}
}
MoveWindow(
self.address,
px(8),
px(5),
(width - px(16)).max(0),
px(ADDRESS_HEIGHT),
true,
)?;
// A one-line formatting rectangle centers the native read-only edit text.
// ES_AUTOHSCROLL keeps long URLs on one line and lets users select/copy them.
let mut client = RECT::default();
GetClientRect(self.address, &mut client)?;
let dc = GetDC(Some(self.address));
let previous = SelectObject(dc, self.font.get().expect("font initialized").1.into());
let mut text_metrics = TEXTMETRICW::default();
let measured = GetTextMetricsW(dc, &mut text_metrics);
SelectObject(dc, previous);
ReleaseDC(Some(self.address), dc);
measured.ok()?;
let top = ((client.bottom - text_metrics.tmHeight) / 2).max(0);
let text = RECT {
left: px(6),
top,
right: client.right - px(6),
bottom: top + text_metrics.tmHeight,
};
SendMessageW(
self.address,
EM_SETRECT,
Some(WPARAM(0)),
Some(LPARAM(&text as *const _ as isize)),
);
let status = self.status.get();
let header = if status == RecoveryStatus::Hidden {
TOOLBAR_HEIGHT
} else {
TOOLBAR_HEIGHT + 68
};
MoveWindow(
self.message,
px(8),
px(TOOLBAR_HEIGHT + 2),
(width - px(16)).max(0),
px(38),
true,
)?;
let mut right = width - px(8);
for (hwnd, visible, size) in [
(self.cancel, status.blocks_page(), 70),
(self.proceed, status.can_continue(), 136),
(self.retry, status.can_retry(), 84),
] {
if visible {
right -= px(size);
MoveWindow(hwnd, right, px(TOOLBAR_HEIGHT + 38), px(size), px(28), true)?;
right -= px(6);
}
}
let content_height = (bounds.bottom - px(header)).max(0);
MoveWindow(self.webview_host, 0, px(header), width, content_height, true)?;
state.controller.SetBounds(RECT {
left: 0,
top: 0,
right: width,
bottom: content_height,
})?;
let _ = InvalidateRect(Some(self.parent), None, true);
}
Ok(())
}
}
impl Drop for Controls {
fn drop(&mut self) {
if let Some((_, font)) = self.font.get() {
unsafe {
let _ = DeleteObject(font.into());
}
}
}
}
/// Keep the native edit's selection and accessibility, with a quiet, flat frame.
unsafe extern "system" fn address_proc(
hwnd: HWND,
msg: u32,
wparam: WPARAM,
lparam: LPARAM,
id: usize,
_: usize,
) -> LRESULT {
if msg == WM_NCDESTROY {
unsafe {
let _ = RemoveWindowSubclass(hwnd, Some(address_proc), id);
}
}
let result = unsafe { DefSubclassProc(hwnd, msg, wparam, lparam) };
// EDIT also repaints its frame during WM_PAINT, so style it after native drawing.
if matches!(msg, WM_NCPAINT | WM_PAINT) {
unsafe {
let dc = GetWindowDC(Some(hwnd));
let mut bounds = RECT::default();
if !dc.is_invalid() && GetWindowRect(hwnd, &mut bounds).is_ok() {
let background = GetSysColor(COLOR_3DFACE);
let foreground = GetSysColor(COLOR_WINDOWTEXT);
let mut border = 0;
for shift in [0, 8, 16] {
let channel = (((background >> shift) & 255) * 82 + ((foreground >> shift) & 255) * 18) / 100;
border |= channel << shift;
}
let brush = CreateSolidBrush(COLORREF(border));
FrameRect(
dc,
&RECT {
left: 0,
top: 0,
right: bounds.right - bounds.left,
bottom: bounds.bottom - bounds.top,
},
brush,
);
let _ = DeleteObject(brush.into());
}
ReleaseDC(Some(hwnd), dc);
}
}
result
}
unsafe extern "system" fn window_proc(
hwnd: HWND,
msg: u32,
wparam: WPARAM,
lparam: LPARAM,
id: usize,
key: usize,
) -> LRESULT {
let state = STATES.with_borrow(|states| states.get(&key).cloned());
// Paint the native toolbar and recovery surface outside the child webview.
if msg == WM_ERASEBKGND {
unsafe {
let mut bounds = RECT::default();
if GetClientRect(hwnd, &mut bounds).is_ok() {
FillRect(HDC(wparam.0 as *mut _), &bounds, GetSysColorBrush(COLOR_WINDOW));
}
}
return LRESULT(1);
}
if let Some(state) = &state {
if msg == WM_COMMAND && (wparam.0 >> 16) == BN_CLICKED as usize {
let event = match wparam.0 & 0xffff {
RETRY => Some(AuthEvent::Retry),
PROCEED => Some(AuthEvent::RequestTlsException),
CANCEL => Some(AuthEvent::Close),
_ => None,
};
if let Some(event) = event {
state.messenger.send_auth_event(event);
return LRESULT(0);
}
}
}
let result = unsafe { DefSubclassProc(hwnd, msg, wparam, lparam) };
if msg == WM_SIZE || msg == WM_DPICHANGED {
if let Some(state) = &state {
let _ = state.controls.layout(state);
}
}
if msg == WM_NCDESTROY {
unsafe {
let _ = RemoveWindowSubclass(hwnd, Some(window_proc), id);
}
STATES.with_borrow_mut(|states| states.remove(&key));
if let Some(state) = state {
super::tls::clear_exceptions(&state.core);
}
}
result
}
-128
View File
@@ -1,128 +0,0 @@
use super::super::tls::{TlsFailure, TlsFailureReason};
use super::*;
use std::collections::HashSet;
use webview2_com::{ClearServerCertificateErrorActionsCompletedHandler, ServerCertificateErrorDetectedEventHandler};
use windows::Win32::UI::WindowsAndMessaging::{IDYES, MB_DEFBUTTON2, MB_ICONWARNING, MB_YESNO, MessageBoxW};
#[derive(Default)]
pub(super) struct Policy {
pub ignore_errors: bool,
approved: HashSet<(String, String)>,
pending: Option<Failure>,
}
#[derive(Clone)]
struct Failure {
identity: (String, String),
failure: TlsFailure,
generation: u64,
}
fn reason(error: COREWEBVIEW2_WEB_ERROR_STATUS) -> TlsFailureReason {
match error {
COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_COMMON_NAME_IS_INCORRECT => TlsFailureReason::HostnameMismatch,
COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_EXPIRED => TlsFailureReason::Expired,
_ => TlsFailureReason::InvalidCertificate,
}
}
pub(super) fn install(state: &Rc<State>) -> windows::core::Result<()> {
let weak = Rc::downgrade(state);
let handler = ServerCertificateErrorDetectedEventHandler::create(Box::new(move |_, args| {
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
return Ok(());
};
unsafe {
let uri = text(|p| args.RequestUri(p))?;
let host = url::Url::parse(&uri)
.ok()
.and_then(|url| url.host_str().map(str::to_owned))
.unwrap_or_default();
let pem = text(|p| args.ServerCertificate()?.ToPemEncoding(p))?;
let mut error = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
args.ErrorStatus(&mut error)?;
let identity = (host.clone(), pem);
let mut policy = state.tls.borrow_mut();
if policy.ignore_errors || policy.approved.contains(&identity) {
args.SetAction(COREWEBVIEW2_SERVER_CERTIFICATE_ERROR_ACTION_ALWAYS_ALLOW)?;
} else {
args.SetAction(COREWEBVIEW2_SERVER_CERTIFICATE_ERROR_ACTION_CANCEL)?;
let generation = state.document.borrow().1;
let failure = TlsFailure {
host,
reason: reason(error),
can_continue: error != COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_REVOKED,
};
state
.messenger
.send_auth_event(AuthEvent::Error(generation, AuthError::Tls(failure.clone())));
policy.pending = Some(Failure {
identity,
failure,
generation,
});
}
}
Ok(())
}));
let mut token = 0;
unsafe {
state
.core
.cast::<ICoreWebView2_14>()?
.add_ServerCertificateErrorDetected(&handler, &mut token)
}
}
pub(super) fn confirm(state: &State) -> anyhow::Result<()> {
let pending = state
.tls
.borrow()
.pending
.clone()
.context("No certificate error to confirm")?;
if !pending.failure.can_continue || pending.generation != state.messenger.generation() {
bail!("This certificate exception is no longer available");
}
let answer = unsafe {
MessageBoxW(
Some(state.controls.parent),
&HSTRING::from(pending.failure.confirmation_message()),
&HSTRING::from(pending.failure.confirmation_title()),
MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2,
)
};
if answer == IDYES {
let identity = pending.identity.clone();
let generation = pending.generation;
state.tls.borrow_mut().approved.insert(identity);
state.messenger.send_auth_event(AuthEvent::TlsAccepted(generation));
}
Ok(())
}
// WebView2 caches approvals in the session. Do not leave them for another sign-in window.
pub(super) fn clear_exceptions(core: &ICoreWebView2) {
if let Ok(core) = core.cast::<ICoreWebView2_14>() {
let _ = unsafe {
core.ClearServerCertificateErrorActions(&ClearServerCertificateErrorActionsCompletedHandler::create(Box::new(
|_| Ok(()),
)))
};
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn maps_certificate_failure_reasons() {
assert_eq!(
reason(COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_COMMON_NAME_IS_INCORRECT),
TlsFailureReason::HostnameMismatch
);
assert_eq!(
reason(COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_EXPIRED),
TlsFailureReason::Expired
);
}
}
+1 -4
View File
@@ -16,7 +16,4 @@ which = { workspace = true, optional = true }
[features]
default = []
launcher = ["dep:open", "dep:webbrowser", "dep:which", "dep:winreg"]
[target.'cfg(windows)'.dependencies]
winreg = { version = "0.55", optional = true }
launcher = ["dep:open", "dep:webbrowser", "dep:which"]
+2 -5
View File
@@ -1,11 +1,8 @@
#[cfg(all(feature = "launcher", windows))]
#[path = "platform/windows.rs"]
mod platform;
#[cfg(all(feature = "launcher", target_os = "macos"))]
#[path = "platform/macos.rs"]
mod platform;
#[cfg(all(feature = "launcher", unix, not(target_os = "macos")))]
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
#[path = "platform/generic.rs"]
mod platform;
@@ -41,7 +38,7 @@ impl<'a> Browser<'a> {
}
}
#[cfg(all(feature = "launcher", unix, not(target_os = "macos")))]
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
pub(crate) fn as_str(&self) -> &str {
match self {
Browser::Auto => "auto",
@@ -1,35 +0,0 @@
//! Windows browsers are resolved through their registered App Paths.
use crate::Browser;
use anyhow::{Context, bail};
use std::path::PathBuf;
use winreg::{
RegKey,
enums::{HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE},
};
pub(super) fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
let executable = match browser {
Browser::Auto | Browser::Default => return webbrowser::open(url).context("Could not open the browser"),
Browser::Chrome => registered_browser("chrome.exe").context("Chrome is not installed")?,
Browser::Edge => registered_browser("msedge.exe").context("Edge is not installed")?,
Browser::Firefox => registered_browser("firefox.exe").context("Firefox is not installed")?,
Browser::Safari => bail!("Safari is not available on Windows"),
Browser::Other(program) => PathBuf::from(program),
};
std::process::Command::new(executable)
.arg(url)
.spawn()
.context("Could not open the configured browser")?;
Ok(())
}
fn registered_browser(name: &str) -> Option<PathBuf> {
[HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE].into_iter().find_map(|hive| {
let key = RegKey::predef(hive)
.open_subkey(format!(r"Software\Microsoft\Windows\CurrentVersion\App Paths\{name}"))
.ok()?;
let path: String = key.get_value("").ok()?;
let path = PathBuf::from(path.trim_matches('"'));
path.is_file().then_some(path)
})
}
+5 -10
View File
@@ -5,16 +5,11 @@ fn main() {
let workspace_dir = Path::new(manifest_dir).ancestors().nth(2).unwrap();
let gpgui_dir = workspace_dir.parent().unwrap().join("gpgui");
let suffix = if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
".exe"
} else {
""
};
let gp_service_binary = workspace_dir.join(format!("target/debug/gpservice{suffix}"));
let gp_client_binary = workspace_dir.join(format!("target/debug/gpclient{suffix}"));
let gp_auth_binary = workspace_dir.join(format!("target/debug/gpauth{suffix}"));
let gp_gui_helper_binary = workspace_dir.join(format!("target/debug/gpgui-helper{suffix}"));
let gp_gui_binary = gpgui_dir.join(format!("target/debug/gpgui{suffix}"));
let gp_service_binary = workspace_dir.join("target/debug/gpservice");
let gp_client_binary = workspace_dir.join("target/debug/gpclient");
let gp_auth_binary = workspace_dir.join("target/debug/gpauth");
let gp_gui_helper_binary = workspace_dir.join("target/debug/gpgui-helper");
let gp_gui_binary = gpgui_dir.join("target/debug/gpgui");
println!("cargo:rustc-env=GP_SERVICE_BINARY={}", gp_service_binary.display());
println!("cargo:rustc-env=GP_CLIENT_BINARY={}", gp_client_binary.display());
+1 -1
View File
@@ -89,7 +89,7 @@ fn sibling_binary(binary_name: &str) -> Option<PathBuf> {
fn sibling_binary_for_executable(executable: &Path, binary_name: &str) -> Option<PathBuf> {
let executable = executable.canonicalize().ok()?;
let bin_dir = executable.parent()?;
let binary = bin_dir.join(format!("{binary_name}{}", std::env::consts::EXE_SUFFIX));
let binary = bin_dir.join(binary_name);
if is_file(&binary) {
return Some(binary);
}
+1
View File
@@ -2,6 +2,7 @@ pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
pub const GP_CLIENT_VERSION_LINUX: &str = "6.3.3-619";
pub const GP_CLIENT_VERSION_WINDOWS: &str = "6.3.3-650";
pub const GP_CLIENT_VERSION_MACOS: &str = "6.3.3-915";
pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
#[cfg(target_os = "linux")]
pub const GP_VPNC_SCRIPT_INSTALLER_BINARY: &str = "/usr/libexec/gpclient/gp-vpnc-script-installer";
#[cfg(target_os = "linux")]
-1
View File
@@ -1,3 +1,2 @@
pub mod binary_paths;
pub mod constants;
pub mod paths;
-32
View File
@@ -1,32 +0,0 @@
//! Machine-wide service state shared by the daemon and desktop clients.
use std::path::PathBuf;
pub fn service_lock_file() -> PathBuf {
#[cfg(unix)]
{
PathBuf::from("/var/run/gpservice.lock")
}
#[cfg(windows)]
{
std::env::var_os("ProgramData")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from(r"C:\ProgramData"))
.join("GP Connect")
.join("gpservice.lock")
}
}
#[cfg(windows)]
pub const SERVICE_PIPE: &str = r"\\.\pipe\GPConnect.Service";
#[cfg(windows)]
pub const SERVICE_NAME: &str = "GPConnect";
/// Installer-owned SYSTEM/Administrators-only state, including temporary keys.
#[cfg(windows)]
pub fn service_private_dir() -> PathBuf {
service_lock_file()
.parent()
.expect("service state directory")
.join("Private")
}
+2 -10
View File
@@ -6,6 +6,7 @@ edition.workspace = true
license = "MIT"
[dependencies]
nix = { version = "0.31", features = ["fs", "signal", "process"], optional = true }
common = { path = "../common" }
anyhow.workspace = true
base64.workspace = true
@@ -34,6 +35,7 @@ thiserror.workspace = true
chacha20poly1305 = { version = "0.11", features = ["zeroize"] }
url.workspace = true
regex.workspace = true
uzers = { workspace = true, optional = true }
serde_urlencoded.workspace = true
md5.workspace = true
sha2.workspace = true
@@ -88,13 +90,3 @@ tauri = ["desktop", "dep:tauri", "dep:gtk", "dep:os_info"]
clap = ["desktop", "dep:clap", "dep:clap-verbosity-flag"]
webview-auth = []
logger = ["desktop", "dep:env_logger", "dep:log-reload", "dep:oslog"]
[target.'cfg(unix)'.dependencies]
nix = { version = "0.31", features = ["fs", "signal", "process"], optional = true }
uzers = { workspace = true, optional = true }
[target.'cfg(windows)'.dependencies]
windows-sys = { version = "0.61", features = ["Win32_NetworkManagement_IpHelper", "Win32_NetworkManagement_Ndis", "Win32_Networking_WinSock", "Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_Pipes", "Win32_System_Threading", "Win32_System_Services", "Win32_Globalization", "Win32_System_Environment", "Win32_System_JobObjects", "Win32_System_IO"] }
[target.'cfg(windows)'.dev-dependencies]
windows-sys = { version = "0.61", features = ["Win32_UI_Shell"] }
+2 -16
View File
@@ -10,7 +10,6 @@ pub enum AnchorSource {
UnixMac,
UnixRandom,
MacosIokit,
WindowsSmbios,
}
impl From<AnchorSource> for u8 {
@@ -19,7 +18,6 @@ impl From<AnchorSource> for u8 {
AnchorSource::UnixMac => 1,
AnchorSource::UnixRandom => 2,
AnchorSource::MacosIokit => 3,
AnchorSource::WindowsSmbios => 4,
}
}
}
@@ -43,7 +41,6 @@ impl TryFrom<u8> for AnchorSource {
1 => Ok(Self::UnixMac),
2 => Ok(Self::UnixRandom),
3 => Ok(Self::MacosIokit),
4 => Ok(Self::WindowsSmbios),
value => Err(InvalidAnchorSource(value)),
}
}
@@ -68,7 +65,6 @@ impl DeviceAnchor {
AnchorSource::UnixMac => b"gp-device-anchor:v1:unix-mac:".as_slice(),
AnchorSource::UnixRandom => b"gp-device-anchor:v1:unix-random:".as_slice(),
AnchorSource::MacosIokit => b"gp-device-anchor:v1:macos-platform-uuid:".as_slice(),
AnchorSource::WindowsSmbios => b"gp-device-anchor:v1:windows-smbios-uuid:".as_slice(),
};
let mut input = domain.to_vec();
input.extend_from_slice(seed.as_ref());
@@ -85,7 +81,7 @@ mod tests {
#[test]
fn preserves_existing_hardware_ids_for_all_sources() {
let cases: [(AnchorSource, &[u8], &str); 4] = [
let cases: [(AnchorSource, &[u8], &str); 3] = [
(
AnchorSource::UnixMac,
&[0, 17, 34, 51, 68, 85],
@@ -101,11 +97,6 @@ mod tests {
b"12345678-1234-5678-9abc-def012345678",
"K1KMtAwiOiXKQvQuRmTDKPA6-ZPF5QKUWZzmvRzeP34",
),
(
AnchorSource::WindowsSmbios,
b"12345678-1234-5678-9abc-def012345678",
"C843jG-lDX91Tab02VelrMJl_OmOji_pCtNWilwzW5s",
),
];
for (source, seed, expected) in cases {
let anchor = DeviceAnchor::derive(source, seed);
@@ -133,17 +124,12 @@ mod tests {
assert_eq!(serde_json::to_string(&AnchorSource::UnixMac).unwrap(), "1");
assert_eq!(serde_json::to_string(&AnchorSource::UnixRandom).unwrap(), "2");
assert_eq!(serde_json::to_string(&AnchorSource::MacosIokit).unwrap(), "3");
assert_eq!(serde_json::to_string(&AnchorSource::WindowsSmbios).unwrap(), "4");
assert_eq!(
serde_json::from_str::<AnchorSource>("4").unwrap(),
AnchorSource::WindowsSmbios
);
assert_eq!(
serde_json::from_str::<AnchorSource>("1").unwrap(),
AnchorSource::UnixMac
);
assert!(serde_json::from_str::<AnchorSource>("0").is_err());
assert!(serde_json::from_str::<AnchorSource>("5").is_err());
assert!(serde_json::from_str::<AnchorSource>("4").is_err());
assert!(serde_json::from_str::<AnchorSource>(r#""unix_mac""#).is_err());
}
}
-3
View File
@@ -31,6 +31,3 @@ pub mod clap;
#[cfg(feature = "desktop")]
pub mod script_tun;
#[cfg(all(feature = "desktop", windows))]
pub mod windows;
+1 -37
View File
@@ -236,7 +236,7 @@ impl<'a> SamlAuthLauncher<'a> {
}
#[cfg(feature = "webview-auth")]
if self.browser.is_none() {
{
if self.hidpi {
auth_cmd.arg("--hidpi");
}
@@ -409,42 +409,6 @@ mod tests {
assert!(args.iter().any(|arg| arg == "--ignore-tls-errors"));
}
#[cfg(feature = "webview-auth")]
#[test]
fn external_browser_receives_no_embedded_window_arguments() {
let args = child_args(
SamlAuthLauncher::new("vpn.example.com")
.browser(Some("edge"))
.clean(true)
.hidpi(true)
.window_title("GP Connect Login")
.window_theme(AuthWindowTheme::Dark),
);
assert!(args.windows(2).any(|pair| pair == ["--browser", "edge"]));
for option in ["--clean", "--hidpi", "--window-title", "--window-theme"] {
assert!(!args.iter().any(|arg| arg == option), "unexpected {option} in {args:?}");
}
}
#[cfg(feature = "webview-auth")]
#[test]
fn embedded_window_receives_auth_preferences() {
let args = child_args(
SamlAuthLauncher::new("vpn.example.com")
.clean(true)
.window_title("GP Connect Login")
.window_theme(AuthWindowTheme::Dark),
);
assert!(args.iter().any(|arg| arg == "--clean"));
assert!(
args
.windows(2)
.any(|pair| pair == ["--window-title", "GP Connect Login"])
);
assert!(args.windows(2).any(|pair| pair == ["--window-theme", "dark"]));
assert!(!args.iter().any(|arg| arg == "--browser"));
}
#[test]
fn os_profile_sets_os_from_profile() {
let profile = OsProfileBuilder::new(ClientOs::Linux)
-21
View File
@@ -1,41 +1,20 @@
#[cfg(unix)]
mod command_runner;
#[cfg(windows)]
#[path = "windows/command_runner.rs"]
mod command_runner;
#[cfg(unix)]
mod command_traits;
#[cfg(windows)]
#[path = "windows/command_traits.rs"]
mod command_traits;
#[cfg(unix)]
mod desktop_child;
#[cfg(unix)]
mod desktop_session_env;
#[cfg(unix)]
pub(crate) mod gui_helper_launcher;
pub use command_traits::CommandExt;
pub mod auth_launcher;
#[cfg(unix)]
pub mod desktop_launcher;
#[cfg(unix)]
pub mod gui_launcher;
#[cfg(any(target_os = "linux", test))]
pub mod gui_switch;
#[cfg(any(target_os = "linux", test))]
mod nsh_runtime;
#[cfg(unix)]
pub mod users;
#[cfg(unix)]
pub mod collection;
#[cfg(windows)]
#[path = "windows/collection.rs"]
pub mod collection;
pub mod rendering_recovery;
#[cfg(windows)]
#[path = "windows/user_process.rs"]
pub mod user_process;
@@ -49,17 +49,11 @@ impl RecoveryState {
}
}
#[cfg(unix)]
pub(crate) fn is_crash_exit(status: ExitStatus) -> bool {
use std::os::unix::process::ExitStatusExt;
!status.success() && !matches!(status.signal(), Some(1 | 2 | 9 | 15))
}
#[cfg(windows)]
pub(crate) fn is_crash_exit(status: ExitStatus) -> bool {
status.code().is_some_and(|code| (code as u32) >= 0xC0000000)
}
pub fn eligible(command: &Command) -> bool {
eligible_with_inheritance(command, true)
}
@@ -1,42 +0,0 @@
//! Resolve system collectors from Windows' system directory, never the working directory.
use super::command_runner::run_controlled;
use crate::collection::CollectionControl;
use std::{
io,
path::{Path, PathBuf},
process::{Command, Output},
};
pub struct CollectorCommands<'a> {
control: &'a dyn CollectionControl,
}
impl<'a> CollectorCommands<'a> {
pub fn new(control: &'a dyn CollectionControl) -> Self {
Self { control }
}
pub fn resolve(&self, name: &str) -> Option<PathBuf> {
let system = std::env::var_os("SystemRoot")?;
let path = PathBuf::from(system).join("System32").join(name).with_extension("exe");
path.is_file().then_some(path)
}
pub fn run(&self, name: &str, args: &[&str]) -> io::Result<Option<Output>> {
self.control.check()?;
match self.resolve(name) {
Some(path) => self.run_path(&path, args),
None => Ok(None),
}
}
pub fn run_executable(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
self.run_path(path, args)
}
pub fn run_path(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
self.control.check()?;
let mut command = Command::new(path);
command.args(args);
match run_controlled(command, self.control, 256 * 1024) {
Ok(output) => Ok(Some(output)),
Err(error) if matches!(error.kind(), io::ErrorKind::NotFound | io::ErrorKind::PermissionDenied) => Ok(None),
Err(error) => Err(error),
}
}
}
@@ -1,198 +0,0 @@
//! Controlled Windows child execution. Pipe polling keeps cancellation responsive.
use crate::collection::CollectionControl;
use std::{
io::{self, Read, Write},
os::windows::io::AsRawHandle,
process::{Child, Command, Output, Stdio},
thread,
time::Duration,
};
use windows_sys::Win32::System::Pipes::PeekNamedPipe;
pub(crate) enum ChildInput<'a> {
Null,
Terminal,
// Preserve the borrowed input type shared by callers without a Windows launcher.
#[allow(dead_code)]
Frame(&'a [u8]),
}
#[derive(Debug)]
pub(crate) struct ObservedOutput {
pub output: Output,
}
pub(crate) fn run_controlled(command: Command, control: &dyn CollectionControl, limit: usize) -> io::Result<Output> {
run_observed(
command,
control,
Some(limit),
&mut |_| {},
&mut io::sink(),
ChildInput::Null,
)
.map(|observed| observed.output)
}
pub(crate) fn run_observed(
mut command: Command,
control: &dyn CollectionControl,
output_limit: Option<usize>,
observer: &mut dyn FnMut(&[u8]),
stderr_sink: &mut dyn Write,
stdin: ChildInput<'_>,
) -> io::Result<ObservedOutput> {
control.check()?;
// Windows desktop processes must not open a console for each helper.
use std::os::windows::process::CommandExt;
if !matches!(stdin, ChildInput::Terminal) {
command.creation_flags(0x08000000); // CREATE_NO_WINDOW
}
command.stdout(if output_limit.is_some() {
Stdio::piped()
} else {
Stdio::inherit()
});
command.stderr(Stdio::piped());
command.stdin(match stdin {
ChildInput::Terminal => Stdio::inherit(),
ChildInput::Null => Stdio::null(),
ChildInput::Frame(_) => Stdio::piped(),
});
let mut child = ControlledChild(command.spawn()?);
let input = if let ChildInput::Frame(frame) = stdin {
let mut pipe = child.0.stdin.take().expect("piped stdin");
let frame = frame.to_vec();
Some(thread::spawn(move || pipe.write_all(&frame)))
} else {
None
};
let mut stdout = child.0.stdout.take();
let mut stderr = child.0.stderr.take().expect("piped stderr");
let mut output = Vec::new();
let mut buffer = [0u8; 8192];
loop {
control.check()?;
if let Some(pipe) = &mut stdout {
let length = read_available(pipe, &mut buffer)?;
if length > output_limit.unwrap().saturating_sub(output.len()) {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Command output exceeds its limit",
));
}
output.extend_from_slice(&buffer[..length]);
}
let length = read_available(&mut stderr, &mut buffer)?;
observer(&buffer[..length]);
stderr_sink.write_all(&buffer[..length])?;
if let Some(status) = child.0.try_wait()? {
// Drain the remaining buffered output after the process exits.
if let Some(pipe) = &mut stdout {
loop {
let length = read_available(pipe, &mut buffer)?;
if length == 0 {
break;
}
if length > output_limit.unwrap().saturating_sub(output.len()) {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Command output exceeds its limit",
));
}
output.extend_from_slice(&buffer[..length]);
}
}
loop {
let length = read_available(&mut stderr, &mut buffer)?;
if length == 0 {
break;
}
observer(&buffer[..length]);
stderr_sink.write_all(&buffer[..length])?;
}
if let Some(result) = input.and_then(|worker| worker.join().ok()) {
result?;
}
return Ok(ObservedOutput {
output: Output {
status,
stdout: output,
stderr: Vec::new(),
},
});
}
thread::sleep(Duration::from_millis(10));
}
}
fn read_available(pipe: &mut (impl Read + AsRawHandle), buffer: &mut [u8]) -> io::Result<usize> {
let mut available = 0;
let success = unsafe {
PeekNamedPipe(
pipe.as_raw_handle(),
std::ptr::null_mut(),
0,
std::ptr::null_mut(),
&mut available,
std::ptr::null_mut(),
)
};
if success == 0 {
let error = io::Error::last_os_error();
if error.raw_os_error() == Some(109) {
return Ok(0);
} // ERROR_BROKEN_PIPE
return Err(error);
}
let length = buffer.len().min(available as usize);
if length == 0 {
return Ok(0);
}
pipe.read(&mut buffer[..length])
}
struct ControlledChild(Child);
impl Drop for ControlledChild {
fn drop(&mut self) {
let _ = self.0.kill();
let _ = self.0.wait();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn captures_output_and_rejects_excess_output() {
let mut command = Command::new("cmd.exe");
command.args(["/D", "/C", "echo hello"]);
let result = run_controlled(command, &|| Ok(()), 1024).unwrap();
assert!(result.status.success());
assert_eq!(String::from_utf8(result.stdout).unwrap().trim(), "hello");
let mut command = Command::new("cmd.exe");
command.args(["/D", "/C", "echo too much"]);
assert_eq!(
run_controlled(command, &|| Ok(()), 2).unwrap_err().kind(),
io::ErrorKind::InvalidData
);
}
#[test]
fn cancels_a_running_helper() {
let start = std::time::Instant::now();
let mut command = Command::new("powershell.exe");
command.args(["-NoProfile", "-Command", "Start-Sleep -Seconds 30"]);
let control = || {
if start.elapsed() > Duration::from_millis(150) {
Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"))
} else {
Ok(())
}
};
assert_eq!(
run_controlled(command, &control, 1024).unwrap_err().kind(),
io::ErrorKind::Interrupted
);
assert!(start.elapsed() < Duration::from_secs(3));
}
}
@@ -1,12 +0,0 @@
use tokio::process::Command;
/// Windows authentication runs in the interactive user's GUI process.
pub trait CommandExt {
fn into_non_root(self) -> anyhow::Result<Command>;
}
impl CommandExt for Command {
fn into_non_root(self) -> anyhow::Result<Command> {
Ok(self)
}
}
@@ -1,309 +0,0 @@
//! Launch a native worker with the admitted user's primary token and environment.
use std::{
ffi::{OsStr, c_void},
io,
os::windows::{
ffi::OsStrExt,
io::{AsRawHandle, BorrowedHandle, FromRawHandle, OwnedHandle},
},
path::Path,
ptr,
};
use windows_sys::Win32::{
Foundation::{WAIT_OBJECT_0, WAIT_TIMEOUT},
Globalization::{CSTR_EQUAL, CompareStringOrdinal},
Security::{ImpersonateLoggedOnUser, RevertToSelf},
System::{
Environment::{CreateEnvironmentBlock, DestroyEnvironmentBlock},
JobObjects::*,
Threading::*,
},
};
pub struct UserProcess {
process: OwnedHandle,
job: Option<OwnedHandle>,
pid: u32,
}
struct Environment(*mut c_void);
impl Drop for Environment {
fn drop(&mut self) {
unsafe {
DestroyEnvironmentBlock(self.0);
}
}
}
fn invalid(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, message)
}
fn wide(value: &OsStr) -> io::Result<Vec<u16>> {
let value: Vec<_> = value.encode_wide().collect();
if value.contains(&0) {
return Err(invalid("Windows process strings cannot contain NUL"));
}
Ok(value)
}
fn quote(argument: &[u16], output: &mut Vec<u16>) {
output.push(b'"' as u16);
let mut backslashes = 0;
for &character in argument {
if character == b'\\' as u16 {
backslashes += 1;
continue;
}
let count = if character == b'"' as u16 {
backslashes * 2 + 1
} else {
backslashes
};
output.extend(std::iter::repeat_n(b'\\' as u16, count));
output.push(character);
backslashes = 0;
}
output.extend(std::iter::repeat_n(b'\\' as u16, backslashes * 2));
output.push(b'"' as u16);
}
fn command_line(program: &[u16], arguments: &[String]) -> io::Result<Vec<u16>> {
let mut output = Vec::new();
quote(program, &mut output);
for argument in arguments {
output.push(b' ' as u16);
quote(&wide(OsStr::new(argument))?, &mut output);
}
output.push(0);
if output.len() > 32767 {
return Err(invalid("Windows worker command line is too long"));
}
Ok(output)
}
fn key(entry: &[u16]) -> &[u16] {
let end = entry
.iter()
.enumerate()
.find(|(index, value)| *index != 0 && **value == b'=' as u16)
.map(|(index, _)| index)
.unwrap_or(entry.len());
&entry[..end]
}
fn compare(left: &[u16], right: &[u16]) -> std::cmp::Ordering {
// Environment names follow Windows' ordinal, case-insensitive ordering.
unsafe { CompareStringOrdinal(left.as_ptr(), left.len() as i32, right.as_ptr(), right.len() as i32, 1) }
.cmp(&CSTR_EQUAL)
}
fn user_environment(token: BorrowedHandle<'_>, variables: &[(&str, &str)]) -> io::Result<Vec<u16>> {
let mut pointer = ptr::null_mut();
if unsafe { CreateEnvironmentBlock(&mut pointer, token.as_raw_handle(), 0) } == 0 {
return Err(io::Error::last_os_error());
}
let environment = Environment(pointer);
let mut entries = Vec::new();
unsafe {
let mut current = environment.0.cast::<u16>();
while *current != 0 {
let mut length = 0;
while *current.add(length) != 0 {
length += 1;
}
entries.push(std::slice::from_raw_parts(current, length).to_vec());
current = current.add(length + 1);
}
}
for (name, value) in variables {
if name.is_empty() || name.contains('=') {
return Err(invalid("Invalid worker environment name"));
}
let name = wide(OsStr::new(name))?;
let value = wide(OsStr::new(value))?;
entries.retain(|entry| compare(key(entry), &name) != std::cmp::Ordering::Equal);
let mut entry = name;
entry.push(b'=' as u16);
entry.extend(value);
entries.push(entry);
}
entries.sort_by(|left, right| compare(key(left), key(right)));
let mut block = Vec::new();
for entry in entries {
block.extend(entry);
block.push(0);
}
if block.is_empty() {
block.push(0);
}
block.push(0);
Ok(block)
}
impl UserProcess {
/// No service handles or service environment are inherited. The user token
/// determines the Windows session, including an existing interactive desktop.
pub fn launch(
token: BorrowedHandle<'_>,
program: &Path,
arguments: &[String],
variables: &[(&str, &str)],
) -> io::Result<Self> {
if !program.is_absolute() {
return Err(invalid("Windows worker executable must be absolute"));
}
let mut executable = wide(program.as_os_str())?;
let mut command = command_line(&executable, arguments)?;
executable.push(0);
let mut environment = user_environment(token, variables)?;
let directory = program.parent().ok_or_else(|| invalid("Worker directory is missing"))?;
let mut directory = wide(directory.as_os_str())?;
directory.push(0);
let job = unsafe { CreateJobObjectW(ptr::null(), ptr::null()) };
if job.is_null() {
return Err(io::Error::last_os_error());
}
let job = unsafe { OwnedHandle::from_raw_handle(job) };
let limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION {
LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
..Default::default()
},
..Default::default()
};
if unsafe {
SetInformationJobObject(
job.as_raw_handle(),
JobObjectExtendedLimitInformation,
(&limits as *const JOBOBJECT_EXTENDED_LIMIT_INFORMATION).cast(),
std::mem::size_of_val(&limits) as u32,
)
} == 0
{
return Err(io::Error::last_os_error());
}
let mut desktop: Vec<u16> = "winsta0\\default".encode_utf16().chain(Some(0)).collect();
let startup = STARTUPINFOW {
cb: std::mem::size_of::<STARTUPINFOW>() as u32,
lpDesktop: desktop.as_mut_ptr(),
..Default::default()
};
let mut information = PROCESS_INFORMATION::default();
// Read/execute the requested image as its user, as Unix exec-after-setuid
// does. The service's filesystem access must not authorize a private image.
if unsafe { ImpersonateLoggedOnUser(token.as_raw_handle()) } == 0 {
return Err(io::Error::last_os_error());
}
struct Revert;
impl Drop for Revert {
fn drop(&mut self) {
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
}
}
let revert = Revert;
let created = unsafe {
CreateProcessAsUserW(
token.as_raw_handle(),
executable.as_ptr(),
command.as_mut_ptr(),
ptr::null(),
ptr::null(),
0,
CREATE_UNICODE_ENVIRONMENT | CREATE_SUSPENDED | CREATE_NO_WINDOW,
environment.as_mut_ptr().cast(),
directory.as_ptr(),
&startup,
&mut information,
)
};
let error = (created == 0).then(io::Error::last_os_error);
drop(revert);
if let Some(error) = error {
return Err(error);
}
let process = unsafe { OwnedHandle::from_raw_handle(information.hProcess) };
let thread = unsafe { OwnedHandle::from_raw_handle(information.hThread) };
if unsafe { AssignProcessToJobObject(job.as_raw_handle(), process.as_raw_handle()) } == 0 {
let error = io::Error::last_os_error();
// The suspended child is not owned by the job on this failure path.
unsafe {
TerminateProcess(process.as_raw_handle(), 1);
WaitForSingleObject(process.as_raw_handle(), 5000);
}
return Err(error);
}
let child = Self {
process,
job: Some(job),
pid: information.dwProcessId,
};
if unsafe { ResumeThread(thread.as_raw_handle()) } == u32::MAX {
return Err(io::Error::last_os_error());
}
Ok(child)
}
pub fn id(&self) -> u32 {
self.pid
}
pub fn has_exited(&self) -> io::Result<bool> {
match unsafe { WaitForSingleObject(self.process.as_raw_handle(), 0) } {
WAIT_OBJECT_0 => Ok(true),
WAIT_TIMEOUT => Ok(false),
_ => Err(io::Error::last_os_error()),
}
}
pub fn stop(&mut self) -> io::Result<()> {
if self.job.take().is_none() {
return Ok(());
}
match unsafe { WaitForSingleObject(self.process.as_raw_handle(), 5000) } {
WAIT_OBJECT_0 => Ok(()),
WAIT_TIMEOUT => Err(io::Error::new(
io::ErrorKind::TimedOut,
"Windows worker did not terminate",
)),
_ => Err(io::Error::last_os_error()),
}
}
}
impl Drop for UserProcess {
fn drop(&mut self) {
if let Err(error) = self.stop() {
log::warn!("Could not stop Windows worker: {error}");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use windows_sys::Win32::{Foundation::LocalFree, UI::Shell::CommandLineToArgvW};
#[test]
fn command_line_round_trips_through_windows_parser() {
let program: Vec<u16> = r"C:\Program Files\GP Connect\gpgui-nsh.exe".encode_utf16().collect();
let arguments = [
"proxy-worker",
"",
"space value",
"quoted\"value",
"two\\\\\"quotes",
"trailing\\",
"雪",
"&|<>",
]
.map(String::from);
let command = command_line(&program, &arguments).unwrap();
let mut count = 0;
unsafe {
let parsed = CommandLineToArgvW(command.as_ptr(), &mut count);
assert!(!parsed.is_null());
let result = std::slice::from_raw_parts(parsed, count as usize)
.iter()
.map(|&value| {
let mut length = 0;
while *value.add(length) != 0 {
length += 1;
}
String::from_utf16_lossy(std::slice::from_raw_parts(value, length))
})
.collect::<Vec<_>>();
LocalFree(parsed.cast());
assert_eq!(result[0], String::from_utf16_lossy(&program));
assert_eq!(result[1..], arguments);
}
}
}
@@ -187,28 +187,19 @@ mod tests {
#[test]
fn credential_round_trips_a_validated_device_anchor() {
use crate::device_anchor::AnchorSource;
for (source, wire_source) in [
(AnchorSource::UnixMac, 1),
(AnchorSource::UnixRandom, 2),
(AnchorSource::MacosIokit, 3),
(AnchorSource::WindowsSmbios, 4),
] {
let anchor = DeviceAnchor {
hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]),
source,
};
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5")
.unwrap()
.with_device_anchor(anchor.clone())
.unwrap();
let frame = credential.encode_frame().unwrap();
let payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
assert_eq!(payload["device_anchor"]["source"], wire_source);
let decoded = SessionCredential::decode_frame(&frame).unwrap();
assert_eq!(decoded.device_anchor(), Some(&anchor));
}
let anchor = DeviceAnchor {
hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]),
source: crate::device_anchor::AnchorSource::UnixMac,
};
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5")
.unwrap()
.with_device_anchor(anchor.clone())
.unwrap();
let frame = credential.encode_frame().unwrap();
let payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
assert_eq!(payload["device_anchor"]["source"], 1);
let decoded = SessionCredential::decode_frame(&frame).unwrap();
assert_eq!(decoded.device_anchor(), Some(&anchor));
}
#[test]
@@ -218,7 +209,7 @@ mod tests {
let mut payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
let hardware_id = general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]);
for source in [0, u8::MAX] {
for source in [0, 4] {
payload["device_anchor"] = serde_json::json!({
"hardware_id": hardware_id,
"source": source
@@ -11,8 +11,6 @@ pub use message::{ClientMessage, ServerMessage, ServiceRejection, ServiceResult}
pub use noise::{NoiseInitiator, NoiseResponder, NoiseTransport};
pub const MAX_CREDENTIAL_FRAME: usize = 512;
/// First request read before a Windows service captures its pipe client's token.
pub const WINDOWS_ADMISSION_REQUEST: [u8; 4] = *b"GPC1";
pub const MAX_PRELUDE: usize = 256;
pub const MAX_PRODUCT_VERSION: usize = 64;
pub const HIP_PROTOCOL_VERSION: u16 = 1;
@@ -29,11 +29,6 @@ use linux as platform;
#[cfg(target_os = "macos")]
use macos as platform;
#[cfg(windows)]
mod windows;
#[cfg(windows)]
use windows as platform;
mod binding;
use super::detection;
pub mod native;
@@ -480,7 +475,6 @@ fn snapshot(interfaces: &[Interface], control: &dyn CollectionControl) -> anyhow
})
}
#[cfg(unix)]
fn command(name: &str, args: &[&str], control: &dyn CollectionControl) -> anyhow::Result<String> {
let output = CollectorCommands::new(control)
.run(name, args)?
@@ -1,148 +0,0 @@
//! Windows network identity from IP Helper and adapter DNS configuration.
use super::*;
use std::os::windows::io::AsRawSocket;
use windows_sys::Win32::{
NetworkManagement::IpHelper::{
DNS_INTERFACE_SETTINGS, DNS_INTERFACE_SETTINGS_VERSION1, FreeInterfaceDnsSettings, FreeMibTable,
GetInterfaceDnsSettings, GetIpForwardTable2,
},
Networking::WinSock::{
AF_INET, AF_INET6, AF_UNSPEC, IP_UNICAST_IF, IPPROTO_IP, IPPROTO_IPV6, IPV6_UNICAST_IF, SOCKADDR_INET,
SOCKET_ERROR, WSAGetLastError, setsockopt,
},
};
pub(super) fn scope_resolver_socket(
socket: &tokio::net::UdpSocket,
interface: &Interface,
endpoint: SocketAddr,
) -> anyhow::Result<()> {
ensure!(interface.index != 0, "Resolver interface index is missing");
// IP_UNICAST_IF uses network byte order; IPV6_UNICAST_IF uses host byte order.
let (level, option, index) = if endpoint.is_ipv4() {
(IPPROTO_IP, IP_UNICAST_IF, interface.index.to_be())
} else {
(IPPROTO_IPV6, IPV6_UNICAST_IF, interface.index)
};
let result = unsafe {
setsockopt(
socket.as_raw_socket() as usize,
level,
option,
(&index as *const u32).cast(),
std::mem::size_of::<u32>() as i32,
)
};
if result == SOCKET_ERROR {
return Err(io::Error::from_raw_os_error(unsafe { WSAGetLastError() }).into());
}
Ok(())
}
pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result<Vec<RouteContext>> {
control.check()?;
let mut table = std::ptr::null_mut();
let status = unsafe { GetIpForwardTable2(AF_UNSPEC, &mut table) };
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32).into());
}
let interfaces = netdev::get_interfaces();
let result = unsafe {
let rows = std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize);
rows
.iter()
.filter_map(|row| {
let destination = address(&row.DestinationPrefix.Prefix)?;
let gateway = address(&row.NextHop)?;
let interface = interfaces
.iter()
.find(|interface| interface.index == row.InterfaceIndex)?;
Some(RouteContext {
destination: format!("{destination}/{}", row.DestinationPrefix.PrefixLength),
gateway: gateway.to_string(),
interface: interface.name.clone(),
table: "main".into(),
metric: row.Metric.to_string(),
})
})
.collect()
};
unsafe {
FreeMibTable(table.cast());
}
control.check()?;
Ok(result)
}
unsafe fn address(address: &SOCKADDR_INET) -> Option<IpAddr> {
unsafe {
match address.si_family {
AF_INET => Some(std::net::Ipv4Addr::from(address.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into()),
AF_INET6 => Some(std::net::Ipv6Addr::from(address.Ipv6.sin6_addr.u.Byte).into()),
_ => None,
}
}
}
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
control.check()?;
let mut resolvers = netdev::get_interfaces()
.into_iter()
.filter(|interface| !interface.dns_servers.is_empty())
.map(|interface| {
Ok(ResolverContext {
interface: Some(interface.name.clone()),
servers: interface.dns_servers.iter().map(ToString::to_string).collect(),
domains: resolver_domains(&interface.name)?,
})
})
.collect::<anyhow::Result<Vec<_>>>()?;
resolvers.sort();
control.check()?;
Ok(resolvers)
}
fn resolver_domains(interface: &str) -> anyhow::Result<Vec<String>> {
let id = uuid::Uuid::parse_str(interface.trim_matches(['{', '}']))?;
let (data1, data2, data3, data4) = id.as_fields();
let guid = windows_sys::core::GUID {
data1,
data2,
data3,
data4: *data4,
};
let mut settings = DNS_INTERFACE_SETTINGS {
Version: DNS_INTERFACE_SETTINGS_VERSION1,
..Default::default()
};
let status = unsafe { GetInterfaceDnsSettings(guid, &mut settings) };
if status != 0 {
return Err(io::Error::from_raw_os_error(status as i32).into());
}
let mut domains = Vec::new();
for pointer in [settings.Domain, settings.SearchList] {
if pointer.is_null() {
continue;
}
let text = unsafe {
let mut length = 0;
while *pointer.add(length) != 0 {
length += 1;
}
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
};
for domain in text
.split(|ch: char| ch == ',' || ch.is_whitespace())
.filter(|domain| !domain.is_empty())
{
let domain = domain.to_ascii_lowercase();
if !domains.contains(&domain) {
domains.push(domain);
}
}
}
unsafe {
FreeInterfaceDnsSettings(&mut settings);
}
Ok(domains)
}
@@ -45,7 +45,7 @@ fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) ->
Ok(builder.interface(binding.interface()))
}
#[cfg(any(target_os = "freebsd", target_os = "openbsd", windows))]
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
if let std::net::SocketAddr::V6(source) = binding.source() {
anyhow::ensure!(
+2 -2
View File
@@ -1,6 +1,6 @@
use std::path::{Path, PathBuf};
use common::paths::service_lock_file;
use common::constants::GP_SERVICE_LOCK_FILE;
use thiserror::Error;
use tokio::fs;
@@ -109,7 +109,7 @@ impl LockInfo {
}
pub async fn gpservice_lock_info() -> Result<LockInfo, LockFileError> {
gpservice_lock_info_at(service_lock_file()).await
gpservice_lock_info_at(GP_SERVICE_LOCK_FILE).await
}
pub async fn gpservice_lock_info_at(path: impl AsRef<Path>) -> Result<LockInfo, LockFileError> {
@@ -13,9 +13,6 @@ pub async fn shutdown_signal() {
.await;
};
#[cfg(not(unix))]
let terminate = std::future::pending::<()>();
tokio::select! {
_ = ctrl_c => {},
_ = terminate => {},
-176
View File
@@ -1,176 +0,0 @@
//! Windows user identity and private local IPC.
use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, OwnedHandle};
use std::{io, ptr};
mod pipes;
pub use pipes::{PacketPipe, connect_service_admission, connect_service_worker, create_service_admission_pipe};
use tokio::net::windows::named_pipe::NamedPipeServer;
use windows_sys::Win32::{
Foundation::{CloseHandle, LocalFree},
Security::{Authorization::ConvertSidToStringSidW, GetTokenInformation, TOKEN_QUERY, TOKEN_USER, TokenUser},
System::Threading::{GetCurrentProcess, OpenProcess, OpenProcessToken, PROCESS_QUERY_LIMITED_INFORMATION},
};
pub fn current_user_sid() -> io::Result<String> {
unsafe {
let mut token = ptr::null_mut();
if OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) == 0 {
return Err(io::Error::last_os_error());
}
let result = token_user_sid(token);
CloseHandle(token);
result
}
}
/// An authenticated pipe client's primary token, retained for its user-session worker.
/// Windows user identity is a SID and token; it is never represented as a Unix UID.
pub struct PipeClientIdentity {
sid: String,
token: OwnedHandle,
}
impl PipeClientIdentity {
pub fn sid(&self) -> &str {
&self.sid
}
pub fn primary_token(&self) -> BorrowedHandle<'_> {
self.token.as_handle()
}
/// Call after reading the client's admission request. Impersonation stays on
/// this thread and ends before returning; no asynchronous work can run in it.
pub fn from_pipe(pipe: &NamedPipeServer) -> io::Result<Self> {
use windows_sys::Win32::{
Security::{
DuplicateTokenEx, RevertToSelf, SecurityImpersonation, TOKEN_ASSIGN_PRIMARY, TOKEN_DUPLICATE, TokenPrimary,
},
System::{
Pipes::ImpersonateNamedPipeClient,
Threading::{GetCurrentThread, OpenThreadToken},
},
};
struct Revert;
impl Drop for Revert {
fn drop(&mut self) {
// Continuing a service thread as its client would corrupt its privilege
// boundary. Windows documents terminating if RevertToSelf fails.
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
}
}
unsafe {
if ImpersonateNamedPipeClient(pipe.as_raw_handle()) == 0 {
return Err(io::Error::last_os_error());
}
let _revert = Revert;
let mut token = ptr::null_mut();
if OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_DUPLICATE, 1, &mut token) == 0 {
return Err(io::Error::last_os_error());
}
let token = OwnedHandle::from_raw_handle(token);
let sid = token_user_sid(token.as_raw_handle())?;
let mut primary = ptr::null_mut();
if DuplicateTokenEx(
token.as_raw_handle(),
TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY,
ptr::null(),
SecurityImpersonation,
TokenPrimary,
&mut primary,
) == 0
{
return Err(io::Error::last_os_error());
}
Ok(Self {
sid,
token: OwnedHandle::from_raw_handle(primary),
})
}
}
}
/// Resolve a local IPC peer from its OS process token.
pub fn process_user_sid(pid: u32) -> io::Result<String> {
unsafe {
let process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
if process.is_null() {
return Err(io::Error::last_os_error());
}
let mut token = ptr::null_mut();
if OpenProcessToken(process, TOKEN_QUERY, &mut token) == 0 {
let error = io::Error::last_os_error();
CloseHandle(process);
return Err(error);
}
CloseHandle(process);
let result = token_user_sid(token);
CloseHandle(token);
result
}
}
unsafe fn token_user_sid(token: windows_sys::Win32::Foundation::HANDLE) -> io::Result<String> {
unsafe {
let mut length = 0;
GetTokenInformation(token, TokenUser, ptr::null_mut(), 0, &mut length);
// TOKEN_USER contains pointers; retain pointer alignment in its backing allocation.
let mut buffer = vec![0usize; (length as usize).div_ceil(std::mem::size_of::<usize>())];
if GetTokenInformation(token, TokenUser, buffer.as_mut_ptr().cast(), length, &mut length) == 0 {
return Err(io::Error::last_os_error());
}
let user = &*buffer.as_ptr().cast::<TOKEN_USER>();
let mut text = ptr::null_mut();
if ConvertSidToStringSidW(user.User.Sid, &mut text) == 0 {
return Err(io::Error::last_os_error());
}
let mut length = 0;
while *text.add(length) != 0 {
length += 1;
}
let sid = String::from_utf16_lossy(std::slice::from_raw_parts(text, length));
LocalFree(text.cast());
Ok(sid)
}
}
/// Only the owning user and SYSTEM can access authentication callbacks.
pub fn create_user_pipe(name: &str, first_instance: bool) -> io::Result<NamedPipeServer> {
pipes::user_pipe(&current_user_sid()?, name, first_instance)
}
/// Query a registered service without requiring access to its SYSTEM process token.
pub fn service_process_id(name: &str) -> io::Result<u32> {
use windows_sys::Win32::System::Services::*;
let name: Vec<u16> = name.encode_utf16().chain(Some(0)).collect();
unsafe {
let manager = OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT);
if manager.is_null() {
return Err(io::Error::last_os_error());
}
let service = OpenServiceW(manager, name.as_ptr(), SERVICE_QUERY_STATUS);
if service.is_null() {
let error = io::Error::last_os_error();
CloseServiceHandle(manager);
return Err(error);
}
let mut status = SERVICE_STATUS_PROCESS::default();
let mut length = 0;
let success = QueryServiceStatusEx(
service,
SC_STATUS_PROCESS_INFO,
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
std::mem::size_of_val(&status) as u32,
&mut length,
);
let result = if success == 0 {
Err(io::Error::last_os_error())
} else {
Ok(status.dwProcessId)
};
CloseServiceHandle(service);
CloseServiceHandle(manager);
result
}
}
-202
View File
@@ -1,202 +0,0 @@
//! Local service admission and worker pipes with explicit user access.
use super::PipeClientIdentity;
use std::{
fs::OpenOptions,
io,
os::windows::{
fs::OpenOptionsExt,
io::{AsRawHandle, FromRawHandle, IntoRawHandle, OwnedHandle},
},
ptr,
time::Duration,
};
use tokio::net::windows::named_pipe::{NamedPipeClient, NamedPipeServer, ServerOptions};
use windows_sys::Win32::{
Foundation::{ERROR_IO_PENDING, ERROR_PIPE_CONNECTED, INVALID_HANDLE_VALUE, LocalFree, WAIT_OBJECT_0, WAIT_TIMEOUT},
Security::{Authorization::ConvertStringSecurityDescriptorToSecurityDescriptorW, SECURITY_ATTRIBUTES},
Storage::FileSystem::*,
System::{
IO::{CancelIoEx, GetOverlappedResult, OVERLAPPED},
Pipes::*,
Threading::{CreateEventW, WaitForSingleObject},
},
};
// Generic write also grants FILE_CREATE_PIPE_INSTANCE. Clients receive only
// data/metadata access; creating another instance remains SYSTEM-only.
const CLIENT_ACCESS: u32 = FILE_GENERIC_READ | FILE_WRITE_DATA | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES;
fn wide(value: &str) -> Vec<u16> {
value.encode_utf16().chain(Some(0)).collect()
}
fn with_security<T>(sddl: &str, operation: impl FnOnce(&SECURITY_ATTRIBUTES) -> io::Result<T>) -> io::Result<T> {
struct Descriptor(*mut std::ffi::c_void);
impl Drop for Descriptor {
fn drop(&mut self) {
unsafe {
LocalFree(self.0);
}
}
}
let mut pointer = ptr::null_mut();
if unsafe {
ConvertStringSecurityDescriptorToSecurityDescriptorW(wide(sddl).as_ptr(), 1, &mut pointer, ptr::null_mut())
} == 0
{
return Err(io::Error::last_os_error());
}
let descriptor = Descriptor(pointer);
operation(&SECURITY_ATTRIBUTES {
nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
lpSecurityDescriptor: descriptor.0,
bInheritHandle: 0,
})
}
fn server(sddl: &str, name: &str, first: bool) -> io::Result<NamedPipeServer> {
with_security(sddl, |attributes| unsafe {
ServerOptions::new()
.first_pipe_instance(first)
.reject_remote_clients(true)
.create_with_security_attributes_raw(name, (attributes as *const SECURITY_ATTRIBUTES).cast_mut().cast())
})
}
pub(super) fn user_pipe(sid: &str, name: &str, first: bool) -> io::Result<NamedPipeServer> {
server(&format!("D:P(A;;GA;;;SY)(A;;GA;;;{sid})"), name, first)
}
pub fn create_service_admission_pipe(first: bool) -> io::Result<NamedPipeServer> {
server(
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;AU)"),
common::paths::SERVICE_PIPE,
first,
)
}
fn client(name: &str, message: bool, impersonation: bool) -> io::Result<NamedPipeClient> {
let file = OpenOptions::new()
.read(true)
.write(true)
.access_mode(CLIENT_ACCESS)
.custom_flags(FILE_FLAG_OVERLAPPED)
.security_qos_flags(if impersonation {
SECURITY_IMPERSONATION
} else {
SECURITY_IDENTIFICATION
})
.open(name)?;
let pipe = unsafe { NamedPipeClient::from_raw_handle(file.into_raw_handle()) }?;
let mut pid = 0;
if unsafe { GetNamedPipeServerProcessId(pipe.as_raw_handle(), &mut pid) } == 0 {
return Err(io::Error::last_os_error());
}
if pid == 0 || pid != super::service_process_id(common::paths::SERVICE_NAME)? {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Pipe does not belong to the registered VPN service",
));
}
if message {
let mode = PIPE_READMODE_MESSAGE;
if unsafe { SetNamedPipeHandleState(pipe.as_raw_handle(), &mode, ptr::null(), ptr::null()) } == 0 {
return Err(io::Error::last_os_error());
}
}
Ok(pipe)
}
/// Verify the service before the first request permits it to impersonate this user.
pub fn connect_service_admission() -> io::Result<NamedPipeClient> {
client(common::paths::SERVICE_PIPE, false, true)
}
pub fn connect_service_worker(name: &str, message: bool) -> io::Result<NamedPipeClient> {
client(name, message, false)
}
impl PipeClientIdentity {
pub fn create_control_pipe(&self, name: &str) -> io::Result<NamedPipeServer> {
server(
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;{})", self.sid()),
name,
true,
)
}
pub fn create_packet_pipe(&self, name: &str) -> io::Result<PacketPipe> {
let name = wide(name);
with_security(
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;{})", self.sid()),
|attributes| {
let handle = unsafe {
CreateNamedPipeW(
name.as_ptr(),
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS,
1,
256 * 1024,
256 * 1024,
0,
attributes,
)
};
if handle == INVALID_HANDLE_VALUE {
return Err(io::Error::last_os_error());
}
Ok(PacketPipe(unsafe { OwnedHandle::from_raw_handle(handle) }))
},
)
}
}
/// Raw Win32 overlapped I/O, deliberately never registered with Tokio/Mio IOCP.
pub struct PacketPipe(OwnedHandle);
impl PacketPipe {
pub fn connect(&mut self, expected_pid: u32, timeout: Duration) -> io::Result<()> {
let event = unsafe { CreateEventW(ptr::null(), 1, 0, ptr::null()) };
if event.is_null() {
return Err(io::Error::last_os_error());
}
let event = unsafe { OwnedHandle::from_raw_handle(event) };
let mut overlap = OVERLAPPED {
hEvent: event.as_raw_handle(),
..Default::default()
};
if unsafe { ConnectNamedPipe(self.0.as_raw_handle(), &mut overlap) } == 0 {
let error = io::Error::last_os_error();
match error.raw_os_error().map(|code| code as u32) {
Some(ERROR_PIPE_CONNECTED) => {}
Some(ERROR_IO_PENDING) => {
let status = unsafe {
WaitForSingleObject(
event.as_raw_handle(),
timeout.as_millis().min(u32::MAX as u128 - 1) as u32,
)
};
let mut bytes = 0;
if status != WAIT_OBJECT_0 {
// Complete cancellation before OVERLAPPED/event storage is released.
unsafe {
CancelIoEx(self.0.as_raw_handle(), &overlap);
GetOverlappedResult(self.0.as_raw_handle(), &overlap, &mut bytes, 1);
}
if status == WAIT_TIMEOUT {
return Err(io::Error::new(io::ErrorKind::TimedOut, "Packet worker did not connect"));
}
return Err(io::Error::last_os_error());
}
if unsafe { GetOverlappedResult(self.0.as_raw_handle(), &overlap, &mut bytes, 0) } == 0 {
return Err(io::Error::last_os_error());
}
}
_ => return Err(error),
}
}
let mut pid = 0;
if unsafe { GetNamedPipeClientProcessId(self.0.as_raw_handle(), &mut pid) } == 0 {
return Err(io::Error::last_os_error());
}
if pid != expected_pid {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Unexpected packet pipe client",
));
}
Ok(())
}
pub fn into_handle(self) -> OwnedHandle {
self.0
}
}
-87
View File
@@ -1,87 +0,0 @@
#![cfg(windows)]
use gpapi::windows::{PipeClientIdentity, create_user_pipe, current_user_sid};
use std::{io, os::windows::io::AsRawHandle, ptr, time::Duration};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::windows::named_pipe::ClientOptions,
};
use windows_sys::Win32::{
Foundation::{CloseHandle, ERROR_NO_TOKEN},
Security::{GetTokenInformation, TOKEN_QUERY, TOKEN_TYPE, TokenPrimary, TokenType},
Storage::FileSystem::{SECURITY_IDENTIFICATION, SECURITY_IMPERSONATION},
System::Threading::{GetCurrentThread, OpenThreadToken},
};
fn assert_reverted() {
let mut token = ptr::null_mut();
let success = unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) };
if success != 0 {
unsafe {
CloseHandle(token);
}
panic!("The service thread still impersonates its client");
}
assert_eq!(io::Error::last_os_error().raw_os_error(), Some(ERROR_NO_TOKEN as i32));
}
async fn admission(qos: u32) -> io::Result<PipeClientIdentity> {
let path = format!(r"\\.\pipe\GPConnect.IdentityTest.{}", uuid::Uuid::new_v4());
let mut pipe = create_user_pipe(&path, true)?;
let client = tokio::spawn(async move {
let mut pipe = ClientOptions::new().security_qos_flags(qos).open(path).unwrap();
pipe.write_all(b"admit").await.unwrap();
let mut response = [0];
pipe.read_exact(&mut response).await.unwrap();
// Confirm delivery before the server disconnects its Windows pipe.
pipe.write_all(b"ack").await.unwrap();
});
pipe.connect().await?;
let mut request = [0; 5];
pipe.read_exact(&mut request).await?;
assert_eq!(&request, b"admit");
let identity = PipeClientIdentity::from_pipe(&pipe);
assert_reverted();
pipe.write_all(&[1]).await?;
let mut ack = [0; 3];
pipe.read_exact(&mut ack).await?;
assert_eq!(&ack, b"ack");
client.await.unwrap();
identity
}
#[tokio::test]
async fn captures_primary_token_and_reverts_before_returning() {
let identity = tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IMPERSONATION))
.await
.unwrap()
.unwrap();
assert_eq!(identity.sid(), current_user_sid().unwrap());
let mut kind: TOKEN_TYPE = 0;
let mut length = 0;
assert_ne!(
unsafe {
GetTokenInformation(
identity.primary_token().as_raw_handle(),
TokenType,
(&mut kind as *mut TOKEN_TYPE).cast(),
std::mem::size_of_val(&kind) as u32,
&mut length,
)
},
0
);
assert_eq!(kind, TokenPrimary);
assert_reverted();
}
#[tokio::test]
async fn identification_only_client_cannot_supply_a_worker_token() {
assert!(
tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IDENTIFICATION))
.await
.unwrap()
.is_err()
);
assert_reverted();
}
+1 -3
View File
@@ -15,7 +15,5 @@ serde.workspace = true
serde_json.workspace = true
serde_urlencoded.workspace = true
uuid = { workspace = true, features = ["v5"] }
xmltree.workspace = true
[target.'cfg(unix)'.dependencies]
uzers.workspace = true
xmltree.workspace = true
-3
View File
@@ -570,14 +570,11 @@ fn detect_ufw(commands: &CollectorCommands<'_>) -> io::Result<Option<UfwInfo>> {
let Some(ufw) = commands.resolve("ufw") else {
return Ok(None);
};
#[cfg(unix)]
let output = if uzers::get_effective_uid() == 0 {
commands.run_path(&ufw, &["status"])?
} else {
commands.run("sudo", &["-n", &ufw.to_string_lossy(), "status"])?
};
#[cfg(windows)]
let output = commands.run_path(&ufw, &["status"])?;
let Some(output) = output.filter(|output| output.status.success()) else {
return Ok(None);
};
+1 -17
View File
@@ -5,21 +5,5 @@ version.workspace = true
edition.workspace = true
license.workspace = true
[target.'cfg(any(target_os = "macos", windows))'.dependencies]
[target.'cfg(target_os = "macos")'.dependencies]
log.workspace = true
[target.'cfg(windows)'.dependencies]
ipnet = { version = "2", features = ["serde"] }
base64.workspace = true
serde_json.workspace = true
serde.workspace = true
winreg = "0.56"
uuid = { workspace = true, features = ["v4"] }
windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_NetworkManagement_IpHelper", "Win32_NetworkManagement_Ndis", "Win32_Networking_WinSock", "Win32_System_Threading"] }
[dev-dependencies]
ipnet = "2"
[target.'cfg(windows)'.dev-dependencies]
tempfile.workspace = true
windows-sys = { version = "0.61", features = ["Win32_System_LibraryLoader"] }
-5
View File
@@ -1,7 +1,2 @@
#[cfg(target_os = "macos")]
pub mod macos;
#[cfg(windows)]
pub mod windows;
#[cfg(all(test, not(windows)))]
#[path = "windows/configuration.rs"]
mod windows_configuration;
-249
View File
@@ -1,249 +0,0 @@
//! Convert OpenConnect's normal configuration callback into a Windows network plan.
use ipnet::IpNet;
use std::{collections::HashMap, io, net::IpAddr};
#[derive(Debug)]
pub(super) struct Configuration {
pub interface: u32,
pub gateway: IpAddr,
pub addresses: Vec<IpNet>,
pub mtu: Option<u32>,
pub includes: Vec<IpNet>,
pub excludes: Vec<IpNet>,
pub servers: Vec<IpAddr>,
pub domains: Vec<String>,
pub split_dns: Vec<String>,
}
fn invalid(message: impl Into<String>) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message.into())
}
impl Configuration {
pub fn parse(environment: &[(String, Option<String>)]) -> io::Result<Self> {
let values: HashMap<_, _> = environment
.iter()
.filter_map(|(key, value)| value.as_deref().map(|value| (key.as_str(), value)))
.collect();
let required = |key: &str| {
values
.get(key)
.copied()
.filter(|value| !value.is_empty())
.ok_or_else(|| invalid(format!("Missing VPN configuration: {key}")))
};
let interface: u32 = required("TUNIDX")?
.parse()
.map_err(|_| invalid("Invalid VPN interface index"))?;
if interface == 0 {
return Err(invalid("VPN interface index is zero"));
}
let gateway = required("VPNGATEWAY")?
.parse()
.map_err(|_| invalid("Invalid VPN gateway address"))?;
let mut addresses = Vec::new();
if let Some(address) = values.get("INTERNAL_IP4_ADDRESS") {
let prefix = values.get("INTERNAL_IP4_NETMASKLEN").copied().unwrap_or("32");
let network: IpNet = format!("{address}/{prefix}")
.parse()
.map_err(|_| invalid("Invalid VPN IPv4 address or prefix"))?;
if !matches!(network, IpNet::V4(_)) {
return Err(invalid("VPN IPv4 address has the wrong family"));
}
addresses.push(network);
}
if let Some(address) = values.get("INTERNAL_IP6_ADDRESS") {
let prefix = values
.get("INTERNAL_IP6_NETMASK")
.and_then(|value| value.rsplit_once('/'))
.map(|(_, prefix)| prefix)
.unwrap_or("128");
let network: IpNet = format!("{address}/{prefix}")
.parse()
.map_err(|_| invalid("Invalid VPN IPv6 address or prefix"))?;
if !matches!(network, IpNet::V6(_)) {
return Err(invalid("VPN IPv6 address has the wrong family"));
}
addresses.push(network);
}
if addresses.is_empty() {
return Err(invalid("The VPN did not assign an IP address"));
}
let mtu = values
.get("INTERNAL_IP4_MTU")
.filter(|value| !value.is_empty())
.map(|value| value.parse::<u32>().map_err(|_| invalid("Invalid VPN MTU")))
.transpose()?
.filter(|mtu| *mtu != 0);
let mut includes = Vec::new();
let mut excludes = Vec::new();
for (family, prefix) in [(4, "CISCO_SPLIT"), (6, "CISCO_IPV6_SPLIT")] {
if !addresses
.iter()
.any(|address| address.addr().is_ipv4() == (family == 4))
{
continue;
}
let included = routes(&values, &format!("{prefix}_INC"), family)?;
if included.is_empty() {
// Preserve the physical default route, using the two more-specific halves.
let defaults: &[&str] = if family == 4 {
&["0.0.0.0/1", "128.0.0.0/1"]
} else {
&["::/1", "8000::/1"]
};
includes.extend(defaults.iter().map(|route| route.parse::<IpNet>().unwrap()));
} else {
includes.extend(included);
}
excludes.extend(routes(&values, &format!("{prefix}_EXC"), family)?);
}
let mut servers = values
.get("INTERNAL_IP4_DNS")
.into_iter()
.flat_map(|text| text.split_whitespace())
.map(|address| address.parse().map_err(|_| invalid("Invalid VPN DNS server")))
.collect::<io::Result<Vec<IpAddr>>>()?;
let advertised_dns = !servers.is_empty();
servers.retain(|server| {
addresses
.iter()
.any(|address| address.addr().is_ipv4() == server.is_ipv4())
});
if advertised_dns && servers.is_empty() {
return Err(invalid("No VPN DNS server matches an assigned address family"));
}
let domains = names(values.get("CISCO_DEF_DOMAIN").copied().unwrap_or(""));
let split_dns = names(values.get("CISCO_SPLIT_DNS").copied().unwrap_or(""));
Ok(Self {
interface,
gateway,
addresses,
mtu,
includes,
excludes,
servers,
domains,
split_dns,
})
}
}
fn names(text: &str) -> Vec<String> {
text
.split(|ch: char| ch == ',' || ch.is_whitespace())
.filter(|part| !part.is_empty())
.map(str::to_owned)
.collect()
}
fn routes(values: &HashMap<&str, &str>, key: &str, family: u8) -> io::Result<Vec<IpNet>> {
let count = values
.get(key)
.map(|value| {
value
.parse::<u32>()
.map_err(|_| invalid(format!("Invalid {key} count")))
})
.transpose()?
.unwrap_or(0);
(0..count)
.map(|index| {
let address = values
.get(format!("{key}_{index}_ADDR").as_str())
.ok_or_else(|| invalid(format!("Missing {key} address")))?;
let prefix = values
.get(format!("{key}_{index}_MASKLEN").as_str())
.ok_or_else(|| invalid(format!("Missing {key} prefix")))?;
let route: IpNet = format!("{address}/{prefix}")
.parse()
.map_err(|_| invalid(format!("Invalid {key} route")))?;
if route.addr().is_ipv4() != (family == 4) {
return Err(invalid(format!("Wrong {key} route family")));
}
Ok(route.trunc())
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn environment(extra: &[(&str, &str)]) -> Vec<(String, Option<String>)> {
[
("TUNIDX", "16"),
("VPNGATEWAY", "198.51.100.1"),
("INTERNAL_IP4_ADDRESS", "10.20.30.4"),
]
.into_iter()
.chain(extra.iter().copied())
.map(|(key, value)| (key.into(), Some(value.into())))
.collect()
}
#[test]
fn full_tunnel_keeps_assigned_addresses_and_routes_both_families() {
let plan = Configuration::parse(&environment(&[
("INTERNAL_IP4_NETMASKLEN", "24"),
("INTERNAL_IP6_ADDRESS", "fd00::4"),
("INTERNAL_IP6_NETMASK", "fd00::4/64"),
("INTERNAL_IP4_MTU", "1406"),
("INTERNAL_IP4_DNS", "10.20.30.1 fd00::1"),
]))
.unwrap();
assert_eq!(
plan.addresses.iter().map(ToString::to_string).collect::<Vec<_>>(),
["10.20.30.4/24", "fd00::4/64"]
);
assert_eq!(plan.includes.len(), 4);
assert_eq!(plan.servers.len(), 2);
assert_eq!(plan.mtu, Some(1406));
assert_eq!(plan.interface, 16);
assert_eq!(plan.gateway.to_string(), "198.51.100.1");
}
#[test]
fn split_routes_and_dns_preserve_gateway_configuration() {
let plan = Configuration::parse(&environment(&[
("CISCO_SPLIT_INC", "1"),
("CISCO_SPLIT_INC_0_ADDR", "172.16.5.9"),
("CISCO_SPLIT_INC_0_MASKLEN", "16"),
("CISCO_SPLIT_EXC", "1"),
("CISCO_SPLIT_EXC_0_ADDR", "172.16.10.0"),
("CISCO_SPLIT_EXC_0_MASKLEN", "24"),
("CISCO_DEF_DOMAIN", "corp.example"),
("CISCO_SPLIT_DNS", "corp.example, internal.example"),
]))
.unwrap();
assert_eq!(
plan.includes.iter().map(ToString::to_string).collect::<Vec<_>>(),
["172.16.0.0/16"]
);
assert_eq!(plan.excludes[0].to_string(), "172.16.10.0/24");
assert_eq!(plan.domains, ["corp.example"]);
assert_eq!(plan.split_dns, ["corp.example", "internal.example"]);
}
#[test]
fn unassigned_address_family_does_not_install_routes_or_resolvers() {
let plan = Configuration::parse(&environment(&[
("CISCO_IPV6_SPLIT_INC", "1"),
("CISCO_IPV6_SPLIT_INC_0_ADDR", "fd00::"),
("CISCO_IPV6_SPLIT_INC_0_MASKLEN", "64"),
("INTERNAL_IP4_DNS", "10.20.30.1 fd00::1"),
]))
.unwrap();
assert!(plan.includes.iter().all(|route| route.addr().is_ipv4()));
assert_eq!(
plan.servers.iter().map(ToString::to_string).collect::<Vec<_>>(),
["10.20.30.1"]
);
assert!(Configuration::parse(&environment(&[("INTERNAL_IP4_DNS", "fd00::1")])).is_err());
}
#[test]
fn malformed_network_data_is_rejected_before_changes() {
for extra in [
vec![("TUNIDX", "0")],
vec![("INTERNAL_IP4_NETMASKLEN", "99")],
vec![("INTERNAL_IP4_DNS", "not-an-address")],
vec![("CISCO_SPLIT_INC", "1")],
] {
assert!(Configuration::parse(&environment(&extra)).is_err());
}
}
}
-18
View File
@@ -1,18 +0,0 @@
$ErrorActionPreference = 'Stop'
$request = [Console]::In.ReadToEnd() | ConvertFrom-Json
switch ($request.operation) {
'add' {
Add-DnsClientNrptRule -Namespace ([string[]]$request.namespaces) -NameServers ([string[]]$request.servers) -Comment $request.tag | Out-Null
}
'remove' {
Get-DnsClientNrptRule | Where-Object { $_.Comment -eq $request.tag } | ForEach-Object {
Remove-DnsClientNrptRule -Name $_.Name -Force
}
}
'clear-stale' {
Get-DnsClientNrptRule | Where-Object { $_.Comment -like 'GPConnect:*' } | ForEach-Object {
Remove-DnsClientNrptRule -Name $_.Name -Force
}
}
default { throw 'Invalid DNS policy operation' }
}
-178
View File
@@ -1,178 +0,0 @@
//! Adapter DNS settings and Windows name-resolution policy scoped to this connection.
use super::configuration::Configuration;
use base64::Engine;
use serde_json::json;
use std::{
io::{self, Write},
os::windows::process::CommandExt,
process::{Command, Stdio},
};
use windows_sys::{
Win32::{
NetworkManagement::{IpHelper::*, Ndis::NET_LUID_LH},
System::Threading::CREATE_NO_WINDOW,
},
core::GUID,
};
struct Snapshot {
domain: String,
search: String,
}
pub(super) struct Installed {
guid: GUID,
snapshot: Option<Snapshot>,
tag: Option<String>,
}
fn check(status: u32) -> io::Result<()> {
if status == 0 {
Ok(())
} else {
Err(io::Error::from_raw_os_error(status as i32))
}
}
fn wide(text: &str) -> Vec<u16> {
text.encode_utf16().chain(Some(0)).collect()
}
unsafe fn string(pointer: *const u16) -> String {
if pointer.is_null() {
return String::new();
}
unsafe {
let mut length = 0;
while *pointer.add(length) != 0 {
length += 1;
}
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
}
}
impl Snapshot {
fn capture(guid: GUID) -> io::Result<Self> {
let mut settings = DNS_INTERFACE_SETTINGS {
Version: DNS_INTERFACE_SETTINGS_VERSION1,
..Default::default()
};
check(unsafe { GetInterfaceDnsSettings(guid, &mut settings) })?;
let snapshot = unsafe {
Self {
domain: string(settings.Domain),
search: string(settings.SearchList),
}
};
unsafe {
FreeInterfaceDnsSettings(&mut settings);
}
Ok(snapshot)
}
fn write(&self, guid: GUID) -> io::Result<()> {
let (mut domain, mut search) = (wide(&self.domain), wide(&self.search));
let settings = DNS_INTERFACE_SETTINGS {
Version: DNS_INTERFACE_SETTINGS_VERSION1,
Flags: (DNS_SETTING_DOMAIN | DNS_SETTING_SEARCHLIST) as u64,
Domain: domain.as_mut_ptr(),
SearchList: search.as_mut_ptr(),
..Default::default()
};
check(unsafe { SetInterfaceDnsSettings(guid, &settings) })
}
}
impl Installed {
pub fn apply(configuration: &Configuration) -> io::Result<Self> {
let mut luid = NET_LUID_LH::default();
let mut guid = GUID::default();
check(unsafe { ConvertInterfaceIndexToLuid(configuration.interface, &mut luid) })?;
check(unsafe { ConvertInterfaceLuidToGuid(&luid, &mut guid) })?;
let mut installed = Self {
guid,
snapshot: Some(Snapshot::capture(guid)?),
tag: None,
};
Snapshot {
domain: configuration.domains.first().cloned().unwrap_or_default(),
search: configuration.domains.join(","),
}
.write(guid)?;
// NRPT selects both IPv4 and IPv6 VPN resolvers. Split namespaces leave
// unrelated DNS on the physical network; "." covers full-tunnel DNS.
// Existing static/DHCP adapter nameserver configuration stays untouched.
if !configuration.servers.is_empty() {
let namespaces: Vec<String> = if configuration.split_dns.is_empty() {
vec![".".into()]
} else {
configuration
.split_dns
.iter()
.map(|domain| format!(".{}", domain.trim_matches('.')))
.collect()
};
let tag = format!("GPConnect:{}", uuid::Uuid::new_v4());
installed.tag = Some(tag.clone());
policy(
json!({"operation":"add", "tag":tag, "namespaces":namespaces, "servers":configuration.servers.iter().map(ToString::to_string).collect::<Vec<_>>()}),
)?;
}
Ok(installed)
}
pub fn restore(&mut self) -> io::Result<()> {
let mut failure = None;
if let Some(tag) = self.tag.take() {
if let Err(error) = policy(json!({"operation":"remove", "tag":tag})) {
log::warn!("Could not remove VPN DNS policy: {error}");
failure = Some(error);
}
}
if let Some(snapshot) = self.snapshot.take() {
if let Err(error) = snapshot.write(self.guid) {
log::warn!("Could not restore VPN adapter DNS: {error}");
if failure.is_none() {
failure = Some(error);
}
}
}
failure.map_or(Ok(()), Err)
}
}
impl Drop for Installed {
fn drop(&mut self) {
let _ = self.restore();
}
}
/// A crashed service cannot run Drop. Remove only GP Connect's tagged policies
/// before accepting a new connection; adapter rows disappear with Wintun itself.
pub(super) fn clear_stale_policies() -> io::Result<()> {
policy(json!({"operation":"clear-stale"}))
}
fn policy(request: serde_json::Value) -> io::Result<()> {
const SCRIPT: &str = include_str!("dns-policy.ps1");
let encoded = base64::engine::general_purpose::STANDARD
.encode(SCRIPT.encode_utf16().flat_map(u16::to_le_bytes).collect::<Vec<_>>());
let root =
std::env::var_os("SystemRoot").ok_or_else(|| io::Error::other("Windows system directory is unavailable"))?;
let executable = std::path::PathBuf::from(root).join("System32/WindowsPowerShell/v1.0/powershell.exe");
let mut child = Command::new(executable)
.args(["-NoProfile", "-NonInteractive", "-EncodedCommand", &encoded])
.creation_flags(CREATE_NO_WINDOW)
.stdin(Stdio::piped())
.stdout(Stdio::null())
.stderr(Stdio::piped())
.spawn()?;
let input = child
.stdin
.take()
.expect("stdin is piped")
.write_all(request.to_string().as_bytes());
if let Err(error) = input {
let _ = child.kill();
let _ = child.wait();
return Err(error);
}
let output = child.wait_with_output()?;
if !output.status.success() {
return Err(io::Error::other(format!(
"Windows DNS policy failed: {}",
String::from_utf8_lossy(&output.stderr).trim()
)));
}
Ok(())
}
-317
View File
@@ -1,317 +0,0 @@
//! Native IP Helper changes with ownership of only the rows this connection creates.
use super::{
configuration::Configuration,
recovery::{Journal, Route},
};
use ipnet::IpNet;
use std::{
io,
net::{IpAddr, Ipv4Addr, Ipv6Addr},
ptr,
};
use windows_sys::Win32::{
Foundation::{ERROR_NOT_FOUND, ERROR_OBJECT_ALREADY_EXISTS},
NetworkManagement::IpHelper::*,
Networking::WinSock::*,
};
struct InstalledRoute {
row: MIB_IPFORWARD_ROW2,
record: Option<String>,
}
pub(super) struct Installed {
routes: Vec<InstalledRoute>,
journal: Journal,
addresses: Vec<MIB_UNICASTIPADDRESS_ROW>,
interfaces: Vec<MIB_IPINTERFACE_ROW>,
}
fn check(status: u32) -> io::Result<()> {
if status == 0 {
Ok(())
} else {
Err(io::Error::from_raw_os_error(status as i32))
}
}
fn socket_address(address: IpAddr) -> SOCKADDR_INET {
let mut result = SOCKADDR_INET::default();
match address {
IpAddr::V4(address) => {
result.Ipv4.sin_family = AF_INET;
result.Ipv4.sin_addr.S_un.S_addr = u32::from_ne_bytes(address.octets());
}
IpAddr::V6(address) => {
result.Ipv6.sin6_family = AF_INET6;
result.Ipv6.sin6_addr.u.Byte = address.octets();
}
}
result
}
fn empty_address(ipv4: bool) -> SOCKADDR_INET {
socket_address(if ipv4 {
Ipv4Addr::UNSPECIFIED.into()
} else {
Ipv6Addr::UNSPECIFIED.into()
})
}
fn route(prefix: IpNet, interface: u32) -> MIB_IPFORWARD_ROW2 {
let mut storage = std::mem::MaybeUninit::<MIB_IPFORWARD_ROW2>::zeroed();
// IP Helper initializes BOOLEAN fields to 0xff. They must contain canonical
// Rust bool values before this storage can become an initialized Rust row.
let mut row = unsafe {
let pointer = storage.as_mut_ptr();
InitializeIpForwardEntry(pointer);
std::ptr::addr_of_mut!((*pointer).Loopback).write(false);
std::ptr::addr_of_mut!((*pointer).AutoconfigureAddress).write(false);
std::ptr::addr_of_mut!((*pointer).Publish).write(false);
std::ptr::addr_of_mut!((*pointer).Immortal).write(true);
storage.assume_init()
};
row.InterfaceIndex = interface;
row.DestinationPrefix.Prefix = socket_address(prefix.network());
row.DestinationPrefix.PrefixLength = prefix.prefix_len();
row.NextHop = empty_address(prefix.addr().is_ipv4());
row.SitePrefixLength = 0;
row.Metric = 0;
row.Protocol = MIB_IPPROTO_NETMGMT;
row
}
fn physical_route(prefix: IpNet, tunnel: u32) -> io::Result<MIB_IPFORWARD_ROW2> {
let destination = socket_address(prefix.addr());
let mut existing = MIB_IPFORWARD_ROW2::default();
let mut source = SOCKADDR_INET::default();
check(unsafe { GetBestRoute2(ptr::null(), 0, ptr::null(), &destination, 0, &mut existing, &mut source) })?;
if existing.InterfaceIndex == tunnel {
return Err(io::Error::other(
"The VPN gateway or exclusion resolves through the VPN adapter",
));
}
let mut row = route(prefix, existing.InterfaceIndex);
row.InterfaceLuid = existing.InterfaceLuid;
row.NextHop = existing.NextHop;
row.Metric = existing.Metric;
Ok(row)
}
impl Installed {
pub fn apply(configuration: &Configuration, recovery_key: &str) -> io::Result<Self> {
// Resolve all physical paths before introducing any tunnel routes.
let gateway = IpNet::new(
configuration.gateway,
if configuration.gateway.is_ipv4() { 32 } else { 128 },
)
.map_err(io::Error::other)?;
let physical = std::iter::once(gateway)
.chain(configuration.excludes.iter().copied())
.map(|prefix| physical_route(prefix, configuration.interface))
.collect::<io::Result<Vec<_>>>()?;
let mut installed = Self {
routes: Vec::new(),
addresses: Vec::new(),
interfaces: Vec::new(),
journal: Journal::begin(recovery_key)?,
};
for row in physical {
installed.add_route(row, true)?;
}
for family in [AF_INET, AF_INET6] {
if !configuration
.addresses
.iter()
.any(|address| address.addr().is_ipv4() == (family == AF_INET))
{
continue;
}
let mut row = MIB_IPINTERFACE_ROW {
Family: family,
InterfaceIndex: configuration.interface,
..Default::default()
};
check(unsafe { GetIpInterfaceEntry(&mut row) })?;
installed.interfaces.push(row);
row.UseAutomaticMetric = false;
row.Metric = 1;
row.DadTransmits = 0;
row.RouterDiscoveryBehavior = RouterDiscoveryDisabled;
if let Some(mtu) = configuration.mtu {
row.NlMtu = mtu;
}
if family == AF_INET {
row.SitePrefixLength = 0;
}
check(unsafe { SetIpInterfaceEntry(&mut row) })?;
}
for address in &configuration.addresses {
let mut row = MIB_UNICASTIPADDRESS_ROW::default();
unsafe {
InitializeUnicastIpAddressEntry(&mut row);
}
row.InterfaceIndex = configuration.interface;
row.Address = socket_address(address.addr());
row.OnLinkPrefixLength = address.prefix_len();
row.PrefixOrigin = IpPrefixOriginManual;
row.SuffixOrigin = IpSuffixOriginManual;
row.DadState = IpDadStatePreferred;
let status = unsafe { CreateUnicastIpAddressEntry(&row) };
if status != ERROR_OBJECT_ALREADY_EXISTS {
check(status)?;
installed.addresses.push(row);
}
}
for prefix in &configuration.includes {
installed.add_route(route(*prefix, configuration.interface), false)?;
}
for server in &configuration.servers {
if *server == configuration.gateway {
continue;
}
let prefix = IpNet::new(*server, if server.is_ipv4() { 32 } else { 128 }).map_err(io::Error::other)?;
installed.add_route(route(prefix, configuration.interface), false)?;
}
Ok(installed)
}
fn add_route(&mut self, row: MIB_IPFORWARD_ROW2, physical: bool) -> io::Result<()> {
let status = unsafe { CreateIpForwardEntry2(&row) };
if status != ERROR_OBJECT_ALREADY_EXISTS {
check(status)?;
// Retain rollback ownership even if writing the registry record fails.
self.routes.push(InstalledRoute { row, record: None });
if physical {
let name = self.journal.record(&Route::from_row(&row)?)?;
self.routes.last_mut().expect("route was just installed").record = Some(name);
}
}
Ok(())
}
pub fn restore(&mut self) -> io::Result<()> {
let mut failure = None;
for route in self.routes.drain(..).rev() {
match remove_owned_route(&route.row) {
Ok(()) => {
if let Some(name) = route.record {
if let Err(error) = self.journal.forget(&name) {
log::warn!("Could not clear Windows route ownership: {error}");
if failure.is_none() {
failure = Some(error);
}
}
}
}
Err(error) => {
log::warn!("Could not remove owned Windows route: {error}");
if failure.is_none() {
failure = Some(error);
}
}
}
}
let mut record = |status| {
if status != ERROR_NOT_FOUND && status != 0 {
let error = io::Error::from_raw_os_error(status as i32);
log::warn!("Could not restore VPN network configuration: {error}");
if failure.is_none() {
failure = Some(error);
}
}
};
for row in self.addresses.drain(..).rev() {
record(unsafe { DeleteUnicastIpAddressEntry(&row) });
}
for original in self.interfaces.drain(..).rev() {
let mut current = MIB_IPINTERFACE_ROW {
Family: original.Family,
InterfaceIndex: original.InterfaceIndex,
..Default::default()
};
let status = unsafe { GetIpInterfaceEntry(&mut current) };
if status != 0 {
record(status);
continue;
}
current.UseAutomaticMetric = original.UseAutomaticMetric;
current.Metric = original.Metric;
current.NlMtu = original.NlMtu;
current.DadTransmits = original.DadTransmits;
current.RouterDiscoveryBehavior = original.RouterDiscoveryBehavior;
if current.Family == AF_INET {
current.SitePrefixLength = 0;
}
record(unsafe { SetIpInterfaceEntry(&mut current) });
}
failure.map_or(Ok(()), Err)
}
}
impl Drop for Installed {
fn drop(&mut self) {
let _ = self.restore();
}
}
fn address(value: &SOCKADDR_INET) -> io::Result<IpAddr> {
unsafe {
match value.si_family {
AF_INET => Ok(Ipv4Addr::from(value.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into()),
AF_INET6 => Ok(Ipv6Addr::from(value.Ipv6.sin6_addr.u.Byte).into()),
_ => Err(io::Error::new(
io::ErrorKind::InvalidData,
"Invalid route address family",
)),
}
}
}
fn scope(value: &SOCKADDR_INET) -> u32 {
unsafe {
if value.si_family == AF_INET6 {
value.Ipv6.Anonymous.sin6_scope_id
} else {
0
}
}
}
impl Route {
fn from_row(row: &MIB_IPFORWARD_ROW2) -> io::Result<Self> {
Ok(Self {
prefix: IpNet::new(
address(&row.DestinationPrefix.Prefix)?,
row.DestinationPrefix.PrefixLength,
)
.map_err(io::Error::other)?,
next_hop: address(&row.NextHop)?,
interface_luid: unsafe { row.InterfaceLuid.Value },
metric: row.Metric,
prefix_scope: scope(&row.DestinationPrefix.Prefix),
next_hop_scope: scope(&row.NextHop),
})
}
fn row(&self) -> io::Result<MIB_IPFORWARD_ROW2> {
if self.interface_luid == 0 || self.prefix.addr().is_ipv4() != self.next_hop.is_ipv4() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Invalid saved Windows route",
));
}
let mut row = route(self.prefix, 0);
row.InterfaceLuid.Value = self.interface_luid;
row.Metric = self.metric;
row.NextHop = socket_address(self.next_hop);
if self.prefix.addr().is_ipv6() {
row.DestinationPrefix.Prefix.Ipv6.Anonymous.sin6_scope_id = self.prefix_scope;
row.NextHop.Ipv6.Anonymous.sin6_scope_id = self.next_hop_scope;
}
Ok(row)
}
}
fn remove_owned_route(row: &MIB_IPFORWARD_ROW2) -> io::Result<()> {
let mut current = *row;
let status = unsafe { GetIpForwardEntry2(&mut current) };
if status == ERROR_NOT_FOUND {
return Ok(());
}
check(status)?;
if current.Protocol != row.Protocol || current.Metric != row.Metric {
log::warn!("Preserving a Windows route changed after VPN installation");
return Ok(());
}
check(unsafe { DeleteIpForwardEntry2(&current) })
}
pub(super) fn recover_route(saved: &Route) -> io::Result<()> {
remove_owned_route(&saved.row()?)
}
-64
View File
@@ -1,64 +0,0 @@
//! Windows network installation driven by OpenConnect's normal configuration callback.
mod configuration;
mod dns;
mod ip_helper;
mod recovery;
use configuration::Configuration;
use std::io;
pub struct NetworkConfigurator {
connection: Option<Connection>,
recovery_key: String,
}
struct Connection {
dns: dns::Installed,
network: ip_helper::Installed,
}
impl NetworkConfigurator {
/// The owner supplies an HKLM key under its administrator-controlled namespace.
pub fn new(recovery_key: &str) -> io::Result<Self> {
recovery::Journal::begin(recovery_key)?;
Ok(Self {
connection: None,
recovery_key: recovery_key.into(),
})
}
pub fn configure(&mut self, reason: &str, environment: &[(String, Option<String>)]) -> io::Result<()> {
match reason {
"pre-init" | "attempt-reconnect" => Ok(()),
"connect" | "reconnect" => {
let configuration = Configuration::parse(environment)?;
self.disconnect()?;
let network = ip_helper::Installed::apply(&configuration, &self.recovery_key)?;
let dns = dns::Installed::apply(&configuration)?;
self.connection = Some(Connection { dns, network });
Ok(())
}
"disconnect" => self.disconnect(),
_ => Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("Unknown VPN configuration reason: {reason}"),
)),
}
}
fn disconnect(&mut self) -> io::Result<()> {
if let Some(mut connection) = self.connection.take() {
let dns = connection.dns.restore();
let network = connection.network.restore();
dns.and(network)
} else {
Ok(())
}
}
}
/// Restore process-owned physical routes and DNS policy before service admission.
pub fn recover(recovery_key: &str) -> io::Result<()> {
if let Some(journal) = recovery::Journal::open(recovery_key)? {
for (name, route) in journal.routes()? {
ip_helper::recover_route(&route)?;
journal.forget(&name)?;
}
}
dns::clear_stale_policies()
}
-70
View File
@@ -1,70 +0,0 @@
//! Ownership records for physical routes, retained across process termination.
use ipnet::IpNet;
use serde::{Deserialize, Serialize};
use std::{io, net::IpAddr};
use winreg::{RegKey, enums::*};
const PREFIX: &str = "Route-";
#[derive(Serialize, Deserialize)]
pub(super) struct Route {
pub prefix: IpNet,
pub next_hop: IpAddr,
pub interface_luid: u64,
pub metric: u32,
pub prefix_scope: u32,
pub next_hop_scope: u32,
}
pub(super) struct Journal(RegKey);
impl Journal {
pub fn begin(path: &str) -> io::Result<Self> {
let (parent, name) = path
.rsplit_once('\\')
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Recovery key must have a registry parent"))?;
let (parent, _) = RegKey::predef(HKEY_LOCAL_MACHINE).create_subkey(parent)?;
// ActiveStore routes and this volatile key share the kernel's lifetime.
// HKLM parent permissions restrict writes to SYSTEM and administrators.
let (key, _) = parent.create_subkey_with_options_flags(name, REG_OPTION_VOLATILE, KEY_READ | KEY_WRITE)?;
let journal = Self(key);
if !journal.routes()?.is_empty() {
return Err(io::Error::other(
"Recover the previous Windows network state before connecting",
));
}
Ok(journal)
}
pub fn open(path: &str) -> io::Result<Option<Self>> {
match RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey_with_flags(path, KEY_READ | KEY_WRITE) {
Ok(key) => Ok(Some(Self(key))),
Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(None),
Err(error) => Err(error),
}
}
pub fn routes(&self) -> io::Result<Vec<(String, Route)>> {
self
.0
.enum_values()
.filter_map(|value| match value {
Ok((name, _)) if name.starts_with(PREFIX) => Some((|| {
let text: String = self.0.get_value(&name)?;
let route = serde_json::from_str(&text).map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
Ok((name, route))
})()),
Ok(_) => None,
Err(error) => Some(Err(error)),
})
.collect()
}
pub fn record(&self, route: &Route) -> io::Result<String> {
let name = format!("{PREFIX}{}", uuid::Uuid::new_v4());
self
.0
.set_value(&name, &serde_json::to_string(route).map_err(io::Error::other)?)?;
Ok(name)
}
pub fn forget(&self, name: &str) -> io::Result<()> {
match self.0.delete_value(name) {
Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()),
result => result,
}
}
}
-454
View File
@@ -1,454 +0,0 @@
#![cfg(windows)]
//! Run as administrator with GP_TEST_WINTUN_DLL pointing to the signed Wintun DLL.
use std::{ffi::c_void, io, net::IpAddr, os::windows::ffi::OsStrExt, path::PathBuf, ptr};
use windows_sys::{
Win32::{
Foundation::{FreeLibrary, HMODULE},
NetworkManagement::Ndis::NET_LUID_LH,
System::LibraryLoader::*,
},
core::GUID,
};
type CloseAdapter = unsafe extern "system" fn(*mut c_void);
type EndSession = unsafe extern "system" fn(*mut c_void);
struct Library(HMODULE);
impl Drop for Library {
fn drop(&mut self) {
unsafe {
FreeLibrary(self.0);
}
}
}
struct Adapter {
handle: *mut c_void,
session: *mut c_void,
close: CloseAdapter,
end: EndSession,
index: u32,
_library: Library,
}
impl Adapter {
fn create() -> Result<Self, Box<dyn std::error::Error>> {
let path =
PathBuf::from(std::env::var_os("GP_TEST_WINTUN_DLL").ok_or("GP_TEST_WINTUN_DLL is required")?).canonicalize()?;
let path: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
let module = unsafe {
LoadLibraryExW(
path.as_ptr(),
ptr::null_mut(),
LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
)
};
if module.is_null() {
return Err(io::Error::last_os_error().into());
}
let library = Library(module);
// Wintun's public C ABI uses WINAPI and pointer-sized opaque handles.
let create: unsafe extern "system" fn(*const u16, *const u16, *const GUID) -> *mut c_void = unsafe {
std::mem::transmute(
GetProcAddress(module, c"WintunCreateAdapter".as_ptr().cast()).ok_or("Missing WintunCreateAdapter")?,
)
};
let close: CloseAdapter = unsafe {
std::mem::transmute(
GetProcAddress(module, c"WintunCloseAdapter".as_ptr().cast()).ok_or("Missing WintunCloseAdapter")?,
)
};
let luid: unsafe extern "system" fn(*mut c_void, *mut NET_LUID_LH) = unsafe {
std::mem::transmute(
GetProcAddress(module, c"WintunGetAdapterLUID".as_ptr().cast()).ok_or("Missing WintunGetAdapterLUID")?,
)
};
let start: unsafe extern "system" fn(*mut c_void, u32) -> *mut c_void = unsafe {
std::mem::transmute(
GetProcAddress(module, c"WintunStartSession".as_ptr().cast()).ok_or("Missing WintunStartSession")?,
)
};
let end: EndSession = unsafe {
std::mem::transmute(
GetProcAddress(module, c"WintunEndSession".as_ptr().cast()).ok_or("Missing WintunEndSession")?,
)
};
let name: Vec<u16> = format!("GP Connect Test {}", uuid::Uuid::new_v4().simple())
.encode_utf16()
.chain(Some(0))
.collect();
let kind: Vec<u16> = "GP Connect".encode_utf16().chain(Some(0)).collect();
let handle = unsafe { create(name.as_ptr(), kind.as_ptr(), ptr::null()) };
if handle.is_null() {
return Err(io::Error::last_os_error().into());
}
let mut adapter = Self {
handle,
session: ptr::null_mut(),
close,
end,
index: 0,
_library: library,
};
let mut id = NET_LUID_LH::default();
unsafe {
luid(handle, &mut id);
}
check(unsafe { ConvertInterfaceLuidToIndex(&id, &mut adapter.index) });
adapter.session = unsafe { start(handle, 0x400000) };
if adapter.session.is_null() {
return Err(io::Error::last_os_error().into());
}
std::thread::sleep(std::time::Duration::from_secs(1));
Ok(adapter)
}
}
impl Drop for Adapter {
fn drop(&mut self) {
unsafe {
if !self.session.is_null() {
(self.end)(self.session);
}
(self.close)(self.handle);
}
}
}
use gpvpnc::windows::NetworkConfigurator;
use windows_sys::Win32::{NetworkManagement::IpHelper::*, Networking::WinSock::*};
fn check(status: u32) {
assert_eq!(
status,
0,
"Native IP Helper failed: {}",
io::Error::from_raw_os_error(status as i32)
);
}
fn address(value: &SOCKADDR_INET) -> IpAddr {
unsafe {
match value.si_family {
AF_INET => std::net::Ipv4Addr::from(value.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into(),
AF_INET6 => std::net::Ipv6Addr::from(value.Ipv6.sin6_addr.u.Byte).into(),
_ => panic!("unexpected family"),
}
}
}
fn routes(index: Option<u32>) -> Vec<String> {
let mut result = Vec::new();
unsafe {
let mut table = std::ptr::null_mut();
check(GetIpForwardTable2(AF_UNSPEC, &mut table));
for row in std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize) {
if Some(row.InterfaceIndex) != index
&& !["198.51.100.1", "203.0.113.128"].contains(&address(&row.DestinationPrefix.Prefix).to_string().as_str())
{
continue;
}
result.push(format!(
"route {} {}/{} {} {}",
row.InterfaceIndex,
address(&row.DestinationPrefix.Prefix),
row.DestinationPrefix.PrefixLength,
address(&row.NextHop),
row.Metric
));
}
FreeMibTable(table.cast());
}
result.sort();
result
}
fn state(index: u32) -> Vec<String> {
let mut result = routes(Some(index));
unsafe {
let mut table = std::ptr::null_mut();
check(GetUnicastIpAddressTable(AF_UNSPEC, &mut table));
for row in std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize) {
if row.InterfaceIndex == index {
result.push(format!("address {}/{}", address(&row.Address), row.OnLinkPrefixLength));
}
}
FreeMibTable(table.cast());
for family in [AF_INET, AF_INET6] {
let mut row = MIB_IPINTERFACE_ROW {
Family: family,
InterfaceIndex: index,
..Default::default()
};
check(GetIpInterfaceEntry(&mut row));
result.push(format!(
"interface {} {} {} {} {}",
family, row.Metric, row.UseAutomaticMetric, row.NlMtu, row.DadTransmits
));
}
}
unsafe {
let mut luid = NET_LUID_LH::default();
let mut guid = GUID::default();
check(ConvertInterfaceIndexToLuid(index, &mut luid));
check(ConvertInterfaceLuidToGuid(&luid, &mut guid));
let mut dns = DNS_INTERFACE_SETTINGS {
Version: DNS_INTERFACE_SETTINGS_VERSION1,
..Default::default()
};
check(GetInterfaceDnsSettings(guid, &mut dns));
for (name, pointer) in [
("dns-domain", dns.Domain),
("dns-search", dns.SearchList),
("dns-servers", dns.NameServer),
] {
let mut length = 0;
if !pointer.is_null() {
while *pointer.add(length) != 0 {
length += 1;
}
}
let text = if pointer.is_null() {
String::new()
} else {
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
};
result.push(format!("{name} {text}"));
}
FreeInterfaceDnsSettings(&mut dns);
}
result.sort();
result
}
fn best_route(destination: &str) -> MIB_IPFORWARD_ROW2 {
let ip: IpAddr = destination.parse().unwrap();
let mut destination = SOCKADDR_INET::default();
match ip {
IpAddr::V4(ip) => {
destination.Ipv4.sin_family = AF_INET;
destination.Ipv4.sin_addr.S_un.S_addr = u32::from_ne_bytes(ip.octets());
}
IpAddr::V6(ip) => {
destination.Ipv6.sin6_family = AF_INET6;
destination.Ipv6.sin6_addr.u.Byte = ip.octets();
}
}
let mut route = MIB_IPFORWARD_ROW2::default();
let mut source = SOCKADDR_INET::default();
check(unsafe { GetBestRoute2(ptr::null(), 0, ptr::null(), &destination, 0, &mut route, &mut source) });
route
}
fn assert_dns_policy(active: bool) {
const CHECK: &str = r#"
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'
$expected = [int]$env:GP_TEST_EXPECTED_DNS_POLICIES
$configured = @(Get-DnsClientNrptRule | Where-Object { $_.Namespace -contains '.gp-connect-test.invalid' })
$effective = @(Get-DnsClientNrptPolicy | Where-Object { $_.Namespace -contains '.gp-connect-test.invalid' })
if ($configured.Count -ne $expected -or $effective.Count -ne $expected) { throw 'Unexpected configured or effective VPN DNS policy' }
if ($expected) {
$servers = @($configured[0].NameServers)
if ($servers -notcontains '198.18.0.53' -or $servers -notcontains 'fd42:1235::53') { throw 'VPN DNS server families are missing' }
}
"#;
let powershell =
PathBuf::from(std::env::var_os("SystemRoot").unwrap()).join("System32/WindowsPowerShell/v1.0/powershell.exe");
let output = std::process::Command::new(powershell)
.args(["-NoProfile", "-NonInteractive", "-Command", CHECK])
.env("GP_TEST_EXPECTED_DNS_POLICIES", if active { "1" } else { "0" })
.output()
.unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
}
#[test]
#[ignore = "requires administrator privileges and GP_TEST_WINTUN_DLL"]
fn installs_and_restores_native_network_configuration() -> Result<(), Box<dyn std::error::Error>> {
let adapter = Adapter::create()?;
let index = adapter.index;
if let Some(recovery_key) = std::env::var_os("GP_TEST_CRASH_KEY") {
let recovery_key = recovery_key.to_str().ok_or("Invalid registry key")?;
let mut network = NetworkConfigurator::new(recovery_key)?;
network.configure("connect", &environment(index))?;
std::fs::write(
std::env::var_os("GP_TEST_CRASH_READY").ok_or("Missing readiness path")?,
index.to_string(),
)?;
loop {
std::thread::park();
}
}
let environment = environment(index);
let recovery_key = format!(r"SOFTWARE\GP Connect\Tests\Network{}", uuid::Uuid::new_v4().simple());
assert_dns_policy(false);
let before = state(index);
{
let mut network = NetworkConfigurator::new(&recovery_key)?;
network.configure("connect", &environment)?;
let during = state(index);
assert!(during.iter().any(|row| row == "address 192.0.2.2/24"));
assert!(during.iter().any(|row| row == "address fd42:1234::2/64"));
assert!(
during
.iter()
.any(|row| row.starts_with(&format!("route {index} 203.0.113.0/24 ")))
);
assert!(
during
.iter()
.any(|row| row.starts_with(&format!("route {index} 2001:db8:1234::/64 ")))
);
assert_eq!(best_route("203.0.113.1").InterfaceIndex, index);
assert_eq!(best_route("2001:db8:1234::1").InterfaceIndex, index);
assert_eq!(best_route("198.18.0.53").InterfaceIndex, index);
assert_eq!(best_route("fd42:1235::53").InterfaceIndex, index);
assert_ne!(best_route("203.0.113.200").InterfaceIndex, index);
assert_ne!(best_route("198.51.100.1").InterfaceIndex, index);
println!("PASS: IPv4/IPv6 addresses, split routes, resolver routes and MTU installed");
assert_dns_policy(true);
network.configure("disconnect", &[])?;
}
assert_eq!(before, state(index), "Network state was not restored");
assert_dns_policy(false);
println!("PASS: disconnect restored addresses, routes and interface settings");
{
let mut network = NetworkConfigurator::new(&recovery_key)?;
network.configure("connect", &environment)?;
}
assert_eq!(
before,
state(index),
"Dropping the connection did not restore network state"
);
assert_dns_policy(false);
let mut invalid = environment.clone();
invalid[0].1 = Some(u32::MAX.to_string());
assert!(
NetworkConfigurator::new(&recovery_key)?
.configure("connect", &invalid)
.is_err()
);
assert_eq!(before, state(index), "Failed connection left a physical gateway route");
println!("PASS: partial setup failure rolled back its physical gateway route");
drop(adapter);
assert_crash_recovery(&recovery_key)?;
winreg::RegKey::predef(winreg::enums::HKEY_LOCAL_MACHINE).delete_subkey(&recovery_key)?;
Ok(())
}
fn environment(index: u32) -> Vec<(String, Option<String>)> {
let pairs = [
("TUNIDX", index.to_string()),
("VPNGATEWAY", "198.51.100.1".into()),
("INTERNAL_IP4_ADDRESS", "192.0.2.2".into()),
("INTERNAL_IP4_NETMASKLEN", "24".into()),
("INTERNAL_IP6_ADDRESS", "fd42:1234::2".into()),
("INTERNAL_IP6_NETMASK", "fd42:1234::2/64".into()),
("INTERNAL_IP4_MTU", "1406".into()),
("CISCO_SPLIT_INC", "1".into()),
("CISCO_SPLIT_INC_0_ADDR", "203.0.113.0".into()),
("CISCO_SPLIT_INC_0_MASKLEN", "24".into()),
("CISCO_SPLIT_EXC", "1".into()),
("CISCO_SPLIT_EXC_0_ADDR", "203.0.113.128".into()),
("CISCO_SPLIT_EXC_0_MASKLEN", "25".into()),
("CISCO_IPV6_SPLIT_INC", "1".into()),
("CISCO_IPV6_SPLIT_INC_0_ADDR", "2001:db8:1234::".into()),
("CISCO_IPV6_SPLIT_INC_0_MASKLEN", "64".into()),
("INTERNAL_IP4_DNS", "198.18.0.53 fd42:1235::53".into()),
("CISCO_DEF_DOMAIN", "gp-connect-test.invalid".into()),
("CISCO_SPLIT_DNS", "gp-connect-test.invalid".into()),
];
pairs
.into_iter()
.map(|(key, value)| (key.to_string(), Some(value)))
.collect()
}
struct CrashChild {
child: std::process::Child,
key: String,
modified_route: Option<MIB_IPFORWARD_ROW2>,
}
impl Drop for CrashChild {
fn drop(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
if let Some(route) = self.modified_route.take() {
unsafe {
DeleteIpForwardEntry2(&route);
}
}
let _ = gpvpnc::windows::recover(&self.key);
}
}
fn assert_crash_recovery(key: &str) -> Result<(), Box<dyn std::error::Error>> {
let before = routes(None);
let directory = tempfile::tempdir()?;
let ready = directory.path().join("ready");
let child = std::process::Command::new(std::env::current_exe()?)
.args([
"--ignored",
"--exact",
"installs_and_restores_native_network_configuration",
])
.env("GP_TEST_CRASH_KEY", key)
.env("GP_TEST_CRASH_READY", &ready)
.stdout(std::process::Stdio::null())
.spawn()?;
let mut child = CrashChild {
child,
key: key.into(),
modified_route: None,
};
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
while !ready.exists() {
if child.child.try_wait()?.is_some() || std::time::Instant::now() > deadline {
return Err("Crash child did not install its network state".into());
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
let child_index: u32 = std::fs::read_to_string(&ready)?.parse()?;
assert_dns_policy(true);
let dirty = routes(None);
assert_ne!(before, dirty, "Child did not create physical routes");
child.child.kill()?;
child.child.wait()?;
assert_dns_policy(true);
let mut addresses = ptr::null_mut();
check(unsafe { GetUnicastIpAddressTable(AF_UNSPEC, &mut addresses) });
let child_addresses = unsafe {
std::slice::from_raw_parts((*addresses).Table.as_ptr(), (*addresses).NumEntries as usize)
.iter()
.any(|row| row.InterfaceIndex == child_index)
};
unsafe {
FreeMibTable(addresses.cast());
}
assert!(!child_addresses, "Terminated process left its Wintun addresses");
assert_ne!(
before,
routes(None),
"Physical routes unexpectedly disappeared with the process"
);
// Model an administrator taking ownership of an exclusion after the crash.
let mut modified = best_route("203.0.113.200");
assert_eq!(address(&modified.DestinationPrefix.Prefix).to_string(), "203.0.113.128");
modified.Metric += 1;
check(unsafe { SetIpForwardEntry2(&modified) });
child.modified_route = Some(modified);
let mut expected = before.clone();
expected.push(format!(
"route {} {}/{} {} {}",
modified.InterfaceIndex,
address(&modified.DestinationPrefix.Prefix),
modified.DestinationPrefix.PrefixLength,
address(&modified.NextHop),
modified.Metric
));
expected.sort();
gpvpnc::windows::recover(key)?;
assert_eq!(
expected,
routes(None),
"Recovery must remove owned routes and preserve the changed route"
);
assert_dns_policy(false);
drop(NetworkConfigurator::new(key)?);
check(unsafe { DeleteIpForwardEntry2(&modified) });
child.modified_route = None;
assert_eq!(before, routes(None), "Crash recovery did not restore the baseline");
println!("PASS: crash recovery removed owned physical routes and DNS policy and preserved an administrator's change");
Ok(())
}
-3
View File
@@ -19,6 +19,3 @@ fs_extra = "1"
[dev-dependencies]
tempfile = "3"
[target.'cfg(windows)'.dependencies]
windows-sys = { version = "0.61", features = ["Win32_Networking_WinSock"] }
-7
View File
@@ -1,6 +1,3 @@
#[path = "build/windows.rs"]
mod windows;
use std::{env, path::PathBuf};
fn build_libxml2(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
@@ -191,10 +188,6 @@ fn build_openconnect(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
fn main() {
let target = target_os();
if target == "windows" {
windows::build();
return;
}
assert!(
matches!(target.as_str(), "macos" | "linux" | "freebsd" | "openbsd"),
"Unsupported OpenConnect target: {target}"
-31
View File
@@ -1,31 +0,0 @@
//! Link the MinGW-built OpenConnect DLL into the native MSVC Rust service.
use std::{env, path::PathBuf};
pub fn build() {
println!("cargo:rerun-if-env-changed=OPENCONNECT_WINDOWS_PREFIX");
let prefix = PathBuf::from(
env::var_os("OPENCONNECT_WINDOWS_PREFIX")
.expect("Build native OpenConnect and set OPENCONNECT_WINDOWS_PREFIX to its install directory"),
);
let include = prefix.join("include");
let library = prefix.join("lib");
assert!(
library.join("openconnect.lib").is_file(),
"The native OpenConnect MSVC import library is missing"
);
println!("cargo:rerun-if-changed={}", library.join("openconnect.lib").display());
println!("cargo:rerun-if-changed={}", include.join("openconnect.h").display());
println!("cargo:rustc-link-search=native={}", library.display());
println!("cargo:rustc-link-lib=dylib=openconnect");
println!("cargo:rustc-link-lib=ws2_32");
println!("cargo:include={}", include.display());
println!("cargo:lib_dir={}", prefix.join("bin").display());
println!("cargo:rerun-if-changed=src/ffi/vpn.c");
println!("cargo:rerun-if-changed=src/ffi/vpn.h");
cc::Build::new()
.file("src/ffi/vpn.c")
.include("src/ffi")
.include(include)
.std("c11")
.compile("vpn");
}
+6 -10
View File
@@ -1,11 +1,7 @@
#[cfg(unix)]
use libc::{AF_INET, AF_INET6, addrinfo, getaddrinfo};
use std::{
ffi::{c_char, c_int},
ptr,
};
#[cfg(windows)]
use windows_sys::Win32::Networking::WinSock::{ADDRINFOA as addrinfo, AF_INET, AF_INET6, getaddrinfo};
/// Resolve with the system's normal policy, then prefer one family without
/// discarding alternatives. The returned list remains owned by libc and is
@@ -17,18 +13,18 @@ use windows_sys::Win32::Networking::WinSock::{ADDRINFOA as addrinfo, AF_INET, AF
pub unsafe extern "C" fn vpn_resolve_gateway(
node: *const c_char,
service: *const c_char,
hints: *const addrinfo,
result: *mut *mut addrinfo,
hints: *const libc::addrinfo,
result: *mut *mut libc::addrinfo,
preference: u32,
) -> c_int {
// SAFETY: The OpenConnect callback forwards valid getaddrinfo arguments.
let status = unsafe { getaddrinfo(node.cast(), service.cast(), hints, result) };
let status = unsafe { libc::getaddrinfo(node, service, hints, result) };
if status != 0 {
return status;
}
let family = match preference {
4 => AF_INET as c_int,
6 => AF_INET6 as c_int,
4 => libc::AF_INET,
6 => libc::AF_INET6,
_ => return 0,
};
// SAFETY: A successful getaddrinfo call returns an owned, writable list.
@@ -38,7 +34,7 @@ pub unsafe extern "C" fn vpn_resolve_gateway(
/// # Safety
/// `head` must be an exclusively owned, writable addrinfo list with no cycles.
unsafe fn prefer_family(head: *mut addrinfo, family: c_int) -> *mut addrinfo {
unsafe fn prefer_family(head: *mut libc::addrinfo, family: c_int) -> *mut libc::addrinfo {
let mut addresses = Vec::new();
let mut current = head;
// SAFETY: The caller owns every node; sorting only changes the list links.
+8 -15
View File
@@ -1,8 +1,3 @@
#[cfg(unix)]
pub(crate) type CommandHandle = i32;
#[cfg(windows)]
pub(crate) type CommandHandle = usize;
mod gateway;
mod hip;
mod network_configuration;
@@ -46,11 +41,9 @@ pub(crate) struct ConnectOptions {
pub script: *const c_char,
pub configure_network: Option<unsafe extern "C" fn(*mut c_void, *const c_char, *const VpnOptionRaw) -> c_int>,
pub interface_name: *const c_char,
pub interface: *const c_char,
pub script_tun: u32,
pub script_tun_launch: *const ScriptTunLaunchRaw,
#[cfg(windows)]
pub script_tun_pipe: isize,
pub certificate: *const c_char,
pub sslkey: *const c_char,
@@ -84,17 +77,17 @@ pub(crate) struct VpnSessionInfoRaw {
#[link(name = "vpn")]
unsafe extern "C" {
fn vpn_write_cancel(fd: CommandHandle) -> c_int;
fn vpn_write_statistics(fd: CommandHandle) -> c_int;
fn vpn_write_cancel(fd: c_int) -> c_int;
fn vpn_write_statistics(fd: c_int) -> c_int;
#[link_name = "vpn_connect"]
fn vpn_connect(
options: *const ConnectOptions,
callback: extern "C" fn(CommandHandle, *const VpnSessionInfoRaw, *mut c_void),
callback: extern "C" fn(i32, *const VpnSessionInfoRaw, *mut c_void),
) -> c_int;
}
pub(crate) fn write_cancel(fd: CommandHandle) -> std::io::Result<()> {
pub(crate) fn write_cancel(fd: i32) -> std::io::Result<()> {
let error = unsafe { vpn_write_cancel(fd) };
if error == 0 {
Ok(())
@@ -103,7 +96,7 @@ pub(crate) fn write_cancel(fd: CommandHandle) -> std::io::Result<()> {
}
}
pub(crate) fn write_statistics(fd: CommandHandle) -> std::io::Result<()> {
pub(crate) fn write_statistics(fd: i32) -> std::io::Result<()> {
let error = unsafe { vpn_write_statistics(fd) };
if error == 0 {
Ok(())
@@ -113,7 +106,7 @@ pub(crate) fn write_statistics(fd: CommandHandle) -> std::io::Result<()> {
}
#[unsafe(no_mangle)]
extern "C" fn vpn_attach_command_pipe(vpn: *mut c_void, fd: CommandHandle) -> c_int {
extern "C" fn vpn_attach_command_pipe(vpn: *mut c_void, fd: c_int) -> c_int {
unsafe { &*(vpn as *const Vpn) }.attach_command_pipe(fd).into()
}
@@ -141,7 +134,7 @@ pub(crate) extern "C" fn on_hip_report_submitted(vpn: *mut c_void, report: *cons
}
#[unsafe(no_mangle)]
extern "C" fn on_vpn_connected(pipe_fd: CommandHandle, session_info: *const VpnSessionInfoRaw, vpn: *mut c_void) {
extern "C" fn on_vpn_connected(pipe_fd: i32, session_info: *const VpnSessionInfoRaw, vpn: *mut c_void) {
let vpn = unsafe { &*(vpn as *const Vpn) };
vpn.on_connected(pipe_fd, crate::vpn::session_info_from_raw(session_info));
}
+46 -61
View File
@@ -1,15 +1,16 @@
#include "vpn.h"
#include <openconnect.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef _WIN32
#include <sys/utsname.h>
#include <unistd.h>
#endif
#include "vpn.h"
struct vpn_context {
struct openconnect_info *vpninfo;
vpn_command_handle command_fd;
int command_fd;
const vpn_options *options;
vpn_connected_callback on_connected;
};
@@ -58,22 +59,21 @@ static int validate_peer_cert(void *private_data,
if (context->options->servercert)
return openconnect_check_peer_cert_hash(context->vpninfo,
context->options->servercert);
VPN_INFO("Accepting the server certificate though %s", reason);
INFO("Accepting the server certificate though %s", reason);
return 0;
}
/* Print progress messages */
static void print_progress(void *_vpninfo, int level,
static void print_progress(__attribute__((unused)) void *_vpninfo, int level,
const char *format, ...)
{
(void)_vpninfo;
va_list args;
va_start(args, format);
char *message = format_message(format, args);
va_end(args);
if (message == NULL) {
VPN_ERROR("Failed to format log message");
ERROR("Failed to format log message");
} else {
vpn_log(level, message);
free(message);
@@ -88,24 +88,15 @@ static void setup_tun_handler(void *private_data)
int ret;
if (options->script_tun) {
const struct openconnect_script_tun_launch *launch = options->script_tun_launch;
#ifdef _WIN32
if (options->script_tun_pipe != -1) {
ret = openconnect_setup_tun_pipe(_vpninfo, options->script_tun_pipe);
} else
#endif
if (launch) {
#ifndef _WIN32
ret = openconnect_setup_tun_script_exec(_vpninfo, launch);
vpn_script_started(options->user_data);
#else
ret = -EOPNOTSUPP;
#endif
} else {
ret = openconnect_setup_tun_script(_vpninfo, options->script);
}
} else {
ret = openconnect_setup_tun_device(_vpninfo, options->script,
options->interface_name);
options->interface);
}
if (!ret) {
@@ -131,39 +122,39 @@ static void setup_tun_handler(void *private_data)
int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
{
struct openconnect_info *vpninfo;
char hostname[256];
struct utsname utsbuf;
const char *effective_local_hostname = NULL;
struct vpn_context context = { .options = options, .on_connected = callback };
int result = 1;
VPN_INFO("USER_AGENT: %s", options->user_agent);
VPN_INFO("OS: %s", options->os);
VPN_INFO("CLIENT_VERSION: %s", options->client_version);
VPN_INFO("HOST_ID: %s", options->host_id ? options->host_id : "(not set)");
INFO("USER_AGENT: %s", options->user_agent);
INFO("OS: %s", options->os);
INFO("CLIENT_VERSION: %s", options->client_version);
INFO("HOST_ID: %s", options->host_id ? options->host_id : "(not set)");
const char *configuration = options->script;
if (options->configure_network)
configuration = "callback";
else if (options->script_tun_launch)
configuration = options->script_tun_launch->program;
VPN_INFO("Network configuration: %s", configuration);
VPN_INFO("SCRIPT_TUN: %d", options->script_tun);
VPN_INFO("CSD_USER: %d", options->hip_script.uid);
VPN_INFO("CSD_WRAPPER: %s", options->hip_script.path);
VPN_INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
VPN_INFO("MTU: %d", options->mtu);
VPN_INFO("DISABLE_IPV6: %d", options->disable_ipv6);
VPN_INFO("GATEWAY_IP_PREFERENCE: %d", options->gateway_ip_preference);
VPN_INFO("NO_DTLS: %d", options->no_dtls);
VPN_INFO("DPD_INTERVAL: %d", options->dpd_interval);
VPN_INFO("NO_XMLPOST: %d", options->no_xmlpost);
INFO("Network configuration: %s", configuration);
INFO("SCRIPT_TUN: %d", options->script_tun);
INFO("CSD_USER: %d", options->hip_script.uid);
INFO("CSD_WRAPPER: %s", options->hip_script.path);
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
INFO("MTU: %d", options->mtu);
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
INFO("GATEWAY_IP_PREFERENCE: %d", options->gateway_ip_preference);
INFO("NO_DTLS: %d", options->no_dtls);
INFO("DPD_INTERVAL: %d", options->dpd_interval);
INFO("NO_XMLPOST: %d", options->no_xmlpost);
vpninfo =
openconnect_vpninfo_new(options->user_agent, validate_peer_cert,
NULL, NULL, print_progress, &context);
if (!vpninfo) {
VPN_ERROR("openconnect_vpninfo_new failed");
ERROR("openconnect_vpninfo_new failed");
vpn_tunnel_event(options->user_data, VPN_TUNNEL_ENDED);
return 1;
}
@@ -177,21 +168,20 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
openconnect_set_stats_handler(vpninfo, observe_statistics);
openconnect_set_gp_hip_report_callback(vpninfo, options->user_data,
options->on_hip_report_submitted);
/* Windows command pipes are Winsock sockets. Initialize before creating them. */
openconnect_init_ssl();
context.command_fd = openconnect_setup_cmd_pipe(vpninfo);
if (context.command_fd == (vpn_command_handle)-1) {
VPN_ERROR("openconnect_setup_cmd_pipe failed");
if (context.command_fd < 0) {
ERROR("openconnect_setup_cmd_pipe failed");
goto cleanup;
}
/* An earlier disconnect remains latched on this attempt. */
if (vpn_attach_command_pipe(options->user_data, context.command_fd)) {
VPN_INFO("VPN attempt canceled before startup");
INFO("VPN attempt canceled before startup");
result = -EINTR;
goto cleanup;
}
openconnect_set_loglevel(vpninfo, PRG_TRACE);
openconnect_init_ssl();
openconnect_set_protocol(vpninfo, "gp");
openconnect_parse_url(vpninfo, options->server);
if (options->gateway_ip_preference)
@@ -217,19 +207,18 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
}
effective_local_hostname = options->local_hostname;
if (!effective_local_hostname && !gethostname(hostname, sizeof(hostname))) {
hostname[sizeof(hostname) - 1] = 0;
effective_local_hostname = hostname;
if (!effective_local_hostname && !uname(&utsbuf)) {
effective_local_hostname = utsbuf.nodename;
}
if (effective_local_hostname) {
openconnect_set_localname(vpninfo, effective_local_hostname);
}
VPN_INFO("LOCAL_HOSTNAME: %s",
INFO("LOCAL_HOSTNAME: %s",
effective_local_hostname ? effective_local_hostname : "(not set)");
if (options->certificate) {
VPN_INFO("Setting client certificate: %s", options->certificate);
INFO("Setting client certificate: %s", options->certificate);
openconnect_set_client_cert(vpninfo, options->certificate,
options->sslkey);
}
@@ -267,7 +256,7 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
// Essential step
vpn_tunnel_event(options->user_data, OC_TUNNEL_NEGOTIATING);
if (openconnect_make_cstp_connection(vpninfo) != 0) {
VPN_ERROR("openconnect_make_cstp_connection failed");
ERROR("openconnect_make_cstp_connection failed");
goto cleanup;
}
@@ -284,12 +273,12 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
options->reconnect_timeout, 10);
if (ret) {
VPN_INFO("openconnect_mainloop returned %d, exiting", ret);
INFO("openconnect_mainloop returned %d, exiting", ret);
result = ret;
goto cleanup;
}
VPN_INFO("openconnect_mainloop returned 0, reconnecting");
INFO("openconnect_mainloop returned 0, reconnecting");
}
cleanup:
vpn_detach_command_pipe(options->user_data);
@@ -300,28 +289,24 @@ cleanup:
}
/* Called with the attempt cancellation mutex held, never after detach/free. */
static int write_command(vpn_command_handle fd, char command)
int vpn_write_cancel(int fd)
{
#ifdef _WIN32
int written = send(fd, &command, 1, 0);
return written == 1 ? 0 : (written == SOCKET_ERROR ? WSAGetLastError() : EIO);
#else
char command = OC_CMD_CANCEL;
ssize_t written;
do {
written = write(fd, &command, 1);
} while (written < 0 && errno == EINTR);
return written == 1 ? 0 : (written < 0 ? errno : EIO);
#endif
}
int vpn_write_cancel(vpn_command_handle fd)
int vpn_write_statistics(int fd)
{
return write_command(fd, OC_CMD_CANCEL);
}
int vpn_write_statistics(vpn_command_handle fd)
{
return write_command(fd, OC_CMD_STATS);
char command = OC_CMD_STATS;
ssize_t written;
do {
written = write(fd, &command, 1);
} while (written < 0 && errno == EINTR);
return written == 1 ? 0 : (written < 0 ? errno : EIO);
}
int vpn_collect_hip_report(const vpn_hip_script *script,
+9 -19
View File
@@ -1,10 +1,3 @@
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
typedef SOCKET vpn_command_handle;
#else
typedef int vpn_command_handle;
#endif
#include <openconnect.h>
#include <stdarg.h>
#include <stdio.h>
@@ -20,7 +13,7 @@ typedef struct vpn_session_info {
const char *nlb_connected_gw_ip;
} vpn_session_info;
typedef void (*vpn_connected_callback)(vpn_command_handle cmd_pipe_fd,
typedef void (*vpn_connected_callback)(int cmd_pipe_fd,
const vpn_session_info *session_info,
void *user_data);
typedef void (*vpn_hip_report_callback)(void *user_data, const char *report,
@@ -52,12 +45,9 @@ typedef struct vpn_options {
const char *script;
openconnect_configure_tun_fn configure_network;
const char *interface_name;
const char *interface;
const int script_tun;
const struct openconnect_script_tun_launch *script_tun_launch;
#ifdef _WIN32
intptr_t script_tun_pipe;
#endif
const char *certificate;
const char *sslkey;
@@ -83,7 +73,7 @@ extern int vpn_resolve_gateway(const char *node, const char *service,
int vpn_collect_hip_report(const vpn_hip_script *, const struct openconnect_gp_hip_request *,
const struct openconnect_gp_hip_control *, openconnect_gp_hip_generate_fn, void *, char *, size_t, size_t *);
extern int vpn_attach_command_pipe(void *user_data, vpn_command_handle fd);
extern int vpn_attach_command_pipe(void *user_data, int fd);
extern void vpn_detach_command_pipe(void *user_data);
extern void vpn_script_started(void *user_data);
enum vpn_tunnel_event {
@@ -92,7 +82,7 @@ enum vpn_tunnel_event {
VPN_TUNNEL_ENDED,
};
extern void vpn_tunnel_event(void *user_data, int event);
extern void vpn_tunnel_configuration(void *user_data, const char *interface_name,
extern void vpn_tunnel_configuration(void *user_data, const char *interface,
const struct oc_ip_info *info);
extern void vpn_tunnel_statistics(void *user_data, const struct oc_stats *stats);
@@ -132,8 +122,8 @@ static void _log(int level, ...)
}
}
#define VPN_LOG(level, ...) _log(level, __VA_ARGS__)
#define VPN_ERROR(...) VPN_LOG(PRG_ERR, __VA_ARGS__)
#define VPN_INFO(...) VPN_LOG(PRG_INFO, __VA_ARGS__)
#define VPN_DEBUG(...) VPN_LOG(PRG_DEBUG, __VA_ARGS__)
#define VPN_TRACE(...) VPN_LOG(PRG_TRACE, __VA_ARGS__)
#define LOG(level, ...) _log(level, __VA_ARGS__)
#define ERROR(...) LOG(PRG_ERR, __VA_ARGS__)
#define INFO(...) LOG(PRG_INFO, __VA_ARGS__)
#define DEBUG(...) LOG(PRG_DEBUG, __VA_ARGS__)
#define TRACE(...) LOG(PRG_TRACE, __VA_ARGS__)
+8 -63
View File
@@ -1,10 +1,7 @@
#[cfg(unix)]
use std::os::fd::{AsRawFd, OwnedFd};
#[cfg(windows)]
use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::{
ffi::{CStr, CString, c_char},
fmt, io,
os::fd::{AsRawFd, OwnedFd},
sync::{Arc, Mutex, RwLock},
};
@@ -40,8 +37,7 @@ pub(crate) fn session_info_from_raw(raw: *const ffi::VpnSessionInfoRaw) -> VpnSe
let raw = unsafe { &*raw };
let warning_message =
unsafe { optional_c_string(raw.lifetime_warning_message) }.filter(|message| !message.is_empty());
let user_expires =
positive_i64_to_u32(raw.user_expires.into()).or_else(|| positive_i64_to_u32(raw.auth_expiration.into()));
let user_expires = positive_i64_to_u32(raw.user_expires).or_else(|| positive_i64_to_u32(raw.auth_expiration));
VpnSessionInfo {
lifetime_secs: positive_i64_to_u32(raw.lifetime_secs as i64),
@@ -77,12 +73,12 @@ struct Cancellation {
#[derive(Default)]
struct CancellationState {
requested: bool,
command_fd: Option<ffi::CommandHandle>,
command_fd: Option<i32>,
statistics_pending: bool,
}
impl Cancellation {
fn attach(&self, fd: ffi::CommandHandle) -> bool {
fn attach(&self, fd: i32) -> bool {
let mut state = self.state.lock().unwrap();
state.command_fd = Some(fd);
state.requested
@@ -154,10 +150,7 @@ pub struct Vpn {
pub(crate) network_configuration_handler: Option<Arc<NetworkConfigurationHandler>>,
interface: Option<CString>,
script_tun: bool,
#[cfg(unix)]
script_tun_launch: Option<ScriptTunLaunch>,
#[cfg(windows)]
script_tun_pipe: Option<OwnedHandle>,
certificate: Option<CString>,
sslkey: Option<CString>,
@@ -239,9 +232,7 @@ impl Vpn {
}
self.callback.write().unwrap().replace(Box::new(on_connected));
let mut options = self.build_connect_options();
#[cfg(unix)]
let mut argv = Vec::new();
#[cfg(unix)]
let launch = self.script_tun_launch.as_ref().map(|launch| {
argv.push(launch.program.as_ptr());
argv.extend(launch.arguments.iter().map(|s| s.as_ptr()));
@@ -254,10 +245,7 @@ impl Vpn {
}
});
// Both the borrowed launch record and argv remain alive through native connect.
#[cfg(unix)]
{
options.script_tun_launch = launch.as_ref().map_or(std::ptr::null(), |launch| launch);
}
options.script_tun_launch = launch.as_ref().map_or(std::ptr::null(), |launch| launch);
let environment = match self.hip_source.as_ref() {
HipSource::Script(script) => ffi::script_environment(script),
_ => Vec::new(),
@@ -281,7 +269,7 @@ impl Vpn {
}
}
pub(crate) fn on_connected(&self, pipe_fd: ffi::CommandHandle, session_info: VpnSessionInfo) {
pub(crate) fn on_connected(&self, pipe_fd: i32, session_info: VpnSessionInfo) {
info!("Connected to VPN, pipe_fd: {}", pipe_fd);
if let Some(callback) = self.callback.write().unwrap().take() {
@@ -289,7 +277,7 @@ impl Vpn {
}
}
pub(crate) fn attach_command_pipe(&self, fd: ffi::CommandHandle) -> bool {
pub(crate) fn attach_command_pipe(&self, fd: i32) -> bool {
self.cancellation.attach(fd)
}
@@ -323,15 +311,9 @@ impl Vpn {
.network_configuration_handler
.as_ref()
.map(|_| ffi::configure_network as _),
interface_name: Self::option_to_ptr(&self.interface),
interface: Self::option_to_ptr(&self.interface),
script_tun: self.script_tun as u32,
script_tun_launch: std::ptr::null(),
#[cfg(windows)]
script_tun_pipe: self
.script_tun_pipe
.as_ref()
.map(|handle| handle.as_raw_handle() as isize)
.unwrap_or(-1),
certificate: Self::option_to_ptr(&self.certificate),
sslkey: Self::option_to_ptr(&self.sslkey),
@@ -384,7 +366,6 @@ impl fmt::Display for VpnError {
impl std::error::Error for VpnError {}
#[cfg(unix)]
struct ScriptTunLaunch {
program: CString,
arguments: Vec<CString>,
@@ -400,10 +381,7 @@ pub struct VpnBuilder {
script_is_path: bool,
interface: Option<String>,
script_tun: bool,
#[cfg(unix)]
script_tun_launch: Option<ScriptTunLaunch>,
#[cfg(windows)]
script_tun_pipe: Option<OwnedHandle>,
user_agent: Option<String>,
os: Option<String>,
@@ -438,10 +416,7 @@ impl VpnBuilder {
script_is_path: false,
interface: None,
script_tun: false,
#[cfg(unix)]
script_tun_launch: None,
#[cfg(windows)]
script_tun_pipe: None,
user_agent: None,
os: None,
@@ -494,7 +469,6 @@ impl VpnBuilder {
self
}
#[cfg(unix)]
pub fn script_tun_program(
mut self,
program: &str,
@@ -521,19 +495,6 @@ impl VpnBuilder {
Ok(self)
}
/// Deliver packets through a connected Windows message-mode pipe.
///
/// # Safety
/// The handle must use overlapped I/O and must not be associated with an IOCP.
/// OpenConnect duplicates it and owns its own completion events; attaching a
/// Tokio/Mio handle would send native OVERLAPPED completions into that reactor.
#[cfg(windows)]
pub unsafe fn script_tun_pipe(mut self, pipe: OwnedHandle) -> Self {
self.script_tun = true;
self.script_tun_pipe = Some(pipe);
self
}
pub fn script_tun(mut self, script_tun: bool) -> Self {
self.script_tun = script_tun;
self
@@ -635,17 +596,9 @@ impl VpnBuilder {
}
return Ok(None);
}
#[cfg(unix)]
if self.script_tun_launch.is_some() {
return Ok(None);
}
#[cfg(windows)]
if self.script_tun_pipe.is_some() {
if self.script.is_some() || !self.script_tun {
return Err(VpnError::new("Packet pipe conflicts with script options".into()));
}
return Ok(None);
}
let script = match &self.script {
Some(script) => {
if self.script_is_path && !std::path::Path::new(script).exists() {
@@ -665,7 +618,6 @@ impl VpnBuilder {
}
pub fn build(self) -> Result<Vpn, VpnError> {
#[cfg(unix)]
if self.script_tun_launch.is_some() && !self.script_tun {
return Err(VpnError::new("Child identity requires script-tun".into()));
}
@@ -690,10 +642,7 @@ impl VpnBuilder {
network_configuration_handler: self.network_configuration_handler,
interface: self.interface.as_deref().map(Self::to_cstring),
script_tun: self.script_tun,
#[cfg(unix)]
script_tun_launch: self.script_tun_launch,
#[cfg(windows)]
script_tun_pipe: self.script_tun_pipe,
certificate: self.certificate.as_deref().map(Self::to_cstring),
sslkey: self.sslkey.as_deref().map(Self::to_cstring),
@@ -825,10 +774,7 @@ mod tests {
network_configuration_handler: None,
interface: None,
script_tun: false,
#[cfg(unix)]
script_tun_launch: None,
#[cfg(windows)]
script_tun_pipe: None,
certificate: None,
sslkey: None,
key_password: None,
@@ -1132,7 +1078,6 @@ mod tests {
}
#[unsafe(no_mangle)]
#[cfg(unix)]
extern "C" fn vpn_script_started(data: *mut std::ffi::c_void) {
// Native setup has forked or failed; only the child may retain this endpoint.
let vpn = unsafe { &*(data as *const Vpn) };
@@ -1,169 +0,0 @@
/* Exercise the DLL's packet mainloop without a VPN server or kernel adapter. */
#include "config.h"
#include "openconnect-internal.h"
#include <assert.h>
struct test_context {
wchar_t name[128];
SOCKET command;
int mode, seeded;
volatile LONG statistics;
};
static void progress(void *data, int level, const char *format, ...)
{
(void)data; (void)level; (void)format;
}
static void statistics(void *data, const struct oc_stats *stats)
{
struct test_context *context = data;
(void)stats;
InterlockedIncrement(&context->statistics);
}
static int pump(struct openconnect_info *vpninfo, int *timeout, int readable)
{
struct test_context *context = vpninfo->cbdata;
struct pkt *packet;
int work = 0;
(void)timeout; (void)readable;
vpninfo->need_poll_cmd_fd = 1;
while ((packet = dequeue_packet(&vpninfo->outgoing_queue))) {
queue_packet(&vpninfo->incoming_queue, packet);
work = 1;
}
if (context->mode == 2 && !context->seeded) {
int index;
context->seeded = 1;
for (index = 0; index < 32; index++) {
packet = calloc(1, sizeof(*packet) + 1500);
assert(packet);
packet->len = 1500;
memset(packet->data, index, packet->len);
queue_packet(&vpninfo->incoming_queue, packet);
}
work = 1;
}
return work;
}
static const struct vpn_proto protocol = { .name = "packet-test", .tcp_mainloop = pump };
static DWORD WINAPI client(void *data)
{
struct test_context *context = data;
HANDLE pipe = CreateFileW(context->name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, NULL);
DWORD mode = PIPE_READMODE_MESSAGE, count;
char bytes[1024], response[1024], command;
assert(pipe != INVALID_HANDLE_VALUE);
assert(SetNamedPipeHandleState(pipe, &mode, NULL, NULL));
if (context->mode == 0) {
int index;
for (index = 0; index < 2; index++) {
DWORD length = 257 + index * 97;
memset(bytes, 'a' + index, length);
assert(WriteFile(pipe, bytes, length, &count, NULL) && count == length);
assert(ReadFile(pipe, response, sizeof(response), &count, NULL) && count == length);
assert(!memcmp(bytes, response, length));
}
} else if (context->mode == 3) {
/* Free before mainloop must close the duplicate and drain its read. */
assert(!ReadFile(pipe, response, sizeof(response), &count, NULL));
assert(GetLastError() == ERROR_BROKEN_PIPE);
} else {
/* No reads: mode 2 fills the service-to-worker packet buffer. */
Sleep(100);
command = OC_CMD_STATS;
assert(send(context->command, &command, 1, 0) == 1);
Sleep(100);
command = OC_CMD_CANCEL;
assert(send(context->command, &command, 1, 0) == 1);
Sleep(100);
}
CloseHandle(pipe);
return 0;
}
static DWORD WINAPI watchdog(void *event)
{
if (WaitForSingleObject(event, 15000) == WAIT_TIMEOUT) {
fputs("FAIL: packet pipe test timed out\n", stderr);
ExitProcess(99);
}
return 0;
}
static void run(int mode)
{
struct test_context context = { .mode = mode };
struct openconnect_info *vpninfo;
HANDLE pipe, thread, event;
OVERLAPPED connected = { 0 };
DWORD count;
ULONGLONG started;
int result;
swprintf(context.name, 128, L"\\\\.\\pipe\\GPConnect.NativePacketTest.%lu.%d", GetCurrentProcessId(), mode);
pipe = CreateNamedPipeW(context.name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS, 1, 4096, 4096, 0, NULL);
assert(pipe != INVALID_HANDLE_VALUE);
vpninfo = openconnect_vpninfo_new("packet-test", NULL, NULL, NULL, progress, &context);
assert(vpninfo);
context.command = openconnect_setup_cmd_pipe(vpninfo);
assert(context.command != INVALID_SOCKET);
vpninfo->proto = &protocol;
vpninfo->dtls_state = DTLS_DISABLED;
vpninfo->ip_info.mtu = 1500;
openconnect_set_stats_handler(vpninfo, statistics);
thread = CreateThread(NULL, 0, client, &context, 0, NULL);
assert(thread);
event = CreateEvent(NULL, TRUE, FALSE, NULL);
assert(event);
connected.hEvent = event;
if (!ConnectNamedPipe(pipe, &connected)) {
DWORD error = GetLastError();
if (error != ERROR_PIPE_CONNECTED) {
assert(error == ERROR_IO_PENDING);
assert(GetOverlappedResult(pipe, &connected, &count, TRUE));
}
}
CloseHandle(event);
assert(!openconnect_setup_tun_pipe(vpninfo, (intptr_t)pipe));
assert(vpninfo->tun_is_pipe && vpninfo->tun_fh != pipe);
CloseHandle(pipe);
started = GetTickCount64();
if (mode == 3) {
vpninfo->tun_pkt = calloc(1, sizeof(struct pkt) + 1500);
assert(vpninfo->tun_pkt);
assert(!ReadFile(vpninfo->tun_fh, vpninfo->tun_pkt->data, 1500, &count, &vpninfo->tun_rd_overlap));
assert(GetLastError() == ERROR_IO_PENDING);
vpninfo->tun_rd_pending = 1;
openconnect_vpninfo_free(vpninfo);
} else {
result = openconnect_mainloop(vpninfo, 1, 1);
assert(result < 0);
assert(vpninfo->tun_fh == INVALID_HANDLE_VALUE && !vpninfo->tun_rd_pending);
assert(!vpninfo->tun_rd_overlap.hEvent && !vpninfo->tun_wr_overlap.hEvent);
if (mode) {
assert(GetTickCount64() - started < 3000);
assert(context.statistics == 1);
if (mode == 2)
assert(vpninfo->stats.rx_pkts > 0 && vpninfo->stats.rx_pkts < 32);
} else {
assert(vpninfo->stats.rx_pkts == 2 && vpninfo->stats.tx_pkts == 2);
}
openconnect_vpninfo_free(vpninfo);
}
assert(WaitForSingleObject(thread, 2000) == WAIT_OBJECT_0);
CloseHandle(thread);
printf("PASS: native packet pipe case %d\n", mode);
}
int main(void)
{
HANDLE stop = CreateEvent(NULL, TRUE, FALSE, NULL);
HANDLE guard = CreateThread(NULL, 0, watchdog, stop, 0, NULL);
int mode;
assert(stop && guard);
assert(!openconnect_init_ssl());
for (mode = 0; mode < 4; mode++)
run(mode);
SetEvent(stop);
WaitForSingleObject(guard, 1000);
CloseHandle(guard);
CloseHandle(stop);
return 0;
}
-66
View File
@@ -1,66 +0,0 @@
# Windows installer
`installer.nsi` embeds a complete Windows payload and the canonical
`machine-install.ps1` installation implementation. Build it with NSIS 3 Unicode:
```powershell
& makensis /DTARGET_ARCH=x64 /DPAYLOAD_DIR=C:\build\payload /DOUTPUT_FILE=C:\build\GPConnect-Setup.exe /DPRODUCT_VERSION=3.4.0 /DBUILD_VERSION=3.4.0.0 /DDISPLAY_VERSION=3.4.0-snapshot.2026.1114.2 .\packaging\windows\installer.nsi
```
`TARGET_ARCH` is `x64` or `arm64` and must match every executable and DLL in
the payload. Each installer accepts only its native Windows architecture. ARM64
requires Windows 11; x64 requires Windows 10 build 19041 or newer.
`BUILD_VERSION` must contain four numeric components. `PRODUCT_VERSION` must
match the payload's `build-info.json`. `DISPLAY_VERSION` is the full release
identity, including the snapshot build when applicable. The payload must contain matching
`gpgui.exe`, `gpauth.exe`, `gpservice.exe`, their DLL dependency closure, the
vendor-signed `wintun.dll`, `licenses`, and `build-info.json`. The NSIS compiler
adds the generated uninstaller; it is not a separately built executable.
The installer, extraction progress and uninstaller use the shared Windows icon
from `apps/gpauth/icons/windows/icon.ico`. The Finish page uses `sidebar.bmp`,
derived from that same icon. After regenerating application icons, run
`powershell -NoProfile -File scripts/generate-windows-installer-artwork.ps1`
on Windows and retain the updated bitmap before building installers.
The development ZIP includes the same machine implementation as
`installer/machine-install.ps1`. Its install/uninstall entrypoints call that
implementation rather than maintaining a second file replacement algorithm.
Use the EXE installer to upgrade an installation that already has an NSIS
uninstaller; the development ZIP does not contain that generated executable.
Installation waits for the installed GUI/auth paths in all Windows sessions;
it does not stop arbitrary same-name processes. Service shutdown uses SCM,
checks the existing network-recovery criteria, and waits for file release.
Application files are staged under Program Files with protected ACLs. The old
directory is renamed to `GP Connect.previous` until the new service is Running.
Handled replacement/start failures restore old files and metadata and restart
the previous service. An interrupted installer with a retained backup requires
explicit repair; it is not automatically recovered.
Disk use includes the downloaded installer and one expanded new payload. NSIS
extracts into its temporary directory, then the machine implementation consumes
those disposable files into protected staging instead of copying the whole bundle.
When temp and Program Files use different volumes, file moves may temporarily
duplicate the file currently being moved. The old installation is renamed, not
copied. The machine implementation checks the installation volume before staging;
NSIS extraction errors must complete before service shutdown.
Successful installation removes the old copy and staging. Installer logs keep
the current and previous attempt in ProgramData. No updater cache is added.
The installer never launches the GUI as administrator. Users open GP Connect
from the Start menu after completion. User configuration and licensing state
are retained during upgrades and uninstall. Authenticode setup is separate;
WinSparkle must still verify the installer payload signature before handoff.
The service log rotates after 5 MiB and retains three numbered archives, keeping
each entry whole. The bundle includes `licenses/file-rotate.txt` for the Windows
service's rotation library.
On a disposable Windows installation, verify a normal A-to-B upgrade and a B
payload whose `gpservice.exe` is replaced with another valid PE executable that
cannot host a Windows service. The latter must fail service startup, restore A's
files and uninstall metadata, and leave A's service running. Also check held
runtime files, active GUI/auth windows, Wintun-signature failure, and concurrent
installer attempts. Do not run failure fixtures against a live company VPN.
-97
View File
@@ -1,97 +0,0 @@
Unicode true
RequestExecutionLevel admin
!include "MUI2.nsh"
!include "x64.nsh"
!ifndef PAYLOAD_DIR
!error "PAYLOAD_DIR is required"
!endif
!ifndef OUTPUT_FILE
!error "OUTPUT_FILE is required"
!endif
!ifndef PRODUCT_VERSION
!error "PRODUCT_VERSION is required"
!endif
!ifndef TARGET_ARCH
!define TARGET_ARCH "x64"
!endif
!ifndef BUILD_VERSION
!define BUILD_VERSION "${PRODUCT_VERSION}.0"
!endif
!ifndef DISPLAY_VERSION
!define DISPLAY_VERSION "${PRODUCT_VERSION}"
!endif
Name "GP Connect"
OutFile "${OUTPUT_FILE}"
InstallDir "$PROGRAMFILES64\GP Connect"
VIProductVersion "${BUILD_VERSION}"
VIAddVersionKey "ProductName" "GP Connect"
VIAddVersionKey "FileDescription" "GP Connect Installer"
VIAddVersionKey "ProductVersion" "${DISPLAY_VERSION}"
VIAddVersionKey "FileVersion" "${BUILD_VERSION}"
VIAddVersionKey "LegalCopyright" "GP Connect contributors"
ShowInstDetails show
ShowUninstDetails show
!define MUI_ICON "${__FILEDIR__}\..\..\apps\gpauth\icons\windows\icon.ico"
!define MUI_UNICON "${MUI_ICON}"
!define MUI_WELCOMEFINISHPAGE_BITMAP "${__FILEDIR__}\sidebar.bmp"
!define MUI_ABORTWARNING
!define MUI_FINISHPAGE_TITLE "GP Connect is ready"
!define MUI_FINISHPAGE_TEXT "Open GP Connect from the Start menu."
!insertmacro MUI_PAGE_INSTFILES
!insertmacro MUI_PAGE_FINISH
!insertmacro MUI_UNPAGE_CONFIRM
!insertmacro MUI_UNPAGE_INSTFILES
!insertmacro MUI_LANGUAGE "English"
Function .onInit
!if "${TARGET_ARCH}" == "arm64"
${IfNot} ${IsNativeARM64}
MessageBox MB_OK|MB_ICONSTOP "This GP Connect installer requires Windows 11 on ARM64." /SD IDOK
SetErrorLevel 1
Abort
${EndIf}
!else if "${TARGET_ARCH}" == "x64"
${IfNot} ${IsNativeAMD64}
MessageBox MB_OK|MB_ICONSTOP "This GP Connect installer requires x64 Windows." /SD IDOK
SetErrorLevel 1
Abort
${EndIf}
!else
!error "Unsupported TARGET_ARCH"
!endif
SetRegView 64
FunctionEnd
Section "Install"
InitPluginsDir
SetOutPath "$PLUGINSDIR\payload"
File /r "${PAYLOAD_DIR}\*"
WriteUninstaller "$PLUGINSDIR\payload\uninstall.exe"
SetOutPath "$PLUGINSDIR"
File "${__FILEDIR__}\machine-install.ps1"
DetailPrint "Preparing GP Connect and waiting for open windows to close..."
nsExec::ExecToLog '"$WINDIR\Sysnative\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "$PLUGINSDIR\machine-install.ps1" -Action Install -SourceDirectory "$PLUGINSDIR\payload" -Version "${PRODUCT_VERSION}" -ConsumeSource'
Pop $0
${If} $0 != 0
MessageBox MB_OK|MB_ICONSTOP "GP Connect could not be installed. See the details below and try again." /SD IDOK
SetErrorLevel 1
Abort
${EndIf}
SectionEnd
Section "Uninstall"
SetRegView 64
InitPluginsDir
SetOutPath "$PLUGINSDIR"
File "${__FILEDIR__}\machine-install.ps1"
DetailPrint "Waiting for GP Connect and sign-in windows to close..."
nsExec::ExecToLog '"$WINDIR\Sysnative\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "$PLUGINSDIR\machine-install.ps1" -Action Uninstall'
Pop $0
${If} $0 != 0
MessageBox MB_OK|MB_ICONSTOP "GP Connect could not be removed. See the details below and try again." /SD IDOK
SetErrorLevel 1
Abort
${EndIf}
SectionEnd
@@ -1,21 +0,0 @@
MIT License
Copyright (c) 2020 BourgondAries
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-383
View File
@@ -1,383 +0,0 @@
#Requires -RunAsAdministrator
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)][ValidateSet('Install', 'Uninstall')][string]$Action,
[string]$SourceDirectory,
[string]$Version,
[switch]$ConsumeSource
)
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'
if ($PSVersionTable.PSEdition -eq 'Desktop') {
# A PowerShell 7 caller can pass incompatible modules to Windows PowerShell.
$env:PSModulePath = Join-Path $PSHOME 'Modules'
}
if (![Environment]::Is64BitProcess) { throw 'Run the GP Connect installer with 64-bit PowerShell.' }
$destination = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) 'GP Connect'
$state = Join-Path $env:ProgramData 'GP Connect'
$serviceName = 'GPConnect'
$serviceBinary = Join-Path $destination 'gpservice.exe'
$shortcutPath = Join-Path $env:ProgramData 'Microsoft\Windows\Start Menu\Programs\GP Connect.lnk'
$uninstallKey = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\GPConnect'
$recoveryKey = 'HKLM:\SOFTWARE\GP Connect\NetworkRecovery'
$publicAcl = 'O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FRFX;;;BU)'
$privateAcl = 'O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)'
$backup = $destination + '.previous'
$stage = $null
$oldMoved = $false
$newMoved = $false
$serviceStopped = $false
$createdService = $false
$committed = $false
$oldMetadata = $null
$oldShortcut = $null
function Assert-RegularDirectory([string]$Path) {
if (Test-Path -LiteralPath $Path) {
$item = Get-Item -LiteralPath $Path -Force
if (!$item.PSIsContainer -or ($item.Attributes -band [IO.FileAttributes]::ReparsePoint)) {
throw "The installation folder must be a regular directory: $Path"
}
}
}
function Set-DirectoryAcl([string]$Path, [string]$Descriptor) {
Assert-RegularDirectory $Path
if (!(Test-Path -LiteralPath $Path)) { New-Item -ItemType Directory -Path $Path | Out-Null }
$acl = Get-Acl -LiteralPath $Path
$acl.SetSecurityDescriptorSddlForm($Descriptor)
Set-Acl -LiteralPath $Path -AclObject $acl
}
function Wait-ForApplications {
$deadline = [DateTime]::UtcNow.AddSeconds(30)
do {
$running = @(Get-CimInstance Win32_Process -Filter "Name='gpgui.exe' OR Name='gpauth.exe'" |
Where-Object { $_.ExecutablePath -in @((Join-Path $destination 'gpgui.exe'), (Join-Path $destination 'gpauth.exe')) })
if (!$running.Count) { return }
if ([DateTime]::UtcNow -ge $deadline) {
throw 'Quit GP Connect and finish or cancel sign-in in all Windows sessions, then try again.'
}
Start-Sleep -Milliseconds 250
} while ($true)
}
function Wait-ServiceState([string]$Expected) {
$controller = Get-Service -Name $serviceName
try { $controller.WaitForStatus($Expected, [TimeSpan]::FromSeconds(30)) }
finally { $controller.Dispose() }
}
function Stop-InstalledService {
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue
if (!$service) { return }
try { $stopped = $service.Status -eq 'Stopped' } finally { $service.Dispose() }
if (!$stopped) { Stop-Service -Name $serviceName; Wait-ServiceState 'Stopped' }
}
function Start-InstalledService {
Start-Service -Name $serviceName
Wait-ServiceState 'Running'
}
function Move-InstalledDirectoryToBackup {
try { Move-Item -LiteralPath $destination -Destination $backup }
catch [IO.IOException] {
throw 'GP Connect files are in use. Close any GP Connect folders in File Explorer and try again.'
}
}
function Wait-ForRuntimeRelease {
$deadline = [DateTime]::UtcNow.AddSeconds(30)
do {
$locked = $false
foreach ($file in Get-ChildItem -LiteralPath $destination -File | Where-Object { $_.Extension -in @('.exe', '.dll') }) {
try {
$stream = [IO.File]::Open($file.FullName, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)
$stream.Dispose()
} catch [IO.IOException] { $locked = $true; break }
}
if (!$locked) { return }
if ([DateTime]::UtcNow -ge $deadline) { throw 'An application file is still in use. Close GP Connect in all Windows sessions and try again.' }
Start-Sleep -Milliseconds 250
} while ($true)
}
function Assert-NetworkClean {
$records = @()
if (Test-Path $recoveryKey) { $records = @((Get-Item $recoveryKey).GetValueNames() | Where-Object { $_ -like 'Route-*' }) }
$policies = @(Get-DnsClientNrptRule | Where-Object { $_.Comment -like 'GPConnect:*' })
if ($records.Count -or $policies.Count) {
throw 'VPN network cleanup is incomplete. Restart GP Connect before trying again.'
}
}
function Invoke-ServiceCommand([string[]]$Arguments) {
& "$env:SystemRoot\System32\sc.exe" @Arguments | Out-Null
if ($LASTEXITCODE -ne 0) { throw "Windows service configuration failed ($LASTEXITCODE)." }
}
function Set-MachineState {
Set-DirectoryAcl $state $publicAcl
Set-DirectoryAcl (Join-Path $state 'Private') $privateAcl
foreach ($name in @('gpservice.lock', 'gpservice.log')) {
$path = Join-Path $state $name
if (Test-Path -LiteralPath $path) {
if ((Get-Item -LiteralPath $path -Force).Attributes -band [IO.FileAttributes]::ReparsePoint) {
throw "Service state file must not be a link: $path"
}
$acl = Get-Acl -LiteralPath $path
$acl.SetSecurityDescriptorSddlForm($publicAcl)
Set-Acl -LiteralPath $path -AclObject $acl
}
}
$registry = [Microsoft.Win32.Registry]::LocalMachine.CreateSubKey('SOFTWARE\GP Connect')
try {
$recovery = $registry.CreateSubKey('NetworkRecovery', [Microsoft.Win32.RegistryKeyPermissionCheck]::ReadWriteSubTree, [Microsoft.Win32.RegistryOptions]::Volatile)
try {
foreach ($key in @($registry, $recovery)) {
$acl = New-Object System.Security.AccessControl.RegistrySecurity
$acl.SetSecurityDescriptorSddlForm('O:BAG:BAD:P(A;CI;KA;;;SY)(A;CI;KA;;;BA)')
$key.SetAccessControl($acl)
}
} finally { $recovery.Dispose() }
} finally { $registry.Dispose() }
}
function Set-InstallationMetadata([string]$InstalledVersion) {
$shell = New-Object -ComObject WScript.Shell
$shortcut = $shell.CreateShortcut($shortcutPath)
$shortcut.TargetPath = Join-Path $destination 'gpgui.exe'
$shortcut.WorkingDirectory = $destination
$shortcut.Description = 'GP Connect'
$shortcut.IconLocation = (Join-Path $destination 'gpgui.exe') + ',0'
$shortcut.Save()
if (Test-Path -LiteralPath (Join-Path $destination 'uninstall.exe')) {
New-Item -Path $uninstallKey -Force | Out-Null
$values = @{
DisplayName = 'GP Connect'; DisplayVersion = $InstalledVersion; Publisher = 'GP Connect'
InstallLocation = $destination; DisplayIcon = (Join-Path $destination 'gpgui.exe')
UninstallString = '"' + (Join-Path $destination 'uninstall.exe') + '"'
}
foreach ($entry in $values.GetEnumerator()) {
New-ItemProperty -Path $uninstallKey -Name $entry.Key -Value $entry.Value -PropertyType String -Force | Out-Null
}
foreach ($name in @('NoModify', 'NoRepair')) {
New-ItemProperty -Path $uninstallKey -Name $name -Value 1 -PropertyType DWord -Force | Out-Null
}
}
}
function Restore-InstallationMetadata {
if (Test-Path $uninstallKey) { Remove-Item $uninstallKey -Recurse -Force }
if ($oldMetadata) {
New-Item -Path $uninstallKey -Force | Out-Null
foreach ($entry in $oldMetadata.GetEnumerator()) {
New-ItemProperty -Path $uninstallKey -Name $entry.Key -Value $entry.Value.Value -PropertyType $entry.Value.Kind -Force | Out-Null
}
}
if ($oldShortcut) { [IO.File]::WriteAllBytes($shortcutPath, $oldShortcut) }
elseif (Test-Path -LiteralPath $shortcutPath) { Remove-Item -LiteralPath $shortcutPath -Force }
}
function Remove-OwnedCallback {
$callback = 'HKCU:\Software\Classes\globalprotectcallback'
$commandKey = "$callback\shell\open\command"
if (Test-Path $commandKey) {
$command = (Get-Item $commandKey).GetValue('')
$authBinary = Join-Path $destination 'gpauth.exe'
$owned = @("`"$authBinary`" auth-callback `"%1`"", "`"\\?\$authBinary`" auth-callback `"%1`"")
if ($command -in $owned) { Remove-Item $callback -Recurse -Force }
}
}
$mutex = New-Object System.Threading.Mutex($false, 'Global\GPConnect.Installer')
$owned = $false
$transcript = $false
try {
try { $owned = $mutex.WaitOne(0) } catch [Threading.AbandonedMutexException] { $owned = $true }
if (!$owned) { throw 'Another GP Connect installation is running. Wait for it to finish.' }
Assert-RegularDirectory $destination
Assert-RegularDirectory $state
if (Test-Path -LiteralPath $backup) {
throw "A previous installation needs repair. The retained files are in $backup. Do not delete them before restoring GP Connect."
}
# Keep only this attempt and one previous diagnostic log.
Set-DirectoryAcl $state $publicAcl
$log = Join-Path $state 'installer.log'
$previousLog = Join-Path $state 'installer.previous.log'
foreach ($path in @($log, $previousLog)) {
if ((Test-Path -LiteralPath $path) -and ((Get-Item -LiteralPath $path -Force).Attributes -band [IO.FileAttributes]::ReparsePoint)) {
throw 'Installer log must not be a link.'
}
}
if (Test-Path -LiteralPath $previousLog) { Remove-Item -LiteralPath $previousLog -Force }
if (Test-Path -LiteralPath $log) { Move-Item -LiteralPath $log -Destination $previousLog }
Start-Transcript -Path $log -Force | Out-Null
$transcript = $true
$existing = Get-CimInstance Win32_Service -Filter "Name='$serviceName'"
if ($existing -and $existing.PathName -ne ('"' + $serviceBinary + '"')) {
throw 'The GPConnect service is registered to another installation.'
}
$wasRunning = $existing -and $existing.State -ne 'Stopped'
if ($Action -eq 'Install') {
if (!$SourceDirectory) { throw 'An installation source is required.' }
$source = (Resolve-Path -LiteralPath $SourceDirectory).Path.TrimEnd('\')
if ($source -eq $destination -or $source.StartsWith($destination + '\', [StringComparison]::OrdinalIgnoreCase)) {
throw 'Install from an extracted package outside the application folder.'
}
foreach ($name in @('gpservice.exe', 'gpauth.exe', 'gpgui.exe', 'libopenconnect-5.dll', 'wintun.dll', 'build-info.json')) {
if (!(Test-Path -LiteralPath (Join-Path $source $name) -PathType Leaf)) { throw "Missing Windows package file: $name" }
}
$info = Get-Content -LiteralPath (Join-Path $source 'build-info.json') -Raw | ConvertFrom-Json
if ((Test-Path -LiteralPath (Join-Path $destination 'uninstall.exe')) -and
!(Test-Path -LiteralPath (Join-Path $source 'uninstall.exe'))) {
throw 'Use the Windows installer to update this installation.'
}
if (!$Version) { $Version = $info.version }
$architecture = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString().ToLowerInvariant()
if ($info.product -ne 'GP Connect' -or $info.architecture -notin @('x64','arm64') -or $info.architecture -ne $architecture -or !$Version -or $info.version -ne $Version) {
throw 'The package version or architecture does not match this installer.'
}
if (![Environment]::Is64BitProcess -or [Environment]::OSVersion.Version.Build -lt 19041) {
throw 'GP Connect requires Windows 10 build 19041 or newer.'
}
if ($architecture -eq 'arm64' -and [Environment]::OSVersion.Version.Build -lt 22000) {
throw 'GP Connect for ARM64 requires Windows 11.'
}
$payload = @(Get-ChildItem -LiteralPath $source -Force | Where-Object {
($_.PSIsContainer -and $_.Name -eq 'licenses') -or
(!$_.PSIsContainer -and ($_.Extension -eq '.dll' -or
$_.Name -in @('gpservice.exe', 'gpauth.exe', 'gpgui.exe', 'uninstall.exe', 'build-info.json')))
})
foreach ($item in $payload) {
$items = @($item)
if ($item.PSIsContainer) { $items += @(Get-ChildItem -LiteralPath $item.FullName -Force -Recurse) }
if ($items | Where-Object { $_.Attributes -band [IO.FileAttributes]::ReparsePoint }) { throw 'The package must not contain file links.' }
}
$requiredBytes = [long]0
foreach ($item in $payload) {
if ($item.PSIsContainer) { $requiredBytes += [long](Get-ChildItem -LiteralPath $item.FullName -File -Recurse | Measure-Object -Property Length -Sum).Sum }
else { $requiredBytes += $item.Length }
}
$volume = New-Object IO.DriveInfo([IO.Path]::GetPathRoot($destination))
$additionalBytes = $requiredBytes + 16MB
if ($ConsumeSource -and [IO.Path]::GetPathRoot($source) -eq $volume.Name) {
# The extracted files already occupy this volume; renaming them adds no copy.
$additionalBytes = 16MB
}
if ($volume.AvailableFreeSpace -lt $additionalBytes) { throw 'There is not enough free space to install GP Connect.' }
$stage = $destination + '.stage-' + [Guid]::NewGuid().ToString('N')
Set-DirectoryAcl $stage $publicAcl
foreach ($item in $payload) {
if (!$ConsumeSource) {
Copy-Item -LiteralPath $item.FullName -Destination $stage -Recurse -Force
continue
}
# NSIS's extracted payload is disposable. Move files individually so temp
# and Program Files may be on different volumes without keeping two bundles.
$files = @($item)
if ($item.PSIsContainer) { $files = @(Get-ChildItem -LiteralPath $item.FullName -File -Recurse) }
foreach ($file in $files) {
$relative = $file.Name
if ($item.PSIsContainer) {
# Enumerated paths share the same expanded spelling, including 8.3 temp paths.
$child = $file.FullName.Substring($item.FullName.Length).TrimStart('\')
$relative = Join-Path $item.Name $child
}
$target = Join-Path $stage $relative
$parent = Split-Path $target -Parent
if (!(Test-Path -LiteralPath $parent)) { New-Item -ItemType Directory -Path $parent -Force | Out-Null }
Move-Item -LiteralPath $file.FullName -Destination $target
}
}
# Copies inherit the staging directory's protected policy, even when source ACLs differ.
foreach ($item in Get-ChildItem -LiteralPath $stage -Force -Recurse) {
$acl = Get-Acl -LiteralPath $item.FullName
$acl.SetSecurityDescriptorSddlForm($publicAcl)
Set-Acl -LiteralPath $item.FullName -AclObject $acl
}
$signature = Get-AuthenticodeSignature (Join-Path $stage 'wintun.dll')
if ($signature.Status -ne 'Valid' -or $signature.SignerCertificate.Subject -notmatch 'WireGuard LLC') {
throw 'The package requires the vendor-signed Wintun driver DLL.'
}
if ((Test-Path -LiteralPath $destination) -and !$existing) { throw 'The service is not registered. Repair the existing installation before updating.' }
if ($existing -and !(Test-Path -LiteralPath $destination)) { throw 'The registered installation is missing. Restore its files before updating.' }
if (Test-Path $uninstallKey) {
$key = Get-Item $uninstallKey
$oldMetadata = @{}
foreach ($name in $key.GetValueNames()) { $oldMetadata[$name] = @{ Value = $key.GetValue($name); Kind = $key.GetValueKind($name).ToString() } }
}
if (Test-Path -LiteralPath $shortcutPath) { $oldShortcut = [IO.File]::ReadAllBytes($shortcutPath) }
Wait-ForApplications
if ($existing) {
$serviceStopped = $true
Stop-InstalledService
Assert-NetworkClean
Wait-ForRuntimeRelease
}
if (Test-Path -LiteralPath $destination) { Move-InstalledDirectoryToBackup; $oldMoved = $true }
Move-Item -LiteralPath $stage -Destination $destination
$stage = $null
$newMoved = $true
Set-MachineState
if (!$existing) {
New-Service -Name $serviceName -DisplayName 'GP Connect' -BinaryPathName ('"' + $serviceBinary + '"') -StartupType Automatic -Description 'Connects GP Connect to your GlobalProtect VPN network.' | Out-Null
$createdService = $true
} else { Set-Service -Name $serviceName -StartupType Automatic }
Invoke-ServiceCommand @('failure', $serviceName, 'reset=', '86400', 'actions=', 'restart/3000/restart/10000/none/0')
Set-InstallationMetadata $Version
Start-InstalledService
$committed = $true
if ($oldMoved) { Remove-Item -LiteralPath $backup -Recurse -Force; $oldMoved = $false }
Write-Host "Installed GP Connect $Version. Open it from the Start menu."
} else {
if (!$existing) {
if (Test-Path -LiteralPath $destination) { throw 'The service is not registered. Review the installation folder before removing it.' }
Write-Host 'GP Connect is not installed.'
return
}
Wait-ForApplications
$serviceStopped = $true
Stop-InstalledService
Assert-NetworkClean
Wait-ForRuntimeRelease
# Move first: a locked runtime aborts while its registration and files are intact.
Move-InstalledDirectoryToBackup
$oldMoved = $true
Invoke-ServiceCommand @('delete', $serviceName)
$committed = $true
Remove-Item -LiteralPath $backup -Recurse -Force
$oldMoved = $false
if (Test-Path -LiteralPath $shortcutPath) { Remove-Item -LiteralPath $shortcutPath -Force }
if (Test-Path $uninstallKey) { Remove-Item $uninstallKey -Recurse -Force }
if (Test-Path $recoveryKey) { Remove-Item $recoveryKey -Force }
Remove-OwnedCallback
Write-Host 'Removed GP Connect. User settings and service logs are kept.'
}
} catch {
$failure = $_
if (!$committed) {
try {
if ($newMoved) { Stop-InstalledService; Remove-Item -LiteralPath $destination -Recurse -Force }
if ($oldMoved) { Move-Item -LiteralPath $backup -Destination $destination; $oldMoved = $false }
if ($createdService) { Invoke-ServiceCommand @('delete', $serviceName) }
if ($newMoved) { Restore-InstallationMetadata }
if ($existing -and $serviceStopped -and $wasRunning) { Start-InstalledService }
} catch {
Write-Host "Could not restore GP Connect: $($_.Exception.Message)"
Write-Host "Keep any retained files in $backup and run the installer again after restoring the installation."
}
}
Write-Host "Installation failed: $($failure.Exception.Message)"
Write-Host "Details: $(Join-Path $state 'installer.log')"
throw $failure
} finally {
if ($stage -and (Test-Path -LiteralPath $stage)) {
try { Remove-Item -LiteralPath $stage -Recurse -Force } catch { Write-Warning "Could not remove temporary files: $stage" }
}
if ($transcript) { Stop-Transcript | Out-Null }
if ($owned) { $mutex.ReleaseMutex() }
$mutex.Dispose()
}
Binary file not shown.

Before

Width:  |  Height:  |  Size: 151 KiB

-70
View File
@@ -1,70 +0,0 @@
# Requires MSYS2 base-devel/autoconf/automake/libtool and the selected native gcc,
# pkgconf, gnutls, libxml2 and lz4 packages, plus Visual Studio C++ Build Tools.
[CmdletBinding()]
param(
[string]$MsysRoot = 'C:\msys64',
[ValidateSet('mingw64','ucrt64','clangarm64')][string]$MsysSubsystem = 'mingw64',
[string]$Prefix,
[int]$Jobs = 4
)
$ErrorActionPreference = 'Stop'
$repo = Split-Path $PSScriptRoot -Parent
if (!$Prefix) { $Prefix = Join-Path $repo 'target\native-windows' }
$Prefix = [System.IO.Path]::GetFullPath($Prefix)
$bash = Join-Path $MsysRoot 'usr\bin\bash.exe'
if (!(Test-Path $bash)) { throw 'MSYS2 is required to build OpenConnect.' }
$ErrorActionPreference = 'Continue'
& $bash "$PSScriptRoot/build-openconnect-windows.sh" $repo $Prefix $Jobs $MsysSubsystem
$nativeExit = $LASTEXITCODE
$ErrorActionPreference = 'Stop'
if ($nativeExit -ne 0) { throw 'OpenConnect compilation failed.' }
$architecture = 'x64'
if ($MsysSubsystem -eq 'clangarm64') { $architecture = 'arm64' }
$component = 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64'
if ($architecture -eq 'arm64') { $component = 'Microsoft.VisualStudio.Component.VC.Tools.ARM64' }
$hostTools = 'Hostx64'
if ($env:PROCESSOR_ARCHITECTURE -eq 'ARM64') { $hostTools = 'Hostarm64' }
$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
$vs = & $vswhere -latest -products '*' -requires $component -property installationPath
if (!$vs) { throw 'Visual Studio C++ Build Tools are required.' }
$tools = (Get-ChildItem "$vs\VC\Tools\MSVC\*\bin\$hostTools\$architecture\lib.exe" |
Sort-Object FullName | Select-Object -Last 1).DirectoryName
$dll = Join-Path $Prefix 'bin\libopenconnect-5.dll'
$exports = & "$tools\dumpbin.exe" /nologo /exports $dll
if ($LASTEXITCODE -ne 0) { throw 'Could not inspect OpenConnect exports.' }
$names = @($exports | ForEach-Object {
if ($_ -match '^\s+\d+\s+[0-9A-Fa-f]+\s+[0-9A-Fa-f]+\s+(\S+)') { $Matches[1] }
})
foreach ($symbol in @('openconnect_setup_cmd_pipe', 'openconnect_setup_tun_pipe', 'openconnect_set_configure_tun_handler', 'openconnect_set_tunnel_handler')) {
if ($names -notcontains $symbol) { throw "OpenConnect is missing $symbol." }
}
$definition = Join-Path $Prefix 'lib\openconnect.def'
[System.IO.File]::WriteAllLines($definition, @('LIBRARY libopenconnect-5.dll', 'EXPORTS') + $names)
& "$tools\lib.exe" /nologo "/machine:$architecture" "/def:$definition" "/out:$Prefix\lib\openconnect.lib"
if ($LASTEXITCODE -ne 0) { throw 'Could not generate the MSVC import library.' }
# Copy only the native DLL's transitive MinGW runtime dependencies.
$pending = [System.Collections.Generic.Queue[string]]::new()
$visited = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
$pending.Enqueue($dll)
while ($pending.Count) {
$current = $pending.Dequeue()
if (!$visited.Add([System.IO.Path]::GetFileName($current))) { continue }
$dependencies = & "$tools\dumpbin.exe" /nologo /dependents $current
if ($LASTEXITCODE -ne 0) { throw "Could not inspect dependencies of $current." }
foreach ($line in $dependencies) {
if ($line -notmatch '^\s+(\S+\.dll)\s*$') { continue }
$name = $Matches[1]
$source = Join-Path "$MsysRoot\$MsysSubsystem\bin" $name
if (Test-Path $source) {
$target = Join-Path "$Prefix\bin" $name
Copy-Item $source $target -Force
$pending.Enqueue($target)
} elseif (!(Test-Path "$env:SystemRoot\System32\$name") -and $name -notmatch '^(api|ext)-ms-win-') {
throw "Missing runtime dependency: $name"
}
}
}
Write-Host "OpenConnect native files: $Prefix"
Write-Host "Set OPENCONNECT_WINDOWS_PREFIX to this directory before building gpservice."
Loaded 100 of 109 files, more files were not shown because too many files have changed in this diff. Show more