use std::{ borrow::Cow, net::{SocketAddr, UdpSocket}, }; use anyhow::bail; use log::{debug, info, warn}; use reqwest::Client; use tokio_util::sync::CancellationToken; use urlencoding::{decode, encode}; use xmltree::Element; use zeroize::Zeroizing; use crate::{ credential::Credential, error::PortalError, gateway::GatewayLoginContext, gp_params::GpParams, params::gateway_login::{self, GatewayLoginInput}, session::GatewayAuthentication, utils::{normalize_server, parse_gp_response, redact::redact_uri, remove_url_scheme, xml::ElementExt}, }; pub enum GatewayLogin { Authenticated(GatewayAuthentication), Mfa(String, String), } /// Protocol failures cannot be repaired by repeating login with different /// credentials. Issued credentials, when identifiable, are cleaned up first. #[derive(Debug, thiserror::Error)] #[error("Gateway login returned invalid session configuration")] pub struct GatewayLoginProtocolError; #[derive(Clone)] pub struct GatewayLoginClient { origin: reqwest::Url, client: Client, params: GpParams, login_endpoint: Option, login_url: Option, peer_certificate: Option>, } impl GatewayLoginClient { pub fn new(gateway: &str, params: GpParams) -> anyhow::Result { let origin = reqwest::Url::parse(&normalize_server(gateway)?)?; let client = Client::try_from(¶ms)?; Ok(Self { origin, client, params, login_endpoint: None, login_url: None, peer_certificate: None, }) } pub(crate) fn login_endpoint(&self) -> Option { self.login_endpoint } pub(crate) fn params(&self) -> &GpParams { &self.params } pub fn client_identity(&self) -> Option<&crate::utils::request::ClientIdentity> { self.params.client_identity() } pub(crate) fn request_client(&self) -> &Client { &self.client } pub(crate) fn origin(&self) -> &reqwest::Url { &self.origin } /// DER certificate from the TLS connection that returned the login response. /// Callers must retain normal certificate verification when using it as a pin. pub fn authenticated_url(&self) -> Option<&reqwest::Url> { self.login_url.as_ref() } pub fn peer_certificate(&self) -> Option<&[u8]> { self.peer_certificate.as_deref() } pub fn respond_mfa(&mut self, input: &str, otp: &str) { self.params.set_input_str(input); self.params.set_otp(otp); } pub async fn login( &mut self, cred: &Credential, context: Option<&GatewayLoginContext>, cancellation: &CancellationToken, ) -> anyhow::Result { if cancellation.is_cancelled() { return Err(crate::auth::AuthenticationCancelled.into()); } let client_ip = context.and_then(|context| { context .client_ip() .map(str::to_owned) .or_else(|| self.origin.host_str().and_then(detect_local_ipv4)) }); let request = receive_gateway_login( &self.origin, &self.client, cred, &self.params, context, client_ip.as_deref(), false, ); let response = tokio::select! { biased; response = request => response?, _ = cancellation.cancelled() => return Err(crate::auth::AuthenticationCancelled.into()), }; // Once the full response is available, retain issued authentication or finish // cleanup-only logout before the caller observes cancellation. let response = parse_login_response(response, &self.client, &self.origin, &self.params).await?; self.peer_certificate = response.peer_certificate; self.login_endpoint = response.endpoint; self.login_url = Some(response.url); Ok(response.login) } pub(crate) async fn extend_lifetime(&self, cred: &Credential) -> anyhow::Result { let response = receive_gateway_login(&self.origin, &self.client, cred, &self.params, None, None, true).await?; Ok( parse_login_response(response, &self.client, &self.origin, &self.params) .await? .login, ) } } struct LoginResponse { peer_certificate: Option>, login: GatewayLogin, endpoint: Option, url: reqwest::Url, } struct ReceivedLogin { peer_certificate: Option>, body: String, endpoint: Option, url: reqwest::Url, } fn detect_local_ipv4(host: &str) -> Option { let socket = UdpSocket::bind("0.0.0.0:0").ok()?; socket.connect((host, 443)).ok()?; let ip = socket.local_addr().ok()?.ip(); if ip.is_ipv4() { Some(ip.to_string()) } else { None } } async fn receive_gateway_login( origin: &reqwest::Url, client: &Client, cred: &Credential, gp_params: &GpParams, context: Option<&GatewayLoginContext>, client_ip: Option<&str>, extend_lifetime: bool, ) -> anyhow::Result { let gateway = remove_url_scheme(origin.as_str().trim_end_matches('/')); let login_url = format!("{}/ssl-vpn/login.esp", origin.as_str().trim_end_matches('/')); let request_params = gateway_login::build(&GatewayLoginInput { gp_params, cred, gateway_host: &gateway, context, client_ip, extend_lifetime, }); info!("Perform gateway login, user_agent: {}", gp_params.user_agent()); log_gateway_login_context(context, client_ip, gp_params); let res = client .post(&login_url) .form(&request_params.body) .send() .await .map_err(|e| { warn!("Network error: {:?}", e); match crate::error::ServerTlsError::from_request(origin, &e, gp_params.has_client_identity()) { Some(tls) => tls, None => anyhow::anyhow!(PortalError::NetworkError(e)), } })?; let peer_certificate = res .extensions() .get::() .and_then(|info| info.peer_certificate()) .map(<[u8]>::to_vec); let endpoint = res.remote_addr(); let url = res.url().clone(); let http_version = res.version(); let content_type = res.headers().get(reqwest::header::CONTENT_TYPE).cloned(); let res = parse_gp_response(res).await.map_err(|mut err| { // Redirect paths and query strings can contain authentication tokens. Log // only the redacted origin and whether the response is from the login path. warn!( "Gateway login response failed: status={}, reason={}, http={:?}, origin={}, port={:?}, redirected={}, login_endpoint={}, content_type={:?}, client_certificate={}, ignore_tls_errors={}", err.status, err.reason, http_version, redact_uri(&url.origin().ascii_serialization()), url.port_or_known_default(), url.as_str() != login_url, url.path() == "/ssl-vpn/login.esp", content_type, gp_params.has_client_identity(), gp_params.ignore_tls_errors(), ); if let Some(tls) = crate::error::ServerTlsError::from_request(origin, &err, gp_params.has_client_identity()) { return tls; } if let Some(error) = err.take_body_read_error() { return PortalError::NetworkError(error).into(); } if gp_params.os_profile().client_os() == crate::os_profile::ClientOs::Ios && err.is_authentication_rejection() { return anyhow::anyhow!(crate::error::AuthenticationRejected); } anyhow::anyhow!("Gateway login error: {}", err.reason) })?; Ok(ReceivedLogin { peer_certificate, body: res, endpoint, url, }) } async fn parse_login_response( response: ReceivedLogin, client: &Client, origin: &reqwest::Url, gp_params: &GpParams, ) -> anyhow::Result { let ReceivedLogin { peer_certificate, body: res, endpoint, url, } = response; // It's possible to get an empty response, log the response headers for debugging if res.trim().is_empty() { info!("Empty gateway login response headers: {:?}", res); bail!("Got empty gateway login response"); } // MFA detected if res.contains("Challenge") { let Some((message, input_str)) = parse_mfa(&res) else { bail!("Failed to parse MFA challenge"); }; return Ok(LoginResponse { peer_certificate, login: GatewayLogin::Mfa(message, input_str), endpoint, url, }); } let lower = res.to_ascii_lowercase(); if lower.contains(" authentication, Err(_) => { match tokio::time::timeout( std::time::Duration::from_secs(5), crate::session::transport::logout_cookie(client, origin, &cookie, gp_params.os_profile()), ) .await { Ok(Ok(())) => {} Ok(Err(error)) => warn!("Cleanup-only gateway logout failed: {error}"), Err(_) => warn!("Cleanup-only gateway logout timed out"), } return Err(GatewayLoginProtocolError.into()); } }; debug!("Gateway login succeeded, mode: {:?}", authentication.mode()); Ok(LoginResponse { peer_certificate, login: GatewayLogin::Authenticated(authentication), endpoint, url, }) } fn log_gateway_login_context(context: Option<&GatewayLoginContext>, client_ip: Option<&str>, gp_params: &GpParams) { let Some(context) = context else { return; }; info!( "Gateway login context: host_present={}, gateway_name_present={}, connect_method_present={}, selection_type={}, internal={}, clientgpversion_present={}, client_ip_present={}", !context.host().is_empty(), !context.name().is_empty(), context.connect_method().is_some(), context.selection().as_login_param(), context.kind().as_login_param(), gp_params.client_version().is_some(), client_ip.is_some() ); } fn parse_issued_authentication(element: &Element, computer: &str) -> anyhow::Result<(String, anyhow::Result)> { anyhow::ensure!(element.name == "jnlp", "Gateway login response is not JNLP"); anyhow::ensure!( element.attr("status").is_none_or(|status| status == "success"), "Gateway login response rejected authentication" ); let application = element .child("application-desc") .ok_or_else(|| anyhow::anyhow!("Gateway login response has no application description"))?; let args = application .children("argument") .iter() .map(|e| e.get_text().unwrap_or_default()) .collect::>(); let cookie = build_gateway_token(&args, computer)?; let connection_type = read_arg_value(&args, 12) .and_then(|mode| mode.ok_or_else(|| anyhow::anyhow!("Gateway login response has no connection type"))); Ok((cookie, connection_type)) } #[cfg(test)] fn parse_gateway_authentication(element: &Element, computer: &str) -> anyhow::Result { let (cookie, mode) = parse_issued_authentication(element, computer)?; GatewayAuthentication::new(cookie, mode?) } fn build_gateway_token(args: &[Cow<'_, str>], computer: &str) -> anyhow::Result { let mut params = vec![ read_required_arg(&args, 1, "authcookie")?, read_optional_arg(&args, 2, "persistent-cookie")?, read_optional_arg(&args, 3, "portal")?, read_required_arg(&args, 4, "user")?, read_optional_arg(&args, 7, "domain")?, read_optional_arg(&args, 15, "preferred-ip")?, read_optional_arg(&args, 18, "preferred-ipv6")?, ] .into_iter() .flatten() .collect::>(); params.push(("computer", computer.to_string())); let token = params .iter() .map(|(k, v)| format!("{}={}", k, encode(v))) .collect::>() .join("&"); Ok(token) } fn read_required_arg( args: &[Cow<'_, str>], index: usize, key: &'static str, ) -> anyhow::Result> { let Some(value) = read_arg_value(args, index)? else { bail!("Failed to read {key} from args"); }; Ok(Some((key, value))) } fn read_optional_arg( args: &[Cow<'_, str>], index: usize, key: &'static str, ) -> anyhow::Result> { Ok(read_arg_value(args, index)?.map(|value| (key, value))) } fn read_arg_value(args: &[Cow<'_, str>], index: usize) -> anyhow::Result> { Ok( args .get(index) .map(|s| normalize_arg_value(s.as_ref())) .transpose() .map_err(|err| anyhow::anyhow!("Failed to decode gateway login argument {index}: {err}"))? .flatten(), ) } fn normalize_arg_value(value: &str) -> anyhow::Result> { let value = decode(value)?; if value.is_empty() || value == "(null)" || value == "-1" { return Ok(None); } anyhow::ensure!( !value.chars().any(char::is_control), "Gateway argument contains control characters" ); Ok(Some(value.into_owned())) } fn parse_mfa(res: &str) -> Option<(String, String)> { let message = res .lines() .find(|l| l.contains("respMsg")) .and_then(|l| l.split('"').nth(1).map(|s| s.to_string()))?; let input_str = res .lines() .find(|l| l.contains("inputStr")) .and_then(|l| l.split('"').nth(1).map(|s| s.to_string()))?; Some((message, input_str)) } #[cfg(test)] mod tests { use super::*; fn tunnel_response() -> String { let root = login_response(Some("tunnel"), "issued-cookie"); let mut xml = Vec::new(); root.write(&mut xml).unwrap(); crate::session::transport::tests::response(std::str::from_utf8(&xml).unwrap()) } fn test_params() -> GpParams { GpParams::builder( crate::os_profile::OsProfile::builder(crate::os_profile::ClientOs::Linux) .build(crate::os_profile::test_snapshot()), ) .build() } #[tokio::test] async fn failed_login_logs_http_context_without_credentials_or_redirect_tokens() { use std::cell::RefCell; thread_local! { static MESSAGES: RefCell> = const { RefCell::new(Vec::new()) }; } struct Logger; impl log::Log for Logger { fn enabled(&self, _: &log::Metadata<'_>) -> bool { true } fn log(&self, record: &log::Record<'_>) { let message = record.args().to_string(); if message.starts_with("Gateway login response failed:") { MESSAGES.with_borrow_mut(|messages| messages.push(message)); } } fn flush(&self) {} } log::set_logger(&Logger).unwrap(); log::set_max_level(log::LevelFilter::Warn); for (status, reason, redirected) in [ (403, None, false), (502, None, true), (401, Some("access denied"), false), ] { let body = "response-body-secret"; let mut responses = Vec::new(); if redirected { responses.push( "HTTP/1.1 307 Temporary Redirect\r\nLocation: /path-secret?token=query-secret\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(), ); } let reason_header = reason .map(|reason| format!("x-private-pan-globalprotect: {reason}\r\n")) .unwrap_or_default(); responses.push(format!( "HTTP/1.1 {status} Error\r\nContent-Type: text/html\r\nSet-Cookie: cookie-secret\r\n{reason_header}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() )); let (_, origin, server) = crate::session::transport::tests::login_gateway(responses).await; let mut client = GatewayLoginClient::new(origin.as_str(), test_params()).unwrap(); let credential = crate::credential::PasswordCredential::new("username-secret", "password-secret").into(); let error = client .login(&credential, None, &CancellationToken::new()) .await .err() .unwrap(); server.await.unwrap(); assert_eq!( error.to_string(), format!("Gateway login error: {}", reason.unwrap_or("")) ); let messages = MESSAGES.with_borrow_mut(std::mem::take); assert_eq!(messages.len(), 1); let message = &messages[0]; for expected in [ format!("status={status}"), format!("reason={}", reason.unwrap_or("")), format!("port={:?}", origin.port()), format!("redirected={redirected}"), format!("login_endpoint={}", !redirected), "http=HTTP/1.1".into(), "content_type=Some(\"text/html\")".into(), "client_certificate=false".into(), "ignore_tls_errors=false".into(), ] { assert!(message.contains(&expected), "missing {expected}: {message}"); } assert!(!message.contains("secret"), "sensitive data in diagnostic: {message}"); assert!(!message.contains("127.0.0.1"), "unredacted origin: {message}"); } } #[tokio::test] async fn gateway_login_cancels_stalled_headers_and_body() { use tokio::io::{AsyncReadExt, AsyncWriteExt}; for partial_response in ["", "HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n"] { let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let origin = format!("http://{}", listener.local_addr().unwrap()); let (ready, received) = tokio::sync::oneshot::channel(); let (release, released) = tokio::sync::oneshot::channel(); let server = tokio::spawn(async move { let (mut socket, _) = listener.accept().await.unwrap(); let mut buffer = [0; 4096]; assert!(socket.read(&mut buffer).await.unwrap() > 0); socket.write_all(partial_response.as_bytes()).await.unwrap(); ready.send(()).unwrap(); released.await.unwrap(); }); let cancellation = CancellationToken::new(); let token = cancellation.clone(); let login = tokio::spawn(async move { let mut client = GatewayLoginClient::new(&origin, test_params()).unwrap(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); client.login(&credential, None, &token).await }); received.await.unwrap(); cancellation.cancel(); let result = tokio::time::timeout(std::time::Duration::from_secs(1), login) .await .unwrap() .unwrap(); assert!(result.err().unwrap().is::()); release.send(()).unwrap(); server.await.unwrap(); } } #[tokio::test] async fn cancellation_during_cleanup_only_logout_awaits_cleanup() { use crate::session::transport::tests::response; use tokio::io::{AsyncReadExt, AsyncWriteExt}; let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let origin = format!("http://{}", listener.local_addr().unwrap()); let mut xml = Vec::new(); login_response(None, "issued-cookie").write(&mut xml).unwrap(); let login_response = response(std::str::from_utf8(&xml).unwrap()); let (ready, received) = tokio::sync::oneshot::channel(); let (release, released) = tokio::sync::oneshot::channel(); let server = tokio::spawn(async move { let (mut socket, _) = listener.accept().await.unwrap(); let mut buffer = [0; 4096]; assert!(socket.read(&mut buffer).await.unwrap() > 0); socket.write_all(login_response.as_bytes()).await.unwrap(); drop(socket); let (mut socket, _) = listener.accept().await.unwrap(); let read = socket.read(&mut buffer).await.unwrap(); assert!( std::str::from_utf8(&buffer[..read]) .unwrap() .contains("/ssl-vpn/logout.esp") ); ready.send(()).unwrap(); released.await.unwrap(); socket .write_all(response("").as_bytes()) .await .unwrap(); }); let cancellation = CancellationToken::new(); let token = cancellation.clone(); let mut login = tokio::spawn(async move { let mut client = GatewayLoginClient::new(&origin, test_params()).unwrap(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); client.login(&credential, None, &token).await }); received.await.unwrap(); cancellation.cancel(); assert!( tokio::time::timeout(std::time::Duration::from_millis(20), &mut login) .await .is_err() ); release.send(()).unwrap(); assert!(login.await.unwrap().err().unwrap().is::()); server.await.unwrap(); } #[tokio::test] async fn ordinary_tunnel_login_follows_redirects_without_physical_binding() { let (_, origin, server) = crate::session::transport::tests::login_gateway(vec![ "HTTP/1.1 307 Temporary Redirect\r\nLocation: /redirected-login\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(), tunnel_response(), "HTTP/1.1 307 Temporary Redirect\r\nLocation: /redirected-login\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(), tunnel_response(), ]).await; let mut client = GatewayLoginClient::new(origin.as_str(), test_params()).unwrap(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); assert!( matches!(client.login(&credential, None, &CancellationToken::new()).await.unwrap(), GatewayLogin::Authenticated(authentication) if authentication.mode() == crate::session::SessionMode::Tunnel) ); assert!(matches!( client.extend_lifetime(&credential).await.unwrap(), GatewayLogin::Authenticated(_) )); let requests = server.await.unwrap(); assert_eq!(requests[0].0, "/ssl-vpn/login.esp"); assert_eq!(requests[1].0, "/redirected-login"); assert_eq!(requests[3].0, "/redirected-login"); assert!(requests[3].1.contains("extend-lifetime=true")); } #[tokio::test] async fn ordinary_login_keeps_reqwest_address_fallback() { let (_, origin, server) = crate::session::transport::tests::login_gateway(vec![tunnel_response()]).await; let port = origin.port().unwrap(); let params = test_params(); let mut client = GatewayLoginClient::new(&format!("http://gateway.invalid:{port}"), params.clone()).unwrap(); // Supply deterministic DNS candidates; all other client behavior is the // ordinary request path. The first address refuses, the second is reachable. client.client = params .client_builder() .unwrap() .no_proxy() .resolve_to_addrs( "gateway.invalid", &[ SocketAddr::from((std::net::Ipv6Addr::LOCALHOST, port)), SocketAddr::from(([127, 0, 0, 1], port)), ], ) .build() .unwrap(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); assert!(matches!( client .login(&credential, None, &CancellationToken::new()) .await .unwrap(), GatewayLogin::Authenticated(_) )); assert_eq!(server.await.unwrap().len(), 1); } #[tokio::test] async fn ordinary_tunnel_login_can_use_a_proxy_without_local_gateway_resolution() { let (_, proxy, server) = crate::session::transport::tests::login_gateway(vec![tunnel_response()]).await; let params = test_params(); let mut client = GatewayLoginClient::new("http://unresolvable.invalid", params.clone()).unwrap(); client.client = params .client_builder() .unwrap() .proxy(reqwest::Proxy::all(proxy.as_str()).unwrap()) .build() .unwrap(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); assert!(matches!( client .login(&credential, None, &CancellationToken::new()) .await .unwrap(), GatewayLogin::Authenticated(_) )); assert_eq!( server.await.unwrap()[0].0, "http://unresolvable.invalid/ssl-vpn/login.esp" ); } #[tokio::test] async fn invalid_mode_logs_out_issued_cookie_before_returning_protocol_error() { use crate::session::transport::tests::{login_gateway, response}; let root = login_response(None, "issued-cookie"); let mut xml = Vec::new(); root.write(&mut xml).unwrap(); let (client, origin, server) = login_gateway(vec![ response(std::str::from_utf8(&xml).unwrap()), response(""), ]) .await; let params = GpParams::builder( crate::os_profile::OsProfile::builder(crate::os_profile::ClientOs::Linux) .build(crate::os_profile::test_snapshot()), ) .build(); let credential = crate::credential::PasswordCredential::new("alice", "password").into(); let mut client = GatewayLoginClient { client, ..GatewayLoginClient::new(origin.as_str(), params).unwrap() }; let error = client .login(&credential, None, &CancellationToken::new()) .await .err() .unwrap(); assert!(error.is::()); let requests = server.await.unwrap(); assert_eq!(requests.len(), 2); assert_eq!(requests[0].0, "/ssl-vpn/login.esp"); assert_eq!(requests[1].0, "/ssl-vpn/logout.esp"); let form: std::collections::HashMap = serde_urlencoded::from_str(&requests[1].1).unwrap(); assert_eq!(form.get("authcookie").map(String::as_str), Some("issued-cookie")); assert_eq!(form.get("user").map(String::as_str), Some("alice")); } #[test] fn cleanup_only_parsing_does_not_salvage_server_error_authentication() { let mut root = login_response(None, "issued-cookie"); root.attributes.insert("status".into(), "error".into()); assert!(parse_issued_authentication(&root, "computer").is_err()); for encoded in ["%28null%29", "%2D1", "%00"] { assert!(parse_issued_authentication(&login_response(Some("tunnel"), encoded), "computer").is_err()); } } fn login_response(mode: Option<&str>, cookie: &str) -> Element { let mut args = vec![""; 19]; args[1] = cookie; args[4] = "alice"; if let Some(mode) = mode { args[12] = mode; } let arguments = args .iter() .map(|value| format!("{value}")) .collect::(); Element::parse(format!("{arguments}").as_bytes()).unwrap() } #[test] fn login_mode_is_independent_of_network_location() { for (value, mode) in [ ("tunnel", crate::session::SessionMode::Tunnel), ("non-tunnel", crate::session::SessionMode::NonTunnel), ("internal", crate::session::SessionMode::NonTunnel), ] { let authentication = parse_gateway_authentication(&login_response(Some(value), "test-cookie"), "computer").unwrap(); assert_eq!(authentication.mode(), mode); assert_eq!(authentication.connection_type(), value); assert!(!format!("{authentication:?}").contains("test-cookie")); } } #[test] fn login_rejects_missing_mode_or_cookie() { for mode in [None, Some(""), Some("(null)"), Some("-1"), Some(" ")] { assert!(parse_gateway_authentication(&login_response(mode, "test-cookie"), "computer").is_err()); } assert!(parse_gateway_authentication(&login_response(Some("tunnel"), ""), "computer").is_err()); let response = Element::parse(b"".as_slice()).unwrap(); assert!(parse_gateway_authentication(&response, "computer").is_err()); } #[test] fn mfa() { let res = r#"var respStatus = "Challenge"; var respMsg = "MFA message"; thisForm.inputStr.value = "5ef64e83000119ed";"#; let (message, input_str) = parse_mfa(res).unwrap(); assert_eq!(message, "MFA message"); assert_eq!(input_str, "5ef64e83000119ed"); } #[test] fn gateway_token_keeps_upstream_cookie_fields() { let res = r#" AUTHCOOKIE PERSISTENTCOOKIE vpn.example.com alice LDAP-auth vsys1 %28empty_domain%29 tunnel -1 4100 10.0.0.10 unused-user-cookie unused-prelogon-cookie 2001:db8::10 "#; let root = Element::parse(res.as_bytes()).unwrap(); let authentication = parse_gateway_authentication(&root, "metalklesk").unwrap(); let token = authentication.cookie(); assert_eq!(authentication.mode(), crate::session::SessionMode::Tunnel); assert_eq!( token, "authcookie=AUTHCOOKIE&persistent-cookie=PERSISTENTCOOKIE&portal=vpn.example.com&user=alice&domain=%28empty_domain%29&preferred-ip=10.0.0.10&preferred-ipv6=2001%3Adb8%3A%3A10&computer=metalklesk" ); } #[test] fn gateway_token_omits_empty_optional_fields() { let res = r#" AUTHCOOKIE vpn.example.com alice LDAP-auth vsys1 -1 tunnel -1 4100 unused-user-cookie unused-prelogon-cookie (null) "#; let root = Element::parse(res.as_bytes()).unwrap(); let authentication = parse_gateway_authentication(&root, "metalklesk").unwrap(); let token = authentication.cookie(); assert_eq!( token, "authcookie=AUTHCOOKIE&portal=vpn.example.com&user=alice&computer=metalklesk" ); } }