Merge branch 'dev' into gpauth_windows

This commit is contained in:
Kevin Yue committed 2025-12-13 23:56:16 +08:00
commit 0669447aed
91 files changed
+5486 -3171

No files matched your search

+5 -4
View File
@@ -8,6 +8,7 @@ edition.workspace = true
license.workspace = true
[dependencies]
common = { path = "../common" }
gpapi = { path = "../gpapi" }
# Shared dependencies
@@ -32,10 +33,10 @@ html-escape = { version = "0.2.13", optional = true }
webkit2gtk = { version = "2", optional = true }
[target.'cfg(target_os="macos")'.dependencies]
block2 = { version = "0.5", optional = true }
objc2 = { version = "0.5", optional = true }
objc2-foundation = { version = "0.2", optional = true }
objc2-web-kit = { version = "0.2", optional = true }
block2 = { version = "0.6", optional = true }
objc2 = { version = "0.6", optional = true }
objc2-foundation = { version = "0.3", optional = true }
objc2-web-kit = { version = "0.3", optional = true }
[target.'cfg(target_os="windows")'.dependencies]
webview2-com = { version = "0.34", optional = true }
+2 -2
View File
@@ -10,8 +10,8 @@ pub(super) struct AuthServer {
}
impl AuthServer {
pub fn new() -> anyhow::Result<Self> {
let server = Server::http("127.0.0.1:0").map_err(|err| anyhow::anyhow!(err))?;
pub fn new(addr: &str) -> anyhow::Result<Self> {
let server = Server::http(addr).map_err(|err| anyhow::anyhow!(err))?;
let auth_id = Uuid::new_v4().to_string();
Ok(Self { server, auth_id })
+60 -3
View File
@@ -1,8 +1,12 @@
use std::{env::temp_dir, fs};
use gpapi::{auth::SamlAuthData, GP_CALLBACK_PORT_FILENAME};
use common::constants::GP_CALLBACK_PORT_FILENAME;
use gpapi::auth::SamlAuthData;
use log::info;
use tokio::{io::AsyncReadExt, net::TcpListener};
use tokio::{
io::AsyncReadExt,
net::{TcpListener, UdpSocket},
};
use crate::browser::auth_server::AuthServer;
@@ -10,6 +14,7 @@ pub enum Browser<'a> {
Default,
Chrome,
Firefox,
Remote,
Other(&'a str),
}
@@ -19,6 +24,7 @@ impl<'a> Browser<'a> {
"default" => Browser::Default,
"chrome" => Browser::Chrome,
"firefox" => Browser::Firefox,
"remote" => Browser::Remote,
_ => Browser::Other(browser),
}
}
@@ -28,6 +34,7 @@ impl<'a> Browser<'a> {
Browser::Default => "default",
Browser::Chrome => "chrome",
Browser::Firefox => "firefox",
Browser::Remote => "remote",
Browser::Other(browser) => browser,
}
}
@@ -47,7 +54,8 @@ impl<'a> BrowserAuthenticator<'a> {
}
pub async fn authenticate(&self) -> anyhow::Result<SamlAuthData> {
let auth_server = AuthServer::new()?;
let addr = self.determine_addr().await?;
let auth_server = AuthServer::new(&addr)?;
let auth_url = auth_server.auth_url();
let auth_request = self.auth_request.to_string();
@@ -56,6 +64,25 @@ impl<'a> BrowserAuthenticator<'a> {
});
match self.browser {
Browser::Remote => {
info!(
r#"
==== Manual Authentication Required ====
Please open the following URL in your browser:
{}
After completing the authentication, please paste the authentication data back to this terminal.
(The data should start with "globalprotectcallback:...")
Note that the URL is only valid for a single use.
"#,
auth_url
);
return read_auth_data_from_stdin();
}
Browser::Default => {
info!("Launching the default browser...");
webbrowser::open(&auth_url)?;
@@ -71,6 +98,28 @@ impl<'a> BrowserAuthenticator<'a> {
info!("Please continue the authentication process in the default browser");
wait_auth_data().await
}
async fn determine_addr(&self) -> anyhow::Result<String> {
if matches!(self.browser, Browser::Remote) {
let local_ip = detect_local_ip().await?;
Ok(format!("{}:0", local_ip))
} else {
Ok("127.0.0.1:0".to_string())
}
}
}
/// Detect the local IP address by creating a UDP socket and connecting to an external address
async fn detect_local_ip() -> anyhow::Result<String> {
let socket = UdpSocket::bind("0.0.0.0:0").await?;
if let Err(err) = socket.connect("1.1.1.1:80").await {
anyhow::bail!("Failed to connect to external address to determine local IP: {}", err);
}
let local_addr = socket.local_addr()?;
let ip = local_addr.ip().to_string();
info!("Determined local IP address: {}", ip);
Ok(ip.to_string())
}
fn find_browser_path(browser: &Browser) -> String {
@@ -123,3 +172,11 @@ async fn wait_auth_data() -> anyhow::Result<SamlAuthData> {
let auth_data = SamlAuthData::from_gpcallback(&data)?;
Ok(auth_data)
}
fn read_auth_data_from_stdin() -> anyhow::Result<SamlAuthData> {
let mut data = String::new();
std::io::stdin().read_line(&mut data)?;
let auth_data = SamlAuthData::from_gpcallback(data.trim())?;
Ok(auth_data)
}
+2 -1
View File
@@ -103,7 +103,8 @@ impl<'a> WebviewAuthenticator<'a> {
.title("GlobalProtect Login")
.inner_size(900.0, 650.0 + title_bar_height)
.focused(true)
.visible(false)
// when clean is true, the window is expected to be shown because the cookies are cleared
.visible(self.clean)
.center()
.build()?;
-3
View File
@@ -6,6 +6,3 @@ authors.workspace = true
homepage.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
is_executable.workspace = true
@@ -14,6 +14,9 @@ fn main() {
println!("cargo:rustc-env=GP_SERVICE_BINARY={}", gp_service_binary.display());
println!("cargo:rustc-env=GP_CLIENT_BINARY={}", gp_client_binary.display());
println!("cargo:rustc-env=GP_AUTH_BINARY={}", gp_auth_binary.display());
println!("cargo:rustc-env=GP_GUI_HELPER_BINARY={}", gp_gui_helper_binary.display());
println!(
"cargo:rustc-env=GP_GUI_HELPER_BINARY={}",
gp_gui_helper_binary.display()
);
println!("cargo:rustc-env=GP_GUI_BINARY={}", gp_gui_binary.display());
}
+40
View File
@@ -0,0 +1,40 @@
pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
pub const GP_CLIENT_VERSION: &str = "6.3.0-33";
pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
pub const GP_CALLBACK_PORT_FILENAME: &str = "gpcallback.port";
// Release binaries - macOS (Apple Silicon Homebrew)
#[cfg(all(not(debug_assertions), target_os = "macos"))]
pub const GP_CLIENT_BINARY: &str = "/opt/homebrew/bin/gpclient";
#[cfg(all(not(debug_assertions), target_os = "macos"))]
pub const GP_SERVICE_BINARY: &str = "/opt/homebrew/bin/gpservice";
#[cfg(all(not(debug_assertions), target_os = "macos"))]
pub const GP_GUI_BINARY: &str = "/opt/homebrew/bin/gpgui";
#[cfg(all(not(debug_assertions), target_os = "macos"))]
pub const GP_GUI_HELPER_BINARY: &str = "/opt/homebrew/bin/gpgui-helper";
#[cfg(all(not(debug_assertions), target_os = "macos"))]
pub const GP_AUTH_BINARY: &str = "/opt/homebrew/bin/gpauth";
// Release binaries - Linux
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
pub const GP_CLIENT_BINARY: &str = "/usr/bin/gpclient";
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
pub const GP_SERVICE_BINARY: &str = "/usr/bin/gpservice";
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
pub const GP_GUI_BINARY: &str = "/usr/bin/gpgui";
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
pub const GP_GUI_HELPER_BINARY: &str = "/usr/bin/gpgui-helper";
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
pub const GP_AUTH_BINARY: &str = "/usr/bin/gpauth";
// Debug binaries are set in build.rs via environment variables
#[cfg(debug_assertions)]
pub const GP_CLIENT_BINARY: &str = env!("GP_CLIENT_BINARY");
#[cfg(debug_assertions)]
pub const GP_SERVICE_BINARY: &str = env!("GP_SERVICE_BINARY");
#[cfg(debug_assertions)]
pub const GP_GUI_BINARY: &str = env!("GP_GUI_BINARY");
#[cfg(debug_assertions)]
pub const GP_GUI_HELPER_BINARY: &str = env!("GP_GUI_HELPER_BINARY");
#[cfg(debug_assertions)]
pub const GP_AUTH_BINARY: &str = env!("GP_AUTH_BINARY");
+1 -1
View File
@@ -1 +1 @@
pub mod vpn_utils;
pub mod constants;
+14 -1
View File
@@ -6,6 +6,7 @@ edition.workspace = true
license = "MIT"
[dependencies]
common = { path = "../common" }
anyhow.workspace = true
base64.workspace = true
dns-lookup.workspace = true
@@ -14,7 +15,7 @@ reqwest.workspace = true
openssl.workspace = true
version-compare = "0.2"
pem.workspace = true
roxmltree.workspace = true
xmltree.workspace = true
serde.workspace = true
specta = { workspace = true, features = ["derive"] }
urlencoding.workspace = true
@@ -31,7 +32,10 @@ regex.workspace = true
serde_urlencoded.workspace = true
md5.workspace = true
sha256.workspace = true
machine-uid.workspace = true
uuid = { workspace = true, features = ["v5"] }
# Optional dependencies for features
tauri = { workspace = true, optional = true }
clap = { workspace = true, optional = true }
clap-verbosity-flag = { workspace = true, optional = true }
@@ -39,6 +43,15 @@ clap-verbosity-flag = { workspace = true, optional = true }
env_logger = { workspace = true, optional = true }
log-reload = { version = "0.1", optional = true }
# Dependencies for macOS and Windows only
[target.'cfg(any(target_os="macos", target_os="windows"))'.dependencies]
os_info = { version = "3", default-features = false }
# Dependencies for Linux and other OSes only
[target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies]
gtk = "0.18"
# Dependencies for Unix-like systems only
[target.'cfg(target_family="unix")'.dependencies]
uzers.workspace = true
+12 -13
View File
@@ -2,9 +2,13 @@ use std::collections::HashMap;
use log::{info, warn};
use reqwest::Client;
use roxmltree::Document;
use xmltree::Element;
use crate::{gp_params::GpParams, process::hip_launcher::HipLauncher, utils::normalize_server};
use crate::{
gp_params::GpParams,
process::hip_launcher::HipLauncher,
utils::{normalize_server, xml::ElementExt},
};
struct HipReporter<'a> {
server: String,
@@ -65,13 +69,11 @@ impl HipReporter<'_> {
let res = self.client.post(&config_url).form(&params).send().await?;
let res_xml = res.error_for_status()?.text().await?;
let doc = Document::parse(&res_xml)?;
let root = Element::parse(res_xml.as_bytes())?;
// Get <ip-address>
let ip = doc
.descendants()
.find(|n| n.has_tag_name("ip-address"))
.and_then(|n| n.text())
let ip = root
.descendant_text("ip-address")
.ok_or_else(|| anyhow::anyhow!("ip-address not found"))?;
Ok(ip.to_string())
@@ -122,12 +124,9 @@ impl HipReporter<'_> {
}
fn is_hip_needed(res_xml: &str) -> anyhow::Result<bool> {
let doc = Document::parse(res_xml)?;
let hip_needed = doc
.descendants()
.find(|n| n.has_tag_name("hip-report-needed"))
.and_then(|n| n.text())
let root = Element::parse(res_xml.as_bytes())?;
let hip_needed = root
.descendant_text("hip-report-needed")
.ok_or_else(|| anyhow::anyhow!("hip-report-needed not found"))?;
Ok(hip_needed == "yes")
+15 -11
View File
@@ -1,14 +1,16 @@
use std::borrow::Cow;
use anyhow::bail;
use log::{info, warn};
use log::{debug, info, warn};
use reqwest::Client;
use roxmltree::Document;
use urlencoding::encode;
use xmltree::Element;
use crate::{
credential::Credential,
error::PortalError,
gp_params::GpParams,
utils::{normalize_server, parse_gp_response, remove_url_scheme},
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt},
};
pub enum GatewayLogin {
@@ -50,18 +52,20 @@ pub async fn gateway_login(gateway: &str, cred: &Credential, gp_params: &GpParam
return Ok(GatewayLogin::Mfa(message, input_str));
}
let doc = Document::parse(&res)?;
debug!("Gateway login response: {}", res);
let cookie = build_gateway_token(&doc, gp_params.computer())?;
let root = Element::parse(res.as_bytes())?;
let cookie = build_gateway_token(&root, gp_params.computer())?;
Ok(GatewayLogin::Cookie(cookie))
}
fn build_gateway_token(doc: &Document, computer: &str) -> anyhow::Result<String> {
let args = doc
.descendants()
.filter(|n| n.has_tag_name("argument"))
.map(|n| n.text().unwrap_or("").to_string())
fn build_gateway_token(element: &Element, computer: &str) -> anyhow::Result<String> {
let args = element
.descendants("argument")
.iter()
.map(|e| e.get_text().unwrap_or_default())
.collect::<Vec<_>>();
let params = [
@@ -82,7 +86,7 @@ fn build_gateway_token(doc: &Document, computer: &str) -> anyhow::Result<String>
Ok(token)
}
fn read_args<'a>(args: &'a [String], index: usize, key: &'a str) -> anyhow::Result<(&'a str, &'a str)> {
fn read_args<'a>(args: &'a [Cow<'_, str>], index: usize, key: &'a str) -> anyhow::Result<(&'a str, &'a str)> {
args
.get(index)
.ok_or_else(|| anyhow::anyhow!("Failed to read {key} from args"))
+36 -36
View File
@@ -1,64 +1,64 @@
use log::info;
use roxmltree::Node;
use xmltree::Element;
use crate::utils::xml::NodeExt;
use crate::utils::xml::ElementExt;
use super::{Gateway, PriorityRule};
pub(crate) fn parse_gateways(node: &Node, prefer_internal: bool) -> Option<Vec<Gateway>> {
let node_gateways = node.find_descendant("gateways")?;
pub(crate) fn parse_gateways(element: &Element, prefer_internal: bool) -> Option<Vec<Gateway>> {
let node_gateways = element.descendant("gateways")?;
let internal_gateway_list = if prefer_internal {
info!("Try to parse the internal gateways...");
node_gateways.find_descendant("internal").and_then(|n| n.find_child("list"))
node_gateways.descendant("internal").and_then(|n| n.child("list"))
} else {
None
};
let gateway_list = internal_gateway_list.or_else(|| {
info!("Try to parse the external gateways...");
node_gateways.find_descendant("external").and_then(|n| n.find_child("list"))
node_gateways.descendant("external").and_then(|n| n.child("list"))
})?;
let gateways = gateway_list
.children()
.filter_map(|gateway_item| {
if !gateway_item.has_tag_name("entry") {
return None;
}
let address = gateway_item.attribute("name").unwrap_or_default().to_string();
let name = gateway_item.child_text("description").unwrap_or_default().to_string();
let priority = gateway_item
.child_text("priority")
.and_then(|s| s.parse().ok())
.unwrap_or(u32::MAX);
.children("entry")
.iter()
.map(|gateway_item| {
let address = gateway_item.attr("name").map(|s| s.to_string()).unwrap_or_default();
let name = gateway_item.child_text("description").unwrap_or_default();
let priority = parse_priority(gateway_item);
let priority_rules = gateway_item
.find_child("priority-rule")
.map(|n| {
n.children()
.filter_map(|n| {
if !n.has_tag_name("entry") {
return None;
}
let name = n.attribute("name").unwrap_or_default().to_string();
let priority: u32 = n
.child_text("priority")
.and_then(|s| s.parse().ok())
.unwrap_or(u32::MAX);
Some(PriorityRule { name, priority })
})
.collect()
})
.child("priority-rule")
.map(|n| parse_priority_rules(n))
.unwrap_or_default();
Some(Gateway {
Gateway {
name,
address,
priority,
priority_rules,
})
}
})
.collect();
Some(gateways)
}
fn parse_priority_rules(element: &Element) -> Vec<PriorityRule> {
element
.children("entry")
.iter()
.map(|n| {
let name = n.attr("name").map(|s| s.to_string()).unwrap_or_default();
let priority: u32 = parse_priority(n);
PriorityRule { name, priority }
})
.collect()
}
fn parse_priority(element: &Element) -> u32 {
element
.child_text("priority")
.and_then(|s| s.parse().ok())
.unwrap_or(u32::MAX)
}
+2 -1
View File
@@ -1,11 +1,12 @@
use std::collections::HashMap;
use common::constants::GP_USER_AGENT;
use log::info;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use specta::Type;
use crate::{utils::request::create_identity, GP_USER_AGENT};
use crate::utils::request::create_identity;
#[derive(Debug, Serialize, Deserialize, Clone, Type, Default)]
pub enum ClientOs {
-26
View File
@@ -19,29 +19,3 @@ pub mod clap;
#[cfg(debug_assertions)]
pub const GP_API_KEY: &[u8; 32] = &[0; 32];
pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
pub const GP_CALLBACK_PORT_FILENAME: &str = "gpcallback.port";
#[cfg(not(debug_assertions))]
pub const GP_CLIENT_BINARY: &str = "/usr/bin/gpclient";
#[cfg(not(debug_assertions))]
pub const GP_SERVICE_BINARY: &str = "/usr/bin/gpservice";
#[cfg(not(debug_assertions))]
pub const GP_GUI_BINARY: &str = "/usr/bin/gpgui";
#[cfg(not(debug_assertions))]
pub const GP_GUI_HELPER_BINARY: &str = "/usr/bin/gpgui-helper";
#[cfg(not(debug_assertions))]
pub(crate) const GP_AUTH_BINARY: &str = "/usr/bin/gpauth";
#[cfg(debug_assertions)]
pub const GP_CLIENT_BINARY: &str = env!("GP_CLIENT_BINARY");
#[cfg(debug_assertions)]
pub const GP_SERVICE_BINARY: &str = env!("GP_SERVICE_BINARY");
#[cfg(debug_assertions)]
pub const GP_GUI_BINARY: &str = env!("GP_GUI_BINARY");
#[cfg(debug_assertions)]
pub const GP_GUI_HELPER_BINARY: &str = env!("GP_GUI_HELPER_BINARY");
#[cfg(debug_assertions)]
pub(crate) const GP_AUTH_BINARY: &str = env!("GP_AUTH_BINARY");
+23 -11
View File
@@ -1,17 +1,17 @@
use anyhow::bail;
use dns_lookup::lookup_addr;
use log::{info, warn};
use log::{debug, info, warn};
use reqwest::{Client, StatusCode};
use roxmltree::{Document, Node};
use serde::Serialize;
use specta::Type;
use xmltree::Element;
use crate::{
credential::{AuthCookieCredential, Credential},
error::PortalError,
gateway::{parse_gateways, Gateway},
gateway::{Gateway, parse_gateways},
gp_params::GpParams,
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::NodeExt},
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt},
};
#[derive(Debug, Serialize, Type)]
@@ -29,6 +29,10 @@ pub struct PortalConfig {
* - Some(true): Internal host detection is supported and the user is connected to the internal network
*/
internal_host_detection: Option<bool>,
/**
* The version returned by the portal config, if any
*/
version: Option<String>,
}
impl PortalConfig {
@@ -52,6 +56,10 @@ impl PortalConfig {
self.internal_host_detection
}
pub fn version(&self) -> Option<&str> {
self.version.as_deref()
}
/// In-place sort the gateways by region
pub fn sort_gateways(&mut self, region: &str) {
let preferred_gateway = self.find_preferred_gateway(region);
@@ -133,12 +141,12 @@ pub async fn retrieve_config(portal: &str, cred: &Credential, gp_params: &GpPara
bail!(PortalError::ConfigError("Empty portal config response".to_string()))
}
let doc = Document::parse(&res_xml).map_err(|e| PortalError::ConfigError(e.to_string()))?;
let root = doc.root();
debug!("Portal config response: {}", res_xml);
let root = Element::parse(res_xml.as_bytes()).map_err(|e| PortalError::ConfigError(e.to_string()))?;
let mut ihd_enabled = false;
let mut prefer_internal = false;
if let Some(ihd_node) = root.find_descendant("internal-host-detection") {
if let Some(ihd_node) = root.descendant("internal-host-detection") {
ihd_enabled = true;
prefer_internal = internal_host_detect(&ihd_node)
}
@@ -158,21 +166,25 @@ pub async fn retrieve_config(portal: &str, cred: &Credential, gp_params: &GpPara
gateways.push(Gateway::new(server.to_string(), server.to_string()));
}
let version = root.descendant_text("version").map(|s| s.to_string());
info!("Detected portal version: {:?}", version);
Ok(PortalConfig {
portal: server.to_string(),
auth_cookie: AuthCookieCredential::new(cred.username(), user_auth_cookie, prelogon_user_auth_cookie),
auth_cookie: AuthCookieCredential::new(cred.username(), &user_auth_cookie, &prelogon_user_auth_cookie),
config_cred: cred.clone(),
gateways,
config_digest: config_digest.map(|s| s.to_string()),
internal_host_detection: if ihd_enabled { Some(prefer_internal) } else { None },
version,
})
}
// Perform DNS lookup and compare the result with the expected hostname
fn internal_host_detect(node: &Node) -> bool {
fn internal_host_detect(element: &Element) -> bool {
let ip_info = [
(node.child_text("ip-address"), node.child_text("host")),
(node.child_text("ipv6-address"), node.child_text("ipv6-host")),
(element.child_text("ip-address"), element.child_text("host")),
(element.child_text("ipv6-address"), element.child_text("ipv6-host")),
];
info!("Found internal-host-detection, performing DNS lookup");
+20 -29
View File
@@ -1,14 +1,14 @@
use anyhow::{anyhow, bail};
use log::{info, warn};
use reqwest::{Client, StatusCode};
use roxmltree::Document;
use serde::Serialize;
use specta::Type;
use xmltree::Element;
use crate::{
error::PortalError,
gp_params::GpParams,
utils::{base64, normalize_server, parse_gp_response, xml::NodeExt},
utils::{base64, normalize_server, parse_gp_response, xml::ElementExt},
};
const REQUIRED_PARAMS: [&str; 8] = [
@@ -143,32 +143,30 @@ pub async fn prelogin(portal: &str, gp_params: &GpParams) -> anyhow::Result<Prel
}
fn parse_res_xml(res_xml: &str, is_gateway: bool) -> anyhow::Result<Prelogin> {
let doc = Document::parse(res_xml)?;
let root = doc.root();
let root = Element::parse(res_xml.as_bytes())?;
let status = root
.descendant_text("status")
.ok_or_else(|| anyhow::anyhow!("Prelogin response does not contain status element"))?;
// Check the status of the prelogin response
if status.to_uppercase() != "SUCCESS" {
let msg = root.descendant_text("msg").unwrap_or("Unknown error");
let msg = root
.descendant_text("msg")
.unwrap_or_else(|| String::from("Unknown error"));
bail!("{}", msg)
}
let region = root
.descendant_text("region")
.unwrap_or_else(|| {
info!("Prelogin response does not contain region element");
"Unknown"
})
.to_string();
let region = root.descendant_text("region").unwrap_or_else(|| {
info!("Prelogin response does not contain region element");
String::from("Unknown")
});
let saml_method = root.descendant_text("saml-auth-method");
let saml_request = root.descendant_text("saml-request");
let saml_default_browser = root.descendant_text("saml-default-browser");
// Check if the prelogin response is SAML
if saml_method.is_some() && saml_request.is_some() {
let saml_request = base64::decode_to_string(saml_request.unwrap())?;
let saml_request = base64::decode_to_string(&saml_request.unwrap())?;
let support_default_browser = saml_default_browser.map(|s| s.to_lowercase() == "yes").unwrap_or(false);
let saml_prelogin = SamlPrelogin {
@@ -181,25 +179,18 @@ fn parse_res_xml(res_xml: &str, is_gateway: bool) -> anyhow::Result<Prelogin> {
return Ok(Prelogin::Saml(saml_prelogin));
}
let label_username = root
.descendant_text("username-label")
.unwrap_or_else(|| {
info!("Username label has no value, using default");
"Username"
})
.to_string();
let label_password = root
.descendant_text("password-label")
.unwrap_or_else(|| {
info!("Password label has no value, using default");
"Password"
})
.to_string();
let label_username = root.descendant_text("username-label").unwrap_or_else(|| {
info!("Username label has no value, using default");
String::from("Username")
});
let label_password = root.descendant_text("password-label").unwrap_or_else(|| {
info!("Password label has no value, using default");
String::from("Password")
});
let auth_message = root
.descendant_text("authentication-message")
.unwrap_or("Please enter the login credentials")
.to_string();
.unwrap_or_else(|| String::from("Please enter the login credentials"));
let standard_prelogin = StandardPrelogin {
region,
is_gateway,
+11 -2
View File
@@ -1,14 +1,16 @@
use std::process::Stdio;
use anyhow::bail;
use common::constants::GP_AUTH_BINARY;
use tokio::process::Command;
use crate::{auth::SamlAuthResult, credential::Credential, GP_AUTH_BINARY};
use crate::{auth::SamlAuthResult, credential::Credential};
use super::command_traits::CommandExt;
pub struct SamlAuthLauncher<'a> {
server: &'a str,
auth_executable: Option<&'a str>,
gateway: bool,
saml_request: Option<&'a str>,
user_agent: Option<&'a str>,
@@ -30,6 +32,7 @@ impl<'a> SamlAuthLauncher<'a> {
pub fn new(server: &'a str) -> Self {
Self {
server,
auth_executable: None,
gateway: false,
saml_request: None,
user_agent: None,
@@ -48,6 +51,11 @@ impl<'a> SamlAuthLauncher<'a> {
}
}
pub fn auth_executable(mut self, auth_executable: Option<&'a str>) -> Self {
self.auth_executable = auth_executable;
self
}
pub fn gateway(mut self, gateway: bool) -> Self {
self.gateway = gateway;
self
@@ -113,7 +121,8 @@ impl<'a> SamlAuthLauncher<'a> {
/// Launch the authenticator binary as the current user or SUDO_USER if available.
pub async fn launch(self) -> anyhow::Result<Credential> {
let mut auth_cmd = Command::new(GP_AUTH_BINARY);
let program = self.auth_executable.unwrap_or(GP_AUTH_BINARY);
let mut auth_cmd = Command::new(program);
auth_cmd.arg(self.server);
if self.gateway {
+12 -4
View File
@@ -11,10 +11,18 @@ pub trait CommandExt {
impl CommandExt for Command {
fn new_pkexec<S: AsRef<OsStr>>(program: S) -> Command {
let mut cmd = Command::new("pkexec");
cmd.arg("--user").arg("root").arg(program);
cmd
#[cfg(target_os = "macos")]
{
let mut cmd = Command::new("sudo");
cmd.arg(program);
cmd
}
#[cfg(not(target_os = "macos"))]
{
let mut cmd = Command::new("pkexec");
cmd.arg("--user").arg("root").arg(program);
cmd
}
}
fn into_non_root(mut self) -> anyhow::Result<Command> {
@@ -1,10 +1,11 @@
use std::{collections::HashMap, path::PathBuf, process::Stdio};
use anyhow::bail;
use common::constants::GP_GUI_HELPER_BINARY;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::{process::command_traits::CommandExt, utils, GP_GUI_HELPER_BINARY};
use crate::{process::command_traits::CommandExt, utils};
pub struct GuiHelperLauncher<'a> {
program: PathBuf,
+2 -1
View File
@@ -5,10 +5,11 @@ use std::{
};
use anyhow::bail;
use common::constants::GP_GUI_BINARY;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64, GP_GUI_BINARY};
use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64};
use super::command_traits::CommandExt;
+3 -4
View File
@@ -4,10 +4,9 @@ use std::{
process::{ExitStatus, Stdio},
};
use common::constants::GP_SERVICE_BINARY;
use tokio::process::Command;
use crate::GP_SERVICE_BINARY;
use super::command_traits::CommandExt;
pub struct ServiceLauncher<'a> {
@@ -15,7 +14,7 @@ pub struct ServiceLauncher<'a> {
minimized: bool,
env_file: Option<String>,
log_file: Option<String>,
verbose: Option<&'a str>
verbose: Option<&'a str>,
}
impl Default for ServiceLauncher<'_> {
@@ -31,7 +30,7 @@ impl<'a> ServiceLauncher<'a> {
minimized: false,
env_file: None,
log_file: None,
verbose: None
verbose: None,
}
}
+2 -1
View File
@@ -1,10 +1,11 @@
use serde::{Deserialize, Serialize};
use super::vpn_state::VpnState;
use crate::service::{vpn_env::VpnEnv, vpn_state::VpnState};
/// Events that can be emitted by the service
#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum WsEvent {
VpnEnv(VpnEnv),
VpnState(VpnState),
ActiveGui,
ResumeConnection,
+1
View File
@@ -1,3 +1,4 @@
pub mod event;
pub mod request;
pub mod vpn_env;
pub mod vpn_state;
+26
View File
@@ -31,13 +31,19 @@ impl LaunchGuiRequest {
pub struct ConnectArgs {
cookie: String,
vpnc_script: Option<String>,
user_agent: Option<String>,
os: Option<ClientOs>,
client_version: Option<String>,
certificate: Option<String>,
sslkey: Option<String>,
key_password: Option<String>,
hip: bool,
csd_uid: u32,
csd_wrapper: Option<String>,
reconnect_timeout: u32,
mtu: u32,
disable_ipv6: bool,
@@ -51,9 +57,11 @@ impl ConnectArgs {
vpnc_script: None,
user_agent: None,
os: None,
client_version: None,
certificate: None,
sslkey: None,
key_password: None,
hip: false,
csd_uid: 0,
csd_wrapper: None,
reconnect_timeout: 300,
@@ -79,6 +87,10 @@ impl ConnectArgs {
self.os.as_ref().map(|os| os.to_openconnect_os().to_string())
}
pub fn client_version(&self) -> Option<String> {
self.client_version.clone()
}
pub fn certificate(&self) -> Option<String> {
self.certificate.clone()
}
@@ -91,6 +103,10 @@ impl ConnectArgs {
self.key_password.clone()
}
pub fn hip(&self) -> bool {
self.hip
}
pub fn csd_uid(&self) -> u32 {
self.csd_uid
}
@@ -135,6 +151,11 @@ impl ConnectRequest {
self
}
pub fn with_hip(mut self, hip: bool) -> Self {
self.args.hip = hip;
self
}
pub fn with_csd_uid(mut self, csd_uid: u32) -> Self {
self.args.csd_uid = csd_uid;
self
@@ -155,6 +176,11 @@ impl ConnectRequest {
self
}
pub fn with_client_version(mut self, client_version: &str) -> Self {
self.args.client_version = Some(client_version.to_string());
self
}
pub fn with_certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
self.args.certificate = certificate.into();
self
+22
View File
@@ -0,0 +1,22 @@
use serde::{Deserialize, Serialize};
use crate::service::vpn_state::VpnState;
/// Represents the VPN environment configuration.
/// When a client connects, the gpservice sends the current VPN environment
/// to the client so that it can configure itself accordingly.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct VpnEnv {
/// The VPN connection state
pub vpn_state: VpnState,
/// The default VPN script path
pub vpnc_script: Option<String>,
/// The default CSD wrapper script path
pub csd_wrapper: Option<String>,
/// The gpauth executable path
/// Used by the client to launch gpauth for authentication
pub auth_executable: String,
}
+3 -3
View File
@@ -1,6 +1,6 @@
use chacha20poly1305::{
aead::{Aead, OsRng},
AeadCore, ChaCha20Poly1305, Key, KeyInit, Nonce,
AeadCore, ChaCha20Poly1305, Key, KeyInit,
};
use serde::{de::DeserializeOwned, Serialize};
@@ -31,10 +31,10 @@ where
{
let cipher = ChaCha20Poly1305::new(key);
let nonce = Nonce::from_slice(&encrypted[..12]);
let nonce = &encrypted[..12];
let cipher_text = &encrypted[12..];
let plaintext = cipher.decrypt(nonce, cipher_text)?;
let plaintext = cipher.decrypt(nonce.into(), cipher_text)?;
let value = serde_json::from_slice(&plaintext)?;
+5 -9
View File
@@ -39,17 +39,13 @@ pub fn load_env_vars<T: AsRef<Path>>(env_file: T) -> anyhow::Result<HashMap<Stri
pub fn patch_gui_runtime_env(hidpi: bool) {
// This is to avoid blank screen on some systems
std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
// Workaround for https://github.com/tauri-apps/tao/issues/929
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
if is_wayland {
env::set_var("GDK_BACKEND", "x11");
}
unsafe { std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1") };
if hidpi {
info!("Setting GDK_SCALE=2 and GDK_DPI_SCALE=0.5");
std::env::set_var("GDK_SCALE", "2");
std::env::set_var("GDK_DPI_SCALE", "0.5");
unsafe {
std::env::set_var("GDK_SCALE", "2");
std::env::set_var("GDK_DPI_SCALE", "0.5");
};
}
}
+108
View File
@@ -0,0 +1,108 @@
use std::sync::OnceLock;
const DEFAULT_MACOS_VERSION: &str = "13.4.0";
#[cfg(not(target_os = "linux"))]
const DEFAULT_LINUX_DISTRO: &str = "Ubuntu 24.04.3 LTS";
#[cfg(not(target_os = "windows"))]
const DEFAULT_WINDOWS_DISTRO: &str = "Windows 11 Pro";
const DEFAULT_WINDOWS_VERSION: &str = "10.0.22631.0";
const DEFAULT_MACHINE_ID: &str = "DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF";
static MACHINE_ID: OnceLock<&'static str> = OnceLock::new();
static MACOS_VERSION: OnceLock<&'static str> = OnceLock::new();
static MACOS_OS_STRING: OnceLock<String> = OnceLock::new();
static LINUX_OS_STRING: OnceLock<String> = OnceLock::new();
static WINDOWS_VERSION: OnceLock<&'static str> = OnceLock::new();
static WINDOWS_OS_STRING: OnceLock<String> = OnceLock::new();
/// On macOS, get the OS version, or fallback to default
/// On other OSes, always return default
pub fn get_macos_version() -> &'static str {
MACOS_VERSION.get_or_init(|| {
#[cfg(target_os = "macos")]
{
match os_info::get().version() {
os_info::Version::Unknown => DEFAULT_MACOS_VERSION,
v => v.to_string().leak(),
}
}
#[cfg(not(target_os = "macos"))]
DEFAULT_MACOS_VERSION
})
}
pub fn get_macos_os_string() -> &'static str {
MACOS_OS_STRING.get_or_init(|| format!("Apple Mac OS X {}", get_macos_version()))
}
/// On Linux, use the real distro name if possible
/// On other OSes, fallback to default
pub fn get_linux_os_string() -> &'static str {
LINUX_OS_STRING.get_or_init(|| {
#[cfg(target_os = "linux")]
{
format!("Linux {}", whoami::distro())
}
#[cfg(not(target_os = "linux"))]
{
format!("Linux {}", DEFAULT_LINUX_DISTRO)
}
})
}
/// On Windows, get the OS version, or fallback to default
/// On other OSes, always return default
pub fn get_windows_version() -> &'static str {
WINDOWS_VERSION.get_or_init(|| {
#[cfg(target_os = "windows")]
{
match os_info::get().version() {
os_info::Version::Unknown => DEFAULT_WINDOWS_VERSION,
v => format!("{}.0", v).leak(),
}
}
#[cfg(not(target_os = "windows"))]
DEFAULT_WINDOWS_VERSION
})
}
/// On Windows, use the real edition if possible
/// On other OSes, fallback to default
/// The trailing space is intentional
pub fn get_windows_os_string() -> &'static str {
WINDOWS_OS_STRING.get_or_init(|| {
#[cfg(target_os = "windows")]
{
let edition = os_info::get()
.edition()
.map(|e| e.to_string())
.unwrap_or_else(|| whoami::distro());
format!("Microsoft {} , 64-bit", edition)
}
#[cfg(not(target_os = "windows"))]
{
format!("Microsoft {} , 64-bit", DEFAULT_WINDOWS_DISTRO)
}
})
}
/// Get machine ID or fallback to default
pub fn get_machine_id() -> &'static str {
MACHINE_ID.get_or_init(|| {
machine_uid::get()
.map(|id| id.to_string().leak() as &'static str)
.unwrap_or(DEFAULT_MACHINE_ID)
})
}
/// Generate a UUID v5 based on machine ID and provided seeds
pub fn derive_uuid(seeds: &[&str]) -> String {
use uuid::Uuid;
let namespace = Uuid::NAMESPACE_DNS;
let name = format!("{}-{}", get_machine_id(), seeds.join("-"));
let uuid = Uuid::new_v5(&namespace, name.as_bytes());
uuid.hyphenated().to_string()
}
+2 -1
View File
@@ -1,5 +1,6 @@
use std::path::PathBuf;
use common::constants::GP_SERVICE_LOCK_FILE;
use thiserror::Error;
use tokio::fs;
@@ -94,7 +95,7 @@ impl LockInfo {
}
pub async fn gpservice_lock_info() -> Result<LockInfo, LockFileError> {
LockInfo::from_file(crate::GP_SERVICE_LOCK_FILE).await
LockInfo::from_file(GP_SERVICE_LOCK_FILE).await
}
#[cfg(test)]
+1
View File
@@ -5,6 +5,7 @@ pub mod checksum;
pub mod crypto;
pub mod endpoint;
pub mod env_utils;
pub mod host_utils;
pub mod lock_file;
pub mod openssl;
pub mod redact;
+1 -1
View File
@@ -46,7 +46,7 @@ pub fn fix_openssl_env() -> anyhow::Result<NamedTempFile> {
let openssl_conf_path = openssl_conf.path();
fix_openssl(openssl_conf_path)?;
std::env::set_var("OPENSSL_CONF", openssl_conf_path);
unsafe { std::env::set_var("OPENSSL_CONF", openssl_conf_path) };
Ok(openssl_conf)
}
+77 -53
View File
@@ -1,73 +1,97 @@
use std::{process::ExitStatus, time::Duration};
use anyhow::bail;
use log::info;
use tauri::WebviewWindow;
use tokio::process::Command;
pub trait WindowExt {
fn raise(&self) -> anyhow::Result<()>;
}
impl WindowExt for WebviewWindow {
#[cfg(any(target_os = "macos", target_os = "windows"))]
fn raise(&self) -> anyhow::Result<()> {
raise_window(self)
self.show()?;
Ok(())
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
fn raise(&self) -> anyhow::Result<()> {
unix::raise_window(self)
}
}
pub fn raise_window(win: &WebviewWindow) -> anyhow::Result<()> {
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
mod unix {
use std::{process::ExitStatus, time::Duration};
if is_wayland {
win.hide()?;
win.show()?;
} else {
if !win.is_visible()? {
win.show()?;
}
let title = win.title()?;
tokio::spawn(async move {
if let Err(err) = wmctrl_raise_window(&title).await {
info!("Window not raised: {}", err);
use anyhow::bail;
use gtk::{
glib::Cast,
traits::{EventBoxExt, GtkWindowExt, WidgetExt},
EventBox,
};
use log::info;
use tauri::WebviewWindow;
use tokio::process::Command;
pub fn raise_window(win: &WebviewWindow) -> anyhow::Result<()> {
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
if is_wayland {
let gtk_win = win.gtk_window()?;
if let Some(header) = gtk_win.titlebar() {
let _ = header.downcast::<EventBox>().map(|event_box| {
event_box.set_above_child(false);
});
}
});
}
// Calling window.show() on Windows will cause the menu to be shown.
// We need to hide it again.
win.hide_menu()?;
Ok(())
}
async fn wmctrl_raise_window(title: &str) -> anyhow::Result<()> {
let mut counter = 0;
loop {
if let Ok(exit_status) = wmctrl_try_raise_window(title).await {
if exit_status.success() {
info!("Window raised after {} attempts", counter + 1);
return Ok(());
gtk_win.hide();
gtk_win.show_all();
} else {
if !win.is_visible()? {
win.show()?;
}
let title = win.title()?;
tokio::spawn(async move {
if let Err(err) = wmctrl_raise_window(&title).await {
info!("Window not raised: {}", err);
}
});
}
if counter >= 10 {
bail!("Failed to raise window: {}", title)
}
// Calling window.show() on window object will cause the menu to be shown.
// We need to hide it again.
win.hide_menu()?;
counter += 1;
tokio::time::sleep(Duration::from_millis(100)).await;
Ok(())
}
async fn wmctrl_raise_window(title: &str) -> anyhow::Result<()> {
let mut counter = 0;
loop {
if let Ok(exit_status) = wmctrl_try_raise_window(title).await {
if exit_status.success() {
info!("Window raised after {} attempts", counter + 1);
return Ok(());
}
}
if counter >= 10 {
bail!("Failed to raise window: {}", title)
}
counter += 1;
tokio::time::sleep(Duration::from_millis(100)).await;
}
}
async fn wmctrl_try_raise_window(title: &str) -> anyhow::Result<ExitStatus> {
let exit_status = Command::new("wmctrl")
.arg("-F")
.arg("-a")
.arg(title)
.spawn()?
.wait()
.await?;
Ok(exit_status)
}
}
async fn wmctrl_try_raise_window(title: &str) -> anyhow::Result<ExitStatus> {
let exit_status = Command::new("wmctrl")
.arg("-F")
.arg("-a")
.arg(title)
.spawn()?
.wait()
.await?;
Ok(exit_status)
}
+75 -15
View File
@@ -1,27 +1,87 @@
use roxmltree::Node;
use xmltree::Element;
pub(crate) trait NodeExt<'a> {
fn find_descendant(&self, name: &str) -> Option<Node<'a, 'a>>;
fn descendant_text(&self, name: &str) -> Option<&'a str>;
pub(crate) trait ElementExt {
/// Recursively find all descendants with the given name
fn descendants(&self, name: &str) -> Vec<&Element>;
fn find_child(&self, name: &str) -> Option<Node<'a, 'a>>;
fn child_text(&self, name: &str) -> Option<&'a str>;
/// Recursively find the first descendant with the given name
fn descendant(&self, name: &str) -> Option<&Element>;
/// Recursively find the text of the first descendant with the given name
fn descendant_text(&self, name: &str) -> Option<String>;
/// Find the first child with the given name
fn child(&self, name: &str) -> Option<&Element>;
/// Find the text of the first child with the given name
fn child_text(&self, name: &str) -> Option<String>;
/// Get the direct child element with the given name
fn children(&self, name: &str) -> Vec<&Element>;
/// Get the attribute value by name
fn attr(&self, name: &str) -> Option<&str>;
}
impl<'a> NodeExt<'a> for Node<'a, 'a> {
fn find_descendant(&self, name: &str) -> Option<Node<'a, 'a>> {
self.descendants().find(|n| n.has_tag_name(name))
impl ElementExt for Element {
fn descendants(&self, name: &str) -> Vec<&Element> {
let mut results = Vec::new();
if self.name == name {
results.push(self);
}
for child in &self.children {
if let Some(element) = child.as_element() {
results.extend(element.descendants(name));
}
}
results
}
fn descendant_text(&self, name: &str) -> Option<&'a str> {
self.find_descendant(name).and_then(|node| node.text())
fn descendant(&self, name: &str) -> Option<&Element> {
if self.name == name {
return Some(self);
}
for child in &self.children {
if let Some(element) = child.as_element() {
if let Some(found) = element.descendant(name) {
return Some(found);
}
}
}
None
}
fn find_child(&self, name: &str) -> Option<Node<'a, 'a>> {
self.children().find(|n| n.has_tag_name(name))
fn descendant_text(&self, name: &str) -> Option<String> {
self
.descendant(name)
.and_then(|element| element.get_text().map(|s| s.to_string()))
}
fn child_text(&self, name: &str) -> Option<&'a str> {
self.find_child(name).and_then(|node| node.text())
fn child(&self, name: &str) -> Option<&Element> {
self.get_child(name)
}
fn child_text(&self, name: &str) -> Option<String> {
self
.get_child(name)
.and_then(|element| element.get_text().map(|s| s.to_string()))
}
fn children(&self, name: &str) -> Vec<&Element> {
self
.children
.iter()
.filter_map(|child| child.as_element())
.filter(|element| element.name == name)
.collect()
}
fn attr(&self, name: &str) -> Option<&str> {
self.attributes.get(name).map(|s| s.as_str())
}
}
+4 -1
View File
@@ -6,8 +6,11 @@ license.workspace = true
links = "openconnect"
[dependencies]
common = { path = "../common" }
log.workspace = true
is_executable.workspace = true
[build-dependencies]
cc = "1"
autotools = "0.2"
pkg-config = "0.3"
fs_extra = "1"
+82 -5
View File
@@ -1,14 +1,91 @@
use std::{env, path::PathBuf, process::Command};
fn main() {
// Link to the native openconnect library
println!("cargo:rustc-link-lib=openconnect");
println!("cargo:rustc-link-search=/opt/homebrew/lib"); // Homebrew path
let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
let deps_dir = PathBuf::from(&manifest_dir).join("../../deps");
let openconnect_dir = deps_dir.join("openconnect");
let gp_version_patch = deps_dir.join("patches/openconnect-gp-version.patch");
// The temporary location where we will build
let build_src = out_dir.join("openconnect_build");
// Track changes so cargo rebuilds if patch or submodule changes
println!("cargo:rerun-if-changed={}", openconnect_dir.display());
println!("cargo:rerun-if-changed={}", gp_version_patch.display());
// Prepare the build directory
// If the directory exists from a previous run, remove it to ensure a clean slate
if build_src.exists() {
std::fs::remove_dir_all(&build_src).unwrap();
}
std::fs::create_dir_all(&build_src).unwrap();
// Copy the source code to OUT_DIR
// We use fs_extra options to copy contents recursively
let mut options = fs_extra::dir::CopyOptions::new();
options.overwrite = true;
options.content_only = true; // Copy content of src into dest, not src folder itself
fs_extra::dir::copy(&openconnect_dir, &build_src, &options).expect("Failed to copy C source code to OUT_DIR");
// Apply the Patch
// We use the system `patch` command.
let status = Command::new("patch")
.arg("-p1") // Strip one level of path (standard for git diffs)
.arg("-i") // Input file
.arg(&gp_version_patch)
.current_dir(&build_src) // Run INSIDE the copied dir
.status()
.expect("Failed to execute patch command");
if !status.success() {
panic!("Failed to apply patch file: {}", gp_version_patch.display());
}
// Build the OpenConnect library using autotools
// We explicitly enable static and disable shared to ensure we get a .a file.
// .reconf("-ivf") is CRITICAL for git submodules because 'configure'
// usually doesn't exist yet and needs to be generated.
let dst = autotools::Config::new(&build_src)
.reconf("-ivf")
.enable_static()
.disable_shared()
.disable("nls", None) // disable translations to save space
.disable("docs", None)
.disable("dsa-tests", None)
.without("libproxy", None)
.without("stoken", None)
.without("libpcsclite", None)
.without("libpskc", None)
.without("gssapi", None)
.with("gnutls-tss2", Some("no"))
.with("vpnc-script", Some("/etc/vpnc/vpnc-script")) // Specify vpnc-script, otherwise it will fail on macOS
.build();
// Link the 'openconnect' static library
println!("cargo:rustc-link-search=native={}/lib", dst.display());
println!("cargo:rustc-link-lib=static=openconnect");
// Using pkg-config to find system deps
pkg_config::probe_library("libxml-2.0").unwrap();
pkg_config::probe_library("zlib").unwrap();
pkg_config::probe_library("liblz4").unwrap();
pkg_config::probe_library("gnutls").unwrap();
// Below are required by gnutls
pkg_config::probe_library("p11-kit-1").unwrap();
pkg_config::probe_library("hogweed").unwrap();
pkg_config::probe_library("nettle").unwrap();
pkg_config::probe_library("gmp").unwrap();
// Compile the vpn.c file
println!("cargo:rerun-if-changed=src/ffi/vpn.c");
println!("cargo:rerun-if-changed=src/ffi/vpn.h");
// Compile the vpn.c file
cc::Build::new()
.file("src/ffi/vpn.c")
.include("src/ffi")
.include("/opt/homebrew/include") // Homebrew path
.include(&dst.join("include"))
.compile("vpn");
}
+12 -4
View File
@@ -2,6 +2,7 @@ use crate::Vpn;
use log::{debug, info, trace, warn};
use std::ffi::{c_char, c_int, c_void};
/// ConnectOptions struct for FFI, the field names and order must match the C definition.
#[repr(C)]
#[derive(Debug)]
pub(crate) struct ConnectOptions {
@@ -9,10 +10,15 @@ pub(crate) struct ConnectOptions {
pub server: *const c_char,
pub cookie: *const c_char,
pub user_agent: *const c_char,
pub os: *const c_char,
pub client_version: *const c_char,
pub script: *const c_char,
pub os: *const c_char,
pub interface: *const c_char,
pub script_tun: u32,
pub certificate: *const c_char,
pub sslkey: *const c_char,
pub key_password: *const c_char,
@@ -25,10 +31,12 @@ pub(crate) struct ConnectOptions {
pub mtu: u32,
pub disable_ipv6: u32,
pub no_dtls: u32,
pub dpd_interval: u32,
}
#[link(name = "vpn")]
extern "C" {
unsafe extern "C" {
#[link_name = "vpn_connect"]
fn vpn_connect(options: *const ConnectOptions, callback: extern "C" fn(i32, *mut c_void)) -> c_int;
@@ -44,7 +52,7 @@ pub(crate) fn disconnect() {
unsafe { vpn_disconnect() }
}
#[no_mangle]
#[unsafe(no_mangle)]
extern "C" fn on_vpn_connected(pipe_fd: i32, vpn: *mut c_void) {
let vpn = unsafe { &*(vpn as *const Vpn) };
vpn.on_connected(pipe_fd);
@@ -53,7 +61,7 @@ extern "C" fn on_vpn_connected(pipe_fd: i32, vpn: *mut c_void) {
// Logger used in the C code.
// level: 0 = error, 1 = info, 2 = debug, 3 = trace
// map the error level log in openconnect to the warning level
#[no_mangle]
#[unsafe(no_mangle)]
extern "C" fn vpn_log(level: i32, message: *const c_char) {
let message = unsafe { std::ffi::CStr::from_ptr(message) };
let message = message.to_str().unwrap_or("Invalid log message");
+128 -98
View File
@@ -1,9 +1,9 @@
#include <openconnect.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <openconnect.h>
#include <unistd.h>
#include "vpn.h"
@@ -11,143 +11,173 @@ void *g_user_data;
static int g_cmd_pipe_fd;
static const char *g_vpnc_script;
static const char *g_vpnc_interface;
static int g_script_tun;
static vpn_connected_callback on_vpn_connected;
/* Validate the peer certificate */
static int validate_peer_cert(__attribute__((unused)) void *_vpninfo, const char *reason)
static int validate_peer_cert(__attribute__((unused)) void *_vpninfo,
const char *reason)
{
INFO("Accepting the server certificate though %s", reason);
return 0;
INFO("Accepting the server certificate though %s", reason);
return 0;
}
/* Print progress messages */
static void print_progress(__attribute__((unused)) void *_vpninfo, int level, const char *format, ...)
static void print_progress(__attribute__((unused)) void *_vpninfo, int level,
const char *format, ...)
{
va_list args;
va_start(args, format);
char *message = format_message(format, args);
va_end(args);
va_list args;
va_start(args, format);
char *message = format_message(format, args);
va_end(args);
if (message == NULL) {
ERROR("Failed to format log message");
} else {
LOG(level, message);
free(message);
}
if (message == NULL) {
ERROR("Failed to format log message");
} else {
LOG(level, message);
free(message);
}
}
static void setup_tun_handler(void *_vpninfo)
{
int ret = openconnect_setup_tun_device(_vpninfo, g_vpnc_script, NULL);
if (!ret) {
on_vpn_connected(g_cmd_pipe_fd, g_user_data);
}
int ret;
if (g_script_tun) {
ret = openconnect_setup_tun_script(_vpninfo, g_vpnc_script);
} else {
ret = openconnect_setup_tun_device(_vpninfo, g_vpnc_script,
g_vpnc_interface);
}
if (!ret) {
on_vpn_connected(g_cmd_pipe_fd, g_user_data);
}
}
/* Initialize VPN connection */
int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
{
INFO("openconnect version: %s", openconnect_get_version());
struct openconnect_info *vpninfo;
struct utsname utsbuf;
struct openconnect_info *vpninfo;
struct utsname utsbuf;
g_user_data = options->user_data;
g_vpnc_script = options->script;
on_vpn_connected = callback;
g_user_data = options->user_data;
g_vpnc_script = options->script;
g_vpnc_interface = options->interface;
g_script_tun = options->script_tun;
on_vpn_connected = callback;
INFO("User agent: %s", options->user_agent);
INFO("VPNC script: %s", options->script);
INFO("OS: %s", options->os);
INFO("CSD_USER: %d", options->csd_uid);
INFO("CSD_WRAPPER: %s", options->csd_wrapper);
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
INFO("MTU: %d", options->mtu);
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
INFO("NO_DTLS: %d", options->no_dtls);
INFO("USER_AGENT: %s", options->user_agent);
INFO("OS: %s", options->os);
INFO("CLIENT_VERSION: %s", options->client_version);
INFO("VPNC_SCRIPT: %s", options->script);
INFO("SCRIPT_TUN: %d", g_script_tun);
INFO("CSD_USER: %d", options->csd_uid);
INFO("CSD_WRAPPER: %s", options->csd_wrapper);
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
INFO("MTU: %d", options->mtu);
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
INFO("NO_DTLS: %d", options->no_dtls);
INFO("DPD_INTERVAL: %d", options->dpd_interval);
vpninfo = openconnect_vpninfo_new(options->user_agent, validate_peer_cert, NULL, NULL, print_progress, NULL);
vpninfo =
openconnect_vpninfo_new(options->user_agent, validate_peer_cert,
NULL, NULL, print_progress, NULL);
if (!vpninfo) {
ERROR("openconnect_vpninfo_new failed");
return 1;
}
if (!vpninfo) {
ERROR("openconnect_vpninfo_new failed");
return 1;
}
openconnect_set_loglevel(vpninfo, PRG_TRACE);
openconnect_init_ssl();
openconnect_set_protocol(vpninfo, "gp");
openconnect_set_hostname(vpninfo, options->server);
openconnect_set_cookie(vpninfo, options->cookie);
openconnect_set_loglevel(vpninfo, PRG_TRACE);
openconnect_init_ssl();
openconnect_set_protocol(vpninfo, "gp");
openconnect_parse_url(vpninfo, options->server);
openconnect_set_cookie(vpninfo, options->cookie);
if (options->os) {
openconnect_set_reported_os(vpninfo, options->os);
}
if (options->os) {
openconnect_set_reported_os(vpninfo, options->os);
}
if (options->certificate) {
INFO("Setting client certificate: %s", options->certificate);
openconnect_set_client_cert(vpninfo, options->certificate, options->sslkey);
}
if (options->client_version) {
openconnect_set_gp_app_version(vpninfo,
options->client_version);
}
if (options->key_password) {
openconnect_set_key_password(vpninfo, options->key_password);
}
if (options->certificate) {
INFO("Setting client certificate: %s", options->certificate);
openconnect_set_client_cert(vpninfo, options->certificate,
options->sslkey);
}
if (options->csd_wrapper) {
openconnect_setup_csd(vpninfo, options->csd_uid, 1, options->csd_wrapper);
}
if (options->key_password) {
openconnect_set_key_password(vpninfo, options->key_password);
}
if (options->mtu > 0) {
int mtu = options->mtu < 576 ? 576 : options->mtu;
openconnect_set_reqmtu(vpninfo, mtu);
}
if (options->csd_wrapper) {
openconnect_setup_csd(vpninfo, options->csd_uid, 1,
options->csd_wrapper);
}
if (options->disable_ipv6) {
openconnect_disable_ipv6(vpninfo);
}
if (options->mtu > 0) {
int mtu = options->mtu < 576 ? 576 : options->mtu;
openconnect_set_reqmtu(vpninfo, mtu);
}
g_cmd_pipe_fd = openconnect_setup_cmd_pipe(vpninfo);
if (g_cmd_pipe_fd < 0) {
ERROR("openconnect_setup_cmd_pipe failed");
return 1;
}
if (options->disable_ipv6) {
openconnect_disable_ipv6(vpninfo);
}
if (!uname(&utsbuf)) {
openconnect_set_localname(vpninfo, utsbuf.nodename);
}
if (options->dpd_interval > 0) {
openconnect_set_dpd(vpninfo, options->dpd_interval);
}
// Essential step
if (openconnect_make_cstp_connection(vpninfo) != 0) {
ERROR("openconnect_make_cstp_connection failed");
return 1;
}
g_cmd_pipe_fd = openconnect_setup_cmd_pipe(vpninfo);
if (g_cmd_pipe_fd < 0) {
ERROR("openconnect_setup_cmd_pipe failed");
return 1;
}
if (options->no_dtls || openconnect_setup_dtls(vpninfo, 60) != 0) {
openconnect_disable_dtls(vpninfo);
}
if (!uname(&utsbuf)) {
openconnect_set_localname(vpninfo, utsbuf.nodename);
}
// Essential step
openconnect_set_setup_tun_handler(vpninfo, setup_tun_handler);
// Essential step
if (openconnect_make_cstp_connection(vpninfo) != 0) {
ERROR("openconnect_make_cstp_connection failed");
return 1;
}
while (1) {
int ret = openconnect_mainloop(vpninfo, options->reconnect_timeout, 10);
if (options->no_dtls || openconnect_setup_dtls(vpninfo, 60) != 0) {
openconnect_disable_dtls(vpninfo);
}
if (ret) {
INFO("openconnect_mainloop returned %d, exiting", ret);
openconnect_vpninfo_free(vpninfo);
return ret;
}
// Essential step
openconnect_set_setup_tun_handler(vpninfo, setup_tun_handler);
INFO("openconnect_mainloop returned 0, reconnecting");
}
while (1) {
int ret = openconnect_mainloop(vpninfo,
options->reconnect_timeout, 10);
if (ret) {
INFO("openconnect_mainloop returned %d, exiting", ret);
openconnect_vpninfo_free(vpninfo);
return ret;
}
INFO("openconnect_mainloop returned 0, reconnecting");
}
}
/* Stop the VPN connection */
void vpn_disconnect()
{
char cmd = OC_CMD_CANCEL;
char cmd = OC_CMD_CANCEL;
INFO("Stopping VPN connection: %d", g_cmd_pipe_fd);
INFO("Stopping VPN connection: %d", g_cmd_pipe_fd);
if (write(g_cmd_pipe_fd, &cmd, 1) < 0) {
ERROR("Failed to write to command pipe, VPN connection may not be stopped");
}
if (write(g_cmd_pipe_fd, &cmd, 1) < 0) {
ERROR("Failed to write to command pipe, VPN connection may not "
"be stopped");
}
}
+48 -45
View File
@@ -1,31 +1,38 @@
#include <openconnect.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <openconnect.h>
typedef void (*vpn_connected_callback)(int cmd_pipe_fd, void *user_data);
typedef struct vpn_options
{
void *user_data;
const char *server;
const char *cookie;
const char *user_agent;
typedef struct vpn_options {
void *user_data;
const char *script;
const char *os;
const char *certificate;
const char *sslkey;
const char *key_password;
const char *servercert;
const char *server;
const char *cookie;
const uid_t csd_uid;
const char *csd_wrapper;
const char *user_agent;
const char *os;
const char *client_version;
const int reconnect_timeout;
const int mtu;
const int disable_ipv6;
const int no_dtls;
const char *script;
const char *interface;
const int script_tun;
const char *certificate;
const char *sslkey;
const char *key_password;
const char *servercert;
const uid_t csd_uid;
const char *csd_wrapper;
const int reconnect_timeout;
const int mtu;
const int disable_ipv6;
const int no_dtls;
const int dpd_interval;
} vpn_options;
int vpn_connect(const vpn_options *options, vpn_connected_callback callback);
@@ -35,40 +42,36 @@ extern void vpn_log(int level, const char *msg);
static char *format_message(const char *format, va_list args)
{
va_list args_copy;
va_copy(args_copy, args);
int len = vsnprintf(NULL, 0, format, args_copy);
va_end(args_copy);
va_list args_copy;
va_copy(args_copy, args);
int len = vsnprintf(NULL, 0, format, args_copy);
va_end(args_copy);
char *buffer = (char*)malloc(len + 1);
if (buffer == NULL)
{
return NULL;
}
char *buffer = (char *)malloc(len + 1);
if (buffer == NULL) {
return NULL;
}
vsnprintf(buffer, len + 1, format, args);
return buffer;
vsnprintf(buffer, len + 1, format, args);
return buffer;
}
static void _log(int level, ...)
{
va_list args;
va_start(args, level);
va_list args;
va_start(args, level);
char *format = va_arg(args, char *);
char *message = format_message(format, args);
char *format = va_arg(args, char *);
char *message = format_message(format, args);
va_end(args);
va_end(args);
if (message == NULL)
{
vpn_log(PRG_ERR, "Failed to format log message");
}
else
{
vpn_log(level, message);
free(message);
}
if (message == NULL) {
vpn_log(PRG_ERR, "Failed to format log message");
} else {
vpn_log(level, message);
free(message);
}
}
#define LOG(level, ...) _log(level, __VA_ARGS__)
+2
View File
@@ -1,4 +1,6 @@
mod ffi;
mod vpn;
mod vpn_utils;
pub use vpn::*;
pub use vpn_utils::*;
+89 -15
View File
@@ -4,19 +4,25 @@ use std::{
sync::{Arc, RwLock},
};
use common::vpn_utils::{check_executable, find_vpnc_script};
use log::info;
use crate::ffi;
use crate::vpn_utils::{check_executable, find_csd_wrapper, find_vpnc_script};
type OnConnectedCallback = Arc<RwLock<Option<Box<dyn FnOnce() + 'static + Send + Sync>>>>;
pub struct Vpn {
server: CString,
cookie: CString,
user_agent: CString,
script: CString,
os: CString,
client_version: Option<CString>,
script: CString,
interface: Option<CString>,
script_tun: bool,
certificate: Option<CString>,
sslkey: Option<CString>,
key_password: Option<CString>,
@@ -30,6 +36,8 @@ pub struct Vpn {
disable_ipv6: bool,
no_dtls: bool,
dpd_interval: u32,
callback: OnConnectedCallback,
}
@@ -63,9 +71,14 @@ impl Vpn {
server: self.server.as_ptr(),
cookie: self.cookie.as_ptr(),
user_agent: self.user_agent.as_ptr(),
script: self.script.as_ptr(),
os: self.os.as_ptr(),
client_version: Self::option_to_ptr(&self.client_version),
script: self.script.as_ptr(),
interface: Self::option_to_ptr(&self.interface),
script_tun: self.script_tun as u32,
certificate: Self::option_to_ptr(&self.certificate),
sslkey: Self::option_to_ptr(&self.sslkey),
@@ -79,6 +92,7 @@ impl Vpn {
mtu: self.mtu,
disable_ipv6: self.disable_ipv6 as u32,
no_dtls: self.no_dtls as u32,
dpd_interval: self.dpd_interval,
}
}
@@ -113,14 +127,18 @@ pub struct VpnBuilder {
server: String,
cookie: String,
script: Option<String>,
interface: Option<String>,
script_tun: bool,
user_agent: Option<String>,
os: Option<String>,
client_version: Option<String>,
certificate: Option<String>,
sslkey: Option<String>,
key_password: Option<String>,
hip: bool,
csd_uid: u32,
csd_wrapper: Option<String>,
@@ -128,6 +146,8 @@ pub struct VpnBuilder {
mtu: u32,
disable_ipv6: bool,
no_dtls: bool,
dpd_interval: u32,
}
impl VpnBuilder {
@@ -136,14 +156,18 @@ impl VpnBuilder {
server: server.to_string(),
cookie: cookie.to_string(),
script: None,
interface: None,
script_tun: false,
user_agent: None,
os: None,
client_version: None,
certificate: None,
sslkey: None,
key_password: None,
hip: false,
csd_uid: 0,
csd_wrapper: None,
@@ -151,6 +175,7 @@ impl VpnBuilder {
mtu: 0,
disable_ipv6: false,
no_dtls: false,
dpd_interval: 0,
}
}
@@ -159,6 +184,16 @@ impl VpnBuilder {
self
}
pub fn interface<T: Into<Option<String>>>(mut self, interface: T) -> Self {
self.interface = interface.into();
self
}
pub fn script_tun(mut self, script_tun: bool) -> Self {
self.script_tun = script_tun;
self
}
pub fn user_agent<T: Into<Option<String>>>(mut self, user_agent: T) -> Self {
self.user_agent = user_agent.into();
self
@@ -169,6 +204,11 @@ impl VpnBuilder {
self
}
pub fn client_version<T: Into<Option<String>>>(mut self, client_version: T) -> Self {
self.client_version = client_version.into();
self
}
pub fn certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
self.certificate = certificate.into();
self
@@ -184,6 +224,11 @@ impl VpnBuilder {
self
}
pub fn hip(mut self, hip: bool) -> Self {
self.hip = hip;
self
}
pub fn csd_uid(mut self, csd_uid: u32) -> Self {
self.csd_uid = csd_uid;
self
@@ -214,18 +259,41 @@ impl VpnBuilder {
self
}
pub fn build(self) -> Result<Vpn, VpnError> {
let script = match self.script {
Some(script) => {
check_executable(&script).map_err(|e| VpnError::new(e.to_string()))?;
script
}
None => find_vpnc_script().ok_or_else(|| VpnError::new(String::from("Failed to find vpnc-script")))?,
};
pub fn dpd_interval(mut self, dpd_interval: u32) -> Self {
self.dpd_interval = dpd_interval;
self
}
if let Some(csd_wrapper) = &self.csd_wrapper {
check_executable(csd_wrapper).map_err(|e| VpnError::new(e.to_string()))?;
fn determine_script(&self) -> Result<&str, VpnError> {
match &self.script {
Some(script) => {
check_executable(script).map_err(|e| VpnError::new(e.to_string()))?;
Ok(script)
}
None => find_vpnc_script().ok_or_else(|| VpnError::new(String::from("Failed to find vpnc-script"))),
}
}
fn determine_csd_wrapper(&self) -> Result<Option<&str>, VpnError> {
if !self.hip {
return Ok(None);
}
match &self.csd_wrapper {
Some(csd_wrapper) if !csd_wrapper.is_empty() => {
check_executable(csd_wrapper).map_err(|e| VpnError::new(e.to_string()))?;
Ok(Some(csd_wrapper))
}
_ => {
let s = find_csd_wrapper().ok_or_else(|| VpnError::new(String::from("Failed to find csd wrapper")))?;
Ok(Some(s))
}
}
}
pub fn build(self) -> Result<Vpn, VpnError> {
let script = self.determine_script()?.to_owned();
let csd_wrapper = self.determine_csd_wrapper()?.map(|s| s.to_owned());
let user_agent = self.user_agent.unwrap_or_default();
let os = self.os.unwrap_or("linux".to_string());
@@ -233,9 +301,14 @@ impl VpnBuilder {
Ok(Vpn {
server: Self::to_cstring(&self.server),
cookie: Self::to_cstring(&self.cookie),
user_agent: Self::to_cstring(&user_agent),
script: Self::to_cstring(&script),
os: Self::to_cstring(&os),
client_version: self.client_version.as_deref().map(Self::to_cstring),
script: Self::to_cstring(&script),
interface: self.interface.as_deref().map(Self::to_cstring),
script_tun: self.script_tun,
certificate: self.certificate.as_deref().map(Self::to_cstring),
sslkey: self.sslkey.as_deref().map(Self::to_cstring),
@@ -243,12 +316,13 @@ impl VpnBuilder {
servercert: None,
csd_uid: self.csd_uid,
csd_wrapper: self.csd_wrapper.as_deref().map(Self::to_cstring),
csd_wrapper: csd_wrapper.as_deref().map(Self::to_cstring),
reconnect_timeout: self.reconnect_timeout,
mtu: self.mtu,
disable_ipv6: self.disable_ipv6,
no_dtls: self.no_dtls,
dpd_interval: self.dpd_interval,
callback: Default::default(),
})
@@ -9,11 +9,13 @@ const VPNC_SCRIPT_LOCATIONS: &[&str] = &[
"/usr/sbin/vpnc-script",
"/etc/vpnc/vpnc-script",
"/etc/openconnect/vpnc-script",
"/usr/libexec/vpnc-scripts/vpnc-script",
#[cfg(target_os = "macos")]
"/opt/homebrew/etc/vpnc/vpnc-script",
];
const CSD_WRAPPER_LOCATIONS: &[&str] = &[
"/usr/libexec/gpclient/hipreport.sh",
#[cfg(target_arch = "x86_64")]
"/usr/lib/x86_64-linux-gnu/openconnect/hipreport.sh",
#[cfg(target_arch = "aarch64")]
@@ -24,22 +26,22 @@ const CSD_WRAPPER_LOCATIONS: &[&str] = &[
"/opt/homebrew/opt/openconnect/libexec/openconnect/hipreport.sh",
];
fn find_executable(locations: &[&str]) -> Option<String> {
fn find_executable(locations: &[&'static str]) -> Option<&'static str> {
for location in locations.iter() {
let path = Path::new(location);
if path.is_executable() {
return Some(location.to_string());
return Some(*location);
}
}
None
}
pub fn find_vpnc_script() -> Option<String> {
pub fn find_vpnc_script() -> Option<&'static str> {
find_executable(&VPNC_SCRIPT_LOCATIONS)
}
pub fn find_csd_wrapper() -> Option<String> {
pub fn find_csd_wrapper() -> Option<&'static str> {
find_executable(&CSD_WRAPPER_LOCATIONS)
}