hashcracker 0.1.0

GPU-accelerated password cracker — 41 hash types, Vulkan/Metal/DX12, single binary
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

use clap::Parser;
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct HashEntry {
    pub hex: String,
    pub hash: [u32; 8],
    pub hash_extra: [u32; 8],
    pub salt: [u32; 16],
    pub salt_len: u32,
    pub username: Option<String>,
}

#[derive(Parser)]
#[command(
    name = "hashcracker",
    version,
    about = "GPU-accelerated password cracker — 41 hash types, Vulkan/Metal/DX12, single binary",
    long_about = "hashcracker — GPU-accelerated password cracking with a focus on portability and ergonomics.

Supports 41 hash types across CPU and GPU (Vulkan via wgpu).
Auto-detects hash type from format prefixes and hex lengths.

Examples:
  hashcracker --hash-type md5 --hash e99a18c428cb38d5f260853678922e03
  hashcracker --hashlist hashes.txt --wordlist rockyou.txt --rules best64.rule
  hashcracker --hash '$1$c$TEPt3Oo2oa8cNB9HQmta7/'
  hashcracker --bench
  hashcracker --show
  hashcracker --extract pdf document.pdf

Documentation: https://github.com/anomalyco/hashcracker
",
    arg_required_else_help = true,
)]
pub struct Args {
    // === Attack configuration ===
    #[arg(short, long, default_value = "brute",
        help = "Attack mode: brute, wordlist, mask, hybrid, prince, single, markov, incremental")]
    pub mode: String,

    #[arg(help = "Known plaintext password (for benchmarking / known-plaintext mode)")]
    pub password: Option<String>,

    #[arg(long, default_value = "auto",
        help = "Hash type (auto-detect, or pick from 41 types: md5, sha1, sha256, sha512, ntlm, bcrypt, keepass, ...)")]
    pub hash_type: String,

    #[arg(short, long,
        help = "Wordlist file path")]
    pub wordlist: Option<PathBuf>,

    #[arg(long,
        help = "Mask pattern, e.g. ?l?l?d?d?d (?l=lower, ?u=upper, ?d=digit, ?a=all)")]
    pub mask: Option<String>,

    #[arg(long,
        help = "Prepend word to mask result (suffix mode is default)")]
    pub prefix: bool,

    #[arg(long, default_value = "",
        help = "Static salt (hex or string) for hash computation")]
    pub salt: String,

    #[arg(long,
        help = "Rules file for wordlist mode (hashcat-compatible .rule syntax)")]
    pub rules: Option<PathBuf>,

    #[arg(long,
        help = "Stacked rules files applied sequentially")]
    pub rules_stack: Vec<PathBuf>,

    #[arg(long,
        help = "Filter constraints: min=X, max=X, chars=abc")]
    pub filter: Vec<String>,

    // === Target specification ===
    #[arg(long,
        help = "Single target hash (hex string or prefixed format like $1$..., $6$...)")]
    pub hash: Option<String>,

    #[arg(long,
        help = "Hashlist file (one hash per line, supports user:hash format)")]
    pub hashlist: Option<PathBuf>,

    // === Attack modes ===
    #[arg(long,
        help = "Prince mode dictionary file (word-concatenation chains)")]
    pub prince_dict: Option<PathBuf>,

    #[arg(long, default_value = "false",
        help = "Use potfile cracked passwords as wordlist input")]
    pub loopback: bool,

    #[arg(long, default_value = "false",
        help = "Generate candidate passwords to stdout (no cracking)")]
    pub stdout: bool,

    // === Session & persistence ===
    #[arg(long,
        help = "Session name for save/resume")]
    pub session: Option<String>,

    #[arg(long,
        help = "Custom potfile path (default: ~/.hashcracker/potfile)")]
    pub potfile: Option<PathBuf>,

    // === Display modes ===
    #[arg(long, default_value = "false",
        help = "Show cracked passwords from potfile")]
    pub show: bool,

    #[arg(long, default_value = "false",
        help = "Show remaining (uncracked) hashes")]
    pub left: bool,

    #[arg(long, default_value = "false",
        help = "Only output cracked passwords, suppress progress and banner")]
    pub quiet: bool,

    #[arg(long, default_value = "false",
        help = "Show detailed per-event GPU stats")]
    pub verbose: bool,

    #[arg(long, default_value = "false",
        help = "Output cracked password as hex-encoded string")]
    pub hex: bool,

    #[arg(long, default_value = "false",
        help = "Machine-readable JSON-line output per event")]
    pub json: bool,

    // === Utility ===
    #[arg(long, default_value = "false",
        help = "Benchmark all supported hash types")]
    pub bench: bool,

    #[arg(long,
        help = "Extract hash from file (pdf, zip)")]
    pub extract: Option<String>,
}