cipherrun 0.3.0

A fast, modular, and scalable TLS/SSL security scanner written in Rust
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// Display utilities for enhanced output formatting

use colored::*;

/// Display configuration
#[derive(Debug, Clone)]
pub struct DisplayConfig {
    pub colorblind_mode: bool,
    pub show_rfc_names: bool,
    pub show_openssl_names: bool,
    pub show_each: bool,
}

impl DisplayConfig {
    /// Create new display config from CLI args
    pub fn from_args(colorblind: bool, cipher_mapping: Option<&str>, show_each: bool) -> Self {
        let (show_rfc_names, show_openssl_names) = match cipher_mapping {
            Some("no-openssl") => (true, false),
            Some("no-rfc") => (false, true),
            _ => (true, true), // Show both by default
        };

        Self {
            colorblind_mode: colorblind,
            show_rfc_names,
            show_openssl_names,
            show_each,
        }
    }

    /// Get cipher name to display
    pub fn format_cipher_name(&self, openssl_name: &str, rfc_name: &str) -> String {
        match (self.show_openssl_names, self.show_rfc_names) {
            (true, true) => format!("{} ({})", openssl_name, rfc_name),
            (true, false) => openssl_name.to_string(),
            (false, true) => rfc_name.to_string(),
            (false, false) => openssl_name.to_string(), // Fallback
        }
    }

    /// Get success color (green or blue for colorblind)
    pub fn success_color<T: Colorize>(&self, text: T) -> ColoredString {
        if self.colorblind_mode {
            text.blue()
        } else {
            text.green()
        }
    }

    /// Get warning color (yellow or cyan for colorblind)
    pub fn warning_color<T: Colorize>(&self, text: T) -> ColoredString {
        if self.colorblind_mode {
            text.cyan()
        } else {
            text.yellow()
        }
    }

    /// Get error color (red or magenta for colorblind)
    pub fn error_color<T: Colorize>(&self, text: T) -> ColoredString {
        if self.colorblind_mode {
            text.magenta()
        } else {
            text.red()
        }
    }

    /// Get info color (cyan or normal for colorblind)
    pub fn info_color<T: Colorize>(&self, text: T) -> ColoredString {
        if self.colorblind_mode {
            text.normal()
        } else {
            text.cyan()
        }
    }

    /// Get critical color (red bold or magenta bold for colorblind)
    pub fn critical_color<T: Colorize>(&self, text: T) -> ColoredString {
        if self.colorblind_mode {
            text.magenta().bold()
        } else {
            text.red().bold()
        }
    }
}

impl Default for DisplayConfig {
    fn default() -> Self {
        Self {
            colorblind_mode: false,
            show_rfc_names: true,
            show_openssl_names: true,
            show_each: false,
        }
    }
}

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

    #[test]
    fn test_display_config_default() {
        let config = DisplayConfig::default();
        assert!(!config.colorblind_mode);
        assert!(config.show_rfc_names);
        assert!(config.show_openssl_names);
        assert!(!config.show_each);
    }

    #[test]
    fn test_cipher_name_formatting() {
        let config = DisplayConfig::default();
        let name =
            config.format_cipher_name("ECDHE-RSA-AES128-SHA", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
        assert!(name.contains("ECDHE-RSA-AES128-SHA"));
        assert!(name.contains("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"));
    }

    #[test]
    fn test_no_openssl_mapping() {
        let config = DisplayConfig::from_args(false, Some("no-openssl"), false);
        assert!(!config.show_openssl_names);
        assert!(config.show_rfc_names);

        let name =
            config.format_cipher_name("ECDHE-RSA-AES128-SHA", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
        assert_eq!(name, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
    }

    #[test]
    fn test_no_rfc_mapping() {
        let config = DisplayConfig::from_args(false, Some("no-rfc"), false);
        assert!(config.show_openssl_names);
        assert!(!config.show_rfc_names);

        let name =
            config.format_cipher_name("ECDHE-RSA-AES128-SHA", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
        assert_eq!(name, "ECDHE-RSA-AES128-SHA");
    }

    #[test]
    fn test_colorblind_mode() {
        let config = DisplayConfig::from_args(true, None, false);
        assert!(config.colorblind_mode);

        // Verify color methods work (we can't easily test actual colors)
        let _ = config.success_color("test");
        let _ = config.error_color("test");
        let _ = config.warning_color("test");
    }
}