Skip to main content

serial_mcp/
security.rs

1use glob::Pattern;
2use tracing::warn;
3
4/// Security manager that handles port allowlist checks.
5///
6/// If the allowlist is empty, all ports are allowed.
7#[derive(Clone)]
8pub struct SecurityManager {
9    allowlist: Vec<Pattern>,
10}
11
12impl SecurityManager {
13    /// Create a security manager from explicit glob pattern strings.
14    /// Invalid patterns are silently ignored (logged as warnings).
15    pub fn from_patterns<I: IntoIterator>(patterns: I) -> Self
16    where
17        I::Item: AsRef<str>,
18    {
19        let allowlist = patterns
20            .into_iter()
21            .filter_map(|s| match Pattern::new(s.as_ref()) {
22                Ok(p) => Some(p),
23                Err(e) => {
24                    warn!("Invalid allowlist pattern '{}': {e}", s.as_ref());
25                    None
26                }
27            })
28            .collect();
29        Self { allowlist }
30    }
31
32    /// Check if a port matches the allowlist. Empty allowlist = allow all.
33    pub fn is_port_allowed(&self, port: &str) -> bool {
34        if self.allowlist.is_empty() {
35            return true;
36        }
37        self.allowlist.iter().any(|pattern| pattern.matches(port))
38    }
39
40    /// Human-readable summary of allowlist patterns for error messages.
41    pub fn allowlist_summary(&self) -> String {
42        if self.allowlist.is_empty() {
43            "(all ports allowed)".to_string()
44        } else {
45            self.allowlist
46                .iter()
47                .map(|p| p.as_str())
48                .collect::<Vec<_>>()
49                .join(", ")
50        }
51    }
52}
53
54#[cfg(test)]
55mod tests {
56    use super::*;
57
58    fn from_str(env_val: &str) -> SecurityManager {
59        let patterns = env_val
60            .split(',')
61            .map(|s| s.trim())
62            .filter(|s| !s.is_empty())
63            .filter_map(|s| match Pattern::new(s) {
64                Ok(p) => Some(p),
65                Err(e) => {
66                    warn!("Invalid allowlist pattern '{s}': {e}");
67                    None
68                }
69            })
70            .collect();
71        SecurityManager {
72            allowlist: patterns,
73        }
74    }
75
76    #[test]
77    fn empty_allowlist_allows_all() {
78        let mgr = from_str("");
79        assert!(mgr.is_port_allowed("/dev/ttyUSB0"));
80        assert!(mgr.is_port_allowed("COM3"));
81        assert_eq!(mgr.allowlist_summary(), "(all ports allowed)");
82    }
83
84    #[test]
85    fn pattern_in_allowlist_matches() {
86        let mgr = from_str("/dev/ttyUSB*");
87        assert!(mgr.is_port_allowed("/dev/ttyUSB0"));
88        assert!(mgr.is_port_allowed("/dev/ttyUSB99"));
89        assert!(!mgr.is_port_allowed("/dev/ttyS0"));
90        assert!(!mgr.is_port_allowed("COM3"));
91    }
92
93    #[test]
94    fn allowlist_summary_shows_patterns() {
95        let mgr = from_str("/dev/ttyUSB*,COM*");
96        let summary = mgr.allowlist_summary();
97        assert!(summary.contains("/dev/ttyUSB*"));
98        assert!(summary.contains("COM*"));
99    }
100
101    #[test]
102    fn ignores_invalid_patterns() {
103        let mgr = from_str("/dev/ttyUSB*,[invalid");
104        assert_eq!(mgr.allowlist.len(), 1);
105        assert!(mgr.is_port_allowed("/dev/ttyUSB0"));
106    }
107
108    #[test]
109    fn all_invalid_patterns_yields_empty() {
110        let mgr = from_str("[invalid,[also_broken");
111        assert!(mgr.allowlist.is_empty());
112        assert!(mgr.is_port_allowed("/dev/ttyUSB0"));
113    }
114
115    #[test]
116    fn multiple_valid_and_invalid() {
117        let mgr = from_str("COM3,[bad,/dev/tty[a-z]*");
118        assert_eq!(mgr.allowlist.len(), 2);
119        assert!(mgr.is_port_allowed("COM3"));
120        assert!(mgr.is_port_allowed("/dev/ttyb"));
121        assert!(!mgr.is_port_allowed("/dev/tty0"));
122    }
123}