mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
* fix(gpclient): keep cookie cache when the cached login gets no answer A connect or timeout error during the cached gateway login or cached portal discovery deleted the --cookie-cache file and fell back to SAML, although the server never rejected the cookie. Keep the cache and return the error for unanswered requests; only clear it when the server responds. * fix(gpclient): preserve cached cookies for all failed requests --------- Co-authored-by: Kevin Yue <[email protected]>
708 lines
24 KiB
Rust
708 lines
24 KiB
Rust
use std::time::Duration;
|
|
|
|
use clap::Parser;
|
|
use gpapi::{
|
|
cookie_store::{self, StoredCookie},
|
|
credential::AuthCookieCredential,
|
|
gateway::{Gateway, GatewayLoginContext, GatewaySelection},
|
|
log_format::LogFormat,
|
|
session::SessionMode,
|
|
};
|
|
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
|
|
|
use super::{ConnectArgs, ConnectHandler};
|
|
use crate::cli::SharedArgs;
|
|
|
|
#[derive(Parser)]
|
|
struct TestArgs {
|
|
#[command(flatten)]
|
|
connect: ConnectArgs,
|
|
}
|
|
|
|
fn login_response() -> String {
|
|
let mut fields = [""; 20];
|
|
fields[1] = "issued-cookie";
|
|
fields[3] = "gateway";
|
|
fields[4] = "alice";
|
|
fields[5] = "fixture-auth";
|
|
fields[6] = "vsys1";
|
|
fields[12] = "tunnel";
|
|
format!(
|
|
"<jnlp><application-desc>{}</application-desc></jnlp>",
|
|
fields
|
|
.iter()
|
|
.map(|field| format!("<argument>{field}</argument>"))
|
|
.collect::<String>()
|
|
)
|
|
}
|
|
|
|
async fn read_request(stream: &mut tokio::net::TcpStream) -> String {
|
|
let mut request = Vec::new();
|
|
loop {
|
|
let mut buf = [0; 4096];
|
|
let count = stream.read(&mut buf).await.unwrap();
|
|
assert_ne!(count, 0, "Request ended before its body");
|
|
request.extend_from_slice(&buf[..count]);
|
|
if let Some(end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
|
|
let headers = String::from_utf8_lossy(&request[..end]).to_ascii_lowercase();
|
|
let length = headers
|
|
.lines()
|
|
.find_map(|line| line.strip_prefix("content-length:"))
|
|
.map(|value| value.trim().parse::<usize>().unwrap())
|
|
.unwrap_or(0);
|
|
if request.len() >= end + 4 + length {
|
|
return String::from_utf8(request).unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task::JoinHandle<Vec<String>>) {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let origin = format!("http://{}", listener.local_addr().unwrap());
|
|
let worker = tokio::spawn(async move {
|
|
tokio::time::timeout(Duration::from_secs(5), async move {
|
|
let mut requests = Vec::new();
|
|
for (status, body) in responses {
|
|
let (mut stream, _) = listener.accept().await.unwrap();
|
|
requests.push(read_request(&mut stream).await);
|
|
stream
|
|
.write_all(
|
|
format!(
|
|
"HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
|
body.len()
|
|
)
|
|
.as_bytes(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
requests
|
|
})
|
|
.await
|
|
.expect("Gateway fixture timed out")
|
|
});
|
|
(origin, worker)
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
|
|
let (gateway, worker) = gateway(vec![("200 OK", login_response())]).await;
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let cache = directory.path().join("cookie.json");
|
|
let args = TestArgs::parse_from([
|
|
"test",
|
|
"http://unavailable-portal.invalid",
|
|
"--cookie-only",
|
|
"--cookie-cache",
|
|
cache.to_str().unwrap(),
|
|
])
|
|
.connect;
|
|
let lock = directory.path().join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: true,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
cookie_store::save(
|
|
&cache,
|
|
&StoredCookie::new(
|
|
args.server.clone(),
|
|
"alice".into(),
|
|
handler.os_profile.borrow().host_identity().host_id().into(),
|
|
gateway,
|
|
AuthCookieCredential::new("alice", "portal-cookie", ""),
|
|
),
|
|
)
|
|
.unwrap();
|
|
handler.handle_impl().await.unwrap();
|
|
let requests = worker.await.unwrap();
|
|
assert_eq!(requests.len(), 1);
|
|
assert!(requests[0].starts_with("POST /ssl-vpn/login.esp "));
|
|
assert!(requests[0].contains("portal-cookie"));
|
|
assert_eq!(
|
|
handler.sessions.borrow().members()[0].transport.authentication().mode(),
|
|
SessionMode::Tunnel
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn unreachable_gateway_keeps_cached_cookie() {
|
|
// Nothing listens here: the cached gateway login gets no answer at all.
|
|
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let gateway = format!("http://{}", listener.local_addr().unwrap());
|
|
drop(listener);
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let cache = directory.path().join("cookie.json");
|
|
let args = TestArgs::parse_from([
|
|
"test",
|
|
"http://unavailable-portal.invalid",
|
|
"--cookie-only",
|
|
"--cookie-cache",
|
|
cache.to_str().unwrap(),
|
|
])
|
|
.connect;
|
|
let lock = directory.path().join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: true,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
cookie_store::save(
|
|
&cache,
|
|
&StoredCookie::new(
|
|
args.server.clone(),
|
|
"alice".into(),
|
|
handler.os_profile.borrow().host_identity().host_id().into(),
|
|
gateway,
|
|
AuthCookieCredential::new("alice", "portal-cookie", ""),
|
|
),
|
|
)
|
|
.unwrap();
|
|
assert!(handler.handle_impl().await.is_err());
|
|
assert!(
|
|
cache.exists(),
|
|
"a login that got no answer must not delete the cookie cache"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn gateway_closing_without_response_keeps_cached_cookie() {
|
|
closed_connection_keeps_cached_cookie(false).await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn portal_closing_without_response_keeps_cached_cookie() {
|
|
closed_connection_keeps_cached_cookie(true).await;
|
|
}
|
|
|
|
async fn closed_connection_keeps_cached_cookie(portal_discovery: bool) {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let origin = format!("http://{}", listener.local_addr().unwrap());
|
|
let worker = tokio::spawn(async move {
|
|
tokio::time::timeout(Duration::from_secs(5), async move {
|
|
if portal_discovery {
|
|
let (mut stream, _) = listener.accept().await.unwrap();
|
|
assert!(read_request(&mut stream).await.contains("/global-protect/prelogin.esp"));
|
|
let body = "<prelogin-response><status>Success</status></prelogin-response>";
|
|
stream
|
|
.write_all(
|
|
format!(
|
|
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
|
body.len()
|
|
)
|
|
.as_bytes(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
let (mut stream, _) = listener.accept().await.unwrap();
|
|
// Read the complete request, then close without sending HTTP headers.
|
|
read_request(&mut stream).await
|
|
})
|
|
.await
|
|
.expect("Connection-closing fixture timed out")
|
|
});
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let cache = directory.path().join("cookie.json");
|
|
let args = TestArgs::parse_from([
|
|
"test",
|
|
&origin,
|
|
"--cookie-only",
|
|
"--cookie-cache",
|
|
cache.to_str().unwrap(),
|
|
])
|
|
.connect;
|
|
let lock = directory.path().join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: true,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
cookie_store::save(
|
|
&cache,
|
|
&StoredCookie::new(
|
|
args.server.clone(),
|
|
"alice".into(),
|
|
handler.os_profile.borrow().host_identity().host_id().into(),
|
|
origin.clone(),
|
|
AuthCookieCredential::new("alice", "portal-cookie", ""),
|
|
),
|
|
)
|
|
.unwrap();
|
|
let result = if portal_discovery {
|
|
handler.connect_portal_with_prelogin(&origin).await
|
|
} else {
|
|
handler.handle_impl().await
|
|
};
|
|
let error = result.unwrap_err();
|
|
let Some(gpapi::error::PortalError::NetworkError(network)) = error.downcast_ref() else {
|
|
panic!("Expected a network error, got {error:?}");
|
|
};
|
|
assert!(network.is_request());
|
|
assert!(!network.is_connect());
|
|
assert!(!network.is_timeout());
|
|
assert!(cache.exists(), "an unanswered request must not delete the cookie cache");
|
|
let request = worker.await.unwrap();
|
|
assert!(request.contains("portal-cookie"));
|
|
if portal_discovery {
|
|
assert!(request.starts_with("POST /global-protect/getconfig.esp "));
|
|
} else {
|
|
assert!(request.starts_with("POST /ssl-vpn/login.esp "));
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_rejection() {
|
|
let (origin, worker) = gateway(vec![
|
|
(
|
|
"200 OK",
|
|
"<prelogin-response><status>Success</status></prelogin-response>".into(),
|
|
),
|
|
("403 Forbidden", "<response><error>rejected</error></response>".into()),
|
|
("200 OK", login_response()),
|
|
])
|
|
.await;
|
|
let args = TestArgs::parse_from(["test", &origin, "--user", "alice", "--passwd-on-stdin"]).connect;
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let lock = directory.path().join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: true,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
handler.password_from_stdin.replace(Some("gateway-password".into()));
|
|
let mut value = serde_json::to_value(Gateway::new("internal".into(), origin.clone())).unwrap();
|
|
value["kind"] = serde_json::json!("internal");
|
|
let gateway: Gateway = serde_json::from_value(value).unwrap();
|
|
let session = handler
|
|
.authenticate_gateway(
|
|
&origin,
|
|
&origin,
|
|
&AuthCookieCredential::new("alice", "rejected-cookie", ""),
|
|
false,
|
|
GatewayLoginContext::new(&gateway, GatewaySelection::Auto),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(session.authentication.mode(), SessionMode::Tunnel);
|
|
assert!(session.extension_auth.binding().is_none());
|
|
let requests = worker.await.unwrap();
|
|
assert_eq!(requests.len(), 3);
|
|
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 {
|
|
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 {
|
|
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 {
|
|
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 {
|
|
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);
|
|
}
|
|
|
|
#[cfg(all(
|
|
feature = "webview-auth",
|
|
any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")
|
|
))]
|
|
mod gtk_retry {
|
|
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn real_gtk_crash_retries_bundled_authenticator() {
|
|
// Environment overrides belong to a separate test process, never the parallel test runner.
|
|
if let Some(directory) = std::env::var_os("GP_TEST_GTK_AUTH_DIR") {
|
|
verify_real_authenticator_retry(std::path::Path::new(&directory)).await;
|
|
} else {
|
|
run_real_authenticator_retry(false);
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
#[test]
|
|
#[ignore = "requires non-interactive sudo authorization and a running Wayland desktop session"]
|
|
fn sudo_gtk_crash_retries_after_restoring_desktop_environment() {
|
|
run_real_authenticator_retry(true);
|
|
}
|
|
|
|
fn run_real_authenticator_retry(sudo: bool) {
|
|
use std::{fs, os::unix::fs::PermissionsExt, process::Command};
|
|
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let executable = directory.path().join("gpauth");
|
|
// Fixtures contain only dummy data and must remain accessible after a root test drops privileges.
|
|
fs::set_permissions(directory.path(), fs::Permissions::from_mode(0o755)).unwrap();
|
|
let attempts_path = directory.path().join("attempts");
|
|
fs::write(&attempts_path, "").unwrap();
|
|
fs::set_permissions(&attempts_path, fs::Permissions::from_mode(0o666)).unwrap();
|
|
fs::write(&executable, r#"#!/bin/sh
|
|
set -eu
|
|
request=
|
|
while [ "$#" -gt 0 ]; do
|
|
if [ "$1" = '--saml-request' ]; then
|
|
shift
|
|
request=$1
|
|
fi
|
|
shift
|
|
done
|
|
printf '%s|%s|%s|%s\n' "$(id -u)" "${WAYLAND_DISPLAY:-}" "${WEBKIT_DISABLE_DMABUF_RENDERER-unset}" "$request" >> "$GP_TEST_GTK_AUTH_DIR/attempts"
|
|
if [ "$request" = 'old' ]; then
|
|
printf 'Gdk-Message: 10:49:22.617: Error 71 (Protocol error) dispatching to Wayland display.\n' >&2
|
|
exit 1
|
|
fi
|
|
[ "$request" = 'new' ] && [ "${WEBKIT_DISABLE_DMABUF_RENDERER:-}" = '1' ] || exit 2
|
|
printf '%s\n' '{"success":{"username":"alice","preloginCookie":"new-cookie"}}'
|
|
"#).unwrap();
|
|
fs::set_permissions(&executable, fs::Permissions::from_mode(0o755)).unwrap();
|
|
|
|
let mut command = if sudo {
|
|
assert_ne!(
|
|
uzers::get_effective_uid(),
|
|
0,
|
|
"run this test as the Wayland desktop user"
|
|
);
|
|
let mut command = Command::new("sudo");
|
|
command.args([
|
|
"-n",
|
|
"env",
|
|
"-u",
|
|
"WAYLAND_DISPLAY",
|
|
"-u",
|
|
"DISPLAY",
|
|
"-u",
|
|
"XDG_SESSION_TYPE",
|
|
"-u",
|
|
"WEBKIT_DISABLE_DMABUF_RENDERER",
|
|
]);
|
|
command.arg("GP_TEST_EXPECT_ROOT=1");
|
|
command
|
|
} else {
|
|
let mut command = Command::new("env");
|
|
command.arg("-u").arg("WEBKIT_DISABLE_DMABUF_RENDERER");
|
|
command.arg("WAYLAND_DISPLAY=wayland-test");
|
|
command
|
|
};
|
|
command.arg(format!("GP_AUTH_BINARY={}", executable.display()));
|
|
command.arg(format!("GP_TEST_GTK_AUTH_DIR={}", directory.path().display()));
|
|
command.arg(std::env::current_exe().unwrap()).args([
|
|
"--exact",
|
|
"connect::flow_tests::gtk_retry::real_gtk_crash_retries_bundled_authenticator",
|
|
"--nocapture",
|
|
]);
|
|
let output = command.output().unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"retry subprocess failed: {}\n{}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
let expected_uid = gpapi::process::users::get_non_root_user().unwrap().uid().to_string();
|
|
let attempts = fs::read_to_string(attempts_path).unwrap();
|
|
let attempts: Vec<Vec<&str>> = attempts.lines().map(|line| line.split('|').collect()).collect();
|
|
assert_eq!(attempts.len(), 2, "expected exactly one retry");
|
|
for attempt in &attempts {
|
|
assert_eq!(attempt[0], expected_uid, "authenticator must run as the desktop user");
|
|
assert!(!attempt[1].is_empty(), "authenticator must receive WAYLAND_DISPLAY");
|
|
}
|
|
assert_eq!(&attempts[0][2..], ["unset", "old"]);
|
|
assert_eq!(&attempts[1][2..], ["1", "new"]);
|
|
}
|
|
|
|
async fn verify_real_authenticator_retry(directory: &std::path::Path) {
|
|
use gpapi::credential::Credential;
|
|
|
|
if std::env::var_os("GP_TEST_EXPECT_ROOT").is_some() {
|
|
assert_eq!(uzers::get_effective_uid(), 0);
|
|
assert!(std::env::var_os("SUDO_UID").is_some());
|
|
assert!(std::env::var_os("WAYLAND_DISPLAY").is_none());
|
|
}
|
|
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]).connect;
|
|
let lock = directory.join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: true,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
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!(matches!(credential, Credential::Prelogin(ref value) if value.prelogin_cookie() == Some("new-cookie")));
|
|
assert_eq!(
|
|
worker.await.unwrap().len(),
|
|
2,
|
|
"recovery must fetch fresh prelogin data"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn unsupported_and_malformed_identities_fail_before_password_prompt_or_network_connection() {
|
|
use gpapi::utils::request::RequestIdentityError;
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let malformed = directory.path().join("invalid.p12");
|
|
std::fs::write(&malformed, b"not a certificate archive").unwrap();
|
|
let fixtures =
|
|
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../crates/gpapi/tests/files/client-identity");
|
|
|
|
for (certificate, key, expected) in [
|
|
(
|
|
fixtures.join("rsa-pss-cert.pem"),
|
|
Some(fixtures.join("rsa-pss.pem")),
|
|
"algorithm",
|
|
),
|
|
(fixtures.join("legacy-RC2-128.p12"), None, "encryption"),
|
|
(malformed, None, "malformed"),
|
|
] {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let server = format!("https://{}", listener.local_addr().unwrap());
|
|
let mut argv = vec![
|
|
"test".to_owned(),
|
|
server,
|
|
"--as-gateway".to_owned(),
|
|
"--certificate".to_owned(),
|
|
certificate.to_string_lossy().into_owned(),
|
|
];
|
|
if let Some(key) = key {
|
|
argv.extend(["--sslkey".to_owned(), key.to_string_lossy().into_owned()]);
|
|
}
|
|
let args = TestArgs::parse_from(argv).connect;
|
|
let lock = directory.path().join("client.pid");
|
|
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
|
let shared = SharedArgs {
|
|
ignore_tls_errors: false,
|
|
lock_file: &lock,
|
|
verbose: &verbose,
|
|
log_format: LogFormat::Text,
|
|
};
|
|
let handler = ConnectHandler::new(&args, &shared);
|
|
let error = tokio::time::timeout(Duration::from_secs(2), handler.handle_attempt())
|
|
.await
|
|
.expect("identity failure must not wait for a password or server")
|
|
.unwrap_err();
|
|
match (expected, error.downcast_ref::<RequestIdentityError>()) {
|
|
("algorithm", Some(RequestIdentityError::UnsupportedKeyAlgorithm("RSA-PSS"))) => {}
|
|
("encryption", Some(RequestIdentityError::UnsupportedEncryption)) => {}
|
|
("malformed", Some(RequestIdentityError::InvalidPkcs12(_) | RequestIdentityError::InvalidCertificate)) => {}
|
|
_ => panic!("{expected}: unexpected failure {error:#}"),
|
|
}
|
|
assert!(
|
|
tokio::time::timeout(Duration::from_millis(20), listener.accept())
|
|
.await
|
|
.is_err(),
|
|
"{expected}: local identity failure must precede network access"
|
|
);
|
|
}
|
|
}
|