quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
pub fn sanitize_ip(text: &str) -> String {
    let mut result = String::with_capacity(text.len());
    let mut chars = text.char_indices().peekable();
    let mut last_end = 0;

    while let Some(&(i, c)) = chars.peek() {
        if c.is_ascii_digit() {
            let start = i;
            let mut octet_count = 0;
            let mut curr_end = start;

            while let Some(&(idx, ch)) = chars.peek() {
                if ch.is_ascii_digit() {
                    curr_end = idx + 1;
                    chars.next();
                } else if ch == '.' {
                    octet_count += 1;
                    curr_end = idx + 1;
                    chars.next();
                } else if ch == ':' && octet_count == 3 {
                    chars.next();
                    while let Some(&(p_idx, p_ch)) = chars.peek() {
                        if p_ch.is_ascii_digit() {
                            curr_end = p_idx + 1;
                            chars.next();
                        } else {
                            break;
                        }
                    }
                    break;
                } else {
                    break;
                }
            }

            let candidate = &text[start..curr_end];
            let host_part = candidate.split(':').next().unwrap_or("");
            let octets: Vec<&str> = host_part.split('.').collect();
            if octets.len() == 4
                && octets
                    .iter()
                    .all(|o| !o.is_empty() && o.len() <= 3 && o.parse::<u8>().is_ok())
            {
                result.push_str(&text[last_end..start]);
                result.push_str("[REDACTED_IP]");
                last_end = curr_end;
            }
        } else {
            chars.next();
        }
    }
    result.push_str(&text[last_end..]);
    result
}

fn sanitize_connection_strings(text: &str) -> String {
    let prefixes = [
        "postgres://",
        "postgresql://",
        "mysql://",
        "redis://",
        "nats://",
        "mongodb://",
    ];
    let mut result = text.to_string();
    for prefix in prefixes {
        while let Some(start) = result.find(prefix) {
            let rest = &result[start..];
            let end = rest
                .find(|c: char| c.is_whitespace() || c == '"' || c == '\'' || c == ')' || c == ']')
                .map(|idx| start + idx)
                .unwrap_or(result.len());
            result.replace_range(start..end, "[REDACTED_CONNECTION_STRING]");
        }
    }
    result
}

pub fn sanitize_url(raw: &str) -> String {
    let raw_clean = sanitize_ip(raw);
    match url::Url::parse(&raw_clean) {
        Ok(mut parsed) => {
            let has_password = parsed.password().is_some();
            let has_username = !parsed.username().is_empty();
            if has_password || has_username {
                let _ = parsed.set_username("[REDACTED]");
                let _ = parsed.set_password(Some("[REDACTED]"));
            }

            let sensitive_keys: &[&str] = &[
                "api-key", "api_key", "apikey", "key", "token", "secret",
                "password", "pass", "auth", "authorization",
            ];

            let original_pairs: Vec<(String, String)> = parsed
                .query_pairs()
                .map(|(k, v)| (k.into_owned(), v.into_owned()))
                .collect();

            let needs_redaction = original_pairs
                .iter()
                .any(|(k, _)| sensitive_keys.contains(&k.to_lowercase().as_str()));

            if needs_redaction {
                let redacted: Vec<(String, String)> = original_pairs
                    .into_iter()
                    .map(|(k, v)| {
                        if sensitive_keys.contains(&k.to_lowercase().as_str()) {
                            (k, "[REDACTED]".to_string())
                        } else {
                            (k, v)
                        }
                    })
                    .collect();

                parsed.set_query(None);
                {
                    let mut pairs = parsed.query_pairs_mut();
                    for (k, v) in &redacted {
                        pairs.append_pair(k, v);
                    }
                }
            }

            parsed.to_string()
        }
        Err(_) => raw_clean,
    }
}

pub fn sanitize_text(text: &str) -> String {
    let clean_conn = sanitize_connection_strings(text);
    let clean_ip = sanitize_ip(&clean_conn);
    sanitize_url(&clean_ip)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_no_sensitive_params_unchanged() {
        let url = "https://api.example.com/v1/health";
        assert_eq!(sanitize_url(url), url);
    }

    #[test]
    fn test_api_key_param_redacted() {
        let url = "https://devnet.helius-rpc.com/?api-key=super_secret_key";
        let sanitized = sanitize_url(url);
        let redacted = sanitized.contains("[REDACTED]")
            || sanitized.contains("%5BREDACTED%5D")
            || sanitized.contains("REDACTED");
        assert!(redacted, "sanitized URL must contain REDACTED: {}", sanitized);
        assert!(!sanitized.contains("super_secret_key"));
    }

    #[test]
    fn test_multiple_params_only_sensitive_redacted() {
        let url = "https://api.example.com/v1/strategy?objective=fastest&token=abc123&other=visible";
        let sanitized = sanitize_url(url);
        assert!(sanitized.contains("objective=fastest"));
        assert!(sanitized.contains("other=visible"));
        assert!(sanitized.contains("token=%5BREDACTED%5D") || sanitized.contains("token=[REDACTED]"));
        assert!(!sanitized.contains("abc123"));
    }

    #[test]
    fn test_userinfo_redacted() {
        let url = "https://user:password@api.example.com/v1/health";
        let sanitized = sanitize_url(url);
        assert!(!sanitized.contains("password"));
    }

    #[test]
    fn test_ip_address_redacted() {
        let text = "failed to connect to http://132.226.188.165:3000/v1/health on 10.0.0.161";
        let sanitized = sanitize_text(text);
        assert!(!sanitized.contains("132.226.188.165"));
        assert!(!sanitized.contains("10.0.0.161"));
        assert!(sanitized.contains("[REDACTED_IP]"));
    }

    #[test]
    fn test_db_connection_string_redacted() {
        let text = "error: failed to connect to postgresql://user:secret123@ep-cool-db.neon.tech/neondb?sslmode=require";
        let sanitized = sanitize_text(text);
        assert!(!sanitized.contains("secret123"));
        assert!(!sanitized.contains("neon.tech"));
        assert!(sanitized.contains("[REDACTED_CONNECTION_STRING]"));
    }

    #[test]
    fn test_ip_address_edge_cases() {
        // Invalid octets (>255) must NOT match as an IP
        let text_invalid = "value is 999.999.999.999 in logs";
        assert_eq!(sanitize_ip(text_invalid), text_invalid);

        // Version string with non-numeric suffix must not panic
        let version_str = "running solana-validator v2.1.0-beta.1 on cluster";
        assert_eq!(sanitize_ip(version_str), version_str);

        // Valid IP with port
        let ip_port = "validator at 198.13.130.39:8003 active";
        assert_eq!(sanitize_ip(ip_port), "validator at [REDACTED_IP] active");
    }
}