Files
GlobalProtect-openconnect/crates/gpapi/src/utils/redact.rs
T
Kevin Yue 888dc93643 refactor: align GP profile and packaging flow
Main changes:

- Refactor connect/auth flows around a single OS profile and host identity model, including gateway fallback and cookie-on-stdin handling.

- Align request parameters, HIP host-id propagation, SAML webview user-agent behavior, and portal default-browser handling with observed official client behavior.

- Add opt-in cookie cache support and Microsoft Defender HIP reporting while keeping host-id validation explicit.

- Add BSD build, packaging, release artifact, and provenance support with FreeBSD/OpenBSD path and dependency cleanup.

- Update NixOS install documentation and dependency compatibility fixes.
2026-06-19 21:23:29 +08:00

274 lines
6.5 KiB
Rust

use std::sync::RwLock;
use redact_engine::{Pattern, Redaction as RedactEngine};
use regex::Regex;
use url::{Url, form_urlencoded};
pub struct Redaction {
redact_engine: RwLock<Option<RedactEngine>>,
}
impl Default for Redaction {
fn default() -> Self {
Self::new()
}
}
impl Redaction {
pub fn new() -> Self {
let redact_engine = RedactEngine::custom("[**********]").add_pattern(Pattern {
test: Regex::new("(((25[0-5]|(2[0-4]|1\\d|[1-9]|)\\d)\\.?\\b){4})").unwrap(),
group: 1,
});
Self {
redact_engine: RwLock::new(Some(redact_engine)),
}
}
pub fn add_value(&self, text: &str) -> anyhow::Result<()> {
let mut redact_engine = self
.redact_engine
.write()
.map_err(|_| anyhow::anyhow!("Failed to acquire write lock on redact engine"))?;
*redact_engine = Some(
redact_engine
.take()
.ok_or_else(|| anyhow::anyhow!("Failed to take redact engine"))?
.add_value(text)?,
);
Ok(())
}
pub fn add_values(&self, texts: &[&str]) -> anyhow::Result<()> {
let mut redact_engine = self
.redact_engine
.write()
.map_err(|_| anyhow::anyhow!("Failed to acquire write lock on redact engine"))?;
*redact_engine = Some(
redact_engine
.take()
.ok_or_else(|| anyhow::anyhow!("Failed to take redact engine"))?
.add_values(texts.to_vec())?,
);
Ok(())
}
pub fn redact_str(&self, text: &str) -> String {
self
.redact_engine
.read()
.expect("Failed to acquire read lock on redact engine")
.as_ref()
.expect("Failed to get redact engine")
.redact_str(text)
}
}
/// Redact a value by replacing all but the first and last character with asterisks,
/// The length of the value to be redacted must be at least 3 characters.
/// e.g. "foo" -> "f**********o"
pub fn redact_value(text: &str) -> String {
if text.len() < 3 {
return text.to_string();
}
let mut redacted = String::new();
redacted.push_str(&text[0..1]);
redacted.push_str(&"*".repeat(10));
redacted.push_str(&text[text.len() - 1..]);
redacted
}
pub fn redact_uri(uri: &str) -> String {
let Ok(mut url) = Url::parse(uri) else {
return uri.to_string();
};
// Could be a data: URI
if url.cannot_be_a_base() {
if url.scheme() == "about" {
return uri.to_string();
}
if url.path().len() > 15 {
return format!(
"{}:{}{}",
url.scheme(),
&url.path()[0..10],
redact_value(&url.path()[10..])
);
}
return format!("{}:{}", url.scheme(), redact_value(url.path()));
}
let host = url.host_str().unwrap_or_default();
if url.set_host(Some(&redact_value(host))).is_err() {
let redacted_query = redact_query(url.query())
.as_deref()
.map(|query| format!("?{}", query))
.unwrap_or_default();
return format!("{}://[**********]{}{}", url.scheme(), url.path(), redacted_query);
}
let redacted_query = redact_query(url.query());
url.set_query(redacted_query.as_deref());
url.to_string()
}
pub fn redact_form_params(params: &[(&str, &str)]) -> String {
let mut pairs = params
.iter()
.map(|(key, value)| (*key, redact_form_value(key, value)))
.collect::<Vec<_>>();
pairs.sort_by(|(left, _), (right, _)| left.cmp(right));
form_urlencoded::Serializer::new(String::new())
.extend_pairs(pairs)
.finish()
}
fn redact_form_value(key: &str, value: &str) -> String {
if value.is_empty() || is_safe_form_param(key) {
return value.to_string();
}
format!("redacted-{}", value.len())
}
fn is_safe_form_param(key: &str) -> bool {
matches!(
key,
"clientVer"
| "clientos"
| "config-digest"
| "csc-digest"
| "csc-support"
| "direct"
| "ipv6-support"
| "jnlpReady"
| "ok"
| "os-version"
| "prot"
| "swg-auth-token"
| "swg-nonce"
)
}
fn redact_query(query: Option<&str>) -> Option<String> {
let query = query?;
let query_pairs = form_urlencoded::parse(query.as_bytes());
let mut redacted_pairs = query_pairs.map(|(key, value)| (key, redact_value(&value)));
let query = form_urlencoded::Serializer::new(String::new())
.extend_pairs(redacted_pairs.by_ref())
.finish();
Some(query)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_should_not_redact_value() {
let text = "fo";
assert_eq!(redact_value(text), "fo");
}
#[test]
fn it_should_redact_value() {
let text = "foo";
assert_eq!(redact_value(text), "f**********o");
}
#[test]
fn it_should_redact_dynamic_value() {
let redaction = Redaction::new();
redaction.add_value("foo").unwrap();
assert_eq!(redaction.redact_str("hello, foo, bar"), "hello, [**********], bar");
}
#[test]
fn it_should_redact_dynamic_values() {
let redaction = Redaction::new();
redaction.add_values(&["foo", "bar"]).unwrap();
assert_eq!(
redaction.redact_str("hello, foo, bar"),
"hello, [**********], [**********]"
);
}
#[test]
fn it_should_redact_uri() {
let uri = "https://foo.bar";
assert_eq!(redact_uri(uri), "https://f**********r/");
let uri = "https://foo.bar/";
assert_eq!(redact_uri(uri), "https://f**********r/");
let uri = "https://foo.bar/baz";
assert_eq!(redact_uri(uri), "https://f**********r/baz");
let uri = "https://foo.bar/baz?qux=quux";
assert_eq!(redact_uri(uri), "https://f**********r/baz?qux=q**********x");
}
#[test]
fn it_should_redact_form_params() {
let params = [
("portal-userauthcookie", "secret-cookie"),
("csc-support", "yes"),
("prelogin-cookie", ""),
];
assert_eq!(
redact_form_params(&params),
"csc-support=yes&portal-userauthcookie=redacted-13&prelogin-cookie="
);
}
#[test]
fn it_should_redact_data_uri() {
let uri = "data:text/plain;a";
assert_eq!(redact_uri(uri), "data:t**********a");
let uri = "data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==";
assert_eq!(redact_uri(uri), "data:text/plain;**********=");
let uri = "about:blank";
assert_eq!(redact_uri(uri), "about:blank");
}
#[test]
fn it_should_redact_ipv6() {
let uri = "https://[2001:db8::1]:8080";
assert_eq!(redact_uri(uri), "https://[**********]/");
let uri = "https://[2001:db8::1]:8080/";
assert_eq!(redact_uri(uri), "https://[**********]/");
let uri = "https://[2001:db8::1]:8080/baz";
assert_eq!(redact_uri(uri), "https://[**********]/baz");
let uri = "https://[2001:db8::1]:8080/baz?qux=quux";
assert_eq!(redact_uri(uri), "https://[**********]/baz?qux=q**********x");
}
}