use std::{fmt, io, sync::OnceLock}; use quick_xml::{Reader, events::Event}; use regex::{Captures, Regex}; use serde_json::Value as JsonValue; use super::{ authorization::AuthorizedFile, redaction::{REDACTED, Redactor, is_sensitive_key}, }; pub const MAX_CONFIG_BYTES: usize = 1024 * 1024; const MAX_DEPTH: usize = 64; const MAX_NODES: usize = 10_000; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum ConfigFormat { Json, Toml, Yaml, Ini, Xml, DotEnv, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct ParsedConfig { pub display_name: String, pub format: ConfigFormat, pub redacted_text: String, } #[derive(Debug)] pub enum ConfigError { AuthorizationExpired, TooLarge, InvalidUtf8, UnsupportedConstruct(&'static str), InvalidSyntax(&'static str), Io(io::Error), } impl fmt::Display for ConfigError { fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::AuthorizationExpired => { formatter.write_str("the local file authorization has expired") } Self::TooLarge => formatter.write_str("the selected config exceeds the read limit"), Self::InvalidUtf8 => formatter.write_str("the selected config is not UTF-8 text"), Self::UnsupportedConstruct(kind) => { write!(formatter, "the selected config contains unsupported {kind}") } Self::InvalidSyntax(format) => write!(formatter, "the selected {format} is invalid"), Self::Io(error) => write!(formatter, "config read failed: {}", error.kind()), } } } impl std::error::Error for ConfigError {} pub fn parse_authorized_config( authorized: &AuthorizedFile, format: ConfigFormat, redactor: &Redactor, ) -> Result { authorized .ensure_active() .map_err(|_| ConfigError::AuthorizationExpired)?; let bytes = authorized.read_bounded(MAX_CONFIG_BYTES).map_err(|error| { if error.kind() == io::ErrorKind::InvalidData { ConfigError::TooLarge } else { ConfigError::Io(error) } })?; let text = std::str::from_utf8(&bytes).map_err(|_| ConfigError::InvalidUtf8)?; let normalized = match format { ConfigFormat::Json => parse_json(text, redactor)?, ConfigFormat::Toml => parse_toml(text, redactor)?, ConfigFormat::Yaml => validate_yaml(text)?, ConfigFormat::Ini => validate_ini(text)?, ConfigFormat::Xml => validate_xml(text)?, ConfigFormat::DotEnv => validate_dotenv(text)?, }; let redacted_text = redact_xml_elements(&redactor.redact(&normalized)); Ok(ParsedConfig { display_name: authorized.display_name().to_owned(), format, redacted_text, }) } fn parse_json(text: &str, redactor: &Redactor) -> Result { let mut value = serde_json::from_str::(text).map_err(|_| ConfigError::InvalidSyntax("JSON"))?; let mut nodes = 0; redact_json_value(&mut value, redactor, 0, &mut nodes)?; serde_json::to_string_pretty(&value).map_err(|_| ConfigError::InvalidSyntax("JSON")) } fn redact_json_value( value: &mut JsonValue, redactor: &Redactor, depth: usize, nodes: &mut usize, ) -> Result<(), ConfigError> { enforce_limits(depth, nodes)?; match value { JsonValue::Object(map) => { for (key, child) in map { if is_sensitive_key(key) { *child = JsonValue::String(REDACTED.to_owned()); } else { redact_json_value(child, redactor, depth + 1, nodes)?; } } } JsonValue::Array(values) => { for child in values { redact_json_value(child, redactor, depth + 1, nodes)?; } } JsonValue::String(value) => *value = redactor.redact(value), _ => {} } Ok(()) } fn parse_toml(text: &str, redactor: &Redactor) -> Result { let mut value = text .parse::() .map_err(|_| ConfigError::InvalidSyntax("TOML"))?; let mut nodes = 0; redact_toml_value(&mut value, redactor, 0, &mut nodes)?; toml::to_string_pretty(&value).map_err(|_| ConfigError::InvalidSyntax("TOML")) } fn redact_toml_value( value: &mut toml::Value, redactor: &Redactor, depth: usize, nodes: &mut usize, ) -> Result<(), ConfigError> { enforce_limits(depth, nodes)?; match value { toml::Value::Table(table) => { for (key, child) in table { if is_sensitive_key(key) { *child = toml::Value::String(REDACTED.to_owned()); } else { redact_toml_value(child, redactor, depth + 1, nodes)?; } } } toml::Value::Array(values) => { for child in values { redact_toml_value(child, redactor, depth + 1, nodes)?; } } toml::Value::String(value) => *value = redactor.redact(value), _ => {} } Ok(()) } fn enforce_limits(depth: usize, nodes: &mut usize) -> Result<(), ConfigError> { if depth > MAX_DEPTH { return Err(ConfigError::UnsupportedConstruct("nesting depth")); } *nodes += 1; if *nodes > MAX_NODES { return Err(ConfigError::UnsupportedConstruct("node count")); } Ok(()) } fn validate_yaml(text: &str) -> Result { let mut nodes = 0_usize; for line in text.lines() { let trimmed = line.trim(); if trimmed.is_empty() || trimmed.starts_with('#') || matches!(trimmed, "---" | "...") { continue; } if trimmed.contains("<<:") || trimmed.starts_with('!') || trimmed.starts_with('&') || trimmed.starts_with('*') || trimmed.contains(": &") || trimmed.contains(": *") { return Err(ConfigError::UnsupportedConstruct( "YAML tag, anchor, or alias", )); } let indentation = line .chars() .take_while(|character| character.is_whitespace()) .count(); if indentation > MAX_DEPTH * 2 { return Err(ConfigError::UnsupportedConstruct("YAML nesting depth")); } if !trimmed.starts_with('-') && !trimmed.contains(':') { return Err(ConfigError::InvalidSyntax("YAML")); } nodes += 1; if nodes > MAX_NODES { return Err(ConfigError::UnsupportedConstruct("YAML node count")); } } Ok(text.to_owned()) } fn validate_ini(text: &str) -> Result { let mut nodes = 0_usize; for line in text.lines() { let trimmed = line.trim(); if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with(';') { continue; } let is_section = trimmed.starts_with('[') && trimmed.ends_with(']'); if !is_section && !trimmed.contains('=') { return Err(ConfigError::InvalidSyntax("INI")); } nodes += 1; if nodes > MAX_NODES { return Err(ConfigError::UnsupportedConstruct("INI entry count")); } } Ok(text.to_owned()) } fn validate_dotenv(text: &str) -> Result { let mut entries = 0_usize; for line in text.lines() { let trimmed = line.trim(); if trimmed.is_empty() || trimmed.starts_with('#') { continue; } let assignment = trimmed.strip_prefix("export ").unwrap_or(trimmed); let (key, _) = assignment .split_once('=') .ok_or(ConfigError::InvalidSyntax(".env"))?; if key.is_empty() || !key.chars().enumerate().all(|(index, value)| { value == '_' || (value.is_ascii_alphanumeric() && (index > 0 || !value.is_ascii_digit())) }) { return Err(ConfigError::InvalidSyntax(".env")); } entries += 1; if entries > MAX_NODES { return Err(ConfigError::UnsupportedConstruct(".env entry count")); } } Ok(text.to_owned()) } fn validate_xml(text: &str) -> Result { let lowercase = text.to_ascii_lowercase(); if lowercase.contains(" { depth += 1; nodes += 1; if depth > MAX_DEPTH || nodes > MAX_NODES { return Err(ConfigError::UnsupportedConstruct("XML depth or node count")); } } Ok(Event::End(_)) => depth = depth.saturating_sub(1), Ok(Event::Empty(_)) => { nodes += 1; if nodes > MAX_NODES { return Err(ConfigError::UnsupportedConstruct("XML node count")); } } Ok(Event::DocType(_)) => return Err(ConfigError::UnsupportedConstruct("XML DTD")), Ok(Event::Eof) => break, Ok(_) => {} Err(_) => return Err(ConfigError::InvalidSyntax("XML")), } buffer.clear(); } Ok(text.to_owned()) } fn redact_xml_elements(text: &str) -> String { static XML_SECRET: OnceLock = OnceLock::new(); let pattern = XML_SECRET.get_or_init(|| { Regex::new( r"(?is)(?P<(?:access[_-]?token|refresh[_-]?token|api[_-]?key|client[_-]?secret|private[_-]?key|password|passwd|secret|cookie|authorization)(?:\s[^>]*)?>).*?(?P)", ) .expect("the XML redaction regex is valid") }); pattern .replace_all(text, |captures: &Captures<'_>| { format!("{}{}{}", &captures["open"], REDACTED, &captures["close"]) }) .into_owned() } #[cfg(test)] mod tests { use std::{fs, time::Duration}; use super::*; fn parse_fixture(contents: &str, format: ConfigFormat) -> Result { let path = std::env::temp_dir().join(format!("astrbot-config-{}", uuid::Uuid::new_v4())); fs::write(&path, contents).expect("write config fixture"); let result = { let authorized = AuthorizedFile::open_local_selection(&path, Duration::from_secs(5)) .expect("authorize config fixture"); parse_authorized_config(&authorized, format, &Redactor::default()) }; fs::remove_file(path).expect("remove config fixture"); result } #[test] fn recursively_redacts_json_fields() { let parsed = parse_fixture( r#"{"database":{"password":"canary-value"},"safe":"visible"}"#, ConfigFormat::Json, ) .expect("parse JSON"); assert!(!parsed.redacted_text.contains("canary-value")); assert!(parsed.redacted_text.contains("visible")); } #[test] fn rejects_yaml_aliases_and_xml_entities() { assert!(matches!( parse_fixture("defaults: &defaults\n token: value", ConfigFormat::Yaml), Err(ConfigError::UnsupportedConstruct(_)) )); assert!(matches!( parse_fixture( "]>&y;", ConfigFormat::Xml ), Err(ConfigError::UnsupportedConstruct(_)) )); } #[test] fn redacts_xml_sensitive_elements() { let parsed = parse_fixture( "canary-valuevisible", ConfigFormat::Xml, ) .expect("parse XML"); assert!(!parsed.redacted_text.contains("canary-value")); assert!(parsed.redacted_text.contains("visible")); } }