huginn 1.0.0

Secure input validation and sanitization library with extensible architecture
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use super::{config::SecurityConfig, error::ValidationError};
use std::{borrow::Cow, fmt::Debug};
use urlencoding::decode;

/// Result of input processing with sanitized data
#[derive(Debug, Clone)]
pub struct SanitizedInput<T> {
    /// Original user input
    pub original: String,
    /// Cleaned and validated data
    pub cleaned: T,
}

/// Trait for thread-safe validators with async support
#[async_trait::async_trait]
pub trait Validator<T>: Send + Sync {
    /// Validates and converts cleaned input synchronously
    fn validate(&self, input: &str) -> Result<T, ValidationError>;

    /// Validates and converts cleaned input asynchronously
    async fn validate_async(&self, input: &str) -> Result<T, ValidationError> {
        Ok(self.validate(input)?)
    }

    /// Returns target type name for error reporting
    fn target_type(&self) -> &'static str;
}

/// Main processing pipeline with synchronous validation
pub fn sanitize_and_validate<T>(
    input: &str,
    validator: &impl Validator<T>,
    config: &SecurityConfig,
) -> Result<SanitizedInput<T>, ValidationError>
where
    T: Debug + Send + Sync,
{
    let decoded = decode(input).unwrap_or(Cow::Borrowed(input));
    let (cleaned, bad_chars) = sanitize_input(&decoded, config);

    if !bad_chars.is_empty() {
        let symbols = bad_chars
            .iter()
            .map(|c| format!("'{}'", c))
            .collect::<Vec<_>>()
            .join(", ");
        return Err(ValidationError::DangerousCharacters {
            symbols,
            count: bad_chars.len(),
        });
    }

    if config.has_blocked_pattern(&cleaned) {
        return Err(ValidationError::BlockedPattern {
            pattern: "blocked pattern detected".to_string(),
        });
    }

    validator.validate(&cleaned).map(|result| SanitizedInput {
        original: input.to_string(),
        cleaned: result,
    })
}

/// Main processing pipeline with asynchronous validation
pub async fn sanitize_and_validate_async<T>(
    input: &str,
    validator: &impl Validator<T>,
    config: &SecurityConfig,
) -> Result<SanitizedInput<T>, ValidationError>
where
    T: Debug + Send + Sync,
{
    let decoded = decode(input).unwrap_or(Cow::Borrowed(input));
    let (cleaned, bad_chars) = sanitize_input(&decoded, config);

    if !bad_chars.is_empty() {
        let symbols = bad_chars
            .iter()
            .map(|c| format!("'{}'", c))
            .collect::<Vec<_>>()
            .join(", ");
        return Err(ValidationError::DangerousCharacters {
            symbols,
            count: bad_chars.len(),
        });
    }

    if config.has_blocked_pattern(&cleaned) {
        return Err(ValidationError::BlockedPattern {
            pattern: "blocked pattern detected".to_string(),
        });
    }

    validator
        .validate_async(&cleaned)
        .await
        .map(|result| SanitizedInput {
            original: input.to_string(),
            cleaned: result,
        })
}

/// Sanitizes input using iterator optimizations
pub fn sanitize_input(input: &str, config: &SecurityConfig) -> (String, Vec<char>) {
    let mut cleaned = String::with_capacity(input.len());
    let mut bad_chars = Vec::with_capacity(8); // Предварительное выделение для типичного случая

    input.chars().for_each(|c| {
        if config.is_char_forbidden(&c) {
            bad_chars.push(c);
        } else {
            cleaned.push(c);
        }
    });

    (cleaned, bad_chars)
}