happy-cracking 0.3.0

A fast, comprehensive CTF toolkit for cryptographic encoding/decoding, classic ciphers, hash operations, and analysis tools
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
119
120
121
122
123
124
125
126

use anyhow::Result;
use clap::Subcommand;

#[derive(Subcommand)]
pub enum HashIdAction {
    #[command(about = "Identify hash type")]
    Identify {
        #[arg(help = "Hash string to identify")]
        input: String,
    },
}

pub fn run(action: HashIdAction) -> Result<()> {
    match action {
        HashIdAction::Identify { input } => {
            let results = identify(&input);
            if results.is_empty() {
                println!("Unknown hash format");
            } else {
                println!("Possible hash types:");
                for result in results {
                    println!("  - {}", result);
                }
            }
        }
    }
    Ok(())
}

pub fn identify(input: &str) -> Vec<&'static str> {
    let input = input.trim();
    let len = input.len();
    let is_hex = input.chars().all(|c| c.is_ascii_hexdigit());
    let is_base64 = input
        .chars()
        .all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '/' || c == '=');

    let mut results = Vec::new();

    if is_hex {
        match len {
            32 => {
                results.push("MD5");
                results.push("MD4");
                results.push("MD2");
                results.push("NTLM");
            }
            40 => {
                results.push("SHA-1");
                results.push("RIPEMD-160");
            }
            56 => {
                results.push("SHA-224");
            }
            64 => {
                results.push("SHA-256");
                results.push("RIPEMD-256");
                results.push("Snefru-256");
                results.push("GOST R 34.11-94");
            }
            96 => {
                results.push("SHA-384");
            }
            128 => {
                results.push("SHA-512");
                results.push("Whirlpool");
                results.push("SHA-512/256");
            }
            _ => {}
        }
    }

    // Check for bcrypt
    if input.starts_with("$2a$")
        || input.starts_with("$2b$")
        || input.starts_with("$2y$")
        || input.starts_with("$2x$")
    {
        results.push("bcrypt");
    }

    // Check for Argon2
    if input.starts_with("$argon2") {
        results.push("Argon2");
    }

    // Check for Unix crypt formats
    if input.starts_with("$1$") {
        results.push("MD5 Crypt (Unix)");
    }
    if input.starts_with("$5$") {
        results.push("SHA-256 Crypt (Unix)");
    }
    if input.starts_with("$6$") {
        results.push("SHA-512 Crypt (Unix)");
    }

    // Check for Base64-encoded hashes
    if is_base64 && !is_hex {
        match len {
            24 => {
                results.push("MD5 (Base64)");
            }
            28 => {
                results.push("SHA-1 (Base64)");
            }
            44 => {
                results.push("SHA-256 (Base64)");
            }
            88 => {
                results.push("SHA-512 (Base64)");
            }
            _ => {}
        }
    }

    // MySQL
    if len == 16 && is_hex {
        results.push("MySQL (old)");
    }
    if len == 41 && input.starts_with('*') {
        results.push("MySQL 5.x");
    }

    results
}