use std::{borrow::Cow, collections::HashMap}; use anyhow::bail; use log::{debug, info, warn}; use reqwest::Client; use urlencoding::{decode, encode}; use xmltree::Element; use crate::{ credential::Credential, error::PortalError, gp_params::GpParams, utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt}, }; pub enum GatewayLogin { Cookie(String), Mfa(String, String), } pub async fn gateway_login(gateway: &str, cred: &Credential, gp_params: &GpParams) -> anyhow::Result { gateway_login_with_options(gateway, cred, gp_params, false).await } pub async fn gateway_login_with_extend_lifetime( gateway: &str, cred: &Credential, gp_params: &GpParams, ) -> anyhow::Result { gateway_login_with_options(gateway, cred, gp_params, true).await } async fn gateway_login_with_options( gateway: &str, cred: &Credential, gp_params: &GpParams, extend_lifetime: bool, ) -> anyhow::Result { let url = normalize_server(gateway)?; let gateway = remove_url_scheme(&url); let login_url = format!("{}/ssl-vpn/login.esp", url); let client = Client::try_from(gp_params)?; let params = build_gateway_login_params(&gateway, cred, gp_params, extend_lifetime); info!("Perform gateway login, user_agent: {}", gp_params.user_agent()); let res = client.post(&login_url).form(¶ms).send().await.map_err(|e| { warn!("Network error: {:?}", e); anyhow::anyhow!(PortalError::NetworkError(e)) })?; let res = parse_gp_response(res).await.map_err(|err| { warn!("{err}"); anyhow::anyhow!("Gateway login error: {}", err.reason) })?; // It's possible to get an empty response, log the response headers for debugging if res.trim().is_empty() { debug!("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: {res}"); }; return Ok(GatewayLogin::Mfa(message, input_str)); } debug!("Gateway login response: {}", res); let root = Element::parse(res.as_bytes())?; let cookie = build_gateway_token(&root, gp_params.computer())?; Ok(GatewayLogin::Cookie(cookie)) } fn build_gateway_login_params( gateway: &str, cred: &Credential, gp_params: &GpParams, extend_lifetime: bool, ) -> HashMap { let mut params = cred .to_params() .into_iter() .map(|(key, value)| (key.to_string(), value.to_string())) .collect::>(); params.extend( gp_params .to_params() .into_iter() .map(|(key, value)| (key.to_string(), value.to_string())), ); params.insert("server".to_string(), gateway.to_string()); if extend_lifetime { params.insert("extend-lifetime".to_string(), "true".to_string()); } params } fn build_gateway_token(element: &Element, computer: &str) -> anyhow::Result { let args = element .descendants("argument") .iter() .map(|e| e.get_text().unwrap_or_default()) .collect::>(); 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> { if value.is_empty() || value == "(null)" || value == "-1" { return Ok(None); } Ok(Some(decode(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::*; #[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 normal_gateway_login_params_do_not_extend_lifetime() { let cred = Credential::Password(crate::credential::PasswordCredential::new("alice", "secret")); let gp_params = GpParams::builder().build(); let params = build_gateway_login_params("vpn.example.com", &cred, &gp_params, false); assert!(!params.contains_key("extend-lifetime")); } #[test] fn extension_gateway_login_params_extend_lifetime() { let cred = Credential::Password(crate::credential::PasswordCredential::new("alice", "secret")); let gp_params = GpParams::builder().build(); let params = build_gateway_login_params("vpn.example.com", &cred, &gp_params, true); assert_eq!(params.get("extend-lifetime").map(String::as_str), Some("true")); } #[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 token = build_gateway_token(&root, "metalklesk").unwrap(); 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 token = build_gateway_token(&root, "metalklesk").unwrap(); assert_eq!( token, "authcookie=AUTHCOOKIE&portal=vpn.example.com&user=alice&computer=metalklesk" ); } }