mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-17 13:46:27 -05:00
Compare commits
1
Commits
dev
...
release/3.0.6
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
86c8d188c4 |
No files matched your search
@@ -44,9 +44,6 @@ on:
|
||||
- .devcontainer
|
||||
branches:
|
||||
- main
|
||||
- hotfix/*
|
||||
- feature/*
|
||||
- release/*
|
||||
tags:
|
||||
- v*.*.*
|
||||
|
||||
|
||||
@@ -44,23 +44,34 @@ jobs:
|
||||
run: |
|
||||
pacman -Syu --noconfirm --needed \
|
||||
appmenu-gtk-module \
|
||||
autoconf \
|
||||
automake \
|
||||
cargo \
|
||||
curl \
|
||||
desktop-file-utils \
|
||||
file \
|
||||
git \
|
||||
gettext \
|
||||
gmp \
|
||||
gnutls \
|
||||
libappindicator-gtk3 \
|
||||
libp11-kit \
|
||||
libsecret \
|
||||
libtool \
|
||||
libxml2 \
|
||||
lz4 \
|
||||
make \
|
||||
namcap \
|
||||
openconnect \
|
||||
nettle \
|
||||
openssl \
|
||||
patch \
|
||||
pkgconf \
|
||||
librsvg \
|
||||
shared-mime-info \
|
||||
vpnc \
|
||||
wget \
|
||||
webkit2gtk-4.1
|
||||
webkit2gtk-4.1 \
|
||||
xdg-utils \
|
||||
zlib
|
||||
|
||||
- name: Save committed .SRCINFO
|
||||
if: ${{ github.event_name == 'push' }}
|
||||
|
||||
Generated
+552
-99
File diff suppressed because it is too large.
Load diff
+4
-4
@@ -11,7 +11,7 @@ members = [
|
||||
|
||||
[workspace.package]
|
||||
rust-version = "1.91"
|
||||
version = "3.0.5"
|
||||
version = "3.0.6"
|
||||
authors = ["Kevin Yue <[email protected]>"]
|
||||
homepage = "https://github.com/yuezk/GlobalProtect-openconnect"
|
||||
edition = "2024"
|
||||
@@ -30,7 +30,8 @@ dns-lookup = "4.0.2"
|
||||
env_logger = "0.11"
|
||||
is_executable = "1.0"
|
||||
log = "0.4"
|
||||
regex = "1"
|
||||
# RUST_LOG accepts user-supplied Unicode property filters through env_logger.
|
||||
regex = { version = "1", default-features = false, features = ["std", "perf", "unicode"] }
|
||||
reqwest = { version = "0.13", default-features = false, features = ["native-tls", "charset", "http2", "system-proxy", "json", "form", "query"] }
|
||||
openssl = "0.10"
|
||||
pem = "4"
|
||||
@@ -50,11 +51,10 @@ futures-util = "0.3"
|
||||
uzers = "0.12"
|
||||
whoami = "2"
|
||||
thiserror = "2"
|
||||
redact-engine = "0.1"
|
||||
compile-time = "0.4"
|
||||
serde_urlencoded = "0.7"
|
||||
md5 = "0.8"
|
||||
sha256 = { version = "1", default-features = false }
|
||||
sha2 = { version = "0.11", default-features = false }
|
||||
which = "8"
|
||||
uuid = "1"
|
||||
netdev = "0.46.3"
|
||||
|
||||
@@ -73,6 +73,8 @@ Options:
|
||||
-V, --version Print version
|
||||
```
|
||||
|
||||
The `--fix-openssl` option is available on Linux, FreeBSD, and OpenBSD. macOS uses native TLS and GnuTLS and does not accept this option.
|
||||
|
||||
> **Tip:** Use `gpclient help <command>` for detailed information on a specific command.
|
||||
|
||||
#### HIP reports
|
||||
@@ -95,6 +97,8 @@ Use `gpclient` directly for browser-based authentication. It opens the browser a
|
||||
sudo gpclient connect <portal> --browser
|
||||
```
|
||||
|
||||
For standalone CLI installations, use `--browser manual` (`--browser remote` before v3.0.6): open the printed URL and paste the resulting `globalprotectcallback:…` data into the terminal.
|
||||
|
||||
To reuse a saved portal cookie for later connections, add `--cookie-cache`:
|
||||
|
||||
```bash
|
||||
@@ -109,10 +113,9 @@ sudo gpclient connect <portal> --browser --cookie-cache=/absolute/path/to/cookie
|
||||
|
||||
**Browser Options:**
|
||||
|
||||
- Use `--browser` to try your recognized default browser first, then another detected browser, and finally the system URL handler
|
||||
- Use `--browser default` to use the system default browser
|
||||
- Use `--browser` to automatically select an available browser
|
||||
- Use `--browser <browser>` to specify a browser (e.g., `firefox`, `chrome`)
|
||||
- Use `--browser remote` for headless servers – this provides a URL you can access from another machine to complete authentication
|
||||
- Use `--browser manual` for standalone CLI installations or headless servers
|
||||
|
||||
### Graphical User Interface
|
||||
|
||||
@@ -365,18 +368,18 @@ docker run --rm -it --cap-add=NET_ADMIN --device=/dev/net/tun \
|
||||
connect <portal>
|
||||
```
|
||||
|
||||
For browser authentication in a headless environment, use remote browser authentication:
|
||||
For browser authentication in a headless environment, use manual browser authentication:
|
||||
|
||||
```bash
|
||||
docker run --rm -it --cap-add=NET_ADMIN --device=/dev/net/tun \
|
||||
yuezk/globalprotect-openconnect:<version> \
|
||||
connect <portal> --browser remote
|
||||
connect <portal> --browser manual
|
||||
```
|
||||
|
||||
On a host with multiple network interfaces, use `--browser-listen` to select the IP address reachable from the browser machine:
|
||||
|
||||
```bash
|
||||
gpclient connect <portal> --browser remote --browser-listen 192.168.107.15
|
||||
gpclient connect <portal> --browser manual --browser-listen 192.168.107.15
|
||||
```
|
||||
|
||||
On a Linux host, add host networking if the VPN routes should affect the host network namespace:
|
||||
@@ -384,7 +387,7 @@ On a Linux host, add host networking if the VPN routes should affect the host ne
|
||||
```bash
|
||||
docker run --rm -it --network host --cap-add=NET_ADMIN --device=/dev/net/tun \
|
||||
yuezk/globalprotect-openconnect:<version> \
|
||||
connect <portal> --browser remote
|
||||
connect <portal> --browser manual
|
||||
```
|
||||
|
||||
Without `--network host`, the VPN connection stays inside the container's network namespace. Docker Desktop on macOS and Windows does not make the host use the VPN through `--network host`; run `gpclient` on the host or use a container gateway setup for host traffic.
|
||||
@@ -513,7 +516,7 @@ Verify the CLI client is working correctly:
|
||||
### Build Options
|
||||
|
||||
- `BUILD_GUI_HELPER=0` – Skip building and installing the GUI helper
|
||||
- `BUILD_WEBVIEW_AUTH=0` – Build `gpauth` without embedded browser authentication; use an external or remote browser
|
||||
- `BUILD_WEBVIEW_AUTH=0` – Build `gpauth` without embedded browser authentication; use an external browser or manual authentication
|
||||
- `INCLUDE_GUI=1` – Download the matching published Linux desktop application for installation
|
||||
- `OFFLINE=1` – Build in offline mode using vendored dependencies
|
||||
|
||||
@@ -539,7 +542,7 @@ sudo gpclient connect <portal> --browser
|
||||
|
||||
See related issue: [#316](https://github.com/yuezk/GlobalProtect-openconnect/issues/316)
|
||||
|
||||
On a headless server, use `--browser remote` and complete authentication from another machine.
|
||||
On a headless server, use `--browser manual` and complete authentication from another machine.
|
||||
|
||||
## NetworkManager Integration
|
||||
|
||||
|
||||
+78
-18
@@ -6,17 +6,21 @@ use clap::Parser;
|
||||
use clap::Subcommand;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
use gpapi::auth::AuthWindowTheme;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use gpapi::utils::openssl;
|
||||
use gpapi::{
|
||||
auth::{AuthenticationCancelled, SamlAuthData, SamlAuthResult},
|
||||
clap::{Args, InfoLevelVerbosity, args::Os, handle_error},
|
||||
error::ServerTlsError,
|
||||
gp_params::GpParams,
|
||||
log_format::LogFormat,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
utils::{normalize_server, openssl},
|
||||
utils::normalize_server,
|
||||
};
|
||||
use log::info;
|
||||
use serde_json::json;
|
||||
use std::net::IpAddr;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use tempfile::NamedTempFile;
|
||||
|
||||
const VERSION: &str = concat!(
|
||||
@@ -84,6 +88,7 @@ struct Cli {
|
||||
#[arg(short = 'p', long, help = "The key passphrase of the private key")]
|
||||
key_password: Option<String>,
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[arg(long, help = "Get around the OpenSSL `unsafe legacy renegotiation` error")]
|
||||
fix_openssl: bool,
|
||||
|
||||
@@ -104,13 +109,13 @@ struct Cli {
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Use external browser authentication. With no value, auto-select Chrome, Firefox, then system default. Use `default` for the system default browser or `remote` for headless servers.",
|
||||
help = "Use a browser; omit the value to auto-select. Use `manual` to open the URL and paste the callback.",
|
||||
default_missing_value = "auto",
|
||||
num_args=0..=1
|
||||
)]
|
||||
browser: Option<String>,
|
||||
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser remote'")]
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser manual'")]
|
||||
browser_listen: Option<IpAddr>,
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -144,6 +149,7 @@ enum CliCommand {
|
||||
}
|
||||
|
||||
impl Args for Cli {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> bool {
|
||||
self.fix_openssl
|
||||
}
|
||||
@@ -158,10 +164,8 @@ impl Args for Cli {
|
||||
}
|
||||
|
||||
impl Cli {
|
||||
fn prepare_env(&self) -> anyhow::Result<Option<NamedTempFile>> {
|
||||
#[cfg(feature = "webview-auth")]
|
||||
gpapi::utils::env_utils::patch_gui_runtime_env(self.hidpi);
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn prepare_openssl(&self) -> anyhow::Result<Option<NamedTempFile>> {
|
||||
if self.fix_openssl {
|
||||
info!("Fixing OpenSSL environment");
|
||||
let file = openssl::fix_openssl_env()?;
|
||||
@@ -174,16 +178,19 @@ impl Cli {
|
||||
|
||||
async fn run(&self) -> anyhow::Result<()> {
|
||||
if self.browser_listen.is_some()
|
||||
&& !matches!(self.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("remote"))
|
||||
&& !matches!(self.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("manual") || browser.eq_ignore_ascii_case("remote"))
|
||||
{
|
||||
anyhow::bail!("The '--browser-listen' option requires '--browser remote'");
|
||||
anyhow::bail!("The '--browser-listen' option requires '--browser manual'");
|
||||
}
|
||||
|
||||
if self.ignore_tls_errors {
|
||||
info!("TLS errors will be ignored");
|
||||
}
|
||||
|
||||
let openssl_conf = self.prepare_env()?;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
gpapi::utils::env_utils::patch_gui_runtime_env(self.hidpi);
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let openssl_conf = self.prepare_openssl()?;
|
||||
|
||||
let server = normalize_server(self.server.as_deref().expect("server is required for authentication"))?;
|
||||
let gp_params = self.build_gp_params();
|
||||
@@ -194,7 +201,17 @@ impl Cli {
|
||||
|
||||
let auth_request = match self.saml_request.as_deref() {
|
||||
Some(auth_request) => auth_request.to_string(),
|
||||
None => auth_prelogin(&server, &gp_params, self.external_browser_requested(), self.gateway).await?,
|
||||
None => match auth_prelogin(&server, &gp_params, self.external_browser_requested(), self.gateway).await {
|
||||
Ok(request) => request,
|
||||
Err(error) => {
|
||||
let Some(tls) = error.downcast_ref::<ServerTlsError>().cloned() else {
|
||||
return Err(error);
|
||||
};
|
||||
handle_error(error, self);
|
||||
print_auth_result(Err(tls.into()), None);
|
||||
return Ok(());
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -213,7 +230,7 @@ impl Cli {
|
||||
|
||||
print_auth_result(auth_result, Some(&auth_host_id));
|
||||
|
||||
// explicitly drop openssl_conf to avoid the unused variable warning
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
drop(openssl_conf);
|
||||
return Ok(());
|
||||
}
|
||||
@@ -226,6 +243,7 @@ impl Cli {
|
||||
self.clean,
|
||||
self.window_title.clone(),
|
||||
self.window_theme,
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
openssl_conf,
|
||||
)
|
||||
.await?;
|
||||
@@ -298,7 +316,11 @@ pub async fn run() {
|
||||
}
|
||||
|
||||
pub fn print_auth_result(auth_result: anyhow::Result<SamlAuthData>, host_id: Option<&str>) {
|
||||
let auth_result = match auth_result {
|
||||
println!("{}", json!(auth_outcome(auth_result, host_id)));
|
||||
}
|
||||
|
||||
fn auth_outcome(auth_result: anyhow::Result<SamlAuthData>, host_id: Option<&str>) -> SamlAuthResult {
|
||||
match auth_result {
|
||||
Ok(auth_data) => {
|
||||
let auth_data = match host_id {
|
||||
Some(host_id) => auth_data.with_host_id(host_id),
|
||||
@@ -307,16 +329,54 @@ pub fn print_auth_result(auth_result: anyhow::Result<SamlAuthData>, host_id: Opt
|
||||
SamlAuthResult::Success(auth_data)
|
||||
}
|
||||
Err(err) if err.downcast_ref::<AuthenticationCancelled>().is_some() => SamlAuthResult::Cancelled,
|
||||
Err(err) => SamlAuthResult::Failure(format!("{}", err)),
|
||||
};
|
||||
|
||||
println!("{}", json!(auth_result));
|
||||
Err(err) => match err.downcast::<ServerTlsError>() {
|
||||
Ok(tls) => SamlAuthResult::ServerTlsError(tls),
|
||||
Err(err) => SamlAuthResult::Failure(err.to_string()),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn openssl_option_is_available_only_on_supported_platforms() {
|
||||
let result = Cli::try_parse_from(["gpauth", "portal.example.com", "--fix-openssl"]);
|
||||
assert_eq!(result.is_ok(), !cfg!(target_os = "macos"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn result_keeps_server_tls_kind_and_generic_failure_format() {
|
||||
use gpapi::error::ServerTlsErrorKind;
|
||||
let tls = ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: ServerTlsErrorKind::LegacyRenegotiation,
|
||||
};
|
||||
let outcome = auth_outcome(Err(anyhow::Error::new(tls).context("retry failed")), None);
|
||||
assert_eq!(
|
||||
serde_json::to_value(outcome).unwrap(),
|
||||
json!({"serverTlsError": {"server": "https://vpn.example.com", "kind": "legacyRenegotiation"}})
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::to_value(auth_outcome(Err(anyhow::anyhow!("rejected")), None)).unwrap(),
|
||||
json!({"failure": "rejected"})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retry_result_preserves_client_certificate_requirement() {
|
||||
let error = ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: gpapi::error::ServerTlsErrorKind::ClientCertificateRequired,
|
||||
};
|
||||
let outcome = auth_outcome(Err(anyhow::Error::new(error).context("retry failed")), None);
|
||||
assert_eq!(
|
||||
serde_json::to_value(outcome).unwrap(),
|
||||
json!({"serverTlsError": {"server": "https://vpn.example.com", "kind": "clientCertificateRequired"}})
|
||||
);
|
||||
}
|
||||
|
||||
/// gpauth's own result already goes to stdout as JSON; this makes its *logs*
|
||||
/// readable the same way, so a caller driving it does not have to parse prose
|
||||
/// on stderr to find out why an attempt failed.
|
||||
@@ -399,7 +459,7 @@ mod tests {
|
||||
"gpauth",
|
||||
"portal.example.com",
|
||||
"--browser",
|
||||
"remote",
|
||||
"manual",
|
||||
"--browser-listen",
|
||||
"192.168.107.15",
|
||||
])
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
use auth::{WebviewAuthenticator, apply_auth_theme};
|
||||
use gpapi::{auth::AuthWindowTheme, gp_params::GpParams};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use log::info;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use tauri::RunEvent;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use tempfile::NamedTempFile;
|
||||
|
||||
use crate::cli::print_auth_result;
|
||||
@@ -13,7 +16,7 @@ pub async fn authenticate(
|
||||
clean: bool,
|
||||
window_title: Option<String>,
|
||||
window_theme: AuthWindowTheme,
|
||||
mut openssl_conf: Option<NamedTempFile>,
|
||||
#[cfg(not(target_os = "macos"))] mut openssl_conf: Option<NamedTempFile>,
|
||||
) -> anyhow::Result<()> {
|
||||
let auth_host_id = gp_params.os_profile().host_identity().host_id().to_string();
|
||||
|
||||
@@ -43,8 +46,9 @@ pub async fn authenticate(
|
||||
Ok(())
|
||||
})
|
||||
.build(crate::tauri_context::get())?
|
||||
.run(move |_app_handle, event| {
|
||||
if let RunEvent::Exit = event {
|
||||
.run(move |_app_handle, _event| {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
if let RunEvent::Exit = _event {
|
||||
if let Some(file) = openssl_conf.take() {
|
||||
if let Err(err) = file.close() {
|
||||
info!("Error closing OpenSSL config file: {}", err);
|
||||
|
||||
@@ -11,13 +11,17 @@ common = { path = "../../crates/common" }
|
||||
gpapi = { path = "../../crates/gpapi", features = ["clap"] }
|
||||
gphip = { path = "../../crates/gphip" }
|
||||
openconnect = { path = "../../crates/openconnect" }
|
||||
gptunnel = { path = "../../crates/gptunnel" }
|
||||
|
||||
anyhow.workspace = true
|
||||
clap.workspace = true
|
||||
env_logger.workspace = true
|
||||
inquire = "0.9"
|
||||
log.workspace = true
|
||||
nix = { version = "0.31", features = ["fs", "signal", "process"] }
|
||||
nix = { version = "0.31", features = ["fs", "signal", "process", "poll", "term"] }
|
||||
ratatui = { version = "=0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
|
||||
crossterm = { version = "0.29", features = ["use-dev-tty"] }
|
||||
strip-ansi-escapes = "0.2"
|
||||
tokio = { workspace = true, features = ["rt-multi-thread"] }
|
||||
tokio-util.workspace = true
|
||||
sysinfo.workspace = true
|
||||
@@ -33,3 +37,6 @@ uzers.workspace = true
|
||||
[features]
|
||||
default = ["webview-auth"]
|
||||
webview-auth = ["gpapi/webview-auth"]
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
gpvpnc = { path = "../../crates/gpvpnc" }
|
||||
@@ -5,13 +5,15 @@ use std::{
|
||||
|
||||
use anyhow::bail;
|
||||
use clap::{Parser, Subcommand};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use gpapi::utils::openssl;
|
||||
use gpapi::{
|
||||
clap::{Args, InfoLevelVerbosity, handle_error},
|
||||
log_format::{LogFormat, write_json_record},
|
||||
utils::openssl,
|
||||
};
|
||||
use log::info;
|
||||
use sysinfo::{Pid, System};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use tempfile::NamedTempFile;
|
||||
use tokio::fs;
|
||||
|
||||
@@ -34,6 +36,7 @@ const VERSION: &str = concat!(
|
||||
);
|
||||
|
||||
pub(crate) struct SharedArgs<'a> {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
pub(crate) fix_openssl: bool,
|
||||
pub(crate) ignore_tls_errors: bool,
|
||||
pub(crate) lock_file: &'a Path,
|
||||
@@ -92,6 +95,7 @@ struct Cli {
|
||||
#[command(subcommand)]
|
||||
command: CliCommand,
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[arg(
|
||||
long,
|
||||
help = "Uses extended compatibility mode for OpenSSL operations to support a broader range of systems and formats."
|
||||
@@ -123,6 +127,7 @@ struct Cli {
|
||||
}
|
||||
|
||||
impl Args for Cli {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> bool {
|
||||
self.fix_openssl
|
||||
}
|
||||
@@ -164,6 +169,7 @@ impl Cli {
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> anyhow::Result<Option<NamedTempFile>> {
|
||||
if self.fix_openssl {
|
||||
let file = openssl::fix_openssl_env()?;
|
||||
@@ -174,6 +180,11 @@ impl Cli {
|
||||
}
|
||||
|
||||
async fn run(&self) -> anyhow::Result<()> {
|
||||
if let CliCommand::Connect(args) = &self.command {
|
||||
if args.dashboard {
|
||||
crate::dashboard::validate(self.log_format)?;
|
||||
}
|
||||
}
|
||||
if self.background_worker_fd.is_some() && !matches!(&self.command, CliCommand::Connect(args) if args.background) {
|
||||
bail!("Background worker requires connect --background");
|
||||
}
|
||||
@@ -205,8 +216,10 @@ impl Cli {
|
||||
|
||||
// The temp file will be dropped automatically when the file handle is dropped
|
||||
// So, declare it here to ensure it's not dropped
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let _file = self.fix_openssl()?;
|
||||
let shared_args = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: self.fix_openssl,
|
||||
ignore_tls_errors: self.ignore_tls_errors,
|
||||
lock_file: &self.lock_file,
|
||||
@@ -263,7 +276,13 @@ fn build_logger(cli: &Cli) -> env_logger::Builder {
|
||||
pub(crate) async fn run() {
|
||||
let cli = Cli::parse();
|
||||
|
||||
build_logger(&cli).init();
|
||||
if matches!(&cli.command, CliCommand::Connect(args) if args.dashboard) {
|
||||
let logger = build_logger(&cli).build();
|
||||
log::set_max_level(logger.filter());
|
||||
log::set_boxed_logger(Box::new(crate::dashboard::NoticeLogger::new(logger))).expect("failed to initialize logger");
|
||||
} else {
|
||||
build_logger(&cli).init();
|
||||
}
|
||||
|
||||
info!("gpclient started: {}", VERSION);
|
||||
|
||||
@@ -325,10 +344,42 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dashboard_is_opt_in_and_conflicts_with_noninteractive_connection_modes() {
|
||||
for option in ["--background", "--cookie-only"] {
|
||||
assert!(Cli::try_parse_from(["gpclient", "connect", "portal.example.com", "--dashboard", option]).is_err());
|
||||
}
|
||||
assert!(Cli::try_parse_from(["gpclient", "connect", "portal.example.com", "--stats"]).is_err());
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpclient",
|
||||
"connect",
|
||||
"portal.example.com",
|
||||
"--dashboard",
|
||||
"--cookie-on-stdin",
|
||||
])
|
||||
.unwrap();
|
||||
assert!(matches!(cli.command, CliCommand::Connect(args) if args.dashboard));
|
||||
let cli = Cli::try_parse_from(["gpclient", "connect", "portal.example.com"]).unwrap();
|
||||
assert!(matches!(cli.command, CliCommand::Connect(args) if !args.dashboard));
|
||||
assert!(
|
||||
crate::dashboard::validate(LogFormat::Json)
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.contains("--log-format json")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openssl_option_is_available_only_on_supported_platforms() {
|
||||
let result = Cli::try_parse_from(["gpclient", "--fix-openssl", "diagnostics"]);
|
||||
assert_eq!(result.is_ok(), !cfg!(target_os = "macos"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diagnostics_accepts_output_options_and_runs_alongside_the_client() {
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpclient",
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
"--fix-openssl",
|
||||
"diagnostics",
|
||||
"--json",
|
||||
@@ -501,6 +552,40 @@ mod tests {
|
||||
captured.contents()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_property_log_filters_keep_matching_and_excluding_records() {
|
||||
for (pattern, matching, excluded) in [
|
||||
(r"\p{Greek}", "α", "plain ASCII"),
|
||||
(r"\p{Mark}", "\u{0301}", "plain ASCII"),
|
||||
(r"\p{Alphabetic}", "α", "123"),
|
||||
(r"\p{Grapheme_Extend}", "\u{0301}", "plain ASCII"),
|
||||
] {
|
||||
let captured = Captured::default();
|
||||
let logger = build_logger(&parse_cli(&["gpclient", "disconnect"]))
|
||||
.parse_filters(&format!("info/{pattern}"))
|
||||
.target(env_logger::Target::Pipe(Box::new(captured.clone())))
|
||||
.build();
|
||||
for message in [excluded, matching] {
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(log::Level::Info)
|
||||
.target("gpclient")
|
||||
.args(format_args!("{message}"))
|
||||
.build(),
|
||||
);
|
||||
}
|
||||
let output = captured.contents();
|
||||
assert!(
|
||||
output.contains(matching),
|
||||
"filter {pattern} dropped its matching record"
|
||||
);
|
||||
assert!(
|
||||
!output.contains(excluded),
|
||||
"filter {pattern} allowed an excluded record"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The point of the flag: with `json`, a caller gets fields, and gets them one
|
||||
/// record per line so the stream can be read incrementally.
|
||||
#[test]
|
||||
|
||||
@@ -20,6 +20,13 @@ pub(crate) struct ConnectArgs {
|
||||
)]
|
||||
pub(crate) background: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
conflicts_with_all = ["background", "cookie_only"],
|
||||
help = "Show an interactive connection dashboard after sign-in (requires a foreground terminal)"
|
||||
)]
|
||||
pub(crate) dashboard: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
requires = "background",
|
||||
@@ -158,13 +165,13 @@ pub(crate) struct ConnectArgs {
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Use external browser authentication. With no value, auto-select Chrome, Firefox, then system default. Use `default` for the system default browser or `remote` for headless servers.",
|
||||
help = "Use a browser; omit the value to auto-select. Use `manual` to open the URL and paste the callback.",
|
||||
default_missing_value = "auto",
|
||||
num_args=0..=1
|
||||
)]
|
||||
pub(super) browser: Option<String>,
|
||||
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser remote'")]
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser manual'")]
|
||||
pub(super) browser_listen: Option<IpAddr>,
|
||||
|
||||
#[arg(
|
||||
@@ -299,7 +306,7 @@ mod tests {
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--browser",
|
||||
"remote",
|
||||
"manual",
|
||||
"--browser-listen",
|
||||
"192.168.107.15",
|
||||
])
|
||||
|
||||
@@ -129,7 +129,6 @@ impl ConnectHandler<'_> {
|
||||
.gateway(is_gateway)
|
||||
.saml_request(prelogin.saml_request())
|
||||
.os_profile(&os_profile)
|
||||
.fix_openssl(self.shared_args.fix_openssl)
|
||||
.ignore_tls_errors(self.shared_args.ignore_tls_errors)
|
||||
.certificate(self.args.certificate.as_deref())
|
||||
.sslkey(self.args.sslkey.as_deref())
|
||||
@@ -139,6 +138,9 @@ impl ConnectHandler<'_> {
|
||||
.log_format(self.shared_args.log_format)
|
||||
.verbose(verbose);
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let auth_launcher = auth_launcher.fix_openssl(self.shared_args.fix_openssl);
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let use_default_browser = external_browser_supported && self.args.default_browser;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
|
||||
@@ -98,6 +98,7 @@ async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -143,6 +144,7 @@ async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_reject
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -190,6 +192,7 @@ async fn rendering_recovery_fetches_new_prelogin_metadata_and_preserves_gateway_
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -224,6 +227,7 @@ async fn cancellation_during_recovery_prelogin_stops_request() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -291,6 +295,7 @@ async fn auth_crash_uses_fresh_saml_and_clean_once_with_shared_budget() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -350,6 +355,7 @@ async fn exhausted_auth_recovery_is_terminal_before_portal_gateway_fallback() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -497,6 +503,7 @@ printf '%s\n' '{"success":{"username":"alice","preloginCookie":"new-cookie"}}'
|
||||
let lock = directory.join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
|
||||
@@ -20,14 +20,14 @@ use gpapi::{
|
||||
};
|
||||
use inquire::Text;
|
||||
use log::{Level, info, warn};
|
||||
use openconnect::{HipScript, HipSource, Vpn, VpnBuilder};
|
||||
use openconnect::{HipScript, HipSource, VpnBuilder};
|
||||
use tokio::{runtime::Handle, task::JoinHandle};
|
||||
|
||||
use crate::session::{
|
||||
SessionContextInput, build_session_context, session_info_from_vpn, spawn_session_runtime_with_info,
|
||||
};
|
||||
|
||||
use super::{ConnectHandler, args::cookie_cache_path};
|
||||
use super::{ConnectHandler, args::cookie_cache_path, vpn_script};
|
||||
|
||||
const OPENCONNECT_INTERRUPTED_EXIT_CODE: i32 = -4;
|
||||
|
||||
@@ -443,10 +443,8 @@ impl ConnectHandler<'_> {
|
||||
disable_ipv6: self.args.disable_ipv6,
|
||||
extension_auth: Some(extension_auth),
|
||||
});
|
||||
let vpn_builder = Vpn::builder(gateway, cookie)
|
||||
.script(self.args.script.clone())
|
||||
let vpn_builder = vpn_script::builder(gateway, cookie, self.args)
|
||||
.interface(self.args.interface.clone())
|
||||
.script_tun(self.args.script_tun)
|
||||
.certificate(certificate)
|
||||
.sslkey(sslkey)
|
||||
.key_password(key_password)
|
||||
@@ -458,15 +456,6 @@ impl ConnectHandler<'_> {
|
||||
.local_hostname(self.args.local_hostname.clone())
|
||||
.dpd_interval(self.args.dpd_interval.unwrap_or(0))
|
||||
.no_xmlpost(self.args.no_xmlpost);
|
||||
#[cfg(target_os = "macos")]
|
||||
let vpn_builder = if self.args.script.is_none()
|
||||
&& std::env::var_os("GP_VPNC_SCRIPT").is_none_or(|value| value.is_empty())
|
||||
&& let Some(script) = common::binary_paths::bundled_vpnc_script()
|
||||
{
|
||||
vpn_builder.script_path(script.to_string_lossy().into_owned())
|
||||
} else {
|
||||
vpn_builder
|
||||
};
|
||||
let vpn = apply_os_profile(vpn_builder, &os_profile)
|
||||
.build()
|
||||
.map_err(|err| GatewayConnectError::before_establishment(err.into()))?;
|
||||
@@ -491,6 +480,16 @@ impl ConnectHandler<'_> {
|
||||
.transpose()
|
||||
.map_err(GatewayConnectError::before_establishment)?;
|
||||
|
||||
let mut dashboard = if self.args.dashboard {
|
||||
Some(
|
||||
crate::dashboard::Dashboard::prepare(gateway.to_owned(), self.cancellation.clone())
|
||||
.map_err(GatewayConnectError::before_establishment)?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let monitor = gptunnel::TunnelMonitor::attach(vpn.clone());
|
||||
|
||||
let disconnect_task = tokio::spawn(async move {
|
||||
cancellation.cancelled().await;
|
||||
info!("Received the interrupt signal, disconnecting...");
|
||||
@@ -523,7 +522,7 @@ impl ConnectHandler<'_> {
|
||||
session_task_on_connect.lock().unwrap().replace(task);
|
||||
})
|
||||
});
|
||||
let mut background_error = None;
|
||||
let mut output_error = None;
|
||||
let connect_result = tokio::select! {
|
||||
result = &mut worker => result,
|
||||
established = established_rx => {
|
||||
@@ -537,6 +536,12 @@ impl ConnectHandler<'_> {
|
||||
self.logout_gateway(&server).await;
|
||||
}
|
||||
}, || {
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.start_tunnel(monitor.clone()) {
|
||||
self.cancellation.cancel();
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
if let (Some(background), Some(stdio)) = (&self.background, &mut background_stdio) {
|
||||
let detach = if self.pid_written.load(Ordering::SeqCst) {
|
||||
background.detach(stdio)
|
||||
@@ -545,7 +550,7 @@ impl ConnectHandler<'_> {
|
||||
};
|
||||
if let Err(error) = detach {
|
||||
self.cancellation.cancel();
|
||||
background_error = Some(error);
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
}).await
|
||||
@@ -554,6 +559,12 @@ impl ConnectHandler<'_> {
|
||||
}
|
||||
}
|
||||
};
|
||||
monitor.stop().await;
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.finish() {
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
|
||||
disconnect_task.abort();
|
||||
let _ = disconnect_task.await;
|
||||
@@ -564,7 +575,7 @@ impl ConnectHandler<'_> {
|
||||
let _ = task.await;
|
||||
}
|
||||
|
||||
if let Some(error) = background_error {
|
||||
if let Some(error) = output_error {
|
||||
return Err(GatewayConnectError::after_establishment(error));
|
||||
}
|
||||
|
||||
|
||||
@@ -112,6 +112,18 @@ impl ConnectHandler<'_> {
|
||||
let source = Arc::new(source);
|
||||
let validate_network = network.clone();
|
||||
let validate_detection = detection.clone();
|
||||
let members = crate::dashboard::InternalMembers::default();
|
||||
let dashboard_members = members.clone();
|
||||
let (established_tx, established_rx) = tokio::sync::oneshot::channel();
|
||||
let established_tx = std::sync::Mutex::new(Some(established_tx));
|
||||
let mut dashboard = if self.args.dashboard {
|
||||
Some(crate::dashboard::Dashboard::prepare(
|
||||
authenticated[0].0.server().to_owned(),
|
||||
cancellation.clone(),
|
||||
)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let callbacks = SessionCallbacks {
|
||||
produce_report: Arc::new(move |request, control| {
|
||||
control.check()?;
|
||||
@@ -143,12 +155,23 @@ impl ConnectHandler<'_> {
|
||||
)
|
||||
}),
|
||||
report_submitted: Arc::new(|_, _| {}),
|
||||
status_changed: Arc::new(|member| match member.maintenance {
|
||||
MaintenanceState::Healthy => info!(
|
||||
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
|
||||
member.gateway, member.client_ip, member.client_ipv6
|
||||
),
|
||||
state => info!("Internal gateway {}: {state:?}", member.gateway),
|
||||
status_changed: Arc::new(move |member| {
|
||||
match member.maintenance {
|
||||
MaintenanceState::Healthy => {
|
||||
info!(
|
||||
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
|
||||
member.gateway, member.client_ip, member.client_ipv6
|
||||
);
|
||||
if let Some(established) = established_tx.lock().unwrap().take() {
|
||||
let _ = established.send(());
|
||||
}
|
||||
}
|
||||
state => info!("Internal gateway {}: {state:?}", member.gateway),
|
||||
}
|
||||
members.lock().unwrap().insert(
|
||||
member.gateway.server().to_owned(),
|
||||
format!("{}: {:?}", member.gateway, member.maintenance),
|
||||
);
|
||||
}),
|
||||
validate_network: Arc::new(move |cancellation| {
|
||||
let network = validate_network.clone();
|
||||
@@ -183,13 +206,38 @@ impl ConnectHandler<'_> {
|
||||
std::sync::atomic::Ordering::SeqCst,
|
||||
);
|
||||
let mut sessions = self.sessions.take();
|
||||
let result = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
|
||||
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
|
||||
})
|
||||
.await;
|
||||
let mut dashboard_error = None;
|
||||
let result = {
|
||||
let maintenance = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
|
||||
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
|
||||
});
|
||||
tokio::pin!(maintenance);
|
||||
tokio::select! {
|
||||
result = &mut maintenance => result,
|
||||
established = established_rx => {
|
||||
if established.is_ok() {
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.start_internal(dashboard_members) {
|
||||
self.cancellation.cancel();
|
||||
dashboard_error = Some(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
maintenance.await
|
||||
}
|
||||
}
|
||||
};
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.finish() {
|
||||
dashboard_error = Some(error);
|
||||
}
|
||||
}
|
||||
self.sessions.replace(sessions);
|
||||
monitor_cancel.cancel();
|
||||
monitor.await.context("Internal network monitor failed")?;
|
||||
if let Some(error) = dashboard_error {
|
||||
return Err(error);
|
||||
}
|
||||
match result? {
|
||||
SessionExit::Disconnected => Ok(()),
|
||||
SessionExit::Failed(reason) => bail!("Internal session ended: {reason:?}. Connect again to authenticate."),
|
||||
|
||||
@@ -4,6 +4,7 @@ mod credential;
|
||||
mod flow_tests;
|
||||
mod gateway;
|
||||
mod internal;
|
||||
mod vpn_script;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::sync::{
|
||||
@@ -153,9 +154,9 @@ impl<'a> ConnectHandler<'a> {
|
||||
|
||||
async fn handle_attempt(&self) -> anyhow::Result<()> {
|
||||
if self.args.browser_listen.is_some()
|
||||
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("remote"))
|
||||
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("manual") || browser.eq_ignore_ascii_case("remote"))
|
||||
{
|
||||
bail!("The '--browser-listen' option requires '--browser remote'");
|
||||
bail!("The '--browser-listen' option requires '--browser manual'");
|
||||
}
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -178,11 +179,18 @@ impl<'a> ConnectHandler<'a> {
|
||||
{
|
||||
return Err(err);
|
||||
}
|
||||
let Some(root_cause) = err.root_cause().downcast_ref::<RequestIdentityError>() else {
|
||||
let Some(identity_error) = err.downcast_ref::<RequestIdentityError>() else {
|
||||
return Err(err);
|
||||
};
|
||||
|
||||
match root_cause {
|
||||
match identity_error {
|
||||
RequestIdentityError::UnsupportedEncryption
|
||||
| RequestIdentityError::LegacyKeyConversion(_)
|
||||
| RequestIdentityError::UnsupportedKeyFormat
|
||||
| RequestIdentityError::InvalidKey
|
||||
| RequestIdentityError::InvalidCertificate
|
||||
| RequestIdentityError::IncompletePkcs12
|
||||
| RequestIdentityError::InvalidPkcs12(_) => return Err(err),
|
||||
RequestIdentityError::NoKey => {
|
||||
let format = self.shared_args.log_format;
|
||||
report(
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
|
||||
use crate::connect::ConnectArgs;
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> VpnBuilder {
|
||||
Vpn::builder(server, cookie)
|
||||
.script(args.script.clone())
|
||||
.script_tun(args.script_tun)
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
use std::ffi::OsStr;
|
||||
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
|
||||
use crate::connect::ConnectArgs;
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> VpnBuilder {
|
||||
let configured_script = std::env::var_os("GP_VPNC_SCRIPT");
|
||||
configure_builder(server, cookie, args, configured_script.as_deref())
|
||||
}
|
||||
|
||||
fn configure_builder(server: &str, cookie: &str, args: &ConnectArgs, configured_script: Option<&OsStr>) -> VpnBuilder {
|
||||
let builder = Vpn::builder(server, cookie)
|
||||
.script(args.script.clone())
|
||||
.script_tun(args.script_tun);
|
||||
let has_environment_script = configured_script.is_some_and(|value| !value.is_empty());
|
||||
if args.script.is_none() && !args.script_tun && !has_environment_script {
|
||||
builder.network_configuration_handler(|configuration| {
|
||||
gpvpnc::macos::configure_network(&configuration.reason, &configuration.environment)
|
||||
})
|
||||
} else {
|
||||
builder
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use clap::Parser;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct TestCli {
|
||||
#[command(flatten)]
|
||||
args: ConnectArgs,
|
||||
}
|
||||
|
||||
fn args(options: &[&str]) -> ConnectArgs {
|
||||
TestCli::try_parse_from(
|
||||
["connect", "vpn.example.com"]
|
||||
.into_iter()
|
||||
.chain(options.iter().copied()),
|
||||
)
|
||||
.unwrap()
|
||||
.args
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_does_not_require_an_installed_script() {
|
||||
for configured in [None, Some(OsStr::new(""))] {
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&[]), configured)
|
||||
.build()
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&[]), configured)
|
||||
.script("/bin/sh".to_string())
|
||||
.script_tun(true)
|
||||
.build()
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_commands_and_script_tunnels_remain_supported() {
|
||||
for options in [
|
||||
vec!["--script", "exec /bin/sh"],
|
||||
vec!["--script", "/bin/sh", "--script-tun"],
|
||||
] {
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&options), None)
|
||||
.build()
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn environment_override_does_not_install_default_callback() {
|
||||
let builder = configure_builder("server", "cookie", &args(&[]), Some(OsStr::new("/bin/sh")));
|
||||
// Converting the selected builder to an explicit packet script would fail
|
||||
// if the embedded configuration callback had replaced the environment override.
|
||||
assert!(builder.script("/bin/sh".to_string()).script_tun(true).build().is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "macos.rs"]
|
||||
mod platform;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[path = "default.rs"]
|
||||
mod platform;
|
||||
|
||||
pub(super) use platform::builder;
|
||||
@@ -0,0 +1,625 @@
|
||||
//! Dashboard presentation only; connection ownership and sampling stay outside this module.
|
||||
use crossterm::event::KeyCode;
|
||||
use gpapi::session::tunnel::{TunnelList, TunnelPhase, TunnelState, TunnelStatisticsSnapshot, TunnelStatisticsState};
|
||||
use ratatui::{
|
||||
Frame,
|
||||
buffer::Buffer,
|
||||
layout::Rect,
|
||||
style::{Color, Modifier, Style},
|
||||
text::{Line, Span},
|
||||
widgets::{Paragraph, Widget, Wrap},
|
||||
};
|
||||
|
||||
use super::output::plain_text;
|
||||
|
||||
const MAX_CONTENT_WIDTH: u16 = 120;
|
||||
const LABEL_WIDTH: usize = 12;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct DetailScroll {
|
||||
offset: u16,
|
||||
maximum: u16,
|
||||
page: u16,
|
||||
}
|
||||
|
||||
impl DetailScroll {
|
||||
pub(super) fn handle_key(&mut self, key: KeyCode) {
|
||||
self.offset = match key {
|
||||
KeyCode::Up => self.offset.saturating_sub(1),
|
||||
KeyCode::Down => self.offset.saturating_add(1),
|
||||
KeyCode::PageUp => self.offset.saturating_sub(self.page),
|
||||
KeyCode::PageDown => self.offset.saturating_add(self.page),
|
||||
KeyCode::Home => 0,
|
||||
KeyCode::End => self.maximum,
|
||||
_ => self.offset,
|
||||
}
|
||||
.min(self.maximum);
|
||||
}
|
||||
|
||||
pub(super) fn can_scroll(&self) -> bool {
|
||||
self.maximum > 0
|
||||
}
|
||||
|
||||
fn update(&mut self, content_height: u16, viewport_height: u16) {
|
||||
self.maximum = if viewport_height == 0 {
|
||||
0
|
||||
} else {
|
||||
content_height.saturating_sub(viewport_height)
|
||||
};
|
||||
self.offset = self.offset.min(self.maximum);
|
||||
self.page = viewport_height.saturating_sub(1).max(1);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn phase_label(phase: TunnelPhase) -> &'static str {
|
||||
match phase {
|
||||
TunnelPhase::Establishing => "Establishing",
|
||||
TunnelPhase::Connected => "Connected",
|
||||
TunnelPhase::Reconnecting => "Reconnecting",
|
||||
TunnelPhase::Ended => "Disconnected",
|
||||
}
|
||||
}
|
||||
|
||||
fn uptime(milliseconds: u64) -> String {
|
||||
let seconds = milliseconds / 1000;
|
||||
format!("{:02}:{:02}:{:02}", seconds / 3600, (seconds / 60) % 60, seconds % 60)
|
||||
}
|
||||
|
||||
fn bytes(value: u64) -> String {
|
||||
const UNITS: [&str; 7] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];
|
||||
let mut amount = value as f64;
|
||||
let mut unit = 0;
|
||||
while amount >= 1024.0 && unit < UNITS.len() - 1 {
|
||||
amount /= 1024.0;
|
||||
unit += 1;
|
||||
}
|
||||
if unit == 0 {
|
||||
format!("{value} B")
|
||||
} else {
|
||||
format!("{amount:.1} {}", UNITS[unit])
|
||||
}
|
||||
}
|
||||
|
||||
fn muted(text: impl Into<String>) -> Span<'static> {
|
||||
Span::styled(text.into(), Style::default().fg(Color::DarkGray))
|
||||
}
|
||||
|
||||
fn heading(text: impl Into<String>) -> Line<'static> {
|
||||
Line::styled(
|
||||
text.into(),
|
||||
Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn row(label: &str, value: impl Into<String>) -> Line<'static> {
|
||||
Line::from(vec![
|
||||
muted(format!("{label:<LABEL_WIDTH$} ")),
|
||||
Span::raw(plain_text(value.into().as_bytes())),
|
||||
])
|
||||
}
|
||||
|
||||
fn paragraph(lines: Vec<Line<'static>>) -> Paragraph<'static> {
|
||||
Paragraph::new(lines).wrap(Wrap { trim: false })
|
||||
}
|
||||
|
||||
fn summary(server: &str, state: &TunnelState, width: u16) -> Paragraph<'static> {
|
||||
let status = Span::styled(
|
||||
format!("{:<LABEL_WIDTH$} ", phase_label(state.phase)),
|
||||
Style::default().fg(if state.phase == TunnelPhase::Connected {
|
||||
Color::Green
|
||||
} else {
|
||||
Color::Yellow
|
||||
}),
|
||||
);
|
||||
let mut lines = if width >= 64 {
|
||||
vec![Line::from(vec![
|
||||
status,
|
||||
Span::raw(format!(
|
||||
"{} Uptime {}",
|
||||
state.transport.label(),
|
||||
uptime(state.elapsed_ms)
|
||||
)),
|
||||
])]
|
||||
} else {
|
||||
vec![
|
||||
Line::from(status),
|
||||
row("Transport", state.transport.label()),
|
||||
row("Uptime", uptime(state.elapsed_ms)),
|
||||
]
|
||||
};
|
||||
lines.insert(0, row("Server", server));
|
||||
paragraph(lines)
|
||||
}
|
||||
|
||||
fn traffic(statistics: &TunnelStatisticsSnapshot, width: u16) -> Paragraph<'static> {
|
||||
let mut lines = vec![heading("TRAFFIC")];
|
||||
if let Some(view) = statistics.view() {
|
||||
let label = match view.state {
|
||||
TunnelStatisticsState::Disabled => "disabled",
|
||||
TunnelStatisticsState::Waiting => "waiting for sample",
|
||||
TunnelStatisticsState::Fresh => "live",
|
||||
TunnelStatisticsState::Stale => "stale",
|
||||
TunnelStatisticsState::Ended => "ended",
|
||||
};
|
||||
lines[0] = heading(format!("TRAFFIC · {label}"));
|
||||
if let Some(sample) = &view.sample {
|
||||
if width >= 56 {
|
||||
let rows = [
|
||||
("Bytes", bytes(sample.received_bytes), bytes(sample.sent_bytes)),
|
||||
(
|
||||
"Packets",
|
||||
sample.received_packets.to_string(),
|
||||
sample.sent_packets.to_string(),
|
||||
),
|
||||
];
|
||||
// Size to the values, while keeping room for full u64 counters and a
|
||||
// visible gap even when both numeric columns are filled.
|
||||
let numeric_width = rows
|
||||
.iter()
|
||||
.flat_map(|(_, received, sent)| [received.len(), sent.len()])
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
.max(10);
|
||||
lines.push(Line::from(muted(format!(
|
||||
"{:<10}{:>numeric_width$} {:>numeric_width$}",
|
||||
"", "Received", "Sent"
|
||||
))));
|
||||
for (label, received, sent) in rows {
|
||||
lines.push(Line::from(vec![
|
||||
muted(format!("{label:<10}")),
|
||||
Span::raw(format!("{received:>numeric_width$} {sent:>numeric_width$}")),
|
||||
]));
|
||||
}
|
||||
} else {
|
||||
lines.push(row("Received", bytes(sample.received_bytes)));
|
||||
lines.push(row("Sent", bytes(sample.sent_bytes)));
|
||||
lines.push(row("Packets in", sample.received_packets.to_string()));
|
||||
lines.push(row("Packets out", sample.sent_packets.to_string()));
|
||||
}
|
||||
if view.state != TunnelStatisticsState::Fresh {
|
||||
if let Some(age) = view.sample_age_ms {
|
||||
lines.push(row("Sample age", format!("{} seconds", age / 1000)));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
lines.push(row("Statistics", "unavailable"));
|
||||
}
|
||||
paragraph(lines)
|
||||
}
|
||||
|
||||
fn list_rows(lines: &mut Vec<Line<'static>>, label: &str, value: &TunnelList) {
|
||||
if value.items.is_empty() && !value.truncated {
|
||||
lines.push(row(label, "none"));
|
||||
} else {
|
||||
for (index, item) in value.items.iter().enumerate() {
|
||||
lines.push(row(if index == 0 { label } else { "" }, item));
|
||||
}
|
||||
if value.truncated {
|
||||
lines.push(row("", format!("[truncated; {} total]", value.total_count)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn routes(lines: &mut Vec<Line<'static>>, label: &str, list: &TunnelList, width: u16) {
|
||||
lines.push(row(label, list.total_count.to_string()));
|
||||
// Only whole entries move between columns. Long individual entries wrap through
|
||||
// Paragraph rather than disappearing off the edge of a narrow terminal.
|
||||
let entries: Vec<_> = list.items.iter().map(|item| plain_text(item.as_bytes())).collect();
|
||||
let cell_width = entries.iter().map(|item| Line::raw(item).width()).max().unwrap_or(0) + 3;
|
||||
let columns = (width as usize / cell_width).clamp(1, 3);
|
||||
for chunk in entries.chunks(columns) {
|
||||
let mut spans = Vec::new();
|
||||
for (index, entry) in chunk.iter().enumerate() {
|
||||
spans.push(Span::raw(entry.clone()));
|
||||
if index + 1 < chunk.len() {
|
||||
spans.push(Span::raw(" ".repeat(cell_width - Line::raw(entry).width())));
|
||||
}
|
||||
}
|
||||
lines.push(Line::from(spans));
|
||||
}
|
||||
if list.truncated {
|
||||
lines.push(Line::raw(format!(
|
||||
"[truncated; showing {} of {}]",
|
||||
list.items.len(),
|
||||
list.total_count
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
fn details(state: &TunnelState, statistics: &TunnelStatisticsSnapshot, width: u16) -> Buffer {
|
||||
let traffic = traffic(statistics, width);
|
||||
let traffic_height = traffic.line_count(width) as u16;
|
||||
let mut tunnel = vec![heading("TUNNEL")];
|
||||
let mut dns = vec![heading("DNS")];
|
||||
let mut route_lines = vec![heading("ROUTES")];
|
||||
if let Some(config) = &state.configuration {
|
||||
tunnel.extend([
|
||||
row("Interface", config.interface.as_deref().unwrap_or("none")),
|
||||
row(
|
||||
"IPv4",
|
||||
config
|
||||
.ipv4
|
||||
.as_ref()
|
||||
.map(|address| address.display())
|
||||
.unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
row(
|
||||
"IPv6",
|
||||
config
|
||||
.ipv6
|
||||
.as_ref()
|
||||
.map(|address| address.display())
|
||||
.unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
row("Gateway", config.server_ip.as_deref().unwrap_or("none")),
|
||||
row(
|
||||
"MTU",
|
||||
config.mtu.map(|mtu| mtu.to_string()).unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
]);
|
||||
list_rows(&mut dns, "Servers", &config.dns);
|
||||
list_rows(&mut dns, "Domains", &config.search_domains);
|
||||
list_rows(&mut dns, "Split DNS", &config.split_dns);
|
||||
routes(&mut route_lines, "Included", &config.included_routes, width);
|
||||
routes(&mut route_lines, "Excluded", &config.excluded_routes, width);
|
||||
if config.truncated {
|
||||
route_lines.push(row("Configuration", "truncated"));
|
||||
}
|
||||
} else {
|
||||
tunnel.push(row("Configuration", "unavailable"));
|
||||
}
|
||||
let tunnel = paragraph(tunnel);
|
||||
let dns = paragraph(dns);
|
||||
let routes = paragraph(route_lines);
|
||||
let columns = width >= 88;
|
||||
let column_width = if columns { (width - 4) / 2 } else { width };
|
||||
let tunnel_height = tunnel.line_count(column_width) as u16;
|
||||
let dns_height = dns.line_count(column_width) as u16;
|
||||
let network_height = if columns {
|
||||
tunnel_height.max(dns_height)
|
||||
} else {
|
||||
tunnel_height + 1 + dns_height
|
||||
};
|
||||
let network_y = traffic_height + 1;
|
||||
let routes_y = network_y + network_height + 1;
|
||||
let height = routes_y + routes.line_count(width) as u16;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, width, height));
|
||||
traffic.render(Rect::new(0, 0, width, traffic_height), &mut buffer);
|
||||
tunnel.render(Rect::new(0, network_y, column_width, tunnel_height), &mut buffer);
|
||||
let (dns_x, dns_y) = if columns {
|
||||
(column_width + 4, network_y)
|
||||
} else {
|
||||
(0, network_y + tunnel_height + 1)
|
||||
};
|
||||
dns.render(Rect::new(dns_x, dns_y, column_width, dns_height), &mut buffer);
|
||||
routes.render(Rect::new(0, routes_y, width, height - routes_y), &mut buffer);
|
||||
buffer
|
||||
}
|
||||
|
||||
pub(super) fn render_tunnel(
|
||||
frame: &mut Frame,
|
||||
area: Rect,
|
||||
server: &str,
|
||||
state: &TunnelState,
|
||||
statistics: &TunnelStatisticsSnapshot,
|
||||
scroll: &mut DetailScroll,
|
||||
) {
|
||||
if area.is_empty() {
|
||||
return;
|
||||
}
|
||||
let area = Rect {
|
||||
width: area.width.min(MAX_CONTENT_WIDTH),
|
||||
..area
|
||||
};
|
||||
let full_summary = summary(server, state, area.width);
|
||||
let summary = if full_summary.line_count(area.width) + 2 > area.height as usize {
|
||||
Paragraph::new(phase_label(state.phase))
|
||||
} else {
|
||||
full_summary
|
||||
};
|
||||
let summary_height = (summary.line_count(area.width) as u16).min(area.height);
|
||||
frame.render_widget(summary, Rect::new(area.x, area.y, area.width, summary_height));
|
||||
let body_y = summary_height.saturating_add(1).min(area.height);
|
||||
let viewport = Rect::new(area.x, area.y + body_y, area.width, area.height - body_y);
|
||||
let buffer = details(state, statistics, area.width);
|
||||
scroll.update(buffer.area.height, viewport.height);
|
||||
// Render the full detail layout with Ratatui, then expose just the scrolled rows.
|
||||
// This preserves wrapped fields and aligned columns through terminal resizes.
|
||||
for y in 0..viewport.height {
|
||||
if y + scroll.offset >= buffer.area.height {
|
||||
break;
|
||||
}
|
||||
for x in 0..viewport.width {
|
||||
frame.buffer_mut()[(viewport.x + x, viewport.y + y)] = buffer[(x, y + scroll.offset)].clone();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use gpapi::session::tunnel::{TunnelStatistics, TunnelStatisticsView, TunnelTransport};
|
||||
use ratatui::{Terminal, backend::TestBackend};
|
||||
|
||||
use super::*;
|
||||
|
||||
fn state() -> TunnelState {
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"tunnelId": "00000000-0000-0000-0000-000000000001",
|
||||
"sequence": "1", "phase": "connected", "configurationRevision": "1",
|
||||
"transport": "ipsecEsp", "elapsedMs": "177000",
|
||||
"configuration": {
|
||||
"interface": "tun0", "serverIp": "220.191.185.154",
|
||||
"ipv4": {"address": "10.197.121.152", "prefixLength": 32, "netmask": null},
|
||||
"ipv6": null, "mtu": 1439, "truncated": false,
|
||||
"dns": {"items": ["10.197.82.140", "10.15.70.11"], "totalCount": 2, "truncated": false},
|
||||
"searchDomains": {"items": ["corp.microstrategy.com"], "totalCount": 1, "truncated": false},
|
||||
"splitDns": {"items": [], "totalCount": 0, "truncated": false},
|
||||
"includedRoutes": {"items": ["10.15.70.11/32", "10.197.82.140/32", "185.199.108.0/22", "2001:db8:1234:5678::/64"], "totalCount": 5, "truncated": true},
|
||||
"excludedRoutes": {"items": ["192.168.0.0/16"], "totalCount": 1, "truncated": false}
|
||||
}
|
||||
})).unwrap()
|
||||
}
|
||||
|
||||
fn statistics(state: &TunnelState) -> TunnelStatisticsSnapshot {
|
||||
TunnelStatisticsSnapshot::Available(TunnelStatisticsView {
|
||||
sequence: 1,
|
||||
tunnel_id: state.tunnel_id,
|
||||
state_sequence: 1,
|
||||
phase: state.phase,
|
||||
transport: TunnelTransport::IpsecEsp,
|
||||
state: TunnelStatisticsState::Fresh,
|
||||
elapsed_ms: state.elapsed_ms,
|
||||
sample_age_ms: Some(0),
|
||||
sample: Some(TunnelStatistics {
|
||||
tunnel_id: state.tunnel_id,
|
||||
sequence: 1,
|
||||
state_sequence: 1,
|
||||
configuration_revision: 1,
|
||||
elapsed_ms: state.elapsed_ms,
|
||||
received_bytes: 1_258_291,
|
||||
sent_bytes: 71_578,
|
||||
received_packets: u64::MAX,
|
||||
sent_packets: 702,
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
fn text(buffer: &Buffer) -> String {
|
||||
(0..buffer.area.height)
|
||||
.map(|y| {
|
||||
(0..buffer.area.width)
|
||||
.map(|x| buffer[(x, y)].symbol())
|
||||
.collect::<String>()
|
||||
.trim_end()
|
||||
.to_string()
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn server_and_transport_share_a_column_through_status_changes() {
|
||||
let mut state = state();
|
||||
for width in [40, 64, 120] {
|
||||
for phase in [
|
||||
TunnelPhase::Establishing,
|
||||
TunnelPhase::Connected,
|
||||
TunnelPhase::Reconnecting,
|
||||
TunnelPhase::Ended,
|
||||
] {
|
||||
state.phase = phase;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, width, 8));
|
||||
summary("vpn.example.com", &state, width).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
let server = rendered.lines().find(|line| line.contains("vpn.example.com")).unwrap();
|
||||
let transport = rendered.lines().find(|line| line.contains("IPsec (ESP)")).unwrap();
|
||||
assert_eq!(server.find("vpn.example.com"), Some(14));
|
||||
assert_eq!(
|
||||
transport.find("IPsec (ESP)"),
|
||||
server.find("vpn.example.com"),
|
||||
"{phase:?} at width {width}"
|
||||
);
|
||||
assert!(rendered.lines().any(|line| line.starts_with(phase_label(phase))));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wide_layout_groups_settings_and_keeps_routes_and_counters_intact() {
|
||||
let state = state();
|
||||
let buffer = details(&state, &statistics(&state), 100);
|
||||
let text = text(&buffer);
|
||||
let headings = text.lines().find(|line| line.starts_with("TUNNEL")).unwrap();
|
||||
assert!(headings.contains("DNS"));
|
||||
assert!(text.contains("18446744073709551615"));
|
||||
assert!(text.contains("1.2 MiB"));
|
||||
assert!(text.contains("69.9 KiB"));
|
||||
assert!(text.contains("2001:db8:1234:5678::/64"));
|
||||
assert!(text.contains("[truncated; showing 4 of 5]"));
|
||||
assert!(text.contains("192.168.0.0/16"));
|
||||
let received_column = text
|
||||
.lines()
|
||||
.find(|line| line.contains("Received"))
|
||||
.unwrap()
|
||||
.find("Received")
|
||||
.unwrap()
|
||||
+ "Received".len();
|
||||
let bytes_column = text
|
||||
.lines()
|
||||
.find(|line| line.starts_with("Bytes"))
|
||||
.unwrap()
|
||||
.find("1.2 MiB")
|
||||
.unwrap()
|
||||
+ "1.2 MiB".len();
|
||||
assert_eq!(received_column, bytes_column);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn traffic_columns_stay_compact_with_a_visible_gap() {
|
||||
let state = state();
|
||||
let mut stats = statistics(&state);
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut stats else {
|
||||
unreachable!()
|
||||
};
|
||||
view.sample.as_mut().unwrap().received_packets = 6518;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 120, 4));
|
||||
traffic(&stats, 120).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
for line in rendered.lines() {
|
||||
assert!(
|
||||
line.len() <= 40,
|
||||
"traffic row should not expand with the terminal: {line}"
|
||||
);
|
||||
}
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut stats else {
|
||||
unreachable!()
|
||||
};
|
||||
view.sample.as_mut().unwrap().received_packets = u64::MAX;
|
||||
view.sample.as_mut().unwrap().sent_packets = u64::MAX;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 56, 4));
|
||||
traffic(&stats, 56).render(buffer.area, &mut buffer);
|
||||
assert!(text(&buffer).contains("18446744073709551615 18446744073709551615"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wide_terminal_keeps_content_left_aligned_and_within_120_columns() {
|
||||
let state = state();
|
||||
let stats = statistics(&state);
|
||||
let mut terminal = Terminal::new(TestBackend::new(220, 40)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
let wide = terminal.backend().buffer().clone();
|
||||
terminal.backend_mut().resize(120, 40);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
for y in 0..40 {
|
||||
for x in 0..220 {
|
||||
if x < 120 {
|
||||
assert_eq!(wide[(x, y)], terminal.backend().buffer()[(x, y)]);
|
||||
} else {
|
||||
assert_eq!(wide[(x, y)].symbol(), " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn routes_use_at_most_three_columns_and_keep_every_entry() {
|
||||
let list = TunnelList {
|
||||
items: (1..=7).map(|n| format!("10.0.{n}.0/24")).collect(),
|
||||
total_count: 7,
|
||||
truncated: false,
|
||||
};
|
||||
let mut lines = Vec::new();
|
||||
routes(&mut lines, "Included", &list, 220);
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 220, 4));
|
||||
paragraph(lines).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
let route_rows: Vec<_> = rendered.lines().skip(1).collect();
|
||||
assert_eq!(route_rows.len(), 3);
|
||||
for line in route_rows {
|
||||
assert!(line.split_whitespace().count() <= 3);
|
||||
}
|
||||
for entry in &list.items {
|
||||
assert!(rendered.contains(entry));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn narrow_layout_stacks_sections_without_losing_routes() {
|
||||
let state = state();
|
||||
for width in [24, 60, 87] {
|
||||
let text = text(&details(&state, &statistics(&state), width));
|
||||
assert!(text.lines().any(|line| line == "TUNNEL"));
|
||||
assert!(text.lines().any(|line| line == "DNS"));
|
||||
assert!(text.contains("2001:db8:1234:5678::/64"));
|
||||
assert!(text.contains("192.168.0.0/16"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scrolling_reaches_last_route_and_resize_clamps_offset_with_summary_pinned() {
|
||||
let state = state();
|
||||
let statistics = statistics(&state);
|
||||
let mut terminal = Terminal::new(TestBackend::new(60, 14)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(scroll.can_scroll());
|
||||
scroll.handle_key(KeyCode::End);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
let rendered = text(terminal.backend().buffer());
|
||||
assert!(rendered.contains("Connected"));
|
||||
assert!(rendered.contains("vpn.example.com"));
|
||||
assert!(rendered.contains("192.168.0.0/16"));
|
||||
terminal.backend_mut().resize(100, 50);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(!scroll.can_scroll());
|
||||
assert_eq!(scroll.offset, 0);
|
||||
assert!(text(terminal.backend().buffer()).contains("TRAFFIC · live"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn very_short_body_keeps_status_and_scrollable_details_visible() {
|
||||
let state = state();
|
||||
for (width, height) in [(60, 6), (24, 3)] {
|
||||
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
let stats = statistics(&state);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(text(terminal.backend().buffer()).contains("Connected"));
|
||||
assert!(text(terminal.backend().buffer()).contains("TRAFFIC"));
|
||||
scroll.handle_key(KeyCode::End);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(text(terminal.backend().buffer()).contains("192.168.0.0/16"));
|
||||
scroll.handle_key(KeyCode::PageUp);
|
||||
let page_up = scroll.offset;
|
||||
assert!(page_up < scroll.maximum);
|
||||
scroll.handle_key(KeyCode::Up);
|
||||
assert!(scroll.offset < page_up);
|
||||
scroll.handle_key(KeyCode::Down);
|
||||
assert_eq!(scroll.offset, page_up);
|
||||
scroll.handle_key(KeyCode::PageDown);
|
||||
assert_eq!(scroll.offset, scroll.maximum);
|
||||
scroll.handle_key(KeyCode::Home);
|
||||
assert_eq!(scroll.offset, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stale_and_missing_configuration_remain_explicit() {
|
||||
let mut state = state();
|
||||
let mut statistics = statistics(&state);
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut statistics else {
|
||||
unreachable!()
|
||||
};
|
||||
view.state = TunnelStatisticsState::Stale;
|
||||
view.sample_age_ms = Some(12_000);
|
||||
state.configuration = None;
|
||||
let rendered = text(&details(&state, &statistics, 100));
|
||||
assert!(rendered.contains("TRAFFIC · stale"));
|
||||
assert!(rendered.contains("12 seconds"));
|
||||
assert!(rendered.contains("unavailable"));
|
||||
assert!(rendered.contains("1.2 MiB"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn units_and_long_sessions_are_explicit() {
|
||||
assert_eq!(bytes(1024), "1.0 KiB");
|
||||
assert_eq!(bytes(0), "0 B");
|
||||
assert_eq!(uptime(90_061_000), "25:01:01");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
//! Optional foreground presentation. Connection ownership stays with ConnectHandler.
|
||||
mod layout;
|
||||
mod notice;
|
||||
mod output;
|
||||
mod restoration;
|
||||
mod screen;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use std::{
|
||||
fs::{File, OpenOptions},
|
||||
io::IsTerminal,
|
||||
os::fd::AsRawFd,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc,
|
||||
},
|
||||
thread::JoinHandle,
|
||||
};
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::log_format::LogFormat;
|
||||
use nix::unistd::{getpgrp, tcgetpgrp};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
pub(crate) use notice::{NoticeLogger, session_notice};
|
||||
use output::OutputRouting;
|
||||
|
||||
pub(crate) type InternalMembers = Arc<Mutex<std::collections::BTreeMap<String, String>>>;
|
||||
|
||||
pub(crate) fn validate(format: LogFormat) -> anyhow::Result<()> {
|
||||
ensure!(
|
||||
format == LogFormat::Text,
|
||||
"--dashboard conflicts with --log-format json"
|
||||
);
|
||||
ensure!(
|
||||
std::env::var_os("TERM").is_some_and(|term| term != "dumb"),
|
||||
"--dashboard requires a capable terminal (TERM must not be dumb)"
|
||||
);
|
||||
let tty = terminal()?;
|
||||
ensure!(
|
||||
std::io::stderr().is_terminal(),
|
||||
"--dashboard requires stderr attached to the controlling terminal"
|
||||
);
|
||||
let stderr = output::duplicate(2)?;
|
||||
ensure!(
|
||||
same_terminal(&stderr, &tty),
|
||||
"--dashboard requires stderr attached to the controlling terminal"
|
||||
);
|
||||
ensure!(
|
||||
tcgetpgrp(&tty)? == getpgrp(),
|
||||
"--dashboard requires a foreground terminal"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn terminal() -> anyhow::Result<File> {
|
||||
OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.open("/dev/tty")
|
||||
.context("--dashboard requires a controlling terminal")
|
||||
}
|
||||
|
||||
fn same_terminal(first: &File, second: &File) -> bool {
|
||||
// /dev/tty is a multiplexor node, so its st_rdev differs from the underlying
|
||||
// PTY. A session has one controlling terminal; compare terminal session IDs.
|
||||
let first_session = unsafe { nix::libc::tcgetsid(first.as_raw_fd()) };
|
||||
let second_session = unsafe { nix::libc::tcgetsid(second.as_raw_fd()) };
|
||||
first_session >= 0 && first_session == second_session
|
||||
}
|
||||
|
||||
pub(super) enum Content {
|
||||
Tunnel(Arc<gptunnel::TunnelMonitor>),
|
||||
Internal(InternalMembers),
|
||||
}
|
||||
|
||||
pub(super) enum Command {
|
||||
Suspend,
|
||||
Resume,
|
||||
}
|
||||
|
||||
pub(crate) struct Dashboard {
|
||||
routing: OutputRouting,
|
||||
server: String,
|
||||
cancellation: CancellationToken,
|
||||
stop: Arc<AtomicBool>,
|
||||
worker: Option<JoinHandle<()>>,
|
||||
signals: Vec<tokio::task::JoinHandle<()>>,
|
||||
error: Arc<Mutex<Option<String>>>,
|
||||
}
|
||||
|
||||
impl Dashboard {
|
||||
/// Install before native startup so persistent children inherit captured descriptors.
|
||||
pub(crate) fn prepare(server: String, cancellation: CancellationToken) -> anyhow::Result<Self> {
|
||||
let capture_stdout =
|
||||
std::io::stdout().is_terminal() && same_terminal(&output::duplicate(1)?, &output::duplicate(2)?);
|
||||
Ok(Self {
|
||||
routing: OutputRouting::install(capture_stdout, cancellation.clone())?,
|
||||
server,
|
||||
cancellation,
|
||||
stop: Arc::default(),
|
||||
worker: None,
|
||||
signals: Vec::new(),
|
||||
error: Arc::default(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn start_tunnel(&mut self, monitor: Arc<gptunnel::TunnelMonitor>) -> anyhow::Result<()> {
|
||||
self.start(Content::Tunnel(monitor.clone()))?;
|
||||
monitor.set_statistics_enabled(true);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn start_internal(&mut self, members: InternalMembers) -> anyhow::Result<()> {
|
||||
self.start(Content::Internal(members))
|
||||
}
|
||||
|
||||
fn start(&mut self, content: Content) -> anyhow::Result<()> {
|
||||
ensure!(self.worker.is_none(), "Dashboard already started");
|
||||
let (commands, receiver) = mpsc::channel();
|
||||
for (kind, command) in [
|
||||
(
|
||||
tokio::signal::unix::SignalKind::from_raw(nix::libc::SIGTSTP),
|
||||
Command::Suspend,
|
||||
),
|
||||
(
|
||||
tokio::signal::unix::SignalKind::from_raw(nix::libc::SIGCONT),
|
||||
Command::Resume,
|
||||
),
|
||||
] {
|
||||
let mut signal = tokio::signal::unix::signal(kind)?;
|
||||
let commands = commands.clone();
|
||||
self.signals.push(tokio::spawn(async move {
|
||||
while signal.recv().await.is_some() {
|
||||
let command = match command {
|
||||
Command::Suspend => Command::Suspend,
|
||||
Command::Resume => Command::Resume,
|
||||
};
|
||||
if commands.send(command).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}));
|
||||
}
|
||||
let mut hangup = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::hangup())?;
|
||||
let cancellation = self.cancellation.clone();
|
||||
self.signals.push(tokio::spawn(async move {
|
||||
if hangup.recv().await.is_some() {
|
||||
cancellation.cancel();
|
||||
}
|
||||
}));
|
||||
let (ready, started) = mpsc::sync_channel(1);
|
||||
let context = screen::Context {
|
||||
terminal: terminal()?,
|
||||
output: self.routing.original_error.clone(),
|
||||
saved_stdout: self.routing.saved_output(),
|
||||
saved_stdin_flags: self.routing.saved_input_flags(),
|
||||
history: self.routing.history(),
|
||||
passthrough: self.routing.passthrough(),
|
||||
gate: self.routing.gate(),
|
||||
stop: self.stop.clone(),
|
||||
cancellation: self.cancellation.clone(),
|
||||
notice: notice::slot(),
|
||||
server: self.server.clone(),
|
||||
content,
|
||||
commands: receiver,
|
||||
};
|
||||
let error = self.error.clone();
|
||||
let cancellation = self.cancellation.clone();
|
||||
self.worker = Some(std::thread::Builder::new().name("dashboard".into()).spawn(move || {
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| screen::run(context, ready)));
|
||||
let failure = match result {
|
||||
Ok(Ok(())) => None,
|
||||
Ok(Err(failure)) => Some(format!("{failure:#}")),
|
||||
Err(_) => Some("Dashboard renderer panicked".into()),
|
||||
};
|
||||
if let Some(failure) = failure {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) = Some(failure);
|
||||
cancellation.cancel();
|
||||
}
|
||||
})?);
|
||||
started.recv().context("Dashboard stopped during initialization")??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Called after native shutdown and network cleanup, while capture still drains.
|
||||
pub(crate) fn finish(&mut self) -> anyhow::Result<()> {
|
||||
self.stop.store(true, Ordering::Release);
|
||||
if let Some(worker) = self.worker.take() {
|
||||
let _ = worker.join();
|
||||
}
|
||||
for signal in self.signals.drain(..) {
|
||||
signal.abort();
|
||||
}
|
||||
self.routing.restore();
|
||||
if let Some(error) = self.routing.take_error() {
|
||||
anyhow::bail!("Dashboard failed: {error}");
|
||||
}
|
||||
if let Some(error) = self.error.lock().unwrap_or_else(|error| error.into_inner()).take() {
|
||||
anyhow::bail!("Dashboard failed: {error}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Dashboard {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.finish();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
|
||||
use log::{Level, Log};
|
||||
|
||||
use super::output::plain_text;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(super) struct Notice {
|
||||
pub(super) level: Level,
|
||||
pub(super) message: String,
|
||||
}
|
||||
|
||||
pub(super) type NoticeSlot = Arc<Mutex<Option<Notice>>>;
|
||||
static NOTICES: OnceLock<NoticeSlot> = OnceLock::new();
|
||||
|
||||
pub(super) fn slot() -> NoticeSlot {
|
||||
NOTICES.get_or_init(Arc::default).clone()
|
||||
}
|
||||
|
||||
pub(crate) fn session_notice(level: Level, message: &str) {
|
||||
if let Some(slot) = NOTICES.get() {
|
||||
let mut end = message.len().min(8192);
|
||||
while !message.is_char_boundary(end) {
|
||||
end -= 1;
|
||||
}
|
||||
*slot.lock().unwrap_or_else(|error| error.into_inner()) = Some(Notice {
|
||||
level,
|
||||
message: plain_text(message[..end].as_bytes()),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Metadata goes to the notice slot; descriptor capture owns the sole history entry.
|
||||
pub(crate) struct NoticeLogger {
|
||||
inner: env_logger::Logger,
|
||||
}
|
||||
|
||||
impl NoticeLogger {
|
||||
pub(crate) fn new(inner: env_logger::Logger) -> Self {
|
||||
let _ = slot();
|
||||
Self { inner }
|
||||
}
|
||||
}
|
||||
|
||||
impl Log for NoticeLogger {
|
||||
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
|
||||
self.inner.enabled(metadata)
|
||||
}
|
||||
fn log(&self, record: &log::Record<'_>) {
|
||||
if self.inner.matches(record) {
|
||||
if record.level() <= Level::Warn {
|
||||
session_notice(record.level(), &record.args().to_string());
|
||||
}
|
||||
self.inner.log(record);
|
||||
}
|
||||
}
|
||||
fn flush(&self) {
|
||||
self.inner.flush();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn notice_tap_honors_message_filters_and_keeps_warning_severity() {
|
||||
let logger = NoticeLogger::new(
|
||||
env_logger::Builder::new()
|
||||
.parse_filters("warn/allowed")
|
||||
.target(env_logger::Target::Pipe(Box::new(std::io::sink())))
|
||||
.build(),
|
||||
);
|
||||
session_notice(Level::Info, "previous event");
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(Level::Warn)
|
||||
.args(format_args!("filtered warning"))
|
||||
.build(),
|
||||
);
|
||||
assert_eq!(slot().lock().unwrap().as_ref().unwrap().message, "previous event");
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(Level::Warn)
|
||||
.args(format_args!("allowed warning"))
|
||||
.build(),
|
||||
);
|
||||
let current = slot();
|
||||
let notice = current.lock().unwrap();
|
||||
assert_eq!(notice.as_ref().unwrap().level, Level::Warn);
|
||||
assert_eq!(notice.as_ref().unwrap().message, "allowed warning");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,338 @@
|
||||
//! Own terminal output while the native worker and its children are running.
|
||||
use std::{
|
||||
collections::VecDeque,
|
||||
fs::File,
|
||||
io::{self, Read, Write},
|
||||
os::fd::{AsFd, FromRawFd},
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
thread::{self, JoinHandle},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use anyhow::Context;
|
||||
use nix::{
|
||||
fcntl::{FcntlArg, FdFlag, OFlag, fcntl},
|
||||
poll::{PollFd, PollFlags, poll},
|
||||
unistd::{dup2_stderr, dup2_stdout},
|
||||
};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
const MAX_LINES: usize = 2_000;
|
||||
const MAX_BYTES: usize = 1_048_576;
|
||||
const MAX_LINE_BYTES: usize = 8_192;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct History {
|
||||
lines: VecDeque<String>,
|
||||
bytes: usize,
|
||||
discarded: u64,
|
||||
partial: [String; 2],
|
||||
}
|
||||
|
||||
impl History {
|
||||
fn push(&mut self, line: String) {
|
||||
self.bytes += line.len();
|
||||
self.lines.push_back(line);
|
||||
while self.lines.len() > MAX_LINES || self.bytes > MAX_BYTES {
|
||||
if let Some(line) = self.lines.pop_front() {
|
||||
self.bytes -= line.len();
|
||||
self.discarded = self.discarded.saturating_add(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn tail(&self, count: usize) -> Vec<String> {
|
||||
if count == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut lines = Vec::new();
|
||||
if self.discarded > 0 {
|
||||
lines.push(format!("[{} older log lines discarded]", self.discarded));
|
||||
}
|
||||
let partial_count = self.partial.iter().filter(|line| !line.is_empty()).count();
|
||||
let retained_count = count.saturating_sub(lines.len() + partial_count);
|
||||
lines.extend(
|
||||
self
|
||||
.lines
|
||||
.iter()
|
||||
.skip(self.lines.len().saturating_sub(retained_count))
|
||||
.cloned(),
|
||||
);
|
||||
lines.extend(self.partial.iter().filter(|line| !line.is_empty()).cloned());
|
||||
lines.truncate(count);
|
||||
lines
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn plain_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(&strip_ansi_escapes::strip(bytes))
|
||||
.chars()
|
||||
.filter(|ch| !ch.is_control() || *ch == '\t')
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct LineDecoder {
|
||||
bytes: Vec<u8>,
|
||||
truncated: bool,
|
||||
stream: usize,
|
||||
}
|
||||
|
||||
impl LineDecoder {
|
||||
fn new(stream: usize) -> Self {
|
||||
Self {
|
||||
bytes: Vec::new(),
|
||||
truncated: false,
|
||||
stream,
|
||||
}
|
||||
}
|
||||
|
||||
fn text(&self) -> String {
|
||||
let suffix = if self.truncated { " [line truncated]" } else { "" };
|
||||
format!("{}{suffix}", plain_text(&self.bytes))
|
||||
}
|
||||
|
||||
fn ingest(&mut self, bytes: &[u8], history: &mut History) {
|
||||
for byte in bytes {
|
||||
if *byte == b'\n' {
|
||||
history.push(self.text());
|
||||
self.bytes.clear();
|
||||
self.truncated = false;
|
||||
} else if self.bytes.len() < MAX_LINE_BYTES {
|
||||
self.bytes.push(*byte);
|
||||
} else {
|
||||
self.truncated = true;
|
||||
}
|
||||
}
|
||||
history.partial[self.stream] = if self.bytes.is_empty() && !self.truncated {
|
||||
String::new()
|
||||
} else {
|
||||
self.text()
|
||||
};
|
||||
}
|
||||
|
||||
fn finish(&mut self, history: &mut History) {
|
||||
if !self.bytes.is_empty() || self.truncated {
|
||||
history.push(self.text());
|
||||
}
|
||||
history.partial[self.stream].clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// The duplicate is close-on-exec: helpers inherit the capture pipe, never the renderer.
|
||||
pub(super) fn duplicate(fd: i32) -> io::Result<File> {
|
||||
let duplicate = unsafe { nix::libc::fcntl(fd, nix::libc::F_DUPFD_CLOEXEC, 3) };
|
||||
if duplicate < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
Ok(unsafe { File::from_raw_fd(duplicate) })
|
||||
}
|
||||
|
||||
pub(super) struct OutputRouting {
|
||||
pub(super) original_error: Arc<File>,
|
||||
original_input_flags: FdFlag,
|
||||
original_output: Option<Arc<File>>,
|
||||
history: Arc<Mutex<History>>,
|
||||
passthrough: Arc<AtomicBool>,
|
||||
stop: Arc<AtomicBool>,
|
||||
readers: Vec<JoinHandle<()>>,
|
||||
gate: Arc<Mutex<()>>,
|
||||
error: Arc<Mutex<Option<String>>>,
|
||||
restored: bool,
|
||||
}
|
||||
|
||||
impl OutputRouting {
|
||||
pub(super) fn install(capture_stdout: bool, cancellation: CancellationToken) -> anyhow::Result<Self> {
|
||||
io::stdout().flush()?;
|
||||
io::stderr().flush()?;
|
||||
unsafe {
|
||||
nix::libc::fflush(std::ptr::null_mut());
|
||||
}
|
||||
let mut routing = Self {
|
||||
original_error: Arc::new(duplicate(2)?),
|
||||
original_input_flags: FdFlag::from_bits_truncate(fcntl(io::stdin(), FcntlArg::F_GETFD)?),
|
||||
original_output: capture_stdout.then(|| duplicate(1).map(Arc::new)).transpose()?,
|
||||
history: Arc::default(),
|
||||
passthrough: Arc::new(AtomicBool::new(true)),
|
||||
stop: Arc::default(),
|
||||
readers: Vec::new(),
|
||||
gate: Arc::default(),
|
||||
error: Arc::default(),
|
||||
restored: false,
|
||||
};
|
||||
routing.capture(1, routing.original_error.clone(), cancellation.clone())?;
|
||||
if let Some(original) = routing.original_output.clone() {
|
||||
routing.capture(0, original, cancellation)?;
|
||||
}
|
||||
// Authentication may have initialized Crossterm's global reader with fd 0.
|
||||
// Keep that descriptor stable, but do not let executed helpers inherit it.
|
||||
// Script-TUN packet I/O continues through its separate VPNFD socket.
|
||||
fcntl(
|
||||
io::stdin(),
|
||||
FcntlArg::F_SETFD(routing.original_input_flags | FdFlag::FD_CLOEXEC),
|
||||
)?;
|
||||
Ok(routing)
|
||||
}
|
||||
|
||||
fn capture(&mut self, stream: usize, destination: Arc<File>, cancellation: CancellationToken) -> anyhow::Result<()> {
|
||||
let (reader, writer) = io::pipe()?;
|
||||
// Polling plus nonblocking reads lets teardown bound inherited pipe lifetimes.
|
||||
fcntl(&reader, FcntlArg::F_SETFL(OFlag::O_NONBLOCK))?;
|
||||
let history = self.history.clone();
|
||||
let passthrough = self.passthrough.clone();
|
||||
let stop = self.stop.clone();
|
||||
let gate = self.gate.clone();
|
||||
let error = self.error.clone();
|
||||
let thread = thread::Builder::new()
|
||||
.name(format!("dashboard-output-{stream}"))
|
||||
.spawn(move || {
|
||||
let mut reader = reader;
|
||||
let mut decoder = LineDecoder::new(stream);
|
||||
let mut buffer = [0; 4096];
|
||||
let mut deadline = None;
|
||||
loop {
|
||||
if stop.load(Ordering::Acquire) && deadline.is_none() {
|
||||
deadline = Some(Instant::now() + Duration::from_millis(250));
|
||||
}
|
||||
if deadline.is_some_and(|deadline| Instant::now() >= deadline) {
|
||||
break;
|
||||
}
|
||||
let mut descriptors = [PollFd::new(reader.as_fd(), PollFlags::POLLIN)];
|
||||
match poll(&mut descriptors, 50u16) {
|
||||
Ok(0) => {
|
||||
if deadline.is_some() {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Ok(_) => {}
|
||||
Err(nix::errno::Errno::EINTR) => continue,
|
||||
Err(failure) => {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot poll dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
break;
|
||||
}
|
||||
}
|
||||
match reader.read(&mut buffer) {
|
||||
Ok(0) => break,
|
||||
Ok(length) => {
|
||||
{
|
||||
let _gate = gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
if passthrough.load(Ordering::Acquire) {
|
||||
if let Err(failure) = (&*destination).write_all(&buffer[..length]) {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot forward dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
decoder.ingest(
|
||||
&buffer[..length],
|
||||
&mut history.lock().unwrap_or_else(|error| error.into_inner()),
|
||||
);
|
||||
}
|
||||
Err(error) if matches!(error.kind(), io::ErrorKind::WouldBlock | io::ErrorKind::Interrupted) => continue,
|
||||
Err(failure) => {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot read dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut history.lock().unwrap_or_else(|error| error.into_inner()));
|
||||
})
|
||||
.context("Cannot start dashboard output reader")?;
|
||||
self.readers.push(thread);
|
||||
if stream == 0 {
|
||||
dup2_stdout(&writer)?;
|
||||
} else {
|
||||
dup2_stderr(&writer)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn history(&self) -> Arc<Mutex<History>> {
|
||||
self.history.clone()
|
||||
}
|
||||
pub(super) fn passthrough(&self) -> Arc<AtomicBool> {
|
||||
self.passthrough.clone()
|
||||
}
|
||||
pub(super) fn gate(&self) -> Arc<Mutex<()>> {
|
||||
self.gate.clone()
|
||||
}
|
||||
pub(super) fn saved_output(&self) -> Option<Arc<File>> {
|
||||
self.original_output.clone()
|
||||
}
|
||||
pub(super) fn saved_input_flags(&self) -> FdFlag {
|
||||
self.original_input_flags
|
||||
}
|
||||
pub(super) fn take_error(&self) -> Option<String> {
|
||||
self.error.lock().unwrap_or_else(|error| error.into_inner()).take()
|
||||
}
|
||||
|
||||
pub(super) fn restore(&mut self) {
|
||||
if self.restored {
|
||||
return;
|
||||
}
|
||||
let _ = io::stdout().flush();
|
||||
let _ = io::stderr().flush();
|
||||
unsafe {
|
||||
nix::libc::fflush(std::ptr::null_mut());
|
||||
}
|
||||
let _ = dup2_stderr(&*self.original_error);
|
||||
let _ = fcntl(io::stdin(), FcntlArg::F_SETFD(self.original_input_flags));
|
||||
if let Some(output) = &self.original_output {
|
||||
let _ = dup2_stdout(&**output);
|
||||
}
|
||||
self.stop.store(true, Ordering::Release);
|
||||
for reader in self.readers.drain(..) {
|
||||
let _ = reader.join();
|
||||
}
|
||||
self.restored = true;
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for OutputRouting {
|
||||
fn drop(&mut self) {
|
||||
self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn split_utf8_and_unterminated_lines_are_preserved_without_escape_commands() {
|
||||
for stream in [0, 1] {
|
||||
let mut history = History::default();
|
||||
let mut decoder = LineDecoder::new(stream);
|
||||
let bytes = "connected 日本語\x1b[2J\npartial".as_bytes();
|
||||
for byte in bytes {
|
||||
decoder.ingest(&[*byte], &mut history);
|
||||
}
|
||||
assert_eq!(history.tail(10), ["connected 日本語", "partial"]);
|
||||
decoder.finish(&mut history);
|
||||
assert_eq!(history.tail(10), ["connected 日本語", "partial"]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_long_lines_and_history_are_bounded() {
|
||||
let mut history = History::default();
|
||||
let mut decoder = LineDecoder::new(0);
|
||||
decoder.ingest(&vec![b'x'; MAX_LINE_BYTES * 3], &mut history);
|
||||
decoder.ingest(b"\n", &mut history);
|
||||
assert!(history.lines[0].ends_with("[line truncated]"));
|
||||
for _ in 0..MAX_LINES + 10 {
|
||||
decoder.ingest(b"line\n", &mut history);
|
||||
}
|
||||
assert!(history.lines.len() <= MAX_LINES);
|
||||
assert!(history.bytes <= MAX_BYTES);
|
||||
assert!(history.tail(10)[0].contains("discarded"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
//! Panic restoration must remain independent of renderer and output-ingestion locks.
|
||||
use std::{
|
||||
fs::File,
|
||||
io,
|
||||
os::fd::AsRawFd,
|
||||
sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
};
|
||||
|
||||
pub(super) struct TerminalRestoration {
|
||||
terminal: File,
|
||||
error: Arc<File>,
|
||||
output: Option<Arc<File>>,
|
||||
input_flags: nix::fcntl::FdFlag,
|
||||
termios: nix::libc::termios,
|
||||
active: AtomicBool,
|
||||
}
|
||||
|
||||
impl TerminalRestoration {
|
||||
pub(super) fn install(
|
||||
terminal: File,
|
||||
error: Arc<File>,
|
||||
output: Option<Arc<File>>,
|
||||
input_flags: nix::fcntl::FdFlag,
|
||||
) -> io::Result<Arc<Self>> {
|
||||
let mut termios = std::mem::MaybeUninit::uninit();
|
||||
if unsafe { nix::libc::tcgetattr(terminal.as_raw_fd(), termios.as_mut_ptr()) } != 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let restoration = Arc::new(Self {
|
||||
terminal,
|
||||
error,
|
||||
output,
|
||||
input_flags,
|
||||
termios: unsafe { termios.assume_init() },
|
||||
active: AtomicBool::new(false),
|
||||
});
|
||||
let previous = std::panic::take_hook();
|
||||
let panic_restoration = restoration.clone();
|
||||
std::panic::set_hook(Box::new(move |panic| {
|
||||
panic_restoration.restore();
|
||||
previous(panic);
|
||||
}));
|
||||
Ok(restoration)
|
||||
}
|
||||
|
||||
pub(super) fn arm(&self) {
|
||||
self.active.store(true, Ordering::Release);
|
||||
}
|
||||
pub(super) fn disarm(&self) {
|
||||
self.active.store(false, Ordering::Release);
|
||||
}
|
||||
|
||||
pub(super) fn restore(&self) {
|
||||
if !self.active.swap(false, Ordering::AcqRel) {
|
||||
return;
|
||||
}
|
||||
unsafe {
|
||||
nix::libc::tcsetattr(self.terminal.as_raw_fd(), nix::libc::TCSANOW, &self.termios);
|
||||
let sequence = b"\x1b[?25h\x1b[?1049l";
|
||||
nix::libc::write(self.error.as_raw_fd(), sequence.as_ptr().cast(), sequence.len());
|
||||
nix::libc::dup2(self.error.as_raw_fd(), 2);
|
||||
nix::libc::fcntl(0, nix::libc::F_SETFD, self.input_flags.bits());
|
||||
if let Some(output) = &self.output {
|
||||
nix::libc::dup2(output.as_raw_fd(), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,359 @@
|
||||
use std::{
|
||||
fs::File,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc,
|
||||
},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use anyhow::{Context as _, ensure};
|
||||
use crossterm::{
|
||||
cursor::Show,
|
||||
event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
|
||||
execute,
|
||||
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
|
||||
};
|
||||
use gpapi::session::tunnel::TunnelPhase;
|
||||
use log::Level;
|
||||
use nix::unistd::{getpgrp, tcgetpgrp};
|
||||
use ratatui::{
|
||||
Terminal,
|
||||
backend::CrosstermBackend,
|
||||
layout::{Constraint, Layout},
|
||||
style::{Color, Modifier, Style},
|
||||
text::Line,
|
||||
widgets::{Block, Borders, Paragraph, Wrap},
|
||||
};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use super::{
|
||||
Command, Content,
|
||||
layout::{DetailScroll, phase_label, render_tunnel, row},
|
||||
notice::{Notice, NoticeSlot},
|
||||
output::{History, plain_text},
|
||||
restoration::TerminalRestoration,
|
||||
};
|
||||
|
||||
pub(super) struct Context {
|
||||
pub(super) terminal: File,
|
||||
pub(super) output: Arc<File>,
|
||||
pub(super) saved_stdout: Option<Arc<File>>,
|
||||
pub(super) saved_stdin_flags: nix::fcntl::FdFlag,
|
||||
pub(super) history: Arc<Mutex<History>>,
|
||||
pub(super) passthrough: Arc<AtomicBool>,
|
||||
pub(super) gate: Arc<Mutex<()>>,
|
||||
pub(super) stop: Arc<AtomicBool>,
|
||||
pub(super) cancellation: CancellationToken,
|
||||
pub(super) notice: NoticeSlot,
|
||||
pub(super) server: String,
|
||||
pub(super) content: Content,
|
||||
pub(super) commands: mpsc::Receiver<Command>,
|
||||
}
|
||||
|
||||
struct Screen {
|
||||
terminal: Terminal<CrosstermBackend<File>>,
|
||||
restore: Arc<TerminalRestoration>,
|
||||
controlling_terminal: File,
|
||||
passthrough: Arc<AtomicBool>,
|
||||
gate: Arc<Mutex<()>>,
|
||||
active: bool,
|
||||
}
|
||||
|
||||
impl Screen {
|
||||
fn new(context: &Context) -> anyhow::Result<Self> {
|
||||
let restore = TerminalRestoration::install(
|
||||
context.terminal.try_clone()?,
|
||||
context.output.clone(),
|
||||
context.saved_stdout.clone(),
|
||||
context.saved_stdin_flags,
|
||||
)?;
|
||||
let terminal = Terminal::new(CrosstermBackend::new(context.output.try_clone()?))?;
|
||||
let mut screen = Self {
|
||||
terminal,
|
||||
restore,
|
||||
controlling_terminal: context.terminal.try_clone()?,
|
||||
passthrough: context.passthrough.clone(),
|
||||
gate: context.gate.clone(),
|
||||
active: false,
|
||||
};
|
||||
screen.enter()?;
|
||||
Ok(screen)
|
||||
}
|
||||
|
||||
fn enter(&mut self) -> anyhow::Result<()> {
|
||||
if self.active {
|
||||
return Ok(());
|
||||
}
|
||||
ensure!(
|
||||
tcgetpgrp(&self.controlling_terminal)? == getpgrp(),
|
||||
"Dashboard is no longer in the foreground"
|
||||
);
|
||||
let _gate = self.gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
self.passthrough.store(false, Ordering::Release);
|
||||
// Arm before changing termios, including partial initialization failures.
|
||||
self.restore.arm();
|
||||
self.active = true;
|
||||
enable_raw_mode()?;
|
||||
execute!(self.terminal.backend_mut(), EnterAlternateScreen)?;
|
||||
// Terminal::clear queries cursor position through process stdout. Fullscreen
|
||||
// resize clears and resets buffers through our saved terminal backend only.
|
||||
self.terminal.resize(self.terminal.size()?.into())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn leave(&mut self) {
|
||||
if !self.active {
|
||||
return;
|
||||
}
|
||||
let _gate = self.gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
let _ = disable_raw_mode();
|
||||
let _ = execute!(self.terminal.backend_mut(), Show, LeaveAlternateScreen);
|
||||
self.restore.disarm();
|
||||
self.passthrough.store(true, Ordering::Release);
|
||||
self.active = false;
|
||||
}
|
||||
|
||||
fn suspend(&mut self) {
|
||||
self.leave();
|
||||
// SIGSTOP avoids recursion through our SIGTSTP listener. The shell resumes us.
|
||||
unsafe {
|
||||
nix::libc::raise(nix::libc::SIGSTOP);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Screen {
|
||||
fn drop(&mut self) {
|
||||
self.leave();
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn run(context: Context, ready: mpsc::SyncSender<anyhow::Result<()>>) -> anyhow::Result<()> {
|
||||
let screen = Screen::new(&context);
|
||||
let mut screen = match screen {
|
||||
Ok(screen) => {
|
||||
let _ = ready.send(Ok(()));
|
||||
screen
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = ready.send(Err(anyhow::anyhow!("{error:#}")));
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let mut logs = false;
|
||||
let mut scroll = DetailScroll::default();
|
||||
let mut next_draw = Instant::now();
|
||||
let mut dirty = true;
|
||||
while !context.stop.load(Ordering::Acquire) {
|
||||
for command in context.commands.try_iter() {
|
||||
match command {
|
||||
Command::Suspend => screen.suspend(),
|
||||
Command::Resume => {}
|
||||
}
|
||||
}
|
||||
if !screen.active {
|
||||
if tcgetpgrp(&context.terminal)? == getpgrp() {
|
||||
screen.enter()?;
|
||||
} else {
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if dirty || Instant::now() >= next_draw {
|
||||
draw(&mut screen.terminal, &context, logs, &mut scroll)?;
|
||||
next_draw = Instant::now() + Duration::from_secs(1);
|
||||
dirty = false;
|
||||
}
|
||||
if event::poll(Duration::from_millis(100)).context("Cannot read dashboard input")? {
|
||||
if let Event::Key(key) = event::read()? {
|
||||
if key.kind != KeyEventKind::Press {
|
||||
continue;
|
||||
}
|
||||
match key.code {
|
||||
KeyCode::Tab | KeyCode::BackTab => {
|
||||
logs = !logs;
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Up | KeyCode::Down | KeyCode::PageUp | KeyCode::PageDown | KeyCode::Home | KeyCode::End if !logs => {
|
||||
scroll.handle_key(key.code);
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
||||
context.cancellation.cancel();
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Char('z') if key.modifiers.contains(KeyModifiers::CONTROL) => screen.suspend(),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn draw(
|
||||
terminal: &mut Terminal<CrosstermBackend<File>>,
|
||||
context: &Context,
|
||||
logs: bool,
|
||||
scroll: &mut DetailScroll,
|
||||
) -> anyhow::Result<()> {
|
||||
terminal.draw(|frame| {
|
||||
let area = frame.area();
|
||||
if area.height < 8 || area.width < 24 {
|
||||
frame.render_widget(
|
||||
Paragraph::new("GP Connect\nCtrl+C Disconnect").wrap(Wrap { trim: false }),
|
||||
area,
|
||||
);
|
||||
return;
|
||||
}
|
||||
let compact = area.height < 18;
|
||||
let footer_height = if area.width < 80 { 2 } else { 1 };
|
||||
let [header, body, notice, footer] = Layout::vertical([
|
||||
Constraint::Length(2),
|
||||
Constraint::Min(1),
|
||||
Constraint::Length(if compact { 1 } else { 3 }),
|
||||
Constraint::Length(footer_height),
|
||||
])
|
||||
.areas(area);
|
||||
let view = if logs { "Live logs" } else { "Dashboard" };
|
||||
frame.render_widget(
|
||||
Paragraph::new(format!(" GP Connect · {view}"))
|
||||
.style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
|
||||
.block(Block::default().borders(Borders::BOTTOM)),
|
||||
header,
|
||||
);
|
||||
let mut lines = vec![row("Server", context.server.clone()), Line::default()];
|
||||
if logs {
|
||||
let history = context.history.lock().unwrap_or_else(|error| error.into_inner());
|
||||
let tail = history.tail(body.height as usize);
|
||||
lines = tail.into_iter().map(Line::raw).collect();
|
||||
let skip = lines.len().saturating_sub(body.height as usize);
|
||||
lines.drain(..skip);
|
||||
} else {
|
||||
match &context.content {
|
||||
Content::Tunnel(monitor) => {
|
||||
render_tunnel(
|
||||
frame,
|
||||
body,
|
||||
&context.server,
|
||||
&monitor.state(),
|
||||
&monitor.statistics(),
|
||||
scroll,
|
||||
);
|
||||
}
|
||||
Content::Internal(members) => {
|
||||
lines.push(row("Status", "Internal network session"));
|
||||
lines.push(Line::raw("Tunnel statistics unavailable (non-tunnel session)"));
|
||||
lines.push(Line::default());
|
||||
lines.extend(
|
||||
members
|
||||
.lock()
|
||||
.unwrap_or_else(|error| error.into_inner())
|
||||
.values()
|
||||
.map(|member| Line::raw(plain_text(member.as_bytes()))),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if logs || matches!(context.content, Content::Internal(_)) {
|
||||
frame.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), body);
|
||||
}
|
||||
let current = context.notice.lock().unwrap_or_else(|error| error.into_inner()).clone();
|
||||
let current = match &context.content {
|
||||
Content::Tunnel(monitor) => {
|
||||
let state = monitor.state();
|
||||
Some(notice_for_status(current, state.phase, state.transport))
|
||||
}
|
||||
Content::Internal(_) => current,
|
||||
};
|
||||
if let Some(current) = current {
|
||||
let color = if current.level <= Level::Warn {
|
||||
Color::Yellow
|
||||
} else {
|
||||
Color::Gray
|
||||
};
|
||||
let block = if compact {
|
||||
Block::default()
|
||||
} else {
|
||||
Block::default().title("Latest event").borders(Borders::TOP)
|
||||
};
|
||||
frame.render_widget(
|
||||
Paragraph::new(current.message)
|
||||
.style(Style::default().fg(color))
|
||||
.wrap(Wrap { trim: false })
|
||||
.block(block),
|
||||
notice,
|
||||
);
|
||||
}
|
||||
let ending = if context.cancellation.is_cancelled() {
|
||||
"Disconnecting…"
|
||||
} else {
|
||||
"Ctrl+C Disconnect"
|
||||
};
|
||||
frame.render_widget(
|
||||
footer_text(logs, ending, scroll.can_scroll(), area.width).style(Style::default().fg(Color::DarkGray)),
|
||||
footer,
|
||||
);
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn footer_text(logs: bool, ending: &str, scrollable: bool, width: u16) -> Paragraph<'static> {
|
||||
let view = if logs { "Dashboard" } else { "Logs" };
|
||||
let scrolling = scrollable && !logs;
|
||||
let text = if width < 80 {
|
||||
format!("{ending}\nTab {view}{}", if scrolling { " ↑↓ Scroll" } else { "" })
|
||||
} else {
|
||||
format!(
|
||||
"Tab {view} {ending}{}",
|
||||
if scrolling { " ↑↓/PgUp/PgDn Scroll" } else { "" }
|
||||
)
|
||||
};
|
||||
Paragraph::new(text)
|
||||
}
|
||||
|
||||
fn notice_for_status(
|
||||
notice: Option<Notice>,
|
||||
phase: TunnelPhase,
|
||||
transport: gpapi::session::tunnel::TunnelTransport,
|
||||
) -> Notice {
|
||||
notice.unwrap_or_else(|| Notice {
|
||||
level: Level::Info,
|
||||
message: format!("{} · {}", phase_label(phase), transport.label()),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn narrow_footer_keeps_disconnect_switch_and_scroll_hints_visible() {
|
||||
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
|
||||
let area = Rect::new(0, 0, 24, 2);
|
||||
let mut buffer = Buffer::empty(area);
|
||||
footer_text(false, "Ctrl+C Disconnect", true, area.width).render(area, &mut buffer);
|
||||
let lines: Vec<String> = (0..2)
|
||||
.map(|y| (0..24).map(|x| buffer[(x, y)].symbol()).collect())
|
||||
.collect();
|
||||
assert!(lines[0].contains("Ctrl+C Disconnect"));
|
||||
assert!(lines[1].contains("Tab Logs"));
|
||||
assert!(lines[1].contains("↑↓ Scroll"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_transitions_cannot_overwrite_an_existing_warning() {
|
||||
use gpapi::session::tunnel::TunnelTransport;
|
||||
let warning = Notice {
|
||||
level: Level::Warn,
|
||||
message: "ESP unavailable; using SSL".into(),
|
||||
};
|
||||
let first = notice_for_status(Some(warning), TunnelPhase::Connected, TunnelTransport::SslTls);
|
||||
let reconnecting = notice_for_status(Some(first), TunnelPhase::Reconnecting, TunnelTransport::Unavailable);
|
||||
let resumed = notice_for_status(Some(reconnecting), TunnelPhase::Connected, TunnelTransport::IpsecEsp);
|
||||
assert_eq!(resumed.level, Level::Warn);
|
||||
assert_eq!(resumed.message, "ESP unavailable; using SSL");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,456 @@
|
||||
//! Terminal integration runs in child test processes so descriptor/signal changes
|
||||
//! cannot capture another test's output or change its controlling terminal.
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{self, Read, Write},
|
||||
os::unix::process::CommandExt,
|
||||
process::{Child, Command, Stdio},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use nix::{
|
||||
fcntl::{FcntlArg, OFlag, fcntl},
|
||||
pty::{Winsize, openpty},
|
||||
sys::signal::{Signal, kill},
|
||||
unistd::Pid,
|
||||
};
|
||||
|
||||
use super::*;
|
||||
|
||||
struct Fixture {
|
||||
child: Child,
|
||||
master: File,
|
||||
slave: File,
|
||||
output: Vec<u8>,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn start(piped: bool) -> Self {
|
||||
Self::start_mode(if piped { "piped" } else { "terminal" }, piped)
|
||||
}
|
||||
|
||||
fn start_mode(mode: &str, piped: bool) -> Self {
|
||||
let mut command = Command::new(std::env::current_exe().unwrap());
|
||||
command
|
||||
.args([
|
||||
"--exact",
|
||||
"dashboard::tests::terminal_fixture",
|
||||
"--ignored",
|
||||
"--nocapture",
|
||||
])
|
||||
.env("GPCLIENT_DASHBOARD_FIXTURE", mode);
|
||||
Self::spawn(command, piped)
|
||||
}
|
||||
|
||||
fn spawn(mut command: Command, piped: bool) -> Self {
|
||||
let pty = openpty(
|
||||
Some(&Winsize {
|
||||
ws_row: 40,
|
||||
ws_col: 100,
|
||||
ws_xpixel: 0,
|
||||
ws_ypixel: 0,
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
let master = File::from(pty.master);
|
||||
let slave = File::from(pty.slave);
|
||||
fcntl(&master, FcntlArg::F_SETFL(OFlag::O_NONBLOCK)).unwrap();
|
||||
command
|
||||
.env("TERM", "xterm-256color")
|
||||
.stdin(if piped {
|
||||
Stdio::piped()
|
||||
} else {
|
||||
Stdio::from(slave.try_clone().unwrap())
|
||||
})
|
||||
.stdout(if piped {
|
||||
Stdio::piped()
|
||||
} else {
|
||||
Stdio::from(slave.try_clone().unwrap())
|
||||
})
|
||||
.stderr(Stdio::from(slave.try_clone().unwrap()));
|
||||
unsafe {
|
||||
command.pre_exec(|| {
|
||||
if nix::libc::setsid() < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if nix::libc::ioctl(2, nix::libc::TIOCSCTTY as _, 0) < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let no_core = nix::libc::rlimit {
|
||||
rlim_cur: 0,
|
||||
rlim_max: 0,
|
||||
};
|
||||
nix::libc::setrlimit(nix::libc::RLIMIT_CORE, &no_core);
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
let mut child = command.spawn().unwrap();
|
||||
if piped {
|
||||
child.stdin.take().unwrap().write_all(b"fixture-cookie\n").unwrap();
|
||||
}
|
||||
Self {
|
||||
child,
|
||||
master,
|
||||
slave,
|
||||
output: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn drain(&mut self) {
|
||||
let mut bytes = [0; 8192];
|
||||
loop {
|
||||
match self.master.read(&mut bytes) {
|
||||
Ok(0) => break,
|
||||
Ok(length) => self.output.extend_from_slice(&bytes[..length]),
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock => break,
|
||||
Err(error) if error.raw_os_error() == Some(nix::libc::EIO) => break,
|
||||
Err(error) => panic!("PTY read: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn wait_text(&mut self, text: &str) {
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
loop {
|
||||
self.drain();
|
||||
let plain = strip_ansi_escapes::strip(&self.output);
|
||||
if String::from_utf8_lossy(&plain).contains(text) {
|
||||
return;
|
||||
}
|
||||
if let Some(status) = self.child.try_wait().unwrap() {
|
||||
panic!(
|
||||
"Fixture exited {status} before {text:?}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
Instant::now() < deadline,
|
||||
"Missing {text:?}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(&mut self) {
|
||||
self.wait_text("DASHBOARD_RESTORED");
|
||||
let attrs = nix::sys::termios::tcgetattr(&self.slave).unwrap();
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON));
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ECHO));
|
||||
self.master.write_all(b"\n").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
loop {
|
||||
self.drain();
|
||||
if let Some(status) = self.child.try_wait().unwrap() {
|
||||
assert!(
|
||||
status.success(),
|
||||
"Fixture failed {status}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
self.drain();
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "Fixture did not restore/exit");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
assert!(String::from_utf8_lossy(&self.output).contains("DASHBOARD_RESTORED"));
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
// A failed assertion must not leave a suspended child or its helper alive.
|
||||
let _ = kill(Pid::from_raw(self.child.id() as i32), Signal::SIGCONT);
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn panel_switches_to_captured_child_logs_and_ctrl_c_restores_terminal() {
|
||||
let mut fixture = Fixture::start(false);
|
||||
fixture.wait_text("Internal");
|
||||
fixture.master.write_all(b"\t").unwrap();
|
||||
fixture.wait_text("Live logs");
|
||||
fixture.wait_text("child-stderr-after-entry");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warning_before_first_tunnel_frame_remains_visible() {
|
||||
let mut fixture = Fixture::start_mode("tunnel", false);
|
||||
fixture.wait_text("initial-fallback-warning");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connected_tunnel_samples_statistics_and_accepts_ctrl_c() {
|
||||
let mut fixture = Fixture::start_mode("active-tunnel", false);
|
||||
fixture.wait_text("IPsec");
|
||||
fixture.wait_text("(ESP)");
|
||||
fixture.wait_text("Received");
|
||||
fixture.wait_text("4.0");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn authenticated_terminal_input_remains_usable_after_dashboard_entry() {
|
||||
let mut fixture = Fixture::start_mode("prompted-tunnel", false);
|
||||
fixture.wait_text("Received");
|
||||
fixture.master.write_all(b"\t").unwrap();
|
||||
fixture.wait_text("Live logs");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn piped_credentials_and_stdout_redirection_preserve_their_streams() {
|
||||
let mut fixture = Fixture::start(true);
|
||||
fixture.wait_text("Internal");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
let mut output = String::new();
|
||||
fixture
|
||||
.child
|
||||
.stdout
|
||||
.take()
|
||||
.unwrap()
|
||||
.read_to_string(&mut output)
|
||||
.unwrap();
|
||||
assert!(output.contains("redirected-stdout"));
|
||||
assert!(!output.contains('\x1b'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn external_termination_and_suspend_resume_restore_terminal() {
|
||||
let mut fixture = Fixture::start(false);
|
||||
fixture.wait_text("Internal");
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGTSTP).unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
let attrs = nix::sys::termios::tcgetattr(&fixture.slave).unwrap();
|
||||
if attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON) {
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "suspend did not restore termios");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGCONT).unwrap();
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGTERM).unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_panic_hook_restores_terminal_with_panic_abort() {
|
||||
let dependencies = std::env::current_exe().unwrap().parent().unwrap().to_path_buf();
|
||||
let nix = std::fs::read_dir(&dependencies)
|
||||
.unwrap()
|
||||
.filter_map(Result::ok)
|
||||
.map(|entry| entry.path())
|
||||
.find(|path| {
|
||||
path.file_name().unwrap().to_string_lossy().starts_with("libnix-")
|
||||
&& path.extension().is_some_and(|ext| ext == "rlib")
|
||||
})
|
||||
.expect("compiled nix rlib");
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let binary = directory.path().join("dashboard-abort");
|
||||
let build = Command::new("rustc")
|
||||
.args(["--edition=2024", "-C", "panic=abort", "-A", "dead_code"])
|
||||
.arg(format!(
|
||||
"{}/tests/fixtures/dashboard_abort.rs",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
))
|
||||
.arg("--extern")
|
||||
.arg(format!("nix={}", nix.display()))
|
||||
.arg("-L")
|
||||
.arg(format!("dependency={}", dependencies.display()))
|
||||
.arg("-o")
|
||||
.arg(&binary)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
build.status.success(),
|
||||
"Abort fixture compilation failed: {}",
|
||||
String::from_utf8_lossy(&build.stderr)
|
||||
);
|
||||
let mut fixture = Fixture::spawn(Command::new(binary), false);
|
||||
fixture.wait_text("ABORT_FIXTURE_READY");
|
||||
fixture.master.write_all(b"x").unwrap();
|
||||
fixture.wait_text("ABORT_HOOK_RESTORED");
|
||||
let attrs = nix::sys::termios::tcgetattr(&fixture.slave).unwrap();
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON));
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ECHO));
|
||||
fixture.master.write_all(b"\n").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
fixture.drain();
|
||||
if let Some(status) = fixture.child.try_wait().unwrap() {
|
||||
assert!(!status.success(), "panic=abort fixture unexpectedly succeeded");
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "abort fixture did not exit");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
fixture.drain();
|
||||
assert!(String::from_utf8_lossy(&fixture.output).contains("intentional abort-hook fixture panic"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "runs in an isolated PTY subprocess"]
|
||||
fn terminal_fixture() {
|
||||
let mode = std::env::var("GPCLIENT_DASHBOARD_FIXTURE").expect("subprocess fixture only");
|
||||
if mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
env_logger::builder()
|
||||
.filter_level(log::LevelFilter::Info)
|
||||
.try_init()
|
||||
.unwrap();
|
||||
}
|
||||
if mode == "piped" {
|
||||
let mut credentials = String::new();
|
||||
std::io::stdin().read_to_string(&mut credentials).unwrap();
|
||||
assert_eq!(credentials, "fixture-cookie\n");
|
||||
}
|
||||
validate(LogFormat::Text).unwrap();
|
||||
if mode == "prompted-tunnel" {
|
||||
// Authentication prompts use Crossterm before dashboard output routing.
|
||||
// Exercise its real global reader initialization while stdin is the TTY.
|
||||
let _ = crossterm::event::poll(Duration::from_millis(1)).unwrap();
|
||||
}
|
||||
let runtime = tokio::runtime::Runtime::new().unwrap();
|
||||
runtime.block_on(async {
|
||||
let cancellation = CancellationToken::new();
|
||||
let signal_cancel = cancellation.clone();
|
||||
let signals = tokio::spawn(async move {
|
||||
gpapi::utils::shutdown_signal().await;
|
||||
signal_cancel.cancel();
|
||||
});
|
||||
let input_flags = fcntl(std::io::stdin(), FcntlArg::F_GETFD).unwrap();
|
||||
let mut dashboard = Dashboard::prepare("vpn.example.com".into(), cancellation.clone()).unwrap();
|
||||
eprintln!("child-stderr-before-entry");
|
||||
// Native VPN helpers exec /bin/sh without Rust's standard-fd repair.
|
||||
let mut child = Command::new("/bin/sh")
|
||||
.args([
|
||||
"-c",
|
||||
r#"
|
||||
sleep 1
|
||||
if test -t 0; then exit 1; fi
|
||||
if read -r input 2>/dev/null; then exit 1; fi
|
||||
printf '%s\n' child-stderr-after-entry >&2
|
||||
"#,
|
||||
])
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let members = InternalMembers::default();
|
||||
members
|
||||
.lock()
|
||||
.unwrap()
|
||||
.insert("internal.example.com".into(), "internal.example.com: Healthy".into());
|
||||
let mut native = None;
|
||||
let monitor = if mode == "tunnel" || mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
let vpn = Arc::new(
|
||||
openconnect::Vpn::builder("vpn.example.com", "fixture-cookie")
|
||||
.network_configuration_handler(|_| Ok(()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
);
|
||||
let monitor = gptunnel::TunnelMonitor::attach(vpn.clone());
|
||||
if mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
native = Some(active_native_fixture(vpn, cancellation.clone()));
|
||||
}
|
||||
let _ = notice::slot();
|
||||
session_notice(log::Level::Warn, "initial-fallback-warning");
|
||||
dashboard.start_tunnel(monitor.clone()).unwrap();
|
||||
Some(monitor)
|
||||
} else {
|
||||
dashboard.start_internal(members).unwrap();
|
||||
None
|
||||
};
|
||||
println!("redirected-stdout");
|
||||
tokio::time::timeout(Duration::from_secs(15), cancellation.cancelled())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
child.wait().unwrap().success(),
|
||||
"helper must not inherit dashboard input"
|
||||
);
|
||||
if let Some(monitor) = monitor {
|
||||
monitor.stop().await;
|
||||
}
|
||||
if let Some(native) = native {
|
||||
native.join().unwrap();
|
||||
}
|
||||
dashboard.finish().unwrap();
|
||||
assert_eq!(fcntl(std::io::stdin(), FcntlArg::F_GETFD).unwrap(), input_flags);
|
||||
signals.abort();
|
||||
eprintln!("DASHBOARD_RESTORED");
|
||||
let mut acknowledgement = String::new();
|
||||
let mut tty = std::fs::OpenOptions::new().read(true).open("/dev/tty").unwrap();
|
||||
use std::io::BufRead;
|
||||
std::io::BufReader::new(&mut tty)
|
||||
.read_line(&mut acknowledgement)
|
||||
.unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
fn active_native_fixture(vpn: Arc<openconnect::Vpn>, cancellation: CancellationToken) -> std::thread::JoinHandle<()> {
|
||||
use std::{
|
||||
ffi::{c_int, c_void},
|
||||
os::fd::AsRawFd,
|
||||
os::unix::net::UnixStream,
|
||||
};
|
||||
#[repr(C)]
|
||||
struct Statistics {
|
||||
tx_pkts: u64,
|
||||
tx_bytes: u64,
|
||||
rx_pkts: u64,
|
||||
rx_bytes: u64,
|
||||
}
|
||||
unsafe extern "C" {
|
||||
fn vpn_attach_command_pipe(vpn: *mut c_void, fd: c_int) -> c_int;
|
||||
fn vpn_detach_command_pipe(vpn: *mut c_void);
|
||||
fn vpn_tunnel_event(vpn: *mut c_void, event: c_int);
|
||||
fn vpn_tunnel_statistics(vpn: *mut c_void, statistics: *const Statistics);
|
||||
}
|
||||
let (sender, mut receiver) = UnixStream::pair().unwrap();
|
||||
receiver.set_nonblocking(true).unwrap();
|
||||
let pointer = Arc::as_ptr(&vpn).cast_mut().cast();
|
||||
// SAFETY: the fixture retains Vpn and both endpoints through detach; event
|
||||
// numbers and statistics layout match the native bridge used in production.
|
||||
unsafe {
|
||||
assert_eq!(vpn_attach_command_pipe(pointer, sender.as_raw_fd()), 0);
|
||||
vpn_tunnel_event(pointer, 1);
|
||||
vpn_tunnel_event(pointer, 5);
|
||||
}
|
||||
std::thread::spawn(move || {
|
||||
let pointer = Arc::as_ptr(&vpn).cast_mut().cast();
|
||||
let mut command = [0];
|
||||
while !cancellation.is_cancelled() {
|
||||
match receiver.read(&mut command) {
|
||||
Ok(1) if command[0] == b's' => unsafe {
|
||||
vpn_tunnel_statistics(
|
||||
pointer,
|
||||
&Statistics {
|
||||
tx_pkts: 2,
|
||||
tx_bytes: 1024,
|
||||
rx_pkts: 4,
|
||||
rx_bytes: 4096,
|
||||
},
|
||||
);
|
||||
},
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock => std::thread::sleep(Duration::from_millis(10)),
|
||||
other => panic!("Unexpected native fixture command: {other:?}"),
|
||||
}
|
||||
}
|
||||
// SAFETY: all native observations finish before the retained Vpn is freed.
|
||||
unsafe {
|
||||
vpn_detach_command_pipe(pointer);
|
||||
vpn_tunnel_event(pointer, 7);
|
||||
}
|
||||
drop(sender);
|
||||
})
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
mod background;
|
||||
mod cli;
|
||||
mod connect;
|
||||
mod dashboard;
|
||||
mod diagnostics;
|
||||
mod disconnect;
|
||||
mod hip;
|
||||
|
||||
@@ -75,6 +75,7 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
|
||||
|
||||
tokio::time::sleep(schedule.delay).await;
|
||||
|
||||
crate::dashboard::session_notice(Level::Warn, &schedule.message);
|
||||
report(log_format, Level::Warn, &format!("\nWARNING: {}", schedule.message));
|
||||
|
||||
if !schedule.should_auto_extend {
|
||||
@@ -90,6 +91,7 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
|
||||
return;
|
||||
};
|
||||
|
||||
crate::dashboard::session_notice(Level::Info, "Session extended.");
|
||||
report(log_format, Level::Info, "Session extended.");
|
||||
session_info = next_session_info;
|
||||
}
|
||||
|
||||
@@ -30,7 +30,13 @@ async fn embedded_collector_reports_missing_helpers_without_recursing_or_exposin
|
||||
let output = tokio::time::timeout(
|
||||
Duration::from_secs(30),
|
||||
Command::new(env!("CARGO_BIN_EXE_gpclient"))
|
||||
.args(["--fix-openssl", "diagnostics", "--json", "--output"])
|
||||
.args([
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
"--fix-openssl",
|
||||
"diagnostics",
|
||||
"--json",
|
||||
"--output",
|
||||
])
|
||||
.arg(&report_file)
|
||||
.env("PATH", format!("{}:/usr/bin:/bin", bin.display()))
|
||||
.env("GP_AUTH_BINARY", dir.path().join("missing-gpauth"))
|
||||
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
//! Compiled by the PTY test with -C panic=abort against the production hook.
|
||||
#[path = "../../src/dashboard/restoration.rs"]
|
||||
mod restoration;
|
||||
|
||||
use std::{fs::{File, OpenOptions}, io::{Read, Write}, os::fd::{AsRawFd, FromRawFd}, sync::Arc};
|
||||
|
||||
fn main() {
|
||||
let tty = OpenOptions::new().read(true).write(true).open("/dev/tty").unwrap();
|
||||
let error = Arc::new(unsafe { File::from_raw_fd(nix::libc::fcntl(2, nix::libc::F_DUPFD_CLOEXEC, 3)) });
|
||||
let input_flags = nix::fcntl::FdFlag::from_bits_truncate(unsafe { nix::libc::fcntl(0, nix::libc::F_GETFD) });
|
||||
let previous = std::panic::take_hook();
|
||||
std::panic::set_hook(Box::new(move |panic| {
|
||||
assert_eq!(unsafe { nix::libc::fcntl(0, nix::libc::F_GETFD) }, input_flags.bits());
|
||||
previous(panic);
|
||||
eprintln!("ABORT_HOOK_RESTORED");
|
||||
let mut acknowledgement = String::new();
|
||||
std::io::stdin().read_line(&mut acknowledgement).unwrap();
|
||||
}));
|
||||
let restore = restoration::TerminalRestoration::install(tty.try_clone().unwrap(), error.clone(), None, input_flags).unwrap();
|
||||
restore.arm();
|
||||
unsafe { nix::libc::fcntl(0, nix::libc::F_SETFD, input_flags.bits() | nix::libc::FD_CLOEXEC); }
|
||||
let mut termios = std::mem::MaybeUninit::uninit();
|
||||
unsafe {
|
||||
assert_eq!(nix::libc::tcgetattr(tty.as_raw_fd(), termios.as_mut_ptr()), 0);
|
||||
let mut raw = termios.assume_init();
|
||||
nix::libc::cfmakeraw(&mut raw);
|
||||
assert_eq!(nix::libc::tcsetattr(tty.as_raw_fd(), nix::libc::TCSANOW, &raw), 0);
|
||||
}
|
||||
(&*error).write_all(b"\x1b[?1049hABORT_FIXTURE_READY").unwrap();
|
||||
let mut trigger = [0];
|
||||
(&tty).read_exact(&mut trigger).unwrap();
|
||||
panic!("intentional abort-hook fixture panic");
|
||||
}
|
||||
@@ -250,7 +250,7 @@ async fn run_installer_connection(
|
||||
};
|
||||
let _ = command.reply.send(result);
|
||||
}
|
||||
ServerMessage::Event { .. } | ServerMessage::Snapshot { .. } => {}
|
||||
ServerMessage::Event { .. } | ServerMessage::Snapshot { .. } | ServerMessage::TunnelStatistics { .. } => {}
|
||||
ServerMessage::Attached { .. } => bail!("Service sent a duplicate attach response"),
|
||||
},
|
||||
Message::Ping(data) => socket.send(Message::Pong(data)).await?,
|
||||
@@ -631,6 +631,7 @@ mod tests {
|
||||
current_revision: 0,
|
||||
snapshot: VpnEnv {
|
||||
vpn_state: VpnState::Disconnected,
|
||||
tunnel_state: None,
|
||||
vpnc_script: None,
|
||||
auth_executable: String::new(),
|
||||
host_info: HostInfo {
|
||||
|
||||
@@ -8,8 +8,8 @@ license.workspace = true
|
||||
common = { path = "../../crates/common" }
|
||||
gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] }
|
||||
gphip = { path = "../../crates/gphip" }
|
||||
gptunnel = { path = "../../crates/gptunnel" }
|
||||
base64.workspace = true
|
||||
sha256.workspace = true
|
||||
openconnect = { path = "../../crates/openconnect" }
|
||||
clap.workspace = true
|
||||
anyhow.workspace = true
|
||||
@@ -37,3 +37,6 @@ nix = { version = "0.31", features = ["fs", "socket", "user"] }
|
||||
[dev-dependencies]
|
||||
openssl.workspace = true
|
||||
tokio-tungstenite = "0.29"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
gpvpnc = { path = "../../crates/gpvpnc" }
|
||||
@@ -119,23 +119,13 @@ impl Cli {
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let brokered_scripts_dir = if externally_brokered {
|
||||
let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
|
||||
let contents_dir = executable
|
||||
.parent()
|
||||
.and_then(std::path::Path::parent)
|
||||
.context("gpservice is not inside a macOS application bundle")?;
|
||||
Some(contents_dir.join("Resources/Scripts"))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let (mut vpn_task, lifecycle) = VpnTask::new(vpn_state_tx, externally_brokered, Arc::clone(®istry));
|
||||
let dispatcher = Arc::new(RequestDispatcher::new(
|
||||
lifecycle.clone(),
|
||||
Arc::clone(&gui_restart_requested),
|
||||
Arc::clone(&redaction),
|
||||
!externally_brokered,
|
||||
brokered_scripts_dir,
|
||||
externally_brokered,
|
||||
));
|
||||
#[cfg(target_os = "macos")]
|
||||
let idle_vpn_state_rx = vpn_state_rx.clone();
|
||||
|
||||
@@ -7,7 +7,7 @@ use std::{
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use base64::{Engine, engine::general_purpose::STANDARD};
|
||||
use gpapi::hip::HipApprovalStatus;
|
||||
use gpapi::{hip::HipApprovalStatus, utils::checksum::sha256_hex};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use tempfile::Builder;
|
||||
use uuid::Uuid;
|
||||
@@ -169,7 +169,7 @@ fn install_at(
|
||||
let info = ApprovalInfo {
|
||||
approval_id: approval_id.clone(),
|
||||
owner_uid: approving_uid,
|
||||
sha256: sha256::digest(contents),
|
||||
sha256: sha256_hex(contents),
|
||||
original_path,
|
||||
};
|
||||
let staged = Builder::new().prefix(".install-").tempdir_in(base)?;
|
||||
@@ -232,7 +232,7 @@ fn resolve_at_with_control(
|
||||
}
|
||||
ensure!(!contents.is_empty(), "Approved HIP script is empty");
|
||||
ensure!(
|
||||
sha256::digest(&contents) == info.sha256,
|
||||
sha256_hex(&contents) == info.sha256,
|
||||
"Approved HIP script digest mismatch"
|
||||
);
|
||||
control.check()?;
|
||||
|
||||
@@ -78,16 +78,19 @@ pub struct RequestDispatcher {
|
||||
redaction: Arc<Redaction>,
|
||||
install_lock: Mutex<()>,
|
||||
gui_management_enabled: bool,
|
||||
brokered_scripts_dir: Option<std::path::PathBuf>,
|
||||
externally_brokered: bool,
|
||||
}
|
||||
|
||||
impl RequestDispatcher {
|
||||
pub fn subscribe_tunnel(&self) -> tokio::sync::watch::Receiver<crate::vpn_task::TunnelBinding> {
|
||||
self.lifecycle.subscribe_tunnel()
|
||||
}
|
||||
pub fn new(
|
||||
lifecycle: crate::vpn_task::LifecycleHandle,
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
redaction: Arc<Redaction>,
|
||||
gui_management_enabled: bool,
|
||||
brokered_scripts_dir: Option<std::path::PathBuf>,
|
||||
externally_brokered: bool,
|
||||
) -> Self {
|
||||
Self {
|
||||
lifecycle,
|
||||
@@ -95,7 +98,7 @@ impl RequestDispatcher {
|
||||
redaction,
|
||||
install_lock: Mutex::new(()),
|
||||
gui_management_enabled,
|
||||
brokered_scripts_dir,
|
||||
externally_brokered,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -108,7 +111,7 @@ impl RequestDispatcher {
|
||||
) -> Result<PendingDispatch, ServiceResult> {
|
||||
match request {
|
||||
WsRequest::Connect(request) => {
|
||||
if let Err(message) = self.validate_connect_paths(&request) {
|
||||
if let Err(message) = self.validate_connect_request(&request) {
|
||||
return Err(ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message));
|
||||
}
|
||||
let redaction_values = request
|
||||
@@ -197,12 +200,8 @@ impl RequestDispatcher {
|
||||
desktop_uid,
|
||||
edited_report,
|
||||
} => {
|
||||
let prepared = crate::vpn_task::prepare_connection(
|
||||
*request,
|
||||
self.brokered_scripts_dir.is_some(),
|
||||
preparation.cancellation(),
|
||||
)
|
||||
.await;
|
||||
let prepared =
|
||||
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) => {
|
||||
@@ -271,19 +270,19 @@ impl RequestDispatcher {
|
||||
| WsRequest::PreviewHipReport(_)
|
||||
| WsRequest::GetHipApprovalStatus { .. }
|
||||
| WsRequest::ReadHipPreviewChunk(_)
|
||||
| WsRequest::GetLastSubmittedHipReport => {
|
||||
| WsRequest::GetLastSubmittedHipReport
|
||||
| WsRequest::SetTunnelStatisticsEnabled { .. } => {
|
||||
unreachable!("session-bound request was already dispatched")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
|
||||
let Some(scripts) = &self.brokered_scripts_dir else {
|
||||
fn validate_connect_request(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
|
||||
if !self.externally_brokered {
|
||||
return Ok(());
|
||||
};
|
||||
let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned();
|
||||
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
|
||||
return Err("macOS VPN script must be the bundled script");
|
||||
}
|
||||
if request.args().vpnc_script().is_some() {
|
||||
return Err("macOS does not support custom VPN scripts");
|
||||
}
|
||||
if matches!(
|
||||
request.args().hip_source(),
|
||||
@@ -520,7 +519,7 @@ mod tests {
|
||||
#[test]
|
||||
fn installs_gui_at_the_supplied_target() {
|
||||
let archive = compressed_gui_archive(b"gui binary");
|
||||
let checksum = sha256::try_digest(archive.path()).unwrap();
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpclient/gpgui");
|
||||
|
||||
@@ -549,7 +548,7 @@ mod tests {
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
false,
|
||||
Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
|
||||
true,
|
||||
);
|
||||
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else {
|
||||
panic!("brokered mode accepted GUI restart");
|
||||
@@ -558,9 +557,7 @@ mod tests {
|
||||
|
||||
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
|
||||
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
|
||||
let request = test_request(info)
|
||||
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
|
||||
.with_certificate(Some("/Users/example/client.pem".to_string()));
|
||||
let request = test_request(info).with_certificate(Some("/Users/example/client.pem".to_string()));
|
||||
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
|
||||
panic!("brokered mode accepted a root-readable identity path");
|
||||
};
|
||||
@@ -568,33 +565,37 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brokered_mode_accepts_only_resource_script_paths() {
|
||||
fn brokered_mode_rejects_script_overrides() {
|
||||
let dispatcher = RequestDispatcher::new(
|
||||
crate::vpn_task::LifecycleHandle::for_tests(),
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
false,
|
||||
Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
|
||||
true,
|
||||
);
|
||||
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
|
||||
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
|
||||
let bundled =
|
||||
test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
|
||||
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
|
||||
let embedded = test_request(info.clone());
|
||||
assert_eq!(dispatcher.validate_connect_request(&embedded), Ok(()));
|
||||
|
||||
let old_layout = test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_paths(&old_layout),
|
||||
Err("macOS VPN script must be the bundled script")
|
||||
);
|
||||
for script in [
|
||||
"/app/Contents/Resources/Scripts/vpnc-script",
|
||||
"/tmp/custom-vpnc-script",
|
||||
"echo untrusted",
|
||||
"",
|
||||
] {
|
||||
let custom = test_request(info.clone()).with_vpnc_script(Some(script.to_string()));
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_request(&custom),
|
||||
Err("macOS does not support custom VPN scripts")
|
||||
);
|
||||
}
|
||||
|
||||
let custom = test_request(info)
|
||||
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
|
||||
.with_hip_source(gpapi::hip::HipSource::UserScript {
|
||||
path: "/tmp/hip.sh".into(),
|
||||
});
|
||||
let custom = test_request(info).with_hip_source(gpapi::hip::HipSource::UserScript {
|
||||
path: "/tmp/hip.sh".into(),
|
||||
});
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_paths(&custom),
|
||||
dispatcher.validate_connect_request(&custom),
|
||||
Err("macOS does not support custom HIP scripts")
|
||||
);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
use gpapi::service::request::ConnectArgs;
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> anyhow::Result<VpnBuilder> {
|
||||
anyhow::ensure!(
|
||||
args.vpnc_script().is_none(),
|
||||
"macOS does not support custom VPN scripts"
|
||||
);
|
||||
Ok(
|
||||
Vpn::builder(server, cookie).network_configuration_handler(|configuration| {
|
||||
gpvpnc::macos::configure_network(&configuration.reason, &configuration.environment)
|
||||
}),
|
||||
)
|
||||
}
|
||||
@@ -1,7 +1,15 @@
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[path = "privileged_unix.rs"]
|
||||
mod platform;
|
||||
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "macos.rs"]
|
||||
mod platform;
|
||||
#[cfg(not(any(
|
||||
target_os = "linux",
|
||||
target_os = "freebsd",
|
||||
target_os = "openbsd",
|
||||
target_os = "macos"
|
||||
)))]
|
||||
#[path = "default.rs"]
|
||||
mod platform;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
|
||||
|
||||
@@ -32,9 +32,20 @@ mod runtime;
|
||||
pub(crate) struct LifecycleHandle {
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
admissions: Arc<Mutex<Admissions>>,
|
||||
tunnel: watch::Sender<TunnelBinding>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
pub(crate) struct TunnelBinding {
|
||||
pub attempt: u64,
|
||||
pub monitor: Option<Arc<gptunnel::TunnelMonitor>>,
|
||||
pub non_tunnel: bool,
|
||||
}
|
||||
|
||||
impl LifecycleHandle {
|
||||
pub fn subscribe_tunnel(&self) -> watch::Receiver<TunnelBinding> {
|
||||
self.tunnel.subscribe()
|
||||
}
|
||||
pub fn reserve_connect(&self) -> Result<ConnectReservation, ServiceResult> {
|
||||
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
|
||||
if admissions.closed {
|
||||
@@ -370,6 +381,10 @@ enum AdmissionPhase {
|
||||
}
|
||||
|
||||
enum LifecycleEvent {
|
||||
TunnelMonitor {
|
||||
attempt: u64,
|
||||
monitor: Arc<gptunnel::TunnelMonitor>,
|
||||
},
|
||||
Start {
|
||||
attempt: u64,
|
||||
connection: PreparedConnection,
|
||||
@@ -429,6 +444,7 @@ impl VpnTask {
|
||||
let lifecycle = LifecycleHandle {
|
||||
events: events_tx,
|
||||
admissions: Arc::new(Mutex::new(Admissions::default())),
|
||||
tunnel: watch::channel(TunnelBinding::default()).0,
|
||||
};
|
||||
let task = Self {
|
||||
events,
|
||||
@@ -493,6 +509,16 @@ impl VpnTask {
|
||||
|
||||
async fn handle_event(&mut self, event: LifecycleEvent) {
|
||||
match event {
|
||||
LifecycleEvent::TunnelMonitor { attempt, monitor } => {
|
||||
if self.active.as_ref().is_some_and(|active| active.attempt == attempt) {
|
||||
let non_tunnel = false;
|
||||
self.lifecycle.tunnel.send_replace(TunnelBinding {
|
||||
attempt,
|
||||
monitor: Some(monitor),
|
||||
non_tunnel,
|
||||
});
|
||||
}
|
||||
}
|
||||
LifecycleEvent::Start {
|
||||
attempt,
|
||||
connection,
|
||||
@@ -526,6 +552,16 @@ impl VpnTask {
|
||||
session_id: Option<Uuid>,
|
||||
) {
|
||||
let activated = self.lifecycle.activate_attempt(attempt);
|
||||
self.lifecycle.tunnel.send_replace(TunnelBinding {
|
||||
attempt,
|
||||
monitor: None,
|
||||
non_tunnel: connection
|
||||
.request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel),
|
||||
});
|
||||
let info = connection.request.info().clone();
|
||||
let allow_extend_session = connection.request.args().allow_extend_session();
|
||||
let cancellation = self.lifecycle.attempt_cancellation(attempt);
|
||||
@@ -661,6 +697,12 @@ impl VpnTask {
|
||||
if let Some(session_id) = active.session_id {
|
||||
self.registry.clear_successful_hip_report(session_id);
|
||||
}
|
||||
if self.lifecycle.tunnel.borrow().monitor.is_none() {
|
||||
self.lifecycle.tunnel.send_replace(TunnelBinding {
|
||||
attempt,
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
if let Some(reason) = active.failure {
|
||||
self.send_state(VpnState::Failed(reason));
|
||||
self.lifecycle.clear_attempt(attempt);
|
||||
@@ -815,49 +857,22 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
fn identity_material() -> (openssl::pkey::PKey<openssl::pkey::Private>, openssl::x509::X509) {
|
||||
use openssl::{
|
||||
asn1::Asn1Time,
|
||||
hash::MessageDigest,
|
||||
pkey::PKey,
|
||||
rsa::Rsa,
|
||||
x509::{X509, X509NameBuilder},
|
||||
};
|
||||
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
|
||||
let mut name = X509NameBuilder::new().unwrap();
|
||||
name.append_entry_by_text("CN", "service-identity-fixture").unwrap();
|
||||
let name = name.build();
|
||||
let mut certificate = X509::builder().unwrap();
|
||||
certificate.set_version(2).unwrap();
|
||||
certificate.set_subject_name(&name).unwrap();
|
||||
certificate.set_issuer_name(&name).unwrap();
|
||||
certificate.set_pubkey(&key).unwrap();
|
||||
certificate
|
||||
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
|
||||
.unwrap();
|
||||
certificate.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
|
||||
certificate.sign(&key, MessageDigest::sha256()).unwrap();
|
||||
(key, certificate.build())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tunnel_identity_paths_allow_large_files_and_retain_loaded_material() {
|
||||
let (key, certificate) = identity_material();
|
||||
let certificate = include_bytes!("../../../crates/gpapi/tests/files/client-identity/rsa-cert.pem");
|
||||
let key = include_bytes!("../../../crates/gpapi/tests/files/client-identity/rsa-pkcs8.pem");
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let path = directory.path().join("identity.pem");
|
||||
let mut pem = certificate.to_pem().unwrap();
|
||||
pem.extend(key.private_key_to_pem_pkcs8().unwrap());
|
||||
let mut pem = certificate.to_vec();
|
||||
pem.extend(key);
|
||||
pem.resize(gpapi::service::request::MAX_CLIENT_IDENTITY_DATA + 1, b'\n');
|
||||
std::fs::write(&path, pem).unwrap();
|
||||
let request = identity_request().with_certificate(Some(path.to_str().unwrap().into()));
|
||||
let identity = prepare_identity(request.args(), false).unwrap().unwrap();
|
||||
std::fs::remove_file(path).unwrap();
|
||||
assert_eq!(identity.certificate_data(), certificate.to_pem().unwrap());
|
||||
assert_eq!(identity.certificate_data(), certificate);
|
||||
let files = identity.write_files(None).unwrap();
|
||||
assert_eq!(
|
||||
std::fs::read(files.certificate()).unwrap(),
|
||||
certificate.to_pem().unwrap()
|
||||
);
|
||||
assert_eq!(std::fs::read(files.certificate()).unwrap(), certificate);
|
||||
assert!(files.key().is_some());
|
||||
}
|
||||
|
||||
@@ -881,17 +896,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn protected_pkcs12_import_retains_password_and_single_file_material() {
|
||||
use openssl::pkcs12::Pkcs12;
|
||||
let (key, certificate) = identity_material();
|
||||
let password = "service-fixture-password";
|
||||
let p12 = Pkcs12::builder()
|
||||
.name("fixture")
|
||||
.pkey(&key)
|
||||
.cert(&certificate)
|
||||
.build2(password)
|
||||
.unwrap()
|
||||
.to_der()
|
||||
.unwrap();
|
||||
let password = "fixture-password";
|
||||
let p12 = include_bytes!("../../../crates/gpapi/tests/files/client-identity/modern.p12").to_vec();
|
||||
let request = identity_request()
|
||||
.with_certificate_data(Some(p12.clone()))
|
||||
.with_key_password(Some(password.into()));
|
||||
|
||||
@@ -262,6 +262,18 @@ async fn run_tunnel(
|
||||
if cancellation.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
let monitor = gptunnel::TunnelMonitor::attach(prepared.vpn.clone());
|
||||
if events
|
||||
.send(LifecycleEvent::TunnelMonitor {
|
||||
attempt,
|
||||
monitor: monitor.clone(),
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
monitor.stop().await;
|
||||
return;
|
||||
}
|
||||
let vpn = prepared.vpn.clone();
|
||||
// The native tunnel keeps its reconnect endpoint and cookie current and owns
|
||||
// normal logout. The ledger remains responsible only before native execution.
|
||||
@@ -291,6 +303,7 @@ async fn run_tunnel(
|
||||
Ok(code) => warn!("Tunnel worker exited with status {code}"),
|
||||
Err(error) => warn!("Tunnel worker failed: {error}"),
|
||||
}
|
||||
monitor.stop().await;
|
||||
}
|
||||
|
||||
pub(super) fn stop_for_revoked_approval(lifecycle: &LifecycleHandle, cancellation: &CancellationToken) {
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
use std::{collections::HashSet, sync::Arc, time::Duration};
|
||||
use std::{
|
||||
collections::HashSet,
|
||||
sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use axum::extract::ws::{CloseFrame, Message, Utf8Bytes, WebSocket};
|
||||
use futures::StreamExt;
|
||||
@@ -34,6 +41,9 @@ pub(crate) struct ConnectionControl {
|
||||
connection_id: Uuid,
|
||||
tx: mpsc::Sender<ConnectionCommand>,
|
||||
close_tx: watch::Sender<Option<CloseReason>>,
|
||||
statistics: watch::Sender<Option<gpapi::session::tunnel::TunnelStatisticsSnapshot>>,
|
||||
statistics_enabled: Arc<AtomicBool>,
|
||||
committed: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl ConnectionControl {
|
||||
@@ -44,6 +54,9 @@ impl ConnectionControl {
|
||||
connection_id,
|
||||
tx,
|
||||
close_tx,
|
||||
statistics: watch::channel(None).0,
|
||||
statistics_enabled: Arc::new(AtomicBool::new(false)),
|
||||
committed: Arc::new(AtomicBool::new(false)),
|
||||
},
|
||||
close_rx,
|
||||
)
|
||||
@@ -62,9 +75,43 @@ impl ConnectionControl {
|
||||
}
|
||||
|
||||
pub fn close(&self, reason: CloseReason) {
|
||||
self.set_statistics_enabled(false);
|
||||
self.close_tx.send_replace(Some(reason));
|
||||
}
|
||||
|
||||
pub fn mark_committed(&self) {
|
||||
self.committed.store(true, Ordering::Release);
|
||||
}
|
||||
|
||||
pub fn is_committed(&self) -> bool {
|
||||
self.committed.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
pub fn statistics_enabled(&self) -> bool {
|
||||
self.statistics_enabled.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
pub fn set_statistics_enabled(&self, enabled: bool) {
|
||||
self.statistics_enabled.store(enabled, Ordering::Release);
|
||||
if !enabled {
|
||||
self.statistics.send_replace(None);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn clear_statistics(&self) {
|
||||
self.statistics.send_replace(None);
|
||||
}
|
||||
|
||||
pub fn publish_statistics(&self, snapshot: gpapi::session::tunnel::TunnelStatisticsSnapshot) {
|
||||
if self.statistics_enabled() && !self.is_closed() {
|
||||
self.statistics.send_replace(Some(snapshot));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn subscribe_statistics(&self) -> watch::Receiver<Option<gpapi::session::tunnel::TunnelStatisticsSnapshot>> {
|
||||
self.statistics.subscribe()
|
||||
}
|
||||
|
||||
pub async fn send_reply(&self, id: Uuid, result: ServiceResult) {
|
||||
let _ = self.tx.send(ConnectionCommand::Reply { id, result }).await;
|
||||
}
|
||||
@@ -96,12 +143,14 @@ impl WsConnection {
|
||||
|
||||
info!("Authenticated GUI connection {}", control.connection_id());
|
||||
let mut pending_requests = HashSet::new();
|
||||
let mut statistics_rx = control.subscribe_statistics();
|
||||
let mut heartbeat = tokio::time::interval(Duration::from_secs(1));
|
||||
let mut last_outbound = Instant::now();
|
||||
let mut pong_deadline = None;
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
command = command_rx.recv() => {
|
||||
let Some(command) = command else { break };
|
||||
match command {
|
||||
@@ -181,6 +230,16 @@ impl WsConnection {
|
||||
pong_deadline = Some(now + PONG_TIMEOUT);
|
||||
}
|
||||
}
|
||||
changed = statistics_rx.changed() => {
|
||||
if changed.is_err() { break; }
|
||||
let snapshot = statistics_rx.borrow_and_update().clone();
|
||||
if control.statistics_enabled() {
|
||||
if let Some(snapshot) = snapshot {
|
||||
if send_encrypted(&mut socket, &mut noise, &ServerMessage::TunnelStatistics { snapshot }).await.is_err() { break; }
|
||||
last_outbound = Instant::now();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -341,6 +400,14 @@ async fn handle_client_message(
|
||||
return Err(());
|
||||
}
|
||||
|
||||
if let WsRequest::SetTunnelStatisticsEnabled { enabled } = request {
|
||||
let result = ctx
|
||||
.set_statistics_enabled(control, session_id, generation, enabled)
|
||||
.await;
|
||||
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if let WsRequest::StoreEditedHipReportChunk(report) = request {
|
||||
let upload_id = report.upload_id.as_deref().and_then(|id| Uuid::parse_str(id).ok());
|
||||
let result = if report.upload_id.is_some() && upload_id.is_none() {
|
||||
@@ -596,7 +663,7 @@ mod tests {
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
false,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
@@ -669,6 +736,23 @@ mod tests {
|
||||
} if id == request_id
|
||||
));
|
||||
|
||||
let statistics_id = Uuid::new_v4();
|
||||
let request = ClientMessage::Request {
|
||||
id: statistics_id,
|
||||
request: WsRequest::SetTunnelStatisticsEnabled { enabled: true },
|
||||
};
|
||||
socket
|
||||
.send(ClientFrame::Binary(noise.encrypt(&request).unwrap().into()))
|
||||
.await
|
||||
.unwrap();
|
||||
let reply = noise
|
||||
.decrypt::<ServerMessage>(&receive_client_binary(&mut socket).await)
|
||||
.unwrap();
|
||||
assert!(matches!(reply, ServerMessage::Reply {
|
||||
id,
|
||||
result: ServiceResult::TunnelStatisticsSnapshot(gpapi::session::tunnel::TunnelStatisticsSnapshot::Unavailable { reason: gpapi::session::tunnel::TunnelUnavailableReason::NoTunnel }),
|
||||
} if id == statistics_id));
|
||||
|
||||
let update_id = Uuid::new_v4();
|
||||
let update_file = tempfile::NamedTempFile::new().unwrap();
|
||||
std::fs::write(update_file.path(), b"invalid archive").unwrap();
|
||||
|
||||
+371
-18
@@ -9,6 +9,7 @@ use gpapi::{
|
||||
vpn_env::{HostInfo, VpnEnv},
|
||||
vpn_state::VpnState,
|
||||
},
|
||||
session::tunnel::{TunnelStatisticsSnapshot, TunnelUnavailableReason},
|
||||
utils::lock_file::LockFile,
|
||||
};
|
||||
use log::{info, warn};
|
||||
@@ -31,6 +32,28 @@ struct ServiceState {
|
||||
revision: u64,
|
||||
snapshot: VpnEnv,
|
||||
connections: HashMap<Uuid, ConnectionControl>,
|
||||
tunnel: crate::vpn_task::TunnelBinding,
|
||||
}
|
||||
|
||||
impl ServiceState {
|
||||
fn refresh_demand(&self) {
|
||||
if let Some(monitor) = &self.tunnel.monitor {
|
||||
monitor.set_statistics_enabled(
|
||||
self
|
||||
.connections
|
||||
.values()
|
||||
.any(|connection| connection.statistics_enabled() && !connection.is_closed()),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> VpnEnv {
|
||||
let mut snapshot = self.snapshot.clone();
|
||||
if let Some(monitor) = &self.tunnel.monitor {
|
||||
snapshot.tunnel_state = Some(monitor.state());
|
||||
}
|
||||
snapshot
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct WsServerContext {
|
||||
@@ -57,6 +80,7 @@ impl WsServerContext {
|
||||
revision: 0,
|
||||
snapshot: build_snapshot(vpn_state_rx.borrow().clone()),
|
||||
connections: HashMap::new(),
|
||||
tunnel: Default::default(),
|
||||
}),
|
||||
handshake_slots: Arc::new(Semaphore::new(16)),
|
||||
hip_previews: crate::hip_preview::HipPreviews::new(),
|
||||
@@ -91,12 +115,14 @@ impl WsServerContext {
|
||||
let mut state = self.state.lock().await;
|
||||
let prepared = self.registry.prepare_attach(permit)?;
|
||||
|
||||
let mut attached = ServerMessage::Attached {
|
||||
connection_id: control.connection_id(),
|
||||
current_revision: state.revision,
|
||||
snapshot: state.snapshot(),
|
||||
};
|
||||
fit_snapshot_message(&mut attached).map_err(|_| SessionError::Unavailable)?;
|
||||
control
|
||||
.send(ConnectionCommand::Send(ServerMessage::Attached {
|
||||
connection_id: control.connection_id(),
|
||||
current_revision: state.revision,
|
||||
snapshot: state.snapshot.clone(),
|
||||
}))
|
||||
.send(ConnectionCommand::Send(attached))
|
||||
.map_err(|_| SessionError::Unavailable)?;
|
||||
state.connections.insert(control.connection_id(), control);
|
||||
Ok(prepared)
|
||||
@@ -117,42 +143,49 @@ impl WsServerContext {
|
||||
}
|
||||
match self.registry.commit_attach(permit, connection.clone()) {
|
||||
Ok(replaced) => {
|
||||
connection.mark_committed();
|
||||
if let Some(replaced) = &replaced {
|
||||
replaced.set_statistics_enabled(false);
|
||||
state.connections.remove(&replaced.connection_id());
|
||||
}
|
||||
state.refresh_demand();
|
||||
Ok(replaced)
|
||||
}
|
||||
Err(err) => {
|
||||
state.connections.remove(&connection.connection_id());
|
||||
state.refresh_demand();
|
||||
Err(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn abandon_connection(&self, connection_id: Uuid) {
|
||||
self.state.lock().await.connections.remove(&connection_id);
|
||||
let mut state = self.state.lock().await;
|
||||
state.connections.remove(&connection_id);
|
||||
state.refresh_demand();
|
||||
}
|
||||
|
||||
pub async fn remove_closed_connections(&self) {
|
||||
self
|
||||
.state
|
||||
.lock()
|
||||
.await
|
||||
.connections
|
||||
.retain(|_, connection| !connection.is_closed());
|
||||
let mut state = self.state.lock().await;
|
||||
state.connections.retain(|_, connection| !connection.is_closed());
|
||||
state.refresh_demand();
|
||||
}
|
||||
|
||||
pub async fn send_snapshot(&self, control: &ConnectionControl) -> Result<(), ()> {
|
||||
let state = self.state.lock().await;
|
||||
control.send(ConnectionCommand::Send(ServerMessage::Snapshot {
|
||||
let mut message = ServerMessage::Snapshot {
|
||||
current_revision: state.revision,
|
||||
snapshot: state.snapshot.clone(),
|
||||
}))
|
||||
snapshot: state.snapshot(),
|
||||
};
|
||||
fit_snapshot_message(&mut message)?;
|
||||
control.send(ConnectionCommand::Send(message))
|
||||
}
|
||||
|
||||
pub async fn remove_connection(&self, connection_id: Uuid, session_id: Uuid, generation: u64) {
|
||||
self.registry.disconnect_if_current(session_id, generation);
|
||||
self.state.lock().await.connections.remove(&connection_id);
|
||||
let mut state = self.state.lock().await;
|
||||
state.connections.remove(&connection_id);
|
||||
state.refresh_demand();
|
||||
}
|
||||
|
||||
pub async fn send_event(&self, event: WsEvent) {
|
||||
@@ -161,6 +194,8 @@ impl WsServerContext {
|
||||
state.snapshot = env.clone();
|
||||
} else if let WsEvent::VpnState(vpn_state) = &event {
|
||||
state.snapshot.vpn_state = vpn_state.clone();
|
||||
} else if let WsEvent::TunnelState(tunnel) = &event {
|
||||
state.snapshot.tunnel_state = tunnel.clone();
|
||||
}
|
||||
|
||||
let Some(revision) = state.revision.checked_add(1) else {
|
||||
@@ -168,6 +203,7 @@ impl WsServerContext {
|
||||
connection.close(CloseReason::InternalError);
|
||||
}
|
||||
state.connections.clear();
|
||||
state.refresh_demand();
|
||||
return;
|
||||
};
|
||||
state.revision = revision;
|
||||
@@ -186,6 +222,97 @@ impl WsServerContext {
|
||||
false
|
||||
}
|
||||
});
|
||||
state.refresh_demand();
|
||||
}
|
||||
|
||||
pub async fn set_statistics_enabled(
|
||||
&self,
|
||||
control: &ConnectionControl,
|
||||
session_id: Uuid,
|
||||
generation: u64,
|
||||
enabled: bool,
|
||||
) -> gpapi::service::transport::ServiceResult {
|
||||
use gpapi::service::transport::{ServiceErrorCode, ServiceResult};
|
||||
let state = self.state.lock().await;
|
||||
if !control.is_committed()
|
||||
|| control.is_closed()
|
||||
|| !state.connections.contains_key(&control.connection_id())
|
||||
|| !self.registry.is_current(session_id, generation)
|
||||
{
|
||||
return ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"Service attachment is no longer active",
|
||||
);
|
||||
}
|
||||
control.set_statistics_enabled(enabled);
|
||||
state.refresh_demand();
|
||||
let snapshot = match &state.tunnel.monitor {
|
||||
Some(monitor) => monitor.statistics(),
|
||||
None => TunnelStatisticsSnapshot::Unavailable {
|
||||
reason: if state.tunnel.non_tunnel {
|
||||
TunnelUnavailableReason::NonTunnel
|
||||
} else {
|
||||
TunnelUnavailableReason::NoTunnel
|
||||
},
|
||||
},
|
||||
};
|
||||
ServiceResult::TunnelStatisticsSnapshot(if enabled { snapshot } else { snapshot.disabled() })
|
||||
}
|
||||
|
||||
async fn bind_tunnel(&self, binding: crate::vpn_task::TunnelBinding) {
|
||||
let mut state = self.state.lock().await;
|
||||
if let Some(previous) = &state.tunnel.monitor {
|
||||
previous.set_statistics_enabled(false);
|
||||
}
|
||||
state.tunnel = binding;
|
||||
for connection in state.connections.values() {
|
||||
connection.clear_statistics();
|
||||
}
|
||||
state.refresh_demand();
|
||||
let tunnel_state = state.tunnel.monitor.as_ref().map(|monitor| monitor.state());
|
||||
drop(state);
|
||||
self.send_event(WsEvent::TunnelState(tunnel_state)).await;
|
||||
let state = self.state.lock().await;
|
||||
let snapshot = match &state.tunnel.monitor {
|
||||
Some(monitor) => monitor.statistics(),
|
||||
None => TunnelStatisticsSnapshot::unavailable(if state.tunnel.non_tunnel {
|
||||
TunnelUnavailableReason::NonTunnel
|
||||
} else {
|
||||
TunnelUnavailableReason::NoTunnel
|
||||
}),
|
||||
};
|
||||
for connection in state.connections.values() {
|
||||
connection.publish_statistics(snapshot.clone());
|
||||
}
|
||||
}
|
||||
|
||||
async fn publish_tunnel(&self, attempt: u64) {
|
||||
let state = self.state.lock().await;
|
||||
if state.tunnel.attempt != attempt {
|
||||
return;
|
||||
}
|
||||
let Some(monitor) = &state.tunnel.monitor else {
|
||||
return;
|
||||
};
|
||||
let current = monitor.state();
|
||||
let changed = state
|
||||
.snapshot
|
||||
.tunnel_state
|
||||
.as_ref()
|
||||
.is_none_or(|previous| previous.tunnel_id != current.tunnel_id || previous.sequence != current.sequence);
|
||||
drop(state);
|
||||
if changed {
|
||||
self.send_event(WsEvent::TunnelState(Some(current))).await;
|
||||
}
|
||||
let state = self.state.lock().await;
|
||||
if state.tunnel.attempt != attempt {
|
||||
return;
|
||||
}
|
||||
if let Some(monitor) = &state.tunnel.monitor {
|
||||
for connection in state.connections.values() {
|
||||
connection.publish_statistics(monitor.statistics());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -240,6 +367,7 @@ impl WsServer {
|
||||
_ = watch_vpn_state(self.vpn_state_rx.clone(), Arc::clone(&self.ctx)) => {
|
||||
info!("VPN state watch task completed");
|
||||
}
|
||||
_ = watch_tunnel(self.ctx.dispatcher.subscribe_tunnel(), Arc::clone(&self.ctx)) => {}
|
||||
result = axum::serve(listener, routes::routes(Arc::clone(&self.ctx))) => {
|
||||
if let Err(err) = result {
|
||||
warn!("WS server stopped: {err}");
|
||||
@@ -264,6 +392,7 @@ impl WsServer {
|
||||
|
||||
fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
|
||||
VpnEnv {
|
||||
tunnel_state: None,
|
||||
vpn_state,
|
||||
vpnc_script: find_vpnc_script(),
|
||||
auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(),
|
||||
@@ -273,6 +402,36 @@ fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the observation's explicit truncation policy to the space remaining in
|
||||
/// a complete envelope. Existing host/connection facts are never shortened.
|
||||
fn fit_snapshot_message(message: &mut ServerMessage) -> Result<(), ()> {
|
||||
let encoded_size = serde_json::to_vec(&message).map_err(|_| ())?.len();
|
||||
let Some(excess) = encoded_size.checked_sub(gpapi::service::transport::MAX_PLAINTEXT) else {
|
||||
return Ok(());
|
||||
};
|
||||
if excess == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
let snapshot = match message {
|
||||
ServerMessage::Attached { snapshot, .. } | ServerMessage::Snapshot { snapshot, .. } => snapshot,
|
||||
_ => return Err(()),
|
||||
};
|
||||
let configuration = snapshot
|
||||
.tunnel_state
|
||||
.as_mut()
|
||||
.and_then(|state| state.configuration.as_mut())
|
||||
.ok_or(())?;
|
||||
let configuration_size = serde_json::to_vec(&configuration).map_err(|_| ())?.len();
|
||||
let remaining = configuration_size.checked_sub(excess).ok_or(())?;
|
||||
if !configuration.limit_encoded_size(remaining) {
|
||||
return Err(());
|
||||
}
|
||||
if serde_json::to_vec(message).map_err(|_| ())?.len() > gpapi::service::transport::MAX_PLAINTEXT {
|
||||
return Err(());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::{Arc, atomic::AtomicBool};
|
||||
@@ -285,6 +444,171 @@ mod tests {
|
||||
|
||||
use super::*;
|
||||
|
||||
fn context() -> (Arc<WsServerContext>, Arc<SessionRegistry>) {
|
||||
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
|
||||
let dispatcher = Arc::new(RequestDispatcher::new(
|
||||
crate::vpn_task::LifecycleHandle::for_tests(),
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
false,
|
||||
));
|
||||
let (_, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
(
|
||||
Arc::new(WsServerContext::new(
|
||||
env!("CARGO_PKG_VERSION"),
|
||||
registry.clone(),
|
||||
dispatcher,
|
||||
&state_rx,
|
||||
)),
|
||||
registry,
|
||||
)
|
||||
}
|
||||
|
||||
async fn attach(
|
||||
context: &WsServerContext,
|
||||
registry: &Arc<SessionRegistry>,
|
||||
) -> (ConnectionControl, Uuid, u64, mpsc::Receiver<ConnectionCommand>) {
|
||||
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
|
||||
let permit = registry
|
||||
.begin_handshake(
|
||||
credential.service_instance_id(),
|
||||
credential.session_id(),
|
||||
credential.product_version(),
|
||||
)
|
||||
.unwrap();
|
||||
let (tx, mut rx) = mpsc::channel(8);
|
||||
let (control, _) = ConnectionControl::new(Uuid::new_v4(), tx);
|
||||
let prepared = context.prepare_connection(&permit, control.clone()).await.unwrap();
|
||||
rx.recv().await.unwrap();
|
||||
context.commit_connection(&permit, &control).await.unwrap();
|
||||
(control, credential.session_id(), prepared.generation, rx)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn statistics_demand_is_per_attachment_and_does_not_consume_revisions() {
|
||||
use gpapi::service::transport::ServiceResult;
|
||||
use gpapi::session::tunnel::TunnelStatisticsState;
|
||||
let (context, registry) = context();
|
||||
let (a, a_session, a_generation, _a_rx) = attach(&context, ®istry).await;
|
||||
let (b, b_session, b_generation, _b_rx) = attach(&context, ®istry).await;
|
||||
let vpn = Arc::new(
|
||||
openconnect::Vpn::builder("vpn.example.com", "cookie")
|
||||
.network_configuration_handler(|_| Ok(()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
);
|
||||
let monitor = gptunnel::TunnelMonitor::attach(vpn);
|
||||
context
|
||||
.bind_tunnel(crate::vpn_task::TunnelBinding {
|
||||
attempt: 1,
|
||||
monitor: Some(monitor.clone()),
|
||||
non_tunnel: false,
|
||||
})
|
||||
.await;
|
||||
let revision = context.state.lock().await.revision;
|
||||
for (connection, session, generation) in [(&a, a_session, a_generation), (&b, b_session, b_generation)] {
|
||||
assert!(matches!(
|
||||
context
|
||||
.set_statistics_enabled(connection, session, generation, true)
|
||||
.await,
|
||||
ServiceResult::TunnelStatisticsSnapshot(_)
|
||||
));
|
||||
}
|
||||
assert_eq!(
|
||||
monitor.statistics().view().unwrap().state,
|
||||
TunnelStatisticsState::Waiting
|
||||
);
|
||||
let ServiceResult::TunnelStatisticsSnapshot(disabled) =
|
||||
context.set_statistics_enabled(&b, b_session, b_generation, false).await
|
||||
else {
|
||||
panic!("expected snapshot");
|
||||
};
|
||||
assert_eq!(disabled.view().unwrap().state, TunnelStatisticsState::Disabled);
|
||||
assert_eq!(
|
||||
monitor.statistics().view().unwrap().state,
|
||||
TunnelStatisticsState::Waiting
|
||||
);
|
||||
context
|
||||
.remove_connection(a.connection_id(), a_session, a_generation)
|
||||
.await;
|
||||
assert_eq!(
|
||||
monitor.statistics().view().unwrap().state,
|
||||
TunnelStatisticsState::Disabled
|
||||
);
|
||||
assert_eq!(context.state.lock().await.revision, revision);
|
||||
monitor.stop().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sample_slot_coalesces_without_consuming_control_queue_and_disable_clears_it() {
|
||||
let (context, registry) = context();
|
||||
let (control, session, generation, mut commands) = attach(&context, ®istry).await;
|
||||
context
|
||||
.set_statistics_enabled(&control, session, generation, true)
|
||||
.await;
|
||||
let mut samples = control.subscribe_statistics();
|
||||
let snapshot = TunnelStatisticsSnapshot::unavailable(TunnelUnavailableReason::NoTunnel);
|
||||
for _ in 0..1000 {
|
||||
control.publish_statistics(snapshot.clone());
|
||||
}
|
||||
assert_eq!(samples.borrow_and_update().as_ref(), Some(&snapshot));
|
||||
assert!(commands.try_recv().is_err());
|
||||
context
|
||||
.set_statistics_enabled(&control, session, generation, false)
|
||||
.await;
|
||||
assert!(samples.borrow().is_none());
|
||||
control.publish_statistics(snapshot);
|
||||
assert!(samples.borrow().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snapshot_budget_trims_observation_without_changing_existing_metadata() {
|
||||
use gpapi::session::tunnel::{TunnelConfiguration, TunnelPhase, TunnelState, TunnelTransport};
|
||||
let mut snapshot = build_snapshot(VpnState::Disconnected);
|
||||
let mut configuration = TunnelConfiguration::default();
|
||||
configuration.included_routes.items = vec!["r".repeat(1000); 15];
|
||||
configuration.included_routes.total_count = 15;
|
||||
snapshot.tunnel_state = Some(TunnelState {
|
||||
tunnel_id: Uuid::nil(),
|
||||
sequence: 4,
|
||||
phase: TunnelPhase::Connected,
|
||||
configuration_revision: 1,
|
||||
configuration: Some(configuration),
|
||||
transport: TunnelTransport::IpsecEsp,
|
||||
elapsed_ms: 600_000,
|
||||
});
|
||||
let original_metadata = "a".repeat(52_000);
|
||||
snapshot.auth_executable = original_metadata.clone();
|
||||
let mut message = ServerMessage::Snapshot {
|
||||
current_revision: 9,
|
||||
snapshot,
|
||||
};
|
||||
assert!(serde_json::to_vec(&message).unwrap().len() > gpapi::service::transport::MAX_PLAINTEXT);
|
||||
fit_snapshot_message(&mut message).unwrap();
|
||||
assert!(serde_json::to_vec(&message).unwrap().len() <= gpapi::service::transport::MAX_PLAINTEXT);
|
||||
let ServerMessage::Snapshot {
|
||||
mut snapshot,
|
||||
current_revision,
|
||||
} = message
|
||||
else {
|
||||
unreachable!()
|
||||
};
|
||||
assert_eq!(current_revision, 9);
|
||||
assert_eq!(snapshot.auth_executable, original_metadata);
|
||||
let configuration = snapshot.tunnel_state.as_ref().unwrap().configuration.as_ref().unwrap();
|
||||
assert!(configuration.included_routes.truncated);
|
||||
assert_eq!(configuration.included_routes.total_count, 15);
|
||||
snapshot.auth_executable = "a".repeat(gpapi::service::transport::MAX_PLAINTEXT);
|
||||
assert!(
|
||||
fit_snapshot_message(&mut ServerMessage::Snapshot {
|
||||
current_revision: 9,
|
||||
snapshot
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn resync_snapshot_is_ordered_with_state_events() {
|
||||
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
|
||||
@@ -301,7 +625,7 @@ mod tests {
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
false,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
@@ -351,7 +675,7 @@ mod tests {
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
Arc::new(Redaction::new()),
|
||||
true,
|
||||
None,
|
||||
false,
|
||||
));
|
||||
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let context = Arc::new(WsServerContext::new(
|
||||
@@ -397,3 +721,32 @@ async fn watch_vpn_state(mut vpn_state_rx: watch::Receiver<VpnState>, ctx: Arc<W
|
||||
ctx.send_event(WsEvent::VpnState(vpn_state)).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn watch_tunnel(mut binding_rx: watch::Receiver<crate::vpn_task::TunnelBinding>, ctx: Arc<WsServerContext>) {
|
||||
loop {
|
||||
let binding = binding_rx.borrow_and_update().clone();
|
||||
let mut updates = binding.monitor.as_ref().map(|monitor| monitor.subscribe());
|
||||
let attempt = binding.attempt;
|
||||
ctx.bind_tunnel(binding).await;
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
changed = binding_rx.changed() => {
|
||||
if changed.is_err() { return; }
|
||||
break;
|
||||
}
|
||||
changed = async {
|
||||
match &mut updates {
|
||||
Some(receiver) => receiver.changed().await,
|
||||
None => std::future::pending().await,
|
||||
}
|
||||
} => {
|
||||
if changed.is_err() { break; }
|
||||
// Fence an update against a new lifecycle binding already published.
|
||||
if binding_rx.has_changed().unwrap_or(true) { break; }
|
||||
ctx.publish_tunnel(attempt).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,18 @@
|
||||
# Changelog
|
||||
|
||||
## 3.0.6
|
||||
|
||||
### Changed
|
||||
|
||||
- Embedded macOS VPN network configuration and added configuration logs for troubleshooting.
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed desktop notifications disappearing immediately on GNOME.
|
||||
- Corrected the notification sender to GP Connect and clarified update notification titles on Linux and BSD.
|
||||
- Fixed ESP tunnel setup when a gateway reports a zero address, including load-balanced gateways.
|
||||
- Removed obsolete OpenConnect package dependencies from the AUR package.
|
||||
|
||||
## 3.0.5
|
||||
|
||||
### Added
|
||||
|
||||
@@ -26,9 +26,11 @@ tauri = { workspace = true, optional = true }
|
||||
regex = { workspace = true, optional = true }
|
||||
tokio-util = { workspace = true, optional = true }
|
||||
html-escape = { version = "0.3", optional = true }
|
||||
url = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
|
||||
webkit2gtk = { version = "2", optional = true }
|
||||
gtk = { version = "0.18", optional = true }
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
block2 = { version = "0.6", optional = true }
|
||||
@@ -36,6 +38,7 @@ objc2 = { version = "0.6", optional = true }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSWorkspace", "block2"], optional = true }
|
||||
objc2-foundation = { version = "0.3", optional = true }
|
||||
objc2-web-kit = { version = "0.3", optional = true }
|
||||
objc2-security = { version = "0.3", default-features = false, features = ["std", "SecBase", "SecTrust", "SecCertificate"], optional = true }
|
||||
|
||||
[features]
|
||||
browser-auth = [
|
||||
@@ -54,11 +57,36 @@ webview-auth = [
|
||||
"dep:regex",
|
||||
"dep:tokio-util",
|
||||
"dep:html-escape",
|
||||
"dep:url",
|
||||
"dep:gtk",
|
||||
"dep:webkit2gtk",
|
||||
"dep:block2",
|
||||
"dep:objc2",
|
||||
"dep:objc2-foundation",
|
||||
"dep:objc2-web-kit",
|
||||
"dep:objc2-security",
|
||||
"objc2-app-kit/NSAlert",
|
||||
"dep:objc2-app-kit",
|
||||
"objc2-app-kit/NSView",
|
||||
"objc2-app-kit/NSText",
|
||||
"objc2-app-kit/NSTextView",
|
||||
"objc2-app-kit/NSTextContainer",
|
||||
"objc2-app-kit/NSParagraphStyle",
|
||||
"objc2-app-kit/NSFont",
|
||||
"objc2-app-kit/NSBox",
|
||||
"objc2-app-kit/NSButton",
|
||||
"objc2-app-kit/NSButtonCell",
|
||||
"objc2-app-kit/NSEvent",
|
||||
"objc2-app-kit/NSTextField",
|
||||
"objc2-app-kit/NSProgressIndicator",
|
||||
"objc2-app-kit/NSColor",
|
||||
"objc2-app-kit/NSResponder",
|
||||
"objc2-app-kit/NSAccessibilityProtocols",
|
||||
"objc2-app-kit/NSWindow",
|
||||
"objc2-app-kit/NSToolbar",
|
||||
"objc2-app-kit/NSToolbarItem",
|
||||
"objc2-app-kit/NSLayoutAnchor",
|
||||
"objc2-app-kit/NSLayoutConstraint",
|
||||
]
|
||||
release-devtools = ["webview-auth", "tauri/devtools"]
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ impl<'a> BrowserAuthenticator<'a> {
|
||||
}
|
||||
|
||||
pub async fn authenticate(&self) -> anyhow::Result<SamlAuthData> {
|
||||
let callback_receiver = if is_remote_browser(self.browser) {
|
||||
let callback_receiver = if is_manual_browser(self.browser) {
|
||||
None
|
||||
} else {
|
||||
ensure_auth_callback_handler()?;
|
||||
@@ -41,7 +41,7 @@ impl<'a> BrowserAuthenticator<'a> {
|
||||
auth_server.serve_request(&auth_request);
|
||||
});
|
||||
|
||||
if is_remote_browser(self.browser) {
|
||||
if is_manual_browser(self.browser) {
|
||||
info!(
|
||||
r#"
|
||||
|
||||
@@ -69,7 +69,7 @@ Note that the URL is only valid for a single use.
|
||||
}
|
||||
|
||||
async fn determine_addr(&self) -> anyhow::Result<SocketAddr> {
|
||||
if is_remote_browser(self.browser) {
|
||||
if is_manual_browser(self.browser) {
|
||||
let local_ip = match self.browser_listen {
|
||||
Some(ip) => ip,
|
||||
None => detect_local_ip().await?,
|
||||
@@ -81,8 +81,8 @@ Note that the URL is only valid for a single use.
|
||||
}
|
||||
}
|
||||
|
||||
fn is_remote_browser(browser: &str) -> bool {
|
||||
browser.eq_ignore_ascii_case("remote")
|
||||
fn is_manual_browser(browser: &str) -> bool {
|
||||
browser.eq_ignore_ascii_case("manual") || browser.eq_ignore_ascii_case("remote")
|
||||
}
|
||||
|
||||
/// Detect the local IP address by creating a UDP socket and connecting to an external address
|
||||
@@ -120,20 +120,24 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn browser_remote_remains_auth_specific() {
|
||||
assert!(is_remote_browser("remote"));
|
||||
assert!(is_remote_browser("REMOTE"));
|
||||
assert_ne!(LaunchBrowser::from_name("remote"), LaunchBrowser::Default);
|
||||
fn browser_manual_remains_auth_specific() {
|
||||
assert!(is_manual_browser("manual"));
|
||||
assert!(is_manual_browser("MANUAL"));
|
||||
assert!(is_manual_browser("remote"));
|
||||
assert!(is_manual_browser("REMOTE"));
|
||||
assert_ne!(LaunchBrowser::from_name("manual"), LaunchBrowser::Default);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn remote_browser_uses_explicit_listen_address() {
|
||||
async fn manual_browser_uses_explicit_listen_address() {
|
||||
let listen_ip = "192.168.107.15".parse().unwrap();
|
||||
let authenticator = BrowserAuthenticator::new("request", "remote", Some(listen_ip));
|
||||
for browser in ["manual", "MANUAL", "remote", "REMOTE"] {
|
||||
let authenticator = BrowserAuthenticator::new("request", browser, Some(listen_ip));
|
||||
|
||||
assert_eq!(
|
||||
authenticator.determine_addr().await.unwrap(),
|
||||
SocketAddr::new(listen_ip, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
authenticator.determine_addr().await.unwrap(),
|
||||
SocketAddr::new(listen_ip, 0)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,7 @@
|
||||
mod address_bar;
|
||||
mod auth_messenger;
|
||||
mod recovery;
|
||||
mod tls;
|
||||
mod webview_auth;
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
pub const TOOLBAR_HEIGHT: f64 = 40.0;
|
||||
pub const LOADING_ADDRESS: &str = "Loading sign-in page…";
|
||||
|
||||
/// Display web addresses with query strings and fragments, but without credentials.
|
||||
pub fn display_address(uri: Option<&str>) -> String {
|
||||
let Some(mut url) = uri.and_then(|uri| url::Url::parse(uri).ok()) else {
|
||||
return LOADING_ADDRESS.to_string();
|
||||
};
|
||||
if !matches!(url.scheme(), "http" | "https") || url.host_str().is_none() {
|
||||
return LOADING_ADDRESS.to_string();
|
||||
}
|
||||
|
||||
let _ = url.set_username("");
|
||||
let _ = url.set_password(None);
|
||||
url.into()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn hides_credentials_but_preserves_query_and_fragment() {
|
||||
assert_eq!(
|
||||
display_address(Some(
|
||||
"https://user:[email protected]:8443/saml?SAMLRequest=secret#token"
|
||||
)),
|
||||
"https://login.example:8443/saml?SAMLRequest=secret#token"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preserves_scheme_host_and_encoded_path() {
|
||||
assert_eq!(
|
||||
display_address(Some("http://example.com/a%20b")),
|
||||
"http://example.com/a%20b"
|
||||
);
|
||||
assert_eq!(display_address(Some("https://[::1]:8443/")), "https://[::1]:8443/");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uses_placeholder_for_local_pages_and_callbacks() {
|
||||
for uri in [
|
||||
None,
|
||||
Some(""),
|
||||
Some("invalid"),
|
||||
Some("about:blank"),
|
||||
Some("data:text/html,secret"),
|
||||
Some("globalprotectcallback:secret"),
|
||||
] {
|
||||
assert_eq!(display_address(uri), LOADING_ADDRESS);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,9 @@
|
||||
use super::tls::TlsFailure;
|
||||
use anyhow::bail;
|
||||
use gpapi::{auth::SamlAuthData, error::AuthDataParseError};
|
||||
use log::{error, info};
|
||||
use regex::Regex;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
use tokio::sync::{RwLock, mpsc};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
@@ -14,36 +16,30 @@ pub(crate) enum AuthDataLocation {
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum AuthError {
|
||||
/// Failed to load page due to TLS error
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
TlsError,
|
||||
/// 1. Found auth data in headers/body but it's invalid
|
||||
/// 2. Loaded an empty page, failed to load page. etc.
|
||||
/// A certificate or TLS handshake failure in the native webview.
|
||||
Tls(TlsFailure),
|
||||
/// The authentication service returned a temporary failure.
|
||||
TemporarilyUnavailable,
|
||||
/// A sign-in request could not be loaded.
|
||||
LoadFailed(anyhow::Error),
|
||||
/// Found auth data in headers/body but it's invalid.
|
||||
Invalid(anyhow::Error, AuthDataLocation),
|
||||
/// No auth data found in headers/body
|
||||
NotFound(AuthDataLocation),
|
||||
}
|
||||
|
||||
impl AuthError {
|
||||
pub fn invalid_from_body(err: anyhow::Error) -> Self {
|
||||
Self::Invalid(err, AuthDataLocation::Body)
|
||||
}
|
||||
|
||||
pub fn not_found_in_body() -> Self {
|
||||
Self::NotFound(AuthDataLocation::Body)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
impl AuthError {
|
||||
pub fn not_found_in_headers() -> Self {
|
||||
Self::NotFound(AuthDataLocation::Headers)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) enum AuthEvent {
|
||||
Data(SamlAuthData, AuthDataLocation),
|
||||
Error(AuthError),
|
||||
Data(u64, SamlAuthData, AuthDataLocation),
|
||||
Error(u64, AuthError),
|
||||
NoAuthData(u64, AuthDataLocation),
|
||||
PageLoaded(u64),
|
||||
Retry,
|
||||
RequestTlsException,
|
||||
TlsAccepted(u64),
|
||||
RaiseWindow,
|
||||
Close,
|
||||
}
|
||||
@@ -52,6 +48,7 @@ pub struct AuthMessenger {
|
||||
tx: mpsc::UnboundedSender<AuthEvent>,
|
||||
rx: RwLock<mpsc::UnboundedReceiver<AuthEvent>>,
|
||||
raise_window_cancel_token: RwLock<Option<CancellationToken>>,
|
||||
generation: AtomicU64,
|
||||
}
|
||||
|
||||
impl AuthMessenger {
|
||||
@@ -62,6 +59,7 @@ impl AuthMessenger {
|
||||
tx,
|
||||
rx: RwLock::new(rx),
|
||||
raise_window_cancel_token: Default::default(),
|
||||
generation: AtomicU64::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -79,12 +77,12 @@ impl AuthMessenger {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn send_auth_error(&self, err: AuthError) {
|
||||
self.send_auth_event(AuthEvent::Error(err));
|
||||
pub fn generation(&self) -> u64 {
|
||||
self.generation.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
fn send_auth_data(&self, data: SamlAuthData, location: AuthDataLocation) {
|
||||
self.send_auth_event(AuthEvent::Data(data, location));
|
||||
pub fn begin_attempt(&self) {
|
||||
self.generation.fetch_add(1, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
pub fn schedule_raise_window(&self, delay: u64) {
|
||||
@@ -132,9 +130,9 @@ impl AuthMessenger {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_from_html(&self, html: &str) {
|
||||
pub fn read_from_html(&self, html: &str, generation: u64) {
|
||||
if html.contains("Temporarily Unavailable") {
|
||||
return self.send_auth_error(AuthError::invalid_from_body(anyhow::anyhow!("Temporarily Unavailable")));
|
||||
return self.send_auth_event(AuthEvent::Error(generation, AuthError::TemporarilyUnavailable));
|
||||
}
|
||||
|
||||
let auth_result = SamlAuthData::from_html(html).or_else(|err| {
|
||||
@@ -149,18 +147,20 @@ impl AuthMessenger {
|
||||
});
|
||||
|
||||
match auth_result {
|
||||
Ok(data) => self.send_auth_data(data, AuthDataLocation::Body),
|
||||
Err(AuthDataParseError::NotFound) => self.send_auth_error(AuthError::not_found_in_body()),
|
||||
Err(err) => self.send_auth_error(AuthError::invalid_from_body(err.into())),
|
||||
Ok(data) => self.send_auth_event(AuthEvent::Data(generation, data, AuthDataLocation::Body)),
|
||||
Err(AuthDataParseError::NotFound) => {
|
||||
self.send_auth_event(AuthEvent::NoAuthData(generation, AuthDataLocation::Body))
|
||||
}
|
||||
Err(err) => self.send_auth_event(AuthEvent::Error(generation, AuthError::invalid_from_body(err.into()))),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
pub fn read_from_response(&self, auth_response: &impl super::webview_auth::GetHeader) {
|
||||
pub fn read_from_response(&self, auth_response: &impl super::webview_auth::GetHeader, generation: u64) {
|
||||
use log::warn;
|
||||
|
||||
let Some(status) = auth_response.get_header("saml-auth-status") else {
|
||||
return self.send_auth_error(AuthError::not_found_in_headers());
|
||||
return self.send_auth_event(AuthEvent::NoAuthData(generation, AuthDataLocation::Headers));
|
||||
};
|
||||
|
||||
// Do not send auth error when reading from headers, as the html body may contain the auth data
|
||||
@@ -174,7 +174,7 @@ impl AuthMessenger {
|
||||
let portal_userauthcookie = auth_response.get_header("portal-userauthcookie");
|
||||
|
||||
match SamlAuthData::new(username, prelogin_cookie, portal_userauthcookie) {
|
||||
Ok(auth_data) => self.send_auth_data(auth_data, AuthDataLocation::Headers),
|
||||
Ok(auth_data) => self.send_auth_event(AuthEvent::Data(generation, auth_data, AuthDataLocation::Headers)),
|
||||
Err(err) => {
|
||||
warn!("Failed to read auth data from headers: {}", err);
|
||||
}
|
||||
@@ -193,6 +193,43 @@ fn extract_gpcallback(html: &str) -> Option<String> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn ordinary_sign_in_page_is_an_observation_with_its_original_generation() {
|
||||
let messenger = AuthMessenger::new();
|
||||
messenger.read_from_html("<html><h1>Sign in</h1></html>", 7);
|
||||
assert!(matches!(
|
||||
messenger.subscribe().await.unwrap(),
|
||||
AuthEvent::NoAuthData(7, AuthDataLocation::Body)
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn distinguishes_temporary_failure_from_rejected_authentication() {
|
||||
let messenger = AuthMessenger::new();
|
||||
messenger.read_from_html("<html>Temporarily Unavailable</html>", 0);
|
||||
assert!(matches!(
|
||||
messenger.subscribe().await.unwrap(),
|
||||
AuthEvent::Error(0, AuthError::TemporarilyUnavailable)
|
||||
));
|
||||
messenger.read_from_html("<saml-auth-status>0</saml-auth-status>", 0);
|
||||
assert!(matches!(
|
||||
messenger.subscribe().await.unwrap(),
|
||||
AuthEvent::Error(0, AuthError::Invalid(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn html_callbacks_keep_the_generation_that_started_the_read() {
|
||||
let messenger = AuthMessenger::new();
|
||||
let generation = messenger.generation();
|
||||
messenger.begin_attempt();
|
||||
messenger.read_from_html("<html>Temporarily Unavailable</html>", generation);
|
||||
match messenger.subscribe().await.unwrap() {
|
||||
AuthEvent::Error(generation, _) => assert_ne!(generation, messenger.generation()),
|
||||
_ => panic!("Expected an authentication error"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extract_gpcallback_some() {
|
||||
let html = r#"
|
||||
|
||||
+244
-55
@@ -1,8 +1,9 @@
|
||||
use std::sync::Arc;
|
||||
use std::{cell::Cell, rc::Rc, sync::Arc};
|
||||
|
||||
use anyhow::bail;
|
||||
use anyhow::{Context, bail};
|
||||
use gpapi::utils::redact::redact_uri;
|
||||
use log::warn;
|
||||
use gtk::prelude::*;
|
||||
use log::{info, warn};
|
||||
use tauri::webview::PlatformWebview;
|
||||
use webkit2gtk::{
|
||||
LoadEvent, SettingsExt, TLSErrorsPolicy, URIResponseExt, WebResource, WebResourceExt, WebViewExt,
|
||||
@@ -10,10 +11,26 @@ use webkit2gtk::{
|
||||
};
|
||||
|
||||
use super::{
|
||||
auth_messenger::AuthError,
|
||||
auth_messenger::{AuthError, AuthEvent, AuthMessenger},
|
||||
recovery::RecoveryStatus,
|
||||
webview_auth::{GetHeader, PlatformWebviewExt},
|
||||
};
|
||||
|
||||
#[path = "gtk_recovery.rs"]
|
||||
mod recovery_row;
|
||||
#[path = "gtk_tls.rs"]
|
||||
mod tls;
|
||||
|
||||
fn action_button(label: &str) -> anyhow::Result<gtk::Button> {
|
||||
let button = gtk::Button::with_label(label);
|
||||
let spacing = gtk::CssProvider::new();
|
||||
spacing.load_from_data(b"button { padding: 4px 12px; }")?;
|
||||
button
|
||||
.style_context()
|
||||
.add_provider(&spacing, gtk::STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
Ok(button)
|
||||
}
|
||||
|
||||
impl GetHeader for WebResource {
|
||||
fn get_header(&self, key: &str) -> Option<String> {
|
||||
self
|
||||
@@ -25,6 +42,62 @@ impl GetHeader for WebResource {
|
||||
}
|
||||
|
||||
impl PlatformWebviewExt for PlatformWebview {
|
||||
fn install_auth_controls(&self, window: &tauri::WebviewWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
use super::address_bar::display_address;
|
||||
|
||||
let entry = gtk::Entry::new();
|
||||
entry.set_editable(false);
|
||||
entry.set_can_focus(true);
|
||||
entry.set_direction(gtk::TextDirection::Ltr);
|
||||
entry.set_text(&display_address(self.inner().uri().as_deref()));
|
||||
let header = gtk::Box::new(gtk::Orientation::Vertical, 4);
|
||||
header.style_context().add_class(gtk::STYLE_CLASS_TOOLBAR);
|
||||
header.style_context().add_class(gtk::STYLE_CLASS_PRIMARY_TOOLBAR);
|
||||
header.style_context().add_class("gpauth-header");
|
||||
// One native header owns the outer padding and the gap between its rows.
|
||||
// Keep theme colors, borders, focus styling, and natural button sizes.
|
||||
let spacing = gtk::CssProvider::new();
|
||||
spacing.load_from_data(b".gpauth-header { padding: 6px; } entry { min-height: 22px; padding: 2px 6px; }")?;
|
||||
entry
|
||||
.style_context()
|
||||
.add_provider(&spacing, gtk::STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
header
|
||||
.style_context()
|
||||
.add_provider(&spacing, gtk::STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
header.pack_start(&entry, false, false, 0);
|
||||
header.show_all();
|
||||
recovery_row::install(&self.inner(), &header, Arc::clone(&messenger))?;
|
||||
let container = window.default_vbox()?;
|
||||
container.pack_start(&header, false, false, 0);
|
||||
container.reorder_child(&header, 0);
|
||||
let separator = gtk::Separator::new(gtk::Orientation::Horizontal);
|
||||
container.pack_start(&separator, false, false, 0);
|
||||
container.reorder_child(&separator, 1);
|
||||
separator.show();
|
||||
|
||||
// Observe the top-level URI, including redirects and history API changes.
|
||||
let address = entry.clone();
|
||||
self.inner().connect_uri_notify(move |webview| {
|
||||
address.set_text(&display_address(webview.uri().as_deref()));
|
||||
address.set_position(0);
|
||||
});
|
||||
tls::install(&self.inner(), Arc::clone(&messenger));
|
||||
install_navigation_observers(&self.inner(), messenger, entry);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
recovery_row::update(&self.inner(), status)
|
||||
}
|
||||
|
||||
fn stop_loading(&self) {
|
||||
self.inner().stop_loading();
|
||||
}
|
||||
|
||||
fn confirm_tls_exception(&self) -> anyhow::Result<()> {
|
||||
tls::confirm(&self.inner())
|
||||
}
|
||||
|
||||
fn ignore_tls_errors(&self) -> anyhow::Result<()> {
|
||||
if let Some(manager) = self.inner().website_data_manager() {
|
||||
manager.set_tls_errors_policy(TLSErrorsPolicy::Ignore);
|
||||
@@ -34,7 +107,7 @@ impl PlatformWebviewExt for PlatformWebview {
|
||||
}
|
||||
|
||||
fn user_agent(&self) -> anyhow::Result<String> {
|
||||
let Some(settings) = self.inner().settings() else {
|
||||
let Some(settings) = WebViewExt::settings(&self.inner()) else {
|
||||
bail!("Failed to get webview settings");
|
||||
};
|
||||
|
||||
@@ -45,7 +118,7 @@ impl PlatformWebviewExt for PlatformWebview {
|
||||
}
|
||||
|
||||
fn set_user_agent(&self, user_agent: &str) -> anyhow::Result<()> {
|
||||
let Some(settings) = self.inner().settings() else {
|
||||
let Some(settings) = WebViewExt::settings(&self.inner()) else {
|
||||
bail!("Failed to get webview settings");
|
||||
};
|
||||
|
||||
@@ -54,72 +127,188 @@ impl PlatformWebviewExt for PlatformWebview {
|
||||
}
|
||||
|
||||
fn load_url(&self, url: &str) -> anyhow::Result<()> {
|
||||
prepare_navigation(&self.inner())?;
|
||||
self.inner().load_uri(url);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn load_html(&self, html: &str) -> anyhow::Result<()> {
|
||||
prepare_navigation(&self.inner())?;
|
||||
self.inner().load_html(html, None);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn get_html(&self, callback: Box<dyn Fn(anyhow::Result<String>) + 'static>) {
|
||||
let script = "document.documentElement.outerHTML";
|
||||
self
|
||||
.inner()
|
||||
.evaluate_javascript(script, None, None, Cancellable::NONE, move |result| match result {
|
||||
Ok(value) => callback(Ok(value.to_string())),
|
||||
Err(err) => callback(Err(anyhow::anyhow!(err))),
|
||||
});
|
||||
const NAVIGATION_KEY: &str = "gpauth-navigation";
|
||||
|
||||
#[derive(Default)]
|
||||
struct NavigationAttempts {
|
||||
pending: Cell<Option<u64>>,
|
||||
current: Cell<Option<u64>>,
|
||||
}
|
||||
|
||||
impl NavigationAttempts {
|
||||
fn started(&self, generation: u64) {
|
||||
self.current.set(Some(self.pending.take().unwrap_or(generation)));
|
||||
}
|
||||
}
|
||||
|
||||
pub trait PlatformWebviewOnResponse {
|
||||
fn on_response(&self, callback: Box<dyn Fn(anyhow::Result<WebResource, AuthError>) + 'static>);
|
||||
struct NavigationObserver {
|
||||
attempts: NavigationAttempts,
|
||||
messenger: Arc<AuthMessenger>,
|
||||
}
|
||||
|
||||
impl PlatformWebviewOnResponse for PlatformWebview {
|
||||
fn on_response(&self, callback: Box<dyn Fn(anyhow::Result<WebResource, AuthError>) + 'static>) {
|
||||
let wv = self.inner();
|
||||
let callback = Arc::new(callback);
|
||||
let callback_clone = Arc::clone(&callback);
|
||||
fn prepare_navigation(webview: &webkit2gtk::WebView) -> anyhow::Result<()> {
|
||||
let observer =
|
||||
unsafe { webview.data::<Rc<NavigationObserver>>(NAVIGATION_KEY) }.context("Navigation observer is unavailable")?;
|
||||
let observer = unsafe { observer.as_ref() };
|
||||
observer.attempts.pending.set(Some(observer.messenger.generation()));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
wv.connect_load_changed(move |wv, event| {
|
||||
if event != LoadEvent::Finished {
|
||||
return;
|
||||
fn install_navigation_observers(webview: &webkit2gtk::WebView, messenger: Arc<AuthMessenger>, address: gtk::Entry) {
|
||||
let observer = Rc::new(NavigationObserver {
|
||||
attempts: NavigationAttempts::default(),
|
||||
messenger,
|
||||
});
|
||||
unsafe {
|
||||
webview.set_data(NAVIGATION_KEY, Rc::clone(&observer));
|
||||
}
|
||||
let loading = Rc::clone(&observer);
|
||||
webview.connect_load_changed(move |webview, event| {
|
||||
match event {
|
||||
LoadEvent::Started => {
|
||||
loading.attempts.started(loading.messenger.generation());
|
||||
loading.messenger.cancel_raise_window();
|
||||
}
|
||||
|
||||
let Some(web_resource) = wv.main_resource() else {
|
||||
return;
|
||||
};
|
||||
|
||||
let uri = web_resource.uri().unwrap_or("".into());
|
||||
if uri.is_empty() {
|
||||
callback_clone(Err(AuthError::invalid_from_body(anyhow::anyhow!("Empty URI"))));
|
||||
} else {
|
||||
callback_clone(Ok(web_resource));
|
||||
LoadEvent::Committed => {
|
||||
if let Some(generation) = loading.attempts.current.get() {
|
||||
info!(
|
||||
"Started loading page: {}",
|
||||
redact_uri(webview.uri().as_deref().unwrap_or_default())
|
||||
);
|
||||
read_navigation_html(webview, Arc::clone(&loading.messenger), generation);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
wv.connect_load_failed_with_tls_errors(move |_wv, uri, cert, err| {
|
||||
let redacted_uri = redact_uri(uri);
|
||||
warn!(
|
||||
"Failed to load uri: {} with error: {}, cert: {}",
|
||||
redacted_uri, err, cert
|
||||
);
|
||||
|
||||
callback(Err(AuthError::TlsError));
|
||||
true
|
||||
});
|
||||
|
||||
wv.connect_load_failed(move |_wv, _event, uri, err| {
|
||||
let redacted_uri = redact_uri(uri);
|
||||
if !uri.starts_with("globalprotectcallback:") {
|
||||
warn!("Failed to load uri: {} with error: {}", redacted_uri, err);
|
||||
LoadEvent::Finished => {
|
||||
// WebKitGTK finishes a cancelled load before starting its replacement.
|
||||
// Retain that load's generation instead of relabeling it at callback time.
|
||||
let Some(generation) = loading.attempts.current.take() else {
|
||||
return;
|
||||
};
|
||||
info!(
|
||||
"Finished loading page: {}",
|
||||
redact_uri(webview.uri().as_deref().unwrap_or_default())
|
||||
);
|
||||
read_navigation_html(webview, Arc::clone(&loading.messenger), generation);
|
||||
if let Some(resource) = webview.main_resource() {
|
||||
let uri = resource.uri().unwrap_or_default();
|
||||
if uri.is_empty() {
|
||||
loading.messenger.send_auth_event(AuthEvent::Error(
|
||||
generation,
|
||||
AuthError::invalid_from_body(anyhow::anyhow!("Empty URI")),
|
||||
));
|
||||
} else {
|
||||
loading.messenger.read_from_response(&resource, generation);
|
||||
}
|
||||
}
|
||||
loading.messenger.send_auth_event(AuthEvent::PageLoaded(generation));
|
||||
}
|
||||
// NOTE: Don't send error here, since load_changed event will be triggered after this
|
||||
// true to stop other handlers from being invoked for the event. false to propagate the event further.
|
||||
true
|
||||
});
|
||||
_ => {}
|
||||
}
|
||||
});
|
||||
|
||||
let tls = Rc::clone(&observer);
|
||||
let tls_address = address.clone();
|
||||
webview.connect_load_failed_with_tls_errors(move |webview, uri, cert, err| {
|
||||
warn!(
|
||||
"Failed to load uri: {} with error: {}, cert: {}",
|
||||
redact_uri(uri),
|
||||
err,
|
||||
cert
|
||||
);
|
||||
if let Some(generation) = tls.attempts.current.take() {
|
||||
if generation != tls.messenger.generation() {
|
||||
return true;
|
||||
}
|
||||
show_failed_address(&tls_address, uri);
|
||||
let failure = tls::record_failure(webview, uri, cert, err, generation);
|
||||
tls
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::Error(generation, AuthError::Tls(failure)));
|
||||
}
|
||||
true
|
||||
});
|
||||
|
||||
webview.connect_load_failed(move |_webview, _event, uri, err| {
|
||||
if let Some(generation) = observer.attempts.current.take() {
|
||||
if generation != observer.messenger.generation() {
|
||||
return true;
|
||||
}
|
||||
if !uri.starts_with("globalprotectcallback:") && !err.matches(webkit2gtk::NetworkError::Cancelled) {
|
||||
warn!("Failed to load uri: {} with error: {}", redact_uri(uri), err);
|
||||
show_failed_address(&address, uri);
|
||||
let error = if err.kind::<webkit2gtk::gio::TlsError>().is_some() {
|
||||
AuthError::Tls(super::tls::TlsFailure {
|
||||
host: url::Url::parse(uri)
|
||||
.ok()
|
||||
.and_then(|uri| uri.host_str().map(str::to_owned))
|
||||
.unwrap_or_default(),
|
||||
reason: super::tls::TlsFailureReason::Handshake,
|
||||
can_continue: false,
|
||||
})
|
||||
} else {
|
||||
AuthError::LoadFailed(anyhow::anyhow!("{}", err))
|
||||
};
|
||||
observer.messenger.send_auth_event(AuthEvent::Error(generation, error));
|
||||
}
|
||||
}
|
||||
true
|
||||
});
|
||||
}
|
||||
|
||||
// A failed provisional load may leave WebView.uri unset.
|
||||
fn show_failed_address(entry: >k::Entry, uri: &str) {
|
||||
entry.set_text(&super::address_bar::display_address(Some(uri)));
|
||||
entry.set_position(0);
|
||||
}
|
||||
|
||||
fn read_navigation_html(webview: &webkit2gtk::WebView, messenger: Arc<AuthMessenger>, generation: u64) {
|
||||
webview.evaluate_javascript(
|
||||
"document.documentElement.outerHTML",
|
||||
None,
|
||||
None,
|
||||
Cancellable::NONE,
|
||||
move |result| match result {
|
||||
Ok(value) => messenger.read_from_html(&value.to_string(), generation),
|
||||
Err(err) => warn!("Failed to get html: {}", err),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::NavigationAttempts;
|
||||
|
||||
#[test]
|
||||
fn cancelled_load_keeps_its_generation_until_replacement_starts() {
|
||||
let attempts = NavigationAttempts::default();
|
||||
attempts.started(0);
|
||||
attempts.pending.set(Some(2));
|
||||
// The previous load's cancellation/finish arrives after retry generation advances.
|
||||
assert_eq!(attempts.current.take(), Some(0));
|
||||
attempts.started(2);
|
||||
assert_eq!(attempts.current.take(), Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requested_generation_survives_attempt_changes_before_native_start() {
|
||||
let attempts = NavigationAttempts::default();
|
||||
attempts.pending.set(Some(2));
|
||||
attempts.started(3);
|
||||
assert_eq!(attempts.current.take(), Some(2));
|
||||
// User navigation after that load starts in the current attempt.
|
||||
attempts.started(3);
|
||||
assert_eq!(attempts.current.take(), Some(3));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use anyhow::Context;
|
||||
use gtk::prelude::*;
|
||||
use webkit2gtk::WebView;
|
||||
|
||||
use super::super::{
|
||||
auth_messenger::{AuthEvent, AuthMessenger},
|
||||
recovery::RecoveryStatus,
|
||||
};
|
||||
|
||||
const CONTROLS_KEY: &str = "gpauth-recovery-controls";
|
||||
|
||||
struct RecoveryRow {
|
||||
row: gtk::Box,
|
||||
spinner: gtk::Spinner,
|
||||
label: gtk::Label,
|
||||
retry: gtk::Button,
|
||||
proceed: gtk::Button,
|
||||
cancel: gtk::Button,
|
||||
detail: gtk::Label,
|
||||
}
|
||||
|
||||
pub(super) fn install(webview: &WebView, header: >k::Box, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
let row = gtk::Box::new(gtk::Orientation::Horizontal, 8);
|
||||
// Align status text with the address text's 6px inset and native 1px border.
|
||||
row.set_margin_start(7);
|
||||
let spinner = gtk::Spinner::new();
|
||||
spinner.set_valign(gtk::Align::Center);
|
||||
let label = gtk::Label::new(None);
|
||||
label.set_xalign(0.0);
|
||||
label.set_ellipsize(gtk::pango::EllipsizeMode::End);
|
||||
let detail = gtk::Label::new(None);
|
||||
detail.set_xalign(0.0);
|
||||
detail.set_ellipsize(gtk::pango::EllipsizeMode::End);
|
||||
detail.style_context().add_class("dim-label");
|
||||
detail.set_no_show_all(true);
|
||||
let copy = gtk::Box::new(gtk::Orientation::Vertical, 2);
|
||||
copy.set_valign(gtk::Align::Center);
|
||||
copy.pack_start(&label, false, false, 0);
|
||||
copy.pack_start(&detail, false, false, 0);
|
||||
copy.show();
|
||||
let retry = super::action_button("Try Again")?;
|
||||
retry.set_valign(gtk::Align::Center);
|
||||
let proceed = super::action_button("Continue Anyway…")?;
|
||||
proceed.set_valign(gtk::Align::Center);
|
||||
proceed.set_no_show_all(true);
|
||||
let cancel = super::action_button("Cancel")?;
|
||||
cancel.set_valign(gtk::Align::Center);
|
||||
// Showing or raising the window must not override recovery-state visibility.
|
||||
row.set_no_show_all(true);
|
||||
spinner.set_no_show_all(true);
|
||||
retry.set_no_show_all(true);
|
||||
label.show();
|
||||
cancel.set_no_show_all(true);
|
||||
let retry_messenger = Arc::clone(&messenger);
|
||||
retry.connect_clicked(move |_| retry_messenger.send_auth_event(AuthEvent::Retry));
|
||||
let proceed_messenger = Arc::clone(&messenger);
|
||||
proceed.connect_clicked(move |_| proceed_messenger.send_auth_event(AuthEvent::RequestTlsException));
|
||||
cancel.connect_clicked(move |_| messenger.send_auth_event(AuthEvent::Close));
|
||||
row.pack_start(&spinner, false, false, 0);
|
||||
row.pack_start(©, true, true, 0);
|
||||
row.pack_start(&retry, false, false, 0);
|
||||
row.pack_start(&proceed, false, false, 0);
|
||||
row.pack_start(&cancel, false, false, 0);
|
||||
header.pack_start(&row, false, false, 0);
|
||||
// The WebView owns the controls for exactly its native lifetime, on the GTK thread.
|
||||
unsafe {
|
||||
webview.set_data(
|
||||
CONTROLS_KEY,
|
||||
RecoveryRow {
|
||||
row,
|
||||
spinner,
|
||||
label,
|
||||
retry,
|
||||
proceed,
|
||||
cancel,
|
||||
detail,
|
||||
},
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn update(webview: &WebView, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
let controls = unsafe { webview.data::<RecoveryRow>(CONTROLS_KEY) }.context("Recovery controls are unavailable")?;
|
||||
let controls = unsafe { controls.as_ref() };
|
||||
controls.label.set_text(status.message());
|
||||
controls.detail.set_text(status.detail());
|
||||
controls.detail.set_visible(!status.detail().is_empty());
|
||||
controls.retry.set_visible(status.can_retry());
|
||||
controls.proceed.set_visible(status.can_continue());
|
||||
controls.cancel.set_visible(status.blocks_page());
|
||||
controls.spinner.set_visible(status.is_busy());
|
||||
if status.is_busy() {
|
||||
controls.spinner.start();
|
||||
} else {
|
||||
controls.spinner.stop();
|
||||
}
|
||||
controls.row.set_visible(status != RecoveryStatus::Hidden);
|
||||
webview.set_sensitive(!status.blocks_page());
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use anyhow::Context;
|
||||
use gtk::prelude::*;
|
||||
use webkit2gtk::{
|
||||
WebContextExt, WebView, WebViewExt,
|
||||
gio::{TlsCertificate, TlsCertificateFlags},
|
||||
};
|
||||
|
||||
use super::super::{
|
||||
auth_messenger::{AuthEvent, AuthMessenger},
|
||||
tls::{TlsFailure, TlsFailureReason},
|
||||
};
|
||||
|
||||
const TLS_KEY: &str = "gpauth-tls";
|
||||
|
||||
#[derive(Clone)]
|
||||
struct PendingCertificate {
|
||||
generation: u64,
|
||||
certificate: TlsCertificate,
|
||||
failure: TlsFailure,
|
||||
}
|
||||
|
||||
struct TlsState {
|
||||
pending: RefCell<Option<PendingCertificate>>,
|
||||
confirmation_open: Cell<bool>,
|
||||
messenger: Arc<AuthMessenger>,
|
||||
}
|
||||
|
||||
pub(super) fn install(webview: &WebView, messenger: Arc<AuthMessenger>) {
|
||||
unsafe {
|
||||
webview.set_data(
|
||||
TLS_KEY,
|
||||
Rc::new(TlsState {
|
||||
pending: RefCell::new(None),
|
||||
confirmation_open: Cell::new(false),
|
||||
messenger,
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn state(webview: &WebView) -> anyhow::Result<Rc<TlsState>> {
|
||||
let data = unsafe { webview.data::<Rc<TlsState>>(TLS_KEY) }.context("TLS controls are unavailable")?;
|
||||
Ok(unsafe { data.as_ref() }.clone())
|
||||
}
|
||||
|
||||
pub(super) fn record_failure(
|
||||
webview: &WebView,
|
||||
uri: &str,
|
||||
certificate: &TlsCertificate,
|
||||
flags: TlsCertificateFlags,
|
||||
generation: u64,
|
||||
) -> TlsFailure {
|
||||
let reason = if flags.contains(TlsCertificateFlags::EXPIRED) {
|
||||
TlsFailureReason::Expired
|
||||
} else if flags.contains(TlsCertificateFlags::NOT_ACTIVATED) {
|
||||
TlsFailureReason::NotYetValid
|
||||
} else if flags.contains(TlsCertificateFlags::BAD_IDENTITY) {
|
||||
TlsFailureReason::HostnameMismatch
|
||||
} else if flags.contains(TlsCertificateFlags::UNKNOWN_CA) {
|
||||
TlsFailureReason::Untrusted
|
||||
} else {
|
||||
TlsFailureReason::InvalidCertificate
|
||||
};
|
||||
let host = url::Url::parse(uri)
|
||||
.ok()
|
||||
.filter(|uri| uri.scheme() == "https")
|
||||
.and_then(|uri| uri.host_str().map(str::to_owned));
|
||||
let failure = TlsFailure {
|
||||
host: host.clone().unwrap_or_default(),
|
||||
reason,
|
||||
can_continue: reason.is_certificate_error() && host.is_some(),
|
||||
};
|
||||
if let Ok(state) = state(webview) {
|
||||
*state.pending.borrow_mut() = host.map(|_| PendingCertificate {
|
||||
generation,
|
||||
certificate: certificate.clone(),
|
||||
failure: failure.clone(),
|
||||
});
|
||||
}
|
||||
failure
|
||||
}
|
||||
|
||||
pub(super) fn confirm(webview: &WebView) -> anyhow::Result<()> {
|
||||
let state = state(webview)?;
|
||||
let pending = state
|
||||
.pending
|
||||
.borrow()
|
||||
.clone()
|
||||
.context("No certificate error is awaiting confirmation")?;
|
||||
if pending.generation != state.messenger.generation() || state.confirmation_open.get() {
|
||||
return Ok(());
|
||||
}
|
||||
let parent = webview
|
||||
.toplevel()
|
||||
.and_then(|widget| widget.downcast::<gtk::Window>().ok())
|
||||
.context("Auth window is unavailable")?;
|
||||
let dialog = gtk::Dialog::builder()
|
||||
.transient_for(&parent)
|
||||
.modal(true)
|
||||
.destroy_with_parent(true)
|
||||
.title("Certificate Warning")
|
||||
.use_header_bar(0)
|
||||
.resizable(false)
|
||||
.build();
|
||||
let content = dialog.content_area();
|
||||
content.set_spacing(12);
|
||||
content.set_margin_top(18);
|
||||
content.set_margin_bottom(18);
|
||||
content.set_margin_start(18);
|
||||
content.set_margin_end(18);
|
||||
let title = gtk::Label::new(None);
|
||||
title.set_markup(&format!(
|
||||
"<b>{}</b>",
|
||||
gtk::glib::markup_escape_text(&pending.failure.confirmation_title())
|
||||
));
|
||||
let message = gtk::Label::new(Some(&pending.failure.confirmation_message()));
|
||||
for label in [&title, &message] {
|
||||
label.set_xalign(0.0);
|
||||
label.set_line_wrap(true);
|
||||
label.set_line_wrap_mode(gtk::pango::WrapMode::WordChar);
|
||||
label.set_max_width_chars(48);
|
||||
content.pack_start(label, false, false, 0);
|
||||
}
|
||||
let actions = gtk::ButtonBox::new(gtk::Orientation::Horizontal);
|
||||
actions.set_layout(gtk::ButtonBoxStyle::End);
|
||||
actions.set_spacing(8);
|
||||
actions.set_margin_top(6);
|
||||
content.pack_start(&actions, false, false, 0);
|
||||
for (label, response) in [
|
||||
("Cancel", gtk::ResponseType::Cancel),
|
||||
("Continue Anyway", gtk::ResponseType::Accept),
|
||||
] {
|
||||
let button = super::action_button(label)?;
|
||||
button.set_can_default(true);
|
||||
let weak_dialog = dialog.downgrade();
|
||||
button.connect_clicked(move |_| {
|
||||
if let Some(dialog) = weak_dialog.upgrade() {
|
||||
dialog.response(response);
|
||||
}
|
||||
});
|
||||
actions.pack_start(&button, false, false, 0);
|
||||
actions.set_child_non_homogeneous(&button, true);
|
||||
if response == gtk::ResponseType::Cancel {
|
||||
dialog.set_default(Some(&button));
|
||||
}
|
||||
}
|
||||
state.confirmation_open.set(true);
|
||||
let weak = webview.downgrade();
|
||||
dialog.connect_response(move |dialog, response| {
|
||||
state.confirmation_open.set(false);
|
||||
if response == gtk::ResponseType::Accept && pending.generation == state.messenger.generation() {
|
||||
if let Some(webview) = weak.upgrade() {
|
||||
let current = state.pending.borrow().as_ref().is_some_and(|current| {
|
||||
current.generation == pending.generation
|
||||
&& current.certificate == pending.certificate
|
||||
&& current.failure.host == pending.failure.host
|
||||
});
|
||||
if current {
|
||||
if let Some(context) = webview.context() {
|
||||
// This single-window auth process discards its WebContext on exit.
|
||||
context.allow_tls_certificate_for_host(&pending.certificate, &pending.failure.host);
|
||||
state.pending.borrow_mut().take();
|
||||
state
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::TlsAccepted(pending.generation));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
dialog.close();
|
||||
});
|
||||
dialog.show_all();
|
||||
Ok(())
|
||||
}
|
||||
@@ -1,58 +1,149 @@
|
||||
use std::{ffi::c_void, ptr};
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
collections::HashMap,
|
||||
ffi::c_void,
|
||||
ptr,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
use block2::{DynBlock, RcBlock};
|
||||
use gpapi::utils::redact::redact_uri;
|
||||
use log::{info, warn};
|
||||
use objc2::{
|
||||
DefinedClass, MainThreadOnly, define_class,
|
||||
ffi::{OBJC_ASSOCIATION_RETAIN_NONATOMIC, objc_setAssociatedObject},
|
||||
DefinedClass, MainThreadOnly, Message, define_class,
|
||||
ffi::{OBJC_ASSOCIATION_RETAIN_NONATOMIC, objc_getAssociatedObject, objc_setAssociatedObject},
|
||||
msg_send,
|
||||
rc::Retained,
|
||||
runtime::{AnyObject, ProtocolObject, Sel},
|
||||
sel,
|
||||
};
|
||||
use objc2_foundation::{
|
||||
MainThreadMarker, NSError, NSObject, NSObjectNSKeyValueCoding, NSObjectProtocol, NSString, NSURL,
|
||||
NSURLAuthenticationChallenge, NSURLAuthenticationMethodServerTrust, NSURLCredential, NSURLRequest,
|
||||
NSURLAuthenticationChallenge, NSURLAuthenticationMethodServerTrust, NSURLCredential, NSURLErrorCancelled,
|
||||
NSURLErrorDomain, NSURLErrorFailingURLErrorKey, NSURLErrorUnsupportedURL, NSURLRequest,
|
||||
NSURLSessionAuthChallengeDisposition,
|
||||
};
|
||||
use objc2_web_kit::{WKNavigationDelegate, WKWebView};
|
||||
use objc2_web_kit::{WKNavigation, WKNavigationDelegate, WKWebView};
|
||||
use tauri::webview::PlatformWebview;
|
||||
|
||||
use super::webview_auth::PlatformWebviewExt;
|
||||
use super::{
|
||||
auth_messenger::{AuthError, AuthEvent, AuthMessenger},
|
||||
recovery::RecoveryStatus,
|
||||
webview_auth::PlatformWebviewExt,
|
||||
};
|
||||
|
||||
static TLS_NAVIGATION_DELEGATE_KEY: u8 = 0;
|
||||
#[path = "macos/address_bar.rs"]
|
||||
mod address_bar;
|
||||
#[path = "macos/recovery_row.rs"]
|
||||
mod recovery_row;
|
||||
#[path = "macos/tls.rs"]
|
||||
mod tls;
|
||||
|
||||
struct TlsNavigationDelegateIvars {
|
||||
static AUTH_NAVIGATION_DELEGATE_KEY: u8 = 0;
|
||||
|
||||
struct AuthNavigationDelegateIvars {
|
||||
original: Retained<ProtocolObject<dyn WKNavigationDelegate>>,
|
||||
messenger: Arc<AuthMessenger>,
|
||||
ignore_tls_errors: Cell<bool>,
|
||||
navigations: RefCell<HashMap<usize, (Retained<WKNavigation>, u64)>>,
|
||||
tls: RefCell<tls::TlsState>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super = NSObject)]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[ivars = TlsNavigationDelegateIvars]
|
||||
struct TlsNavigationDelegate;
|
||||
#[ivars = AuthNavigationDelegateIvars]
|
||||
struct AuthNavigationDelegate;
|
||||
|
||||
unsafe impl NSObjectProtocol for TlsNavigationDelegate {}
|
||||
unsafe impl NSObjectProtocol for AuthNavigationDelegate {}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
unsafe impl WKNavigationDelegate for TlsNavigationDelegate {
|
||||
unsafe impl WKNavigationDelegate for AuthNavigationDelegate {
|
||||
#[unsafe(method(webView:didStartProvisionalNavigation:))]
|
||||
unsafe fn webView_didStartProvisionalNavigation(&self, webview: &WKWebView, navigation: Option<&WKNavigation>) {
|
||||
self.track_navigation(navigation);
|
||||
self.ivars().messenger.cancel_raise_window();
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didStartProvisionalNavigation:)) {
|
||||
unsafe { original.webView_didStartProvisionalNavigation(webview, navigation); }
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method(webView:didCommitNavigation:))]
|
||||
unsafe fn webView_didCommitNavigation(&self, webview: &WKWebView, navigation: Option<&WKNavigation>) {
|
||||
if let Some(generation) = self.navigation_generation(navigation) {
|
||||
info!("Started loading page: {}", navigation_address(webview));
|
||||
read_navigation_html(webview, Arc::clone(&self.ivars().messenger), generation);
|
||||
}
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didCommitNavigation:)) {
|
||||
unsafe { original.webView_didCommitNavigation(webview, navigation); }
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method(webView:didFinishNavigation:))]
|
||||
unsafe fn webView_didFinishNavigation(&self, webview: &WKWebView, navigation: Option<&WKNavigation>) {
|
||||
if let Some(generation) = self.finish_navigation(navigation) {
|
||||
info!("Finished loading page: {}", navigation_address(webview));
|
||||
read_navigation_html(webview, Arc::clone(&self.ivars().messenger), generation);
|
||||
self.ivars().messenger.send_auth_event(AuthEvent::PageLoaded(generation));
|
||||
}
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didFinishNavigation:)) {
|
||||
unsafe { original.webView_didFinishNavigation(webview, navigation); }
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method(webView:didFailProvisionalNavigation:withError:))]
|
||||
unsafe fn webView_didFailProvisionalNavigation_withError(&self, webview: &WKWebView, navigation: Option<&WKNavigation>, error: &NSError) {
|
||||
self.report_load_failure(webview, navigation, error);
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didFailProvisionalNavigation:withError:)) {
|
||||
unsafe { original.webView_didFailProvisionalNavigation_withError(webview, navigation, error); }
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method(webView:didFailNavigation:withError:))]
|
||||
unsafe fn webView_didFailNavigation_withError(&self, webview: &WKWebView, navigation: Option<&WKNavigation>, error: &NSError) {
|
||||
self.report_load_failure(webview, navigation, error);
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didFailNavigation:withError:)) {
|
||||
unsafe { original.webView_didFailNavigation_withError(webview, navigation, error); }
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method(webView:didReceiveAuthenticationChallenge:completionHandler:))]
|
||||
unsafe fn webView_didReceiveAuthenticationChallenge_completionHandler(
|
||||
&self,
|
||||
_webview: &WKWebView,
|
||||
webview: &WKWebView,
|
||||
challenge: &NSURLAuthenticationChallenge,
|
||||
completion_handler: &DynBlock<dyn Fn(NSURLSessionAuthChallengeDisposition, *mut NSURLCredential)>,
|
||||
) {
|
||||
// Preserve Wry's normal authentication challenge handling unless the caller
|
||||
// approved this certificate or requested the ignore-TLS-errors behavior.
|
||||
let protection_space = challenge.protectionSpace();
|
||||
let is_server_trust = protection_space
|
||||
.authenticationMethod()
|
||||
.isEqualToString(unsafe { NSURLAuthenticationMethodServerTrust });
|
||||
|
||||
let is_server_trust = protection_space.authenticationMethod().isEqualToString(unsafe { NSURLAuthenticationMethodServerTrust });
|
||||
let server_trust: *mut AnyObject = if is_server_trust {
|
||||
msg_send![&*protection_space, serverTrust]
|
||||
} else { ptr::null_mut() };
|
||||
let approved = std::ptr::NonNull::new(server_trust.cast::<objc2_security::SecTrust>()).is_some_and(|trust| {
|
||||
self.ivars().tls.borrow().allows(&protection_space.host().to_string(), unsafe { trust.as_ref() })
|
||||
});
|
||||
if !self.ivars().ignore_tls_errors.get() && !approved {
|
||||
let original = &self.ivars().original;
|
||||
if original.respondsToSelector(sel!(webView:didReceiveAuthenticationChallenge:completionHandler:)) {
|
||||
unsafe { original.webView_didReceiveAuthenticationChallenge_completionHandler(webview, challenge, completion_handler); }
|
||||
} else {
|
||||
completion_handler.call((challenge_disposition(false), ptr::null_mut()));
|
||||
}
|
||||
return;
|
||||
}
|
||||
if !is_server_trust {
|
||||
completion_handler.call((challenge_disposition(false), ptr::null_mut()));
|
||||
return;
|
||||
}
|
||||
|
||||
let server_trust: *mut AnyObject = msg_send![&*protection_space, serverTrust];
|
||||
if server_trust.is_null() {
|
||||
completion_handler.call((challenge_disposition(false), ptr::null_mut()));
|
||||
return;
|
||||
@@ -64,7 +155,7 @@ define_class!(
|
||||
}
|
||||
}
|
||||
|
||||
impl TlsNavigationDelegate {
|
||||
impl AuthNavigationDelegate {
|
||||
#[unsafe(method(respondsToSelector:))]
|
||||
fn responds_to_selector(&self, selector: Sel) -> bool {
|
||||
let responds: bool = unsafe { msg_send![super(self), respondsToSelector: selector] };
|
||||
@@ -82,10 +173,92 @@ define_class!(
|
||||
}
|
||||
);
|
||||
|
||||
impl TlsNavigationDelegate {
|
||||
fn new(original: Retained<ProtocolObject<dyn WKNavigationDelegate>>, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(TlsNavigationDelegateIvars { original });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
impl AuthNavigationDelegate {
|
||||
fn track_navigation(&self, navigation: Option<&WKNavigation>) {
|
||||
if let Some(navigation) = navigation {
|
||||
let key = navigation as *const WKNavigation as usize;
|
||||
self
|
||||
.ivars()
|
||||
.navigations
|
||||
.borrow_mut()
|
||||
.entry(key)
|
||||
.or_insert_with(|| (navigation.retain(), self.ivars().messenger.generation()));
|
||||
}
|
||||
}
|
||||
|
||||
fn navigation_generation(&self, navigation: Option<&WKNavigation>) -> Option<u64> {
|
||||
let key = navigation? as *const WKNavigation as usize;
|
||||
self
|
||||
.ivars()
|
||||
.navigations
|
||||
.borrow()
|
||||
.get(&key)
|
||||
.map(|(_, generation)| *generation)
|
||||
}
|
||||
|
||||
fn finish_navigation(&self, navigation: Option<&WKNavigation>) -> Option<u64> {
|
||||
let key = navigation? as *const WKNavigation as usize;
|
||||
self
|
||||
.ivars()
|
||||
.navigations
|
||||
.borrow_mut()
|
||||
.remove(&key)
|
||||
.map(|(_, generation)| generation)
|
||||
}
|
||||
|
||||
fn report_load_failure(&self, webview: &WKWebView, navigation: Option<&WKNavigation>, error: &NSError) {
|
||||
let Some(generation) = self.finish_navigation(navigation) else {
|
||||
return;
|
||||
};
|
||||
if generation != self.ivars().messenger.generation() {
|
||||
return;
|
||||
}
|
||||
let is_url_error = error.domain().isEqualToString(unsafe { NSURLErrorDomain });
|
||||
if is_url_error && error.code() == NSURLErrorCancelled {
|
||||
return;
|
||||
}
|
||||
if is_url_error && error.code() == NSURLErrorUnsupportedURL {
|
||||
let callback = error
|
||||
.userInfo()
|
||||
.objectForKey(unsafe { NSURLErrorFailingURLErrorKey })
|
||||
.and_then(|value| value.downcast::<NSURL>().ok())
|
||||
.and_then(|url| url.scheme());
|
||||
if callback.is_some_and(|scheme| scheme.to_string() == "globalprotectcallback") {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let messenger = &self.ivars().messenger;
|
||||
if let Some(failure) = self.ivars().tls.borrow_mut().record_failure(webview, error, generation) {
|
||||
messenger.send_auth_event(AuthEvent::Error(generation, failure));
|
||||
return;
|
||||
}
|
||||
// Log codes rather than NSError descriptions, which may contain callback URLs.
|
||||
messenger.send_auth_event(AuthEvent::Error(
|
||||
generation,
|
||||
AuthError::LoadFailed(anyhow::anyhow!(
|
||||
"Navigation failed: {} ({})",
|
||||
error.domain(),
|
||||
error.code()
|
||||
)),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
fn navigation_delegate(webview: &WKWebView) -> Option<Retained<AuthNavigationDelegate>> {
|
||||
unsafe {
|
||||
let pointer = objc_getAssociatedObject(
|
||||
webview as *const WKWebView as *mut AnyObject,
|
||||
&AUTH_NAVIGATION_DELEGATE_KEY as *const u8 as *const c_void,
|
||||
)
|
||||
.cast::<AuthNavigationDelegate>();
|
||||
Retained::retain(pointer.cast_mut())
|
||||
}
|
||||
}
|
||||
|
||||
fn track_requested_navigation(webview: &WKWebView, navigation: Option<&WKNavigation>) {
|
||||
let delegate = navigation_delegate(webview);
|
||||
if let Some(delegate) = delegate {
|
||||
delegate.track_navigation(navigation);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -97,15 +270,22 @@ fn challenge_disposition(is_server_trust: bool) -> NSURLSessionAuthChallengeDisp
|
||||
}
|
||||
}
|
||||
|
||||
fn install_tls_navigation_delegate(webview: &WKWebView) -> anyhow::Result<()> {
|
||||
fn install_navigation_delegate(webview: &WKWebView, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
let original = unsafe { webview.navigationDelegate() }.context("WebView navigation delegate is unavailable")?;
|
||||
let mtm = MainThreadMarker::new().context("WebView must be configured on the main thread")?;
|
||||
let delegate = TlsNavigationDelegate::new(original, mtm);
|
||||
let delegate = AuthNavigationDelegate::alloc(mtm).set_ivars(AuthNavigationDelegateIvars {
|
||||
original,
|
||||
messenger,
|
||||
ignore_tls_errors: Cell::new(false),
|
||||
tls: RefCell::new(tls::TlsState::default()),
|
||||
navigations: RefCell::new(HashMap::new()),
|
||||
});
|
||||
let delegate: Retained<AuthNavigationDelegate> = unsafe { msg_send![super(delegate), init] };
|
||||
|
||||
unsafe {
|
||||
objc_setAssociatedObject(
|
||||
webview as *const WKWebView as *mut AnyObject,
|
||||
&TLS_NAVIGATION_DELEGATE_KEY as *const u8 as *const c_void,
|
||||
&AUTH_NAVIGATION_DELEGATE_KEY as *const u8 as *const c_void,
|
||||
Retained::as_ptr(&delegate).cast_mut().cast(),
|
||||
OBJC_ASSOCIATION_RETAIN_NONATOMIC,
|
||||
);
|
||||
@@ -139,9 +319,47 @@ mod tests {
|
||||
}
|
||||
|
||||
impl PlatformWebviewExt for PlatformWebview {
|
||||
fn install_auth_controls(&self, window: &tauri::WebviewWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
let webview: &WKWebView = unsafe { &*self.inner().cast() };
|
||||
address_bar::install(webview)?;
|
||||
install_navigation_delegate(webview, Arc::clone(&messenger))?;
|
||||
recovery_row::install(webview, messenger)?;
|
||||
let window_handle = window.clone();
|
||||
window.on_window_event(move |event| {
|
||||
if matches!(
|
||||
event,
|
||||
tauri::WindowEvent::Resized(_) | tauri::WindowEvent::ScaleFactorChanged { .. }
|
||||
) {
|
||||
let _ = window_handle.with_webview(|webview| {
|
||||
let webview: &WKWebView = unsafe { &*webview.inner().cast() };
|
||||
address_bar::resize(webview);
|
||||
});
|
||||
}
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
let webview: &WKWebView = unsafe { &*self.inner().cast() };
|
||||
recovery_row::update(webview, status)
|
||||
}
|
||||
|
||||
fn stop_loading(&self) {
|
||||
let webview: &WKWebView = unsafe { &*self.inner().cast() };
|
||||
unsafe {
|
||||
webview.stopLoading();
|
||||
}
|
||||
}
|
||||
|
||||
fn confirm_tls_exception(&self) -> anyhow::Result<()> {
|
||||
tls::confirm(unsafe { &*self.inner().cast::<WKWebView>() })
|
||||
}
|
||||
|
||||
fn ignore_tls_errors(&self) -> anyhow::Result<()> {
|
||||
let webview: &WKWebView = unsafe { &*self.inner().cast() };
|
||||
install_tls_navigation_delegate(webview)
|
||||
let delegate = navigation_delegate(webview).context("Auth navigation delegate is unavailable")?;
|
||||
delegate.ivars().ignore_tls_errors.set(true);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn user_agent(&self) -> anyhow::Result<String> {
|
||||
@@ -173,7 +391,8 @@ impl PlatformWebviewExt for PlatformWebview {
|
||||
let url = NSURL::URLWithString(&NSString::from_str(url)).ok_or_else(|| anyhow::anyhow!("Invalid URL"))?;
|
||||
let request = NSURLRequest::requestWithURL(&url);
|
||||
|
||||
wv.loadRequest(&request);
|
||||
let navigation = wv.loadRequest(&request);
|
||||
track_requested_navigation(wv, navigation.as_deref());
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -182,31 +401,31 @@ impl PlatformWebviewExt for PlatformWebview {
|
||||
fn load_html(&self, html: &str) -> anyhow::Result<()> {
|
||||
unsafe {
|
||||
let wv: &WKWebView = &*self.inner().cast();
|
||||
wv.loadHTMLString_baseURL(&NSString::from_str(html), None);
|
||||
let navigation = wv.loadHTMLString_baseURL(&NSString::from_str(html), None);
|
||||
track_requested_navigation(wv, navigation.as_deref());
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn get_html(&self, callback: Box<dyn Fn(anyhow::Result<String>) + 'static>) {
|
||||
unsafe {
|
||||
let wv: &WKWebView = &*self.inner().cast();
|
||||
fn navigation_address(webview: &WKWebView) -> String {
|
||||
let url = unsafe { webview.URL() }.and_then(|url| url.absoluteString());
|
||||
redact_uri(&url.map(|url| url.to_string()).unwrap_or_default())
|
||||
}
|
||||
|
||||
let js_callback = RcBlock::new(move |body: *mut AnyObject, err: *mut NSError| {
|
||||
if let Some(err) = err.as_ref() {
|
||||
let code = err.code();
|
||||
let message = err.localizedDescription();
|
||||
callback(Err(anyhow::anyhow!("Error {}: {}", code, message)));
|
||||
} else {
|
||||
let body: &NSString = &*body.cast();
|
||||
callback(Ok(body.to_string()));
|
||||
}
|
||||
});
|
||||
|
||||
wv.evaluateJavaScript_completionHandler(
|
||||
&NSString::from_str("document.documentElement.outerHTML"),
|
||||
Some(&js_callback),
|
||||
);
|
||||
fn read_navigation_html(webview: &WKWebView, messenger: Arc<AuthMessenger>, generation: u64) {
|
||||
let callback = RcBlock::new(move |body: *mut AnyObject, error: *mut NSError| {
|
||||
if let Some(error) = unsafe { error.as_ref() } {
|
||||
warn!("Failed to get html: {} ({})", error.domain(), error.code());
|
||||
} else if let Some(body) = unsafe { body.as_ref() }.and_then(|body| body.downcast_ref::<NSString>()) {
|
||||
messenger.read_from_html(&body.to_string(), generation);
|
||||
}
|
||||
});
|
||||
unsafe {
|
||||
webview.evaluateJavaScript_completionHandler(
|
||||
&NSString::from_str("document.documentElement.outerHTML"),
|
||||
Some(&callback),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
use std::{ffi::c_void, ptr};
|
||||
|
||||
use anyhow::Context;
|
||||
use objc2::{
|
||||
DefinedClass, MainThreadOnly, Message, define_class,
|
||||
ffi::{OBJC_ASSOCIATION_RETAIN_NONATOMIC, objc_getAssociatedObject, objc_setAssociatedObject},
|
||||
msg_send,
|
||||
rc::Retained,
|
||||
runtime::{AnyObject, ProtocolObject},
|
||||
};
|
||||
use objc2_app_kit::{
|
||||
NSAccessibility, NSAutoresizingMaskOptions, NSBox, NSBoxType, NSColor, NSFont, NSLayoutConstraint,
|
||||
NSLayoutConstraintOrientation, NSLineBreakMode, NSTextView, NSToolbar, NSToolbarDelegate, NSToolbarDisplayMode,
|
||||
NSToolbarItem, NSToolbarItemIdentifier, NSWindowTitleVisibility, NSWindowToolbarStyle,
|
||||
};
|
||||
use objc2_foundation::{
|
||||
MainThreadMarker, NSArray, NSDictionary, NSKeyValueChangeKey, NSKeyValueObservingOptions, NSObject,
|
||||
NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString,
|
||||
};
|
||||
use objc2_web_kit::WKWebView;
|
||||
|
||||
use super::super::address_bar::{LOADING_ADDRESS, display_address};
|
||||
|
||||
static ADDRESS_TOOLBAR_KEY: u8 = 0;
|
||||
const ADDRESS_ITEM_ID: &str = "com.yuezk.gpauth.address";
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super = NSTextView)]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
struct AddressView;
|
||||
|
||||
impl AddressView {
|
||||
#[unsafe(method(intrinsicContentSize))]
|
||||
fn intrinsic_content_size(&self) -> NSSize {
|
||||
// URL length must not determine the toolbar item's width.
|
||||
NSSize::new(-1.0, 22.0)
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
struct AddressToolbarIvars {
|
||||
webview: Retained<WKWebView>,
|
||||
address_view: Retained<NSTextView>,
|
||||
separator: Retained<NSBox>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
// The content view retains the delegate because NSToolbar's delegate is weak.
|
||||
// Drop unregisters URL observation before releasing the retained webview.
|
||||
#[unsafe(super = NSObject)]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[ivars = AddressToolbarIvars]
|
||||
struct AddressToolbar;
|
||||
|
||||
unsafe impl NSObjectProtocol for AddressToolbar {}
|
||||
|
||||
unsafe impl NSToolbarDelegate for AddressToolbar {
|
||||
#[unsafe(method_id(toolbar:itemForItemIdentifier:willBeInsertedIntoToolbar:))]
|
||||
fn toolbar_item(
|
||||
&self,
|
||||
_toolbar: &NSToolbar,
|
||||
identifier: &NSToolbarItemIdentifier,
|
||||
inserting: bool,
|
||||
) -> Option<Retained<NSToolbarItem>> {
|
||||
if !inserting || !identifier.isEqualToString(&NSString::from_str(ADDRESS_ITEM_ID)) {
|
||||
None
|
||||
} else {
|
||||
let item = NSToolbarItem::initWithItemIdentifier(NSToolbarItem::alloc(self.mtm()), identifier);
|
||||
item.setLabel(&NSString::from_str("Sign-in page address"));
|
||||
item.setBordered(true);
|
||||
item.setView(Some(&self.ivars().address_view));
|
||||
Some(item)
|
||||
}
|
||||
}
|
||||
|
||||
#[unsafe(method_id(toolbarDefaultItemIdentifiers:))]
|
||||
fn default_items(&self, _toolbar: &NSToolbar) -> Retained<NSArray<NSToolbarItemIdentifier>> {
|
||||
NSArray::from_retained_slice(&[NSString::from_str(ADDRESS_ITEM_ID)])
|
||||
}
|
||||
|
||||
#[unsafe(method_id(toolbarAllowedItemIdentifiers:))]
|
||||
fn allowed_items(&self, _toolbar: &NSToolbar) -> Retained<NSArray<NSToolbarItemIdentifier>> {
|
||||
NSArray::from_retained_slice(&[NSString::from_str(ADDRESS_ITEM_ID)])
|
||||
}
|
||||
}
|
||||
|
||||
impl AddressToolbar {
|
||||
#[unsafe(method(observeValueForKeyPath:ofObject:change:context:))]
|
||||
fn observe_url(
|
||||
&self,
|
||||
_key_path: Option<&NSString>,
|
||||
_object: Option<&AnyObject>,
|
||||
_change: Option<&NSDictionary<NSKeyValueChangeKey, AnyObject>>,
|
||||
_context: *mut c_void,
|
||||
) {
|
||||
let uri = unsafe { self.ivars().webview.URL() }.and_then(|url| url.absoluteString());
|
||||
let address = display_address(uri.as_ref().map(|uri| uri.to_string()).as_deref());
|
||||
self.ivars().address_view.setString(&NSString::from_str(&address));
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl Drop for AddressToolbar {
|
||||
fn drop(&mut self) {
|
||||
// This private observer registers only URL and remains on the main thread.
|
||||
unsafe {
|
||||
self
|
||||
.ivars()
|
||||
.webview
|
||||
.removeObserver_forKeyPath(self, &NSString::from_str("URL"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn install(webview: &WKWebView) -> anyhow::Result<()> {
|
||||
let mtm = MainThreadMarker::new().context("Toolbar must be installed on the main thread")?;
|
||||
let parent = unsafe { webview.superview() }.context("Webview has no containing view")?;
|
||||
let window = webview.window().context("Webview has no window")?;
|
||||
parent.setWantsLayer(true);
|
||||
let address_view: Retained<AddressView> =
|
||||
unsafe { msg_send![AddressView::alloc(mtm), initWithFrame: NSRect::default()] };
|
||||
// Use one native text layout for display and selection.
|
||||
address_view.setString(&NSString::from_str(LOADING_ADDRESS));
|
||||
address_view.setDrawsBackground(false);
|
||||
// Keep NSTextView's visible-rect cursor tracking inside the address bar.
|
||||
address_view.setClipsToBounds(true);
|
||||
address_view.setRichText(false);
|
||||
address_view.setHorizontallyResizable(false);
|
||||
address_view.setVerticallyResizable(false);
|
||||
address_view.setTextContainerInset(NSSize::new(6.0, 3.0));
|
||||
address_view.setEditable(false);
|
||||
address_view.setSelectable(true);
|
||||
address_view.setFont(Some(&NSFont::systemFontOfSize(12.0)));
|
||||
address_view.setContentHuggingPriority_forOrientation(1.0, NSLayoutConstraintOrientation::Horizontal);
|
||||
address_view.setAccessibilityLabel(Some(&NSString::from_str("Sign-in page address")));
|
||||
if let Some(container) = unsafe { address_view.textContainer() } {
|
||||
container.setWidthTracksTextView(true);
|
||||
container.setLineFragmentPadding(0.0);
|
||||
container.setMaximumNumberOfLines(1);
|
||||
container.setLineBreakMode(NSLineBreakMode::ByTruncatingTail);
|
||||
}
|
||||
// AppKit measures the toolbar item's minimum and maximum width from its view.
|
||||
NSLayoutConstraint::activateConstraints(&NSArray::from_retained_slice(&[
|
||||
address_view.widthAnchor().constraintGreaterThanOrEqualToConstant(200.0),
|
||||
address_view.widthAnchor().constraintLessThanOrEqualToConstant(10000.0),
|
||||
address_view.heightAnchor().constraintEqualToConstant(22.0),
|
||||
]));
|
||||
let separator = NSBox::new(mtm);
|
||||
separator
|
||||
.setAutoresizingMask(NSAutoresizingMaskOptions::ViewWidthSizable | NSAutoresizingMaskOptions::ViewMinYMargin);
|
||||
separator.setBoxType(NSBoxType::Custom);
|
||||
separator.setBorderWidth(0.0);
|
||||
separator.setCornerRadius(0.0);
|
||||
separator.setFillColor(&NSColor::separatorColor());
|
||||
parent.addSubview(&separator);
|
||||
let delegate = AddressToolbar::alloc(mtm).set_ivars(AddressToolbarIvars {
|
||||
webview: webview.retain(),
|
||||
address_view: Retained::into_super(address_view),
|
||||
separator,
|
||||
});
|
||||
let delegate: Retained<AddressToolbar> = unsafe { msg_send![super(delegate), init] };
|
||||
// Observe the current URL independently of navigation callbacks.
|
||||
unsafe {
|
||||
webview.addObserver_forKeyPath_options_context(
|
||||
&delegate,
|
||||
&NSString::from_str("URL"),
|
||||
NSKeyValueObservingOptions::Initial,
|
||||
ptr::null_mut(),
|
||||
);
|
||||
objc_setAssociatedObject(
|
||||
Retained::as_ptr(&parent).cast_mut().cast(),
|
||||
&ADDRESS_TOOLBAR_KEY as *const u8 as *const c_void,
|
||||
Retained::as_ptr(&delegate).cast_mut().cast(),
|
||||
OBJC_ASSOCIATION_RETAIN_NONATOMIC,
|
||||
);
|
||||
}
|
||||
let toolbar = NSToolbar::initWithIdentifier(NSToolbar::alloc(mtm), &NSString::from_str("com.yuezk.gpauth.toolbar"));
|
||||
toolbar.setAllowsUserCustomization(false);
|
||||
toolbar.setDisplayMode(NSToolbarDisplayMode::IconOnly);
|
||||
toolbar.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
|
||||
window.setTitleVisibility(NSWindowTitleVisibility::Visible);
|
||||
if objc2::available!(macos = 11.0) {
|
||||
window.setToolbarStyle(NSWindowToolbarStyle::Expanded);
|
||||
}
|
||||
window.setToolbar(Some(&toolbar));
|
||||
window.setInitialFirstResponder(Some(webview));
|
||||
resize(webview);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn address_view(webview: &WKWebView) -> Option<Retained<NSTextView>> {
|
||||
let parent = unsafe { webview.superview() }?;
|
||||
let delegate = unsafe {
|
||||
objc_getAssociatedObject(
|
||||
Retained::as_ptr(&parent).cast_mut().cast(),
|
||||
&ADDRESS_TOOLBAR_KEY as *const u8 as *const c_void,
|
||||
)
|
||||
.cast::<AddressToolbar>()
|
||||
.as_ref()
|
||||
}?;
|
||||
Some(delegate.ivars().address_view.clone())
|
||||
}
|
||||
|
||||
pub(super) fn show_address(webview: &WKWebView, uri: &str) {
|
||||
if let Some(view) = address_view(webview) {
|
||||
view.setString(&NSString::from_str(&display_address(Some(uri))));
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn resize(webview: &WKWebView) {
|
||||
let Some(parent) = (unsafe { webview.superview() }) else {
|
||||
return;
|
||||
};
|
||||
let Some(window) = webview.window() else {
|
||||
return;
|
||||
};
|
||||
// Keep the native separator outside WebKit so page backgrounds cannot cover it.
|
||||
let content = parent.convertRect_fromView(window.contentLayoutRect(), None);
|
||||
let separator_height = 1.0 / window.backingScaleFactor();
|
||||
let recovery_height = super::recovery_row::layout(webview, content);
|
||||
let page_height = (content.size.height - recovery_height - separator_height).max(0.0);
|
||||
let delegate = unsafe {
|
||||
objc_getAssociatedObject(
|
||||
Retained::as_ptr(&parent).cast_mut().cast(),
|
||||
&ADDRESS_TOOLBAR_KEY as *const u8 as *const c_void,
|
||||
)
|
||||
.cast::<AddressToolbar>()
|
||||
.as_ref()
|
||||
};
|
||||
if let Some(delegate) = delegate {
|
||||
delegate.ivars().separator.setFrame(NSRect::new(
|
||||
NSPoint::new(content.origin.x, content.origin.y + page_height),
|
||||
NSSize::new(content.size.width, separator_height),
|
||||
));
|
||||
}
|
||||
webview.setFrame(NSRect::new(
|
||||
content.origin,
|
||||
NSSize::new(content.size.width, page_height),
|
||||
));
|
||||
}
|
||||
@@ -0,0 +1,332 @@
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
ffi::c_void,
|
||||
ptr,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use anyhow::Context;
|
||||
use block2::RcBlock;
|
||||
use objc2::{
|
||||
DefinedClass, MainThreadOnly, Message, define_class,
|
||||
ffi::{OBJC_ASSOCIATION_RETAIN_NONATOMIC, objc_getAssociatedObject, objc_setAssociatedObject},
|
||||
msg_send,
|
||||
rc::{Retained, Weak},
|
||||
runtime::AnyObject,
|
||||
sel,
|
||||
};
|
||||
use objc2_app_kit::{
|
||||
NSAutoresizingMaskOptions, NSBezelStyle, NSBox, NSBoxType, NSButton, NSColor, NSControlSize, NSEvent, NSEventMask,
|
||||
NSEventModifierFlags, NSFont, NSLineBreakMode, NSProgressIndicator, NSProgressIndicatorStyle, NSTextField,
|
||||
NSTitlePosition, NSView,
|
||||
};
|
||||
use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString};
|
||||
use objc2_web_kit::WKWebView;
|
||||
|
||||
use super::super::{
|
||||
auth_messenger::{AuthEvent, AuthMessenger},
|
||||
recovery::RecoveryStatus,
|
||||
};
|
||||
|
||||
static RECOVERY_ROW_KEY: u8 = 0;
|
||||
|
||||
struct RecoveryRowIvars {
|
||||
webview: Retained<WKWebView>,
|
||||
messenger: Arc<AuthMessenger>,
|
||||
row: Retained<NSBox>,
|
||||
blocker: Retained<NSView>,
|
||||
label: Retained<NSTextField>,
|
||||
detail: Retained<NSTextField>,
|
||||
proceed: Retained<NSButton>,
|
||||
status: Cell<RecoveryStatus>,
|
||||
spinner: Retained<NSProgressIndicator>,
|
||||
retry: Retained<NSButton>,
|
||||
cancel: Retained<NSButton>,
|
||||
keyboard_monitor: RefCell<Option<Retained<AnyObject>>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super = NSObject)]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[ivars = RecoveryRowIvars]
|
||||
struct RecoveryRow;
|
||||
|
||||
unsafe impl NSObjectProtocol for RecoveryRow {}
|
||||
|
||||
impl RecoveryRow {
|
||||
#[unsafe(method(retry:))]
|
||||
fn retry(&self, _sender: &AnyObject) {
|
||||
self.ivars().messenger.send_auth_event(AuthEvent::Retry);
|
||||
}
|
||||
|
||||
#[unsafe(method(continueTls:))]
|
||||
fn continue_tls(&self, _sender: &AnyObject) {
|
||||
self.ivars().messenger.send_auth_event(AuthEvent::RequestTlsException);
|
||||
}
|
||||
|
||||
#[unsafe(method(cancel:))]
|
||||
fn cancel(&self, _sender: &AnyObject) {
|
||||
self.ivars().messenger.send_auth_event(AuthEvent::Close);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl Drop for RecoveryRow {
|
||||
fn drop(&mut self) {
|
||||
if let Some(monitor) = self.ivars().keyboard_monitor.borrow_mut().take() {
|
||||
unsafe {
|
||||
NSEvent::removeMonitor(&monitor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RecoveryRow {
|
||||
fn handle_key(&self, event: &NSEvent) -> bool {
|
||||
let controls = self.ivars();
|
||||
if !controls.status.get().blocks_page() {
|
||||
return false;
|
||||
}
|
||||
let Some(window) = controls.webview.window() else {
|
||||
return false;
|
||||
};
|
||||
if window.attachedSheet().is_some() || event.window(self.mtm()).as_deref() != Some(&*window) {
|
||||
return false;
|
||||
}
|
||||
let responder = window.firstResponder();
|
||||
let modifiers = event.modifierFlags();
|
||||
if event.keyCode() == 48 && !modifiers.intersects(NSEventModifierFlags::Command | NSEventModifierFlags::Control) {
|
||||
// Explicit traversal also works when the system skips buttons in its default key loop.
|
||||
let Some(address) = super::address_bar::address_view(&controls.webview) else {
|
||||
return false;
|
||||
};
|
||||
let mut views: Vec<&NSView> = vec![&address];
|
||||
if !controls.retry.isHidden() {
|
||||
views.push(&controls.retry);
|
||||
}
|
||||
if !controls.proceed.isHidden() {
|
||||
views.push(&controls.proceed);
|
||||
}
|
||||
views.push(&controls.cancel);
|
||||
let current = responder.as_ref().and_then(|responder| {
|
||||
views.iter().position(|view| {
|
||||
ptr::eq(
|
||||
(*view) as *const NSView as *const c_void,
|
||||
Retained::as_ptr(responder).cast(),
|
||||
)
|
||||
})
|
||||
});
|
||||
let next = match current {
|
||||
Some(index) if modifiers.contains(NSEventModifierFlags::Shift) => (index + views.len() - 1) % views.len(),
|
||||
Some(index) => (index + 1) % views.len(),
|
||||
None => views.len() - 1,
|
||||
};
|
||||
window.makeFirstResponder(Some(views[next]));
|
||||
return true;
|
||||
}
|
||||
// If WebKit regains focus programmatically, do not deliver keys to the covered page.
|
||||
if responder
|
||||
.as_deref()
|
||||
.and_then(|responder| responder.downcast_ref::<NSView>())
|
||||
.is_some_and(|view| view.isDescendantOf(&controls.webview))
|
||||
{
|
||||
window.makeFirstResponder(Some(&controls.cancel));
|
||||
return true;
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn install(webview: &WKWebView, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
let mtm = MainThreadMarker::new().context("Recovery controls require the main thread")?;
|
||||
let parent = unsafe { webview.superview() }.context("Webview has no containing view")?;
|
||||
let row = NSBox::new(mtm);
|
||||
// AppKit may resize the parent after the application's window resize callback.
|
||||
row.setAutoresizingMask(NSAutoresizingMaskOptions::ViewWidthSizable | NSAutoresizingMaskOptions::ViewMinYMargin);
|
||||
row.setBoxType(NSBoxType::Custom);
|
||||
row.setTitlePosition(NSTitlePosition::NoTitle);
|
||||
row.setContentViewMargins(NSSize::new(0.0, 0.0));
|
||||
row.setBorderWidth(0.0);
|
||||
row.setCornerRadius(0.0);
|
||||
row.setFillColor(&NSColor::windowBackgroundColor());
|
||||
let label = NSTextField::labelWithString(&NSString::new(), mtm);
|
||||
label.setFont(Some(&NSFont::systemFontOfSize(12.0)));
|
||||
label.setLineBreakMode(NSLineBreakMode::ByTruncatingTail);
|
||||
label.setAutoresizingMask(NSAutoresizingMaskOptions::ViewWidthSizable);
|
||||
let detail = NSTextField::labelWithString(&NSString::new(), mtm);
|
||||
detail.setFont(Some(&NSFont::systemFontOfSize(11.0)));
|
||||
detail.setTextColor(Some(&NSColor::secondaryLabelColor()));
|
||||
detail.setLineBreakMode(NSLineBreakMode::ByTruncatingTail);
|
||||
detail.setAutoresizingMask(NSAutoresizingMaskOptions::ViewWidthSizable);
|
||||
let spinner = NSProgressIndicator::new(mtm);
|
||||
spinner.setStyle(NSProgressIndicatorStyle::Spinning);
|
||||
spinner.setControlSize(NSControlSize::Small);
|
||||
spinner.setIndeterminate(true);
|
||||
let retry = unsafe { NSButton::buttonWithTitle_target_action(&NSString::from_str("Try Again"), None, None, mtm) };
|
||||
let cancel = unsafe { NSButton::buttonWithTitle_target_action(&NSString::from_str("Cancel"), None, None, mtm) };
|
||||
let proceed =
|
||||
unsafe { NSButton::buttonWithTitle_target_action(&NSString::from_str("Continue Anyway…"), None, None, mtm) };
|
||||
for button in [&retry, &proceed, &cancel] {
|
||||
button.setAutoresizingMask(NSAutoresizingMaskOptions::ViewMinXMargin);
|
||||
button.setBezelStyle(NSBezelStyle::Push);
|
||||
button.setControlSize(NSControlSize::Small);
|
||||
button.setFont(Some(&NSFont::systemFontOfSize(12.0)));
|
||||
row.addSubview(button);
|
||||
}
|
||||
row.addSubview(&label);
|
||||
row.addSubview(&detail);
|
||||
row.addSubview(&spinner);
|
||||
let blocker = NSView::new(mtm);
|
||||
blocker
|
||||
.setAutoresizingMask(NSAutoresizingMaskOptions::ViewWidthSizable | NSAutoresizingMaskOptions::ViewHeightSizable);
|
||||
parent.addSubview(&blocker);
|
||||
parent.addSubview(&row);
|
||||
row.setHidden(true);
|
||||
blocker.setHidden(true);
|
||||
let controller = RecoveryRow::alloc(mtm).set_ivars(RecoveryRowIvars {
|
||||
webview: webview.retain(),
|
||||
messenger,
|
||||
row,
|
||||
blocker,
|
||||
label,
|
||||
detail,
|
||||
proceed,
|
||||
status: Cell::new(RecoveryStatus::Hidden),
|
||||
spinner,
|
||||
retry,
|
||||
cancel,
|
||||
keyboard_monitor: RefCell::new(None),
|
||||
});
|
||||
let controller: Retained<RecoveryRow> = unsafe { msg_send![super(controller), init] };
|
||||
let weak_controller = Weak::from_retained(&controller);
|
||||
let handler = RcBlock::new(move |event: std::ptr::NonNull<NSEvent>| {
|
||||
let blocked = weak_controller
|
||||
.load()
|
||||
.is_some_and(|controller| controller.handle_key(unsafe { event.as_ref() }));
|
||||
if blocked { ptr::null_mut() } else { event.as_ptr() }
|
||||
});
|
||||
let monitor = unsafe { NSEvent::addLocalMonitorForEventsMatchingMask_handler(NSEventMask::KeyDown, &handler) }
|
||||
.context("Failed to guard keyboard input during sign-in recovery")?;
|
||||
*controller.ivars().keyboard_monitor.borrow_mut() = Some(monitor);
|
||||
unsafe {
|
||||
controller.ivars().retry.setTarget(Some(&controller));
|
||||
controller.ivars().retry.setAction(Some(sel!(retry:)));
|
||||
controller.ivars().proceed.setTarget(Some(&controller));
|
||||
controller.ivars().proceed.setAction(Some(sel!(continueTls:)));
|
||||
controller.ivars().cancel.setTarget(Some(&controller));
|
||||
controller.ivars().cancel.setAction(Some(sel!(cancel:)));
|
||||
objc_setAssociatedObject(
|
||||
Retained::as_ptr(&parent).cast_mut().cast(),
|
||||
&RECOVERY_ROW_KEY as *const u8 as *const c_void,
|
||||
Retained::as_ptr(&controller).cast_mut().cast(),
|
||||
OBJC_ASSOCIATION_RETAIN_NONATOMIC,
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn controller(webview: &WKWebView) -> Option<Retained<RecoveryRow>> {
|
||||
let parent = unsafe { webview.superview() }?;
|
||||
unsafe {
|
||||
let pointer = objc_getAssociatedObject(
|
||||
Retained::as_ptr(&parent).cast_mut().cast(),
|
||||
&RECOVERY_ROW_KEY as *const u8 as *const c_void,
|
||||
)
|
||||
.cast::<RecoveryRow>();
|
||||
Retained::retain(pointer.cast_mut())
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn update(webview: &WKWebView, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
let controller = controller(webview).context("Recovery controls are unavailable")?;
|
||||
let controls = controller.ivars();
|
||||
let was_blocking = controls.status.replace(status).blocks_page();
|
||||
let hidden = status == RecoveryStatus::Hidden;
|
||||
controls.label.setStringValue(&NSString::from_str(status.message()));
|
||||
controls.detail.setStringValue(&NSString::from_str(status.detail()));
|
||||
controls.detail.setHidden(status.detail().is_empty());
|
||||
controls.retry.setHidden(!status.can_retry());
|
||||
controls.proceed.setHidden(!status.can_continue());
|
||||
controls.cancel.setHidden(!status.blocks_page());
|
||||
controls.spinner.setHidden(!status.is_busy());
|
||||
unsafe {
|
||||
if status.is_busy() {
|
||||
controls.spinner.startAnimation(None);
|
||||
} else {
|
||||
controls.spinner.stopAnimation(None);
|
||||
}
|
||||
}
|
||||
controls.row.setHidden(hidden);
|
||||
controls.blocker.setHidden(!status.blocks_page());
|
||||
if was_blocking != status.blocks_page() {
|
||||
if let Some(window) = webview.window() {
|
||||
if !status.blocks_page() {
|
||||
window.makeFirstResponder(Some(webview));
|
||||
} else {
|
||||
window.makeFirstResponder(Some(&controls.cancel));
|
||||
}
|
||||
}
|
||||
}
|
||||
super::address_bar::resize(webview);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Position the row above the page and return the height reserved for it.
|
||||
pub(super) fn layout(webview: &WKWebView, content: NSRect) -> f64 {
|
||||
let Some(controller) = controller(webview) else {
|
||||
return 0.0;
|
||||
};
|
||||
let controls = controller.ivars();
|
||||
if controls.row.isHidden() {
|
||||
return 0.0;
|
||||
}
|
||||
let height = if controls.status.get().detail().is_empty() {
|
||||
36.0
|
||||
} else {
|
||||
52.0
|
||||
};
|
||||
let width = content.size.width;
|
||||
controls.row.setFrame(NSRect::new(
|
||||
NSPoint::new(content.origin.x, content.origin.y + content.size.height - height),
|
||||
NSSize::new(width, height),
|
||||
));
|
||||
controls.blocker.setFrame(NSRect::new(
|
||||
content.origin,
|
||||
NSSize::new(width, (content.size.height - height).max(0.0)),
|
||||
));
|
||||
controls.cancel.setFrame(NSRect::new(
|
||||
NSPoint::new(width - 80.0, (height - 26.0) / 2.0),
|
||||
NSSize::new(72.0, 26.0),
|
||||
));
|
||||
controls.retry.setFrame(NSRect::new(
|
||||
NSPoint::new(
|
||||
width - 162.0 - if controls.proceed.isHidden() { 0.0 } else { 132.0 },
|
||||
(height - 26.0) / 2.0,
|
||||
),
|
||||
NSSize::new(78.0, 26.0),
|
||||
));
|
||||
controls.proceed.setFrame(NSRect::new(
|
||||
NSPoint::new(width - 212.0, (height - 26.0) / 2.0),
|
||||
NSSize::new(128.0, 26.0),
|
||||
));
|
||||
controls
|
||||
.spinner
|
||||
.setFrame(NSRect::new(NSPoint::new(12.0, 10.0), NSSize::new(16.0, 16.0)));
|
||||
let left = if controls.spinner.isHidden() { 12.0 } else { 36.0 };
|
||||
let right = if !controls.proceed.isHidden() {
|
||||
width - 220.0
|
||||
} else if !controls.retry.isHidden() {
|
||||
width - 170.0
|
||||
} else {
|
||||
width - 88.0
|
||||
};
|
||||
controls.label.setFrame(NSRect::new(
|
||||
NSPoint::new(left, height - 26.0),
|
||||
NSSize::new((right - left).max(0.0), 17.0),
|
||||
));
|
||||
controls.detail.setFrame(NSRect::new(
|
||||
NSPoint::new(left, 7.0),
|
||||
NSSize::new((right - left).max(0.0), 15.0),
|
||||
));
|
||||
height
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
use anyhow::Context;
|
||||
use block2::RcBlock;
|
||||
use objc2::{DefinedClass, MainThreadOnly, rc::Weak};
|
||||
use objc2_app_kit::{NSAlert, NSAlertSecondButtonReturn, NSAlertStyle};
|
||||
use objc2_foundation::{
|
||||
NSError, NSString, NSURL, NSURLErrorDomain, NSURLErrorFailingURLErrorKey, NSURLErrorFailingURLPeerTrustErrorKey,
|
||||
NSUnderlyingErrorKey,
|
||||
};
|
||||
use objc2_security::{SecTrust, errSecHostNameMismatch};
|
||||
use objc2_web_kit::WKWebView;
|
||||
|
||||
use super::super::{
|
||||
auth_messenger::{AuthError, AuthEvent},
|
||||
tls::{TlsFailure, TlsFailureReason},
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct CertificateException {
|
||||
host: String,
|
||||
certificate: Vec<u8>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct PendingCertificate {
|
||||
generation: u64,
|
||||
failure: TlsFailure,
|
||||
exception: CertificateException,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct TlsState {
|
||||
pending: Option<PendingCertificate>,
|
||||
exceptions: Vec<CertificateException>,
|
||||
}
|
||||
|
||||
impl TlsState {
|
||||
fn approve(&mut self, pending: &PendingCertificate, generation: u64) -> bool {
|
||||
if pending.generation != generation
|
||||
|| self.pending.as_ref().is_none_or(|current| {
|
||||
current.generation != pending.generation
|
||||
|| current.exception.certificate != pending.exception.certificate
|
||||
|| current.exception.host != pending.exception.host
|
||||
})
|
||||
{
|
||||
return false;
|
||||
}
|
||||
self.exceptions.push(pending.exception.clone());
|
||||
self.pending = None;
|
||||
true
|
||||
}
|
||||
|
||||
pub fn record_failure(&mut self, webview: &WKWebView, error: &NSError, generation: u64) -> Option<AuthError> {
|
||||
if !error.domain().isEqualToString(unsafe { NSURLErrorDomain }) {
|
||||
return None;
|
||||
}
|
||||
let reason = match error.code() {
|
||||
-1200 => TlsFailureReason::Handshake,
|
||||
-1201 => TlsFailureReason::Expired,
|
||||
-1202 => TlsFailureReason::InvalidCertificate,
|
||||
-1203 => TlsFailureReason::Untrusted,
|
||||
-1204 => TlsFailureReason::NotYetValid,
|
||||
_ => return None,
|
||||
};
|
||||
let reason = if has_hostname_mismatch(error, 0) {
|
||||
TlsFailureReason::HostnameMismatch
|
||||
} else {
|
||||
reason
|
||||
};
|
||||
let url = error
|
||||
.userInfo()
|
||||
.objectForKey(unsafe { NSURLErrorFailingURLErrorKey })?
|
||||
.downcast::<NSURL>()
|
||||
.ok()?;
|
||||
let host = url.host()?.to_string().to_ascii_lowercase();
|
||||
if let Some(uri) = url.absoluteString() {
|
||||
super::address_bar::show_address(webview, &uri.to_string());
|
||||
}
|
||||
let trust = error
|
||||
.userInfo()
|
||||
.objectForKey(unsafe { NSURLErrorFailingURLPeerTrustErrorKey });
|
||||
let certificate = trust.and_then(|trust| {
|
||||
// Foundation documents this entry as a SecTrustRef.
|
||||
let trust = unsafe { &*(objc2::rc::Retained::as_ptr(&trust).cast::<SecTrust>()) };
|
||||
certificate_data(trust)
|
||||
});
|
||||
let failure = TlsFailure {
|
||||
host: host.clone(),
|
||||
reason,
|
||||
can_continue: reason.is_certificate_error() && certificate.is_some(),
|
||||
};
|
||||
self.pending = certificate
|
||||
.filter(|_| failure.can_continue)
|
||||
.map(|certificate| PendingCertificate {
|
||||
generation,
|
||||
failure: failure.clone(),
|
||||
exception: CertificateException { host, certificate },
|
||||
});
|
||||
Some(AuthError::Tls(failure))
|
||||
}
|
||||
|
||||
pub fn allows(&self, host: &str, trust: &SecTrust) -> bool {
|
||||
if self.exceptions.is_empty() {
|
||||
return false;
|
||||
}
|
||||
let Some(certificate) = certificate_data(trust) else {
|
||||
return false;
|
||||
};
|
||||
self
|
||||
.exceptions
|
||||
.iter()
|
||||
.any(|exception| exception.host.eq_ignore_ascii_case(host) && exception.certificate == certificate)
|
||||
}
|
||||
}
|
||||
|
||||
fn has_hostname_mismatch(error: &NSError, depth: usize) -> bool {
|
||||
if depth > 4 {
|
||||
return false;
|
||||
}
|
||||
if error.code() == errSecHostNameMismatch as isize {
|
||||
return true;
|
||||
}
|
||||
error
|
||||
.userInfo()
|
||||
.objectForKey(unsafe { NSUnderlyingErrorKey })
|
||||
.and_then(|value| value.downcast::<NSError>().ok())
|
||||
.is_some_and(|error| has_hostname_mismatch(&error, depth + 1))
|
||||
}
|
||||
|
||||
fn certificate_data(trust: &SecTrust) -> Option<Vec<u8>> {
|
||||
// Retain the leaf immediately. No trust evaluation or mutation runs here.
|
||||
#[allow(deprecated)]
|
||||
let certificate = unsafe { trust.certificate_at_index(0) }?;
|
||||
Some(unsafe { certificate.data() }.to_vec())
|
||||
}
|
||||
|
||||
pub(super) fn confirm(webview: &WKWebView) -> anyhow::Result<()> {
|
||||
let delegate = super::navigation_delegate(webview).context("Auth navigation delegate is unavailable")?;
|
||||
let pending = delegate
|
||||
.ivars()
|
||||
.tls
|
||||
.borrow()
|
||||
.pending
|
||||
.clone()
|
||||
.context("No certificate error is awaiting confirmation")?;
|
||||
if pending.generation != delegate.ivars().messenger.generation() {
|
||||
return Ok(());
|
||||
}
|
||||
let window = webview.window().context("Auth window is unavailable")?;
|
||||
if window.attachedSheet().is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
let alert = NSAlert::new(delegate.mtm());
|
||||
alert.setAlertStyle(NSAlertStyle::Warning);
|
||||
alert.setMessageText(&NSString::from_str(&pending.failure.confirmation_title()));
|
||||
alert.setInformativeText(&NSString::from_str(&pending.failure.confirmation_message()));
|
||||
alert.addButtonWithTitle(&NSString::from_str("Cancel"));
|
||||
alert.addButtonWithTitle(&NSString::from_str("Continue Anyway"));
|
||||
let weak = Weak::from_retained(&delegate);
|
||||
let handler = RcBlock::new(move |response: isize| {
|
||||
let Some(delegate) = weak.load() else {
|
||||
return;
|
||||
};
|
||||
if response != NSAlertSecondButtonReturn || pending.generation != delegate.ivars().messenger.generation() {
|
||||
return;
|
||||
}
|
||||
let mut state = delegate.ivars().tls.borrow_mut();
|
||||
if !state.approve(&pending, delegate.ivars().messenger.generation()) {
|
||||
return;
|
||||
}
|
||||
drop(state);
|
||||
delegate
|
||||
.ivars()
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::TlsAccepted(pending.generation));
|
||||
});
|
||||
alert.beginSheetModalForWindow_completionHandler(&window, Some(&handler));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn pending() -> PendingCertificate {
|
||||
PendingCertificate {
|
||||
generation: 1,
|
||||
failure: TlsFailure {
|
||||
host: "login.example".into(),
|
||||
reason: TlsFailureReason::Expired,
|
||||
can_continue: true,
|
||||
},
|
||||
exception: CertificateException {
|
||||
host: "login.example".into(),
|
||||
certificate: vec![1, 2, 3],
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn certificate_approval_rejects_stale_attempts_and_replacement_certificates() {
|
||||
let original = pending();
|
||||
let mut state = TlsState {
|
||||
pending: Some(original.clone()),
|
||||
..TlsState::default()
|
||||
};
|
||||
assert!(!state.approve(&original, 2));
|
||||
let mut replacement = original.clone();
|
||||
replacement.exception.certificate = vec![4, 5, 6];
|
||||
state.pending = Some(replacement);
|
||||
assert!(!state.approve(&original, 1));
|
||||
assert!(state.exceptions.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn certificate_approval_is_specific_to_the_host_and_consumed_once() {
|
||||
let original = pending();
|
||||
let mut state = TlsState {
|
||||
pending: Some(original.clone()),
|
||||
..TlsState::default()
|
||||
};
|
||||
let mut other_host = original.clone();
|
||||
other_host.exception.host = "other.example".into();
|
||||
assert!(!state.approve(&other_host, 1));
|
||||
assert!(state.approve(&original, 1));
|
||||
assert_eq!(state.exceptions.len(), 1);
|
||||
assert!(!state.approve(&original, 1));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,298 @@
|
||||
use super::tls::TlsFailureReason;
|
||||
|
||||
/// Native UI state for recovering an embedded sign-in session.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub(super) enum RecoveryStatus {
|
||||
#[default]
|
||||
Hidden,
|
||||
Restarting,
|
||||
Loading,
|
||||
Failed,
|
||||
Rejected,
|
||||
Tls {
|
||||
reason: TlsFailureReason,
|
||||
can_continue: bool,
|
||||
},
|
||||
CertificateBypassed,
|
||||
}
|
||||
|
||||
impl RecoveryStatus {
|
||||
pub fn message(self) -> &'static str {
|
||||
match self {
|
||||
Self::Hidden => "",
|
||||
Self::Restarting => "Restarting sign-in…",
|
||||
Self::Loading => "Loading sign-in…",
|
||||
Self::Failed => "Couldn’t restart sign-in.",
|
||||
Self::Rejected => "Sign-in wasn’t completed.",
|
||||
Self::Tls {
|
||||
reason: TlsFailureReason::Handshake,
|
||||
..
|
||||
} => "Secure connection failed.",
|
||||
Self::Tls { .. } => "Cannot verify this server’s identity.",
|
||||
Self::CertificateBypassed => "Certificate verification bypassed in this window.",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn detail(self) -> &'static str {
|
||||
match self {
|
||||
Self::Tls { reason, .. } => reason.message(),
|
||||
_ => "",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn can_continue(self) -> bool {
|
||||
match self {
|
||||
Self::Tls { reason, can_continue } => can_continue && reason.is_certificate_error(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn blocks_page(self) -> bool {
|
||||
!matches!(self, Self::Hidden | Self::CertificateBypassed)
|
||||
}
|
||||
|
||||
pub fn accepts_auth_data(self) -> bool {
|
||||
matches!(self, Self::Hidden | Self::Loading | Self::CertificateBypassed)
|
||||
}
|
||||
|
||||
pub fn is_busy(self) -> bool {
|
||||
matches!(self, Self::Restarting | Self::Loading)
|
||||
}
|
||||
|
||||
pub fn can_retry(self) -> bool {
|
||||
matches!(
|
||||
self,
|
||||
Self::Failed
|
||||
| Self::Rejected
|
||||
| Self::Tls {
|
||||
reason: TlsFailureReason::Handshake,
|
||||
..
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Recovery {
|
||||
status: RecoveryStatus,
|
||||
automatic_retry_used: bool,
|
||||
certificate_bypassed: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum RetrySource {
|
||||
FreshPrelogin,
|
||||
SuppliedRequest,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum RetryTiming {
|
||||
Immediate,
|
||||
AutomaticDelay,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) struct RetryPlan {
|
||||
pub source: RetrySource,
|
||||
pub timing: RetryTiming,
|
||||
}
|
||||
|
||||
impl Recovery {
|
||||
pub fn status(&self) -> RecoveryStatus {
|
||||
self.status
|
||||
}
|
||||
|
||||
pub fn loading(&mut self) {
|
||||
self.status = RecoveryStatus::Loading;
|
||||
}
|
||||
|
||||
pub fn load_failed(&mut self) {
|
||||
self.status = RecoveryStatus::Failed;
|
||||
}
|
||||
|
||||
pub fn tls_failed(&mut self, reason: TlsFailureReason, can_continue: bool) {
|
||||
self.status = RecoveryStatus::Tls { reason, can_continue };
|
||||
}
|
||||
|
||||
pub fn certificate_accepted(&mut self) -> Option<RetryPlan> {
|
||||
if !self.status.can_continue() {
|
||||
return None;
|
||||
}
|
||||
self.certificate_bypassed = true;
|
||||
self.status = RecoveryStatus::Restarting;
|
||||
Some(RetryPlan {
|
||||
source: RetrySource::SuppliedRequest,
|
||||
timing: RetryTiming::Immediate,
|
||||
})
|
||||
}
|
||||
|
||||
/// Temporary service failures get one automatic restart per dialog.
|
||||
/// Duplicate failures while restarting or awaiting user action are ignored.
|
||||
pub fn failure(&mut self, temporary: bool) -> Option<RetryPlan> {
|
||||
if !matches!(
|
||||
self.status,
|
||||
RecoveryStatus::Hidden | RecoveryStatus::Loading | RecoveryStatus::CertificateBypassed
|
||||
) {
|
||||
return None;
|
||||
}
|
||||
if temporary && !self.automatic_retry_used {
|
||||
self.automatic_retry_used = true;
|
||||
self.status = RecoveryStatus::Restarting;
|
||||
return Some(RetryPlan {
|
||||
source: RetrySource::FreshPrelogin,
|
||||
timing: RetryTiming::AutomaticDelay,
|
||||
});
|
||||
}
|
||||
self.status = if temporary {
|
||||
RecoveryStatus::Failed
|
||||
} else {
|
||||
RecoveryStatus::Rejected
|
||||
};
|
||||
None
|
||||
}
|
||||
|
||||
pub fn retry(&mut self) -> Option<RetryPlan> {
|
||||
if !self.status.can_retry() {
|
||||
return None;
|
||||
}
|
||||
let source = if matches!(self.status, RecoveryStatus::Tls { .. }) {
|
||||
RetrySource::SuppliedRequest
|
||||
} else {
|
||||
RetrySource::FreshPrelogin
|
||||
};
|
||||
self.status = RecoveryStatus::Restarting;
|
||||
Some(RetryPlan {
|
||||
source,
|
||||
timing: RetryTiming::Immediate,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn page_loaded(&mut self) {
|
||||
if self.status == RecoveryStatus::Loading {
|
||||
self.status = if self.certificate_bypassed {
|
||||
RecoveryStatus::CertificateBypassed
|
||||
} else {
|
||||
RecoveryStatus::Hidden
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn retry_plans_preserve_request_source_and_timing() {
|
||||
let mut recovery = Recovery::default();
|
||||
assert_eq!(
|
||||
recovery.failure(true),
|
||||
Some(RetryPlan {
|
||||
source: RetrySource::FreshPrelogin,
|
||||
timing: RetryTiming::AutomaticDelay,
|
||||
})
|
||||
);
|
||||
recovery.load_failed();
|
||||
assert_eq!(
|
||||
recovery.retry(),
|
||||
Some(RetryPlan {
|
||||
source: RetrySource::FreshPrelogin,
|
||||
timing: RetryTiming::Immediate,
|
||||
})
|
||||
);
|
||||
recovery.tls_failed(TlsFailureReason::Expired, true);
|
||||
assert_eq!(
|
||||
recovery.certificate_accepted(),
|
||||
Some(RetryPlan {
|
||||
source: RetrySource::SuppliedRequest,
|
||||
timing: RetryTiming::Immediate,
|
||||
})
|
||||
);
|
||||
assert!(recovery.certificate_accepted().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tls_failure_blocks_credentials_and_is_not_cleared_by_page_completion() {
|
||||
let mut recovery = Recovery {
|
||||
status: RecoveryStatus::Tls {
|
||||
reason: TlsFailureReason::Expired,
|
||||
can_continue: true,
|
||||
},
|
||||
..Recovery::default()
|
||||
};
|
||||
assert!(recovery.status.blocks_page());
|
||||
assert!(!recovery.status.accepts_auth_data());
|
||||
assert!(recovery.status.can_continue());
|
||||
recovery.page_loaded();
|
||||
assert!(matches!(recovery.status, RecoveryStatus::Tls { .. }));
|
||||
assert!(recovery.failure(true).is_none());
|
||||
assert!(matches!(recovery.status, RecoveryStatus::Tls { .. }));
|
||||
assert!(recovery.retry().is_none());
|
||||
assert!(recovery.status.can_continue());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handshake_failures_never_offer_a_certificate_exception() {
|
||||
let status = RecoveryStatus::Tls {
|
||||
reason: TlsFailureReason::Handshake,
|
||||
can_continue: true,
|
||||
};
|
||||
assert!(!status.can_continue());
|
||||
assert!(status.can_retry());
|
||||
assert!(status.blocks_page());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn certificate_notice_keeps_successful_page_interactive() {
|
||||
let mut recovery = Recovery {
|
||||
certificate_bypassed: true,
|
||||
status: RecoveryStatus::Loading,
|
||||
..Recovery::default()
|
||||
};
|
||||
recovery.page_loaded();
|
||||
assert_eq!(recovery.status, RecoveryStatus::CertificateBypassed);
|
||||
assert!(!recovery.status.blocks_page());
|
||||
assert!(recovery.status.accepts_auth_data());
|
||||
assert!(recovery.failure(false).is_none());
|
||||
assert_eq!(recovery.status, RecoveryStatus::Rejected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn temporary_failure_retries_once_even_after_manual_restarts() {
|
||||
let mut recovery = Recovery::default();
|
||||
assert!(recovery.failure(true).is_some());
|
||||
assert!(recovery.failure(true).is_none());
|
||||
recovery.status = RecoveryStatus::Loading;
|
||||
recovery.page_loaded();
|
||||
assert!(recovery.failure(true).is_none());
|
||||
assert_eq!(recovery.status, RecoveryStatus::Failed);
|
||||
assert!(recovery.retry().is_some());
|
||||
recovery.status = RecoveryStatus::Loading;
|
||||
assert!(recovery.failure(true).is_none());
|
||||
assert_eq!(recovery.status, RecoveryStatus::Failed);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_auth_requires_user_action_and_deduplicates_errors() {
|
||||
let mut recovery = Recovery::default();
|
||||
assert!(recovery.failure(false).is_none());
|
||||
assert_eq!(recovery.status, RecoveryStatus::Rejected);
|
||||
assert!(recovery.failure(true).is_none());
|
||||
assert!(recovery.retry().is_some());
|
||||
assert!(recovery.retry().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_completion_does_not_clear_errors_or_pending_prelogin() {
|
||||
let mut recovery = Recovery::default();
|
||||
recovery.failure(false);
|
||||
recovery.page_loaded();
|
||||
assert_eq!(recovery.status, RecoveryStatus::Rejected);
|
||||
recovery.retry();
|
||||
recovery.page_loaded();
|
||||
assert_eq!(recovery.status, RecoveryStatus::Restarting);
|
||||
recovery.status = RecoveryStatus::Loading;
|
||||
recovery.page_loaded();
|
||||
assert_eq!(recovery.status, RecoveryStatus::Hidden);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/// A TLS failure that can be presented without exposing request parameters.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum TlsFailureReason {
|
||||
Expired,
|
||||
NotYetValid,
|
||||
Untrusted,
|
||||
HostnameMismatch,
|
||||
InvalidCertificate,
|
||||
Handshake,
|
||||
}
|
||||
|
||||
impl TlsFailureReason {
|
||||
pub fn is_certificate_error(self) -> bool {
|
||||
self != Self::Handshake
|
||||
}
|
||||
|
||||
pub fn message(self) -> &'static str {
|
||||
match self {
|
||||
Self::Expired => "The certificate has expired.",
|
||||
Self::NotYetValid => "The certificate is not valid yet.",
|
||||
Self::Untrusted => "The certificate was issued by an untrusted authority.",
|
||||
Self::HostnameMismatch => "The certificate does not match this server’s hostname.",
|
||||
Self::InvalidCertificate => "The server’s certificate could not be verified.",
|
||||
Self::Handshake => "The server could not establish a compatible TLS connection.",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) struct TlsFailure {
|
||||
pub host: String,
|
||||
pub reason: TlsFailureReason,
|
||||
pub can_continue: bool,
|
||||
}
|
||||
|
||||
impl TlsFailure {
|
||||
pub fn confirmation_title(&self) -> String {
|
||||
format!("Continue to {}?", self.host)
|
||||
}
|
||||
|
||||
pub fn confirmation_message(&self) -> String {
|
||||
format!(
|
||||
"{} Your sign-in information could be intercepted.\n\nThis exception applies only to this host until this sign-in window closes.",
|
||||
self.reason.message()
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,11 @@
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use std::{future::Future, pin::Pin, sync::Arc, time::Duration};
|
||||
|
||||
use anyhow::bail;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use gpapi::utils::window::{WindowTypeHint, set_window_type_hint};
|
||||
use gpapi::{
|
||||
auth::{AuthWindowTheme, AuthenticationCancelled, SamlAuthData},
|
||||
error::ServerTlsError,
|
||||
gp_params::GpParams,
|
||||
os_profile::{WebviewUserAgent, WebviewUserAgentTransform},
|
||||
utils::{redact::redact_uri, window::get_title_bar_height},
|
||||
@@ -12,17 +13,26 @@ use gpapi::{
|
||||
use log::{info, warn};
|
||||
#[cfg(target_os = "macos")]
|
||||
use tauri::Manager;
|
||||
use tauri::{
|
||||
AppHandle, WebviewUrl, WebviewWindow, WindowEvent,
|
||||
webview::{PageLoadEvent, PageLoadPayload},
|
||||
};
|
||||
use tauri::{AppHandle, WebviewUrl, WebviewWindow, WindowEvent};
|
||||
use tokio::{sync::oneshot, time};
|
||||
|
||||
use crate::auth_prelogin;
|
||||
|
||||
use super::address_bar::TOOLBAR_HEIGHT;
|
||||
use super::auth_messenger::{AuthError, AuthEvent, AuthMessenger};
|
||||
use super::recovery::{Recovery, RecoveryStatus, RetryPlan, RetrySource, RetryTiming};
|
||||
|
||||
const RESTART_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
pub trait PlatformWebviewExt {
|
||||
fn install_auth_controls(&self, window: &WebviewWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()>;
|
||||
|
||||
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()>;
|
||||
|
||||
fn stop_loading(&self);
|
||||
|
||||
fn confirm_tls_exception(&self) -> anyhow::Result<()>;
|
||||
|
||||
fn ignore_tls_errors(&self) -> anyhow::Result<()>;
|
||||
|
||||
fn user_agent(&self) -> anyhow::Result<String>;
|
||||
@@ -33,8 +43,6 @@ pub trait PlatformWebviewExt {
|
||||
|
||||
fn load_html(&self, html: &str) -> anyhow::Result<()>;
|
||||
|
||||
fn get_html(&self, callback: Box<dyn Fn(anyhow::Result<String>) + 'static>);
|
||||
|
||||
fn load_auth_request(&self, auth_request: &str) -> anyhow::Result<()> {
|
||||
if auth_request.starts_with("http") {
|
||||
info!("Loading auth request as URL: {}", redact_uri(auth_request));
|
||||
@@ -59,8 +67,6 @@ pub struct WebviewAuthenticator<'a> {
|
||||
clean: bool,
|
||||
window_title: &'a str,
|
||||
window_theme: AuthWindowTheme,
|
||||
|
||||
is_retrying: tokio::sync::RwLock<bool>,
|
||||
}
|
||||
|
||||
fn native_theme(theme: AuthWindowTheme) -> Option<tauri::Theme> {
|
||||
@@ -89,7 +95,6 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
clean: false,
|
||||
window_title: "GlobalProtect Login",
|
||||
window_theme: AuthWindowTheme::System,
|
||||
is_retrying: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -120,39 +125,13 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
|
||||
pub async fn authenticate(&self, app_handle: &AppHandle) -> anyhow::Result<SamlAuthData> {
|
||||
let auth_messenger = Arc::new(AuthMessenger::new());
|
||||
let auth_messenger_clone = Arc::clone(&auth_messenger);
|
||||
|
||||
let on_page_load = move |auth_window: WebviewWindow, event: PageLoadPayload<'_>| {
|
||||
let auth_messenger_clone = Arc::clone(&auth_messenger_clone);
|
||||
let redacted_url = redact_uri(event.url().as_str());
|
||||
|
||||
match event.event() {
|
||||
PageLoadEvent::Started => {
|
||||
info!("Started loading page: {}", redacted_url);
|
||||
auth_messenger_clone.cancel_raise_window();
|
||||
}
|
||||
PageLoadEvent::Finished => {
|
||||
info!("Finished loading page: {}", redacted_url);
|
||||
}
|
||||
}
|
||||
|
||||
// Read auth data from the page no matter whether it's finished loading or not
|
||||
// Because we found that the finished event may not be triggered in some cases (e.g., on macOS)
|
||||
let _ = auth_window.with_webview(move |wv| {
|
||||
wv.get_html(Box::new(move |html| match html {
|
||||
Ok(html) => auth_messenger_clone.read_from_html(&html),
|
||||
Err(err) => warn!("Failed to get html: {}", err),
|
||||
}));
|
||||
});
|
||||
};
|
||||
|
||||
let auth_window_builder = WebviewWindow::builder(app_handle, "auth_window", WebviewUrl::default())
|
||||
.on_page_load(on_page_load)
|
||||
.title(self.window_title)
|
||||
.theme(native_theme(self.window_theme))
|
||||
.devtools(cfg!(any(debug_assertions, feature = "release-devtools")));
|
||||
let auth_window = auth_window_builder
|
||||
.inner_size(900.0, 650.0 + get_title_bar_height())
|
||||
.inner_size(900.0, 650.0 + get_title_bar_height() + TOOLBAR_HEIGHT)
|
||||
.min_inner_size(400.0, 300.0)
|
||||
.focused(true)
|
||||
.visible(false)
|
||||
.center()
|
||||
@@ -161,38 +140,169 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
set_window_type_hint(&auth_window, WindowTypeHint::Dialog)?;
|
||||
|
||||
self
|
||||
.setup_auth_window(&auth_window, Arc::clone(&auth_messenger))
|
||||
.await?;
|
||||
|
||||
if present_after_setup(self.clean) {
|
||||
self.raise_window(&auth_window);
|
||||
let messenger = Arc::clone(&auth_messenger);
|
||||
let raise_task = tokio::spawn(async move {
|
||||
time::sleep(Duration::from_secs(10)).await;
|
||||
messenger.send_auth_event(AuthEvent::RaiseWindow);
|
||||
});
|
||||
let result = async {
|
||||
self
|
||||
.setup_auth_window(&auth_window, Arc::clone(&auth_messenger))
|
||||
.await?;
|
||||
if present_after_setup(self.clean) {
|
||||
self.raise_window(&auth_window);
|
||||
}
|
||||
self.wait_for_auth(&auth_window, Arc::clone(&auth_messenger)).await
|
||||
}
|
||||
.await;
|
||||
|
||||
raise_task.abort();
|
||||
auth_messenger.begin_attempt();
|
||||
auth_messenger.cancel_raise_window();
|
||||
// Preserve the authentication outcome even if native teardown fails.
|
||||
if let Err(error) = auth_window.close() {
|
||||
warn!("Failed to close authentication window: {error}");
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
async fn wait_for_auth(
|
||||
&self,
|
||||
auth_window: &WebviewWindow,
|
||||
auth_messenger: Arc<AuthMessenger>,
|
||||
) -> anyhow::Result<SamlAuthData> {
|
||||
let mut recovery = Recovery::default();
|
||||
let mut restart: Option<Pin<Box<dyn Future<Output = anyhow::Result<String>> + Send + '_>>> = None;
|
||||
let mut loading_deadline = None;
|
||||
|
||||
loop {
|
||||
match auth_messenger.subscribe().await? {
|
||||
AuthEvent::Close => bail!(AuthenticationCancelled),
|
||||
AuthEvent::RaiseWindow => self.raise_window(&auth_window),
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
AuthEvent::Error(AuthError::TlsError) => bail!(gpapi::error::PortalError::TlsError),
|
||||
AuthEvent::Error(AuthError::NotFound(location)) => {
|
||||
let event = tokio::select! {
|
||||
event = auth_messenger.subscribe() => event?,
|
||||
result = async {
|
||||
match restart.as_mut() {
|
||||
Some(restart) => restart.await,
|
||||
None => std::future::pending().await,
|
||||
}
|
||||
} => {
|
||||
restart = None;
|
||||
match result {
|
||||
Ok(auth_request) => {
|
||||
// Fence off reads and cancellation notifications from the old page.
|
||||
auth_messenger.begin_attempt();
|
||||
recovery.loading();
|
||||
loading_deadline = Some(time::Instant::now() + RESTART_TIMEOUT);
|
||||
self.load_restarted_sign_in(auth_window, &auth_messenger, auth_request)?;
|
||||
}
|
||||
Err(err) => {
|
||||
warn!("Failed to restart sign-in: {}", err);
|
||||
if err.downcast_ref::<ServerTlsError>().is_some() {
|
||||
return Err(err);
|
||||
}
|
||||
recovery.load_failed();
|
||||
}
|
||||
}
|
||||
self.update_recovery(auth_window, recovery.status())?;
|
||||
continue;
|
||||
}
|
||||
_ = async {
|
||||
match loading_deadline {
|
||||
Some(deadline) => time::sleep_until(deadline).await,
|
||||
None => std::future::pending().await,
|
||||
}
|
||||
} => {
|
||||
loading_deadline = None;
|
||||
recovery.load_failed();
|
||||
self.update_recovery(auth_window, recovery.status())?;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let mut retry_plan = None;
|
||||
match event {
|
||||
AuthEvent::Close => {
|
||||
bail!(AuthenticationCancelled);
|
||||
}
|
||||
AuthEvent::RaiseWindow => self.raise_window(auth_window),
|
||||
AuthEvent::Data(generation, ..)
|
||||
| AuthEvent::Error(generation, _)
|
||||
| AuthEvent::NoAuthData(generation, _)
|
||||
| AuthEvent::PageLoaded(generation)
|
||||
| AuthEvent::TlsAccepted(generation)
|
||||
if generation != auth_messenger.generation() =>
|
||||
{
|
||||
continue;
|
||||
}
|
||||
AuthEvent::Error(_, AuthError::Tls(failure)) => {
|
||||
warn!("TLS failure for {}: {}", failure.host, failure.reason.message());
|
||||
restart = None;
|
||||
loading_deadline = None;
|
||||
recovery.tls_failed(failure.reason, failure.can_continue);
|
||||
}
|
||||
AuthEvent::RequestTlsException => {
|
||||
if recovery.status().can_continue() {
|
||||
auth_window.with_webview(|wv| {
|
||||
if let Err(err) = wv.confirm_tls_exception() {
|
||||
warn!("Failed to confirm certificate exception: {}", err);
|
||||
}
|
||||
})?;
|
||||
}
|
||||
}
|
||||
AuthEvent::TlsAccepted(_) => {
|
||||
retry_plan = recovery.certificate_accepted();
|
||||
}
|
||||
AuthEvent::NoAuthData(_, location) => {
|
||||
info!(
|
||||
"No auth data found in {:?}, it may not be the /SAML20/SP/ACS endpoint",
|
||||
location
|
||||
);
|
||||
self.handle_not_found(&auth_window, &auth_messenger);
|
||||
self.handle_not_found(auth_window, &auth_messenger);
|
||||
}
|
||||
AuthEvent::Error(AuthError::Invalid(err, location)) => {
|
||||
AuthEvent::Error(_, AuthError::Invalid(err, location)) => {
|
||||
warn!("Got invalid auth data in {:?}: {}", location, err);
|
||||
self.retry_auth(&auth_window).await;
|
||||
recovery.failure(false);
|
||||
}
|
||||
AuthEvent::Data(auth_data, location) => {
|
||||
AuthEvent::Error(_, AuthError::TemporarilyUnavailable) => {
|
||||
retry_plan = recovery.failure(true);
|
||||
}
|
||||
AuthEvent::Error(_, AuthError::LoadFailed(err)) => {
|
||||
if matches!(
|
||||
recovery.status(),
|
||||
RecoveryStatus::Loading | RecoveryStatus::Hidden | RecoveryStatus::CertificateBypassed
|
||||
) {
|
||||
warn!("Failed to load sign-in: {}", err);
|
||||
recovery.load_failed();
|
||||
loading_deadline = None;
|
||||
}
|
||||
}
|
||||
AuthEvent::Retry => {
|
||||
retry_plan = recovery.retry();
|
||||
}
|
||||
AuthEvent::PageLoaded(_) => {
|
||||
recovery.page_loaded();
|
||||
if !recovery.status().blocks_page() {
|
||||
loading_deadline = None;
|
||||
}
|
||||
}
|
||||
AuthEvent::Data(_, auth_data, location) => {
|
||||
if !recovery.status().accepts_auth_data() {
|
||||
continue;
|
||||
}
|
||||
info!("Got auth data from {:?}", location);
|
||||
|
||||
auth_window.close()?;
|
||||
return Ok(auth_data);
|
||||
}
|
||||
}
|
||||
if let Some(plan) = retry_plan {
|
||||
loading_deadline = None;
|
||||
auth_messenger.begin_attempt();
|
||||
auth_window.with_webview(|wv| wv.stop_loading())?;
|
||||
restart = Some(Box::pin(async move {
|
||||
time::timeout(RESTART_TIMEOUT, self.request_sign_in(plan)).await?
|
||||
}));
|
||||
}
|
||||
if recovery.status() != RecoveryStatus::Loading {
|
||||
loading_deadline = None;
|
||||
}
|
||||
self.update_recovery(auth_window, recovery.status())?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -216,13 +326,6 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
}
|
||||
});
|
||||
|
||||
// Show the window after 10 seconds, so that the user can see the window if the auth process is stuck
|
||||
let auth_messenger_clone = Arc::clone(&auth_messenger);
|
||||
tokio::spawn(async move {
|
||||
time::sleep(Duration::from_secs(10)).await;
|
||||
auth_messenger_clone.send_auth_event(AuthEvent::RaiseWindow);
|
||||
});
|
||||
|
||||
let auth_request = match self.auth_request {
|
||||
Some(auth_request) => auth_request.to_string(),
|
||||
None => auth_prelogin(&self.server, &self.gp_params, false, false).await?,
|
||||
@@ -231,19 +334,13 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
let (tx, rx) = oneshot::channel::<anyhow::Result<()>>();
|
||||
let ignore_tls_errors = self.gp_params.ignore_tls_errors();
|
||||
let webview_user_agent = self.webview_user_agent.clone();
|
||||
let window = auth_window.clone();
|
||||
|
||||
// Set up webview
|
||||
auth_window.with_webview(move |wv| {
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
{
|
||||
use super::platform_impl::PlatformWebviewOnResponse;
|
||||
wv.on_response(Box::new(move |response| match response {
|
||||
Ok(response) => auth_messenger.read_from_response(&response),
|
||||
Err(err) => auth_messenger.send_auth_error(err),
|
||||
}));
|
||||
}
|
||||
|
||||
let controls_messenger = Arc::clone(&auth_messenger);
|
||||
let result = || -> anyhow::Result<()> {
|
||||
wv.install_auth_controls(&window, controls_messenger)?;
|
||||
if ignore_tls_errors {
|
||||
wv.ignore_tls_errors()?;
|
||||
}
|
||||
@@ -271,49 +368,48 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
auth_messenger.schedule_raise_window(2);
|
||||
}
|
||||
|
||||
async fn retry_auth(&self, auth_window: &WebviewWindow) {
|
||||
let mut is_retrying = self.is_retrying.write().await;
|
||||
if *is_retrying {
|
||||
info!("Already retrying authentication, skipping...");
|
||||
return;
|
||||
fn update_recovery(&self, auth_window: &WebviewWindow, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
if status != RecoveryStatus::Hidden {
|
||||
self.raise_window(auth_window);
|
||||
}
|
||||
|
||||
*is_retrying = true;
|
||||
drop(is_retrying);
|
||||
|
||||
if let Err(err) = self.retry_auth_impl(auth_window).await {
|
||||
warn!("Failed to retry authentication: {}", err);
|
||||
}
|
||||
|
||||
*self.is_retrying.write().await = false;
|
||||
}
|
||||
|
||||
async fn retry_auth_impl(&self, auth_window: &WebviewWindow) -> anyhow::Result<()> {
|
||||
info!("Retrying authentication...");
|
||||
|
||||
auth_window.eval( r#"
|
||||
var loading = document.createElement("div");
|
||||
loading.innerHTML = '<div style="position: absolute; width: 100%; text-align: center; font-size: 20px; font-weight: bold; top: 50%; left: 50%; transform: translate(-50%, -50%);">Got invalid token, retrying...</div>';
|
||||
loading.style = "position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(255, 255, 255, 0.85); z-index: 99999;";
|
||||
document.body.appendChild(loading);
|
||||
"#)?;
|
||||
|
||||
let auth_request = auth_prelogin(&self.server, &self.gp_params, false, false).await?;
|
||||
|
||||
let (tx, rx) = oneshot::channel::<anyhow::Result<()>>();
|
||||
let webview_user_agent = self.webview_user_agent.clone();
|
||||
auth_window.with_webview(move |wv| {
|
||||
let result = || -> anyhow::Result<()> {
|
||||
load_auth_request_with_user_agent(&wv, webview_user_agent.as_ref(), &auth_request)
|
||||
}();
|
||||
|
||||
if let Err(result) = tx.send(result) {
|
||||
warn!("Failed to send retry auth result: {:?}", result);
|
||||
if let Err(err) = wv.set_recovery_status(status) {
|
||||
warn!("Failed to update sign-in status: {}", err);
|
||||
}
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
rx.await??;
|
||||
async fn request_sign_in(&self, plan: RetryPlan) -> anyhow::Result<String> {
|
||||
info!("Restarting sign-in...");
|
||||
if plan.timing == RetryTiming::AutomaticDelay {
|
||||
time::sleep(Duration::from_secs(1)).await;
|
||||
}
|
||||
if plan.source == RetrySource::SuppliedRequest {
|
||||
if let Some(request) = self.auth_request {
|
||||
return Ok(request.to_owned());
|
||||
}
|
||||
}
|
||||
auth_prelogin(self.server, self.gp_params, false, false).await
|
||||
}
|
||||
|
||||
fn load_restarted_sign_in(
|
||||
&self,
|
||||
auth_window: &WebviewWindow,
|
||||
messenger: &Arc<AuthMessenger>,
|
||||
auth_request: String,
|
||||
) -> anyhow::Result<()> {
|
||||
let webview_user_agent = self.webview_user_agent.clone();
|
||||
let generation = messenger.generation();
|
||||
let messenger = Arc::clone(messenger);
|
||||
auth_window.with_webview(move |wv| {
|
||||
if generation != messenger.generation() {
|
||||
return;
|
||||
}
|
||||
if let Err(err) = load_auth_request_with_user_agent(&wv, webview_user_agent.as_ref(), &auth_request) {
|
||||
messenger.send_auth_event(AuthEvent::Error(generation, AuthError::LoadFailed(err)));
|
||||
}
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -108,17 +108,6 @@ fn sibling_binary_for_executable(executable: &Path, binary_name: &str) -> Option
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
pub fn bundled_vpnc_script() -> Option<PathBuf> {
|
||||
bundled_vpnc_script_for_executable(&env::current_exe().ok()?)
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
fn bundled_vpnc_script_for_executable(executable: &Path) -> Option<PathBuf> {
|
||||
let executable = executable.canonicalize().ok()?;
|
||||
macos::vpnc_script_path(&executable)
|
||||
}
|
||||
|
||||
fn is_file(path: &Path) -> bool {
|
||||
path.is_file()
|
||||
}
|
||||
@@ -174,18 +163,6 @@ mod tests {
|
||||
sibling_binary_for_executable(&bin.join("gpclient"), "gpauth"),
|
||||
Some(helpers.canonicalize().unwrap().join("gpauth"))
|
||||
);
|
||||
#[cfg(target_os = "macos")]
|
||||
assert_eq!(
|
||||
bundled_vpnc_script_for_executable(&bin.join("gpclient")),
|
||||
Some(
|
||||
helpers
|
||||
.canonicalize()
|
||||
.unwrap()
|
||||
.parent()
|
||||
.unwrap()
|
||||
.join("Resources/Scripts/vpnc-script")
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -17,29 +17,3 @@ fn contents_dir(executable: &Path) -> Option<&Path> {
|
||||
pub(super) fn helper_path(executable: &Path, binary_name: &str) -> Option<PathBuf> {
|
||||
Some(contents_dir(executable)?.join("Helpers").join(binary_name))
|
||||
}
|
||||
|
||||
pub(super) fn vpnc_script_path(executable: &Path) -> Option<PathBuf> {
|
||||
Some(contents_dir(executable)?.join("Resources/Scripts/vpnc-script"))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn bundle_entry_points_use_their_own_vpnc_script() {
|
||||
for executable in [
|
||||
"/Applications/GP Connect.app/Contents/Helpers/gpclient",
|
||||
"/Applications/GP Connect.app/Contents/MacOS/gpgui",
|
||||
] {
|
||||
assert_eq!(
|
||||
vpnc_script_path(Path::new(executable)),
|
||||
Some(PathBuf::from(
|
||||
"/Applications/GP Connect.app/Contents/Resources/Scripts/vpnc-script"
|
||||
))
|
||||
);
|
||||
}
|
||||
assert!(vpnc_script_path(Path::new("/opt/homebrew/bin/gpclient")).is_none());
|
||||
assert!(vpnc_script_path(Path::new("/tmp/Contents/Helpers/gpclient")).is_none());
|
||||
}
|
||||
}
|
||||
+10
-5
@@ -13,9 +13,10 @@ base64.workspace = true
|
||||
dns-lookup.workspace = true
|
||||
log.workspace = true
|
||||
reqwest.workspace = true
|
||||
openssl.workspace = true
|
||||
version-compare = "0.2"
|
||||
native-tls = "0.2"
|
||||
pem.workspace = true
|
||||
pkcs8 = { version = "0.11", features = ["pem", "encryption", "sha1-insecure", "3des", "des-insecure"] }
|
||||
x509-cert = { version = "0.3", default-features = false }
|
||||
xmltree.workspace = true
|
||||
serde.workspace = true
|
||||
specta = { workspace = true, features = ["derive", "uuid"] }
|
||||
@@ -27,14 +28,12 @@ whoami.workspace = true
|
||||
tempfile.workspace = true
|
||||
thiserror.workspace = true
|
||||
chacha20poly1305 = { version = "0.11", features = ["zeroize"] }
|
||||
redact-engine.workspace = true
|
||||
url.workspace = true
|
||||
regex.workspace = true
|
||||
uzers.workspace = true
|
||||
serde_urlencoded.workspace = true
|
||||
md5.workspace = true
|
||||
sha256.workspace = true
|
||||
sha2 = { version = "0.11", default-features = false }
|
||||
sha2.workspace = true
|
||||
uuid = { workspace = true, features = ["v4", "v5", "serde"] }
|
||||
chrono.workspace = true
|
||||
humantime.workspace = true
|
||||
@@ -54,13 +53,19 @@ env_logger = { workspace = true, optional = true }
|
||||
log-reload = { version = "0.1", optional = true }
|
||||
|
||||
[target.'cfg(target_os="macos")'.dependencies]
|
||||
security-framework = "3"
|
||||
oslog = { version = "0.2", default-features = false, optional = true }
|
||||
|
||||
# Dependencies for Linux and other OSes only
|
||||
[target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies]
|
||||
gtk = { version = "0.18", optional = true }
|
||||
|
||||
[target.'cfg(not(target_os = "macos"))'.dependencies]
|
||||
openssl.workspace = true
|
||||
version-compare = "0.2"
|
||||
|
||||
[dev-dependencies]
|
||||
openssl.workspace = true
|
||||
proptest.workspace = true
|
||||
tokio = { workspace = true, features = ["test-util"] }
|
||||
|
||||
|
||||
@@ -49,6 +49,7 @@ pub enum SamlAuthResult {
|
||||
Success(SamlAuthData),
|
||||
Cancelled,
|
||||
Failure(String),
|
||||
ServerTlsError(crate::error::ServerTlsError),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -68,6 +69,7 @@ impl SamlAuthResult {
|
||||
SamlAuthResult::Success(_) => true,
|
||||
SamlAuthResult::Cancelled => false,
|
||||
SamlAuthResult::Failure(_) => false,
|
||||
SamlAuthResult::ServerTlsError(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -76,6 +78,7 @@ impl SamlAuthResult {
|
||||
SamlAuthResult::Success(auth_data) => auth_data.host_id(),
|
||||
SamlAuthResult::Cancelled => None,
|
||||
SamlAuthResult::Failure(_) => None,
|
||||
SamlAuthResult::ServerTlsError(_) => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,13 +4,14 @@ use clap_verbosity_flag::{LogLevel, Verbosity, VerbosityFilter};
|
||||
use log::Level;
|
||||
|
||||
use crate::{
|
||||
error::PortalError,
|
||||
error::ServerTlsErrorKind,
|
||||
log_format::{LogFormat, write_json_record},
|
||||
};
|
||||
|
||||
pub mod args;
|
||||
|
||||
pub trait Args {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> bool;
|
||||
fn ignore_tls_errors(&self) -> bool;
|
||||
|
||||
@@ -26,7 +27,7 @@ pub trait Args {
|
||||
/// workaround. Empty when there is nothing useful to say — including when the
|
||||
/// relevant option is already in use.
|
||||
fn retry_hints(err: &anyhow::Error, args: &impl Args) -> Vec<String> {
|
||||
let Some(err) = err.downcast_ref::<PortalError>() else {
|
||||
let Some(kind) = ServerTlsErrorKind::from_error(err) else {
|
||||
return Vec::new();
|
||||
};
|
||||
|
||||
@@ -42,14 +43,15 @@ fn retry_hints(err: &anyhow::Error, args: &impl Args) -> Vec<String> {
|
||||
// users already see; keep it exactly.
|
||||
let mut hints = Vec::new();
|
||||
|
||||
if err.is_legacy_openssl_error() && !args.fix_openssl() {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
if kind == ServerTlsErrorKind::LegacyRenegotiation && !args.fix_openssl() {
|
||||
let (program, rest) = command_line();
|
||||
hints.push(format!(
|
||||
"Re-run it with the `--fix-openssl` option to work around this issue, e.g.:\n\n{program} --fix-openssl {rest}"
|
||||
));
|
||||
}
|
||||
|
||||
if err.is_tls_error() && !args.ignore_tls_errors() {
|
||||
if kind == ServerTlsErrorKind::Certificate && !args.ignore_tls_errors() {
|
||||
let (program, rest) = command_line();
|
||||
hints.push(format!(
|
||||
"Re-run it with the `--ignore-tls-errors` option to ignore the certificate error, e.g.:\n\n{program} --ignore-tls-errors {rest}"
|
||||
@@ -191,15 +193,25 @@ mod tests {
|
||||
use anyhow::anyhow;
|
||||
|
||||
use super::*;
|
||||
use crate::error::ServerTlsError;
|
||||
|
||||
fn certificate_error() -> ServerTlsError {
|
||||
ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: ServerTlsErrorKind::Certificate,
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct TestArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: bool,
|
||||
ignore_tls_errors: bool,
|
||||
log_format: LogFormat,
|
||||
}
|
||||
|
||||
impl Args for TestArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> bool {
|
||||
self.fix_openssl
|
||||
}
|
||||
@@ -224,7 +236,7 @@ mod tests {
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
|
||||
handle_error_to(&mut out, anyhow!(PortalError::TlsError), &args).expect("writing to a Vec cannot fail");
|
||||
handle_error_to(&mut out, anyhow!(certificate_error()), &args).expect("writing to a Vec cannot fail");
|
||||
|
||||
let out = String::from_utf8(out).expect("output should be UTF-8");
|
||||
for line in out.lines() {
|
||||
@@ -235,7 +247,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_tls_failure_suggests_ignoring_tls_errors() {
|
||||
let hints = retry_hints(&anyhow!(PortalError::TlsError), &TestArgs::default());
|
||||
let hints = retry_hints(&anyhow!(certificate_error()), &TestArgs::default());
|
||||
|
||||
assert_eq!(hints.len(), 1, "expected one hint, got {hints:?}");
|
||||
assert!(hints[0].contains("--ignore-tls-errors"), "got {:?}", hints[0]);
|
||||
@@ -247,6 +259,34 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hints_distinguish_legacy_and_unknown_tls_and_respect_both_flags() {
|
||||
let legacy = ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: ServerTlsErrorKind::LegacyRenegotiation,
|
||||
};
|
||||
let hints = retry_hints(&anyhow!(legacy.clone()), &TestArgs::default());
|
||||
if cfg!(target_os = "macos") {
|
||||
assert!(hints.is_empty());
|
||||
} else {
|
||||
assert_eq!(hints.len(), 1);
|
||||
assert!(hints[0].contains("--fix-openssl"));
|
||||
}
|
||||
let args = TestArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: true,
|
||||
ignore_tls_errors: true,
|
||||
..Default::default()
|
||||
};
|
||||
assert!(retry_hints(&anyhow!(legacy), &args).is_empty());
|
||||
assert!(retry_hints(&anyhow!(certificate_error()), &args).is_empty());
|
||||
let other = ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: ServerTlsErrorKind::Other,
|
||||
};
|
||||
assert!(retry_hints(&anyhow!(other), &TestArgs::default()).is_empty());
|
||||
}
|
||||
|
||||
/// Suggesting an option the user already passed is noise, and in JSON mode it
|
||||
/// would be an extra record on every failed run.
|
||||
#[test]
|
||||
@@ -256,7 +296,7 @@ mod tests {
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
assert!(retry_hints(&anyhow!(PortalError::TlsError), &args).is_empty());
|
||||
assert!(retry_hints(&anyhow!(certificate_error()), &args).is_empty());
|
||||
}
|
||||
|
||||
/// Most failures have no known workaround; inventing advice for them would
|
||||
@@ -272,7 +312,7 @@ mod tests {
|
||||
let hints = vec!["Re-run it with the `--ignore-tls-errors` option".to_string()];
|
||||
let mut out = Vec::new();
|
||||
|
||||
write_failure(&mut out, format, &anyhow!(PortalError::TlsError), &hints).expect("writing to a Vec cannot fail");
|
||||
write_failure(&mut out, format, &anyhow!(certificate_error()), &hints).expect("writing to a Vec cannot fail");
|
||||
|
||||
String::from_utf8(out).expect("output should be UTF-8")
|
||||
}
|
||||
|
||||
@@ -252,6 +252,7 @@ impl TryFrom<SamlAuthResult> for Credential {
|
||||
SamlAuthResult::Success(auth_data) => Ok(Self::from(auth_data)),
|
||||
SamlAuthResult::Cancelled => bail!(AuthenticationCancelled),
|
||||
SamlAuthResult::Failure(err) => bail!(err),
|
||||
SamlAuthResult::ServerTlsError(err) => Err(err.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,8 @@
|
||||
use thiserror::Error;
|
||||
|
||||
mod server_tls;
|
||||
pub use server_tls::{ServerTlsError, ServerTlsErrorKind};
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum PortalError {
|
||||
#[error("Prelogin error: {0}")]
|
||||
@@ -10,18 +13,14 @@ pub enum PortalError {
|
||||
|
||||
#[error(transparent)]
|
||||
NetworkError(#[from] reqwest::Error),
|
||||
|
||||
#[error("TLS error")]
|
||||
TlsError,
|
||||
}
|
||||
|
||||
impl PortalError {
|
||||
pub fn is_legacy_openssl_error(&self) -> bool {
|
||||
format!("{:?}", self).contains("unsafe legacy renegotiation")
|
||||
}
|
||||
|
||||
pub fn is_tls_error(&self) -> bool {
|
||||
matches!(self, PortalError::TlsError) || format!("{:?}", self).contains("certificate verify failed")
|
||||
fn tls_error_kind(&self) -> Option<ServerTlsErrorKind> {
|
||||
match self {
|
||||
Self::NetworkError(error) => server_tls::classify(error),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,515 @@
|
||||
use std::{error::Error, fmt};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::PortalError;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "server_tls/macos.rs"]
|
||||
mod backend;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[path = "server_tls/openssl.rs"]
|
||||
mod backend;
|
||||
|
||||
/// A VPN HTTP TLS failure. The server identifies the configured VPN origin,
|
||||
/// not necessarily the peer that failed after an HTTP redirect.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ServerTlsError {
|
||||
pub server: String,
|
||||
pub kind: ServerTlsErrorKind,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum ServerTlsErrorKind {
|
||||
Certificate,
|
||||
ClientCertificateRequired,
|
||||
LegacyRenegotiation,
|
||||
Other,
|
||||
}
|
||||
|
||||
impl ServerTlsError {
|
||||
pub(crate) fn from_request(server: &url::Url, error: &(dyn Error + 'static)) -> Option<Self> {
|
||||
Some(Self {
|
||||
server: server.origin().ascii_serialization(),
|
||||
kind: classify(error)?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for ServerTlsError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let message = match self.kind {
|
||||
ServerTlsErrorKind::Certificate => "The server's certificate could not be verified",
|
||||
ServerTlsErrorKind::ClientCertificateRequired => "The server requires a client certificate",
|
||||
ServerTlsErrorKind::LegacyRenegotiation => "The server requires unsafe legacy TLS renegotiation",
|
||||
ServerTlsErrorKind::Other => "A secure connection to the server could not be established",
|
||||
};
|
||||
write!(f, "{message}: {}", self.server)
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for ServerTlsError {}
|
||||
|
||||
impl ServerTlsErrorKind {
|
||||
/// One classification interface for CLI hints and desktop error mapping.
|
||||
pub fn from_error(error: &anyhow::Error) -> Option<Self> {
|
||||
error.chain().find_map(|source| {
|
||||
source
|
||||
.downcast_ref::<ServerTlsError>()
|
||||
.map(|error| error.kind)
|
||||
.or_else(|| {
|
||||
source
|
||||
.downcast_ref::<PortalError>()
|
||||
.and_then(PortalError::tls_error_kind)
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn classify(error: &(dyn Error + 'static)) -> Option<ServerTlsErrorKind> {
|
||||
let mut source = Some(error);
|
||||
let mut fallback = None;
|
||||
while let Some(error) = source {
|
||||
if let Some(tls) = error.downcast_ref::<ServerTlsError>() {
|
||||
return Some(tls.kind);
|
||||
}
|
||||
if let Some(kind) = backend::classify(error) {
|
||||
return Some(kind);
|
||||
}
|
||||
if let Some(tls) = error.downcast_ref::<native_tls::Error>() {
|
||||
let kind = classify_native(tls);
|
||||
if kind != ServerTlsErrorKind::Other {
|
||||
return Some(kind);
|
||||
}
|
||||
fallback = Some(kind);
|
||||
}
|
||||
source = error
|
||||
.downcast_ref::<std::io::Error>()
|
||||
.and_then(|error| error.get_ref().map(|inner| inner as &(dyn Error + 'static)))
|
||||
.or_else(|| error.source());
|
||||
}
|
||||
fallback
|
||||
}
|
||||
|
||||
fn classify_native(error: &native_tls::Error) -> ServerTlsErrorKind {
|
||||
// native-tls hides some backend reason codes and verification results. Keep
|
||||
// backend text matching here, scoped to a confirmed native TLS error.
|
||||
let detail = format!("{error:?}").to_ascii_lowercase();
|
||||
classify_native_detail(&detail)
|
||||
}
|
||||
|
||||
fn classify_native_detail(detail: &str) -> ServerTlsErrorKind {
|
||||
// native-tls forwards Security.framework's Debug representation, but hides
|
||||
// its OSStatus from the public error chain. Prefer that status to localized
|
||||
// text, including for peer alerts that can mention a rejected client cert.
|
||||
if let Some(code) = detail
|
||||
.strip_prefix("error { code: ")
|
||||
.and_then(|detail| detail.split_once(','))
|
||||
.and_then(|(code, _)| code.parse::<i32>().ok())
|
||||
{
|
||||
return classify_macos_status(code);
|
||||
}
|
||||
if detail.contains("unsafe legacy renegotiation") {
|
||||
return ServerTlsErrorKind::LegacyRenegotiation;
|
||||
}
|
||||
if detail.contains("alert certificate required") {
|
||||
return ServerTlsErrorKind::ClientCertificateRequired;
|
||||
}
|
||||
let certificate = [
|
||||
"certificate verify failed",
|
||||
"certificate verification failed",
|
||||
"certificate was not trusted",
|
||||
"certificate is not trusted",
|
||||
"self signed certificate",
|
||||
"hostname mismatch",
|
||||
"certificate has expired",
|
||||
"certificate is not yet valid",
|
||||
"certificate has been revoked",
|
||||
]
|
||||
.iter()
|
||||
.any(|reason| detail.contains(reason));
|
||||
if certificate {
|
||||
ServerTlsErrorKind::Certificate
|
||||
} else {
|
||||
ServerTlsErrorKind::Other
|
||||
}
|
||||
}
|
||||
|
||||
fn classify_macos_status(code: i32) -> ServerTlsErrorKind {
|
||||
if code == -9863 {
|
||||
return ServerTlsErrorKind::ClientCertificateRequired;
|
||||
}
|
||||
// Local server-certificate validation failures from Security/SecBase.h.
|
||||
// Peer alerts (errSSLPeer*) reject our client certificate; protocol/cipher,
|
||||
// keychain, and internal errors also cannot be fixed by skipping server trust.
|
||||
let certificate = matches!(
|
||||
code,
|
||||
-9807 // errSSLXCertChainInvalid
|
||||
| -9812 // errSSLUnknownRootCert
|
||||
| -9813 // errSSLNoRootCert
|
||||
| -9814 // errSSLCertExpired
|
||||
| -9815 // errSSLCertNotYetValid
|
||||
| -9843 // errSSLHostNameMismatch
|
||||
| -9884 // errSSLATSLeafCertificateHashAlgorithmViolation
|
||||
| -9885 // errSSLATSCertificateHashAlgorithmViolation
|
||||
| -9886 // errSSLATSCertificateTrustViolation
|
||||
| -67602 // errSecHostNameMismatch
|
||||
| -67603 // errSecUnknownCriticalExtensionFlag
|
||||
| -67604 // errSecNoBasicConstraints
|
||||
| -67605 // errSecNoBasicConstraintsCA
|
||||
| -67606 // errSecInvalidAuthorityKeyID
|
||||
| -67607 // errSecInvalidSubjectKeyID
|
||||
| -67608 // errSecInvalidKeyUsageForPolicy
|
||||
| -67609 // errSecInvalidExtendedKeyUsage
|
||||
| -67610 // errSecInvalidIDLinkage
|
||||
| -67611 // errSecPathLengthConstraintExceeded
|
||||
| -67612 // errSecInvalidRoot
|
||||
| -67629 // errSecSSLBadExtendedKeyUsage
|
||||
| -67654 // errSecTrustSettingDeny
|
||||
| -67818 // errSecCertificateExpired
|
||||
| -67819 // errSecCertificateNotValidYet
|
||||
| -67820 // errSecCertificateRevoked
|
||||
| -67821 // errSecCertificateSuspended
|
||||
| -67826 // errSecInvalidCertAuthority
|
||||
| -67843 // errSecNotTrusted
|
||||
| -67899 // errSecCertificatePolicyNotAllowed
|
||||
| -67900 // errSecCertificateNameNotAllowed
|
||||
| -67901 // errSecCertificateValidityPeriodTooLong
|
||||
| -67902 // errSecCertificateIsCA
|
||||
| -67903 // errSecCertificateDuplicateExtension
|
||||
| -67904 // errSecMissingQualifiedCertStatement
|
||||
);
|
||||
if certificate {
|
||||
ServerTlsErrorKind::Certificate
|
||||
} else {
|
||||
ServerTlsErrorKind::Other
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use openssl::{
|
||||
asn1::Asn1Time,
|
||||
hash::MessageDigest,
|
||||
pkey::PKey,
|
||||
rsa::Rsa,
|
||||
ssl::{SslAcceptor, SslMethod, SslVerifyMode},
|
||||
x509::{X509, X509NameBuilder},
|
||||
};
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
net::TcpListener,
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn explicit_client_certificate_requirement_has_a_distinct_kind() {
|
||||
let kind = classify_native_detail("error { code: -9863, message: \"localized message\" }");
|
||||
assert_eq!(serde_json::to_value(kind).unwrap(), "clientCertificateRequired");
|
||||
assert_eq!(
|
||||
classify_native_detail("error { code: -9842, message: \"client cert requested\" }"),
|
||||
ServerTlsErrorKind::Other
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn macos_certificate_statuses_do_not_depend_on_the_error_message() {
|
||||
for code in [-67818, -67819, -67820, -67843, -67602, -67629, -67899, -67901] {
|
||||
let detail = format!("error {{ code: {code}, message: \"localized message\" }}");
|
||||
assert_eq!(
|
||||
classify_native_detail(&detail),
|
||||
ServerTlsErrorKind::Certificate,
|
||||
"{code}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn macos_peer_alerts_and_handshake_errors_are_not_certificate_validation_failures() {
|
||||
for (code, message) in [
|
||||
(-9800, "SSL protocol error"),
|
||||
(-9801, "Cipher Suite negotiation failure"),
|
||||
(-9828, "peer certificate has expired"),
|
||||
(-9831, "unknown certificate authority"),
|
||||
(-9850, "weak ephemeral DH key"),
|
||||
] {
|
||||
let detail = format!("error {{ code: {code}, message: \"{message}\" }}").to_ascii_lowercase();
|
||||
assert_eq!(classify_native_detail(&detail), ServerTlsErrorKind::Other, "{code}");
|
||||
}
|
||||
}
|
||||
|
||||
fn server(tls: bool) -> (String, thread::JoinHandle<()>) {
|
||||
server_with_client_auth(tls, SslVerifyMode::NONE)
|
||||
}
|
||||
|
||||
fn server_with_client_auth(tls: bool, verify: SslVerifyMode) -> (String, thread::JoinHandle<()>) {
|
||||
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
|
||||
let mut name = X509NameBuilder::new().unwrap();
|
||||
name.append_entry_by_text("CN", "localhost").unwrap();
|
||||
let name = name.build();
|
||||
let mut cert = X509::builder().unwrap();
|
||||
cert.set_version(2).unwrap();
|
||||
cert.set_subject_name(&name).unwrap();
|
||||
cert.set_issuer_name(&name).unwrap();
|
||||
cert.set_pubkey(&key).unwrap();
|
||||
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
|
||||
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
|
||||
cert.sign(&key, MessageDigest::sha256()).unwrap();
|
||||
let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
|
||||
acceptor.set_private_key(&key).unwrap();
|
||||
acceptor.set_certificate(&cert.build()).unwrap();
|
||||
acceptor.set_verify(verify);
|
||||
acceptor
|
||||
.set_ca_file(concat!(
|
||||
env!("CARGO_MANIFEST_DIR"),
|
||||
"/tests/files/client-identity/root.pem"
|
||||
))
|
||||
.unwrap();
|
||||
let acceptor = acceptor.build();
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = format!("https://{}", listener.local_addr().unwrap());
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
||||
stream.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
||||
let body = "<prelogin-response><status>Success</status><saml-auth-method>REDIRECT</saml-auth-method><saml-request>aHR0cHM6Ly9pZHAuZXhhbXBsZS5jb20v</saml-request></prelogin-response>";
|
||||
let response = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
body.len()
|
||||
);
|
||||
let mut request = [0; 8192];
|
||||
if tls {
|
||||
if let Ok(mut stream) = acceptor.accept(stream) {
|
||||
let _ = stream.read(&mut request);
|
||||
let _ = stream.write_all(response.as_bytes());
|
||||
}
|
||||
} else {
|
||||
let _ = stream.read(&mut request);
|
||||
let _ = stream.write_all(response.as_bytes());
|
||||
}
|
||||
});
|
||||
(address, worker)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn prelogin_returns_typed_certificate_failure_with_only_the_server_origin() {
|
||||
use crate::{
|
||||
gp_params::GpParams,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
portal::{PreloginOptions, prelogin},
|
||||
};
|
||||
let (address, worker) = server(true);
|
||||
let profile = OsProfile::builder(ClientOs::Linux).build();
|
||||
let params = GpParams::builder(profile).build();
|
||||
let error = prelogin(&address, ¶ms, PreloginOptions::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
worker.join().unwrap();
|
||||
let tls = error
|
||||
.downcast_ref::<ServerTlsError>()
|
||||
.unwrap_or_else(|| panic!("unclassified: {error:?}"));
|
||||
assert_eq!(tls.kind, ServerTlsErrorKind::Certificate);
|
||||
assert_eq!(tls.server, address);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn certificate_bypass_allows_prelogin() {
|
||||
use crate::{
|
||||
gp_params::GpParams,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
portal::{PreloginOptions, prelogin},
|
||||
};
|
||||
let (address, worker) = server(true);
|
||||
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build())
|
||||
.ignore_tls_errors(true)
|
||||
.build();
|
||||
let result = prelogin(&address, ¶ms, PreloginOptions::default()).await;
|
||||
worker.join().unwrap();
|
||||
assert!(matches!(result.unwrap(), crate::portal::Prelogin::Saml(_)));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incompatible_tls_is_not_a_certificate_error_even_with_bypass() {
|
||||
let (address, worker) = server(false);
|
||||
let error = reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.danger_accept_invalid_certs(true)
|
||||
.build()
|
||||
.unwrap()
|
||||
.get(&address)
|
||||
.send()
|
||||
.await
|
||||
.unwrap_err();
|
||||
worker.join().unwrap();
|
||||
let tls = ServerTlsError::from_request(&url::Url::parse(&address).unwrap(), &error).unwrap();
|
||||
assert_eq!(tls.kind, ServerTlsErrorKind::Other);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connection_refused_is_not_tls() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = format!("https://{}", listener.local_addr().unwrap());
|
||||
drop(listener);
|
||||
let error = reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.build()
|
||||
.unwrap()
|
||||
.get(address)
|
||||
.send()
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(classify(&error), None);
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
#[test]
|
||||
fn wrapped_macos_io_status_retains_the_client_certificate_requirement() {
|
||||
let error = std::io::Error::other(std::io::Error::other(security_framework::base::Error::from(-9863)));
|
||||
let server = url::Url::parse("https://vpn.example.com/login?token=secret").unwrap();
|
||||
let tls = ServerTlsError::from_request(&server, &error).unwrap();
|
||||
assert_eq!(tls.kind, ServerTlsErrorKind::ClientCertificateRequired);
|
||||
assert_eq!(tls.server, "https://vpn.example.com");
|
||||
assert_eq!(classify(&std::io::Error::other("alert certificate required")), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rendering_recovery_retains_client_certificate_requirement() {
|
||||
use crate::process::rendering_recovery::{RecoveryState, RenderingCrash};
|
||||
use std::os::unix::process::ExitStatusExt;
|
||||
let mut recovery = RecoveryState::default();
|
||||
assert!(
|
||||
recovery.recover(
|
||||
&RenderingCrash {
|
||||
status: std::process::ExitStatus::from_raw(71 << 8)
|
||||
}
|
||||
.into()
|
||||
)
|
||||
);
|
||||
let error = recovery.terminal(
|
||||
ServerTlsError {
|
||||
server: "https://vpn.example.com".into(),
|
||||
kind: ServerTlsErrorKind::ClientCertificateRequired,
|
||||
}
|
||||
.into(),
|
||||
);
|
||||
assert_eq!(
|
||||
ServerTlsErrorKind::from_error(&error),
|
||||
Some(ServerTlsErrorKind::ClientCertificateRequired)
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn required_client_certificate_is_not_bypassed_by_ignoring_server_trust() {
|
||||
use crate::{
|
||||
gp_params::GpParams,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
portal::{PreloginOptions, prelogin},
|
||||
};
|
||||
let params = GpParams::builder(OsProfile::builder(ClientOs::Linux).build())
|
||||
.ignore_tls_errors(true)
|
||||
.build();
|
||||
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
|
||||
let cancellation = tokio_util::sync::CancellationToken::new();
|
||||
for operation in ["prelogin", "config", "gateway"] {
|
||||
let (address, worker) = server_with_client_auth(true, SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
|
||||
let error = match operation {
|
||||
"prelogin" => prelogin(&address, ¶ms, PreloginOptions::default())
|
||||
.await
|
||||
.err()
|
||||
.unwrap(),
|
||||
"config" => crate::portal::retrieve_config(&address, &credential, ¶ms, &cancellation)
|
||||
.await
|
||||
.err()
|
||||
.unwrap(),
|
||||
_ => crate::gateway::GatewayLoginClient::new(&address, params.clone())
|
||||
.unwrap()
|
||||
.login(&credential, None, &cancellation)
|
||||
.await
|
||||
.err()
|
||||
.unwrap(),
|
||||
};
|
||||
worker.join().unwrap();
|
||||
let kind =
|
||||
ServerTlsErrorKind::from_error(&error).unwrap_or_else(|| panic!("{operation}: unclassified: {error:?}"));
|
||||
// Secure Transport's TLS 1.2 handshake can return only a generic peer alert.
|
||||
if cfg!(target_os = "macos") {
|
||||
assert!(matches!(
|
||||
kind,
|
||||
ServerTlsErrorKind::ClientCertificateRequired | ServerTlsErrorKind::Other
|
||||
));
|
||||
} else {
|
||||
assert_eq!(
|
||||
kind,
|
||||
ServerTlsErrorKind::ClientCertificateRequired,
|
||||
"{operation}: {error:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn prelogin_accepts_a_valid_identity_and_an_optional_certificate_request() {
|
||||
use crate::{
|
||||
gp_params::GpParams,
|
||||
os_profile::{ClientOs, OsProfile},
|
||||
portal::{PreloginOptions, prelogin},
|
||||
};
|
||||
for required in [false, true] {
|
||||
let verify = if required {
|
||||
SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
|
||||
} else {
|
||||
SslVerifyMode::PEER
|
||||
};
|
||||
let (address, worker) = server_with_client_auth(true, verify);
|
||||
let mut builder = GpParams::builder(OsProfile::builder(ClientOs::Linux).build());
|
||||
builder.ignore_tls_errors(true);
|
||||
if required {
|
||||
builder
|
||||
.certificate(Some(
|
||||
concat!(env!("CARGO_MANIFEST_DIR"), "/tests/files/client-identity/rsa-cert.pem").to_owned(),
|
||||
))
|
||||
.sslkey(Some(
|
||||
concat!(env!("CARGO_MANIFEST_DIR"), "/tests/files/client-identity/rsa-pkcs8.pem").to_owned(),
|
||||
));
|
||||
}
|
||||
let result = prelogin(&address, &builder.build(), PreloginOptions::default()).await;
|
||||
worker.join().unwrap();
|
||||
assert!(matches!(result.unwrap(), crate::portal::Prelogin::Saml(_)));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn failed_response_reads_preserve_the_transport_cause() {
|
||||
for status in [200, 403] {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = format!("http://{}", listener.local_addr().unwrap());
|
||||
let worker = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
||||
let mut request = [0; 8192];
|
||||
stream.read(&mut request).unwrap();
|
||||
write!(
|
||||
stream,
|
||||
"HTTP/1.1 {status} Test\r\nContent-Length: 100\r\nConnection: close\r\n\r\ntruncated"
|
||||
)
|
||||
.unwrap();
|
||||
});
|
||||
let response = reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.build()
|
||||
.unwrap()
|
||||
.get(address)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let error = crate::utils::parse_gp_response(response).await.unwrap_err();
|
||||
assert_eq!(error.status.as_u16(), status);
|
||||
assert!(error.source().unwrap().is::<reqwest::Error>());
|
||||
worker.join().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
use std::error::Error;
|
||||
|
||||
use super::{ServerTlsErrorKind, classify_macos_status};
|
||||
|
||||
pub(super) fn classify(error: &(dyn Error + 'static)) -> Option<ServerTlsErrorKind> {
|
||||
error
|
||||
.downcast_ref::<security_framework::base::Error>()
|
||||
.map(|error| classify_macos_status(error.code()))
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
use std::error::Error;
|
||||
|
||||
use super::ServerTlsErrorKind;
|
||||
|
||||
pub(super) fn classify(error: &(dyn Error + 'static)) -> Option<ServerTlsErrorKind> {
|
||||
let stack = error.downcast_ref::<openssl::error::ErrorStack>().or_else(|| {
|
||||
error
|
||||
.downcast_ref::<openssl::ssl::Error>()
|
||||
.and_then(openssl::ssl::Error::ssl_error)
|
||||
})?;
|
||||
// ERR_LIB_SSL and SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED from sslerr.h.
|
||||
stack
|
||||
.errors()
|
||||
.iter()
|
||||
.any(|error| error.library_code() == 20 && error.reason_code() == 1116)
|
||||
.then_some(ServerTlsErrorKind::ClientCertificateRequired)
|
||||
}
|
||||
@@ -254,12 +254,18 @@ async fn receive_gateway_login(
|
||||
.await
|
||||
.map_err(|e| {
|
||||
warn!("Network error: {:?}", e);
|
||||
anyhow::anyhow!(PortalError::NetworkError(e))
|
||||
match crate::error::ServerTlsError::from_request(origin, &e) {
|
||||
Some(tls) => anyhow::anyhow!(tls),
|
||||
None => anyhow::anyhow!(PortalError::NetworkError(e)),
|
||||
}
|
||||
})?;
|
||||
|
||||
let endpoint = res.remote_addr();
|
||||
let url = res.url().clone();
|
||||
let res = parse_gp_response(res).await.map_err(|err| {
|
||||
if let Some(tls) = crate::error::ServerTlsError::from_request(origin, &err) {
|
||||
return anyhow::anyhow!(tls);
|
||||
}
|
||||
warn!("Gateway login response failed: {}", err.reason);
|
||||
anyhow::anyhow!("Gateway login error: {}", err.reason)
|
||||
})?;
|
||||
|
||||
@@ -10,7 +10,7 @@ use xmltree::Element;
|
||||
|
||||
use crate::{
|
||||
credential::{AuthCookieCredential, Credential},
|
||||
error::PortalError,
|
||||
error::{PortalError, ServerTlsError},
|
||||
gateway::{Gateway, parse_gateways},
|
||||
gp_params::GpParams,
|
||||
params,
|
||||
@@ -149,6 +149,7 @@ pub async fn retrieve_config(
|
||||
cancellation: &CancellationToken,
|
||||
) -> anyhow::Result<PortalConfig> {
|
||||
let portal = normalize_server(portal)?;
|
||||
let server_url = url::Url::parse(&portal)?;
|
||||
let server = remove_url_scheme(&portal);
|
||||
|
||||
let url = format!("{}/global-protect/getconfig.esp", portal);
|
||||
@@ -170,10 +171,16 @@ pub async fn retrieve_config(
|
||||
result = async {
|
||||
let res = client.post(&url).form(&request_params.body).send().await.map_err(|e| {
|
||||
warn!("Network error: {:?}", e);
|
||||
anyhow::anyhow!(PortalError::NetworkError(e))
|
||||
match ServerTlsError::from_request(&server_url, &e) {
|
||||
Some(tls) => anyhow::anyhow!(tls),
|
||||
None => anyhow::anyhow!(PortalError::NetworkError(e)),
|
||||
}
|
||||
})?;
|
||||
|
||||
parse_gp_response(res).await.or_else(|err| {
|
||||
if let Some(tls) = ServerTlsError::from_request(&server_url, &err) {
|
||||
return Err(anyhow::anyhow!(tls));
|
||||
}
|
||||
if err.status == StatusCode::NOT_FOUND {
|
||||
bail!(PortalError::ConfigError("Config endpoint not found".to_string()));
|
||||
}
|
||||
@@ -227,16 +234,23 @@ async fn retrieve_csc_config(
|
||||
let swg_nonce = csc::swg_nonce();
|
||||
let params = csc::csc_params(&csc_req, username, gp_params, &swg_nonce);
|
||||
let url = format!("{}/global-protect/getconfig_csc.esp", portal);
|
||||
let server_url = url::Url::parse(portal)?;
|
||||
|
||||
info!("Portal CSC config request summary: {}", csc_req.summary());
|
||||
info!("Portal CSC config request params: {}", redact_params(¶ms));
|
||||
|
||||
let res = client.post(&url).form(¶ms).send().await.map_err(|e| {
|
||||
warn!("Network error: {:?}", e);
|
||||
anyhow::anyhow!(PortalError::NetworkError(e))
|
||||
match ServerTlsError::from_request(&server_url, &e) {
|
||||
Some(tls) => anyhow::anyhow!(tls),
|
||||
None => anyhow::anyhow!(PortalError::NetworkError(e)),
|
||||
}
|
||||
})?;
|
||||
|
||||
parse_gp_response(res).await.or_else(|err| {
|
||||
if let Some(tls) = ServerTlsError::from_request(&server_url, &err) {
|
||||
return Err(anyhow::anyhow!(tls));
|
||||
}
|
||||
if err.status == StatusCode::NOT_FOUND {
|
||||
bail!(PortalError::ConfigError("CSC config endpoint not found".to_string()));
|
||||
}
|
||||
|
||||
@@ -135,6 +135,7 @@ pub async fn prelogin(portal: &str, gp_params: &GpParams, options: PreloginOptio
|
||||
);
|
||||
|
||||
let client = Client::try_from(gp_params)?;
|
||||
let server_url = url::Url::parse(&portal)?;
|
||||
|
||||
let mut request = client.post(&prelogin_url);
|
||||
if !request_params.query.is_empty() {
|
||||
@@ -146,10 +147,16 @@ pub async fn prelogin(portal: &str, gp_params: &GpParams, options: PreloginOptio
|
||||
|
||||
let res = request.send().await.map_err(|e| {
|
||||
warn!("Network error: {:?}", e);
|
||||
anyhow::anyhow!(PortalError::NetworkError(e))
|
||||
match crate::error::ServerTlsError::from_request(&server_url, &e) {
|
||||
Some(error) => anyhow!(error),
|
||||
None => anyhow!(PortalError::NetworkError(e)),
|
||||
}
|
||||
})?;
|
||||
|
||||
let res_xml = parse_gp_response(res).await.or_else(|err| {
|
||||
if let Some(tls) = crate::error::ServerTlsError::from_request(&server_url, &err) {
|
||||
return Err(anyhow!(tls));
|
||||
}
|
||||
if err.status == StatusCode::NOT_FOUND {
|
||||
bail!(PortalError::PreloginError("Prelogin endpoint not found".to_string()))
|
||||
}
|
||||
|
||||
@@ -33,6 +33,7 @@ pub struct SamlAuthLauncher<'a> {
|
||||
certificate: Option<&'a str>,
|
||||
sslkey: Option<&'a str>,
|
||||
key_password: Option<&'a str>,
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: bool,
|
||||
ignore_tls_errors: bool,
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -66,6 +67,7 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
certificate: None,
|
||||
sslkey: None,
|
||||
key_password: None,
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: false,
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -113,6 +115,7 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
self
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
pub fn fix_openssl(mut self, fix_openssl: bool) -> Self {
|
||||
self.fix_openssl = fix_openssl;
|
||||
self
|
||||
@@ -226,6 +229,7 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
auth_cmd.arg("--client-version").arg(client_version);
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
if self.fix_openssl {
|
||||
auth_cmd.arg("--fix-openssl");
|
||||
}
|
||||
@@ -343,10 +347,12 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `gpauth --browser remote` reads the pasted `globalprotectcallback:` data from the user's terminal.
|
||||
/// `gpauth --browser manual` reads the pasted `globalprotectcallback:` data from the user's terminal.
|
||||
fn auth_stdin(browser: Option<&str>) -> ChildInput<'static> {
|
||||
match browser {
|
||||
Some(browser) if browser.eq_ignore_ascii_case("remote") => ChildInput::Terminal,
|
||||
Some(browser) if browser.eq_ignore_ascii_case("manual") || browser.eq_ignore_ascii_case("remote") => {
|
||||
ChildInput::Terminal
|
||||
}
|
||||
_ => ChildInput::Null,
|
||||
}
|
||||
}
|
||||
@@ -376,6 +382,53 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::os_profile::{ClientOs, OsProfileBuilder};
|
||||
|
||||
#[test]
|
||||
fn server_tls_result_survives_process_decoding_as_a_typed_error() {
|
||||
use crate::error::{ServerTlsError, ServerTlsErrorKind};
|
||||
use std::os::unix::process::ExitStatusExt;
|
||||
let output = std::process::Output {
|
||||
status: std::process::ExitStatus::from_raw(0),
|
||||
stdout: br#"{"serverTlsError":{"server":"https://vpn.example.com:8443","kind":"certificate"}}"#.to_vec(),
|
||||
stderr: Vec::new(),
|
||||
};
|
||||
let error = decode_auth_output(output, false).unwrap_err();
|
||||
assert_eq!(
|
||||
error.downcast_ref::<ServerTlsError>(),
|
||||
Some(&ServerTlsError {
|
||||
server: "https://vpn.example.com:8443".into(),
|
||||
kind: ServerTlsErrorKind::Certificate,
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_certificate_required_result_survives_process_decoding() {
|
||||
use crate::error::{ServerTlsError, ServerTlsErrorKind};
|
||||
use std::os::unix::process::ExitStatusExt;
|
||||
let output = std::process::Output {
|
||||
status: std::process::ExitStatus::from_raw(0),
|
||||
stdout: br#"{"serverTlsError":{"server":"https://vpn.example.com","kind":"clientCertificateRequired"}}"#.to_vec(),
|
||||
stderr: Vec::new(),
|
||||
};
|
||||
let error = decode_auth_output(output, false).unwrap_err();
|
||||
let tls = error.downcast_ref::<ServerTlsError>().unwrap();
|
||||
assert_eq!(tls.kind, ServerTlsErrorKind::ClientCertificateRequired);
|
||||
assert_eq!(tls.server, "https://vpn.example.com");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launches_with_platform_tls_options() {
|
||||
let launcher = SamlAuthLauncher::new("vpn.example.com").ignore_tls_errors(true);
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let launcher = launcher.fix_openssl(true);
|
||||
let args = child_args(launcher);
|
||||
assert_eq!(
|
||||
args.iter().any(|arg| arg == "--fix-openssl"),
|
||||
!cfg!(target_os = "macos")
|
||||
);
|
||||
assert!(args.iter().any(|arg| arg == "--ignore-tls-errors"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn os_profile_sets_os_from_profile() {
|
||||
let profile = OsProfileBuilder::new(ClientOs::Linux).client_version("6.0.0").build();
|
||||
@@ -463,7 +516,9 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_a_remote_browser_reads_the_terminal() {
|
||||
fn only_a_manual_browser_reads_the_terminal() {
|
||||
assert!(matches!(auth_stdin(Some("manual")), ChildInput::Terminal));
|
||||
assert!(matches!(auth_stdin(Some("MANUAL")), ChildInput::Terminal));
|
||||
assert!(matches!(auth_stdin(Some("remote")), ChildInput::Terminal));
|
||||
assert!(matches!(auth_stdin(Some("REMOTE")), ChildInput::Terminal));
|
||||
assert!(matches!(auth_stdin(Some("firefox")), ChildInput::Null));
|
||||
|
||||
@@ -5,6 +5,7 @@ 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 {
|
||||
TunnelState(Option<crate::session::tunnel::TunnelState>),
|
||||
VpnEnv(VpnEnv),
|
||||
VpnState(VpnState),
|
||||
ActiveGui,
|
||||
|
||||
@@ -380,6 +380,7 @@ pub struct UpdateLogLevelRequest(pub String);
|
||||
/// Requests that can be sent to the service
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub enum WsRequest {
|
||||
SetTunnelStatisticsEnabled { enabled: bool },
|
||||
Connect(Box<ConnectRequest>),
|
||||
Disconnect(DisconnectRequest),
|
||||
StopNonTunnelAttachment { connection_id: uuid::Uuid },
|
||||
|
||||
@@ -17,6 +17,9 @@ pub enum ClientMessage {
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub enum ServerMessage {
|
||||
TunnelStatistics {
|
||||
snapshot: crate::session::tunnel::TunnelStatisticsSnapshot,
|
||||
},
|
||||
Attached {
|
||||
connection_id: Uuid,
|
||||
current_revision: u64,
|
||||
@@ -39,6 +42,7 @@ pub enum ServerMessage {
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub enum ServiceResult {
|
||||
TunnelStatisticsSnapshot(crate::session::tunnel::TunnelStatisticsSnapshot),
|
||||
Accepted,
|
||||
StoredHipReport {
|
||||
report_id: String,
|
||||
@@ -192,4 +196,73 @@ mod tests {
|
||||
let encoded = encode(&message).unwrap();
|
||||
assert!(encoded.len() <= MAX_PLAINTEXT);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_configuration_and_large_metadata_fit_complete_snapshot_envelopes_at_the_budget() {
|
||||
use crate::{
|
||||
os_profile::HostIdentity,
|
||||
service::{
|
||||
vpn_env::HostInfo,
|
||||
vpn_state::{ConnectedInfo, VpnState},
|
||||
},
|
||||
session::tunnel::{MAX_CONFIGURATION_BYTES, TunnelConfiguration, TunnelPhase, TunnelState, TunnelTransport},
|
||||
};
|
||||
let mut configuration = TunnelConfiguration::default();
|
||||
configuration.included_routes.items = vec!["r".repeat(1024); 15];
|
||||
configuration.included_routes.items.push(String::new());
|
||||
configuration.included_routes.total_count = 16;
|
||||
let padding = MAX_CONFIGURATION_BYTES - serde_json::to_vec(&configuration).unwrap().len();
|
||||
assert!(padding <= 1024);
|
||||
*configuration.included_routes.items.last_mut().unwrap() = "r".repeat(padding);
|
||||
assert_eq!(
|
||||
serde_json::to_vec(&configuration).unwrap().len(),
|
||||
MAX_CONFIGURATION_BYTES
|
||||
);
|
||||
let gateway = Gateway::new("Gateway".repeat(20), "vpn.example.com".into());
|
||||
let info = ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway; 32]);
|
||||
let snapshot = VpnEnv {
|
||||
tunnel_state: Some(TunnelState {
|
||||
tunnel_id: Uuid::new_v4(),
|
||||
sequence: u64::MAX,
|
||||
phase: TunnelPhase::Connected,
|
||||
configuration_revision: u64::MAX,
|
||||
configuration: Some(configuration),
|
||||
transport: TunnelTransport::IpsecEsp,
|
||||
elapsed_ms: u64::MAX,
|
||||
}),
|
||||
vpn_state: VpnState::Connected(Box::new(ConnectedInfo::new(info, None))),
|
||||
vpnc_script: Some("s".repeat(1024)),
|
||||
auth_executable: "a".repeat(1024),
|
||||
host_info: HostInfo {
|
||||
host_identity: HostIdentity::collect(),
|
||||
},
|
||||
};
|
||||
for mut message in [
|
||||
ServerMessage::Attached {
|
||||
connection_id: Uuid::new_v4(),
|
||||
current_revision: u64::MAX,
|
||||
snapshot: snapshot.clone(),
|
||||
},
|
||||
ServerMessage::Snapshot {
|
||||
current_revision: u64::MAX,
|
||||
snapshot,
|
||||
},
|
||||
] {
|
||||
let remaining = MAX_PLAINTEXT - encode(&message).unwrap().len();
|
||||
let snapshot = match &mut message {
|
||||
ServerMessage::Attached { snapshot, .. } | ServerMessage::Snapshot { snapshot, .. } => snapshot,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
// Existing host/connection metadata has no declared maximum. Fill the
|
||||
// remaining envelope budget, then assert its actual boundary explicitly.
|
||||
snapshot.auth_executable.push_str(&"a".repeat(remaining));
|
||||
assert_eq!(encode(&message).unwrap().len(), MAX_PLAINTEXT);
|
||||
let snapshot = match &mut message {
|
||||
ServerMessage::Attached { snapshot, .. } | ServerMessage::Snapshot { snapshot, .. } => snapshot,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
snapshot.auth_executable.push('a');
|
||||
assert!(matches!(encode(&message), Err(TransportError::MessageTooLarge)));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -18,6 +18,7 @@ pub struct HostInfo {
|
||||
/// to the client so that it can configure itself accordingly.
|
||||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||||
pub struct VpnEnv {
|
||||
pub tunnel_state: Option<crate::session::tunnel::TunnelState>,
|
||||
/// The VPN connection state
|
||||
pub vpn_state: VpnState,
|
||||
|
||||
|
||||
@@ -9,6 +9,7 @@ mod gateway_sessions;
|
||||
pub mod network;
|
||||
pub mod non_tunnel;
|
||||
pub mod transport;
|
||||
pub mod tunnel;
|
||||
pub use connection::*;
|
||||
pub use gateway_sessions::{ClientAddresses, GatewaySession, GatewaySessions};
|
||||
|
||||
|
||||
@@ -223,7 +223,7 @@ impl PhysicalNetwork {
|
||||
}
|
||||
|
||||
fn fingerprint(&self) -> anyhow::Result<String> {
|
||||
Ok(sha256::digest(serde_json::to_vec(&self.snapshot)?))
|
||||
Ok(crate::utils::checksum::sha256_hex(serde_json::to_vec(&self.snapshot)?))
|
||||
}
|
||||
|
||||
pub fn capture(control: &dyn CollectionControl) -> anyhow::Result<Self> {
|
||||
|
||||
@@ -320,8 +320,8 @@ fn parse_hip_check(root: &Element) -> Result<HipCheck, GatewayRequestError> {
|
||||
.map_err(|_| GatewayRequestError::MalformedResponse)?,
|
||||
None => 0,
|
||||
};
|
||||
// Limit this client's supported response delay to one hour. The official
|
||||
// registry scheduling cap is not evidence of a wire-protocol maximum.
|
||||
// Accept response delays up to one hour as a client policy, not a
|
||||
// wire-protocol maximum.
|
||||
if delay > 3600 {
|
||||
return Err(GatewayRequestError::MalformedResponse);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,353 @@
|
||||
//! Observed tunnel data, shared by standalone clients and service consumers.
|
||||
//! These values describe negotiated settings, not verified operating-system state.
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use uuid::Uuid;
|
||||
|
||||
pub const MAX_CONFIGURATION_BYTES: usize = 16 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TunnelPhase {
|
||||
Establishing,
|
||||
Connected,
|
||||
Reconnecting,
|
||||
Ended,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TunnelTransport {
|
||||
Negotiating,
|
||||
IpsecEsp,
|
||||
SslTls,
|
||||
Unavailable,
|
||||
}
|
||||
|
||||
impl TunnelTransport {
|
||||
pub fn is_active(self) -> bool {
|
||||
matches!(self, Self::IpsecEsp | Self::SslTls)
|
||||
}
|
||||
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::Negotiating => "Negotiating",
|
||||
Self::IpsecEsp => "IPsec (ESP)",
|
||||
Self::SslTls => "SSL/TLS",
|
||||
Self::Unavailable => "Unavailable",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelList {
|
||||
pub items: Vec<String>,
|
||||
pub total_count: u32,
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelAddress {
|
||||
pub address: String,
|
||||
pub netmask: Option<String>,
|
||||
pub prefix_length: Option<u8>,
|
||||
}
|
||||
|
||||
impl TunnelAddress {
|
||||
pub fn display(&self) -> String {
|
||||
match self.prefix_length {
|
||||
Some(prefix) => format!("{}/{prefix}", self.address),
|
||||
None => match &self.netmask {
|
||||
Some(netmask) => format!("{} (mask {netmask})", self.address),
|
||||
None => self.address.clone(),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelConfiguration {
|
||||
pub interface: Option<String>,
|
||||
pub ipv4: Option<TunnelAddress>,
|
||||
pub ipv6: Option<TunnelAddress>,
|
||||
pub server_ip: Option<String>,
|
||||
pub dns: TunnelList,
|
||||
pub search_domains: TunnelList,
|
||||
pub split_dns: TunnelList,
|
||||
pub included_routes: TunnelList,
|
||||
pub excluded_routes: TunnelList,
|
||||
pub mtu: Option<u32>,
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
impl TunnelConfiguration {
|
||||
/// Bound observation payloads without modifying native network configuration.
|
||||
/// Whole list entries are omitted before shortening scalar text. Counts and
|
||||
/// truncation flags preserve the distinction between absent and omitted data.
|
||||
/// Returns false if even the fixed JSON shape cannot fit the supplied budget.
|
||||
pub fn limit_encoded_size(&mut self, limit: usize) -> bool {
|
||||
while serde_json::to_vec(self).expect("configuration is serializable").len() > limit {
|
||||
self.truncated = true;
|
||||
let lists = [
|
||||
&mut self.excluded_routes,
|
||||
&mut self.included_routes,
|
||||
&mut self.split_dns,
|
||||
&mut self.search_domains,
|
||||
&mut self.dns,
|
||||
];
|
||||
if let Some(list) = lists.into_iter().find(|list| !list.items.is_empty()) {
|
||||
list.items.pop();
|
||||
list.truncated = true;
|
||||
continue;
|
||||
}
|
||||
let mut scalars = vec![&mut self.interface, &mut self.server_ip];
|
||||
if let Some(address) = &mut self.ipv4 {
|
||||
scalars.push(&mut address.netmask);
|
||||
if address.address.len() > 128 {
|
||||
address.address.truncate(address.address.floor_char_boundary(128));
|
||||
address.prefix_length = None;
|
||||
}
|
||||
}
|
||||
if let Some(address) = &mut self.ipv6 {
|
||||
scalars.push(&mut address.netmask);
|
||||
if address.address.len() > 128 {
|
||||
address.address.truncate(address.address.floor_char_boundary(128));
|
||||
address.prefix_length = None;
|
||||
}
|
||||
}
|
||||
match scalars
|
||||
.into_iter()
|
||||
.max_by_key(|value| value.as_ref().map_or(0, String::len))
|
||||
{
|
||||
Some(Some(text)) if !text.is_empty() => {
|
||||
text.truncate(text.floor_char_boundary(text.len() / 2));
|
||||
}
|
||||
_ => return serde_json::to_vec(self).expect("configuration is serializable").len() <= limit,
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelState {
|
||||
pub tunnel_id: Uuid,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub sequence: u64,
|
||||
pub phase: TunnelPhase,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub configuration_revision: u64,
|
||||
pub configuration: Option<TunnelConfiguration>,
|
||||
pub transport: TunnelTransport,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub elapsed_ms: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelStatistics {
|
||||
pub tunnel_id: Uuid,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub sequence: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub state_sequence: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub configuration_revision: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub elapsed_ms: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub received_bytes: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub sent_bytes: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub received_packets: u64,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub sent_packets: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TunnelStatisticsState {
|
||||
Disabled,
|
||||
Waiting,
|
||||
Fresh,
|
||||
Stale,
|
||||
Ended,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TunnelStatisticsView {
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub sequence: u64,
|
||||
pub tunnel_id: Uuid,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub state_sequence: u64,
|
||||
pub phase: TunnelPhase,
|
||||
pub transport: TunnelTransport,
|
||||
pub state: TunnelStatisticsState,
|
||||
#[serde(with = "decimal")]
|
||||
#[specta(type = String)]
|
||||
pub elapsed_ms: u64,
|
||||
#[serde(with = "optional_decimal")]
|
||||
#[specta(type = Option<String>)]
|
||||
pub sample_age_ms: Option<u64>,
|
||||
pub sample: Option<TunnelStatistics>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TunnelUnavailableReason {
|
||||
NoTunnel,
|
||||
NonTunnel,
|
||||
ObservationFailed,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
pub enum TunnelStatisticsSnapshot {
|
||||
Available(TunnelStatisticsView),
|
||||
Unavailable { reason: TunnelUnavailableReason },
|
||||
}
|
||||
|
||||
impl TunnelStatisticsSnapshot {
|
||||
pub fn unavailable(reason: TunnelUnavailableReason) -> Self {
|
||||
Self::Unavailable { reason }
|
||||
}
|
||||
|
||||
pub fn view(&self) -> Option<&TunnelStatisticsView> {
|
||||
match self {
|
||||
Self::Available(view) => Some(view),
|
||||
Self::Unavailable { .. } => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn tunnel_id(&self) -> Option<Uuid> {
|
||||
self.view().map(|view| view.tunnel_id)
|
||||
}
|
||||
|
||||
pub fn sequence(&self) -> Option<u64> {
|
||||
self.view().map(|view| view.sequence)
|
||||
}
|
||||
|
||||
pub fn state_sequence(&self) -> Option<u64> {
|
||||
self.view().map(|view| view.state_sequence)
|
||||
}
|
||||
|
||||
pub fn disabled(&self) -> Self {
|
||||
let mut snapshot = self.clone();
|
||||
if let Self::Available(view) = &mut snapshot {
|
||||
if view.state != TunnelStatisticsState::Ended {
|
||||
view.state = TunnelStatisticsState::Disabled;
|
||||
}
|
||||
}
|
||||
snapshot
|
||||
}
|
||||
|
||||
pub fn stale(&self) -> Self {
|
||||
let mut snapshot = self.clone();
|
||||
if let Self::Available(view) = &mut snapshot {
|
||||
if matches!(
|
||||
view.state,
|
||||
TunnelStatisticsState::Fresh | TunnelStatisticsState::Waiting
|
||||
) {
|
||||
view.state = TunnelStatisticsState::Stale;
|
||||
}
|
||||
}
|
||||
snapshot
|
||||
}
|
||||
}
|
||||
|
||||
mod decimal {
|
||||
use serde::{Deserialize, Deserializer, Serializer};
|
||||
|
||||
pub fn serialize<S: Serializer>(value: &u64, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
serializer.collect_str(value)
|
||||
}
|
||||
|
||||
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<u64, D::Error> {
|
||||
let value = String::deserialize(deserializer)?;
|
||||
if value.is_empty() || !value.bytes().all(|byte| byte.is_ascii_digit()) {
|
||||
return Err(serde::de::Error::custom("expected an unsigned decimal string"));
|
||||
}
|
||||
value.parse().map_err(serde::de::Error::custom)
|
||||
}
|
||||
}
|
||||
|
||||
mod optional_decimal {
|
||||
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
||||
|
||||
pub fn serialize<S: Serializer>(value: &Option<u64>, serializer: S) -> Result<S::Ok, S::Error> {
|
||||
value.map(|value| value.to_string()).serialize(serializer)
|
||||
}
|
||||
|
||||
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<u64>, D::Error> {
|
||||
Option::<String>::deserialize(deserializer)?
|
||||
.map(|value| {
|
||||
if value.is_empty() || !value.bytes().all(|byte| byte.is_ascii_digit()) {
|
||||
return Err(serde::de::Error::custom("expected an unsigned decimal string"));
|
||||
}
|
||||
value.parse().map_err(serde::de::Error::custom)
|
||||
})
|
||||
.transpose()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn counters_above_javascript_precision_round_trip_as_decimal_strings() {
|
||||
let sample = TunnelStatistics {
|
||||
tunnel_id: Uuid::nil(),
|
||||
sequence: 1,
|
||||
state_sequence: 1,
|
||||
configuration_revision: 1,
|
||||
elapsed_ms: 1000,
|
||||
received_bytes: (1_u64 << 53) + 1,
|
||||
sent_bytes: u64::MAX,
|
||||
received_packets: 3,
|
||||
sent_packets: 4,
|
||||
};
|
||||
let value = serde_json::to_value(&sample).unwrap();
|
||||
assert_eq!(value["receivedBytes"], "9007199254740993");
|
||||
assert_eq!(value["sentBytes"], "18446744073709551615");
|
||||
assert_eq!(
|
||||
serde_json::from_value::<TunnelStatistics>(value.clone()).unwrap(),
|
||||
sample
|
||||
);
|
||||
let mut numeric = value;
|
||||
numeric["receivedBytes"] = serde_json::json!(9007199254740993_u64);
|
||||
assert!(serde_json::from_value::<TunnelStatistics>(numeric).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unavailable_has_no_synthetic_counters() {
|
||||
let snapshot = TunnelStatisticsSnapshot::unavailable(TunnelUnavailableReason::NonTunnel);
|
||||
let value = serde_json::to_value(&snapshot).unwrap();
|
||||
assert_eq!(value, serde_json::json!({"kind": "unavailable", "reason": "nonTunnel"}));
|
||||
assert_eq!(
|
||||
serde_json::from_value::<TunnelStatisticsSnapshot>(value).unwrap(),
|
||||
snapshot
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,43 @@
|
||||
use std::path::Path;
|
||||
use std::{
|
||||
fmt::Write as _,
|
||||
fs::File,
|
||||
io::{self, Read},
|
||||
path::Path,
|
||||
};
|
||||
|
||||
use anyhow::bail;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
pub fn sha256_hex(data: impl AsRef<[u8]>) -> String {
|
||||
digest_hex(&Sha256::digest(data.as_ref()))
|
||||
}
|
||||
|
||||
pub fn file_sha256(path: impl AsRef<Path>) -> io::Result<String> {
|
||||
let mut file = File::open(path)?;
|
||||
let mut hasher = Sha256::new();
|
||||
let mut buffer = [0; 8192];
|
||||
loop {
|
||||
let count = match file.read(&mut buffer) {
|
||||
Ok(0) => break,
|
||||
Ok(count) => count,
|
||||
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
hasher.update(&buffer[..count]);
|
||||
}
|
||||
Ok(digest_hex(&hasher.finalize()))
|
||||
}
|
||||
|
||||
fn digest_hex(digest: &[u8]) -> String {
|
||||
let mut hex = String::with_capacity(digest.len() * 2);
|
||||
for byte in digest {
|
||||
write!(&mut hex, "{byte:02x}").expect("writing to a String cannot fail");
|
||||
}
|
||||
hex
|
||||
}
|
||||
|
||||
pub fn verify_checksum(path: &str, expected: &str) -> anyhow::Result<()> {
|
||||
let file = Path::new(&path);
|
||||
let checksum = sha256::try_digest(&file)?;
|
||||
let checksum = file_sha256(path)?;
|
||||
|
||||
if checksum != expected {
|
||||
bail!("Checksum mismatch, expected: {}, actual: {}", expected, checksum);
|
||||
@@ -12,3 +45,43 @@ pub fn verify_checksum(path: &str, expected: &str) -> anyhow::Result<()> {
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::io::Write;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn known_sha256_vectors_use_lowercase_hex() {
|
||||
assert_eq!(
|
||||
sha256_hex(b""),
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
|
||||
);
|
||||
assert_eq!(
|
||||
sha256_hex(b"abc"),
|
||||
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashes_files_across_buffer_boundaries_and_checks_expected_digest() {
|
||||
let mut file = tempfile::NamedTempFile::new().unwrap();
|
||||
file.write_all(&vec![b'a'; 1_000_000]).unwrap();
|
||||
let expected = "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0";
|
||||
|
||||
assert_eq!(file_sha256(file.path()).unwrap(), expected);
|
||||
verify_checksum(file.path().to_str().unwrap(), expected).unwrap();
|
||||
assert!(verify_checksum(file.path().to_str().unwrap(), "wrong").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashes_empty_files_and_propagates_file_errors() {
|
||||
let file = tempfile::NamedTempFile::new().unwrap();
|
||||
assert_eq!(file_sha256(file.path()).unwrap(), sha256_hex(b""));
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let error = file_sha256(directory.path().join("missing")).unwrap_err();
|
||||
assert_eq!(error.kind(), std::io::ErrorKind::NotFound);
|
||||
assert!(file_sha256(directory.path()).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
//! PEM/DER normalization; usable key and certificate imports stay with native TLS.
|
||||
use pkcs8::{
|
||||
AlgorithmIdentifierRef, EncryptedPrivateKeyInfoRef, ObjectIdentifier, PrivateKeyInfoRef, SecretDocument,
|
||||
der::{
|
||||
Decode, Reader, SliceReader, Tag, Tagged,
|
||||
asn1::{AnyRef, OctetStringRef, SequenceRef},
|
||||
},
|
||||
};
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
use super::{request::RequestIdentityError, traditional_key};
|
||||
|
||||
pub(super) enum TraditionalKeyFormat {
|
||||
Sec1Der,
|
||||
PlainPem,
|
||||
EncryptedPem,
|
||||
}
|
||||
|
||||
struct PemBlock {
|
||||
tag: String,
|
||||
headers: pem::HeaderMap,
|
||||
contents: Zeroizing<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl PemBlock {
|
||||
fn encoded(&self) -> Zeroizing<Vec<u8>> {
|
||||
let mut block = pem::Pem::new(&self.tag, self.contents.as_slice());
|
||||
*block.headers_mut() = self.headers.clone();
|
||||
let encoded = Zeroizing::new(pem::encode(&block).into_bytes());
|
||||
// The PEM crate owns a copy of the decoded private key as well.
|
||||
drop(Zeroizing::new(block.into_contents()));
|
||||
encoded
|
||||
}
|
||||
}
|
||||
|
||||
fn is_pem(bytes: &[u8]) -> bool {
|
||||
bytes.windows(b"-----BEGIN".len()).any(|part| part == b"-----BEGIN")
|
||||
}
|
||||
|
||||
// Adopt decoded blocks immediately, including ignored keys in combined files.
|
||||
fn blocks(bytes: &[u8]) -> Result<Vec<PemBlock>, pem::PemError> {
|
||||
Ok(
|
||||
pem::parse_many(bytes)?
|
||||
.into_iter()
|
||||
.map(|block| PemBlock {
|
||||
tag: block.tag().to_owned(),
|
||||
headers: block.headers().clone(),
|
||||
contents: Zeroizing::new(block.into_contents()),
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn private_key(bytes: &[u8], passphrase: Option<&str>) -> anyhow::Result<Zeroizing<Vec<u8>>> {
|
||||
let pem_input = is_pem(bytes);
|
||||
let block = if pem_input {
|
||||
blocks(bytes)
|
||||
.map_err(|_| RequestIdentityError::InvalidKey)?
|
||||
.into_iter()
|
||||
.find(|block| block.tag.ends_with("PRIVATE KEY"))
|
||||
.ok_or(RequestIdentityError::NoKey)?
|
||||
} else {
|
||||
// Unlike combined PEM, a standalone DER certificate cannot include a key.
|
||||
if x509_cert::Certificate::from_der(bytes).is_ok() {
|
||||
return Err(RequestIdentityError::NoKey.into());
|
||||
}
|
||||
PemBlock {
|
||||
tag: der_key_tag(bytes)
|
||||
.map_err(|_| RequestIdentityError::InvalidKey)?
|
||||
.to_owned(),
|
||||
headers: pem::HeaderMap::default(),
|
||||
contents: Zeroizing::new(bytes.to_vec()),
|
||||
}
|
||||
};
|
||||
let der = &block.contents;
|
||||
let document = if traditional_encryption(&block)? {
|
||||
if !matches!(block.tag.as_str(), "RSA PRIVATE KEY" | "EC PRIVATE KEY") {
|
||||
return Err(RequestIdentityError::InvalidKey.into());
|
||||
}
|
||||
traditional_key::normalize(&block.encoded(), TraditionalKeyFormat::EncryptedPem, passphrase)?
|
||||
} else {
|
||||
match block.tag.as_str() {
|
||||
"PRIVATE KEY" => SecretDocument::try_from(der.as_slice()).map_err(|_| RequestIdentityError::InvalidKey)?,
|
||||
"RSA PRIVATE KEY" => {
|
||||
// PKCS#8 stores the original PKCS#1 bytes inside an RSA algorithm envelope.
|
||||
// Native TLS validates the RSA key, as it does for existing PKCS#8 input.
|
||||
let algorithm = AlgorithmIdentifierRef {
|
||||
oid: ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.1"),
|
||||
parameters: Some(AnyRef::NULL),
|
||||
};
|
||||
let private_key = OctetStringRef::new(der).map_err(|_| RequestIdentityError::InvalidKey)?;
|
||||
let info = PrivateKeyInfoRef::new(algorithm, private_key);
|
||||
SecretDocument::encode_msg(&info).map_err(|_| RequestIdentityError::InvalidKey)?
|
||||
}
|
||||
"ENCRYPTED PRIVATE KEY" => decrypt(der, passphrase)?,
|
||||
"EC PRIVATE KEY" => {
|
||||
if pem_input {
|
||||
traditional_key::normalize(&block.encoded(), TraditionalKeyFormat::PlainPem, passphrase)?
|
||||
} else {
|
||||
traditional_key::normalize(der, TraditionalKeyFormat::Sec1Der, passphrase)?
|
||||
}
|
||||
}
|
||||
_ => return Err(RequestIdentityError::UnsupportedKeyFormat.into()),
|
||||
}
|
||||
};
|
||||
PrivateKeyInfoRef::from_der(document.as_bytes()).map_err(|_| RequestIdentityError::InvalidKey)?;
|
||||
let pem = document.to_pem("PRIVATE KEY", pkcs8::LineEnding::LF)?;
|
||||
Ok(Zeroizing::new(pem.as_bytes().to_vec()))
|
||||
}
|
||||
|
||||
// Only choose a container here. The selected decoder/native importer validates
|
||||
// the key. Decoding the complete outer sequence rejects concatenated DER input.
|
||||
fn der_key_tag(bytes: &[u8]) -> Result<&'static str, pkcs8::der::Error> {
|
||||
let sequence = <&SequenceRef>::from_der(bytes)?;
|
||||
let mut reader = SliceReader::new(sequence.as_bytes())?;
|
||||
let first: AnyRef = reader.decode()?;
|
||||
Ok(match (first.tag(), Tag::peek(&reader)?) {
|
||||
(Tag::Integer, Tag::Sequence) => "PRIVATE KEY",
|
||||
(Tag::Integer, Tag::Integer) => "RSA PRIVATE KEY",
|
||||
(Tag::Integer, Tag::OctetString) => "EC PRIVATE KEY",
|
||||
(Tag::Sequence, Tag::OctetString) => "ENCRYPTED PRIVATE KEY",
|
||||
_ => return Err(pkcs8::der::ErrorKind::Failed.into()),
|
||||
})
|
||||
}
|
||||
|
||||
fn traditional_encryption(block: &PemBlock) -> Result<bool, RequestIdentityError> {
|
||||
let mut proc_type = None;
|
||||
let mut dek_info = None;
|
||||
for (name, value) in block.headers.iter() {
|
||||
let slot = match name {
|
||||
"Proc-Type" => &mut proc_type,
|
||||
"DEK-Info" => &mut dek_info,
|
||||
_ => continue,
|
||||
};
|
||||
if slot.replace(value).is_some() {
|
||||
return Err(RequestIdentityError::InvalidKey);
|
||||
}
|
||||
}
|
||||
if proc_type.is_none() && dek_info.is_none() {
|
||||
return Ok(false);
|
||||
}
|
||||
let (Some("4,ENCRYPTED"), Some(dek_info)) = (proc_type, dek_info) else {
|
||||
return Err(RequestIdentityError::InvalidKey);
|
||||
};
|
||||
let (cipher, iv) = dek_info.split_once(',').ok_or(RequestIdentityError::InvalidKey)?;
|
||||
let block_size = match cipher {
|
||||
"AES-128-CBC" | "AES-192-CBC" | "AES-256-CBC" => 16,
|
||||
"DES-EDE3-CBC" => 8,
|
||||
_ => return Err(RequestIdentityError::UnsupportedEncryption),
|
||||
};
|
||||
if iv.len() != block_size * 2
|
||||
|| !iv.bytes().all(|byte| byte.is_ascii_hexdigit())
|
||||
|| block.contents.is_empty()
|
||||
|| block.contents.len() % block_size != 0
|
||||
{
|
||||
return Err(RequestIdentityError::InvalidKey);
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn decrypt(der: &[u8], passphrase: Option<&str>) -> anyhow::Result<SecretDocument> {
|
||||
// pkcs5 collapses unknown outer PBE OIDs into a generic DER value error.
|
||||
// Inspect the typed envelope first so legacy PBE is not called malformed.
|
||||
let algorithm = pkcs8::der::asn1::AnyRef::from_der(der)
|
||||
.and_then(|value| {
|
||||
value.sequence(|reader| {
|
||||
let algorithm = pkcs8::AlgorithmIdentifierRef::decode(reader)?;
|
||||
let _: &pkcs8::der::asn1::OctetStringRef = reader.decode()?;
|
||||
Ok(algorithm.oid)
|
||||
})
|
||||
})
|
||||
.map_err(|_| RequestIdentityError::InvalidKey)?;
|
||||
if algorithm != pkcs8::pkcs5::pbes2::PBES2_OID {
|
||||
// PKCS#12 PBE-SHA1-3DES inside standalone PKCS#8 is not implemented by
|
||||
// RustCrypto. Only this known legacy scheme uses the optional executable.
|
||||
if algorithm == pkcs8::ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.1.3") {
|
||||
return super::legacy_pkcs8::decrypt(der, passphrase);
|
||||
}
|
||||
return Err(RequestIdentityError::UnsupportedEncryption.into());
|
||||
}
|
||||
// Decode the full encryption scheme, including its KDF/PRF/cipher, before
|
||||
// asking for a password. Unsupported algorithms must not cause prompt loops.
|
||||
let encrypted = EncryptedPrivateKeyInfoRef::from_der(der).map_err(|error| match error.kind() {
|
||||
pkcs8::der::ErrorKind::OidUnknown { .. } => RequestIdentityError::UnsupportedEncryption,
|
||||
_ => RequestIdentityError::InvalidKey,
|
||||
})?;
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PEM"))?;
|
||||
let mut plaintext = Zeroizing::new(encrypted.encrypted_data.as_bytes().to_vec());
|
||||
let decrypted = encrypted
|
||||
.encryption_algorithm
|
||||
.decrypt_in_place(passphrase, &mut plaintext)
|
||||
.map_err(|_| RequestIdentityError::DecryptError("PEM"))?;
|
||||
SecretDocument::try_from(decrypted).map_err(|_| RequestIdentityError::DecryptError("PEM").into())
|
||||
}
|
||||
|
||||
pub(super) fn certificate_chain(bytes: &[u8]) -> anyhow::Result<Zeroizing<Vec<u8>>> {
|
||||
if !is_pem(bytes) {
|
||||
return certificate_pem(bytes).map(|pem| Zeroizing::new(pem.into_bytes()));
|
||||
}
|
||||
let mut chain = Zeroizing::new(Vec::new());
|
||||
for block in blocks(bytes).map_err(|_| RequestIdentityError::InvalidCertificate)? {
|
||||
if block.tag == "CERTIFICATE" {
|
||||
let encoded = certificate_pem(&block.contents)?;
|
||||
chain.extend_from_slice(encoded.as_bytes());
|
||||
}
|
||||
}
|
||||
if chain.is_empty() {
|
||||
return Err(RequestIdentityError::InvalidCertificate.into());
|
||||
}
|
||||
Ok(chain)
|
||||
}
|
||||
|
||||
fn certificate_pem(der: &[u8]) -> anyhow::Result<String> {
|
||||
x509_cert::Certificate::from_der(der).map_err(|_| RequestIdentityError::InvalidCertificate)?;
|
||||
Ok(pem::encode_config(
|
||||
&pem::Pem::new("CERTIFICATE", der),
|
||||
pem::EncodeConfig::new().set_line_ending(pem::LineEnding::LF),
|
||||
))
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
//! Optional compatibility conversion for standalone PKCS#12 PBE-SHA1-3DES keys.
|
||||
//! The executable is a runtime option, not a linked or bundled dependency.
|
||||
use std::{
|
||||
io::{ErrorKind, Read, Write},
|
||||
os::{fd::AsFd, unix::process::CommandExt},
|
||||
process::{Child, Command, Stdio},
|
||||
thread,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use nix::{
|
||||
fcntl::{FcntlArg, OFlag, fcntl},
|
||||
sys::signal::{Signal, killpg},
|
||||
unistd::Pid,
|
||||
};
|
||||
use pkcs8::SecretDocument;
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
use super::request::RequestIdentityError::{self, LegacyKeyConversion};
|
||||
|
||||
const TIMEOUT: Duration = Duration::from_secs(10);
|
||||
const MAX_OUTPUT: u64 = 1024 * 1024;
|
||||
const MAX_PASSWORD_BYTES: usize = 1023;
|
||||
|
||||
// The converter owns a separate process group, including wrapper descendants.
|
||||
// Clean up that group and reap the direct child on every return path.
|
||||
struct Converter(Child);
|
||||
|
||||
impl Drop for Converter {
|
||||
fn drop(&mut self) {
|
||||
let _ = killpg(Pid::from_raw(self.0.id() as i32), Signal::SIGKILL);
|
||||
let _ = self.0.wait();
|
||||
}
|
||||
}
|
||||
|
||||
fn nonblocking(pipe: &impl AsFd) -> anyhow::Result<()> {
|
||||
fcntl(pipe, FcntlArg::F_SETFL(OFlag::O_NONBLOCK))
|
||||
.map_err(|_| LegacyKeyConversion("could not configure converter pipes"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Read at most one chunk per iteration so a busy pipe cannot starve the deadline.
|
||||
// Returns true only after EOF; inherited pipes remain subject to the deadline.
|
||||
fn read_output(pipe: &mut impl Read, output: &mut Zeroizing<Vec<u8>>, limit: u64) -> anyhow::Result<bool> {
|
||||
let mut buffer = Zeroizing::new([0u8; 8192]);
|
||||
match pipe.read(buffer.as_mut_slice()) {
|
||||
Ok(0) => Ok(true),
|
||||
Ok(count) => {
|
||||
if output.len() as u64 + count as u64 > limit {
|
||||
return Err(LegacyKeyConversion("converter output exceeds the size limit").into());
|
||||
}
|
||||
output.extend_from_slice(&buffer[..count]);
|
||||
Ok(false)
|
||||
}
|
||||
Err(error) if matches!(error.kind(), ErrorKind::WouldBlock | ErrorKind::Interrupted) => Ok(false),
|
||||
Err(_) => Err(LegacyKeyConversion("could not read converter output").into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn decrypt(der: &[u8], passphrase: Option<&str>) -> anyhow::Result<SecretDocument> {
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PEM"))?;
|
||||
// The command's line reader reserves one byte for a terminator. The linked
|
||||
// OpenSSL API accepted 1024 bytes, but the CLI would truncate that password.
|
||||
if passphrase.len() > MAX_PASSWORD_BYTES {
|
||||
return Err(LegacyKeyConversion("the password exceeds OpenSSL's 1023-byte input limit").into());
|
||||
}
|
||||
// OpenSSL's pipe password source reads one line. Never silently truncate it.
|
||||
if passphrase.contains(['\r', '\n', '\0']) {
|
||||
return Err(LegacyKeyConversion("the password cannot be passed through OpenSSL's line-based input").into());
|
||||
}
|
||||
|
||||
// Only encrypted input touches disk, in a private temporary file. The
|
||||
// original file is never changed and decrypted output stays in memory.
|
||||
let mut input = tempfile::NamedTempFile::new()?;
|
||||
input.write_all(pem::encode(&pem::Pem::new("ENCRYPTED PRIVATE KEY", der)).as_bytes())?;
|
||||
let child = Command::new("openssl")
|
||||
.args([
|
||||
"pkcs8", "-topk8", "-nocrypt", "-inform", "PEM", "-outform", "DER", "-in",
|
||||
])
|
||||
.arg(input.path())
|
||||
.args(["-passin", "stdin"])
|
||||
.env("LC_ALL", "C")
|
||||
.process_group(0)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.map_err(|_| LegacyKeyConversion("the openssl executable is unavailable"))?;
|
||||
let mut converter = Converter(child);
|
||||
let mut stdin = converter.0.stdin.take();
|
||||
let mut stdout = converter.0.stdout.take().unwrap();
|
||||
let mut stderr = converter.0.stderr.take().unwrap();
|
||||
nonblocking(stdin.as_ref().unwrap())?;
|
||||
nonblocking(&stdout)?;
|
||||
nonblocking(&stderr)?;
|
||||
let mut password = Zeroizing::new(passphrase.as_bytes().to_vec());
|
||||
password.push(b'\n');
|
||||
let mut written = 0;
|
||||
let mut input_failed = false;
|
||||
let mut output = Zeroizing::new(Vec::new());
|
||||
let mut diagnostic = Zeroizing::new(Vec::new());
|
||||
let mut output_done = false;
|
||||
let mut diagnostic_done = false;
|
||||
let mut status = None;
|
||||
let started = Instant::now();
|
||||
let status = loop {
|
||||
if started.elapsed() >= TIMEOUT {
|
||||
return Err(LegacyKeyConversion("conversion timed out").into());
|
||||
}
|
||||
if let Some(pipe) = stdin.as_mut() {
|
||||
match pipe.write(&password[written..]) {
|
||||
Ok(0) => {
|
||||
input_failed = true;
|
||||
stdin = None;
|
||||
}
|
||||
Ok(count) => {
|
||||
written += count;
|
||||
if written == password.len() {
|
||||
stdin = None;
|
||||
}
|
||||
}
|
||||
Err(error) if matches!(error.kind(), ErrorKind::WouldBlock | ErrorKind::Interrupted) => {}
|
||||
Err(_) => {
|
||||
input_failed = true;
|
||||
stdin = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
if !output_done {
|
||||
output_done = read_output(&mut stdout, &mut output, MAX_OUTPUT)?;
|
||||
}
|
||||
if !diagnostic_done {
|
||||
diagnostic_done = read_output(&mut stderr, &mut diagnostic, 16 * 1024)?;
|
||||
}
|
||||
if status.is_none() {
|
||||
status = converter
|
||||
.0
|
||||
.try_wait()
|
||||
.map_err(|_| LegacyKeyConversion("could not wait for the converter"))?;
|
||||
}
|
||||
if let Some(status) = status {
|
||||
if output_done && diagnostic_done && stdin.is_none() {
|
||||
break status;
|
||||
}
|
||||
}
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
};
|
||||
if status.success() && input_failed {
|
||||
return Err(LegacyKeyConversion("could not send the password").into());
|
||||
}
|
||||
|
||||
if !status.success() {
|
||||
// Never include the command's output in user-facing errors: it can contain
|
||||
// key material. Preserve the old Linux password retry contract only for
|
||||
// an explicit decryption failure, not missing cipher/provider support.
|
||||
if [b"bad decrypt".as_slice(), b"pkcs12 cipherfinal error".as_slice()]
|
||||
.iter()
|
||||
.any(|message| diagnostic.windows(message.len()).any(|window| window == *message))
|
||||
{
|
||||
return Err(RequestIdentityError::DecryptError("PEM").into());
|
||||
}
|
||||
return Err(LegacyKeyConversion("this OpenSSL installation cannot decrypt the key").into());
|
||||
}
|
||||
SecretDocument::try_from(output.as_slice()).map_err(|_| LegacyKeyConversion("invalid converted key").into())
|
||||
}
|
||||
@@ -5,10 +5,25 @@ pub mod checksum;
|
||||
pub mod crypto;
|
||||
pub mod endpoint;
|
||||
pub mod env_utils;
|
||||
mod identity_encoding;
|
||||
mod legacy_pkcs8;
|
||||
pub mod lock_file;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
pub mod openssl;
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "pkcs12_identity/macos.rs"]
|
||||
mod pkcs12_identity;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[path = "pkcs12_identity/openssl.rs"]
|
||||
mod pkcs12_identity;
|
||||
pub mod redact;
|
||||
pub mod request;
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "traditional_key/macos.rs"]
|
||||
mod traditional_key;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[path = "traditional_key/openssl.rs"]
|
||||
mod traditional_key;
|
||||
#[cfg(feature = "tauri")]
|
||||
pub mod window;
|
||||
|
||||
@@ -51,6 +66,8 @@ pub struct GpError {
|
||||
pub status: StatusCode,
|
||||
pub reason: String,
|
||||
body: String,
|
||||
#[source]
|
||||
source: Option<reqwest::Error>,
|
||||
}
|
||||
|
||||
impl GpError {
|
||||
@@ -63,9 +80,7 @@ pub async fn parse_gp_response(res: Response) -> anyhow::Result<String, GpError>
|
||||
let status = res.status();
|
||||
|
||||
if status.is_client_error() || status.is_server_error() {
|
||||
let (reason, body) = parse_gp_error(res).await;
|
||||
|
||||
return Err(GpError { status, reason, body });
|
||||
return Err(parse_gp_error(res).await);
|
||||
}
|
||||
|
||||
res.text().await.map_err(|err| {
|
||||
@@ -75,21 +90,28 @@ pub async fn parse_gp_response(res: Response) -> anyhow::Result<String, GpError>
|
||||
status,
|
||||
reason: "failed to read response".to_string(),
|
||||
body: "<failed to read response>".to_string(),
|
||||
source: Some(err),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
async fn parse_gp_error(res: Response) -> (String, String) {
|
||||
async fn parse_gp_error(res: Response) -> GpError {
|
||||
let status = res.status();
|
||||
let reason = res
|
||||
.headers()
|
||||
.get("x-private-pan-globalprotect")
|
||||
.map_or_else(|| "<none>", |v| v.to_str().unwrap_or("<invalid header>"))
|
||||
.to_string();
|
||||
|
||||
let res = res.text().await.map_or_else(
|
||||
|_| "<failed to read response>".to_string(),
|
||||
|v| if v.is_empty() { "<empty>".to_string() } else { v },
|
||||
);
|
||||
let (body, source) = match res.text().await {
|
||||
Ok(body) => (if body.is_empty() { "<empty>".to_string() } else { body }, None),
|
||||
Err(error) => ("<failed to read response>".to_string(), Some(error)),
|
||||
};
|
||||
|
||||
(reason, res)
|
||||
GpError {
|
||||
status,
|
||||
reason,
|
||||
body,
|
||||
source,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
use security_framework::{import_export::Pkcs12ImportOptions, os::macos::keychain::CreateOptions};
|
||||
|
||||
use super::request::RequestIdentityError;
|
||||
|
||||
pub(super) fn ensure_complete(bytes: &[u8], password: &str) -> anyhow::Result<()> {
|
||||
// native-tls assumes a successful import has a last item with an identity.
|
||||
// Incomplete archives violate that assumption and panic. Inspect them first
|
||||
// in a private temporary keychain, never the user's default keychain.
|
||||
let directory = tempfile::tempdir()?;
|
||||
let keychain = CreateOptions::new()
|
||||
.password(&uuid::Uuid::new_v4().to_string())
|
||||
.create(directory.path().join("identity.keychain"))?;
|
||||
if let Ok(imports) = Pkcs12ImportOptions::new()
|
||||
.keychain(keychain)
|
||||
.passphrase(password)
|
||||
.import(bytes)
|
||||
&& !imports.last().is_some_and(|item| item.identity.is_some())
|
||||
{
|
||||
return Err(RequestIdentityError::IncompletePkcs12.into());
|
||||
}
|
||||
// Leave failed imports to reqwest so password errors retain their existing
|
||||
// classification and native error chain.
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
use openssl::pkcs12::Pkcs12;
|
||||
|
||||
use super::request::RequestIdentityError;
|
||||
|
||||
pub(super) fn ensure_complete(bytes: &[u8], password: &str) -> anyhow::Result<()> {
|
||||
// Parse errors belong to the existing native TLS importer. A successful parse
|
||||
// lets us report incomplete archives without suggesting a password change.
|
||||
if let Ok(archive) = Pkcs12::from_der(bytes).and_then(|archive| archive.parse2(password))
|
||||
&& (archive.pkey.is_none() || archive.cert.is_none())
|
||||
{
|
||||
return Err(RequestIdentityError::IncompletePkcs12.into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1,11 +1,10 @@
|
||||
use std::sync::RwLock;
|
||||
|
||||
use redact_engine::{Pattern, Redaction as RedactEngine};
|
||||
use regex::Regex;
|
||||
use url::{Url, form_urlencoded};
|
||||
|
||||
pub struct Redaction {
|
||||
redact_engine: RwLock<Option<RedactEngine>>,
|
||||
patterns: RwLock<Vec<Regex>>,
|
||||
}
|
||||
|
||||
impl Default for Redaction {
|
||||
@@ -16,56 +15,45 @@ impl Default for Redaction {
|
||||
|
||||
impl Redaction {
|
||||
pub fn new() -> Self {
|
||||
let redact_engine = RedactEngine::custom("[**********]").add_pattern(Pattern {
|
||||
test: Regex::new("(((25[0-5]|(2[0-4]|1\\d|[1-9]|)\\d)\\.?\\b){4})").unwrap(),
|
||||
group: 1,
|
||||
});
|
||||
|
||||
Self {
|
||||
redact_engine: RwLock::new(Some(redact_engine)),
|
||||
patterns: RwLock::new(vec![
|
||||
Regex::new("(((25[0-5]|(2[0-4]|1\\d|[1-9]|)\\d)\\.?\\b){4})").unwrap(),
|
||||
]),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_value(&self, text: &str) -> anyhow::Result<()> {
|
||||
let mut redact_engine = self
|
||||
.redact_engine
|
||||
.write()
|
||||
.map_err(|_| anyhow::anyhow!("Failed to acquire write lock on redact engine"))?;
|
||||
|
||||
*redact_engine = Some(
|
||||
redact_engine
|
||||
.take()
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to take redact engine"))?
|
||||
.add_value(text)?,
|
||||
);
|
||||
|
||||
Ok(())
|
||||
self.add_values(&[text])
|
||||
}
|
||||
|
||||
pub fn add_values(&self, texts: &[&str]) -> anyhow::Result<()> {
|
||||
let mut redact_engine = self
|
||||
.redact_engine
|
||||
let patterns = texts
|
||||
.iter()
|
||||
.map(|text| Regex::new(®ex::escape(text)))
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
self
|
||||
.patterns
|
||||
.write()
|
||||
.map_err(|_| anyhow::anyhow!("Failed to acquire write lock on redact engine"))?;
|
||||
|
||||
*redact_engine = Some(
|
||||
redact_engine
|
||||
.take()
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to take redact engine"))?
|
||||
.add_values(texts.to_vec())?,
|
||||
);
|
||||
.map_err(|_| anyhow::anyhow!("Failed to acquire write lock on redaction patterns"))?
|
||||
.extend(patterns);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn redact_str(&self, text: &str) -> String {
|
||||
self
|
||||
.redact_engine
|
||||
let patterns = self
|
||||
.patterns
|
||||
.read()
|
||||
.expect("Failed to acquire read lock on redact engine")
|
||||
.as_ref()
|
||||
.expect("Failed to get redact engine")
|
||||
.redact_str(text)
|
||||
.expect("Failed to acquire read lock on redaction patterns");
|
||||
let mut redacted = text.to_owned();
|
||||
// Match the original text, then replace in registration order. Matching the
|
||||
// replacements would change how overlapping values are redacted.
|
||||
for pattern in patterns.iter() {
|
||||
for matched in pattern.find_iter(text) {
|
||||
redacted = redacted.replacen(matched.as_str(), "[**********]", 1);
|
||||
}
|
||||
}
|
||||
redacted
|
||||
}
|
||||
}
|
||||
|
||||
@@ -180,6 +168,38 @@ fn redact_query(query: Option<&str>) -> Option<String> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn redacts_repeated_ipv4_addresses() {
|
||||
assert_eq!(
|
||||
Redaction::new().redact_str("from 192.0.2.1 to 198.51.100.9, then 192.0.2.1"),
|
||||
"from [**********] to [**********], then [**********]"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registered_values_are_literal_and_support_unicode() {
|
||||
let redaction = Redaction::new();
|
||||
redaction.add_values(&["a.b+$[x]", "秘密🔑"]).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
redaction.redact_str("a.b+$[x] 秘密🔑 a.b+$[x] aXb"),
|
||||
"[**********] [**********] [**********] aXb"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_values_keep_registration_order() {
|
||||
let redaction = Redaction::new();
|
||||
redaction.add_values(&["foobar", "foo"]).unwrap();
|
||||
|
||||
assert_eq!(redaction.redact_str("foobar foo"), "[**********] [**********]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_word_characters_preserve_ipv4_boundaries() {
|
||||
assert_eq!(Redaction::new().redact_str("192.0.2.1é"), "192.0.2.1é");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn it_should_not_redact_value() {
|
||||
let text = "fo";
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
use std::{fmt, fs, io::Write, path::Path, sync::Arc};
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use openssl::{pkey::PKey, x509::X509};
|
||||
use reqwest::Identity;
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
use super::{identity_encoding, pkcs12_identity};
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum RequestIdentityError {
|
||||
#[error("Failed to find the private key")]
|
||||
@@ -13,6 +14,24 @@ pub enum RequestIdentityError {
|
||||
NoPassphrase(&'static str),
|
||||
#[error("Failed to decrypt private key")]
|
||||
DecryptError(&'static str),
|
||||
#[error(
|
||||
"Unsupported private key encryption. Convert the key to modern PKCS#8 using PBES2 with AES before importing it"
|
||||
)]
|
||||
UnsupportedEncryption,
|
||||
#[error(
|
||||
"Could not convert the legacy private key with OpenSSL: {0}. Convert the key to modern PKCS#8 using PBES2 with AES before importing it"
|
||||
)]
|
||||
LegacyKeyConversion(&'static str),
|
||||
#[error("Unsupported private key format. Convert the key to PKCS#8 before importing it")]
|
||||
UnsupportedKeyFormat,
|
||||
#[error("Invalid private key")]
|
||||
InvalidKey,
|
||||
#[error("Invalid certificate or certificate chain")]
|
||||
InvalidCertificate,
|
||||
#[error("The PKCS#12 file must contain both a client certificate and its private key")]
|
||||
IncompletePkcs12,
|
||||
#[error("Could not open the PKCS#12 certificate. Check the password and certificate file")]
|
||||
InvalidPkcs12(#[source] reqwest::Error),
|
||||
}
|
||||
|
||||
/// Loaded once by the authentication owner. PEM keys are decrypted once; PKCS#12
|
||||
@@ -41,37 +60,17 @@ impl fmt::Debug for ClientIdentity {
|
||||
impl ClientIdentity {
|
||||
pub fn load(certificate: &str, key: Option<&str>, passphrase: Option<&str>) -> anyhow::Result<Self> {
|
||||
let certificate_bytes = read_identity_file(certificate)?;
|
||||
if certificate.ends_with(".p12") || certificate.ends_with(".pfx") {
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PKCS#12"))?;
|
||||
return Self::from_data(certificate_bytes, None, Some(passphrase));
|
||||
let extension = Path::new(certificate).extension().and_then(|value| value.to_str());
|
||||
if extension.is_some_and(|value| value.eq_ignore_ascii_case("p12") || value.eq_ignore_ascii_case("pfx")) {
|
||||
return Self::from_data(certificate_bytes, None, passphrase);
|
||||
}
|
||||
let key_bytes = match key {
|
||||
Some(path) => read_identity_file(path)?,
|
||||
None => certificate_bytes.clone(),
|
||||
};
|
||||
// Keep the previous first-private-key rule: unrelated later blocks must not
|
||||
// change which key is selected or whether the caller is prompted.
|
||||
let key = pem::parse_many(&*key_bytes)?
|
||||
.into_iter()
|
||||
.find(|pem| pem.tag().ends_with("PRIVATE KEY"))
|
||||
.ok_or(RequestIdentityError::NoKey)?;
|
||||
let key_pem = Zeroizing::new(pem::encode(&key));
|
||||
let key = if key.tag().ends_with("ENCRYPTED PRIVATE KEY") {
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PEM"))?;
|
||||
let key = PKey::private_key_from_pem_passphrase(key_pem.as_bytes(), passphrase.as_bytes())
|
||||
.map_err(|_| RequestIdentityError::DecryptError("PEM"))?;
|
||||
Zeroizing::new(key.private_key_to_pem_pkcs8()?)
|
||||
} else {
|
||||
Zeroizing::new(key_pem.as_bytes().to_vec())
|
||||
};
|
||||
// Strip private-key blocks before importing the certificate chain: macOS
|
||||
// otherwise imports the same key twice for combined PEM files.
|
||||
let mut certificate = Zeroizing::new(Vec::new());
|
||||
for cert in X509::stack_from_pem(&certificate_bytes)? {
|
||||
certificate.extend(cert.to_pem()?);
|
||||
}
|
||||
let identity = Identity::from_pkcs8_pem(&certificate, &key)?;
|
||||
let key = Zeroizing::new(PKey::private_key_from_pem(&key)?.private_key_to_pem_pkcs8()?);
|
||||
let key = identity_encoding::private_key(&key_bytes, passphrase)?;
|
||||
let certificate = identity_encoding::certificate_chain(&certificate_bytes)?;
|
||||
let identity = pem_request_identity(&certificate, &key)?;
|
||||
Ok(Self {
|
||||
material: Arc::new(IdentityMaterial {
|
||||
certificate,
|
||||
@@ -90,12 +89,21 @@ impl ClientIdentity {
|
||||
passphrase: Option<&str>,
|
||||
) -> anyhow::Result<Self> {
|
||||
let (identity, passphrase) = match &key {
|
||||
Some(key) => (Identity::from_pkcs8_pem(&certificate, key)?, None),
|
||||
Some(key) => (pem_request_identity(&certificate, key)?, None),
|
||||
None => {
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PKCS#12"))?;
|
||||
pkcs12_identity::ensure_complete(&certificate, passphrase.unwrap_or_default())?;
|
||||
// A blank settings field is stored as None. Try the empty password so
|
||||
// passwordless archives work, but keep prompting for protected ones.
|
||||
let identity = Identity::from_pkcs12_der(&certificate, passphrase.unwrap_or_default()).map_err(|error| {
|
||||
if passphrase.is_none() {
|
||||
RequestIdentityError::NoPassphrase("PKCS#12")
|
||||
} else {
|
||||
RequestIdentityError::InvalidPkcs12(error)
|
||||
}
|
||||
})?;
|
||||
(
|
||||
Identity::from_pkcs12_der(&certificate, passphrase)?,
|
||||
Some(Zeroizing::new(passphrase.to_owned())),
|
||||
identity,
|
||||
Some(Zeroizing::new(passphrase.unwrap_or_default().to_owned())),
|
||||
)
|
||||
}
|
||||
};
|
||||
@@ -152,6 +160,20 @@ impl ClientIdentityFiles {
|
||||
}
|
||||
}
|
||||
|
||||
fn pem_request_identity(certificate: &[u8], key: &[u8]) -> anyhow::Result<Identity> {
|
||||
let error_context =
|
||||
"Client certificate and private key cannot be used together. Check that the private key matches the certificate";
|
||||
let identity = Identity::from_pkcs8_pem(certificate, key).context(error_context)?;
|
||||
// Native TLS may defer the certificate/key match check until connector creation.
|
||||
// Build the same client used for requests without making a network connection.
|
||||
reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.identity(identity.clone())
|
||||
.build()
|
||||
.context(error_context)?;
|
||||
Ok(identity)
|
||||
}
|
||||
|
||||
fn read_identity_file(path: &str) -> anyhow::Result<Zeroizing<Vec<u8>>> {
|
||||
Ok(Zeroizing::new(
|
||||
fs::read(path).context("Failed to read client identity")?,
|
||||
@@ -189,50 +211,15 @@ pub fn create_identity(cert: &str, key: Option<&str>, passphrase: Option<&str>)
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use openssl::pkcs12::Pkcs12;
|
||||
|
||||
fn generated_identity() -> (Vec<u8>, Vec<u8>) {
|
||||
use openssl::{asn1::Asn1Time, hash::MessageDigest, rsa::Rsa, x509::X509NameBuilder};
|
||||
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
|
||||
let mut name = X509NameBuilder::new().unwrap();
|
||||
name.append_entry_by_text("CN", "identity-fixture").unwrap();
|
||||
let name = name.build();
|
||||
let mut certificate = X509::builder().unwrap();
|
||||
certificate.set_version(2).unwrap();
|
||||
certificate.set_subject_name(&name).unwrap();
|
||||
certificate.set_issuer_name(&name).unwrap();
|
||||
certificate.set_pubkey(&key).unwrap();
|
||||
certificate
|
||||
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
|
||||
.unwrap();
|
||||
certificate.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
|
||||
certificate.sign(&key, MessageDigest::sha256()).unwrap();
|
||||
(
|
||||
certificate.build().to_pem().unwrap(),
|
||||
key.private_key_to_pem_pkcs8().unwrap(),
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pem_uses_first_private_key_without_prompting_for_later_encrypted_keys() {
|
||||
let (certificate, key) = generated_identity();
|
||||
let encrypted = PKey::private_key_from_pem(&key)
|
||||
.unwrap()
|
||||
.private_key_to_pem_pkcs8_passphrase(openssl::symm::Cipher::aes_256_cbc(), b"unused")
|
||||
.unwrap();
|
||||
let mut source = tempfile::NamedTempFile::new().unwrap();
|
||||
source.write_all(&certificate).unwrap();
|
||||
source.write_all(&key).unwrap();
|
||||
source.write_all(&encrypted).unwrap();
|
||||
let identity = ClientIdentity::load(source.path().to_str().unwrap(), None, None).unwrap();
|
||||
assert_eq!(identity.key_data().unwrap(), key);
|
||||
}
|
||||
const CERTIFICATE: &[u8] = include_bytes!("../../tests/files/client-identity/rsa-cert.pem");
|
||||
const KEY: &[u8] = include_bytes!("../../tests/files/client-identity/rsa-pkcs8.pem");
|
||||
const ENCRYPTED_KEY: &[u8] = include_bytes!("../../tests/files/client-identity/rsa-pbes2-sha256.pem");
|
||||
|
||||
#[test]
|
||||
fn pem_without_key_reports_missing_key_even_with_passphrase() {
|
||||
let (certificate, _) = generated_identity();
|
||||
let mut source = tempfile::NamedTempFile::new().unwrap();
|
||||
source.write_all(&certificate).unwrap();
|
||||
source.write_all(CERTIFICATE).unwrap();
|
||||
for passphrase in [None, Some("unused")] {
|
||||
let error = ClientIdentity::load(source.path().to_str().unwrap(), None, passphrase).unwrap_err();
|
||||
assert!(matches!(
|
||||
@@ -244,249 +231,57 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn local_identity_loading_is_not_limited_by_service_message_size() {
|
||||
let (certificate, key) = generated_identity();
|
||||
let mut source = tempfile::NamedTempFile::new().unwrap();
|
||||
source.write_all(&certificate).unwrap();
|
||||
source.write_all(&key).unwrap();
|
||||
source.write_all(CERTIFICATE).unwrap();
|
||||
source.write_all(KEY).unwrap();
|
||||
source.write_all(&vec![b'\n'; 33 * 1024]).unwrap();
|
||||
let identity = ClientIdentity::load(source.path().to_str().unwrap(), None, None).unwrap();
|
||||
assert_eq!(identity.certificate_data(), certificate);
|
||||
assert_eq!(identity.key_data().unwrap(), key);
|
||||
assert_eq!(identity.certificate_data(), CERTIFICATE);
|
||||
assert_eq!(identity.key_data().unwrap(), KEY);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pem_passphrases_preserve_prompt_errors_and_accept_separate_keys() {
|
||||
let (certificate, key) = generated_identity();
|
||||
let mut cert_file = tempfile::NamedTempFile::new().unwrap();
|
||||
cert_file.write_all(&certificate).unwrap();
|
||||
let mut key_file = tempfile::NamedTempFile::new().unwrap();
|
||||
let encrypted = PKey::private_key_from_pem(&key)
|
||||
.unwrap()
|
||||
.private_key_to_pem_pkcs8_passphrase(openssl::symm::Cipher::aes_256_cbc(), b"correct")
|
||||
.unwrap();
|
||||
key_file.write_all(&encrypted).unwrap();
|
||||
let cert = cert_file.path().to_str().unwrap();
|
||||
let key_path = Some(key_file.path().to_str().unwrap());
|
||||
for (passphrase, missing) in [(None, true), (Some("wrong"), false)] {
|
||||
let error = ClientIdentity::load(cert, key_path, passphrase).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>().unwrap() {
|
||||
RequestIdentityError::NoPassphrase("PEM") => assert!(missing),
|
||||
RequestIdentityError::DecryptError("PEM") => assert!(!missing),
|
||||
other => panic!("Unexpected identity error: {other}"),
|
||||
fn create_identity_preserves_password_errors_and_builds_a_native_request_client() {
|
||||
let mut source = tempfile::NamedTempFile::new().unwrap();
|
||||
source.write_all(CERTIFICATE).unwrap();
|
||||
source.write_all(ENCRYPTED_KEY).unwrap();
|
||||
for (password, missing) in [(None, true), (Some("wrong"), false)] {
|
||||
let error = create_identity(source.path().to_str().unwrap(), None, password).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>() {
|
||||
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
||||
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
||||
other => panic!("Unexpected identity error: {other:?}"),
|
||||
}
|
||||
}
|
||||
let loaded = ClientIdentity::load(cert, key_path, Some("correct")).unwrap();
|
||||
assert_eq!(loaded.key_data().unwrap(), key);
|
||||
fs::write(key_file.path(), &key).unwrap();
|
||||
for passphrase in [None, Some("ignored for unencrypted key")] {
|
||||
assert_eq!(
|
||||
ClientIdentity::load(cert, key_path, passphrase)
|
||||
.unwrap()
|
||||
.key_data()
|
||||
.unwrap(),
|
||||
key
|
||||
);
|
||||
}
|
||||
let identity = create_identity(source.path().to_str().unwrap(), None, Some("fixture-password")).unwrap();
|
||||
drop(source);
|
||||
reqwest::Client::builder().identity(identity).build().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loaded_identity_survives_original_file_replacement_and_owns_private_files() {
|
||||
fn unencrypted_key_ignores_unused_password_and_archive_owned_file_is_private() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let (certificate, key) = generated_identity();
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("combined.pem");
|
||||
let mut combined = certificate.clone();
|
||||
combined.extend(&key);
|
||||
fs::write(&source, &combined).unwrap();
|
||||
let identity = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap();
|
||||
fs::write(&source, "changed after authentication").unwrap();
|
||||
assert_eq!(identity.certificate_data(), certificate);
|
||||
assert_eq!(identity.key_data().unwrap(), key);
|
||||
assert!(!format!("{identity:?}").contains("PRIVATE KEY"));
|
||||
let files = identity.write_files(Some(directory.path())).unwrap();
|
||||
let certificate_path = files.certificate().to_owned();
|
||||
let key_path = files.key().unwrap().to_owned();
|
||||
assert_eq!(fs::read(&certificate_path).unwrap(), certificate);
|
||||
assert_eq!(fs::read(&key_path).unwrap(), key);
|
||||
assert_eq!(fs::metadata(&key_path).unwrap().permissions().mode() & 0o777, 0o600);
|
||||
let identity = ClientIdentity::from_data(
|
||||
Zeroizing::new(CERTIFICATE.to_vec()),
|
||||
Some(Zeroizing::new(KEY.to_vec())),
|
||||
Some("unused password"),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(identity.key_password().is_none());
|
||||
let archive = include_bytes!("../../tests/files/client-identity/modern.p12").to_vec();
|
||||
let identity = ClientIdentity::from_data(Zeroizing::new(archive), None, Some("fixture-password")).unwrap();
|
||||
let files = identity.write_files(None).unwrap();
|
||||
let path = files.certificate().to_owned();
|
||||
assert!(path.ends_with(".p12"));
|
||||
assert!(files.key().is_none());
|
||||
assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
|
||||
drop(files);
|
||||
assert!(!Path::new(&certificate_path).exists());
|
||||
assert!(!Path::new(&key_path).exists());
|
||||
// The request identity remains valid after its original files disappear.
|
||||
fs::remove_file(&source).unwrap();
|
||||
assert!(!Path::new(&path).exists());
|
||||
reqwest::Client::builder()
|
||||
.identity(identity.request_identity())
|
||||
.build()
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pkcs12_preserves_original_data_password_and_owned_native_files() {
|
||||
let (certificate, key) = generated_identity();
|
||||
let certificate = X509::from_pem(&certificate).unwrap();
|
||||
let key = PKey::private_key_from_pem(&key).unwrap();
|
||||
let mut builder = Pkcs12::builder();
|
||||
builder.name("identity-fixture").pkey(&key).cert(&certificate);
|
||||
let encoded = builder.build2("fixture-password").unwrap().to_der().unwrap();
|
||||
for suffix in [".p12", ".pfx"] {
|
||||
let mut source = tempfile::Builder::new().suffix(suffix).tempfile().unwrap();
|
||||
source.write_all(&encoded).unwrap();
|
||||
let path = source.path().to_str().unwrap();
|
||||
assert!(ClientIdentity::load(path, None, None).is_err());
|
||||
assert!(ClientIdentity::load(path, None, Some("wrong")).is_err());
|
||||
// PKCS#12 has always ignored a separately configured key path.
|
||||
let identity = ClientIdentity::load(path, Some("missing-key-file"), Some("fixture-password")).unwrap();
|
||||
fs::write(source.path(), b"replaced after login").unwrap();
|
||||
assert_eq!(identity.certificate_data(), encoded);
|
||||
assert!(identity.key_data().is_none());
|
||||
assert_eq!(identity.key_password(), Some("fixture-password"));
|
||||
assert!(!format!("{identity:?}").contains("fixture-password"));
|
||||
let files = identity.write_files(None).unwrap();
|
||||
assert!(files.certificate().ends_with(".p12"));
|
||||
assert!(files.key().is_none());
|
||||
ClientIdentity::load(files.certificate(), files.key(), identity.key_password()).unwrap();
|
||||
let owned_path = files.certificate().to_owned();
|
||||
drop(files);
|
||||
assert!(!Path::new(&owned_path).exists());
|
||||
}
|
||||
let empty_password = builder.build2("").unwrap().to_der().unwrap();
|
||||
// Empty-password support varies by native backend and PKCS#12 algorithms.
|
||||
// Match the previous native import instead of introducing another parser.
|
||||
let previously_accepted = Identity::from_pkcs12_der(&empty_password, "").is_ok();
|
||||
assert_eq!(
|
||||
ClientIdentity::from_data(Zeroizing::new(empty_password), None, Some("")).is_ok(),
|
||||
previously_accepted
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pkcs12_retains_chain_without_reordering_or_reencoding() {
|
||||
use openssl::{
|
||||
asn1::Asn1Time,
|
||||
hash::MessageDigest,
|
||||
rsa::Rsa,
|
||||
stack::Stack,
|
||||
x509::{X509NameBuilder, extension::BasicConstraints},
|
||||
};
|
||||
fn certificate(
|
||||
name: &str,
|
||||
parent: Option<(&X509, &PKey<openssl::pkey::Private>)>,
|
||||
ca: bool,
|
||||
) -> (X509, PKey<openssl::pkey::Private>) {
|
||||
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
|
||||
let mut subject = X509NameBuilder::new().unwrap();
|
||||
subject.append_entry_by_text("CN", name).unwrap();
|
||||
let subject = subject.build();
|
||||
let mut cert = X509::builder().unwrap();
|
||||
cert.set_version(2).unwrap();
|
||||
let serial = openssl::bn::BigNum::from_u32(name.len() as u32)
|
||||
.unwrap()
|
||||
.to_asn1_integer()
|
||||
.unwrap();
|
||||
cert.set_serial_number(&serial).unwrap();
|
||||
cert.set_subject_name(&subject).unwrap();
|
||||
cert
|
||||
.set_issuer_name(parent.map(|(cert, _)| cert.subject_name()).unwrap_or(&subject))
|
||||
.unwrap();
|
||||
cert.set_pubkey(&key).unwrap();
|
||||
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
|
||||
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
|
||||
if ca {
|
||||
cert
|
||||
.append_extension(BasicConstraints::new().critical().ca().build().unwrap())
|
||||
.unwrap();
|
||||
}
|
||||
cert
|
||||
.sign(parent.map(|(_, key)| key).unwrap_or(&key), MessageDigest::sha256())
|
||||
.unwrap();
|
||||
(cert.build(), key)
|
||||
}
|
||||
let (root, root_key) = certificate("root", None, true);
|
||||
let (intermediate, intermediate_key) = certificate("intermediate", Some((&root, &root_key)), true);
|
||||
let (leaf, key) = certificate("client", Some((&intermediate, &intermediate_key)), false);
|
||||
// This is the reverse CA stack consumed by the previous native-tls path.
|
||||
let mut ca = Stack::new().unwrap();
|
||||
ca.push(root.clone()).unwrap();
|
||||
ca.push(intermediate.clone()).unwrap();
|
||||
let mut builder = Pkcs12::builder();
|
||||
builder.name("chain-fixture").pkey(&key).cert(&leaf).ca(ca);
|
||||
let encoded = builder.build2("fixture-password").unwrap().to_der().unwrap();
|
||||
let mut source = tempfile::Builder::new().suffix(".p12").tempfile().unwrap();
|
||||
source.write_all(&encoded).unwrap();
|
||||
let identity = ClientIdentity::load(source.path().to_str().unwrap(), None, Some("fixture-password")).unwrap();
|
||||
assert_eq!(identity.certificate_data(), encoded);
|
||||
assert!(identity.key_data().is_none());
|
||||
ClientIdentity::from_data(
|
||||
Zeroizing::new(identity.certificate_data().to_vec()),
|
||||
None,
|
||||
identity.key_password(),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_identity_from_pem_requires_passphrase() {
|
||||
let cert = "tests/files/badssl.com-client.pem";
|
||||
let identity = create_identity(cert, None, None);
|
||||
|
||||
assert!(identity.is_err());
|
||||
assert!(identity.unwrap_err().to_string().contains("No passphrase provided"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn create_identity_from_pem_with_passphrase() {
|
||||
let cert = "tests/files/badssl.com-client.pem";
|
||||
let passphrase = "badssl.com";
|
||||
|
||||
let identity = create_identity(cert, None, Some(passphrase));
|
||||
|
||||
assert!(identity.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn create_identity_from_pem_unencrypted_key() {
|
||||
let cert = "tests/files/badssl.com-client-unencrypted.pem";
|
||||
let identity = create_identity(cert, None, None);
|
||||
println!("{:?}", identity);
|
||||
|
||||
assert!(identity.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn create_identity_from_pem_cert_and_encrypted_key() {
|
||||
let cert = "tests/files/badssl.com-client.pem";
|
||||
let key = "tests/files/badssl.com-client.pem";
|
||||
let passphrase = "badssl.com";
|
||||
|
||||
let identity = create_identity(cert, Some(key), Some(passphrase));
|
||||
|
||||
assert!(identity.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_identity_from_pem_cert_and_encrypted_key_no_passphrase() {
|
||||
let cert = "tests/files/badssl.com-client.pem";
|
||||
let key = "tests/files/badssl.com-client.pem";
|
||||
|
||||
let identity = create_identity(cert, Some(key), None);
|
||||
|
||||
assert!(identity.is_err());
|
||||
assert!(identity.unwrap_err().to_string().contains("No passphrase provided"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn create_identity_from_pem_cert_and_unencrypted_key() {
|
||||
let cert = "tests/files/badssl.com-client.pem";
|
||||
let key = "tests/files/badssl.com-client-unencrypted.pem";
|
||||
|
||||
let identity = create_identity(cert, Some(key), None);
|
||||
|
||||
assert!(identity.is_ok());
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
use pkcs8::SecretDocument;
|
||||
|
||||
use super::{identity_encoding::TraditionalKeyFormat, request::RequestIdentityError};
|
||||
|
||||
pub(super) fn normalize(
|
||||
_bytes: &[u8],
|
||||
format: TraditionalKeyFormat,
|
||||
_passphrase: Option<&str>,
|
||||
) -> anyhow::Result<SecretDocument> {
|
||||
Err(
|
||||
match format {
|
||||
TraditionalKeyFormat::EncryptedPem => RequestIdentityError::UnsupportedEncryption,
|
||||
TraditionalKeyFormat::PlainPem | TraditionalKeyFormat::Sec1Der => RequestIdentityError::UnsupportedKeyFormat,
|
||||
}
|
||||
.into(),
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
use openssl::{
|
||||
error::ErrorStack,
|
||||
pkey::{Id, PKey},
|
||||
};
|
||||
use pkcs8::SecretDocument;
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
use super::{identity_encoding::TraditionalKeyFormat, request::RequestIdentityError};
|
||||
|
||||
pub(super) fn normalize(
|
||||
bytes: &[u8],
|
||||
format: TraditionalKeyFormat,
|
||||
passphrase: Option<&str>,
|
||||
) -> anyhow::Result<SecretDocument> {
|
||||
let key = match format {
|
||||
TraditionalKeyFormat::Sec1Der => PKey::private_key_from_der(bytes),
|
||||
TraditionalKeyFormat::PlainPem => PKey::private_key_from_pem_passphrase(bytes, b""),
|
||||
TraditionalKeyFormat::EncryptedPem => {
|
||||
let passphrase = passphrase.ok_or(RequestIdentityError::NoPassphrase("PEM"))?;
|
||||
anyhow::ensure!(
|
||||
!passphrase.as_bytes().contains(&0),
|
||||
"Private key passphrases containing NUL are not supported"
|
||||
);
|
||||
PKey::private_key_from_pem_passphrase(bytes, passphrase.as_bytes())
|
||||
}
|
||||
}
|
||||
.map_err(import_error)?;
|
||||
if !matches!(key.id(), Id::RSA | Id::EC) {
|
||||
return Err(RequestIdentityError::UnsupportedKeyFormat.into());
|
||||
}
|
||||
let der = Zeroizing::new(
|
||||
key
|
||||
.private_key_to_pkcs8()
|
||||
.map_err(|_| RequestIdentityError::InvalidKey)?,
|
||||
);
|
||||
Ok(SecretDocument::try_from(der.as_slice()).map_err(|_| RequestIdentityError::InvalidKey)?)
|
||||
}
|
||||
|
||||
fn import_error(error: ErrorStack) -> RequestIdentityError {
|
||||
// Inspect only known backend reasons. Never expose the native error stack or
|
||||
// turn an unclassified decoder failure into a password retry loop.
|
||||
if error.errors().iter().any(|error| error.reason() == Some("bad decrypt")) {
|
||||
RequestIdentityError::DecryptError("PEM")
|
||||
} else if error.errors().iter().any(|error| error.reason() == Some("unsupported")) {
|
||||
RequestIdentityError::UnsupportedEncryption
|
||||
} else {
|
||||
RequestIdentityError::InvalidKey
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,708 @@
|
||||
//! Public identity compatibility and native import behavior.
|
||||
use std::{fs, path::PathBuf};
|
||||
|
||||
use gpapi::utils::request::{ClientIdentity, RequestIdentityError};
|
||||
|
||||
const PASSWORD: &str = "fixture-password";
|
||||
|
||||
fn fixture(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("tests/files/client-identity")
|
||||
.join(name)
|
||||
}
|
||||
|
||||
fn load(certificate: &str, key: &str, password: Option<&str>) -> anyhow::Result<ClientIdentity> {
|
||||
ClientIdentity::load(
|
||||
fixture(certificate).to_str().unwrap(),
|
||||
Some(fixture(key).to_str().unwrap()),
|
||||
password,
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rsa_pkcs8_loads_without_a_password() {
|
||||
let identity = load("rsa-cert.pem", "rsa-pkcs8.pem", None).unwrap();
|
||||
assert_eq!(identity.certificate_data(), fs::read(fixture("rsa-cert.pem")).unwrap());
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
assert!(identity.key_password().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ec_pkcs8_records_native_import_compatibility() {
|
||||
let result = load("ec-cert.pem", "ec-pkcs8.pem", None);
|
||||
if cfg!(target_os = "macos") {
|
||||
// Apple native-tls import currently rejects this P-256 PKCS#8 fixture.
|
||||
assert!(
|
||||
result
|
||||
.unwrap_err()
|
||||
.downcast_ref::<reqwest::Error>()
|
||||
.unwrap()
|
||||
.is_builder()
|
||||
);
|
||||
} else {
|
||||
assert_eq!(
|
||||
result.unwrap().key_data().unwrap(),
|
||||
fs::read(fixture("ec-pkcs8.pem")).unwrap()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encrypted_pkcs8_keys_normalize_to_the_same_private_key() {
|
||||
for (key, expected, certificate) in [
|
||||
("rsa-pbes2-sha1.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-sha256.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-aes-128-cbc-sha1.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-aes-128-cbc-sha256.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-aes-192-cbc-sha1.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-aes-192-cbc-sha256.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("rsa-pbes2-scrypt.pem", "rsa-pkcs8.pem", "rsa-cert.pem"),
|
||||
("ec-pbes2.pem", "ec-pkcs8.pem", "ec-cert.pem"),
|
||||
] {
|
||||
let result = load(certificate, key, Some(PASSWORD));
|
||||
if cfg!(target_os = "macos") && certificate == "ec-cert.pem" {
|
||||
assert!(
|
||||
result
|
||||
.unwrap_err()
|
||||
.downcast_ref::<reqwest::Error>()
|
||||
.unwrap()
|
||||
.is_builder()
|
||||
);
|
||||
} else {
|
||||
let identity = result.unwrap_or_else(|error| panic!("{key}: {error}"));
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture(expected)).unwrap(),
|
||||
"{key}"
|
||||
);
|
||||
assert!(identity.key_password().is_none());
|
||||
}
|
||||
for (password, missing) in [(None, true), (Some("incorrect"), false)] {
|
||||
let error = load(certificate, key, password).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>() {
|
||||
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
||||
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
||||
other => panic!("{key}: unexpected error {other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combined_pem_preserves_the_certificate_chain_and_removes_key_blocks() {
|
||||
let mut chain = fs::read(fixture("rsa-cert.pem")).unwrap();
|
||||
chain.extend(fs::read(fixture("root.pem")).unwrap());
|
||||
let mut combined = chain.clone();
|
||||
let key = fs::read(fixture("rsa-pkcs8.pem")).unwrap();
|
||||
combined.extend(&key);
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("combined.pem");
|
||||
fs::write(&source, combined).unwrap();
|
||||
let identity = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap();
|
||||
assert_eq!(identity.certificate_data(), chain);
|
||||
assert_eq!(identity.key_data().unwrap(), key);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rsa_pkcs1_normalizes_to_pkcs8_in_separate_and_combined_files() {
|
||||
let certificate = fs::read(fixture("rsa-cert.pem")).unwrap();
|
||||
let expected = fs::read(fixture("rsa-pkcs8.pem")).unwrap();
|
||||
for password in [None, Some("unused")] {
|
||||
let identity = load("rsa-cert.pem", "rsa-pkcs1.pem", password).unwrap();
|
||||
assert_eq!(identity.certificate_data(), certificate);
|
||||
assert_eq!(identity.key_data().unwrap(), expected);
|
||||
assert!(identity.key_password().is_none());
|
||||
}
|
||||
|
||||
let mut combined = certificate.clone();
|
||||
combined.extend(fs::read(fixture("rsa-pkcs1.pem")).unwrap());
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("combined.pem");
|
||||
fs::write(&source, combined).unwrap();
|
||||
let identity = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap();
|
||||
assert_eq!(identity.certificate_data(), certificate);
|
||||
assert_eq!(identity.key_data().unwrap(), expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_rsa_pkcs1_is_rejected_by_native_import() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("invalid-key.pem");
|
||||
fs::write(&source, pem::encode(&pem::Pem::new("RSA PRIVATE KEY", vec![0x30, 0]))).unwrap();
|
||||
let error = ClientIdentity::load(
|
||||
fixture("rsa-cert.pem").to_str().unwrap(),
|
||||
Some(source.to_str().unwrap()),
|
||||
None,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(error.downcast_ref::<reqwest::Error>().is_some());
|
||||
}
|
||||
|
||||
fn check_archive(name: &str, password: &str) {
|
||||
let source = fixture(name);
|
||||
let path = source.to_str().unwrap();
|
||||
let identity = ClientIdentity::load(path, None, Some(password)).unwrap();
|
||||
assert_eq!(identity.certificate_data(), fs::read(&source).unwrap());
|
||||
assert!(identity.key_data().is_none());
|
||||
assert_eq!(identity.key_password(), Some(password));
|
||||
let files = identity.write_files(None).unwrap();
|
||||
ClientIdentity::load(files.certificate(), files.key(), identity.key_password()).unwrap();
|
||||
assert!(ClientIdentity::load(path, None, Some("incorrect")).is_err());
|
||||
let error = ClientIdentity::load(path, None, None).unwrap_err();
|
||||
assert!(matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::NoPassphrase("PKCS#12"))
|
||||
));
|
||||
// The MAC is at the end of these fixtures. Change authenticated archive data
|
||||
// (a byte in the friendly name), leaving valid ASN.1 and ciphertext intact.
|
||||
let mut corrupted = fs::read(&source).unwrap();
|
||||
let label = [0, b'f', 0, b'i', 0, b'x', 0, b't', 0, b'u', 0, b'r', 0, b'e'];
|
||||
let offset = corrupted
|
||||
.windows(label.len())
|
||||
.position(|window| window == label)
|
||||
.unwrap();
|
||||
corrupted[offset + 1] = b'F';
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let damaged = directory.path().join("damaged.p12");
|
||||
fs::write(&damaged, corrupted).unwrap();
|
||||
assert!(ClientIdentity::load(damaged.to_str().unwrap(), None, Some(password)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incomplete_pkcs12_reports_that_both_certificate_and_key_are_required() {
|
||||
for name in ["certificate-only.pfx", "key-only.pfx"] {
|
||||
let bytes = fs::read(fixture(name)).unwrap();
|
||||
for result in [
|
||||
ClientIdentity::load(fixture(name).to_str().unwrap(), None, Some(PASSWORD)),
|
||||
ClientIdentity::from_data(zeroize::Zeroizing::new(bytes.clone()), None, Some(PASSWORD)),
|
||||
] {
|
||||
let error = result.unwrap_err();
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"The PKCS#12 file must contain both a client certificate and its private key",
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn modern_pkcs12_checks_password_and_archive_integrity() {
|
||||
check_archive("modern.p12", PASSWORD);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pkcs12_password_errors_explain_how_to_recover() {
|
||||
let archive = fs::read(fixture("modern.p12")).unwrap();
|
||||
for password in ["incorrect", ""] {
|
||||
let errors = [
|
||||
ClientIdentity::load(fixture("modern.p12").to_str().unwrap(), None, Some(password)).unwrap_err(),
|
||||
ClientIdentity::from_data(zeroize::Zeroizing::new(archive.clone()), None, Some(password)).unwrap_err(),
|
||||
];
|
||||
for error in errors {
|
||||
assert!(matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::InvalidPkcs12(_))
|
||||
));
|
||||
let message = error.to_string();
|
||||
assert!(message.contains("PKCS#12"), "{message}");
|
||||
assert!(message.contains("password") && message.contains("file"), "{message}");
|
||||
assert!(!format!("{error:?}").contains("incorrect"));
|
||||
assert!(error.chain().any(|cause| cause.is::<reqwest::Error>()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
// Apple's native importer rejects this empty-password fixture; its native
|
||||
// compatibility decision is covered by archive_snapshot_and_pfx_preserve_native_import_contract.
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn empty_pkcs12_password_survives_loading_and_transport() {
|
||||
let archive = fs::read(fixture("empty-password.p12")).unwrap();
|
||||
for password in [None, Some("")] {
|
||||
let loaded = ClientIdentity::load(fixture("empty-password.p12").to_str().unwrap(), None, password).unwrap();
|
||||
assert_eq!(loaded.key_password(), Some(""));
|
||||
let restored = ClientIdentity::from_data(zeroize::Zeroizing::new(archive.clone()), None, password).unwrap();
|
||||
assert_eq!(restored.key_password(), Some(""));
|
||||
let files = restored.write_files(None).unwrap();
|
||||
ClientIdentity::load(files.certificate(), files.key(), restored.key_password()).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pkcs12_accepts_non_ascii_passwords() {
|
||||
check_archive("unicode-password.p12", "pässword-密码");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_rc2_pkcs12_checks_password_and_archive_integrity() {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
if std::env::var_os("GP_IDENTITY_LEGACY_TEST_CHILD").is_none() {
|
||||
// OpenSSL providers are process-global. Exercise the existing legacy-mode
|
||||
// configuration in an isolated process, without affecting parallel tests.
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let config = directory.path().join("openssl.cnf");
|
||||
fs::write(&config, gpapi::utils::openssl::openssl_conf()).unwrap();
|
||||
let status = std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args([
|
||||
"--exact",
|
||||
"legacy_rc2_pkcs12_checks_password_and_archive_integrity",
|
||||
"--nocapture",
|
||||
])
|
||||
.env("OPENSSL_CONF", config)
|
||||
.env("GP_IDENTITY_LEGACY_TEST_CHILD", "1")
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(status.success());
|
||||
return;
|
||||
}
|
||||
check_archive("legacy-rc2.p12", PASSWORD);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_certificate_and_private_key_data_are_rejected() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let invalid = directory.path().join("invalid.pem");
|
||||
fs::write(&invalid, b"not a certificate or private key").unwrap();
|
||||
assert!(
|
||||
ClientIdentity::load(
|
||||
invalid.to_str().unwrap(),
|
||||
Some(fixture("rsa-pkcs8.pem").to_str().unwrap()),
|
||||
None,
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
let error = ClientIdentity::load(
|
||||
fixture("rsa-cert.pem").to_str().unwrap(),
|
||||
Some(invalid.to_str().unwrap()),
|
||||
None,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::InvalidKey)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pbes2_legacy_ciphers_remain_supported() {
|
||||
for key in ["rsa-pbes2-des3-sha1.pem", "rsa-pbes2-des3-sha256.pem"] {
|
||||
let identity = load("rsa-cert.pem", key, Some(PASSWORD)).unwrap();
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
for (password, missing) in [(None, true), (Some("incorrect"), false)] {
|
||||
let error = load("rsa-cert.pem", key, password).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>() {
|
||||
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
||||
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
||||
other => panic!("{key}: unexpected error {other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_pkcs8_conversion_preserves_the_key_and_password_errors() {
|
||||
let identity = load("rsa-cert.pem", "rsa-pbes1-3des.pem", Some(PASSWORD)).unwrap();
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
assert!(identity.key_password().is_none());
|
||||
for (password, missing) in [(None, true), (Some("incorrect"), false)] {
|
||||
let error = load("rsa-cert.pem", "rsa-pbes1-3des.pem", password).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>() {
|
||||
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
||||
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
||||
other => panic!("unexpected legacy password error: {other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn legacy_pkcs8_matches_previous_linux_openssl_processing() {
|
||||
let encrypted = fs::read(fixture("rsa-pbes1-3des.pem")).unwrap();
|
||||
let previous = openssl::pkey::PKey::private_key_from_pem_passphrase(&encrypted, PASSWORD.as_bytes())
|
||||
.unwrap()
|
||||
.private_key_to_pem_pkcs8()
|
||||
.unwrap();
|
||||
let identity = load("rsa-cert.pem", "rsa-pbes1-3des.pem", Some(PASSWORD)).unwrap();
|
||||
assert_eq!(identity.key_data().unwrap(), previous);
|
||||
assert!(openssl::pkey::PKey::private_key_from_pem_passphrase(&encrypted, b"incorrect").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_pkcs8_converter_failures_are_terminal_and_modern_keys_need_no_executable() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
const CHILD: &str = "GP_LEGACY_CONVERTER_TEST";
|
||||
if let Ok(case) = std::env::var(CHILD) {
|
||||
let started = std::time::Instant::now();
|
||||
let error = load("rsa-cert.pem", "rsa-pbes1-3des.pem", Some(PASSWORD)).unwrap_err();
|
||||
assert!(
|
||||
started.elapsed() < std::time::Duration::from_secs(12),
|
||||
"conversion exceeded its deadline"
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::LegacyKeyConversion(_))
|
||||
),
|
||||
"{error:?}"
|
||||
);
|
||||
let message = format!("{error:?}");
|
||||
assert!(message.contains("Convert the key to modern PKCS#8"));
|
||||
assert!(!message.contains(PASSWORD));
|
||||
assert!(!message.contains("PRIVATE KEY"));
|
||||
if case == "missing" {
|
||||
assert!(message.contains("unavailable"));
|
||||
} else if case.starts_with("timeout") {
|
||||
assert!(message.contains("timed out"));
|
||||
}
|
||||
for key in ["rsa-pkcs8.pem", "rsa-pbes2-sha256.pem"] {
|
||||
let identity = load("rsa-cert.pem", key, Some(PASSWORD)).unwrap();
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// PATH is process-global; isolate executable discovery from parallel tests.
|
||||
for (case, script) in [
|
||||
("missing", None),
|
||||
(
|
||||
"unsupported",
|
||||
Some("#!/bin/sh\nprintf 'unsupported: fixture-password PRIVATE KEY' >&2\nexit 1\n"),
|
||||
),
|
||||
("invalid-output", Some("#!/bin/sh\nprintf 'invalid converted key'\n")),
|
||||
("timeout-wrapper", Some("#!/bin/sh\n/bin/sleep 14\n")),
|
||||
("timeout-exited-wrapper", Some("#!/bin/sh\n/bin/sleep 14 &\nexit 0\n")),
|
||||
] {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
if let Some(script) = script {
|
||||
let executable = directory.path().join("openssl");
|
||||
fs::write(&executable, script).unwrap();
|
||||
fs::set_permissions(executable, fs::Permissions::from_mode(0o700)).unwrap();
|
||||
}
|
||||
let status = std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args([
|
||||
"--exact",
|
||||
"legacy_pkcs8_converter_failures_are_terminal_and_modern_keys_need_no_executable",
|
||||
"--nocapture",
|
||||
])
|
||||
.env("PATH", directory.path())
|
||||
.env(CHILD, case)
|
||||
.status()
|
||||
.unwrap();
|
||||
assert!(status.success(), "converter case: {case}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_converter_reports_its_password_length_limit_without_requesting_a_retry() {
|
||||
let password = "x".repeat(1024);
|
||||
let encrypted = fs::read(fixture("rsa-pbes1-3des-password-1024.pem")).unwrap();
|
||||
// The previous linked API accepted this boundary. The CLI cannot carry it;
|
||||
// report that limitation rather than calling the correct password wrong.
|
||||
openssl::pkey::PKey::private_key_from_pem_passphrase(&encrypted, password.as_bytes()).unwrap();
|
||||
let error = load("rsa-cert.pem", "rsa-pbes1-3des-password-1024.pem", Some(&password)).unwrap_err();
|
||||
assert!(
|
||||
matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::LegacyKeyConversion(_))
|
||||
),
|
||||
"{error:?}"
|
||||
);
|
||||
assert!(error.to_string().contains("1023-byte"));
|
||||
let accepted = load(
|
||||
"rsa-cert.pem",
|
||||
"rsa-pbes1-3des-password-1023.pem",
|
||||
Some(&"x".repeat(1023)),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
accepted.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_conversion_keeps_original_files_and_rejects_line_breaks_in_passwords() {
|
||||
let original = fs::read(fixture("rsa-pbes1-3des.pem")).unwrap();
|
||||
for password in [
|
||||
PASSWORD,
|
||||
"incorrect",
|
||||
"password\nsecond line",
|
||||
"password\r",
|
||||
"password\0",
|
||||
] {
|
||||
let result = load("rsa-cert.pem", "rsa-pbes1-3des.pem", Some(password));
|
||||
if password == PASSWORD {
|
||||
result.unwrap();
|
||||
} else if password != "incorrect" {
|
||||
assert!(matches!(
|
||||
result.unwrap_err().downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::LegacyKeyConversion(_))
|
||||
));
|
||||
} else {
|
||||
assert!(matches!(
|
||||
result.unwrap_err().downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::DecryptError("PEM"))
|
||||
));
|
||||
}
|
||||
assert_eq!(fs::read(fixture("rsa-pbes1-3des.pem")).unwrap(), original);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_key_selection_controls_password_prompt_and_ignores_later_keys() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("combined.pem");
|
||||
let certificate = fs::read(fixture("rsa-cert.pem")).unwrap();
|
||||
let plain = fs::read(fixture("rsa-pkcs8.pem")).unwrap();
|
||||
let encrypted = fs::read(fixture("rsa-pbes2-sha256.pem")).unwrap();
|
||||
for (first, second, needs_password) in [(&plain, &encrypted, false), (&encrypted, &plain, true)] {
|
||||
let mut combined = certificate.clone();
|
||||
combined.extend(first);
|
||||
combined.extend(second);
|
||||
fs::write(&source, combined).unwrap();
|
||||
if needs_password {
|
||||
let error = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap_err();
|
||||
assert!(matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::NoPassphrase("PEM"))
|
||||
));
|
||||
}
|
||||
let identity = ClientIdentity::load(
|
||||
source.to_str().unwrap(),
|
||||
None,
|
||||
if needs_password { Some(PASSWORD) } else { None },
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(identity.key_data().unwrap(), plain);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepared_pem_round_trip_retains_snapshot_and_private_file_lifecycle() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use zeroize::Zeroizing;
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("identity.pem");
|
||||
let mut combined = fs::read(fixture("rsa-cert.pem")).unwrap();
|
||||
combined.extend(fs::read(fixture("rsa-pkcs8.pem")).unwrap());
|
||||
fs::write(&source, combined).unwrap();
|
||||
let loaded = ClientIdentity::load(source.to_str().unwrap(), None, None).unwrap();
|
||||
let snapshot = ClientIdentity::from_data(
|
||||
Zeroizing::new(loaded.certificate_data().to_vec()),
|
||||
Some(Zeroizing::new(loaded.key_data().unwrap().to_vec())),
|
||||
Some("unused-pem-password"),
|
||||
)
|
||||
.unwrap();
|
||||
fs::write(&source, b"replaced after authentication").unwrap();
|
||||
drop(loaded);
|
||||
let clone = snapshot.clone();
|
||||
drop(snapshot);
|
||||
assert!(clone.key_password().is_none());
|
||||
let debug = format!("{clone:?}");
|
||||
assert!(debug.contains("<redacted>"));
|
||||
assert!(!debug.contains("PRIVATE KEY"));
|
||||
assert!(!debug.contains("unused-pem-password"));
|
||||
let files = clone.write_files(Some(directory.path())).unwrap();
|
||||
let certificate = PathBuf::from(files.certificate());
|
||||
let key = PathBuf::from(files.key().unwrap());
|
||||
for path in [&certificate, &key] {
|
||||
assert_eq!(fs::metadata(path).unwrap().permissions().mode() & 0o777, 0o600);
|
||||
}
|
||||
assert_eq!(fs::read(&certificate).unwrap(), clone.certificate_data());
|
||||
assert_eq!(fs::read(&key).unwrap(), clone.key_data().unwrap());
|
||||
ClientIdentity::load(files.certificate(), files.key(), None).unwrap();
|
||||
drop(files);
|
||||
assert!(!certificate.exists() && !key.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn archive_snapshot_and_pfx_preserve_native_import_contract() {
|
||||
use zeroize::Zeroizing;
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let path = directory.path().join("identity.pfx");
|
||||
let data = fs::read(fixture("modern.p12")).unwrap();
|
||||
fs::write(&path, &data).unwrap();
|
||||
let identity = ClientIdentity::load(path.to_str().unwrap(), Some("nonexistent-key"), Some(PASSWORD)).unwrap();
|
||||
fs::remove_file(path).unwrap();
|
||||
let restored = ClientIdentity::from_data(
|
||||
Zeroizing::new(identity.certificate_data().to_vec()),
|
||||
None,
|
||||
identity.key_password(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(restored.certificate_data(), data);
|
||||
assert_eq!(restored.key_password(), Some(PASSWORD));
|
||||
assert!(restored.key_data().is_none());
|
||||
assert!(!format!("{restored:?}").contains(PASSWORD));
|
||||
let empty = fs::read(fixture("empty-password.p12")).unwrap();
|
||||
// Preserve the native backend's existing empty-password decision.
|
||||
let expected = reqwest::Identity::from_pkcs12_der(&empty, "").is_ok();
|
||||
assert_eq!(
|
||||
ClientIdentity::from_data(Zeroizing::new(empty), None, Some("")).is_ok(),
|
||||
expected
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_certificate_der_and_private_key_der_are_rejected_without_secret_output() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let invalid = directory.path().join("invalid.pem");
|
||||
for (tag, invalid_certificate) in [("CERTIFICATE", true), ("PRIVATE KEY", false)] {
|
||||
let invalid_der = b"secret-invalid-der-material";
|
||||
fs::write(&invalid, pem::encode(&pem::Pem::new(tag, invalid_der))).unwrap();
|
||||
let result = if invalid_certificate {
|
||||
ClientIdentity::load(
|
||||
invalid.to_str().unwrap(),
|
||||
Some(fixture("rsa-pkcs8.pem").to_str().unwrap()),
|
||||
None,
|
||||
)
|
||||
} else {
|
||||
ClientIdentity::load(
|
||||
fixture("rsa-cert.pem").to_str().unwrap(),
|
||||
Some(invalid.to_str().unwrap()),
|
||||
None,
|
||||
)
|
||||
};
|
||||
let error = result.unwrap_err();
|
||||
for message in [error.to_string(), format!("{error:?}")] {
|
||||
assert!(!message.contains("secret-invalid-der-material"));
|
||||
assert!(!message.contains("c2VjcmV0LWludmFsaWQtZGVyLW1hdGVyaWFs"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pbes2_des_remains_supported_without_native_legacy_provider() {
|
||||
let identity = load("rsa-cert.pem", "rsa-pbes2-des.pem", Some(PASSWORD)).unwrap();
|
||||
assert_eq!(
|
||||
identity.key_data().unwrap(),
|
||||
fs::read(fixture("rsa-pkcs8.pem")).unwrap()
|
||||
);
|
||||
for (password, missing) in [(None, true), (Some("incorrect"), false)] {
|
||||
let error = load("rsa-cert.pem", "rsa-pbes2-des.pem", password).unwrap_err();
|
||||
match error.downcast_ref::<RequestIdentityError>() {
|
||||
Some(RequestIdentityError::NoPassphrase("PEM")) => assert!(missing),
|
||||
Some(RequestIdentityError::DecryptError("PEM")) => assert!(!missing),
|
||||
other => panic!("unexpected error {other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_unsupported_pbes2_algorithm(oid_der: &[u8]) {
|
||||
let mut encrypted = pem::parse(fs::read(fixture("rsa-pbes2-sha256.pem")).unwrap()).unwrap();
|
||||
let mut der = encrypted.contents().to_vec();
|
||||
let matches: Vec<_> = der
|
||||
.windows(oid_der.len())
|
||||
.enumerate()
|
||||
.filter_map(|(offset, window)| (window == oid_der).then_some(offset))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
matches.len(),
|
||||
1,
|
||||
"the fixture must contain exactly the intended algorithm OID"
|
||||
);
|
||||
// An unknown OID in the same arc preserves ASN.1 structure and algorithm
|
||||
// parameters, isolating algorithm recognition from malformed DER handling.
|
||||
der[matches[0] + oid_der.len() - 1] = 0x7f;
|
||||
encrypted = pem::Pem::new(encrypted.tag(), der);
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("unsupported.pem");
|
||||
fs::write(&source, pem::encode(&encrypted)).unwrap();
|
||||
for password in [None, Some(PASSWORD), Some("incorrect")] {
|
||||
let error = ClientIdentity::load(
|
||||
fixture("rsa-cert.pem").to_str().unwrap(),
|
||||
Some(source.to_str().unwrap()),
|
||||
password,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::UnsupportedEncryption)
|
||||
));
|
||||
let message = error.to_string().to_lowercase();
|
||||
assert!(
|
||||
message.contains("unsupported") && message.contains("encryption"),
|
||||
"{message}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_pbes2_kdf_is_identified_before_password_prompt() {
|
||||
// PBKDF2, 1.2.840.113549.1.5.12.
|
||||
assert_unsupported_pbes2_algorithm(&[0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_pbes2_cipher_is_identified_before_password_prompt() {
|
||||
// AES256-CBC, 2.16.840.1.101.3.4.1.42.
|
||||
assert_unsupported_pbes2_algorithm(&[0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x2a]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_pbes2_prf_is_identified_before_password_prompt() {
|
||||
// HMAC-SHA256, 1.2.840.113549.2.9.
|
||||
assert_unsupported_pbes2_algorithm(&[0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x09]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_encrypted_pkcs8_does_not_request_a_password_or_expose_material() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let source = directory.path().join("malformed.pem");
|
||||
fs::write(
|
||||
&source,
|
||||
pem::encode(&pem::Pem::new(
|
||||
"ENCRYPTED PRIVATE KEY",
|
||||
b"secret-malformed-encrypted-key",
|
||||
)),
|
||||
)
|
||||
.unwrap();
|
||||
for password in [None, Some(PASSWORD), Some("incorrect")] {
|
||||
let error = ClientIdentity::load(
|
||||
fixture("rsa-cert.pem").to_str().unwrap(),
|
||||
Some(source.to_str().unwrap()),
|
||||
password,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(!matches!(
|
||||
error.downcast_ref::<RequestIdentityError>(),
|
||||
Some(RequestIdentityError::NoPassphrase(_) | RequestIdentityError::DecryptError(_))
|
||||
));
|
||||
for message in [error.to_string(), format!("{error:?}")] {
|
||||
assert!(!message.contains("secret-malformed-encrypted-key"));
|
||||
assert!(!message.contains("c2VjcmV0LW1hbGZvcm1lZC1lbmNyeXB0ZWQta2V5"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mismatched_certificate_key_is_rejected_before_request_client_creation() {
|
||||
let certificate = fs::read(fixture("root.pem")).unwrap();
|
||||
let key = fs::read(fixture("rsa-pkcs8.pem")).unwrap();
|
||||
let error = load("root.pem", "rsa-pkcs8.pem", None).unwrap_err();
|
||||
assert!(
|
||||
error
|
||||
.to_string()
|
||||
.contains("Check that the private key matches the certificate")
|
||||
);
|
||||
let error = ClientIdentity::from_data(certificate.into(), Some(key.into()), None).unwrap_err();
|
||||
assert!(
|
||||
error
|
||||
.to_string()
|
||||
.contains("Check that the private key matches the certificate")
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
# Public client identity fixtures
|
||||
|
||||
These generated keys and certificates are **public test data**, never production
|
||||
credentials. Passwords are `fixture-password`, except `unicode-password.p12`,
|
||||
which uses `pässword-密码`, and the `rsa-pbes1-3des-password-{1023,1024}.pem`
|
||||
fixtures, which use `x` repeated the indicated number of bytes.
|
||||
|
||||
Regenerate intentionally with OpenSSL 3:
|
||||
|
||||
```sh
|
||||
OPENSSL_BIN=/path/to/openssl bash generate.sh
|
||||
```
|
||||
|
||||
Generation is random; it replaces the keys, certificates, and archives together.
|
||||
The test runner reads checked-in files. Legacy standalone conversion tests
|
||||
require an `openssl` executable on PATH (OpenSSL or compatible LibreSSL).
|
||||
No fixture generation is needed to run the tests.
|
||||
|
||||
| Files | Contents |
|
||||
| --- | --- |
|
||||
| `root.pem`, `rsa-cert.pem`, `ec-cert.pem` | Test root and issued RSA-2048 / P-256 client certificates, SHA256 signatures |
|
||||
| `rsa-pkcs8.pem`, `ec-pkcs8.pem` | Plain PKCS#8 keys; expected normalized output |
|
||||
| `rsa-pkcs1.pem`, `ec-sec1.pem` | Same keys in traditional containers |
|
||||
| `{rsa,ec}-traditional-{aes128,aes192,aes256,des3}.pem` | Traditional encrypted PEM with AES-CBC or 3DES-CBC; password `fixture-password` |
|
||||
| `rsa-pbes2-sha1.pem`, `rsa-pbes2-sha256.pem` | Encrypted PKCS#8, AES256-CBC/PBKDF2 with SHA1 or SHA256 PRF |
|
||||
| `rsa-pbes2-aes-{128,192}-cbc-{sha1,sha256}.pem` | AES128/192-CBC with PBKDF2 SHA1/SHA256 |
|
||||
| `rsa-pbes2-des3-{sha1,sha256}.pem` | PBES2 3DES-CBC with PBKDF2 SHA1/SHA256; distinct from the legacy PBE scheme handled by optional conversion |
|
||||
| `rsa-pbes2-des.pem` | PBES2 DES-CBC/PBKDF2-SHA256; Rust processing requires no native legacy provider |
|
||||
| `rsa-pbes2-scrypt.pem` | PBES2 AES256-CBC with scrypt |
|
||||
| `rsa-pbes1-3des-password-{1023,1024}.pem` | Same legacy encryption with passwords at the CLI input boundary; the linked importer accepts 1024 bytes, while the converter reports its 1023-byte limit explicitly |
|
||||
| `rsa-pbes1-3des.pem` | Legacy PKCS#12 SHA1/3DES scheme inside standalone encrypted PKCS#8; optional OpenSSL executable conversion case |
|
||||
| `empty-password.p12` | RSA leaf/key/root with an empty password, preserving native backend acceptance |
|
||||
| `ec-pbes2.pem` | Encrypted EC PKCS#8, AES256-CBC/PBKDF2-SHA256 |
|
||||
| `modern.p12`, `unicode-password.p12` | Leaf/key/root, AES256-CBC/PBKDF2-SHA256, SHA256 MAC; RSA and EC respectively |
|
||||
| `certificate-only.pfx`, `key-only.pfx` | Incomplete PKCS#12 archives: certificate without key, and key without certificate; password `fixture-password` |
|
||||
| `legacy-rc2.p12` | Issue #437 case: RC2-40 certificate bags, SHA1/3DES key bag, SHA1 MAC |
|
||||
|
||||
`tests/client_identity.rs` records native import compatibility and the owned
|
||||
identity lifecycle. `tests/identity_encoding.rs` covers container normalization:
|
||||
DER certificates and keys, RSA PKCS#1, Linux/BSD EC SEC1 and traditional encrypted
|
||||
PEM, first-key selection, malformed encryption headers, and archive extension
|
||||
capitalization. macOS rejects SEC1 and traditional encrypted PEM before password
|
||||
handling. Its native importer also rejects the P-256 PKCS#8 PEM fixture, although
|
||||
its native PKCS#12 import accepts the EC archive. Legacy-provider setup is isolated
|
||||
in a child process on Linux/BSD.
|
||||
|
||||
Standalone PKCS#8 PBE-SHA1-3DES uses optional OpenSSL executable conversion,
|
||||
with missing/wrong passwords preserving the old Linux prompt/retry contract.
|
||||
Other unsupported schemes retain explicit conversion guidance. PBES2 DES/3DES
|
||||
use Rust processing and need no executable. Child-process tests isolate PATH
|
||||
for absent/unsupported/stalled converters, invalid output, and secret-free errors.
|
||||
Timeout coverage includes wrappers whose descendants retain pipes after the
|
||||
wrapper exits or is killed; all pipe I/O shares the process deadline.
|
||||
Linux/BSD additionally compare the result with the former linked OpenSSL importer.
|
||||
|
||||
The tests check archive integrity by changing the UTF-16 friendly name without
|
||||
changing the MAC, and compare normalized PEM output against the independent
|
||||
checked-in plaintext key. Public integration tests cover first-key selection,
|
||||
retained snapshots, private-file permissions and cleanup, `.pfx`, empty-password
|
||||
backend behavior, and chain retention. Unit tests in `utils/request.rs` cover
|
||||
missing keys, large local files, and native request-client construction.
|
||||
Binary file not shown.
@@ -0,0 +1,14 @@
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIICMDCCARigAwIBAgIBCjANBgkqhkiG9w0BAQsFADAgMR4wHAYDVQQDDBVHUCBJ
|
||||
ZGVudGl0eSBUZXN0IFJvb3QwHhcNMjYxMDE3MTQxNzM0WhcNMzYxMDE0MTQxNzM0
|
||||
WjAeMRwwGgYDVQQDDBNHUCBJZGVudGl0eSBUZXN0IGVjMFkwEwYHKoZIzj0CAQYI
|
||||
KoZIzj0DAQcDQgAEQm/MjfzelUwWBxNReuqsrrLfBs1ygHeqX6NXBCLWyRWqTI/q
|
||||
BIwba6G3zcnZaArnCw+XsMsBvTtphuiDHouPW6NCMEAwHQYDVR0OBBYEFGySvrUf
|
||||
Wg99yhlvRHe5VcdQV+6sMB8GA1UdIwQYMBaAFNxaJz5kx8+buL1L+wnHUfOmNKDR
|
||||
MA0GCSqGSIb3DQEBCwUAA4IBAQCT4yKBspPRj66lz7y1KjMh0Ju/rVtBlE4pVtbb
|
||||
BYGi29kKVwJyv1GnzKGsbiW7YFEvcBiQFiPV1veab4UR90ESm/SUFXCzwhCkCkQr
|
||||
sYO/tDSyh4vO9zstpN6524lhnEhNqhxrDjwlbHov9Ycsk7nchR2ZXYe7NPF2SZQ3
|
||||
j+NWgOAGHk+xveyfev1sQV8oYn4WL550D0DfCDIVc2n7UdQ2MPw/fvNd1hI6uBUl
|
||||
BrYV+BKeeghn7p7NsesfXqVIuXYbgJ7GFwNh3s3Kdx3p1DQZ37f4P3reSBc7i03+
|
||||
9GmRlPj62a8GnxXFoCcfH4HHp6LkUptZTtHkgyVbsS1Uayj1
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,8 @@
|
||||
-----BEGIN ENCRYPTED PRIVATE KEY-----
|
||||
MIH0MF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBBP0Qie1d771HAwIaHr
|
||||
16KPAgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFlAwQBKgQQJKzM5wh1ay4NLYmy
|
||||
CL43wQSBkLXODq5G55naOF0acp52yJseQ/gpFxKweaqh+dbErhComdC1WW6X1m3x
|
||||
yQZTSGkn9BXXovKbpNPgPbPb7Oks1TEQU33RMi6t89tbZHj757yEY0b+WPpH5Y1g
|
||||
JUE/r2kqpdki7oz5d38R0j7eD1sG/cOvpnkq1jVzp32wRp3cKugLOWx/dC45AhzP
|
||||
X1ZAbDubOg==
|
||||
-----END ENCRYPTED PRIVATE KEY-----
|
||||
@@ -0,0 +1,5 @@
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgwiAZclkH//xmntM5
|
||||
q9LIH7sus8oUbh5BnwXHHfRtPNShRANCAARCb8yN/N6VTBYHE1F66qyust8GzXKA
|
||||
d6pfo1cEItbJFapMj+oEjBtrobfNydloCucLD5ewywG9O2mG6IMei49b
|
||||
-----END PRIVATE KEY-----
|
||||
@@ -0,0 +1,5 @@
|
||||
-----BEGIN EC PRIVATE KEY-----
|
||||
MHcCAQEEIMIgGXJZB//8Zp7TOavSyB+7LrPKFG4eQZ8Fxx30bTzUoAoGCCqGSM49
|
||||
AwEHoUQDQgAEQm/MjfzelUwWBxNReuqsrrLfBs1ygHeqX6NXBCLWyRWqTI/qBIwb
|
||||
a6G3zcnZaArnCw+XsMsBvTtphuiDHouPWw==
|
||||
-----END EC PRIVATE KEY-----
|
||||
@@ -0,0 +1,8 @@
|
||||
-----BEGIN EC PRIVATE KEY-----
|
||||
Proc-Type: 4,ENCRYPTED
|
||||
DEK-Info: AES-128-CBC,EDBB75FE8E4A9290FC3447531722071E
|
||||
|
||||
sg0ogRPLzqBeQztwc20ZPqnuQp/2Lv9a1oqY0SLcWm+z0WXVehUSvOVj6vxBCvuX
|
||||
TVzLYA4q6eEIyaCMEzIFLN/A39gmjBhWZK7+amp0orDuFBHoEbAcUJnGpAglj75f
|
||||
lsKGNAfn5p1WEbB2MFFI6WwKgMFDGvKqK1Dw3crQk8s=
|
||||
-----END EC PRIVATE KEY-----
|
||||
@@ -0,0 +1,8 @@
|
||||
-----BEGIN EC PRIVATE KEY-----
|
||||
Proc-Type: 4,ENCRYPTED
|
||||
DEK-Info: AES-192-CBC,DBD38A287B2D983EF72D8314BE8AA5C3
|
||||
|
||||
m/fzWalU1WmEf76dMsUktNG1Jo/Fvd2hKlaGB0/ITNd/tZuVf6pvz4c8+MhJ7dZ5
|
||||
FPVCe/P8crwM9D4beq8TvUq51U2jfy1iejGU9z9lMsXiutpKIOAsG4iSv0FeZALq
|
||||
cCuZ7tpw1LkIZTfRBoFkQmqYN7oZHtwP7+oGbEDNr5E=
|
||||
-----END EC PRIVATE KEY-----
|
||||
@@ -0,0 +1,8 @@
|
||||
-----BEGIN EC PRIVATE KEY-----
|
||||
Proc-Type: 4,ENCRYPTED
|
||||
DEK-Info: AES-256-CBC,5105F89A3448CA69E8C9784A9876D6F8
|
||||
|
||||
FkTcZ+6JtBHQHimcNXHOYiRI8s3n7lMXuss97oBQvqA/duUT2oItEQbQ548uJol2
|
||||
Xqs0uMKY5H0tvZPUoD9zOWCMIlip7Yj0n5eF5sXU+Nx3aGQHWLmroDA84iCagXRy
|
||||
4YGFRiZsgC2GAOGapTcR62jCyIMYgqyJgUyq3JJWtPA=
|
||||
-----END EC PRIVATE KEY-----
|
||||
@@ -0,0 +1,8 @@
|
||||
-----BEGIN EC PRIVATE KEY-----
|
||||
Proc-Type: 4,ENCRYPTED
|
||||
DEK-Info: DES-EDE3-CBC,C4ABB907B69450C1
|
||||
|
||||
4KvcHjy6UN2l0uf5dPwSrEn8eG4aqvUP0wTUazeqmZ0wFYm3BxNX+Ml44SYXk7rC
|
||||
BKWAFGGjE19I+Y8FiwiIUTx3Jq3sV0/zLROPcw2fv3IxtOjWbnJEppOBrgPfg2Zq
|
||||
FxSQq/C6TyARgxb7muzGFiCD5uuuZthlr3yobSu2jJw=
|
||||
-----END EC PRIVATE KEY-----
|
||||
Binary file not shown.
Loaded 100 of 158 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user