mirror of
https://github.com/hashcat/hashcat.git
synced 2025-08-01 19:38:26 +00:00
07395626fa
Remove hard-coded SCRYPT N, R, and P values in modules, except where they are intentionally hardcoded. Fix a bug that always caused a TMTO value of 1, even when it was not needed. Respect device_available_mem and device_maxmem_alloc values even if a reliable low-level free memory API is present, and always select the lowest of all available limits. Fix benchmark_deep.pl mask to avoid UTF-8 rejects. Improve error messages when the check verifying that all SCRYPT configuration settings across all hashes are identical is triggered. Also improve the error message shown when the SCRYPT configuration of the self-test hash does not match that of the target hash. Fix a bug where a low-tuned SCRYPT hash combined with a TMTO could result in fewer than 1024 iterations, which breaks the hard-coded minimum of 1024 iterations in the SCRYPT kernel.
587 lines
7.8 KiB
Perl
Executable File
587 lines
7.8 KiB
Perl
Executable File
#!/usr/bin/env perl
|
|
|
|
##
|
|
## Author......: See docs/credits.txt
|
|
## License.....: MIT
|
|
##
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
my $nvidia_cache = "~/.nv";
|
|
my $amd_cache = "~/.AMD";
|
|
my $hashcat_path = ".";
|
|
my $kernels_cache = "$hashcat_path/kernels";
|
|
my $hashcat_bin = "$hashcat_path/hashcat";
|
|
my $device = 1;
|
|
my $workload_profile = 3;
|
|
my $runtime = 24;
|
|
my $sleep_sec = 12;
|
|
my $default_mask = "?a?a?a?a?a?a?a";
|
|
my $result = "result.txt";
|
|
my $old_hashcat = 0; # requires to have ran with new hashcat before to create the hashfiles
|
|
my $repeats = 0;
|
|
my $cpu_benchmark = 0;
|
|
|
|
print "\nHardware preparations... You may need to adjust some settings and probably can ignore some of the error\n\n";
|
|
|
|
system ("echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor");
|
|
|
|
if ($cpu_benchmark == 1)
|
|
{
|
|
system ("echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo"); ## for CPU benchmark Intel
|
|
system ("echo 0 > /sys/devices/system/cpu/cpufreq/boost"); ## for CPU benchmark AMD
|
|
}
|
|
else
|
|
{
|
|
system ("rocm-smi --resetprofile --resetclocks --resetfans");
|
|
system ("rocm-smi --setfan 100% --setperflevel high");
|
|
|
|
system ("nvidia-smi -rac");
|
|
system ("nvidia-smi -pm ENABLED");
|
|
system ("nvidia-smi -acp UNRESTRICTED");
|
|
system ("nvidia-smi -pl 225"); ## needs per-gpu adjust
|
|
system ("nvidia-settings -a GPUPowerMizerMode=1 -a GPUFanControlState=1 -a GPUTargetFanSpeed=100");
|
|
}
|
|
|
|
print "\n\nStarting...\n\n";
|
|
|
|
system ("rm -rf $nvidia_cache");
|
|
system ("rm -rf $amd_cache");
|
|
system ("rm -rf $kernels_cache");
|
|
|
|
my @hash_types_selection =
|
|
(
|
|
0,
|
|
100,
|
|
1400,
|
|
1700,
|
|
22000,
|
|
1000,
|
|
3000,
|
|
5500,
|
|
5600,
|
|
1500,
|
|
500,
|
|
3200,
|
|
1800,
|
|
7500,
|
|
13100,
|
|
15300,
|
|
15900,
|
|
7100,
|
|
11600,
|
|
12500,
|
|
13000,
|
|
6241,
|
|
13400,
|
|
6800,
|
|
11300,
|
|
);
|
|
|
|
my @hash_types =
|
|
(
|
|
0,
|
|
20,
|
|
50,
|
|
60,
|
|
100,
|
|
120,
|
|
150,
|
|
160,
|
|
200,
|
|
300,
|
|
400,
|
|
500,
|
|
600,
|
|
900,
|
|
1000,
|
|
1100,
|
|
1300,
|
|
1400,
|
|
1420,
|
|
1450,
|
|
1460,
|
|
1600,
|
|
1600,
|
|
1700,
|
|
1720,
|
|
1750,
|
|
1760,
|
|
1800,
|
|
2100,
|
|
2400,
|
|
2410,
|
|
2611,
|
|
2711,
|
|
2811,
|
|
3000,
|
|
3100,
|
|
3200,
|
|
3710,
|
|
3800,
|
|
3910,
|
|
4010,
|
|
4110,
|
|
4300,
|
|
4400,
|
|
4500,
|
|
4520,
|
|
4700,
|
|
4800,
|
|
4900,
|
|
5100,
|
|
5200,
|
|
5300,
|
|
5400,
|
|
5500,
|
|
5600,
|
|
5800,
|
|
6000,
|
|
6100,
|
|
6211,
|
|
6221,
|
|
6231,
|
|
6241,
|
|
6300,
|
|
6400,
|
|
6500,
|
|
6600,
|
|
6700,
|
|
6800,
|
|
6900,
|
|
7000,
|
|
7100,
|
|
7300,
|
|
7400,
|
|
7500,
|
|
7700,
|
|
7701,
|
|
7800,
|
|
7801,
|
|
7900,
|
|
8000,
|
|
8100,
|
|
8200,
|
|
8300,
|
|
8400,
|
|
8500,
|
|
8600,
|
|
8700,
|
|
8800,
|
|
8900,
|
|
9000,
|
|
9100,
|
|
9400,
|
|
9500,
|
|
9600,
|
|
9700,
|
|
9710,
|
|
9720,
|
|
9800,
|
|
9810,
|
|
9820,
|
|
9900,
|
|
10100,
|
|
10300,
|
|
10400,
|
|
10410,
|
|
10420,
|
|
10500,
|
|
10700,
|
|
10800,
|
|
10900,
|
|
11000,
|
|
11100,
|
|
11200,
|
|
11300,
|
|
11400,
|
|
11500,
|
|
11600,
|
|
11700,
|
|
11750,
|
|
11760,
|
|
11800,
|
|
11850,
|
|
11860,
|
|
11900,
|
|
12000,
|
|
12200,
|
|
12300,
|
|
12400,
|
|
12500,
|
|
12600,
|
|
12700,
|
|
12800,
|
|
12900,
|
|
13000,
|
|
13100,
|
|
13200,
|
|
13300,
|
|
13400,
|
|
13500,
|
|
13600,
|
|
13711,
|
|
13721,
|
|
13731,
|
|
13741,
|
|
13751,
|
|
13761,
|
|
13771,
|
|
13781,
|
|
13800,
|
|
13900,
|
|
14000,
|
|
14100,
|
|
14400,
|
|
14500,
|
|
14700,
|
|
14800,
|
|
14900,
|
|
15000,
|
|
15100,
|
|
15200,
|
|
15300,
|
|
15400,
|
|
15500,
|
|
15600,
|
|
15900,
|
|
16000,
|
|
16100,
|
|
16200,
|
|
16300,
|
|
16400,
|
|
16500,
|
|
16600,
|
|
16700,
|
|
16900,
|
|
17210,
|
|
17300,
|
|
17400,
|
|
17500,
|
|
17600,
|
|
17700,
|
|
17800,
|
|
17900,
|
|
18000,
|
|
18100,
|
|
18200,
|
|
18300,
|
|
18400,
|
|
18500,
|
|
18600,
|
|
18700,
|
|
18800,
|
|
18900,
|
|
19000,
|
|
19100,
|
|
19200,
|
|
19300,
|
|
19500,
|
|
19600,
|
|
19700,
|
|
19800,
|
|
19900,
|
|
20011,
|
|
20012,
|
|
20013,
|
|
20500,
|
|
20510,
|
|
20600,
|
|
20710,
|
|
20800,
|
|
20900,
|
|
21000,
|
|
21100,
|
|
21200,
|
|
21300,
|
|
21400,
|
|
21500,
|
|
21600,
|
|
21700,
|
|
21800,
|
|
22000,
|
|
22100,
|
|
22200,
|
|
22300,
|
|
22400,
|
|
22500,
|
|
22600,
|
|
22700,
|
|
22911,
|
|
22921,
|
|
22931,
|
|
22941,
|
|
22951,
|
|
23001,
|
|
23002,
|
|
23003,
|
|
23100,
|
|
23200,
|
|
23300,
|
|
23400,
|
|
23500,
|
|
23600,
|
|
23700,
|
|
23800,
|
|
23900,
|
|
24100,
|
|
24200,
|
|
24300,
|
|
24410,
|
|
24420,
|
|
24500,
|
|
24600,
|
|
24700,
|
|
24800,
|
|
24900,
|
|
25000,
|
|
25100,
|
|
25200,
|
|
25300,
|
|
25400,
|
|
25500,
|
|
25700,
|
|
25900,
|
|
26000,
|
|
26100,
|
|
26200,
|
|
26300,
|
|
26401,
|
|
26402,
|
|
26403,
|
|
26500,
|
|
26600,
|
|
26700,
|
|
26800,
|
|
26900,
|
|
27000,
|
|
27100,
|
|
27200,
|
|
27300,
|
|
27400,
|
|
27500,
|
|
27600,
|
|
27700,
|
|
27800,
|
|
27900,
|
|
28000,
|
|
);
|
|
|
|
if (scalar @ARGV)
|
|
{
|
|
@hash_types = @ARGV;
|
|
}
|
|
|
|
unlink ($result);
|
|
|
|
chdir ($hashcat_path);
|
|
|
|
for my $hash_type (@hash_types)
|
|
{
|
|
# benchmark always in optimized mode with single hash and mask!
|
|
|
|
my $mask = $default_mask;
|
|
|
|
if ($old_hashcat == 0)
|
|
{
|
|
my $module = get_module ($hash_type);
|
|
|
|
my $st_hash = $module->{"st_hash"};
|
|
my $is_binary = $module->{"is_binary"};
|
|
|
|
open (OUT, ">", "tmp.hash.$hash_type") or die;
|
|
|
|
if ($is_binary)
|
|
{
|
|
print OUT pack ("H*", $st_hash), "\n";
|
|
}
|
|
else
|
|
{
|
|
print OUT "$st_hash\n";
|
|
}
|
|
|
|
close (OUT);
|
|
|
|
$mask = $module->{"mask"};
|
|
}
|
|
|
|
my @command =
|
|
(
|
|
$hashcat_bin, "-D2",
|
|
"--quiet",
|
|
"tmp.hash.$hash_type",
|
|
"--keep-guessing",
|
|
"--self-test-disable",
|
|
"--markov-disable",
|
|
"--restore-disable",
|
|
"--outfile-autohex-disable",
|
|
"--wordlist-autohex-disable",
|
|
"--potfile-disable",
|
|
"--logfile-disable",
|
|
"--status",
|
|
"--status-timer", 1,
|
|
"--runtime", $runtime,
|
|
"--machine-readable",
|
|
"--optimized-kernel-enable",
|
|
"--workload-profile", $workload_profile,
|
|
"--hash-type", $hash_type,
|
|
"--attack-mode", 3,
|
|
$mask
|
|
);
|
|
|
|
if ($cpu_benchmark == 1)
|
|
{
|
|
push (@command, "--opencl-device-types", 1);
|
|
}
|
|
else
|
|
{
|
|
push (@command, "--backend-devices", $device);
|
|
}
|
|
|
|
print "Executing command: ", join (" ", @command), "\n";
|
|
|
|
my $final_speed = 0;
|
|
|
|
for (my $i = 0; $i <= $repeats; $i++)
|
|
{
|
|
printf ("Run #%d\n", $i);
|
|
|
|
open (IN, "-|", @command, "--runtime", 1);
|
|
close (IN);
|
|
|
|
my $was_slower = 0;
|
|
|
|
my $speed = 0;
|
|
|
|
my $sample = 0;
|
|
|
|
open (IN, "-|", @command);
|
|
|
|
while (my $line = <IN>)
|
|
{
|
|
chomp $line;
|
|
|
|
print "$line\n";
|
|
|
|
my @data = split "\t", $line;
|
|
|
|
next unless defined $data[1];
|
|
|
|
next if ($data[1] != '3');
|
|
|
|
$sample++;
|
|
|
|
if ($sample > 5)
|
|
{
|
|
if ($data[3] > $speed)
|
|
{
|
|
$speed = $data[3];
|
|
}
|
|
else
|
|
{
|
|
$was_slower++;
|
|
|
|
last if ($was_slower == 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
close (IN);
|
|
|
|
sleep ($sleep_sec);
|
|
|
|
$final_speed = $speed if ($speed > $final_speed);
|
|
}
|
|
|
|
open (OUT, ">>", $result) or die;
|
|
print OUT $final_speed, "\n";
|
|
close (OUT);
|
|
}
|
|
|
|
sub get_module
|
|
{
|
|
my $hash_type = shift;
|
|
|
|
my $st_hash = undef;
|
|
my $is_binary = 0;
|
|
my $pw_min = -1;
|
|
my $pw_max = -1;
|
|
my $benchmark_mask = undef;
|
|
|
|
my $path = sprintf ("src/modules/module_%05d.c", $hash_type);
|
|
|
|
open (IN, $path) or die;
|
|
|
|
while (my $line = <IN>)
|
|
{
|
|
chomp $line;
|
|
|
|
if ($line =~ /OPTS_TYPE_BINARY_HASHFILE/)
|
|
{
|
|
if (($hash_type == 22000) || ($hash_type == 22001))
|
|
{
|
|
## problem while in -m 2500 backward compatibility mode
|
|
}
|
|
else
|
|
{
|
|
$is_binary = 1;
|
|
}
|
|
}
|
|
|
|
if ($line =~ /ST_HASH *= \"(.*)\"/)
|
|
{
|
|
$st_hash = $1;
|
|
}
|
|
|
|
if ($line =~ /const u32 pw_min = (\d+);/)
|
|
{
|
|
$pw_min = $1;
|
|
}
|
|
|
|
if ($line =~ /const u32 pw_max = (\d+);/)
|
|
{
|
|
$pw_max = $1;
|
|
}
|
|
|
|
if ($line =~ /BENCHMARK_MASK *= \"(.*)\"/)
|
|
{
|
|
$benchmark_mask = $1;
|
|
}
|
|
}
|
|
|
|
close (IN);
|
|
|
|
my $mask = (defined $benchmark_mask) ? $benchmark_mask : $default_mask;
|
|
|
|
if ($pw_min != -1)
|
|
{
|
|
if ($pw_min < 7)
|
|
{
|
|
$mask = substr ($mask, 0, $pw_min * 2);
|
|
}
|
|
else
|
|
{
|
|
my $left = $pw_min - 7;
|
|
|
|
$mask .= "x" x $left;
|
|
}
|
|
}
|
|
elsif ($pw_max != -1)
|
|
{
|
|
if ($pw_max < 7)
|
|
{
|
|
$mask = substr ($mask, 0, $pw_min * 2);
|
|
}
|
|
}
|
|
|
|
my $module =
|
|
{
|
|
"is_binary" => $is_binary,
|
|
"st_hash" => $st_hash,
|
|
"mask" => $mask,
|
|
};
|
|
|
|
return $module;
|
|
}
|