Release 3.0.2

This commit is contained in:
Kevin Yue committed 2026-10-12 00:26:32 +08:00
1 parent 580b81e7bb
commit 888f288c0d
54 files changed
+4007 -374

No files matched your search

+23
View File
@@ -18,6 +18,7 @@ use tokio::fs;
use crate::{
GP_CLIENT_LOCK_FILE,
connect::{ConnectArgs, ConnectHandler},
diagnostics::DiagnosticsArgs,
disconnect::{DisconnectArgs, DisconnectHandler},
hip::{HipArgs, HipHandler},
launch_gui::{LaunchGuiArgs, LaunchGuiHandler},
@@ -50,6 +51,8 @@ enum CliCommand {
LaunchGui(LaunchGuiArgs),
#[command(about = "Generate HIP report")]
Hip(HipArgs),
#[command(about = "Collect system diagnostics for a bug report without connecting to a VPN")]
Diagnostics(DiagnosticsArgs),
#[command(hide = true)]
DetectInternalHost {
#[arg(long)]
@@ -168,6 +171,10 @@ impl Cli {
}
async fn run(&self) -> anyhow::Result<()> {
if let CliCommand::Diagnostics(args) = &self.command {
return args.run(VERSION).await;
}
// check if an instance is running
if !self.can_run_alongside_client() && self.is_running().await {
bail!("Another instance of the client is already running");
@@ -193,6 +200,7 @@ impl Cli {
CliCommand::Disconnect(args) => DisconnectHandler::new(args, shared_args.lock_file).handle().await,
CliCommand::LaunchGui(args) => LaunchGuiHandler::new(args).handle().await,
CliCommand::Hip(args) => HipHandler::new(args).handle().await,
CliCommand::Diagnostics(_) => unreachable!("diagnostics is dispatched before VPN setup"),
CliCommand::DetectInternalHost { address, hostname } => {
let internal = gpapi::session::network::native::detect_in_helper(*address, hostname)?;
println!("{}", serde_json::to_string(&internal)?);
@@ -248,6 +256,21 @@ mod tests {
use super::*;
#[test]
fn diagnostics_accepts_output_options_and_runs_alongside_the_client() {
let cli = Cli::try_parse_from([
"gpclient",
"--fix-openssl",
"diagnostics",
"--json",
"--output",
"report.json",
])
.unwrap();
assert!(matches!(cli.command, CliCommand::Diagnostics(_)));
assert!(cli.can_run_alongside_client());
}
#[test]
fn resolver_helper_runs_alongside_client_and_is_hidden_from_help() {
let cli = Cli::try_parse_from([
+63
View File
@@ -11,6 +11,14 @@ use log::info;
use super::ConnectHandler;
/// Replaces only the child launch boundary in workflow tests.
#[cfg(test)]
#[derive(Default)]
pub(super) struct AuthAttemptFixture {
pub(super) outcomes: std::collections::VecDeque<anyhow::Result<Credential>>,
pub(super) observed: Vec<(String, bool, bool)>,
}
#[derive(Default)]
pub(super) struct CleanAuthState {
requested: bool,
@@ -44,6 +52,47 @@ impl ConnectHandler<'_> {
Ok(())
}
pub(super) async fn obtain_credential_with_recovery(
&self,
mut response: Prelogin,
server: &str,
browser_allowed: bool,
) -> anyhow::Result<(Prelogin, Credential)> {
loop {
self.check_cancelled()?;
let result = self.obtain_credential(&response, server, browser_allowed).await;
self.check_cancelled()?;
match result {
Ok(credential) => return Ok((response, credential)),
Err(error) => {
if !self.auth_recovery.borrow_mut().recover(&error) {
return Err(self.auth_recovery.borrow().terminal(error));
}
log::warn!("Authenticator exited with a Wayland rendering error; retrying with DMABUF disabled");
let refreshed = self
.refresh_auth_prelogin(server, response.is_gateway(), browser_allowed)
.await;
response = refreshed.map_err(|error| self.auth_recovery.borrow().terminal(error))?;
}
}
}
}
pub(super) async fn refresh_auth_prelogin(
&self,
server: &str,
is_gateway: bool,
browser_allowed: bool,
) -> anyhow::Result<Prelogin> {
let mut params = self.build_gp_params();
params.set_is_gateway(is_gateway);
tokio::select! {
biased;
_ = self.cancellation.cancelled() => Err(gpapi::auth::AuthenticationCancelled.into()),
result = gpapi::portal::prelogin(server, &params, self.prelogin_options(browser_allowed)) => result,
}
}
pub(super) async fn obtain_credential(
&self,
prelogin: &Prelogin,
@@ -76,6 +125,7 @@ impl ConnectHandler<'_> {
let os_profile = self.os_profile.borrow().clone();
let key_password = self.latest_key_password.borrow().clone();
let auth_launcher = SamlAuthLauncher::new(server)
.dmabuf_disabled(self.auth_recovery.borrow().dmabuf_disabled())
.gateway(is_gateway)
.saml_request(prelogin.saml_request())
.os_profile(&os_profile)
@@ -116,6 +166,19 @@ impl ConnectHandler<'_> {
.clean(clean_auth)
.default_browser(use_default_browser);
#[cfg(test)]
{
let mut fixture = self.auth_attempt_fixture.borrow_mut();
if let Some(outcome) = fixture.outcomes.pop_front() {
fixture.observed.push((
prelogin.saml_request().to_owned(),
self.auth_recovery.borrow().dmabuf_disabled(),
clean_auth,
));
return outcome;
}
}
let cred = auth_launcher.cancellation(&self.cancellation).launch().await?;
self.check_cancelled()?;
Ok(cred)
+201
View File
@@ -171,3 +171,204 @@ async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_reject
assert!(requests[1].contains("rejected-cookie"));
assert!(requests[2].contains("gateway-password"));
}
#[tokio::test]
async fn rendering_recovery_fetches_new_prelogin_metadata_and_preserves_gateway_mode() {
let (origin, worker) = gateway(vec![
(
"200 OK",
"<prelogin-response><status>Success</status><region>old</region></prelogin-response>".into(),
),
(
"200 OK",
"<prelogin-response><status>Success</status><region>replacement</region></prelogin-response>".into(),
),
])
.await;
let args = TestArgs::parse_from(["test", &origin]).connect;
let directory = tempfile::tempdir().unwrap();
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
let original = handler.refresh_auth_prelogin(&origin, true, true).await.unwrap();
let replacement = handler
.refresh_auth_prelogin(&origin, original.is_gateway(), true)
.await
.unwrap();
assert_eq!(original.region(), "old");
assert_eq!(replacement.region(), "replacement");
assert!(replacement.is_gateway());
let requests = worker.await.unwrap();
assert_eq!(requests.len(), 2);
assert!(
requests
.iter()
.all(|request| request.starts_with("POST /ssl-vpn/prelogin.esp"))
);
}
#[cfg(feature = "webview-auth")]
#[tokio::test]
async fn cancellation_during_recovery_prelogin_stops_request() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
let args = TestArgs::parse_from(["test", &origin]).connect;
let directory = tempfile::tempdir().unwrap();
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
handler
.auth_attempt_fixture
.borrow_mut()
.outcomes
.push_back(Err(rendering_crash()));
let (result, ()) = tokio::time::timeout(Duration::from_secs(3), async {
tokio::join!(
async {
let original = handler.refresh_auth_prelogin(&origin, false, false).await?;
handler.obtain_credential_with_recovery(original, &origin, false).await
},
async {
let (mut socket, _) = listener.accept().await.unwrap();
let mut byte = [0];
socket.read_exact(&mut byte).await.unwrap();
handler.cancellation.cancel();
}
)
})
.await
.unwrap();
assert!(
result
.unwrap_err()
.downcast_ref::<gpapi::auth::AuthenticationCancelled>()
.is_some()
);
}
#[cfg(feature = "webview-auth")]
fn rendering_crash() -> anyhow::Error {
use std::os::unix::process::ExitStatusExt;
gpapi::process::rendering_recovery::RenderingCrash {
status: std::process::ExitStatus::from_raw(71 << 8),
}
.into()
}
#[cfg(feature = "webview-auth")]
fn saml_prelogin_response(region: &str, encoded_request: &str) -> String {
format!(
"<prelogin-response><status>Success</status><region>{region}</region><saml-auth-method>POST</saml-auth-method><saml-request>{encoded_request}</saml-request></prelogin-response>"
)
}
#[cfg(feature = "webview-auth")]
#[tokio::test]
async fn auth_crash_uses_fresh_saml_and_clean_once_with_shared_budget() {
use gpapi::credential::{Credential, PreloginCredential};
let (origin, worker) = gateway(vec![
("200 OK", saml_prelogin_response("old-region", "b2xk")),
("200 OK", saml_prelogin_response("new-region", "bmV3")),
("200 OK", saml_prelogin_response("gateway-region", "Z2F0ZXdheQ==")),
])
.await;
let args = TestArgs::parse_from(["test", &origin, "--clean"]).connect;
let directory = tempfile::tempdir().unwrap();
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
handler.auth_attempt_fixture.borrow_mut().outcomes.extend([
Err(rendering_crash()),
Ok(Credential::Prelogin(PreloginCredential::new(
"alice",
Some("new-cookie"),
None,
None,
))),
Err(rendering_crash()),
]);
let original = handler.refresh_auth_prelogin(&origin, false, false).await.unwrap();
let (replacement, credential) = handler
.obtain_credential_with_recovery(original, &origin, false)
.await
.unwrap();
assert_eq!(replacement.region(), "new-region");
assert_eq!(credential.username(), "alice");
assert!(matches!(credential, Credential::Prelogin(ref value) if value.prelogin_cookie() == Some("new-cookie")));
let gateway_prelogin = handler.refresh_auth_prelogin(&origin, true, false).await.unwrap();
let error = handler
.obtain_credential_with_recovery(gateway_prelogin, &origin, false)
.await
.unwrap_err();
assert!(
error
.downcast_ref::<gpapi::process::rendering_recovery::RecoveryFailed>()
.is_some()
);
assert_eq!(
handler.auth_attempt_fixture.borrow().observed,
[
("old".into(), false, true),
("new".into(), true, false),
("gateway".into(), true, false),
]
);
assert_eq!(worker.await.unwrap().len(), 3);
}
#[cfg(feature = "webview-auth")]
#[tokio::test]
async fn exhausted_auth_recovery_is_terminal_before_portal_gateway_fallback() {
let (origin, worker) = gateway(vec![
("200 OK", saml_prelogin_response("old-region", "b2xk")),
("200 OK", saml_prelogin_response("new-region", "bmV3")),
])
.await;
let args = TestArgs::parse_from(["test", &origin, "--clean"]).connect;
let directory = tempfile::tempdir().unwrap();
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
handler.auth_attempt_fixture.borrow_mut().outcomes.extend([
Err(rendering_crash()),
Err(anyhow::anyhow!(gpapi::error::PortalError::PreloginError(
"second failure".into()
))),
]);
let error = handler.handle_impl().await.unwrap_err();
assert!(
error
.downcast_ref::<gpapi::process::rendering_recovery::RecoveryFailed>()
.is_some()
);
assert_eq!(handler.auth_attempt_fixture.borrow().observed.len(), 2);
assert_eq!(worker.await.unwrap().len(), 2);
}
+11 -4
View File
@@ -170,8 +170,8 @@ impl ConnectHandler<'_> {
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
result = prelogin(gateway, &gp_params, self.direct_gateway_prelogin_options()) => result?,
};
let cred = self
.obtain_credential(&prelogin, gateway, gateway_browser_auth_allowed)
let (_, cred) = self
.obtain_credential_with_recovery(prelogin, gateway, gateway_browser_auth_allowed)
.await?;
let login_session = self
@@ -262,6 +262,13 @@ impl ConnectHandler<'_> {
}
Err(error) => {
self.check_cancelled()?;
let error = self.auth_recovery.borrow().terminal(error);
if error
.downcast_ref::<gpapi::process::rendering_recovery::RecoveryFailed>()
.is_some()
{
return Err(error);
}
if error
.downcast_ref::<gpapi::gateway::GatewayLoginProtocolError>()
.is_some()
@@ -273,8 +280,8 @@ impl ConnectHandler<'_> {
}
}
let credential = self
.obtain_credential(&gateway_prelogin, gateway, browser_allowed)
let (_, credential) = self
.obtain_credential_with_recovery(gateway_prelogin, gateway, browser_allowed)
.await
.inspect_err(|_| self.print_direct_gateway_recommendation(gateway))?;
self.check_cancelled()?;
+3
View File
@@ -57,6 +57,9 @@ impl ConnectHandler<'_> {
Err(error) => {
self.logout_gateway(gateway.server()).await;
self.check_cancelled()?;
if self.auth_recovery.borrow().dmabuf_disabled() {
return Err(self.auth_recovery.borrow().terminal(error));
}
warn!("Internal gateway {gateway} authentication failed: {error}");
}
}
+29 -5
View File
@@ -41,6 +41,9 @@ pub(crate) struct ConnectHandler<'a> {
password_from_stdin: RefCell<Option<String>>,
cookie_from_stdin: RefCell<Option<String>>,
clean_auth_state: RefCell<CleanAuthState>,
#[cfg(test)]
auth_attempt_fixture: RefCell<credential::AuthAttemptFixture>,
auth_recovery: RefCell<gpapi::process::rendering_recovery::RecoveryState>,
sessions: RefCell<GatewaySessions>,
pid_written: Arc<AtomicBool>,
}
@@ -63,6 +66,9 @@ impl<'a> ConnectHandler<'a> {
password_from_stdin: Default::default(),
cookie_from_stdin: Default::default(),
clean_auth_state: RefCell::new(CleanAuthState::new(clean_auth)),
#[cfg(test)]
auth_attempt_fixture: Default::default(),
auth_recovery: RefCell::default(),
sessions: RefCell::default(),
pid_written: Arc::default(),
}
@@ -112,6 +118,7 @@ impl<'a> ConnectHandler<'a> {
gpapi::utils::shutdown_signal().await;
cancellation.cancel();
});
self.auth_recovery.replace(Default::default());
let result = self.handle_attempt().await;
let sessions = self.sessions.take();
if self.args.cookie_only && result.is_ok() {
@@ -153,10 +160,17 @@ impl<'a> ConnectHandler<'a> {
loop {
self.check_cancelled()?;
let Err(err) = self.handle_impl().await else {
let result = self.handle_impl().await;
let Err(err) = self.auth_recovery.borrow().finish(result) else {
return Ok(());
};
if err
.downcast_ref::<gpapi::process::rendering_recovery::RecoveryFailed>()
.is_some()
{
return Err(err);
}
let Some(root_cause) = err.root_cause().downcast_ref::<RequestIdentityError>() else {
return Err(err);
};
@@ -212,6 +226,13 @@ impl<'a> ConnectHandler<'a> {
return Ok(());
};
let err = self.auth_recovery.borrow().terminal(err);
if err
.downcast_ref::<gpapi::process::rendering_recovery::RecoveryFailed>()
.is_some()
{
return Err(err);
}
warn!("Failed to connect portal with prelogin: {}", err);
if err.root_cause().downcast_ref::<PortalError>().is_some() {
info!("Trying the gateway authentication workflow...");
@@ -238,7 +259,7 @@ impl<'a> ConnectHandler<'a> {
async fn connect_portal_with_prelogin(&self, portal: &str) -> anyhow::Result<()> {
let gp_params = self.build_gp_params();
let prelogin = tokio::select! {
let mut prelogin = tokio::select! {
biased;
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
result = prelogin(portal, &gp_params, self.prelogin_options(false)) => result?,
@@ -260,7 +281,10 @@ impl<'a> ConnectHandler<'a> {
let (cred, mut portal_config) = match cached_config {
Some(result) => result,
None => {
let cred = self.obtain_credential(&prelogin, portal, false).await?;
let (replacement, cred) = self
.obtain_credential_with_recovery(prelogin.clone(), portal, false)
.await?;
prelogin = replacement;
self.check_cancelled()?;
let config = retrieve_config(portal, &cred, &gp_params, &self.cancellation).await?;
(cred, config)
@@ -305,8 +329,8 @@ impl<'a> ConnectHandler<'a> {
Ok(()) => return Ok(()),
Err(err) => {
self.logout_gateway(gateway.server()).await;
if !err.is_before_establishment() {
return Err(err.into_error());
if self.auth_recovery.borrow().dmabuf_disabled() || !err.is_before_establishment() {
return Err(self.auth_recovery.borrow().terminal(err.into_error()));
}
warn!(
"Auto-gateway: gateway {} failed before session establishment: {}",
+285
View File
@@ -0,0 +1,285 @@
use std::{
collections::BTreeMap, fs::OpenOptions, io::Write, os::unix::fs::OpenOptionsExt, path::PathBuf, process::Stdio,
};
use anyhow::{Context, ensure};
use clap::Args;
use common::binary_paths;
use serde::Serialize;
use tokio::{io::AsyncWriteExt, process::Command};
const COLLECTOR: &str = include_str!("../../../scripts/collect-diagnostics.sh");
const MAX_REPORT_BYTES: usize = 64 * 1024;
const FIELDS: &[&str] = &[
"os",
"os_version",
"kernel",
"architecture",
"execution_user",
"ssh_session",
"virtualization",
"gpclient_path",
"gpclient_version",
"gpauth_path",
"gpauth_version",
"gpgui_path",
"gpgui_version",
"display_protocol",
"graphics",
"graphics_packages",
"desktop_version",
"env.XDG_CURRENT_DESKTOP",
"env.XDG_SESSION_DESKTOP",
"env.XDG_SESSION_TYPE",
"env.DESKTOP_SESSION",
"env.WEBKIT_DISABLE_DMABUF_RENDERER",
"env.WEBKIT_DISABLE_COMPOSITING_MODE",
"env.LIBGL_ALWAYS_SOFTWARE",
"env.__NV_DISABLE_EXPLICIT_SYNC",
"env.GDK_BACKEND",
"env.GDK_GL",
];
#[derive(Args)]
pub(crate) struct DiagnosticsArgs {
/// Print the report as JSON instead of text
#[arg(long)]
json: bool,
/// Save the report to a new file instead of stdout (existing files are preserved)
#[arg(long, value_name = "PATH")]
output: Option<PathBuf>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
enum ProbeStatus {
Ok,
Unset,
Unavailable,
Failed,
TimedOut,
NotApplicable,
}
#[derive(Debug, Serialize)]
struct DiagnosticField {
status: ProbeStatus,
value: Option<String>,
}
#[derive(Debug, Serialize)]
struct DiagnosticsReport {
schema_version: u32,
fields: BTreeMap<String, DiagnosticField>,
}
impl DiagnosticsReport {
fn parse(bytes: &[u8]) -> anyhow::Result<Self> {
ensure!(
bytes.len() <= MAX_REPORT_BYTES,
"Diagnostics report exceeds its size limit"
);
let mut fields = BTreeMap::new();
let mut schema_version = None;
for raw_line in bytes.split(|byte| *byte == b'\n').filter(|line| !line.is_empty()) {
let line = String::from_utf8_lossy(raw_line);
let (name, rest) = line.split_once(": ").context("Invalid diagnostics record")?;
let (status, value) = rest.split_once(": ").context("Invalid diagnostics status")?;
let raw_value_length = raw_line
.len()
.checked_sub(name.len() + status.len() + 4)
.context("Invalid diagnostics framing")?;
ensure!(raw_value_length <= 512, "Diagnostics field exceeds its size limit");
ensure!(
!value.chars().any(|c| c.is_ascii_control()),
"Invalid diagnostics value"
);
let status = match status {
"ok" => ProbeStatus::Ok,
"unset" => ProbeStatus::Unset,
"unavailable" => ProbeStatus::Unavailable,
"failed" => ProbeStatus::Failed,
"timed_out" => ProbeStatus::TimedOut,
"not_applicable" => ProbeStatus::NotApplicable,
_ => anyhow::bail!("Unknown diagnostics status"),
};
if name == "schema_version" {
ensure!(schema_version.is_none(), "Duplicate diagnostics schema version");
ensure!(
matches!(status, ProbeStatus::Ok) && value == "1",
"Unsupported diagnostics schema"
);
schema_version = Some(1);
continue;
}
ensure!(FIELDS.contains(&name), "Unknown diagnostics field");
let value = if matches!(status, ProbeStatus::Ok) {
let mut normalized = String::new();
for character in value.chars() {
let character = if character.is_control() { ' ' } else { character };
if normalized.len() + character.len_utf8() > 512 {
break;
}
normalized.push(character);
}
Some(normalized)
} else {
ensure!(value.is_empty(), "Unexpected value for unavailable diagnostics field");
None
};
ensure!(
fields
.insert(name.to_owned(), DiagnosticField { status, value })
.is_none(),
"Duplicate diagnostics field"
);
}
ensure!(fields.len() == FIELDS.len(), "Incomplete diagnostics report");
Ok(Self {
schema_version: schema_version.context("Missing diagnostics schema version")?,
fields,
})
}
fn text(&self) -> String {
let mut text = format!("schema_version: ok: {}\n", self.schema_version);
for name in FIELDS {
let field = &self.fields[*name];
let status = match field.status {
ProbeStatus::Ok => "ok",
ProbeStatus::Unset => "unset",
ProbeStatus::Unavailable => "unavailable",
ProbeStatus::Failed => "failed",
ProbeStatus::TimedOut => "timed_out",
ProbeStatus::NotApplicable => "not_applicable",
};
text.push_str(&format!(
"{name}: {status}: {}\n",
field.value.as_deref().unwrap_or_default()
));
}
text
}
}
impl DiagnosticsArgs {
pub(crate) async fn run(&self, version: &str) -> anyhow::Result<()> {
let mut child = Command::new("/bin/sh")
.args(["-s", "--", "--client-version", version, "--client-path"])
.arg(std::env::current_exe().context("Cannot locate gpclient")?)
.arg("--auth-path")
.arg(binary_paths::gpauth())
.arg("--gui-path")
.arg(binary_paths::gpgui())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.kill_on_drop(true)
.spawn()
.context("Cannot start diagnostics collector")?;
let mut input = child.stdin.take().context("Collector input is unavailable")?;
let (_, output) = tokio::try_join!(
async move {
input.write_all(COLLECTOR.as_bytes()).await?;
drop(input);
Ok::<_, std::io::Error>(())
},
child.wait_with_output(),
)
.context("Diagnostics collection failed")?;
ensure!(
output.status.success(),
"Diagnostics collector exited with {}",
output.status
);
let report = DiagnosticsReport::parse(&output.stdout)?;
let content = if self.json {
format!("{}\n", serde_json::to_string_pretty(&report)?)
} else {
report.text()
};
if let Some(path) = &self.output {
save_report(path, &content)?;
} else {
std::io::stdout().lock().write_all(content.as_bytes())?;
}
Ok(())
}
}
fn save_report(path: &std::path::Path, content: &str) -> anyhow::Result<()> {
let mut file = OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(path)
.context("Cannot create diagnostics file; use a new path")?;
file
.write_all(content.as_bytes())
.context("Cannot save diagnostics report")
}
#[cfg(test)]
mod tests {
use super::*;
fn sample_report() -> String {
let mut text = String::from("schema_version: ok: 1\n");
for name in FIELDS {
text.push_str(&format!("{name}: unavailable: \n"));
}
text
}
#[test]
fn json_preserves_collected_values_and_distinguishes_missing_probes() {
let text = sample_report().replace("os: unavailable: ", "os: ok: FreeBSD");
let report = DiagnosticsReport::parse(text.as_bytes()).unwrap();
let json = serde_json::to_value(report).unwrap();
assert_eq!(json["schema_version"], 1);
assert_eq!(json["fields"]["os"]["value"], "FreeBSD");
assert_eq!(json["fields"]["graphics"]["status"], "unavailable");
assert!(json["fields"]["graphics"]["value"].is_null());
}
#[test]
fn malformed_or_injected_records_are_rejected() {
let good = sample_report();
for bad in [
good.replace("os: unavailable: ", "os: mystery: "),
good.replace("os: unavailable: ", "os: ok: text\u{1b}[31m"),
good.replace("os: unavailable: ", "os: ok: value\nsecret: ok: token"),
format!("{good}os: ok: duplicate\n"),
good.replace("schema_version: ok: 1", "schema_version: ok: 2"),
good.replace("os: unavailable: \n", ""),
] {
assert!(DiagnosticsReport::parse(bad.as_bytes()).is_err());
}
}
#[test]
fn invalid_utf8_and_unicode_controls_produce_a_bounded_readable_value() {
let mut bytes = sample_report()
.replace("os: unavailable: ", "os: ok: REPLACE")
.into_bytes();
let start = bytes.windows(7).position(|value| value == b"REPLACE").unwrap();
bytes.splice(start..start + 7, [0xff; 500]);
let report = DiagnosticsReport::parse(&bytes).unwrap();
let value = report.fields["os"].value.as_ref().unwrap();
assert!(value.len() <= 512);
assert!(value.starts_with('\u{fffd}'));
let text = sample_report().replace("os: unavailable: ", "os: ok: Test\u{85}OS");
let report = DiagnosticsReport::parse(text.as_bytes()).unwrap();
assert_eq!(report.fields["os"].value.as_deref(), Some("Test OS"));
assert!(report.text().contains("os: ok: Test OS"));
}
#[test]
fn saving_a_report_does_not_overwrite_existing_files() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("diagnostics.txt");
save_report(&path, "first").unwrap();
assert!(save_report(&path, "second").is_err());
assert_eq!(std::fs::read_to_string(path).unwrap(), "first");
}
}
+1
View File
@@ -1,5 +1,6 @@
mod cli;
mod connect;
mod diagnostics;
mod disconnect;
mod hip;
mod launch_gui;
+64
View File
@@ -0,0 +1,64 @@
use std::{os::unix::fs::PermissionsExt, process::Stdio, time::Duration};
use tokio::process::Command;
fn executable(dir: &std::path::Path, name: &str, body: &str) {
let path = dir.join(name);
std::fs::write(&path, format!("#!/bin/sh\n{body}\n")).unwrap();
std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
}
#[tokio::test]
async fn embedded_collector_finishes_without_recursing_or_exposing_private_environment() {
let dir = tempfile::tempdir().unwrap();
let bin = dir.path().join("bin");
std::fs::create_dir(&bin).unwrap();
executable(
&bin,
"uname",
"case \"$1\" in -s) echo Linux ;; -m) echo aarch64 ;; *) echo test-kernel ;; esac",
);
executable(&bin, "gpclient", "echo unexpected-recursion >&2; exit 99");
executable(&bin, "systemd-detect-virt", "echo kvm");
executable(
&bin,
"lspci",
"echo '00:02.0 VGA compatible controller: Test GPU'; echo ' Kernel driver in use: test'",
);
executable(&bin, "pacman", "echo 'gtk3 test-version'");
let report_file = dir.path().join("report.json");
let output = tokio::time::timeout(
Duration::from_secs(30),
Command::new(env!("CARGO_BIN_EXE_gpclient"))
.args(["--fix-openssl", "diagnostics", "--json", "--output"])
.arg(&report_file)
.env("PATH", format!("{}:/usr/bin:/bin", bin.display()))
.env("GP_DIAGNOSTICS_PRIVATE_TOKEN", "secret-value-must-not-appear")
.env("XDG_CURRENT_DESKTOP", "TestDesktop\nInjected: secret")
.stdin(Stdio::null())
.kill_on_drop(true)
.output(),
)
.await
.expect("collector must close stdin and terminate")
.unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
assert!(output.stdout.is_empty());
let text = std::fs::read_to_string(&report_file).unwrap();
assert!(!text.contains("secret-value-must-not-appear"));
assert!(!String::from_utf8_lossy(&output.stderr).contains("unexpected-recursion"));
let report: serde_json::Value = serde_json::from_str(&text).unwrap();
assert_eq!(report["schema_version"], 1);
assert_eq!(report["fields"]["os"]["value"], "Linux");
assert!(
report["fields"]["gpclient_version"]["value"]
.as_str()
.unwrap()
.starts_with(env!("CARGO_PKG_VERSION"))
);
assert_eq!(
report["fields"]["env.XDG_CURRENT_DESKTOP"]["value"],
"TestDesktop Injected: secret"
);
assert!(!String::from_utf8_lossy(&output.stderr).contains("Using 'UnsafeLegacyServerConnect'"));
}
+65 -11
View File
@@ -17,6 +17,7 @@ use tokio::io::unix::AsyncFd;
use tokio_util::sync::CancellationToken;
use crate::session_registry::SessionRegistry;
use gpapi::service::transport::{DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY};
/// Private parent/service pipes; credentials never pass through argv, environment or files.
pub(crate) struct DesktopClient {
@@ -58,19 +59,28 @@ impl DesktopClient {
restart: Arc<AtomicBool>,
cancel: CancellationToken,
) -> anyhow::Result<()> {
let mut rendering_renewed = false;
loop {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
let session_id = credential.session_id();
let result = tokio::select! {
_ = cancel.cancelled() => Ok(false),
_ = cancel.cancelled() => Ok(None),
result = async {
self.write_frame(&credential.encode_frame()?).await?;
self.gui_exited().await
} => result,
};
registry.revoke(session_id);
if !result? || !restart.swap(false, Ordering::SeqCst) {
return Ok(());
let requested = restart.swap(false, Ordering::SeqCst);
match result? {
None => return Ok(()),
Some(DESKTOP_GUI_EXITED) if requested => {}
Some(DESKTOP_GUI_EXITED) => return Ok(()),
Some(DESKTOP_RENDERING_RETRY) => {
ensure!(!rendering_renewed, "Rendering recovery already requested");
rendering_renewed = true;
}
Some(_) => anyhow::bail!("Invalid desktop control message"),
}
}
}
@@ -90,17 +100,16 @@ impl DesktopClient {
Ok(())
}
async fn gui_exited(&self) -> anyhow::Result<bool> {
async fn gui_exited(&self) -> anyhow::Result<Option<u8>> {
loop {
let mut ready = self.input.readable().await?;
let mut byte = [0];
match ready.try_io(|fd| read(fd.get_ref(), &mut byte).map_err(io::Error::from)) {
Ok(result) => {
if result.context("Desktop control pipe failed")? == 0 {
return Ok(false);
return Ok(None);
}
ensure!(byte[0] == 0, "Invalid desktop control message");
return Ok(true);
return Ok(Some(byte[0]));
}
Err(_) => continue,
}
@@ -165,7 +174,7 @@ mod tests {
#[tokio::test]
async fn desktop_channel_revokes_and_reissues_on_restart_then_closes_on_parent_exit() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let restart = Arc::new(AtomicBool::new(false));
let task = tokio::spawn(channel.serve(registry.clone(), 1000, restart.clone(), CancellationToken::new()));
let (reader, first) = credential(reader).await;
@@ -183,10 +192,55 @@ mod tests {
assert!(registry.last_successful_hip_report(second.session_id()).is_err());
}
#[tokio::test]
async fn rendering_renewal_revokes_credentials_and_consumes_old_restart_intent() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let restart = Arc::new(AtomicBool::new(true));
let task = tokio::spawn(channel.serve(registry.clone(), 1000, restart.clone(), CancellationToken::new()));
let (reader, first) = credential(reader).await;
write(&control, &[DESKTOP_RENDERING_RETRY]).unwrap();
let (_, second) = credential(reader).await;
assert_ne!(first.session_id(), second.session_id());
assert!(registry.last_successful_hip_report(first.session_id()).is_err());
assert!(!restart.load(Ordering::SeqCst));
write(&control, &[DESKTOP_GUI_EXITED]).unwrap();
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(second.session_id()).is_err());
}
#[tokio::test]
async fn repeated_rendering_renewal_fails_closed() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let task = tokio::spawn(channel.serve(
registry.clone(),
1000,
Arc::new(AtomicBool::new(false)),
CancellationToken::new(),
));
let (reader, _) = credential(reader).await;
write(&control, &[DESKTOP_RENDERING_RETRY]).unwrap();
let (_, second) = credential(reader).await;
write(&control, &[DESKTOP_RENDERING_RETRY]).unwrap();
assert!(
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert!(registry.last_successful_hip_report(second.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_shutdown_cancels_pipe_wait_and_revokes_credential() {
let (channel, _control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let cancel = CancellationToken::new();
let task = tokio::spawn(channel.serve(registry.clone(), 1000, Arc::new(AtomicBool::new(false)), cancel.clone()));
let (_, issued) = credential(reader).await;
@@ -202,7 +256,7 @@ mod tests {
#[tokio::test]
async fn desktop_channel_rejects_invalid_control_messages_and_revokes() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let task = tokio::spawn(channel.serve(
registry.clone(),
1000,
@@ -210,7 +264,7 @@ mod tests {
CancellationToken::new(),
));
let (_, issued) = credential(reader).await;
write(&control, &[1]).unwrap();
write(&control, &[255]).unwrap();
assert!(
tokio::time::timeout(Duration::from_secs(1), task)
.await
+1 -1
View File
@@ -186,7 +186,7 @@ mod tests {
#[tokio::test]
async fn anchor_eof_revokes_issued_credential() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let (service, mut client) = UnixStream::pair().unwrap();
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(&registry), Some(1234)));
+1 -1
View File
@@ -233,7 +233,7 @@ mod tests {
"serial".into(),
"00:11:22:33:44:55".into(),
),
registry: Arc::new(SessionRegistry::new(Uuid::new_v4())),
registry: Arc::new(SessionRegistry::for_tests(Uuid::new_v4())),
connection,
}
}
+52 -10
View File
@@ -84,6 +84,8 @@ struct AttachmentAttempt {
pub struct SessionRegistry {
service_instance_id: Uuid,
sessions: Mutex<HashMap<Uuid, SessionRecord>>,
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
resolve_device_anchor: fn() -> anyhow::Result<gpapi::device_anchor::DeviceAnchor>,
}
fn unavailable_connection() -> ServiceResult {
@@ -192,6 +194,25 @@ impl SessionRegistry {
Self {
service_instance_id,
sessions: Mutex::new(HashMap::new()),
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
resolve_device_anchor: crate::device_anchor::resolve,
}
}
/// Session tests use an explicit anchor fixture; persistence and permissions
/// are exercised separately by the device_anchor tests.
#[cfg(test)]
pub(crate) fn for_tests(service_instance_id: Uuid) -> Self {
Self {
service_instance_id,
sessions: Mutex::new(HashMap::new()),
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
resolve_device_anchor: || {
Ok(gpapi::device_anchor::DeviceAnchor::derive(
gpapi::device_anchor::AnchorSource::UnixRandom,
b"session-registry-test-anchor",
))
},
}
}
@@ -218,7 +239,7 @@ impl SessionRegistry {
SessionCredential::generate(self.service_instance_id, product_version).map_err(|_| SessionError::Unavailable)?;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
let credential = {
let anchor = crate::device_anchor::resolve().map_err(|error| {
let anchor = (self.resolve_device_anchor)().map_err(|error| {
log::warn!("GUI device anchor unavailable: {error:#}");
SessionError::Unavailable
})?;
@@ -596,9 +617,30 @@ mod tests {
ConnectionControl::new(Uuid::new_v4(), tx).0
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[test]
fn unavailable_device_anchor_does_not_issue_a_session() {
let mut registry = SessionRegistry::for_tests(Uuid::new_v4());
registry.resolve_device_anchor = || anyhow::bail!("fixture anchor unavailable");
assert!(matches!(
registry.issue("fixture", None),
Err(SessionError::Unavailable)
));
assert!(registry.sessions.lock().unwrap().is_empty());
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[test]
fn issued_credential_carries_the_resolved_device_anchor() {
let registry = SessionRegistry::for_tests(Uuid::new_v4());
let expected = (registry.resolve_device_anchor)().unwrap();
let credential = registry.issue("fixture", Some(1000)).unwrap();
assert_eq!(credential.device_anchor(), Some(&expected));
}
#[tokio::test]
async fn attachment_replacement_cancels_preparation_and_retains_drain_until_release() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let first = registry
@@ -655,7 +697,7 @@ mod tests {
#[tokio::test]
async fn scoped_stop_closes_attachment_to_delayed_starts_without_receipt_history() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let permit = registry
@@ -693,7 +735,7 @@ mod tests {
#[tokio::test]
async fn tunnel_reservation_survives_attachment_loss_but_non_tunnel_revocation_cancels() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let permit = registry
@@ -732,7 +774,7 @@ mod tests {
#[test]
fn credential_retains_verified_desktop_user_across_reconnect() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
@@ -769,7 +811,7 @@ mod tests {
panic!("upload did not complete")
}
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let first_credential = registry.issue("2.6.4", Some(1000)).unwrap();
let second_credential = registry.issue("2.6.4", Some(1001)).unwrap();
for credential in [&first_credential, &second_credential] {
@@ -813,7 +855,7 @@ mod tests {
#[test]
fn submitted_report_changes_only_after_success_callback_and_is_session_bound() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let permit = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
@@ -866,7 +908,7 @@ mod tests {
#[test]
fn reconnect_uses_generation_compare_and_swap() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
@@ -887,7 +929,7 @@ mod tests {
#[test]
fn failed_initial_handshake_only_revokes_its_own_reservation() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
@@ -901,7 +943,7 @@ mod tests {
#[test]
fn failed_reconnect_keeps_active_connection_authoritative() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
+2 -2
View File
@@ -212,7 +212,7 @@ impl LifecycleHandle {
#[cfg(test)]
pub(crate) fn for_tests() -> Self {
let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected);
let registry = Arc::new(crate::session_registry::SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(crate::session_registry::SessionRegistry::for_tests(Uuid::new_v4()));
let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry);
lifecycle
}
@@ -782,7 +782,7 @@ mod tests {
use crate::session_registry::SessionRegistry;
fn registry() -> Arc<SessionRegistry> {
Arc::new(SessionRegistry::new(Uuid::new_v4()))
Arc::new(SessionRegistry::for_tests(Uuid::new_v4()))
}
fn identity_request() -> ConnectRequest {
@@ -56,7 +56,7 @@ async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response(
let mut gateway = serde_json::to_value(Gateway::new("fixture".into(), server_name.clone())).unwrap();
gateway["kind"] = serde_json::json!("internal");
let gateway: Gateway = serde_json::from_value(gateway).unwrap();
let registry = Arc::new(crate::session_registry::SessionRegistry::new(uuid::Uuid::new_v4()));
let registry = Arc::new(crate::session_registry::SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session_id = credential.session_id();
let permit = registry
+1 -1
View File
@@ -589,7 +589,7 @@ mod tests {
#[tokio::test]
async fn authenticates_attaches_and_replies_to_a_request() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
+2 -2
View File
@@ -287,7 +287,7 @@ mod tests {
#[tokio::test]
async fn resync_snapshot_is_ordered_with_state_events() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let permit = registry
.begin_handshake(
@@ -344,7 +344,7 @@ mod tests {
#[tokio::test]
async fn removed_prepared_candidate_cannot_commit_takeover() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),