grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! Redaction helpers for headers, URLs, structured fields and free text (SPEC §2.6).

use std::collections::BTreeMap;

use serde_json::Value;

/// Replacement text for redacted values.
pub const REDACTED: &str = "[REDACTED]";

const SENSITIVE_HEADER_PARTS: &[&str] = &[
    "token",
    "secret",
    "password",
    "api-key",
    "apikey",
    "key",
    "auth",
    "session",
    "signature",
    "credential",
];

const SENSITIVE_HEADERS: &[&str] = &[
    "authorization",
    "proxy-authorization",
    "cookie",
    "set-cookie",
];

/// Sensitive field and query names (case-insensitive substrings).
pub const SENSITIVE_FIELDS: &[&str] = &[
    "password",
    "passwd",
    "secret",
    "token",
    "authorization",
    "cookie",
    "api_key",
    "apikey",
    "api-key",
    "access_key",
    "private_key",
    "client_secret",
    "credential",
    "session",
    "signature",
];

/// Whether a header must be redacted.
pub fn is_sensitive_header(name: &str) -> bool {
    let lower = name.to_ascii_lowercase();
    SENSITIVE_HEADERS.contains(&lower.as_str())
        || SENSITIVE_HEADER_PARTS.iter().any(|p| lower.contains(p))
}

/// Whether a field or query parameter must be redacted.
pub fn is_sensitive_field(name: &str) -> bool {
    is_sensitive_field_with(name, &[])
}

fn is_sensitive_field_with(name: &str, extra: &[&str]) -> bool {
    let lower = name.to_ascii_lowercase();
    SENSITIVE_FIELDS.iter().any(|p| lower.contains(p))
        || extra
            .iter()
            .any(|p| lower.contains(&p.to_ascii_lowercase()))
}

/// Returns the headers with sensitive values replaced by [`REDACTED`].
pub fn redact_headers<I, K, V>(headers: I) -> BTreeMap<String, String>
where
    I: IntoIterator<Item = (K, V)>,
    K: AsRef<str>,
    V: AsRef<str>,
{
    headers
        .into_iter()
        .map(|(k, v)| {
            let name = k.as_ref().to_ascii_lowercase();
            let value = if is_sensitive_header(&name) {
                REDACTED.to_owned()
            } else {
                v.as_ref().to_owned()
            };
            (name, value)
        })
        .collect()
}

/// Redacts the password in the user info and the values of sensitive query parameters.
///
/// Unparseable input is returned with its query string removed.
pub fn redact_url(raw: &str) -> String {
    let Ok(mut url) = url::Url::parse(raw) else {
        return raw.split(['?', '#']).next().unwrap_or_default().to_owned();
    };
    if url.password().is_some() {
        let _ = url.set_password(Some(REDACTED));
    }
    if url.query().is_some() {
        let pairs: Vec<(String, String)> = url
            .query_pairs()
            .map(|(k, v)| {
                let value = if is_sensitive_field(&k) {
                    REDACTED.to_owned()
                } else {
                    v.into_owned()
                };
                (k.into_owned(), value)
            })
            .collect();
        url.query_pairs_mut().clear().extend_pairs(pairs);
    }
    url.to_string()
}

/// Returns a copy of `value` where every object entry with a sensitive key (or one of
/// `extra_keys`) is replaced by [`REDACTED`], recursively through objects and arrays.
pub fn redact_fields(value: &Value, extra_keys: &[&str]) -> Value {
    match value {
        Value::Object(map) => Value::Object(
            map.iter()
                .map(|(k, v)| {
                    let v = if is_sensitive_field_with(k, extra_keys) {
                        Value::String(REDACTED.to_owned())
                    } else {
                        redact_fields(v, extra_keys)
                    };
                    (k.clone(), v)
                })
                .collect(),
        ),
        Value::Array(items) => {
            Value::Array(items.iter().map(|v| redact_fields(v, extra_keys)).collect())
        }
        other => other.clone(),
    }
}

/// Replaces every occurrence of a known secret (length ≥ 4) in `text` by [`REDACTED`].
pub fn redact_text<S: AsRef<str>>(text: &str, known_secrets: &[S]) -> String {
    let mut secrets: Vec<&str> = known_secrets
        .iter()
        .map(AsRef::as_ref)
        .filter(|s| s.chars().count() >= 4)
        .collect();
    // Longest first so a secret that contains another one is fully replaced.
    secrets.sort_by_key(|s| std::cmp::Reverse(s.len()));
    let mut out = text.to_owned();
    for s in secrets {
        if out.contains(s) {
            out = out.replace(s, REDACTED);
        }
    }
    out
}

/// Truncates `text` to at most `max` characters, appending `…` when shortened.
pub fn truncate(text: &str, max: usize) -> String {
    if text.chars().count() <= max {
        return text.to_owned();
    }
    let mut out: String = text.chars().take(max).collect();
    out.push('…');
    out
}