project_ares 0.12.0

Automated decoding tool, Ciphey but in Rust
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

use crate::checkers::checker_result::CheckResult;
use gibberish_or_not::{is_password, Sensitivity};
use lemmeknow::Identifier;

use crate::checkers::checker_type::{Check, Checker};

/// Checks if the input matches a known common password.
pub struct PasswordChecker;

/// Implementation of the Check trait for PasswordChecker
impl Check for Checker<PasswordChecker> {
    fn new() -> Self {
        Checker {
            name: "Password Checker",
            description: "Checks if the input exactly matches a known common password",
            link: "https://crates.io/crates/gibberish-or-not",
            tags: vec!["password", "security"],
            expected_runtime: 0.01,
            popularity: 1.0,
            lemmeknow_config: Identifier::default(),
            sensitivity: Sensitivity::Medium,
            enhanced_detector: None,
            _phantom: std::marker::PhantomData,
        }
    }

    fn check(&self, text: &str) -> CheckResult {
        CheckResult {
            is_identified: is_password(text),
            text: text.to_string(),
            checker_name: self.name,
            checker_description: self.description,
            description: "Common Password".to_string(),
            link: self.link,
        }
    }

    fn with_sensitivity(mut self, sensitivity: Sensitivity) -> Self {
        self.sensitivity = sensitivity;
        self
    }

    fn get_sensitivity(&self) -> Sensitivity {
        self.sensitivity
    }
}

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

    #[test]
    fn test_check_common_password() {
        let checker = Checker::<PasswordChecker>::new();
        assert!(checker.check("123456").is_identified);
    }

    #[test]
    fn test_check_not_password() {
        let checker = Checker::<PasswordChecker>::new();
        assert!(!checker.check("not-a-common-password").is_identified);
    }

    #[test]
    fn test_check_case_sensitive() {
        let checker = Checker::<PasswordChecker>::new();
        // Test exact matching with different cases
        let original = checker.check("password").is_identified;
        let uppercase = checker.check("PASSWORD").is_identified;
        assert!(original != uppercase, "Case sensitivity test failed");
    }

    #[test]
    fn test_default_sensitivity_is_medium() {
        let checker = Checker::<PasswordChecker>::new();
        assert!(matches!(checker.get_sensitivity(), Sensitivity::Medium));
    }

    #[test]
    fn test_with_sensitivity_changes_sensitivity() {
        let checker = Checker::<PasswordChecker>::new().with_sensitivity(Sensitivity::Low);
        assert!(matches!(checker.get_sensitivity(), Sensitivity::Low));

        let checker = Checker::<PasswordChecker>::new().with_sensitivity(Sensitivity::High);
        assert!(matches!(checker.get_sensitivity(), Sensitivity::High));
    }
}