projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added option --stdout to print candidates instead of trying to crack a hash
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 0
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS_MAX 256
88 #define KERNEL_THREADS_MAX_CPU 16
89 #define POWERTUNE_ENABLE 0
90 #define LOGFILE_DISABLE 0
91 #define SCRYPT_TMTO 0
92 #define OPENCL_VECTOR_WIDTH 0
93
94 #define WL_MODE_STDIN 1
95 #define WL_MODE_FILE 2
96 #define WL_MODE_MASK 3
97
98 #define HL_MODE_FILE 4
99 #define HL_MODE_ARG 5
100
101 #define HLFMTS_CNT 11
102 #define HLFMT_HASHCAT 0
103 #define HLFMT_PWDUMP 1
104 #define HLFMT_PASSWD 2
105 #define HLFMT_SHADOW 3
106 #define HLFMT_DCC 4
107 #define HLFMT_DCC2 5
108 #define HLFMT_NETNTLM1 7
109 #define HLFMT_NETNTLM2 8
110 #define HLFMT_NSLDAP 9
111 #define HLFMT_NSLDAPS 10
112
113 #define HLFMT_TEXT_HASHCAT "native hashcat"
114 #define HLFMT_TEXT_PWDUMP "pwdump"
115 #define HLFMT_TEXT_PASSWD "passwd"
116 #define HLFMT_TEXT_SHADOW "shadow"
117 #define HLFMT_TEXT_DCC "DCC"
118 #define HLFMT_TEXT_DCC2 "DCC 2"
119 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
120 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
121 #define HLFMT_TEXT_NSLDAP "nsldap"
122 #define HLFMT_TEXT_NSLDAPS "nsldaps"
123
124 #define ATTACK_MODE_STRAIGHT 0
125 #define ATTACK_MODE_COMBI 1
126 #define ATTACK_MODE_TOGGLE 2
127 #define ATTACK_MODE_BF 3
128 #define ATTACK_MODE_PERM 4
129 #define ATTACK_MODE_TABLE 5
130 #define ATTACK_MODE_HYBRID1 6
131 #define ATTACK_MODE_HYBRID2 7
132 #define ATTACK_MODE_NONE 100
133
134 #define ATTACK_KERN_STRAIGHT 0
135 #define ATTACK_KERN_COMBI 1
136 #define ATTACK_KERN_BF 3
137 #define ATTACK_KERN_NONE 100
138
139 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
140 #define ATTACK_EXEC_INSIDE_KERNEL 11
141
142 #define COMBINATOR_MODE_BASE_LEFT 10001
143 #define COMBINATOR_MODE_BASE_RIGHT 10002
144
145 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
146 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
147
148 #define MAX_CUT_TRIES 4
149
150 #define MAX_DICTSTAT 10000
151
152 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
153
154 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
155
156 #define global_free(attr) \
157 { \
158 myfree ((void *) data.attr); \
159 \
160 data.attr = NULL; \
161 }
162
163 #define local_free(attr) \
164 { \
165 myfree ((void *) attr); \
166 \
167 attr = NULL; \
168 }
169
170 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
171 #define HC_API_CALL __stdcall
172 #else
173 #define HC_API_CALL
174 #endif
175
176 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
177 {
178 900,
179 0,
180 5100,
181 100,
182 1400,
183 10800,
184 1700,
185 5000,
186 10100,
187 6000,
188 6100,
189 6900,
190 11700,
191 11800,
192 400,
193 8900,
194 11900,
195 12000,
196 10900,
197 12100,
198 23,
199 2500,
200 5300,
201 5400,
202 5500,
203 5600,
204 7300,
205 7500,
206 13100,
207 8300,
208 11100,
209 11200,
210 11400,
211 121,
212 2611,
213 2711,
214 2811,
215 8400,
216 11,
217 2612,
218 7900,
219 21,
220 11000,
221 124,
222 10000,
223 3711,
224 7600,
225 12,
226 131,
227 132,
228 1731,
229 200,
230 300,
231 3100,
232 112,
233 12300,
234 8000,
235 141,
236 1441,
237 1600,
238 12600,
239 1421,
240 101,
241 111,
242 1711,
243 3000,
244 1000,
245 1100,
246 2100,
247 12800,
248 1500,
249 12400,
250 500,
251 3200,
252 7400,
253 1800,
254 122,
255 1722,
256 7100,
257 6300,
258 6700,
259 6400,
260 6500,
261 2400,
262 2410,
263 5700,
264 9200,
265 9300,
266 22,
267 501,
268 5800,
269 8100,
270 8500,
271 7200,
272 9900,
273 7700,
274 7800,
275 10300,
276 8600,
277 8700,
278 9100,
279 133,
280 13500,
281 11600,
282 13600,
283 12500,
284 13000,
285 13200,
286 13300,
287 6211,
288 6221,
289 6231,
290 6241,
291 13711,
292 13721,
293 13731,
294 13741,
295 13751,
296 13761,
297 8800,
298 12900,
299 12200,
300 9700,
301 9710,
302 9800,
303 9810,
304 9400,
305 9500,
306 9600,
307 10400,
308 10410,
309 10500,
310 10600,
311 10700,
312 9000,
313 5200,
314 6800,
315 6600,
316 8200,
317 11300,
318 12700,
319 13400,
320 125
321 };
322
323 /**
324 * types
325 */
326
327 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
328
329 /**
330 * globals
331 */
332
333 static unsigned int full01 = 0x01010101;
334 static unsigned int full80 = 0x80808080;
335
336 int SUPPRESS_OUTPUT = 0;
337
338 hc_thread_mutex_t mux_adl;
339 hc_thread_mutex_t mux_counter;
340 hc_thread_mutex_t mux_dispatcher;
341 hc_thread_mutex_t mux_display;
342
343 hc_global_data_t data;
344
345 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
346
347 const char *USAGE_MINI[] =
348 {
349 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
350 "",
351 "Try --help for more help.",
352 NULL
353 };
354
355 const char *USAGE_BIG[] =
356 {
357 "%s, advanced password recovery",
358 "",
359 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
360 "",
361 "- [ Options ] -",
362 "",
363 " Options Short / Long | Type | Description | Example",
364 "===============================|======|======================================================|=======================",
365 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
366 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
367 " -V, --version | | Print version |",
368 " -h, --help | | Print help |",
369 " --quiet | | Suppress output |",
370 " --hex-charset | | Assume charset is given in hex |",
371 " --hex-salt | | Assume salt is given in hex |",
372 " --hex-wordlist | | Assume words in wordlist is given in hex |",
373 " --force | | Ignore warnings |",
374 " --status | | Enable automatic update of the status-screen |",
375 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
376 " --machine-readable | | Display the status view in a machine readable format |",
377 " --loopback | | Add new plains to induct directory |",
378 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
379 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
380 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
381 " --markov-classic | | Enables classic markov-chains, no per-position |",
382 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
383 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
384 " --session | Str | Define specific session name | --session=mysession",
385 " --restore | | Restore session from --session |",
386 " --restore-disable | | Do not write restore file |",
387 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
388 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
389 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
390 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
391 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
392 " --stdout | | Do not crack a hash, instead print candidates only |",
393 " --show | | Show cracked passwords only |",
394 " --left | | Show un-cracked passwords only |",
395 " --username | | Enable ignoring of usernames in hashfile |",
396 " --remove | | Enable remove of hash once it is cracked |",
397 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
398 " --potfile-disable | | Do not write potfile |",
399 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
400 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
401 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
402 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
403 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
404 " --logfile-disable | | Disable the logfile |",
405 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
406 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
407 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
408 " -b, --benchmark | | Run benchmark |",
409 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
410 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
411 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
413 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
414 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
415 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
416 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
417 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
418 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
419 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
420 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
423 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
424 " --powertune-enable | | Enable power tuning, restores settings when finished |",
425 #endif
426 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
427 " -s, --skip | Num | Skip X words from the start | -s 1000000",
428 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
429 " --keyspace | | Show keyspace base:mod values and quit |",
430 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
431 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
432 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
433 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
434 " --generate-rules-func-min | Num | Force min X funcs per rule |",
435 " --generate-rules-func-max | Num | Force max X funcs per rule |",
436 " --generate-rules-seed | Num | Force RNG seed set to X |",
437 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
438 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
439 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
440 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
441 " -i, --increment | | Enable mask increment mode |",
442 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
443 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
444 "",
445 "- [ Hash modes ] -",
446 "",
447 " # | Name | Category",
448 " ======+==================================================+======================================",
449 " 900 | MD4 | Raw Hash",
450 " 0 | MD5 | Raw Hash",
451 " 5100 | Half MD5 | Raw Hash",
452 " 100 | SHA1 | Raw Hash",
453 " 10800 | SHA-384 | Raw Hash",
454 " 1400 | SHA-256 | Raw Hash",
455 " 1700 | SHA-512 | Raw Hash",
456 " 5000 | SHA-3(Keccak) | Raw Hash",
457 " 10100 | SipHash | Raw Hash",
458 " 6000 | RipeMD160 | Raw Hash",
459 " 6100 | Whirlpool | Raw Hash",
460 " 6900 | GOST R 34.11-94 | Raw Hash",
461 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
462 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
463 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
465 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
466 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
467 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
468 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
469 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
470 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
471 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
472 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
473 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
474 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
475 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
477 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
479 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
484 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
485 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
486 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
487 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
488 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
489 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
490 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
491 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
492 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
493 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
494 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
495 " 400 | phpass | Generic KDF",
496 " 8900 | scrypt | Generic KDF",
497 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
498 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
499 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
500 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
501 " 23 | Skype | Network protocols",
502 " 2500 | WPA/WPA2 | Network protocols",
503 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
504 " 5300 | IKE-PSK MD5 | Network protocols",
505 " 5400 | IKE-PSK SHA1 | Network protocols",
506 " 5500 | NetNTLMv1 | Network protocols",
507 " 5500 | NetNTLMv1 + ESS | Network protocols",
508 " 5600 | NetNTLMv2 | Network protocols",
509 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
510 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
511 " 8300 | DNSSEC (NSEC3) | Network protocols",
512 " 10200 | Cram MD5 | Network protocols",
513 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
514 " 11200 | MySQL CRAM (SHA1) | Network protocols",
515 " 11400 | SIP digest authentication (MD5) | Network protocols",
516 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
517 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
519 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
520 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
521 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
522 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
523 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
524 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
525 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
526 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
527 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
528 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
529 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
530 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
531 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
532 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
533 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
534 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
535 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
536 " 12 | PostgreSQL | Database Server",
537 " 131 | MSSQL(2000) | Database Server",
538 " 132 | MSSQL(2005) | Database Server",
539 " 1731 | MSSQL(2012) | Database Server",
540 " 1731 | MSSQL(2014) | Database Server",
541 " 200 | MySQL323 | Database Server",
542 " 300 | MySQL4.1/MySQL5 | Database Server",
543 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
544 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
545 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
546 " 8000 | Sybase ASE | Database Server",
547 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
548 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
549 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
550 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
551 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
552 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
553 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
554 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
555 " 11500 | CRC32 | Checksums",
556 " 3000 | LM | Operating-Systems",
557 " 1000 | NTLM | Operating-Systems",
558 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
559 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
560 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
561 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
562 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
563 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
564 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
565 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
566 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
567 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
568 " 1722 | OSX v10.7 | Operating-Systems",
569 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
570 " 6300 | AIX {smd5} | Operating-Systems",
571 " 6700 | AIX {ssha1} | Operating-Systems",
572 " 6400 | AIX {ssha256} | Operating-Systems",
573 " 6500 | AIX {ssha512} | Operating-Systems",
574 " 2400 | Cisco-PIX | Operating-Systems",
575 " 2410 | Cisco-ASA | Operating-Systems",
576 " 500 | Cisco-IOS $1$ | Operating-Systems",
577 " 5700 | Cisco-IOS $4$ | Operating-Systems",
578 " 9200 | Cisco-IOS $8$ | Operating-Systems",
579 " 9300 | Cisco-IOS $9$ | Operating-Systems",
580 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
581 " 501 | Juniper IVE | Operating-Systems",
582 " 5800 | Android PIN | Operating-Systems",
583 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
584 " 8100 | Citrix Netscaler | Operating-Systems",
585 " 8500 | RACF | Operating-Systems",
586 " 7200 | GRUB 2 | Operating-Systems",
587 " 9900 | Radmin2 | Operating-Systems",
588 " 125 | ArubaOS | Operating-Systems",
589 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
590 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
591 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
592 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
593 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
594 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
595 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
596 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
597 " 11600 | 7-Zip | Archives",
598 " 12500 | RAR3-hp | Archives",
599 " 13000 | RAR5 | Archives",
600 " 13200 | AxCrypt | Archives",
601 " 13300 | AxCrypt in memory SHA1 | Archives",
602 " 13600 | WinZip | Archives",
603 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
604 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
605 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
606 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
607 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
609 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
617 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
618 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
619 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
620 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
621 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
622 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
623 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
624 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
625 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
626 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
627 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
629 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
637 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
638 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
639 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
640 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
641 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
642 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
643 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
644 " 9400 | MS Office 2007 | Documents",
645 " 9500 | MS Office 2010 | Documents",
646 " 9600 | MS Office 2013 | Documents",
647 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
648 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
649 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
650 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
651 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
652 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
653 " 9000 | Password Safe v2 | Password Managers",
654 " 5200 | Password Safe v3 | Password Managers",
655 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
656 " 6600 | 1Password, agilekeychain | Password Managers",
657 " 8200 | 1Password, cloudkeychain | Password Managers",
658 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
659 " 12700 | Blockchain, My Wallet | Password Managers",
660 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
661 "",
662 "- [ Outfile Formats ] -",
663 "",
664 " # | Format",
665 " ===+========",
666 " 1 | hash[:salt]",
667 " 2 | plain",
668 " 3 | hash[:salt]:plain",
669 " 4 | hex_plain",
670 " 5 | hash[:salt]:hex_plain",
671 " 6 | plain:hex_plain",
672 " 7 | hash[:salt]:plain:hex_plain",
673 " 8 | crackpos",
674 " 9 | hash[:salt]:crack_pos",
675 " 10 | plain:crack_pos",
676 " 11 | hash[:salt]:plain:crack_pos",
677 " 12 | hex_plain:crack_pos",
678 " 13 | hash[:salt]:hex_plain:crack_pos",
679 " 14 | plain:hex_plain:crack_pos",
680 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
681 "",
682 "- [ Rule Debugging Modes ] -",
683 "",
684 " # | Format",
685 " ===+========",
686 " 1 | Finding-Rule",
687 " 2 | Original-Word",
688 " 3 | Original-Word:Finding-Rule",
689 " 4 | Original-Word:Finding-Rule:Processed-Word",
690 "",
691 "- [ Attack Modes ] -",
692 "",
693 " # | Mode",
694 " ===+======",
695 " 0 | Straight",
696 " 1 | Combination",
697 " 3 | Brute-force",
698 " 6 | Hybrid Wordlist + Mask",
699 " 7 | Hybrid Mask + Wordlist",
700 "",
701 "- [ Built-in Charsets ] -",
702 "",
703 " ? | Charset",
704 " ===+=========",
705 " l | abcdefghijklmnopqrstuvwxyz",
706 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
707 " d | 0123456789",
708 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
709 " a | ?l?u?d?s",
710 " b | 0x00 - 0xff",
711 "",
712 "- [ OpenCL Device Types ] -",
713 "",
714 " # | Device Type",
715 " ===+=============",
716 " 1 | CPU",
717 " 2 | GPU",
718 " 3 | FPGA, DSP, Co-Processor",
719 "",
720 "- [ Workload Profiles ] -",
721 "",
722 " # | Performance | Runtime | Power Consumption | Desktop Impact",
723 " ===+=============+=========+===================+=================",
724 " 1 | Low | 2 ms | Low | Minimal",
725 " 2 | Default | 12 ms | Economic | Noticeable",
726 " 3 | High | 96 ms | High | Unresponsive",
727 " 4 | Nightmare | 480 ms | Insane | Headless",
728 "",
729 "If you have no idea what just happened then visit the following pages:",
730 "",
731 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
732 "* https://hashcat.net/wiki/#frequently_asked_questions",
733 "",
734 NULL
735 };
736
737 /**
738 * hashcat specific functions
739 */
740
741 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
742 {
743 int exec_pos = (int) device_param->exec_pos - last_num_entries;
744
745 if (exec_pos < 0) exec_pos += EXEC_CACHE;
746
747 double exec_ms_sum = 0;
748
749 int exec_ms_cnt = 0;
750
751 for (int i = 0; i < last_num_entries; i++)
752 {
753 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
754
755 if (exec_ms)
756 {
757 exec_ms_sum += exec_ms;
758
759 exec_ms_cnt++;
760 }
761 }
762
763 if (exec_ms_cnt == 0) return 0;
764
765 return exec_ms_sum / exec_ms_cnt;
766 }
767
768 void status_display_machine_readable ()
769 {
770 FILE *out = stdout;
771
772 fprintf (out, "STATUS\t%u\t", data.devices_status);
773
774 /**
775 * speed new
776 */
777
778 fprintf (out, "SPEED\t");
779
780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
781 {
782 hc_device_param_t *device_param = &data.devices_param[device_id];
783
784 if (device_param->skipped) continue;
785
786 u64 speed_cnt = 0;
787 double speed_ms = 0;
788
789 for (int i = 0; i < SPEED_CACHE; i++)
790 {
791 speed_cnt += device_param->speed_cnt[i];
792 speed_ms += device_param->speed_ms[i];
793 }
794
795 speed_cnt /= SPEED_CACHE;
796 speed_ms /= SPEED_CACHE;
797
798 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
799 }
800
801 /**
802 * exec time
803 */
804
805 fprintf (out, "EXEC_RUNTIME\t");
806
807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
808 {
809 hc_device_param_t *device_param = &data.devices_param[device_id];
810
811 if (device_param->skipped) continue;
812
813 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
814
815 fprintf (out, "%f\t", exec_ms_avg);
816 }
817
818 /**
819 * words_cur
820 */
821
822 u64 words_cur = get_lowest_words_done ();
823
824 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
825
826 /**
827 * counter
828 */
829
830 u64 progress_total = data.words_cnt * data.salts_cnt;
831
832 u64 all_done = 0;
833 u64 all_rejected = 0;
834 u64 all_restored = 0;
835
836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
837 {
838 all_done += data.words_progress_done[salt_pos];
839 all_rejected += data.words_progress_rejected[salt_pos];
840 all_restored += data.words_progress_restored[salt_pos];
841 }
842
843 u64 progress_cur = all_restored + all_done + all_rejected;
844 u64 progress_end = progress_total;
845
846 u64 progress_skip = 0;
847
848 if (data.skip)
849 {
850 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
855 }
856
857 if (data.limit)
858 {
859 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
860
861 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
862 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
863 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
864 }
865
866 u64 progress_cur_relative_skip = progress_cur - progress_skip;
867 u64 progress_end_relative_skip = progress_end - progress_skip;
868
869 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
870
871 /**
872 * cracks
873 */
874
875 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
876 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
877
878 /**
879 * temperature
880 */
881
882 #ifdef HAVE_HWMON
883 if (data.gpu_temp_disable == 0)
884 {
885 fprintf (out, "TEMP\t");
886
887 hc_thread_mutex_lock (mux_adl);
888
889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
890 {
891 hc_device_param_t *device_param = &data.devices_param[device_id];
892
893 if (device_param->skipped) continue;
894
895 int temp = hm_get_temperature_with_device_id (device_id);
896
897 fprintf (out, "%d\t", temp);
898 }
899
900 hc_thread_mutex_unlock (mux_adl);
901 }
902 #endif // HAVE_HWMON
903
904 /**
905 * flush
906 */
907
908 #ifdef _WIN
909 fputc ('\r', out);
910 fputc ('\n', out);
911 #endif
912
913 #ifdef _POSIX
914 fputc ('\n', out);
915 #endif
916
917 fflush (out);
918 }
919
920 void status_display ()
921 {
922 if (data.devices_status == STATUS_INIT) return;
923 if (data.devices_status == STATUS_STARTING) return;
924 if (data.devices_status == STATUS_BYPASS) return;
925
926 if (data.machine_readable == 1)
927 {
928 status_display_machine_readable ();
929
930 return;
931 }
932
933 char tmp_buf[1000] = { 0 };
934
935 uint tmp_len = 0;
936
937 log_info ("Session.Name...: %s", data.session);
938
939 char *status_type = strstatus (data.devices_status);
940
941 uint hash_mode = data.hash_mode;
942
943 char *hash_type = strhashtype (hash_mode); // not a bug
944
945 log_info ("Status.........: %s", status_type);
946
947 /**
948 * show rules
949 */
950
951 if (data.rp_files_cnt)
952 {
953 uint i;
954
955 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
956 {
957 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
958 }
959
960 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
961
962 log_info ("Rules.Type.....: %s", tmp_buf);
963
964 tmp_len = 0;
965 }
966
967 if (data.rp_gen)
968 {
969 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
970
971 if (data.rp_gen_seed)
972 {
973 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
974 }
975 }
976
977 /**
978 * show input
979 */
980
981 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
982 {
983 if (data.wordlist_mode == WL_MODE_FILE)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
986 }
987 else if (data.wordlist_mode == WL_MODE_STDIN)
988 {
989 log_info ("Input.Mode.....: Pipe");
990 }
991 }
992 else if (data.attack_mode == ATTACK_MODE_COMBI)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
995 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
996 }
997 else if (data.attack_mode == ATTACK_MODE_BF)
998 {
999 char *mask = data.mask;
1000
1001 if (mask != NULL)
1002 {
1003 uint mask_len = data.css_cnt;
1004
1005 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1006
1007 if (mask_len > 0)
1008 {
1009 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1010 {
1011 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1012 {
1013 mask_len -= data.salts_buf[0].salt_len;
1014 }
1015 }
1016
1017 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1020 }
1021
1022 if (data.maskcnt > 1)
1023 {
1024 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1027 }
1028
1029 log_info ("Input.Mode.....: %s", tmp_buf);
1030 }
1031
1032 tmp_len = 0;
1033 }
1034 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1035 {
1036 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1037 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1040 {
1041 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1042 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1043 }
1044
1045 if (data.digests_cnt == 1)
1046 {
1047 if (data.hash_mode == 2500)
1048 {
1049 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1050
1051 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1052 (char *) data.salts_buf[0].salt_buf,
1053 wpa->orig_mac1[0],
1054 wpa->orig_mac1[1],
1055 wpa->orig_mac1[2],
1056 wpa->orig_mac1[3],
1057 wpa->orig_mac1[4],
1058 wpa->orig_mac1[5],
1059 wpa->orig_mac2[0],
1060 wpa->orig_mac2[1],
1061 wpa->orig_mac2[2],
1062 wpa->orig_mac2[3],
1063 wpa->orig_mac2[4],
1064 wpa->orig_mac2[5]);
1065 }
1066 else if (data.hash_mode == 5200)
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 else if (data.hash_mode == 9000)
1071 {
1072 log_info ("Hash.Target....: File (%s)", data.hashfile);
1073 }
1074 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1075 {
1076 log_info ("Hash.Target....: File (%s)", data.hashfile);
1077 }
1078 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1079 {
1080 log_info ("Hash.Target....: File (%s)", data.hashfile);
1081 }
1082 else
1083 {
1084 char out_buf[HCBUFSIZ] = { 0 };
1085
1086 ascii_digest (out_buf, 0, 0);
1087
1088 // limit length
1089 if (strlen (out_buf) > 40)
1090 {
1091 out_buf[41] = '.';
1092 out_buf[42] = '.';
1093 out_buf[43] = '.';
1094 out_buf[44] = 0;
1095 }
1096
1097 log_info ("Hash.Target....: %s", out_buf);
1098 }
1099 }
1100 else
1101 {
1102 if (data.hash_mode == 3000)
1103 {
1104 char out_buf1[32] = { 0 };
1105 char out_buf2[32] = { 0 };
1106
1107 ascii_digest (out_buf1, 0, 0);
1108 ascii_digest (out_buf2, 0, 1);
1109
1110 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1111 }
1112 else
1113 {
1114 log_info ("Hash.Target....: File (%s)", data.hashfile);
1115 }
1116 }
1117
1118 log_info ("Hash.Type......: %s", hash_type);
1119
1120 /**
1121 * speed new
1122 */
1123
1124 u64 speed_cnt[DEVICES_MAX] = { 0 };
1125 double speed_ms[DEVICES_MAX] = { 0 };
1126
1127 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1128 {
1129 hc_device_param_t *device_param = &data.devices_param[device_id];
1130
1131 if (device_param->skipped) continue;
1132
1133 speed_cnt[device_id] = 0;
1134 speed_ms[device_id] = 0;
1135
1136 for (int i = 0; i < SPEED_CACHE; i++)
1137 {
1138 speed_cnt[device_id] += device_param->speed_cnt[i];
1139 speed_ms[device_id] += device_param->speed_ms[i];
1140 }
1141
1142 speed_cnt[device_id] /= SPEED_CACHE;
1143 speed_ms[device_id] /= SPEED_CACHE;
1144 }
1145
1146 double hashes_all_ms = 0;
1147
1148 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1149
1150 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1151 {
1152 hc_device_param_t *device_param = &data.devices_param[device_id];
1153
1154 if (device_param->skipped) continue;
1155
1156 hashes_dev_ms[device_id] = 0;
1157
1158 if (speed_ms[device_id])
1159 {
1160 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1161
1162 hashes_all_ms += hashes_dev_ms[device_id];
1163 }
1164 }
1165
1166 /**
1167 * exec time
1168 */
1169
1170 double exec_all_ms[DEVICES_MAX] = { 0 };
1171
1172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1173 {
1174 hc_device_param_t *device_param = &data.devices_param[device_id];
1175
1176 if (device_param->skipped) continue;
1177
1178 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1179
1180 exec_all_ms[device_id] = exec_ms_avg;
1181 }
1182
1183 /**
1184 * timers
1185 */
1186
1187 double ms_running = 0;
1188
1189 hc_timer_get (data.timer_running, ms_running);
1190
1191 double ms_paused = data.ms_paused;
1192
1193 if (data.devices_status == STATUS_PAUSED)
1194 {
1195 double ms_paused_tmp = 0;
1196
1197 hc_timer_get (data.timer_paused, ms_paused_tmp);
1198
1199 ms_paused += ms_paused_tmp;
1200 }
1201
1202 #ifdef WIN
1203
1204 __time64_t sec_run = ms_running / 1000;
1205
1206 #else
1207
1208 time_t sec_run = ms_running / 1000;
1209
1210 #endif
1211
1212 if (sec_run)
1213 {
1214 char display_run[32] = { 0 };
1215
1216 struct tm tm_run;
1217
1218 struct tm *tmp = NULL;
1219
1220 #ifdef WIN
1221
1222 tmp = _gmtime64 (&sec_run);
1223
1224 #else
1225
1226 tmp = gmtime (&sec_run);
1227
1228 #endif
1229
1230 if (tmp != NULL)
1231 {
1232 memset (&tm_run, 0, sizeof (tm_run));
1233
1234 memcpy (&tm_run, tmp, sizeof (tm_run));
1235
1236 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1237
1238 char *start = ctime (&data.proc_start);
1239
1240 size_t start_len = strlen (start);
1241
1242 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1243 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1244
1245 log_info ("Time.Started...: %s (%s)", start, display_run);
1246 }
1247 }
1248 else
1249 {
1250 log_info ("Time.Started...: 0 secs");
1251 }
1252
1253 /**
1254 * counters
1255 */
1256
1257 u64 progress_total = data.words_cnt * data.salts_cnt;
1258
1259 u64 all_done = 0;
1260 u64 all_rejected = 0;
1261 u64 all_restored = 0;
1262
1263 u64 progress_noneed = 0;
1264
1265 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1266 {
1267 all_done += data.words_progress_done[salt_pos];
1268 all_rejected += data.words_progress_rejected[salt_pos];
1269 all_restored += data.words_progress_restored[salt_pos];
1270
1271 // Important for ETA only
1272
1273 if (data.salts_shown[salt_pos] == 1)
1274 {
1275 const u64 all = data.words_progress_done[salt_pos]
1276 + data.words_progress_rejected[salt_pos]
1277 + data.words_progress_restored[salt_pos];
1278
1279 const u64 left = data.words_cnt - all;
1280
1281 progress_noneed += left;
1282 }
1283 }
1284
1285 u64 progress_cur = all_restored + all_done + all_rejected;
1286 u64 progress_end = progress_total;
1287
1288 u64 progress_skip = 0;
1289
1290 if (data.skip)
1291 {
1292 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1297 }
1298
1299 if (data.limit)
1300 {
1301 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1302
1303 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1306 }
1307
1308 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1309 u64 progress_end_relative_skip = progress_end - progress_skip;
1310
1311 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1312 {
1313 if (data.devices_status != STATUS_CRACKED)
1314 {
1315 #ifdef WIN
1316 __time64_t sec_etc = 0;
1317 #else
1318 time_t sec_etc = 0;
1319 #endif
1320
1321 if (hashes_all_ms)
1322 {
1323 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1324
1325 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1326
1327 sec_etc = ms_left / 1000;
1328 }
1329
1330 if (sec_etc == 0)
1331 {
1332 //log_info ("Time.Estimated.: 0 secs");
1333 }
1334 else if ((u64) sec_etc > ETC_MAX)
1335 {
1336 log_info ("Time.Estimated.: > 10 Years");
1337 }
1338 else
1339 {
1340 char display_etc[32] = { 0 };
1341
1342 struct tm tm_etc;
1343
1344 struct tm *tmp = NULL;
1345
1346 #ifdef WIN
1347
1348 tmp = _gmtime64 (&sec_etc);
1349
1350 #else
1351
1352 tmp = gmtime (&sec_etc);
1353
1354 #endif
1355
1356 if (tmp != NULL)
1357 {
1358 memset (&tm_etc, 0, sizeof (tm_etc));
1359
1360 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1361
1362 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1363
1364 time_t now;
1365
1366 time (&now);
1367
1368 now += sec_etc;
1369
1370 char *etc = ctime (&now);
1371
1372 size_t etc_len = strlen (etc);
1373
1374 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1375 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1376
1377 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1378 }
1379 }
1380 }
1381 }
1382
1383 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1384 {
1385 hc_device_param_t *device_param = &data.devices_param[device_id];
1386
1387 if (device_param->skipped) continue;
1388
1389 char display_dev_cur[16] = { 0 };
1390
1391 strncpy (display_dev_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1394
1395 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1396 }
1397
1398 char display_all_cur[16] = { 0 };
1399
1400 strncpy (display_all_cur, "0.00", 4);
1401
1402 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1403
1404 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1405
1406 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1407 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1408
1409 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1410
1411 // crack-per-time
1412
1413 if (data.digests_cnt > 100)
1414 {
1415 time_t now = time (NULL);
1416
1417 int cpt_cur_min = 0;
1418 int cpt_cur_hour = 0;
1419 int cpt_cur_day = 0;
1420
1421 for (int i = 0; i < CPT_BUF; i++)
1422 {
1423 const uint cracked = data.cpt_buf[i].cracked;
1424 const time_t timestamp = data.cpt_buf[i].timestamp;
1425
1426 if ((timestamp + 60) > now)
1427 {
1428 cpt_cur_min += cracked;
1429 }
1430
1431 if ((timestamp + 3600) > now)
1432 {
1433 cpt_cur_hour += cracked;
1434 }
1435
1436 if ((timestamp + 86400) > now)
1437 {
1438 cpt_cur_day += cracked;
1439 }
1440 }
1441
1442 double ms_real = ms_running - ms_paused;
1443
1444 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1445 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1446 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1447
1448 if ((data.cpt_start + 86400) < now)
1449 {
1450 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1451 cpt_cur_min,
1452 cpt_cur_hour,
1453 cpt_cur_day,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 3600) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_cur_hour,
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 else if ((data.cpt_start + 60) < now)
1468 {
1469 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1470 cpt_cur_min,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else
1476 {
1477 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 }
1483
1484 // Restore point
1485
1486 u64 restore_point = get_lowest_words_done ();
1487
1488 u64 restore_total = data.words_base;
1489
1490 float percent_restore = 0;
1491
1492 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1493
1494 if (progress_end_relative_skip)
1495 {
1496 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1497 {
1498 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1499 float percent_rejected = 0.0;
1500
1501 if (progress_cur)
1502 {
1503 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1504 }
1505
1506 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1507 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1508
1509 if (data.restore_disable == 0)
1510 {
1511 if (percent_finished != 1)
1512 {
1513 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1514 }
1515 }
1516 }
1517 }
1518 else
1519 {
1520 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1521 {
1522 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1523 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1524
1525 if (data.restore_disable == 0)
1526 {
1527 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1528 }
1529 }
1530 else
1531 {
1532 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1533 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1534
1535 // --restore not allowed if stdin is used -- really? why?
1536
1537 //if (data.restore_disable == 0)
1538 //{
1539 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1540 //}
1541 }
1542 }
1543
1544 #ifdef HAVE_HWMON
1545
1546 if (data.devices_status == STATUS_EXHAUSTED) return;
1547 if (data.devices_status == STATUS_CRACKED) return;
1548 if (data.devices_status == STATUS_ABORTED) return;
1549 if (data.devices_status == STATUS_QUIT) return;
1550
1551 if (data.gpu_temp_disable == 0)
1552 {
1553 hc_thread_mutex_lock (mux_adl);
1554
1555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1556 {
1557 hc_device_param_t *device_param = &data.devices_param[device_id];
1558
1559 if (device_param->skipped) continue;
1560
1561 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1562 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1563 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1564 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1565 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1566 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1567 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1568
1569 char output_buf[256] = { 0 };
1570
1571 int output_len = 0;
1572
1573 if (num_temperature >= 0)
1574 {
1575 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1576
1577 output_len = strlen (output_buf);
1578 }
1579
1580 if (num_fanspeed >= 0)
1581 {
1582 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1583
1584 output_len = strlen (output_buf);
1585 }
1586
1587 if (num_utilization >= 0)
1588 {
1589 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1590
1591 output_len = strlen (output_buf);
1592 }
1593
1594 if (num_corespeed >= 0)
1595 {
1596 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1597
1598 output_len = strlen (output_buf);
1599 }
1600
1601 if (num_memoryspeed >= 0)
1602 {
1603 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1604
1605 output_len = strlen (output_buf);
1606 }
1607
1608 if (num_buslanes >= 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 if (num_throttle == 1)
1616 {
1617 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1618
1619 output_len = strlen (output_buf);
1620 }
1621
1622 if (output_len == 0)
1623 {
1624 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1625
1626 output_len = strlen (output_buf);
1627 }
1628
1629 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634
1635 #endif // HAVE_HWMON
1636 }
1637
1638 static void status_benchmark_automate ()
1639 {
1640 u64 speed_cnt[DEVICES_MAX] = { 0 };
1641 double speed_ms[DEVICES_MAX] = { 0 };
1642
1643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1644 {
1645 hc_device_param_t *device_param = &data.devices_param[device_id];
1646
1647 if (device_param->skipped) continue;
1648
1649 speed_cnt[device_id] = device_param->speed_cnt[0];
1650 speed_ms[device_id] = device_param->speed_ms[0];
1651 }
1652
1653 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 hashes_dev_ms[device_id] = 0;
1662
1663 if (speed_ms[device_id])
1664 {
1665 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1666 }
1667 }
1668
1669 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1670 {
1671 hc_device_param_t *device_param = &data.devices_param[device_id];
1672
1673 if (device_param->skipped) continue;
1674
1675 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1676 }
1677 }
1678
1679 static void status_benchmark ()
1680 {
1681 if (data.devices_status == STATUS_INIT) return;
1682 if (data.devices_status == STATUS_STARTING) return;
1683 if (data.devices_status == STATUS_BYPASS) return;
1684
1685 if (data.machine_readable == 1)
1686 {
1687 status_benchmark_automate ();
1688
1689 return;
1690 }
1691
1692 u64 speed_cnt[DEVICES_MAX] = { 0 };
1693 double speed_ms[DEVICES_MAX] = { 0 };
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 speed_cnt[device_id] = device_param->speed_cnt[0];
1702 speed_ms[device_id] = device_param->speed_ms[0];
1703 }
1704
1705 double hashes_all_ms = 0;
1706
1707 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1708
1709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1710 {
1711 hc_device_param_t *device_param = &data.devices_param[device_id];
1712
1713 if (device_param->skipped) continue;
1714
1715 hashes_dev_ms[device_id] = 0;
1716
1717 if (speed_ms[device_id])
1718 {
1719 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1720
1721 hashes_all_ms += hashes_dev_ms[device_id];
1722 }
1723 }
1724
1725 /**
1726 * exec time
1727 */
1728
1729 double exec_all_ms[DEVICES_MAX] = { 0 };
1730
1731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1732 {
1733 hc_device_param_t *device_param = &data.devices_param[device_id];
1734
1735 if (device_param->skipped) continue;
1736
1737 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1738
1739 exec_all_ms[device_id] = exec_ms_avg;
1740 }
1741
1742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1743 {
1744 hc_device_param_t *device_param = &data.devices_param[device_id];
1745
1746 if (device_param->skipped) continue;
1747
1748 char display_dev_cur[16] = { 0 };
1749
1750 strncpy (display_dev_cur, "0.00", 4);
1751
1752 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1753
1754 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1755 }
1756
1757 char display_all_cur[16] = { 0 };
1758
1759 strncpy (display_all_cur, "0.00", 4);
1760
1761 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1762
1763 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1764 }
1765
1766 /**
1767 * hashcat -only- functions
1768 */
1769
1770 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1780 }
1781 else
1782 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1783 }
1784
1785 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1786 {
1787 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1788 {
1789 if (attack_kern == ATTACK_KERN_STRAIGHT)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_COMBI)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_BF)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 }
1796 else
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 }
1800 }
1801
1802 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1803 {
1804 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1805 {
1806 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1807 }
1808 else
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1811 }
1812 }
1813
1814 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1815 {
1816 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1819 }
1820 else
1821 {
1822 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1823 }
1824 }
1825
1826 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1827 {
1828 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1829 }
1830
1831 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1832 {
1833 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1834 }
1835
1836 static uint convert_from_hex (char *line_buf, const uint line_len)
1837 {
1838 if (line_len & 1) return (line_len); // not in hex
1839
1840 if (data.hex_wordlist == 1)
1841 {
1842 uint i;
1843 uint j;
1844
1845 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1846 {
1847 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1848 }
1849
1850 memset (line_buf + i, 0, line_len - i);
1851
1852 return (i);
1853 }
1854 else if (line_len >= 6) // $HEX[] = 6
1855 {
1856 if (line_buf[0] != '$') return (line_len);
1857 if (line_buf[1] != 'H') return (line_len);
1858 if (line_buf[2] != 'E') return (line_len);
1859 if (line_buf[3] != 'X') return (line_len);
1860 if (line_buf[4] != '[') return (line_len);
1861 if (line_buf[line_len - 1] != ']') return (line_len);
1862
1863 uint i;
1864 uint j;
1865
1866 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1867 {
1868 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1869 }
1870
1871 memset (line_buf + i, 0, line_len - i);
1872
1873 return (i);
1874 }
1875
1876 return (line_len);
1877 }
1878
1879 static void clear_prompt ()
1880 {
1881 fputc ('\r', stdout);
1882
1883 for (size_t i = 0; i < strlen (PROMPT); i++)
1884 {
1885 fputc (' ', stdout);
1886 }
1887
1888 fputc ('\r', stdout);
1889
1890 fflush (stdout);
1891 }
1892
1893 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1894 {
1895 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1896 }
1897
1898 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1899 {
1900 char *outfile = data.outfile;
1901 uint quiet = data.quiet;
1902 FILE *pot_fp = data.pot_fp;
1903 uint loopback = data.loopback;
1904 uint debug_mode = data.debug_mode;
1905 char *debug_file = data.debug_file;
1906
1907 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1908 int debug_rule_len = 0; // -1 error
1909 uint debug_plain_len = 0;
1910
1911 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1912
1913 // hash
1914
1915 char out_buf[HCBUFSIZ] = { 0 };
1916
1917 const u32 salt_pos = plain->salt_pos;
1918 const u32 digest_pos = plain->digest_pos; // relative
1919 const u32 gidvid = plain->gidvid;
1920 const u32 il_pos = plain->il_pos;
1921
1922 ascii_digest (out_buf, salt_pos, digest_pos);
1923
1924 // plain
1925
1926 u64 crackpos = device_param->words_off;
1927
1928 uint plain_buf[16] = { 0 };
1929
1930 u8 *plain_ptr = (u8 *) plain_buf;
1931
1932 unsigned int plain_len = 0;
1933
1934 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1935 {
1936 pw_t pw;
1937
1938 gidd_to_pw_t (device_param, gidvid, &pw);
1939
1940 for (int i = 0; i < 16; i++)
1941 {
1942 plain_buf[i] = pw.i[i];
1943 }
1944
1945 plain_len = pw.pw_len;
1946
1947 const uint off = device_param->innerloop_pos + il_pos;
1948
1949 if (debug_mode > 0)
1950 {
1951 debug_rule_len = 0;
1952
1953 // save rule
1954 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1955 {
1956 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1957
1958 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1959 }
1960
1961 // save plain
1962 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1963 {
1964 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1965
1966 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1967
1968 debug_plain_len = plain_len;
1969 }
1970 }
1971
1972 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1973
1974 crackpos += gidvid;
1975 crackpos *= data.kernel_rules_cnt;
1976 crackpos += device_param->innerloop_pos + il_pos;
1977
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_COMBI)
1981 {
1982 pw_t pw;
1983
1984 gidd_to_pw_t (device_param, gidvid, &pw);
1985
1986 for (int i = 0; i < 16; i++)
1987 {
1988 plain_buf[i] = pw.i[i];
1989 }
1990
1991 plain_len = pw.pw_len;
1992
1993 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1994 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1995
1996 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1997 {
1998 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1999 }
2000 else
2001 {
2002 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2003
2004 memcpy (plain_ptr, comb_buf, comb_len);
2005 }
2006
2007 plain_len += comb_len;
2008
2009 crackpos += gidvid;
2010 crackpos *= data.combs_cnt;
2011 crackpos += device_param->innerloop_pos + il_pos;
2012
2013 if (data.pw_max != PW_DICTMAX1)
2014 {
2015 if (plain_len > data.pw_max) plain_len = data.pw_max;
2016 }
2017 }
2018 else if (data.attack_mode == ATTACK_MODE_BF)
2019 {
2020 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2021 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2022
2023 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2024 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2025
2026 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2027 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2028
2029 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2030 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2031
2032 plain_len = data.css_cnt;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.bfs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037 }
2038 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2039 {
2040 pw_t pw;
2041
2042 gidd_to_pw_t (device_param, gidvid, &pw);
2043
2044 for (int i = 0; i < 16; i++)
2045 {
2046 plain_buf[i] = pw.i[i];
2047 }
2048
2049 plain_len = pw.pw_len;
2050
2051 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2052
2053 uint start = 0;
2054 uint stop = device_param->kernel_params_mp_buf32[4];
2055
2056 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2057
2058 plain_len += start + stop;
2059
2060 crackpos += gidvid;
2061 crackpos *= data.combs_cnt;
2062 crackpos += device_param->innerloop_pos + il_pos;
2063
2064 if (data.pw_max != PW_DICTMAX1)
2065 {
2066 if (plain_len > data.pw_max) plain_len = data.pw_max;
2067 }
2068 }
2069 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2070 {
2071 pw_t pw;
2072
2073 gidd_to_pw_t (device_param, gidvid, &pw);
2074
2075 for (int i = 0; i < 16; i++)
2076 {
2077 plain_buf[i] = pw.i[i];
2078 }
2079
2080 plain_len = pw.pw_len;
2081
2082 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2083
2084 uint start = 0;
2085 uint stop = device_param->kernel_params_mp_buf32[4];
2086
2087 memmove (plain_ptr + stop, plain_ptr, plain_len);
2088
2089 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2090
2091 plain_len += start + stop;
2092
2093 crackpos += gidvid;
2094 crackpos *= data.combs_cnt;
2095 crackpos += device_param->innerloop_pos + il_pos;
2096
2097 if (data.pw_max != PW_DICTMAX1)
2098 {
2099 if (plain_len > data.pw_max) plain_len = data.pw_max;
2100 }
2101 }
2102
2103 if (data.attack_mode == ATTACK_MODE_BF)
2104 {
2105 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2106 {
2107 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2108 {
2109 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2110 {
2111 plain_len = plain_len - data.salts_buf[0].salt_len;
2112 }
2113 }
2114
2115 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2116 {
2117 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2118 {
2119 plain_ptr[j] = plain_ptr[i];
2120 }
2121
2122 plain_len = plain_len / 2;
2123 }
2124 }
2125 }
2126
2127 // if enabled, update also the potfile
2128
2129 if (pot_fp)
2130 {
2131 lock_file (pot_fp);
2132
2133 fprintf (pot_fp, "%s:", out_buf);
2134
2135 format_plain (pot_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', pot_fp);
2138
2139 fflush (pot_fp);
2140
2141 unlock_file (pot_fp);
2142 }
2143
2144 // outfile
2145
2146 FILE *out_fp = NULL;
2147
2148 if (outfile != NULL)
2149 {
2150 if ((out_fp = fopen (outfile, "ab")) == NULL)
2151 {
2152 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2153
2154 out_fp = stdout;
2155 }
2156
2157 lock_file (out_fp);
2158 }
2159 else
2160 {
2161 out_fp = stdout;
2162
2163 if (quiet == 0) clear_prompt ();
2164 }
2165
2166 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2167
2168 if (outfile != NULL)
2169 {
2170 if (out_fp != stdout)
2171 {
2172 fclose (out_fp);
2173 }
2174 }
2175 else
2176 {
2177 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2178 {
2179 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2180 {
2181 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2182 if (quiet == 0) fflush (stdout);
2183 }
2184 }
2185 }
2186
2187 // loopback
2188
2189 if (loopback)
2190 {
2191 char *loopback_file = data.loopback_file;
2192
2193 FILE *fb_fp = NULL;
2194
2195 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2196 {
2197 lock_file (fb_fp);
2198
2199 format_plain (fb_fp, plain_ptr, plain_len, 1);
2200
2201 fputc ('\n', fb_fp);
2202
2203 fclose (fb_fp);
2204 }
2205 }
2206
2207 // (rule) debug mode
2208
2209 // the next check implies that:
2210 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2211 // - debug_mode > 0
2212
2213 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2214 {
2215 if (debug_rule_len < 0) debug_rule_len = 0;
2216
2217 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2218
2219 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2220
2221 if ((quiet == 0) && (debug_file == NULL))
2222 {
2223 fprintf (stdout, "%s", PROMPT);
2224
2225 fflush (stdout);
2226 }
2227 }
2228 }
2229
2230 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2231 {
2232 salt_t *salt_buf = &data.salts_buf[salt_pos];
2233
2234 u32 num_cracked;
2235
2236 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2237
2238 if (num_cracked)
2239 {
2240 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2241
2242 log_info_nn ("");
2243
2244 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2245
2246 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2247
2248 uint cpt_cracked = 0;
2249
2250 for (uint i = 0; i < num_cracked; i++)
2251 {
2252 const uint hash_pos = cracked[i].hash_pos;
2253
2254 if (data.digests_shown[hash_pos] == 1) continue;
2255
2256 hc_thread_mutex_lock (mux_display);
2257
2258 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2259 {
2260 data.digests_shown[hash_pos] = 1;
2261
2262 data.digests_done++;
2263
2264 cpt_cracked++;
2265
2266 salt_buf->digests_done++;
2267
2268 if (salt_buf->digests_done == salt_buf->digests_cnt)
2269 {
2270 data.salts_shown[salt_pos] = 1;
2271
2272 data.salts_done++;
2273 }
2274 }
2275
2276 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2277
2278 hc_thread_mutex_unlock (mux_display);
2279
2280 check_hash (device_param, &cracked[i]);
2281 }
2282
2283 myfree (cracked);
2284
2285 if (cpt_cracked > 0)
2286 {
2287 hc_thread_mutex_lock (mux_display);
2288
2289 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2290 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2291
2292 data.cpt_pos++;
2293
2294 data.cpt_total += cpt_cracked;
2295
2296 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2297
2298 hc_thread_mutex_unlock (mux_display);
2299 }
2300
2301 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2302 {
2303 // we need to reset cracked state on the device
2304 // otherwise host thinks again and again the hash was cracked
2305 // and returns invalid password each time
2306
2307 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2308
2309 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2310 }
2311
2312 num_cracked = 0;
2313
2314 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2315 }
2316 }
2317
2318 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2319 {
2320 char out_buf[HCBUFSIZ] = { 0 };
2321
2322 uint plain_buf[16] = { 0 };
2323
2324 u8 *plain_ptr = (u8 *) plain_buf;
2325
2326 uint plain_len = 0;
2327
2328 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2329
2330 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2331 {
2332 pw_t pw;
2333
2334 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2335 {
2336 gidd_to_pw_t (device_param, gidvid, &pw);
2337
2338 const uint pos = device_param->innerloop_pos;
2339
2340 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2341 {
2342 for (int i = 0; i < 8; i++)
2343 {
2344 plain_buf[i] = pw.i[i];
2345 }
2346
2347 plain_len = pw.pw_len;
2348
2349 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2350
2351 if (plain_len > data.pw_max) plain_len = data.pw_max;
2352
2353 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2354 }
2355 }
2356 }
2357 else if (data.attack_mode == ATTACK_MODE_COMBI)
2358 {
2359 pw_t pw;
2360
2361 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2362 {
2363 gidd_to_pw_t (device_param, gidvid, &pw);
2364
2365 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2366 {
2367 for (int i = 0; i < 8; i++)
2368 {
2369 plain_buf[i] = pw.i[i];
2370 }
2371
2372 plain_len = pw.pw_len;
2373
2374 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2375 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2376
2377 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2378 {
2379 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2380 }
2381 else
2382 {
2383 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2384
2385 memcpy (plain_ptr, comb_buf, comb_len);
2386 }
2387
2388 plain_len += comb_len;
2389
2390 if (data.pw_max != PW_DICTMAX1)
2391 {
2392 if (plain_len > data.pw_max) plain_len = data.pw_max;
2393 }
2394
2395 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2396 }
2397 }
2398 }
2399 else if (data.attack_mode == ATTACK_MODE_BF)
2400 {
2401 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2402 {
2403 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2404 {
2405 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2406 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2407
2408 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2409 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2410
2411 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2412 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2413
2414 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2415 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2416
2417 plain_len = data.css_cnt;
2418
2419 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2441
2442 uint start = 0;
2443 uint stop = device_param->kernel_params_mp_buf32[4];
2444
2445 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2446
2447 plain_len += start + stop;
2448
2449 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2450 }
2451 }
2452 }
2453 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2454 {
2455 pw_t pw;
2456
2457 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2458 {
2459 gidd_to_pw_t (device_param, gidvid, &pw);
2460
2461 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2462 {
2463 for (int i = 0; i < 8; i++)
2464 {
2465 plain_buf[i] = pw.i[i];
2466 }
2467
2468 plain_len = pw.pw_len;
2469
2470 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2471
2472 uint start = 0;
2473 uint stop = device_param->kernel_params_mp_buf32[4];
2474
2475 memmove (plain_ptr + stop, plain_ptr, plain_len);
2476
2477 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2478
2479 plain_len += start + stop;
2480
2481 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2482 }
2483 }
2484 }
2485 }
2486
2487 static void save_hash ()
2488 {
2489 char *hashfile = data.hashfile;
2490
2491 char new_hashfile[256] = { 0 };
2492 char old_hashfile[256] = { 0 };
2493
2494 snprintf (new_hashfile, 255, "%s.new", hashfile);
2495 snprintf (old_hashfile, 255, "%s.old", hashfile);
2496
2497 unlink (new_hashfile);
2498
2499 char separator = data.separator;
2500
2501 FILE *fp = fopen (new_hashfile, "wb");
2502
2503 if (fp == NULL)
2504 {
2505 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2506
2507 exit (-1);
2508 }
2509
2510 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2511 {
2512 if (data.salts_shown[salt_pos] == 1) continue;
2513
2514 salt_t *salt_buf = &data.salts_buf[salt_pos];
2515
2516 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2517 {
2518 uint idx = salt_buf->digests_offset + digest_pos;
2519
2520 if (data.digests_shown[idx] == 1) continue;
2521
2522 if (data.hash_mode != 2500)
2523 {
2524 char out_buf[HCBUFSIZ] = { 0 };
2525
2526 if (data.username == 1)
2527 {
2528 user_t *user = data.hash_info[idx]->user;
2529
2530 uint i;
2531
2532 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2533
2534 fputc (separator, fp);
2535 }
2536
2537 ascii_digest (out_buf, salt_pos, digest_pos);
2538
2539 fputs (out_buf, fp);
2540
2541 log_out (fp, "");
2542 }
2543 else
2544 {
2545 hccap_t hccap;
2546
2547 to_hccap_t (&hccap, salt_pos, digest_pos);
2548
2549 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2550 }
2551 }
2552 }
2553
2554 fflush (fp);
2555
2556 fclose (fp);
2557
2558 unlink (old_hashfile);
2559
2560 if (rename (hashfile, old_hashfile) != 0)
2561 {
2562 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2563
2564 exit (-1);
2565 }
2566
2567 unlink (hashfile);
2568
2569 if (rename (new_hashfile, hashfile) != 0)
2570 {
2571 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2572
2573 exit (-1);
2574 }
2575
2576 unlink (old_hashfile);
2577 }
2578
2579 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2580 {
2581 uint num_elements = num;
2582
2583 device_param->kernel_params_buf32[30] = data.combs_mode;
2584 device_param->kernel_params_buf32[31] = num;
2585
2586 uint kernel_threads = device_param->kernel_threads;
2587
2588 while (num_elements % kernel_threads) num_elements++;
2589
2590 cl_kernel kernel = NULL;
2591
2592 switch (kern_run)
2593 {
2594 case KERN_RUN_1: kernel = device_param->kernel1; break;
2595 case KERN_RUN_12: kernel = device_param->kernel12; break;
2596 case KERN_RUN_2: kernel = device_param->kernel2; break;
2597 case KERN_RUN_23: kernel = device_param->kernel23; break;
2598 case KERN_RUN_3: kernel = device_param->kernel3; break;
2599 }
2600
2601 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2602 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2603 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2604 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2605 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2606 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2607 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2608 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2609 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2610 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2611 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2612
2613 cl_event event;
2614
2615 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2616 {
2617 const size_t global_work_size[3] = { num_elements, 32, 1 };
2618 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2619
2620 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2621 }
2622 else
2623 {
2624 if (kern_run == KERN_RUN_2)
2625 {
2626 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2627 {
2628 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2629 }
2630 }
2631
2632 while (num_elements % kernel_threads) num_elements++;
2633
2634 const size_t global_work_size[3] = { num_elements, 1, 1 };
2635 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2636
2637 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2638 }
2639
2640 hc_clFlush (data.ocl, device_param->command_queue);
2641
2642 if (data.devices_status == STATUS_RUNNING)
2643 {
2644 if (iteration < EXPECTED_ITERATIONS)
2645 {
2646 switch (kern_run)
2647 {
2648 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration]); break;
2649 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration]); break;
2650 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration]); break;
2651 }
2652 }
2653 }
2654
2655 hc_clWaitForEvents (data.ocl, 1, &event);
2656
2657 cl_ulong time_start;
2658 cl_ulong time_end;
2659
2660 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2661 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2662
2663 const double exec_us = (double) (time_end - time_start) / 1000;
2664
2665 if (data.devices_status == STATUS_RUNNING)
2666 {
2667 if (iteration < EXPECTED_ITERATIONS)
2668 {
2669 switch (kern_run)
2670 {
2671 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2672 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2673 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2674 }
2675 }
2676 }
2677
2678 if (event_update)
2679 {
2680 uint exec_pos = device_param->exec_pos;
2681
2682 device_param->exec_ms[exec_pos] = exec_us / 1000;
2683
2684 exec_pos++;
2685
2686 if (exec_pos == EXEC_CACHE)
2687 {
2688 exec_pos = 0;
2689 }
2690
2691 device_param->exec_pos = exec_pos;
2692 }
2693
2694 hc_clReleaseEvent (data.ocl, event);
2695
2696 hc_clFinish (data.ocl, device_param->command_queue);
2697 }
2698
2699 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2700 {
2701 uint num_elements = num;
2702
2703 switch (kern_run)
2704 {
2705 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2706 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2707 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2708 }
2709
2710 // causes problems with special threads like in bcrypt
2711 // const uint kernel_threads = device_param->kernel_threads;
2712
2713 uint kernel_threads = device_param->kernel_threads;
2714
2715 while (num_elements % kernel_threads) num_elements++;
2716
2717 cl_kernel kernel = NULL;
2718
2719 switch (kern_run)
2720 {
2721 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2722 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2723 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2724 }
2725
2726 switch (kern_run)
2727 {
2728 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2729 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2730 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2731 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2732 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2733 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2734 break;
2735 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2736 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2737 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2738 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2739 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2740 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2741 break;
2742 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2743 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2744 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2745 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2746 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2747 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2748 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2749 break;
2750 }
2751
2752 const size_t global_work_size[3] = { num_elements, 1, 1 };
2753 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2754
2755 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2756
2757 hc_clFlush (data.ocl, device_param->command_queue);
2758
2759 hc_clFinish (data.ocl, device_param->command_queue);
2760 }
2761
2762 static void run_kernel_tm (hc_device_param_t *device_param)
2763 {
2764 const uint num_elements = 1024; // fixed
2765
2766 uint kernel_threads = 32;
2767
2768 cl_kernel kernel = device_param->kernel_tm;
2769
2770 const size_t global_work_size[3] = { num_elements, 1, 1 };
2771 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2772
2773 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2774
2775 hc_clFlush (data.ocl, device_param->command_queue);
2776
2777 hc_clFinish (data.ocl, device_param->command_queue);
2778 }
2779
2780 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2781 {
2782 uint num_elements = num;
2783
2784 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2785 device_param->kernel_params_amp_buf32[6] = num_elements;
2786
2787 // causes problems with special threads like in bcrypt
2788 // const uint kernel_threads = device_param->kernel_threads;
2789
2790 uint kernel_threads = device_param->kernel_threads;
2791
2792 while (num_elements % kernel_threads) num_elements++;
2793
2794 cl_kernel kernel = device_param->kernel_amp;
2795
2796 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2797 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2798
2799 const size_t global_work_size[3] = { num_elements, 1, 1 };
2800 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2801
2802 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2803
2804 hc_clFlush (data.ocl, device_param->command_queue);
2805
2806 hc_clFinish (data.ocl, device_param->command_queue);
2807 }
2808
2809 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2810 {
2811 const u32 num16d = num / 16;
2812 const u32 num16m = num % 16;
2813
2814 if (num16d)
2815 {
2816 device_param->kernel_params_memset_buf32[1] = value;
2817 device_param->kernel_params_memset_buf32[2] = num16d;
2818
2819 uint kernel_threads = device_param->kernel_threads;
2820
2821 uint num_elements = num16d;
2822
2823 while (num_elements % kernel_threads) num_elements++;
2824
2825 cl_kernel kernel = device_param->kernel_memset;
2826
2827 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2828 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2829 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2830
2831 const size_t global_work_size[3] = { num_elements, 1, 1 };
2832 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2833
2834 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2835
2836 hc_clFlush (data.ocl, device_param->command_queue);
2837
2838 hc_clFinish (data.ocl, device_param->command_queue);
2839 }
2840
2841 if (num16m)
2842 {
2843 u32 tmp[4];
2844
2845 tmp[0] = value;
2846 tmp[1] = value;
2847 tmp[2] = value;
2848 tmp[3] = value;
2849
2850 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2851 }
2852 }
2853
2854 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2855 {
2856 run_kernel_memset (device_param, buf, 0, size);
2857
2858 /*
2859 int rc = -1;
2860
2861 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2862 {
2863 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2864
2865 const cl_uchar zero = 0;
2866
2867 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2868 }
2869
2870 if (rc != 0)
2871 {
2872 // NOTE: clEnqueueFillBuffer () always fails with -59
2873 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2874 // How's that possible, OpenCL 1.2 support is advertised??
2875 // We need to workaround...
2876
2877 #define FILLSZ 0x100000
2878
2879 char *tmp = (char *) mymalloc (FILLSZ);
2880
2881 for (size_t i = 0; i < size; i += FILLSZ)
2882 {
2883 const size_t left = size - i;
2884
2885 const size_t fillsz = MIN (FILLSZ, left);
2886
2887 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2888 }
2889
2890 myfree (tmp);
2891 }
2892 */
2893 }
2894
2895 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
2896 {
2897 if (data.hash_mode == 2000)
2898 {
2899 process_stdout (device_param, pws_cnt);
2900
2901 return;
2902 }
2903
2904 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2905 {
2906 if (attack_mode == ATTACK_MODE_BF)
2907 {
2908 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2909 {
2910 const uint size_tm = 32 * sizeof (bs_word_t);
2911
2912 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2913
2914 run_kernel_tm (device_param);
2915
2916 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2917 }
2918 }
2919
2920 if (highest_pw_len < 16)
2921 {
2922 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2923 }
2924 else if (highest_pw_len < 32)
2925 {
2926 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2927 }
2928 else
2929 {
2930 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2931 }
2932 }
2933 else
2934 {
2935 run_kernel_amp (device_param, pws_cnt);
2936
2937 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2938
2939 if (opts_type & OPTS_TYPE_HOOK12)
2940 {
2941 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2942
2943 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2944
2945 // do something with data
2946
2947 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2948 }
2949
2950 uint iter = salt_buf->salt_iter;
2951
2952 uint loop_step = device_param->kernel_loops;
2953
2954 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2955 {
2956 uint loop_left = iter - loop_pos;
2957
2958 loop_left = MIN (loop_left, loop_step);
2959
2960 device_param->kernel_params_buf32[25] = loop_pos;
2961 device_param->kernel_params_buf32[26] = loop_left;
2962
2963 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2964
2965 if (data.devices_status == STATUS_CRACKED) break;
2966 if (data.devices_status == STATUS_ABORTED) break;
2967 if (data.devices_status == STATUS_QUIT) break;
2968
2969 /**
2970 * speed
2971 */
2972
2973 const float iter_part = (float) (loop_pos + loop_left) / iter;
2974
2975 const u64 perf_sum_all = pws_cnt * iter_part;
2976
2977 double speed_ms;
2978
2979 hc_timer_get (device_param->timer_speed, speed_ms);
2980
2981 const u32 speed_pos = device_param->speed_pos;
2982
2983 device_param->speed_cnt[speed_pos] = perf_sum_all;
2984
2985 device_param->speed_ms[speed_pos] = speed_ms;
2986
2987 if (data.benchmark == 1)
2988 {
2989 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2990 }
2991 }
2992
2993 if (opts_type & OPTS_TYPE_HOOK23)
2994 {
2995 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
2996
2997 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2998
2999 // do something with data
3000
3001 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3002 }
3003
3004 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3005 }
3006 }
3007
3008 static int run_rule_engine (const int rule_len, const char *rule_buf)
3009 {
3010 if (rule_len == 0)
3011 {
3012 return 0;
3013 }
3014 else if (rule_len == 1)
3015 {
3016 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3017 }
3018
3019 return 1;
3020 }
3021
3022 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3023 {
3024 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3025 {
3026 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3027 }
3028 else if (data.attack_kern == ATTACK_KERN_COMBI)
3029 {
3030 if (data.attack_mode == ATTACK_MODE_COMBI)
3031 {
3032 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3033 {
3034 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3035 {
3036 for (u32 i = 0; i < pws_cnt; i++)
3037 {
3038 const u32 pw_len = device_param->pws_buf[i].pw_len;
3039
3040 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3041
3042 ptr[pw_len] = 0x01;
3043 }
3044 }
3045 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3046 {
3047 for (u32 i = 0; i < pws_cnt; i++)
3048 {
3049 const u32 pw_len = device_param->pws_buf[i].pw_len;
3050
3051 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3052
3053 ptr[pw_len] = 0x80;
3054 }
3055 }
3056 }
3057 }
3058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3059 {
3060 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3061 {
3062 for (u32 i = 0; i < pws_cnt; i++)
3063 {
3064 const u32 pw_len = device_param->pws_buf[i].pw_len;
3065
3066 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3067
3068 ptr[pw_len] = 0x01;
3069 }
3070 }
3071 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3072 {
3073 for (u32 i = 0; i < pws_cnt; i++)
3074 {
3075 const u32 pw_len = device_param->pws_buf[i].pw_len;
3076
3077 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3078
3079 ptr[pw_len] = 0x80;
3080 }
3081 }
3082 }
3083
3084 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3085 }
3086 else if (data.attack_kern == ATTACK_KERN_BF)
3087 {
3088 const u64 off = device_param->words_off;
3089
3090 device_param->kernel_params_mp_l_buf64[3] = off;
3091
3092 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3093 }
3094 }
3095
3096 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3097 {
3098 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3099
3100 device_param->kernel_params_buf32[25] = 0;
3101 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3102 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3103
3104 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3105 {
3106 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3107 }
3108 else
3109 {
3110 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3111 }
3112
3113 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3114
3115 return exec_ms_prev;
3116 }
3117
3118 static void autotune (hc_device_param_t *device_param)
3119 {
3120 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3121
3122 const u32 kernel_accel_min = device_param->kernel_accel_min;
3123 const u32 kernel_accel_max = device_param->kernel_accel_max;
3124
3125 const u32 kernel_loops_min = device_param->kernel_loops_min;
3126 const u32 kernel_loops_max = device_param->kernel_loops_max;
3127
3128 u32 kernel_accel = kernel_accel_min;
3129 u32 kernel_loops = kernel_loops_min;
3130
3131 // in this case the user specified a fixed -u and -n on the commandline
3132 // no way to tune anything
3133 // but we need to run a few caching rounds
3134
3135 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3136 {
3137 if (data.hash_mode != 2000)
3138 {
3139 try_run (device_param, kernel_accel, kernel_loops);
3140 try_run (device_param, kernel_accel, kernel_loops);
3141 try_run (device_param, kernel_accel, kernel_loops);
3142 try_run (device_param, kernel_accel, kernel_loops);
3143 }
3144
3145 device_param->kernel_accel = kernel_accel;
3146 device_param->kernel_loops = kernel_loops;
3147
3148 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3149
3150 device_param->kernel_power = kernel_power;
3151
3152 return;
3153 }
3154
3155 // from here it's clear we are allowed to autotune
3156 // so let's init some fake words
3157
3158 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3159
3160 if (data.attack_kern == ATTACK_KERN_BF)
3161 {
3162 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3163 }
3164 else
3165 {
3166 for (u32 i = 0; i < kernel_power_max; i++)
3167 {
3168 device_param->pws_buf[i].i[0] = i;
3169 device_param->pws_buf[i].i[1] = 0x01234567;
3170 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3171 }
3172
3173 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3174 }
3175
3176 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3177 {
3178 if (data.kernel_rules_cnt > 1)
3179 {
3180 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3181 }
3182 }
3183 else
3184 {
3185 run_kernel_amp (device_param, kernel_power_max);
3186 }
3187
3188 #define VERIFIER_CNT 1
3189
3190 // first find out highest kernel-loops that stays below target_ms
3191
3192 if (kernel_loops_min < kernel_loops_max)
3193 {
3194 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3195 {
3196 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3197
3198 for (int i = 0; i < VERIFIER_CNT; i++)
3199 {
3200 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3201
3202 exec_ms = MIN (exec_ms, exec_ms_v);
3203 }
3204
3205 if (exec_ms < target_ms) break;
3206 }
3207 }
3208
3209 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3210
3211 #define STEPS_CNT 10
3212
3213 if (kernel_accel_min < kernel_accel_max)
3214 {
3215 for (int i = 0; i < STEPS_CNT; i++)
3216 {
3217 const u32 kernel_accel_try = 1 << i;
3218
3219 if (kernel_accel_try < kernel_accel_min) continue;
3220 if (kernel_accel_try > kernel_accel_max) break;
3221
3222 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3223
3224 for (int i = 0; i < VERIFIER_CNT; i++)
3225 {
3226 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3227
3228 exec_ms = MIN (exec_ms, exec_ms_v);
3229 }
3230
3231 if (exec_ms > target_ms) break;
3232
3233 kernel_accel = kernel_accel_try;
3234 }
3235 }
3236
3237 // at this point we want to know the actual runtime for the following reason:
3238 // we need a reference for the balancing loop following up, and this
3239 // the balancing loop can have an effect that the creates a new opportunity, for example:
3240 // if the target is 95 ms and the current runtime is 48ms the above loop
3241 // stopped the execution because the previous exec_ms was > 95ms
3242 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3243 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3244
3245 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3246
3247 for (int i = 0; i < VERIFIER_CNT; i++)
3248 {
3249 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3250
3251 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3252 }
3253
3254 u32 diff = kernel_loops - kernel_accel;
3255
3256 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3257 {
3258 u32 kernel_accel_orig = kernel_accel;
3259 u32 kernel_loops_orig = kernel_loops;
3260
3261 for (u32 f = 1; f < 1024; f++)
3262 {
3263 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3264 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3265
3266 if (kernel_accel_try > kernel_accel_max) break;
3267 if (kernel_loops_try < kernel_loops_min) break;
3268
3269 u32 diff_new = kernel_loops_try - kernel_accel_try;
3270
3271 if (diff_new > diff) break;
3272
3273 diff_new = diff;
3274
3275 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3276
3277 for (int i = 0; i < VERIFIER_CNT; i++)
3278 {
3279 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3280
3281 exec_ms = MIN (exec_ms, exec_ms_v);
3282 }
3283
3284 if (exec_ms < exec_ms_pre_final)
3285 {
3286 exec_ms_pre_final = exec_ms;
3287
3288 kernel_accel = kernel_accel_try;
3289 kernel_loops = kernel_loops_try;
3290 }
3291 }
3292 }
3293
3294 const double exec_left = target_ms / exec_ms_pre_final;
3295
3296 const double accel_left = kernel_accel_max / kernel_accel;
3297
3298 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3299
3300 if (exec_accel_min >= 1.0)
3301 {
3302 // this is safe to not overflow kernel_accel_max because of accel_left
3303
3304 kernel_accel = (double) kernel_accel * exec_accel_min;
3305 }
3306
3307 // reset them fake words
3308
3309 /*
3310 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3311
3312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3313 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3314 */
3315
3316 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3317
3318 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3319 {
3320 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3321 }
3322
3323 // reset timer
3324
3325 device_param->exec_pos = 0;
3326
3327 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3328
3329 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3330 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3331 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3332
3333 // store
3334
3335 device_param->kernel_accel = kernel_accel;
3336 device_param->kernel_loops = kernel_loops;
3337
3338 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3339
3340 device_param->kernel_power = kernel_power;
3341
3342 #ifdef DEBUG
3343
3344 if (data.quiet == 0)
3345 {
3346 clear_prompt ();
3347
3348 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3349 "Device #%u: autotuned kernel-loops to %u\n",
3350 device_param->device_id + 1, kernel_accel,
3351 device_param->device_id + 1, kernel_loops);
3352
3353 fprintf (stdout, "%s", PROMPT);
3354
3355 fflush (stdout);
3356 }
3357
3358 #endif
3359 }
3360
3361 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3362 {
3363 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3364
3365 // init speed timer
3366
3367 uint speed_pos = device_param->speed_pos;
3368
3369 #ifdef _POSIX
3370 if (device_param->timer_speed.tv_sec == 0)
3371 {
3372 hc_timer_set (&device_param->timer_speed);
3373 }
3374 #endif
3375
3376 #ifdef _WIN
3377 if (device_param->timer_speed.QuadPart == 0)
3378 {
3379 hc_timer_set (&device_param->timer_speed);
3380 }
3381 #endif
3382
3383 // find higest password length, this is for optimization stuff
3384
3385 uint highest_pw_len = 0;
3386
3387 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3388 {
3389 }
3390 else if (data.attack_kern == ATTACK_KERN_COMBI)
3391 {
3392 }
3393 else if (data.attack_kern == ATTACK_KERN_BF)
3394 {
3395 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3396 + device_param->kernel_params_mp_l_buf32[5];
3397 }
3398
3399 // iteration type
3400
3401 uint innerloop_step = 0;
3402 uint innerloop_cnt = 0;
3403
3404 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3405 else innerloop_step = 1;
3406
3407 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3408 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3409 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3410
3411 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3412
3413 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3414 {
3415 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3416
3417 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3418
3419 if (data.devices_status == STATUS_CRACKED) break;
3420 if (data.devices_status == STATUS_ABORTED) break;
3421 if (data.devices_status == STATUS_QUIT) break;
3422 if (data.devices_status == STATUS_BYPASS) break;
3423
3424 salt_t *salt_buf = &data.salts_buf[salt_pos];
3425
3426 device_param->kernel_params_buf32[24] = salt_pos;
3427 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3428 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3429
3430 FILE *combs_fp = device_param->combs_fp;
3431
3432 if (data.attack_mode == ATTACK_MODE_COMBI)
3433 {
3434 rewind (combs_fp);
3435 }
3436
3437 // innerloops
3438
3439 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3440 {
3441 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3442
3443 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3444
3445 if (data.devices_status == STATUS_CRACKED) break;
3446 if (data.devices_status == STATUS_ABORTED) break;
3447 if (data.devices_status == STATUS_QUIT) break;
3448 if (data.devices_status == STATUS_BYPASS) break;
3449
3450 uint fast_iteration = 0;
3451
3452 uint innerloop_left = innerloop_cnt - innerloop_pos;
3453
3454 if (innerloop_left > innerloop_step)
3455 {
3456 innerloop_left = innerloop_step;
3457
3458 fast_iteration = 1;
3459 }
3460
3461 device_param->innerloop_pos = innerloop_pos;
3462 device_param->innerloop_left = innerloop_left;
3463
3464 device_param->kernel_params_buf32[27] = innerloop_left;
3465
3466 // i think we can get rid of this
3467 if (innerloop_left == 0)
3468 {
3469 puts ("bug, how should this happen????\n");
3470
3471 continue;
3472 }
3473
3474 if (data.salts_shown[salt_pos] == 1)
3475 {
3476 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3477
3478 continue;
3479 }
3480
3481 // initialize amplifiers
3482
3483 if (data.attack_mode == ATTACK_MODE_COMBI)
3484 {
3485 uint i = 0;
3486
3487 while (i < innerloop_left)
3488 {
3489 if (feof (combs_fp)) break;
3490
3491 int line_len = fgetl (combs_fp, line_buf);
3492
3493 if (line_len >= PW_MAX1) continue;
3494
3495 line_len = convert_from_hex (line_buf, line_len);
3496
3497 char *line_buf_new = line_buf;
3498
3499 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3500 {
3501 char rule_buf_out[BLOCK_SIZE] = { 0 };
3502
3503 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3504
3505 if (rule_len_out < 0)
3506 {
3507 data.words_progress_rejected[salt_pos] += pws_cnt;
3508
3509 continue;
3510 }
3511
3512 line_len = rule_len_out;
3513
3514 line_buf_new = rule_buf_out;
3515 }
3516
3517 line_len = MIN (line_len, PW_DICTMAX);
3518
3519 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3520
3521 memcpy (ptr, line_buf_new, line_len);
3522
3523 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3524
3525 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3526 {
3527 uppercase (ptr, line_len);
3528 }
3529
3530 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3531 {
3532 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3533 {
3534 ptr[line_len] = 0x80;
3535 }
3536
3537 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3538 {
3539 ptr[line_len] = 0x01;
3540 }
3541 }
3542
3543 device_param->combs_buf[i].pw_len = line_len;
3544
3545 i++;
3546 }
3547
3548 for (uint j = i; j < innerloop_left; j++)
3549 {
3550 device_param->combs_buf[j].i[0] = 0;
3551 device_param->combs_buf[j].i[1] = 0;
3552 device_param->combs_buf[j].i[2] = 0;
3553 device_param->combs_buf[j].i[3] = 0;
3554 device_param->combs_buf[j].i[4] = 0;
3555 device_param->combs_buf[j].i[5] = 0;
3556 device_param->combs_buf[j].i[6] = 0;
3557 device_param->combs_buf[j].i[7] = 0;
3558
3559 device_param->combs_buf[j].pw_len = 0;
3560 }
3561
3562 innerloop_left = i;
3563 }
3564 else if (data.attack_mode == ATTACK_MODE_BF)
3565 {
3566 u64 off = innerloop_pos;
3567
3568 device_param->kernel_params_mp_r_buf64[3] = off;
3569
3570 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3571 }
3572 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3573 {
3574 u64 off = innerloop_pos;
3575
3576 device_param->kernel_params_mp_buf64[3] = off;
3577
3578 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3579 }
3580 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3581 {
3582 u64 off = innerloop_pos;
3583
3584 device_param->kernel_params_mp_buf64[3] = off;
3585
3586 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3587 }
3588
3589 // copy amplifiers
3590
3591 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3592 {
3593 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3594 }
3595 else if (data.attack_mode == ATTACK_MODE_COMBI)
3596 {
3597 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3598 }
3599 else if (data.attack_mode == ATTACK_MODE_BF)
3600 {
3601 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3602 }
3603 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3604 {
3605 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3606 }
3607 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3608 {
3609 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3610 }
3611
3612 if (data.benchmark == 1)
3613 {
3614 hc_timer_set (&device_param->timer_speed);
3615 }
3616
3617 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3618
3619 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3620
3621 if (data.devices_status == STATUS_CRACKED) break;
3622 if (data.devices_status == STATUS_ABORTED) break;
3623 if (data.devices_status == STATUS_QUIT) break;
3624
3625 /**
3626 * result
3627 */
3628
3629 if (data.benchmark == 0)
3630 {
3631 check_cracked (device_param, salt_pos);
3632 }
3633
3634 /**
3635 * progress
3636 */
3637
3638 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3639
3640 hc_thread_mutex_lock (mux_counter);
3641
3642 data.words_progress_done[salt_pos] += perf_sum_all;
3643
3644 hc_thread_mutex_unlock (mux_counter);
3645
3646 /**
3647 * speed
3648 */
3649
3650 double speed_ms;
3651
3652 hc_timer_get (device_param->timer_speed, speed_ms);
3653
3654 hc_timer_set (&device_param->timer_speed);
3655
3656 // current speed
3657
3658 //hc_thread_mutex_lock (mux_display);
3659
3660 device_param->speed_cnt[speed_pos] = perf_sum_all;
3661
3662 device_param->speed_ms[speed_pos] = speed_ms;
3663
3664 //hc_thread_mutex_unlock (mux_display);
3665
3666 speed_pos++;
3667
3668 if (speed_pos == SPEED_CACHE)
3669 {
3670 speed_pos = 0;
3671 }
3672
3673 /**
3674 * benchmark
3675 */
3676
3677 if (data.benchmark == 1) break;
3678 }
3679 }
3680
3681 device_param->speed_pos = speed_pos;
3682
3683 myfree (line_buf);
3684 }
3685
3686 static void load_segment (wl_data_t *wl_data, FILE *fd)
3687 {
3688 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3689
3690 wl_data->pos = 0;
3691
3692 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3693
3694 wl_data->buf[wl_data->cnt] = 0;
3695
3696 if (wl_data->cnt == 0) return;
3697
3698 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3699
3700 while (!feof (fd))
3701 {
3702 if (wl_data->cnt == wl_data->avail)
3703 {
3704 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3705
3706 wl_data->avail += wl_data->incr;
3707 }
3708
3709 const int c = fgetc (fd);
3710
3711 if (c == EOF) break;
3712
3713 wl_data->buf[wl_data->cnt] = (char) c;
3714
3715 wl_data->cnt++;
3716
3717 if (c == '\n') break;
3718 }
3719
3720 // ensure stream ends with a newline
3721
3722 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3723 {
3724 wl_data->cnt++;
3725
3726 wl_data->buf[wl_data->cnt - 1] = '\n';
3727 }
3728
3729 return;
3730 }
3731
3732 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3733 {
3734 char *ptr = buf;
3735
3736 for (u32 i = 0; i < sz; i++, ptr++)
3737 {
3738 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3739
3740 if (i == 7)
3741 {
3742 *off = i;
3743 *len = i;
3744
3745 return;
3746 }
3747
3748 if (*ptr != '\n') continue;
3749
3750 *off = i + 1;
3751
3752 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3753
3754 *len = i;
3755
3756 return;
3757 }
3758
3759 *off = sz;
3760 *len = sz;
3761 }
3762
3763 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3764 {
3765 char *ptr = buf;
3766
3767 for (u32 i = 0; i < sz; i++, ptr++)
3768 {
3769 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3770
3771 if (*ptr != '\n') continue;
3772
3773 *off = i + 1;
3774
3775 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3776
3777 *len = i;
3778
3779 return;
3780 }
3781
3782 *off = sz;
3783 *len = sz;
3784 }
3785
3786 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3787 {
3788 char *ptr = buf;
3789
3790 for (u32 i = 0; i < sz; i++, ptr++)
3791 {
3792 if (*ptr != '\n') continue;
3793
3794 *off = i + 1;
3795
3796 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3797
3798 *len = i;
3799
3800 return;
3801 }
3802
3803 *off = sz;
3804 *len = sz;
3805 }
3806
3807 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3808 {
3809 while (wl_data->pos < wl_data->cnt)
3810 {
3811 uint off;
3812 uint len;
3813
3814 char *ptr = wl_data->buf + wl_data->pos;
3815
3816 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3817
3818 wl_data->pos += off;
3819
3820 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3821 {
3822 char rule_buf_out[BLOCK_SIZE] = { 0 };
3823
3824 int rule_len_out = -1;
3825
3826 if (len < BLOCK_SIZE)
3827 {
3828 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3829 }
3830
3831 if (rule_len_out < 0)
3832 {
3833 continue;
3834 }
3835
3836 if (rule_len_out > PW_MAX)
3837 {
3838 continue;
3839 }
3840 }
3841 else
3842 {
3843 if (len > PW_MAX)
3844 {
3845 continue;
3846 }
3847 }
3848
3849 *out_buf = ptr;
3850 *out_len = len;
3851
3852 return;
3853 }
3854
3855 if (feof (fd))
3856 {
3857 fprintf (stderr, "BUG feof()!!\n");
3858
3859 return;
3860 }
3861
3862 load_segment (wl_data, fd);
3863
3864 get_next_word (wl_data, fd, out_buf, out_len);
3865 }
3866
3867 #ifdef _POSIX
3868 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3869 #endif
3870
3871 #ifdef _WIN
3872 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3873 #endif
3874 {
3875 hc_signal (NULL);
3876
3877 dictstat_t d;
3878
3879 d.cnt = 0;
3880
3881 #ifdef _POSIX
3882 fstat (fileno (fd), &d.stat);
3883 #endif
3884
3885 #ifdef _WIN
3886 _fstat64 (fileno (fd), &d.stat);
3887 #endif
3888
3889 d.stat.st_mode = 0;
3890 d.stat.st_nlink = 0;
3891 d.stat.st_uid = 0;
3892 d.stat.st_gid = 0;
3893 d.stat.st_rdev = 0;
3894 d.stat.st_atime = 0;
3895
3896 #ifdef _POSIX
3897 d.stat.st_blksize = 0;
3898 d.stat.st_blocks = 0;
3899 #endif
3900
3901 if (d.stat.st_size == 0) return 0;
3902
3903 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3904
3905 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3906 {
3907 if (d_cache)
3908 {
3909 u64 cnt = d_cache->cnt;
3910
3911 u64 keyspace = cnt;
3912
3913 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3914 {
3915 keyspace *= data.kernel_rules_cnt;
3916 }
3917 else if (data.attack_kern == ATTACK_KERN_COMBI)
3918 {
3919 keyspace *= data.combs_cnt;
3920 }
3921
3922 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3923 if (data.quiet == 0) log_info ("");
3924
3925 hc_signal (sigHandler_default);
3926
3927 return (keyspace);
3928 }
3929 }
3930
3931 time_t now = 0;
3932 time_t prev = 0;
3933
3934 u64 comp = 0;
3935 u64 cnt = 0;
3936 u64 cnt2 = 0;
3937
3938 while (!feof (fd))
3939 {
3940 load_segment (wl_data, fd);
3941
3942 comp += wl_data->cnt;
3943
3944 u32 i = 0;
3945
3946 while (i < wl_data->cnt)
3947 {
3948 u32 len;
3949 u32 off;
3950
3951 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3952
3953 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3954 {
3955 char rule_buf_out[BLOCK_SIZE] = { 0 };
3956
3957 int rule_len_out = -1;
3958
3959 if (len < BLOCK_SIZE)
3960 {
3961 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3962 }
3963
3964 if (rule_len_out < 0)
3965 {
3966 len = PW_MAX1;
3967 }
3968 else
3969 {
3970 len = rule_len_out;
3971 }
3972 }
3973
3974 if (len < PW_MAX1)
3975 {
3976 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3977 {
3978 cnt += data.kernel_rules_cnt;
3979 }
3980 else if (data.attack_kern == ATTACK_KERN_COMBI)
3981 {
3982 cnt += data.combs_cnt;
3983 }
3984
3985 d.cnt++;
3986 }
3987
3988 i += off;
3989
3990 cnt2++;
3991 }
3992
3993 time (&now);
3994
3995 if ((now - prev) == 0) continue;
3996
3997 float percent = (float) comp / (float) d.stat.st_size;
3998
3999 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4000
4001 time (&prev);
4002 }
4003
4004 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4005 if (data.quiet == 0) log_info ("");
4006
4007 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4008
4009 hc_signal (sigHandler_default);
4010
4011 return (cnt);
4012 }
4013
4014 static void *thread_monitor (void *p)
4015 {
4016 uint runtime_check = 0;
4017 uint remove_check = 0;
4018 uint status_check = 0;
4019 uint restore_check = 0;
4020
4021 uint restore_left = data.restore_timer;
4022 uint remove_left = data.remove_timer;
4023 uint status_left = data.status_timer;
4024
4025 #ifdef HAVE_HWMON
4026 uint hwmon_check = 0;
4027
4028 int slowdown_warnings = 0;
4029
4030 // these variables are mainly used for fan control
4031
4032 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4033
4034 // temperature controller "loopback" values
4035
4036 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4037 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4038
4039 int temp_threshold = 1; // degrees celcius
4040
4041 int fan_speed_min = 15; // in percentage
4042 int fan_speed_max = 100;
4043
4044 time_t last_temp_check_time;
4045 #endif // HAVE_HWMON
4046
4047 uint sleep_time = 1;
4048
4049 if (data.runtime)
4050 {
4051 runtime_check = 1;
4052 }
4053
4054 if (data.restore_timer)
4055 {
4056 restore_check = 1;
4057 }
4058
4059 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4060 {
4061 remove_check = 1;
4062 }
4063
4064 if (data.status == 1)
4065 {
4066 status_check = 1;
4067 }
4068
4069 #ifdef HAVE_HWMON
4070 if (data.gpu_temp_disable == 0)
4071 {
4072 time (&last_temp_check_time);
4073
4074 hwmon_check = 1;
4075 }
4076 #endif
4077
4078 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4079 {
4080 #ifdef HAVE_HWMON
4081 if (hwmon_check == 0)
4082 #endif
4083 return (p);
4084 }
4085
4086 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4087 {
4088 hc_sleep (sleep_time);
4089
4090 if (data.devices_status != STATUS_RUNNING) continue;
4091
4092 #ifdef HAVE_HWMON
4093
4094 if (hwmon_check == 1)
4095 {
4096 hc_thread_mutex_lock (mux_adl);
4097
4098 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4099 {
4100 hc_device_param_t *device_param = &data.devices_param[device_id];
4101
4102 if (device_param->skipped) continue;
4103
4104 if (device_param->device_vendor_id == VENDOR_ID_NV)
4105 {
4106 if (data.hm_nvapi)
4107 {
4108 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4109 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4110
4111 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4112 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4113
4114 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4115
4116 perfPolicies_status.info_value = perfPolicies_info.info_value;
4117
4118 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4119
4120 if (perfPolicies_status.throttle & 2)
4121 {
4122 if (slowdown_warnings < 3)
4123 {
4124 if (data.quiet == 0) clear_prompt ();
4125
4126 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4127
4128 if (slowdown_warnings == 2)
4129 {
4130 log_info ("");
4131 }
4132
4133 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4134 if (data.quiet == 0) fflush (stdout);
4135
4136 slowdown_warnings++;
4137 }
4138 }
4139 else
4140 {
4141 slowdown_warnings = 0;
4142 }
4143 }
4144 }
4145 }
4146
4147 hc_thread_mutex_unlock (mux_adl);
4148 }
4149
4150 if (hwmon_check == 1)
4151 {
4152 hc_thread_mutex_lock (mux_adl);
4153
4154 time_t temp_check_time;
4155
4156 time (&temp_check_time);
4157
4158 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4159
4160 if (Ta == 0) Ta = 1;
4161
4162 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4163 {
4164 hc_device_param_t *device_param = &data.devices_param[device_id];
4165
4166 if (device_param->skipped) continue;
4167
4168 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4169
4170 const int temperature = hm_get_temperature_with_device_id (device_id);
4171
4172 if (temperature > (int) data.gpu_temp_abort)
4173 {
4174 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4175
4176 if (data.devices_status != STATUS_QUIT) myabort ();
4177
4178 break;
4179 }
4180
4181 const int gpu_temp_retain = data.gpu_temp_retain;
4182
4183 if (gpu_temp_retain)
4184 {
4185 if (data.hm_device[device_id].fan_set_supported == 1)
4186 {
4187 int temp_cur = temperature;
4188
4189 int temp_diff_new = gpu_temp_retain - temp_cur;
4190
4191 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4192
4193 // calculate Ta value (time difference in seconds between the last check and this check)
4194
4195 last_temp_check_time = temp_check_time;
4196
4197 float Kp = 1.8;
4198 float Ki = 0.005;
4199 float Kd = 6;
4200
4201 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4202
4203 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
4204
4205 if (abs (fan_diff_required) >= temp_threshold)
4206 {
4207 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4208
4209 int fan_speed_level = fan_speed_cur;
4210
4211 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4212
4213 int fan_speed_new = fan_speed_level - fan_diff_required;
4214
4215 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4216 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4217
4218 if (fan_speed_new != fan_speed_cur)
4219 {
4220 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4221 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4222
4223 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4224 {
4225 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4226 {
4227 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4228 }
4229 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4230 {
4231
4232 }
4233
4234 fan_speed_chgd[device_id] = 1;
4235 }
4236
4237 temp_diff_old[device_id] = temp_diff_new;
4238 }
4239 }
4240 }
4241 }
4242 }
4243
4244 hc_thread_mutex_unlock (mux_adl);
4245 }
4246 #endif // HAVE_HWMON
4247
4248 if (restore_check == 1)
4249 {
4250 restore_left--;
4251
4252 if (restore_left == 0)
4253 {
4254 if (data.restore_disable == 0) cycle_restore ();
4255
4256 restore_left = data.restore_timer;
4257 }
4258 }
4259
4260 if ((runtime_check == 1) && (data.runtime_start > 0))
4261 {
4262 time_t runtime_cur;
4263
4264 time (&runtime_cur);
4265
4266 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4267
4268 if (runtime_left <= 0)
4269 {
4270 if (data.benchmark == 0)
4271 {
4272 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4273 }
4274
4275 if (data.devices_status != STATUS_QUIT) myabort ();
4276 }
4277 }
4278
4279 if (remove_check == 1)
4280 {
4281 remove_left--;
4282
4283 if (remove_left == 0)
4284 {
4285 if (data.digests_saved != data.digests_done)
4286 {
4287 data.digests_saved = data.digests_done;
4288
4289 save_hash ();
4290 }
4291
4292 remove_left = data.remove_timer;
4293 }
4294 }
4295
4296 if (status_check == 1)
4297 {
4298 status_left--;
4299
4300 if (status_left == 0)
4301 {
4302 //hc_thread_mutex_lock (mux_display);
4303
4304 if (data.quiet == 0) clear_prompt ();
4305
4306 if (data.quiet == 0) log_info ("");
4307
4308 status_display ();
4309
4310 if (data.quiet == 0) log_info ("");
4311
4312 //hc_thread_mutex_unlock (mux_display);
4313
4314 status_left = data.status_timer;
4315 }
4316 }
4317 }
4318
4319 #ifdef HAVE_HWMON
4320 myfree (fan_speed_chgd);
4321
4322 myfree (temp_diff_old);
4323 myfree (temp_diff_sum);
4324 #endif
4325
4326 p = NULL;
4327
4328 return (p);
4329 }
4330
4331 static void *thread_outfile_remove (void *p)
4332 {
4333 // some hash-dependent constants
4334 char *outfile_dir = data.outfile_check_directory;
4335 uint dgst_size = data.dgst_size;
4336 uint isSalted = data.isSalted;
4337 uint esalt_size = data.esalt_size;
4338 uint hash_mode = data.hash_mode;
4339
4340 uint outfile_check_timer = data.outfile_check_timer;
4341
4342 char separator = data.separator;
4343
4344 // some hash-dependent functions
4345 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4346 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4347
4348 // buffers
4349 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4350
4351 hash_buf.digest = mymalloc (dgst_size);
4352
4353 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4354
4355 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4356
4357 uint digest_buf[64] = { 0 };
4358
4359 outfile_data_t *out_info = NULL;
4360
4361 char **out_files = NULL;
4362
4363 time_t folder_mtime = 0;
4364
4365 int out_cnt = 0;
4366
4367 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4368
4369 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4370 {
4371 hc_sleep (1);
4372
4373 if (data.devices_status != STATUS_RUNNING) continue;
4374
4375 check_left--;
4376
4377 if (check_left == 0)
4378 {
4379 struct stat outfile_check_stat;
4380
4381 if (stat (outfile_dir, &outfile_check_stat) == 0)
4382 {
4383 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4384
4385 if (is_dir == 1)
4386 {
4387 if (outfile_check_stat.st_mtime > folder_mtime)
4388 {
4389 char **out_files_new = scan_directory (outfile_dir);
4390
4391 int out_cnt_new = count_dictionaries (out_files_new);
4392
4393 outfile_data_t *out_info_new = NULL;
4394
4395 if (out_cnt_new > 0)
4396 {
4397 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4398
4399 for (int i = 0; i < out_cnt_new; i++)
4400 {
4401 out_info_new[i].file_name = out_files_new[i];
4402
4403 // check if there are files that we have seen/checked before (and not changed)
4404
4405 for (int j = 0; j < out_cnt; j++)
4406 {
4407 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4408 {
4409 struct stat outfile_stat;
4410
4411 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4412 {
4413 if (outfile_stat.st_ctime == out_info[j].ctime)
4414 {
4415 out_info_new[i].ctime = out_info[j].ctime;
4416 out_info_new[i].seek = out_info[j].seek;
4417 }
4418 }
4419 }
4420 }
4421 }
4422 }
4423
4424 local_free (out_info);
4425 local_free (out_files);
4426
4427 out_files = out_files_new;
4428 out_cnt = out_cnt_new;
4429 out_info = out_info_new;
4430
4431 folder_mtime = outfile_check_stat.st_mtime;
4432 }
4433
4434 for (int j = 0; j < out_cnt; j++)
4435 {
4436 FILE *fp = fopen (out_info[j].file_name, "rb");
4437
4438 if (fp != NULL)
4439 {
4440 //hc_thread_mutex_lock (mux_display);
4441
4442 #ifdef _POSIX
4443 struct stat outfile_stat;
4444
4445 fstat (fileno (fp), &outfile_stat);
4446 #endif
4447
4448 #ifdef _WIN
4449 struct stat64 outfile_stat;
4450
4451 _fstat64 (fileno (fp), &outfile_stat);
4452 #endif
4453
4454 if (outfile_stat.st_ctime > out_info[j].ctime)
4455 {
4456 out_info[j].ctime = outfile_stat.st_ctime;
4457 out_info[j].seek = 0;
4458 }
4459
4460 fseek (fp, out_info[j].seek, SEEK_SET);
4461
4462 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4463
4464 while (!feof (fp))
4465 {
4466 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4467
4468 if (ptr == NULL) break;
4469
4470 int line_len = strlen (line_buf);
4471
4472 if (line_len <= 0) continue;
4473
4474 int iter = MAX_CUT_TRIES;
4475
4476 for (uint i = line_len - 1; i && iter; i--, line_len--)
4477 {
4478 if (line_buf[i] != separator) continue;
4479
4480 int parser_status = PARSER_OK;
4481
4482 if ((hash_mode != 2500) && (hash_mode != 6800))
4483 {
4484 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4485 }
4486
4487 uint found = 0;
4488
4489 if (parser_status == PARSER_OK)
4490 {
4491 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4492 {
4493 if (data.salts_shown[salt_pos] == 1) continue;
4494
4495 salt_t *salt_buf = &data.salts_buf[salt_pos];
4496
4497 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4498 {
4499 uint idx = salt_buf->digests_offset + digest_pos;
4500
4501 if (data.digests_shown[idx] == 1) continue;
4502
4503 uint cracked = 0;
4504
4505 if (hash_mode == 6800)
4506 {
4507 if (i == salt_buf->salt_len)
4508 {
4509 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4510 }
4511 }
4512 else if (hash_mode == 2500)
4513 {
4514 // BSSID : MAC1 : MAC2 (:plain)
4515 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4516 {
4517 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4518
4519 if (!cracked) continue;
4520
4521 // now compare MAC1 and MAC2 too, since we have this additional info
4522 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4523 char *mac2_pos = mac1_pos + 12 + 1;
4524
4525 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4526 wpa_t *wpa = &wpas[salt_pos];
4527
4528 // compare hex string(s) vs binary MAC address(es)
4529
4530 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4531 {
4532 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4533 {
4534 cracked = 0;
4535
4536 break;
4537 }
4538 }
4539
4540 // early skip ;)
4541 if (!cracked) continue;
4542
4543 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4544 {
4545 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4546 {
4547 cracked = 0;
4548
4549 break;
4550 }
4551 }
4552 }
4553 }
4554 else
4555 {
4556 char *digests_buf_ptr = (char *) data.digests_buf;
4557
4558 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4559
4560 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4561 }
4562
4563 if (cracked == 1)
4564 {
4565 found = 1;
4566
4567 data.digests_shown[idx] = 1;
4568
4569 data.digests_done++;
4570
4571 salt_buf->digests_done++;
4572
4573 if (salt_buf->digests_done == salt_buf->digests_cnt)
4574 {
4575 data.salts_shown[salt_pos] = 1;
4576
4577 data.salts_done++;
4578
4579 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4580 }
4581 }
4582 }
4583
4584 if (data.devices_status == STATUS_CRACKED) break;
4585 }
4586 }
4587
4588 if (found) break;
4589
4590 if (data.devices_status == STATUS_CRACKED) break;
4591
4592 iter--;
4593 }
4594
4595 if (data.devices_status == STATUS_CRACKED) break;
4596 }
4597
4598 myfree (line_buf);
4599
4600 out_info[j].seek = ftell (fp);
4601
4602 //hc_thread_mutex_unlock (mux_display);
4603
4604 fclose (fp);
4605 }
4606 }
4607 }
4608 }
4609
4610 check_left = outfile_check_timer;
4611 }
4612 }
4613
4614 if (esalt_size) local_free (hash_buf.esalt);
4615
4616 if (isSalted) local_free (hash_buf.salt);
4617
4618 local_free (hash_buf.digest);
4619
4620 local_free (out_info);
4621
4622 local_free (out_files);
4623
4624 p = NULL;
4625
4626 return (p);
4627 }
4628
4629 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4630 {
4631 //if (device_param->pws_cnt < device_param->kernel_power)
4632 //{
4633 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4634
4635 u8 *ptr = (u8 *) pw->i;
4636
4637 memcpy (ptr, pw_buf, pw_len);
4638
4639 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4640
4641 pw->pw_len = pw_len;
4642
4643 device_param->pws_cnt++;
4644 //}
4645 //else
4646 //{
4647 // fprintf (stderr, "BUG pw_add()!!\n");
4648 //
4649 // return;
4650 //}
4651 }
4652
4653 static void set_kernel_power_final (const u64 kernel_power_final)
4654 {
4655 if (data.quiet == 0)
4656 {
4657 clear_prompt ();
4658
4659 //log_info ("");
4660
4661 log_info ("INFO: approaching final keyspace, workload adjusted");
4662 log_info ("");
4663
4664 fprintf (stdout, "%s", PROMPT);
4665
4666 fflush (stdout);
4667 }
4668
4669 data.kernel_power_final = kernel_power_final;
4670 }
4671
4672 static u32 get_power (hc_device_param_t *device_param)
4673 {
4674 const u64 kernel_power_final = data.kernel_power_final;
4675
4676 if (kernel_power_final)
4677 {
4678 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4679
4680 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4681
4682 // work should be at least the hardware power available without any accelerator
4683
4684 const u64 work = MAX (words_left_device, device_param->hardware_power);
4685
4686 return work;
4687 }
4688
4689 return device_param->kernel_power;
4690 }
4691
4692 static uint get_work (hc_device_param_t *device_param, const u64 max)
4693 {
4694 hc_thread_mutex_lock (mux_dispatcher);
4695
4696 const u64 words_cur = data.words_cur;
4697 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4698
4699 device_param->words_off = words_cur;
4700
4701 const u64 kernel_power_all = data.kernel_power_all;
4702
4703 const u64 words_left = words_base - words_cur;
4704
4705 if (words_left < kernel_power_all)
4706 {
4707 if (data.kernel_power_final == 0)
4708 {
4709 set_kernel_power_final (words_left);
4710 }
4711 }
4712
4713 const u32 kernel_power = get_power (device_param);
4714
4715 uint work = MIN (words_left, kernel_power);
4716
4717 work = MIN (work, max);
4718
4719 data.words_cur += work;
4720
4721 hc_thread_mutex_unlock (mux_dispatcher);
4722
4723 return work;
4724 }
4725
4726 static void *thread_autotune (void *p)
4727 {
4728 hc_device_param_t *device_param = (hc_device_param_t *) p;
4729
4730 if (device_param->skipped) return NULL;
4731
4732 autotune (device_param);
4733
4734 return NULL;
4735 }
4736
4737 static void *thread_calc_stdin (void *p)
4738 {
4739 hc_device_param_t *device_param = (hc_device_param_t *) p;
4740
4741 if (device_param->skipped) return NULL;
4742
4743 char *buf = (char *) mymalloc (HCBUFSIZ);
4744
4745 const uint attack_kern = data.attack_kern;
4746
4747 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4748 {
4749 hc_thread_mutex_lock (mux_dispatcher);
4750
4751 if (feof (stdin) != 0)
4752 {
4753 hc_thread_mutex_unlock (mux_dispatcher);
4754
4755 break;
4756 }
4757
4758 uint words_cur = 0;
4759
4760 while (words_cur < device_param->kernel_power)
4761 {
4762 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4763
4764 if (line_buf == NULL) break;
4765
4766 uint line_len = in_superchop (line_buf);
4767
4768 line_len = convert_from_hex (line_buf, line_len);
4769
4770 // post-process rule engine
4771
4772 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4773 {
4774 char rule_buf_out[BLOCK_SIZE] = { 0 };
4775
4776 int rule_len_out = -1;
4777
4778 if (line_len < BLOCK_SIZE)
4779 {
4780 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4781 }
4782
4783 if (rule_len_out < 0) continue;
4784
4785 line_buf = rule_buf_out;
4786 line_len = rule_len_out;
4787 }
4788
4789 if (line_len > PW_MAX)
4790 {
4791 continue;
4792 }
4793
4794 // hmm that's always the case, or?
4795
4796 if (attack_kern == ATTACK_KERN_STRAIGHT)
4797 {
4798 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4799 {
4800 hc_thread_mutex_lock (mux_counter);
4801
4802 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4803 {
4804 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4805 }
4806
4807 hc_thread_mutex_unlock (mux_counter);
4808
4809 continue;
4810 }
4811 }
4812
4813 pw_add (device_param, (u8 *) line_buf, line_len);
4814
4815 words_cur++;
4816
4817 if (data.devices_status == STATUS_CRACKED) break;
4818 if (data.devices_status == STATUS_ABORTED) break;
4819 if (data.devices_status == STATUS_QUIT) break;
4820 if (data.devices_status == STATUS_BYPASS) break;
4821 }
4822
4823 hc_thread_mutex_unlock (mux_dispatcher);
4824
4825 if (data.devices_status == STATUS_CRACKED) break;
4826 if (data.devices_status == STATUS_ABORTED) break;
4827 if (data.devices_status == STATUS_QUIT) break;
4828 if (data.devices_status == STATUS_BYPASS) break;
4829
4830 // flush
4831
4832 const uint pws_cnt = device_param->pws_cnt;
4833
4834 if (pws_cnt)
4835 {
4836 run_copy (device_param, pws_cnt);
4837
4838 run_cracker (device_param, pws_cnt);
4839
4840 device_param->pws_cnt = 0;
4841
4842 /*
4843 still required?
4844 if (attack_kern == ATTACK_KERN_STRAIGHT)
4845 {
4846 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4847 }
4848 else if (attack_kern == ATTACK_KERN_COMBI)
4849 {
4850 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4851 }
4852 */
4853 }
4854 }
4855
4856 device_param->kernel_accel = 0;
4857 device_param->kernel_loops = 0;
4858
4859 myfree (buf);
4860
4861 return NULL;
4862 }
4863
4864 static void *thread_calc (void *p)
4865 {
4866 hc_device_param_t *device_param = (hc_device_param_t *) p;
4867
4868 if (device_param->skipped) return NULL;
4869
4870 const uint attack_mode = data.attack_mode;
4871 const uint attack_kern = data.attack_kern;
4872
4873 if (attack_mode == ATTACK_MODE_BF)
4874 {
4875 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4876 {
4877 const uint work = get_work (device_param, -1);
4878
4879 if (work == 0) break;
4880
4881 const u64 words_off = device_param->words_off;
4882 const u64 words_fin = words_off + work;
4883
4884 const uint pws_cnt = work;
4885
4886 device_param->pws_cnt = pws_cnt;
4887
4888 if (pws_cnt)
4889 {
4890 run_copy (device_param, pws_cnt);
4891
4892 run_cracker (device_param, pws_cnt);
4893
4894 device_param->pws_cnt = 0;
4895
4896 /*
4897 still required?
4898 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4899 */
4900 }
4901
4902 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4903
4904 if (data.devices_status == STATUS_CRACKED) break;
4905 if (data.devices_status == STATUS_ABORTED) break;
4906 if (data.devices_status == STATUS_QUIT) break;
4907 if (data.devices_status == STATUS_BYPASS) break;
4908
4909 if (data.benchmark == 1) break;
4910
4911 device_param->words_done = words_fin;
4912 }
4913 }
4914 else
4915 {
4916 const uint segment_size = data.segment_size;
4917
4918 char *dictfile = data.dictfile;
4919
4920 if (attack_mode == ATTACK_MODE_COMBI)
4921 {
4922 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4923 {
4924 dictfile = data.dictfile2;
4925 }
4926 }
4927
4928 FILE *fd = fopen (dictfile, "rb");
4929
4930 if (fd == NULL)
4931 {
4932 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4933
4934 return NULL;
4935 }
4936
4937 if (attack_mode == ATTACK_MODE_COMBI)
4938 {
4939 const uint combs_mode = data.combs_mode;
4940
4941 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4942 {
4943 const char *dictfilec = data.dictfile2;
4944
4945 FILE *combs_fp = fopen (dictfilec, "rb");
4946
4947 if (combs_fp == NULL)
4948 {
4949 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4950
4951 fclose (fd);
4952
4953 return NULL;
4954 }
4955
4956 device_param->combs_fp = combs_fp;
4957 }
4958 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4959 {
4960 const char *dictfilec = data.dictfile;
4961
4962 FILE *combs_fp = fopen (dictfilec, "rb");
4963
4964 if (combs_fp == NULL)
4965 {
4966 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4967
4968 fclose (fd);
4969
4970 return NULL;
4971 }
4972
4973 device_param->combs_fp = combs_fp;
4974 }
4975 }
4976
4977 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4978
4979 wl_data->buf = (char *) mymalloc (segment_size);
4980 wl_data->avail = segment_size;
4981 wl_data->incr = segment_size;
4982 wl_data->cnt = 0;
4983 wl_data->pos = 0;
4984
4985 u64 words_cur = 0;
4986
4987 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4988 {
4989 u64 words_off = 0;
4990 u64 words_fin = 0;
4991
4992 u64 max = -1;
4993
4994 while (max)
4995 {
4996 const uint work = get_work (device_param, max);
4997
4998 if (work == 0) break;
4999
5000 max = 0;
5001
5002 words_off = device_param->words_off;
5003 words_fin = words_off + work;
5004
5005 char *line_buf;
5006 uint line_len;
5007
5008 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5009
5010 for ( ; words_cur < words_fin; words_cur++)
5011 {
5012 get_next_word (wl_data, fd, &line_buf, &line_len);
5013
5014 line_len = convert_from_hex (line_buf, line_len);
5015
5016 // post-process rule engine
5017
5018 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5019 {
5020 char rule_buf_out[BLOCK_SIZE] = { 0 };
5021
5022 int rule_len_out = -1;
5023
5024 if (line_len < BLOCK_SIZE)
5025 {
5026 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5027 }
5028
5029 if (rule_len_out < 0) continue;
5030
5031 line_buf = rule_buf_out;
5032 line_len = rule_len_out;
5033 }
5034
5035 if (attack_kern == ATTACK_KERN_STRAIGHT)
5036 {
5037 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5038 {
5039 max++;
5040
5041 hc_thread_mutex_lock (mux_counter);
5042
5043 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5044 {
5045 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5046 }
5047
5048 hc_thread_mutex_unlock (mux_counter);
5049
5050 continue;
5051 }
5052 }
5053 else if (attack_kern == ATTACK_KERN_COMBI)
5054 {
5055 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5056 // since we still need to combine the plains
5057
5058 if (line_len > data.pw_max)
5059 {
5060 max++;
5061
5062 hc_thread_mutex_lock (mux_counter);
5063
5064 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5065 {
5066 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5067 }
5068
5069 hc_thread_mutex_unlock (mux_counter);
5070
5071 continue;
5072 }
5073 }
5074
5075 pw_add (device_param, (u8 *) line_buf, line_len);
5076
5077 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5078
5079 if (data.devices_status == STATUS_CRACKED) break;
5080 if (data.devices_status == STATUS_ABORTED) break;
5081 if (data.devices_status == STATUS_QUIT) break;
5082 if (data.devices_status == STATUS_BYPASS) break;
5083 }
5084
5085 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5086
5087 if (data.devices_status == STATUS_CRACKED) break;
5088 if (data.devices_status == STATUS_ABORTED) break;
5089 if (data.devices_status == STATUS_QUIT) break;
5090 if (data.devices_status == STATUS_BYPASS) break;
5091 }
5092
5093 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5094
5095 if (data.devices_status == STATUS_CRACKED) break;
5096 if (data.devices_status == STATUS_ABORTED) break;
5097 if (data.devices_status == STATUS_QUIT) break;
5098 if (data.devices_status == STATUS_BYPASS) break;
5099
5100 //
5101 // flush
5102 //
5103
5104 const uint pws_cnt = device_param->pws_cnt;
5105
5106 if (pws_cnt)
5107 {
5108 run_copy (device_param, pws_cnt);
5109
5110 run_cracker (device_param, pws_cnt);
5111
5112 device_param->pws_cnt = 0;
5113
5114 /*
5115 still required?
5116 if (attack_kern == ATTACK_KERN_STRAIGHT)
5117 {
5118 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5119 }
5120 else if (attack_kern == ATTACK_KERN_COMBI)
5121 {
5122 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5123 }
5124 */
5125 }
5126
5127 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5128
5129 if (data.devices_status == STATUS_CRACKED) break;
5130 if (data.devices_status == STATUS_ABORTED) break;
5131 if (data.devices_status == STATUS_QUIT) break;
5132 if (data.devices_status == STATUS_BYPASS) break;
5133
5134 if (words_fin == 0) break;
5135
5136 device_param->words_done = words_fin;
5137 }
5138
5139 if (attack_mode == ATTACK_MODE_COMBI)
5140 {
5141 fclose (device_param->combs_fp);
5142 }
5143
5144 free (wl_data->buf);
5145 free (wl_data);
5146
5147 fclose (fd);
5148 }
5149
5150 device_param->kernel_accel = 0;
5151 device_param->kernel_loops = 0;
5152
5153 return NULL;
5154 }
5155
5156 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5157 {
5158 if (!device_param)
5159 {
5160 log_error ("ERROR: %s : Invalid argument", __func__);
5161
5162 exit (-1);
5163 }
5164
5165 salt_t *salt_buf = &data.salts_buf[salt_pos];
5166
5167 device_param->kernel_params_buf32[24] = salt_pos;
5168 device_param->kernel_params_buf32[27] = 1;
5169 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5170 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5171 device_param->kernel_params_buf32[30] = 0;
5172 device_param->kernel_params_buf32[31] = 1;
5173
5174 char *dictfile_old = data.dictfile;
5175
5176 const char *weak_hash_check = "weak-hash-check";
5177
5178 data.dictfile = (char *) weak_hash_check;
5179
5180 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5181
5182 data.kernel_rules_buf[0].cmds[0] = 0;
5183
5184 /**
5185 * run the kernel
5186 */
5187
5188 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5189 {
5190 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5191 }
5192 else
5193 {
5194 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5195
5196 uint loop_step = 16;
5197
5198 const uint iter = salt_buf->salt_iter;
5199
5200 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5201 {
5202 uint loop_left = iter - loop_pos;
5203
5204 loop_left = MIN (loop_left, loop_step);
5205
5206 device_param->kernel_params_buf32[25] = loop_pos;
5207 device_param->kernel_params_buf32[26] = loop_left;
5208
5209 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5210 }
5211
5212 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5213 }
5214
5215 /**
5216 * result
5217 */
5218
5219 check_cracked (device_param, salt_pos);
5220
5221 /**
5222 * cleanup
5223 */
5224
5225 device_param->kernel_params_buf32[24] = 0;
5226 device_param->kernel_params_buf32[25] = 0;
5227 device_param->kernel_params_buf32[26] = 0;
5228 device_param->kernel_params_buf32[27] = 0;
5229 device_param->kernel_params_buf32[28] = 0;
5230 device_param->kernel_params_buf32[29] = 0;
5231 device_param->kernel_params_buf32[30] = 0;
5232 device_param->kernel_params_buf32[31] = 0;
5233
5234 data.dictfile = dictfile_old;
5235
5236 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5237 }
5238
5239 // hlfmt hashcat
5240
5241 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5242 {
5243 if (data.username == 0)
5244 {
5245 *hashbuf_pos = line_buf;
5246 *hashbuf_len = line_len;
5247 }
5248 else
5249 {
5250 char *pos = line_buf;
5251 int len = line_len;
5252
5253 for (int i = 0; i < line_len; i++, pos++, len--)
5254 {
5255 if (line_buf[i] == data.separator)
5256 {
5257 pos++;
5258
5259 len--;
5260
5261 break;
5262 }
5263 }
5264
5265 *hashbuf_pos = pos;
5266 *hashbuf_len = len;
5267 }
5268 }
5269
5270 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5271 {
5272 char *pos = NULL;
5273 int len = 0;
5274
5275 int sep_cnt = 0;
5276
5277 for (int i = 0; i < line_len; i++)
5278 {
5279 if (line_buf[i] == data.separator)
5280 {
5281 sep_cnt++;
5282
5283 continue;
5284 }
5285
5286 if (sep_cnt == 0)
5287 {
5288 if (pos == NULL) pos = line_buf + i;
5289
5290 len++;
5291 }
5292 }
5293
5294 *userbuf_pos = pos;
5295 *userbuf_len = len;
5296 }
5297
5298 // hlfmt pwdump
5299
5300 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5301 {
5302 int sep_cnt = 0;
5303
5304 int sep2_len = 0;
5305 int sep3_len = 0;
5306
5307 for (int i = 0; i < line_len; i++)
5308 {
5309 if (line_buf[i] == ':')
5310 {
5311 sep_cnt++;
5312
5313 continue;
5314 }
5315
5316 if (sep_cnt == 2) sep2_len++;
5317 if (sep_cnt == 3) sep3_len++;
5318 }
5319
5320 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5321
5322 return 0;
5323 }
5324
5325 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5326 {
5327 char *pos = NULL;
5328 int len = 0;
5329
5330 int sep_cnt = 0;
5331
5332 for (int i = 0; i < line_len; i++)
5333 {
5334 if (line_buf[i] == ':')
5335 {
5336 sep_cnt++;
5337
5338 continue;
5339 }
5340
5341 if (data.hash_mode == 1000)
5342 {
5343 if (sep_cnt == 3)
5344 {
5345 if (pos == NULL) pos = line_buf + i;
5346
5347 len++;
5348 }
5349 }
5350 else if (data.hash_mode == 3000)
5351 {
5352 if (sep_cnt == 2)
5353 {
5354 if (pos == NULL) pos = line_buf + i;
5355
5356 len++;
5357 }
5358 }
5359 }
5360
5361 *hashbuf_pos = pos;
5362 *hashbuf_len = len;
5363 }
5364
5365 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5366 {
5367 char *pos = NULL;
5368 int len = 0;
5369
5370 int sep_cnt = 0;
5371
5372 for (int i = 0; i < line_len; i++)
5373 {
5374 if (line_buf[i] == ':')
5375 {
5376 sep_cnt++;
5377
5378 continue;
5379 }
5380
5381 if (sep_cnt == 0)
5382 {
5383 if (pos == NULL) pos = line_buf + i;
5384
5385 len++;
5386 }
5387 }
5388
5389 *userbuf_pos = pos;
5390 *userbuf_len = len;
5391 }
5392
5393 // hlfmt passwd
5394
5395 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5396 {
5397 int sep_cnt = 0;
5398
5399 char sep5_first = 0;
5400 char sep6_first = 0;
5401
5402 for (int i = 0; i < line_len; i++)
5403 {
5404 if (line_buf[i] == ':')
5405 {
5406 sep_cnt++;
5407
5408 continue;
5409 }
5410
5411 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5412 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5413 }
5414
5415 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5416
5417 return 0;
5418 }
5419
5420 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5421 {
5422 char *pos = NULL;
5423 int len = 0;
5424
5425 int sep_cnt = 0;
5426
5427 for (int i = 0; i < line_len; i++)
5428 {
5429 if (line_buf[i] == ':')
5430 {
5431 sep_cnt++;
5432
5433 continue;
5434 }
5435
5436 if (sep_cnt == 1)
5437 {
5438 if (pos == NULL) pos = line_buf + i;
5439
5440 len++;
5441 }
5442 }
5443
5444 *hashbuf_pos = pos;
5445 *hashbuf_len = len;
5446 }
5447
5448 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5449 {
5450 char *pos = NULL;
5451 int len = 0;
5452
5453 int sep_cnt = 0;
5454
5455 for (int i = 0; i < line_len; i++)
5456 {
5457 if (line_buf[i] == ':')
5458 {
5459 sep_cnt++;
5460
5461 continue;
5462 }
5463
5464 if (sep_cnt == 0)
5465 {
5466 if (pos == NULL) pos = line_buf + i;
5467
5468 len++;
5469 }
5470 }
5471
5472 *userbuf_pos = pos;
5473 *userbuf_len = len;
5474 }
5475
5476 // hlfmt shadow
5477
5478 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5479 {
5480 int sep_cnt = 0;
5481
5482 for (int i = 0; i < line_len; i++)
5483 {
5484 if (line_buf[i] == ':') sep_cnt++;
5485 }
5486
5487 if (sep_cnt == 8) return 1;
5488
5489 return 0;
5490 }
5491
5492 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5493 {
5494 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5495 }
5496
5497 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5498 {
5499 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5500 }
5501
5502 // hlfmt main
5503
5504 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5505 {
5506 switch (hashfile_format)
5507 {
5508 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5509 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5510 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5511 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5512 }
5513 }
5514
5515 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5516 {
5517 switch (hashfile_format)
5518 {
5519 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5520 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5521 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5522 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5523 }
5524 }
5525
5526 char *strhlfmt (const uint hashfile_format)
5527 {
5528 switch (hashfile_format)
5529 {
5530 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5531 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5532 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5533 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5534 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5535 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5536 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5537 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5538 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5539 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5540 }
5541
5542 return ((char *) "Unknown");
5543 }
5544
5545 static uint hlfmt_detect (FILE *fp, uint max_check)
5546 {
5547 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5548
5549 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5550 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5551
5552 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5553
5554 uint num_check = 0;
5555
5556 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5557
5558 while (!feof (fp))
5559 {
5560 int line_len = fgetl (fp, line_buf);
5561
5562 if (line_len == 0) continue;
5563
5564 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5565 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5566 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5567
5568 if (num_check == max_check) break;
5569
5570 num_check++;
5571 }
5572
5573 myfree (line_buf);
5574
5575 uint hashlist_format = HLFMT_HASHCAT;
5576
5577 for (int i = 1; i < HLFMTS_CNT; i++)
5578 {
5579 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5580
5581 hashlist_format = i;
5582 }
5583
5584 free (formats_cnt);
5585
5586 return hashlist_format;
5587 }
5588
5589 /**
5590 * some further helper function
5591 */
5592
5593 // wrapper around mymalloc for ADL
5594
5595 #if defined(HAVE_HWMON)
5596 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5597 {
5598 return mymalloc (iSize);
5599 }
5600 #endif
5601
5602 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5603 {
5604 u64 collisions = 0;
5605
5606 const uint dgst_pos0 = data.dgst_pos0;
5607 const uint dgst_pos1 = data.dgst_pos1;
5608 const uint dgst_pos2 = data.dgst_pos2;
5609 const uint dgst_pos3 = data.dgst_pos3;
5610
5611 memset (bitmap_a, 0, bitmap_size);
5612 memset (bitmap_b, 0, bitmap_size);
5613 memset (bitmap_c, 0, bitmap_size);
5614 memset (bitmap_d, 0, bitmap_size);
5615
5616 for (uint i = 0; i < digests_cnt; i++)
5617 {
5618 uint *digest_ptr = (uint *) digests_buf_ptr;
5619
5620 digests_buf_ptr += dgst_size;
5621
5622 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5623 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5624 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5625 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5626
5627 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5628 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5629 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5630 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5631
5632 if (bitmap_a[idx0] & val0) collisions++;
5633 if (bitmap_b[idx1] & val1) collisions++;
5634 if (bitmap_c[idx2] & val2) collisions++;
5635 if (bitmap_d[idx3] & val3) collisions++;
5636
5637 bitmap_a[idx0] |= val0;
5638 bitmap_b[idx1] |= val1;
5639 bitmap_c[idx2] |= val2;
5640 bitmap_d[idx3] |= val3;
5641
5642 if (collisions >= collisions_max) return 0x7fffffff;
5643 }
5644
5645 return collisions;
5646 }
5647
5648 /**
5649 * main
5650 */
5651
5652 #ifdef WIN
5653 void SetConsoleWindowSize (const int x)
5654 {
5655 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5656
5657 if (h == INVALID_HANDLE_VALUE) return;
5658
5659 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5660
5661 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5662
5663 SMALL_RECT *sr = &bufferInfo.srWindow;
5664
5665 sr->Right = MAX (sr->Right, x - 1);
5666
5667 COORD co;
5668
5669 co.X = sr->Right + 1;
5670 co.Y = 9999;
5671
5672 if (!SetConsoleScreenBufferSize (h, co)) return;
5673
5674 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5675 }
5676 #endif
5677
5678 int main (int argc, char **argv)
5679 {
5680 #ifdef WIN
5681 SetConsoleWindowSize (132);
5682 #endif
5683
5684 /**
5685 * To help users a bit
5686 */
5687
5688 char *compute = getenv ("COMPUTE");
5689
5690 if (compute)
5691 {
5692 static char display[100];
5693
5694 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5695
5696 putenv (display);
5697 }
5698 else
5699 {
5700 if (getenv ("DISPLAY") == NULL)
5701 putenv ((char *) "DISPLAY=:0");
5702 }
5703
5704 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5705 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5706
5707 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5708 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5709
5710 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5711 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5712
5713 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5714 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5715
5716 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5717 putenv ((char *) "POCL_KERNEL_CACHE=0");
5718
5719 umask (077);
5720
5721 /**
5722 * Real init
5723 */
5724
5725 memset (&data, 0, sizeof (hc_global_data_t));
5726
5727 time_t proc_start;
5728
5729 time (&proc_start);
5730
5731 data.proc_start = proc_start;
5732
5733 int myargc = argc;
5734 char **myargv = argv;
5735
5736 hc_thread_mutex_init (mux_dispatcher);
5737 hc_thread_mutex_init (mux_counter);
5738 hc_thread_mutex_init (mux_display);
5739 hc_thread_mutex_init (mux_adl);
5740
5741 /**
5742 * commandline parameters
5743 */
5744
5745 uint usage = USAGE;
5746 uint version = VERSION;
5747 uint quiet = QUIET;
5748 uint benchmark = BENCHMARK;
5749 uint stdout_flag = STDOUT_FLAG;
5750 uint show = SHOW;
5751 uint left = LEFT;
5752 uint username = USERNAME;
5753 uint remove = REMOVE;
5754 uint remove_timer = REMOVE_TIMER;
5755 u64 skip = SKIP;
5756 u64 limit = LIMIT;
5757 uint keyspace = KEYSPACE;
5758 uint potfile_disable = POTFILE_DISABLE;
5759 char *potfile_path = NULL;
5760 uint debug_mode = DEBUG_MODE;
5761 char *debug_file = NULL;
5762 char *induction_dir = NULL;
5763 char *outfile_check_dir = NULL;
5764 uint force = FORCE;
5765 uint runtime = RUNTIME;
5766 uint hash_mode = HASH_MODE;
5767 uint attack_mode = ATTACK_MODE;
5768 uint markov_disable = MARKOV_DISABLE;
5769 uint markov_classic = MARKOV_CLASSIC;
5770 uint markov_threshold = MARKOV_THRESHOLD;
5771 char *markov_hcstat = NULL;
5772 char *outfile = NULL;
5773 uint outfile_format = OUTFILE_FORMAT;
5774 uint outfile_autohex = OUTFILE_AUTOHEX;
5775 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5776 uint restore = RESTORE;
5777 uint restore_timer = RESTORE_TIMER;
5778 uint restore_disable = RESTORE_DISABLE;
5779 uint status = STATUS;
5780 uint status_timer = STATUS_TIMER;
5781 uint machine_readable = MACHINE_READABLE;
5782 uint loopback = LOOPBACK;
5783 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5784 char *session = NULL;
5785 uint hex_charset = HEX_CHARSET;
5786 uint hex_salt = HEX_SALT;
5787 uint hex_wordlist = HEX_WORDLIST;
5788 uint rp_gen = RP_GEN;
5789 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5790 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5791 uint rp_gen_seed = RP_GEN_SEED;
5792 char *rule_buf_l = (char *) RULE_BUF_L;
5793 char *rule_buf_r = (char *) RULE_BUF_R;
5794 uint increment = INCREMENT;
5795 uint increment_min = INCREMENT_MIN;
5796 uint increment_max = INCREMENT_MAX;
5797 char *cpu_affinity = NULL;
5798 OCL_PTR *ocl = NULL;
5799 char *opencl_devices = NULL;
5800 char *opencl_platforms = NULL;
5801 char *opencl_device_types = NULL;
5802 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5803 char *truecrypt_keyfiles = NULL;
5804 char *veracrypt_keyfiles = NULL;
5805 uint veracrypt_pim = 0;
5806 uint workload_profile = WORKLOAD_PROFILE;
5807 uint kernel_accel = KERNEL_ACCEL;
5808 uint kernel_loops = KERNEL_LOOPS;
5809 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5810 #ifdef HAVE_HWMON
5811 uint gpu_temp_abort = GPU_TEMP_ABORT;
5812 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5813 uint powertune_enable = POWERTUNE_ENABLE;
5814 #endif
5815 uint logfile_disable = LOGFILE_DISABLE;
5816 uint segment_size = SEGMENT_SIZE;
5817 uint scrypt_tmto = SCRYPT_TMTO;
5818 char separator = SEPARATOR;
5819 uint bitmap_min = BITMAP_MIN;
5820 uint bitmap_max = BITMAP_MAX;
5821 char *custom_charset_1 = NULL;
5822 char *custom_charset_2 = NULL;
5823 char *custom_charset_3 = NULL;
5824 char *custom_charset_4 = NULL;
5825
5826 #define IDX_HELP 'h'
5827 #define IDX_VERSION 'V'
5828 #define IDX_VERSION_LOWER 'v'
5829 #define IDX_QUIET 0xff02
5830 #define IDX_SHOW 0xff03
5831 #define IDX_LEFT 0xff04
5832 #define IDX_REMOVE 0xff05
5833 #define IDX_REMOVE_TIMER 0xff37
5834 #define IDX_SKIP 's'
5835 #define IDX_LIMIT 'l'
5836 #define IDX_KEYSPACE 0xff35
5837 #define IDX_POTFILE_DISABLE 0xff06
5838 #define IDX_POTFILE_PATH 0xffe0
5839 #define IDX_DEBUG_MODE 0xff43
5840 #define IDX_DEBUG_FILE 0xff44
5841 #define IDX_INDUCTION_DIR 0xff46
5842 #define IDX_OUTFILE_CHECK_DIR 0xff47
5843 #define IDX_USERNAME 0xff07
5844 #define IDX_FORCE 0xff08
5845 #define IDX_RUNTIME 0xff09
5846 #define IDX_BENCHMARK 'b'
5847 #define IDX_STDOUT_FLAG 0xff77
5848 #define IDX_HASH_MODE 'm'
5849 #define IDX_ATTACK_MODE 'a'
5850 #define IDX_RP_FILE 'r'
5851 #define IDX_RP_GEN 'g'
5852 #define IDX_RP_GEN_FUNC_MIN 0xff10
5853 #define IDX_RP_GEN_FUNC_MAX 0xff11
5854 #define IDX_RP_GEN_SEED 0xff34
5855 #define IDX_RULE_BUF_L 'j'
5856 #define IDX_RULE_BUF_R 'k'
5857 #define IDX_INCREMENT 'i'
5858 #define IDX_INCREMENT_MIN 0xff12
5859 #define IDX_INCREMENT_MAX 0xff13
5860 #define IDX_OUTFILE 'o'
5861 #define IDX_OUTFILE_FORMAT 0xff14
5862 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5863 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5864 #define IDX_RESTORE 0xff15
5865 #define IDX_RESTORE_DISABLE 0xff27
5866 #define IDX_STATUS 0xff17
5867 #define IDX_STATUS_TIMER 0xff18
5868 #define IDX_MACHINE_READABLE 0xff50
5869 #define IDX_LOOPBACK 0xff38
5870 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5871 #define IDX_SESSION 0xff19
5872 #define IDX_HEX_CHARSET 0xff20
5873 #define IDX_HEX_SALT 0xff21
5874 #define IDX_HEX_WORDLIST 0xff40
5875 #define IDX_MARKOV_DISABLE 0xff22
5876 #define IDX_MARKOV_CLASSIC 0xff23
5877 #define IDX_MARKOV_THRESHOLD 't'
5878 #define IDX_MARKOV_HCSTAT 0xff24
5879 #define IDX_CPU_AFFINITY 0xff25
5880 #define IDX_OPENCL_DEVICES 'd'
5881 #define IDX_OPENCL_PLATFORMS 0xff72
5882 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5883 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5884 #define IDX_WORKLOAD_PROFILE 'w'
5885 #define IDX_KERNEL_ACCEL 'n'
5886 #define IDX_KERNEL_LOOPS 'u'
5887 #define IDX_GPU_TEMP_DISABLE 0xff29
5888 #define IDX_GPU_TEMP_ABORT 0xff30
5889 #define IDX_GPU_TEMP_RETAIN 0xff31
5890 #define IDX_POWERTUNE_ENABLE 0xff41
5891 #define IDX_LOGFILE_DISABLE 0xff51
5892 #define IDX_TRUECRYPT_KEYFILES 0xff52
5893 #define IDX_VERACRYPT_KEYFILES 0xff53
5894 #define IDX_VERACRYPT_PIM 0xff54
5895 #define IDX_SCRYPT_TMTO 0xff61
5896 #define IDX_SEGMENT_SIZE 'c'
5897 #define IDX_SEPARATOR 'p'
5898 #define IDX_BITMAP_MIN 0xff70
5899 #define IDX_BITMAP_MAX 0xff71
5900 #define IDX_CUSTOM_CHARSET_1 '1'
5901 #define IDX_CUSTOM_CHARSET_2 '2'
5902 #define IDX_CUSTOM_CHARSET_3 '3'
5903 #define IDX_CUSTOM_CHARSET_4 '4'
5904
5905 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5906
5907 struct option long_options[] =
5908 {
5909 {"help", no_argument, 0, IDX_HELP},
5910 {"version", no_argument, 0, IDX_VERSION},
5911 {"quiet", no_argument, 0, IDX_QUIET},
5912 {"show", no_argument, 0, IDX_SHOW},
5913 {"left", no_argument, 0, IDX_LEFT},
5914 {"username", no_argument, 0, IDX_USERNAME},
5915 {"remove", no_argument, 0, IDX_REMOVE},
5916 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5917 {"skip", required_argument, 0, IDX_SKIP},
5918 {"limit", required_argument, 0, IDX_LIMIT},
5919 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5920 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5921 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5922 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5923 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5924 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5925 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5926 {"force", no_argument, 0, IDX_FORCE},
5927 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5928 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5929 {"restore", no_argument, 0, IDX_RESTORE},
5930 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5931 {"status", no_argument, 0, IDX_STATUS},
5932 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5933 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5934 {"loopback", no_argument, 0, IDX_LOOPBACK},
5935 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5936 {"session", required_argument, 0, IDX_SESSION},
5937 {"runtime", required_argument, 0, IDX_RUNTIME},
5938 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5939 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5940 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5941 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5942 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5943 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5944 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5945 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5946 {"rules-file", required_argument, 0, IDX_RP_FILE},
5947 {"outfile", required_argument, 0, IDX_OUTFILE},
5948 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5949 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5950 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5951 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5952 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5953 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5954 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5955 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5956 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5957 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5958 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5959 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5960 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5961 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5962 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5963 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5964 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5965 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5966 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5967 #ifdef HAVE_HWMON
5968 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5969 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5970 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5971 #endif // HAVE_HWMON
5972 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5973 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5974 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5975 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5976 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5977 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5978 {"seperator", required_argument, 0, IDX_SEPARATOR},
5979 {"separator", required_argument, 0, IDX_SEPARATOR},
5980 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5981 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5982 {"increment", no_argument, 0, IDX_INCREMENT},
5983 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5984 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5985 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5986 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5987 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5988 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5989 {0, 0, 0, 0}
5990 };
5991
5992 uint rp_files_cnt = 0;
5993
5994 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5995
5996 int option_index = 0;
5997 int c = -1;
5998
5999 optind = 1;
6000 optopt = 0;
6001
6002 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6003 {
6004 switch (c)
6005 {
6006 case IDX_HELP: usage = 1; break;
6007 case IDX_VERSION:
6008 case IDX_VERSION_LOWER: version = 1; break;
6009 case IDX_RESTORE: restore = 1; break;
6010 case IDX_SESSION: session = optarg; break;
6011 case IDX_SHOW: show = 1; break;
6012 case IDX_LEFT: left = 1; break;
6013 case '?': return (-1);
6014 }
6015 }
6016
6017 if (optopt != 0)
6018 {
6019 log_error ("ERROR: Invalid argument specified");
6020
6021 return (-1);
6022 }
6023
6024 /**
6025 * exit functions
6026 */
6027
6028 if (version)
6029 {
6030 log_info ("%s", VERSION_TAG);
6031
6032 return (0);
6033 }
6034
6035 if (usage)
6036 {
6037 usage_big_print (PROGNAME);
6038
6039 return (0);
6040 }
6041
6042 /**
6043 * session needs to be set, always!
6044 */
6045
6046 if (session == NULL) session = (char *) PROGNAME;
6047
6048 /**
6049 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6050 */
6051
6052 char *exec_path = get_exec_path ();
6053
6054 #ifdef LINUX
6055
6056 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6057 char *resolved_exec_path = realpath (exec_path, NULL);
6058
6059 char *install_dir = get_install_dir (resolved_exec_path);
6060 char *profile_dir = NULL;
6061 char *session_dir = NULL;
6062 char *shared_dir = NULL;
6063
6064 if (strcmp (install_dir, resolved_install_folder) == 0)
6065 {
6066 struct passwd *pw = getpwuid (getuid ());
6067
6068 const char *homedir = pw->pw_dir;
6069
6070 profile_dir = get_profile_dir (homedir);
6071 session_dir = get_session_dir (profile_dir);
6072 shared_dir = strdup (SHARED_FOLDER);
6073
6074 mkdir (profile_dir, 0700);
6075 mkdir (session_dir, 0700);
6076 }
6077 else
6078 {
6079 profile_dir = install_dir;
6080 session_dir = install_dir;
6081 shared_dir = install_dir;
6082 }
6083
6084 myfree (resolved_install_folder);
6085 myfree (resolved_exec_path);
6086
6087 #else
6088
6089 char *install_dir = get_install_dir (exec_path);
6090 char *profile_dir = install_dir;
6091 char *session_dir = install_dir;
6092 char *shared_dir = install_dir;
6093
6094 #endif
6095
6096 data.install_dir = install_dir;
6097 data.profile_dir = profile_dir;
6098 data.session_dir = session_dir;
6099 data.shared_dir = shared_dir;
6100
6101 myfree (exec_path);
6102
6103 /**
6104 * kernel cache, we need to make sure folder exist
6105 */
6106
6107 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6108
6109 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6110
6111 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6112
6113 mkdir (kernels_folder, 0700);
6114
6115 myfree (kernels_folder);
6116
6117 /**
6118 * session
6119 */
6120
6121 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6122
6123 data.session = session;
6124
6125 char *eff_restore_file = (char *) mymalloc (session_size);
6126 char *new_restore_file = (char *) mymalloc (session_size);
6127
6128 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6129 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6130
6131 data.eff_restore_file = eff_restore_file;
6132 data.new_restore_file = new_restore_file;
6133
6134 if (((show == 1) || (left == 1)) && (restore == 1))
6135 {
6136 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6137 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6138
6139 return (-1);
6140 }
6141
6142 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6143 if ((show == 1) || (left == 1))
6144 {
6145 restore_disable = 1;
6146
6147 restore = 0;
6148 }
6149
6150 data.restore_disable = restore_disable;
6151
6152 restore_data_t *rd = init_restore (argc, argv);
6153
6154 data.rd = rd;
6155
6156 /**
6157 * restore file
6158 */
6159
6160 if (restore == 1)
6161 {
6162 read_restore (eff_restore_file, rd);
6163
6164 if (rd->version_bin < RESTORE_MIN)
6165 {
6166 log_error ("ERROR: Incompatible restore-file version");
6167
6168 return (-1);
6169 }
6170
6171 myargc = rd->argc;
6172 myargv = rd->argv;
6173
6174 #ifdef _POSIX
6175 rd->pid = getpid ();
6176 #elif _WIN
6177 rd->pid = GetCurrentProcessId ();
6178 #endif
6179 }
6180
6181 uint hash_mode_chgd = 0;
6182 uint runtime_chgd = 0;
6183 uint kernel_loops_chgd = 0;
6184 uint kernel_accel_chgd = 0;
6185 uint attack_mode_chgd = 0;
6186 uint outfile_format_chgd = 0;
6187 uint rp_gen_seed_chgd = 0;
6188 uint remove_timer_chgd = 0;
6189 uint increment_min_chgd = 0;
6190 uint increment_max_chgd = 0;
6191 uint workload_profile_chgd = 0;
6192 uint opencl_vector_width_chgd = 0;
6193
6194 optind = 1;
6195 optopt = 0;
6196 option_index = 0;
6197
6198 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6199 {
6200 switch (c)
6201 {
6202 //case IDX_HELP: usage = 1; break;
6203 //case IDX_VERSION: version = 1; break;
6204 //case IDX_RESTORE: restore = 1; break;
6205 case IDX_QUIET: quiet = 1; break;
6206 //case IDX_SHOW: show = 1; break;
6207 case IDX_SHOW: break;
6208 //case IDX_LEFT: left = 1; break;
6209 case IDX_LEFT: break;
6210 case IDX_USERNAME: username = 1; break;
6211 case IDX_REMOVE: remove = 1; break;
6212 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6213 remove_timer_chgd = 1; break;
6214 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6215 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6216 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6217 case IDX_DEBUG_FILE: debug_file = optarg; break;
6218 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6219 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6220 case IDX_FORCE: force = 1; break;
6221 case IDX_SKIP: skip = atoll (optarg); break;
6222 case IDX_LIMIT: limit = atoll (optarg); break;
6223 case IDX_KEYSPACE: keyspace = 1; break;
6224 case IDX_BENCHMARK: benchmark = 1; break;
6225 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6226 case IDX_RESTORE: break;
6227 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6228 case IDX_STATUS: status = 1; break;
6229 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6230 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6231 case IDX_LOOPBACK: loopback = 1; break;
6232 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6233 //case IDX_SESSION: session = optarg; break;
6234 case IDX_SESSION: break;
6235 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6236 hash_mode_chgd = 1; break;
6237 case IDX_RUNTIME: runtime = atoi (optarg);
6238 runtime_chgd = 1; break;
6239 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6240 attack_mode_chgd = 1; break;
6241 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6242 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6243 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6244 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6245 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6246 rp_gen_seed_chgd = 1; break;
6247 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6248 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6249 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6250 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6251 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6252 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6253 case IDX_OUTFILE: outfile = optarg; break;
6254 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6255 outfile_format_chgd = 1; break;
6256 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6257 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6258 case IDX_HEX_CHARSET: hex_charset = 1; break;
6259 case IDX_HEX_SALT: hex_salt = 1; break;
6260 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6261 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6262 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6263 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6264 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6265 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6266 opencl_vector_width_chgd = 1; break;
6267 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6268 workload_profile_chgd = 1; break;
6269 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6270 kernel_accel_chgd = 1; break;
6271 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6272 kernel_loops_chgd = 1; break;
6273 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6274 #ifdef HAVE_HWMON
6275 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6276 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6277 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6278 #endif // HAVE_HWMON
6279 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6280 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6281 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6282 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6283 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6284 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6285 case IDX_SEPARATOR: separator = optarg[0]; break;
6286 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6287 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6288 case IDX_INCREMENT: increment = 1; break;
6289 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6290 increment_min_chgd = 1; break;
6291 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6292 increment_max_chgd = 1; break;
6293 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6294 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6295 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6296 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6297
6298 default:
6299 log_error ("ERROR: Invalid argument specified");
6300 return (-1);
6301 }
6302 }
6303
6304 if (optopt != 0)
6305 {
6306 log_error ("ERROR: Invalid argument specified");
6307
6308 return (-1);
6309 }
6310
6311 /**
6312 * Inform user things getting started,
6313 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6314 * - we do not need to check algorithm_pos
6315 */
6316
6317 if (quiet == 0)
6318 {
6319 if (benchmark == 1)
6320 {
6321 if (machine_readable == 0)
6322 {
6323 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6324 log_info ("");
6325 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6326 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6327 log_info ("");
6328 }
6329 else
6330 {
6331 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6332 }
6333 }
6334 else if (restore == 1)
6335 {
6336 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6337 log_info ("");
6338 }
6339 else if (stdout_flag == 1)
6340 {
6341 // do nothing
6342 }
6343 else
6344 {
6345 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6346 log_info ("");
6347 }
6348 }
6349
6350 /**
6351 * sanity check
6352 */
6353
6354 if (attack_mode > 7)
6355 {
6356 log_error ("ERROR: Invalid attack-mode specified");
6357
6358 return (-1);
6359 }
6360
6361 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6362 {
6363 log_error ("ERROR: Invalid runtime specified");
6364
6365 return (-1);
6366 }
6367
6368 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6369 {
6370 log_error ("ERROR: Invalid hash-type specified");
6371
6372 return (-1);
6373 }
6374
6375 // renamed hash modes
6376
6377 if (hash_mode_chgd)
6378 {
6379 int n = -1;
6380
6381 switch (hash_mode)
6382 {
6383 case 123: n = 124;
6384 break;
6385 }
6386
6387 if (n >= 0)
6388 {
6389 log_error ("Old -m specified, use -m %d instead", n);
6390
6391 return (-1);
6392 }
6393 }
6394
6395 if (username == 1)
6396 {
6397 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6398 {
6399 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6400
6401 return (-1);
6402 }
6403 }
6404
6405 if (outfile_format > 16)
6406 {
6407 log_error ("ERROR: Invalid outfile-format specified");
6408
6409 return (-1);
6410 }
6411
6412 if (left == 1)
6413 {
6414 if (outfile_format_chgd == 1)
6415 {
6416 if (outfile_format > 1)
6417 {
6418 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6419
6420 return (-1);
6421 }
6422 }
6423 else
6424 {
6425 outfile_format = OUTFILE_FMT_HASH;
6426 }
6427 }
6428
6429 if (show == 1)
6430 {
6431 if (outfile_format_chgd == 1)
6432 {
6433 if ((outfile_format > 7) && (outfile_format < 16))
6434 {
6435 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6436
6437 return (-1);
6438 }
6439 }
6440 }
6441
6442 if (increment_min < INCREMENT_MIN)
6443 {
6444 log_error ("ERROR: Invalid increment-min specified");
6445
6446 return (-1);
6447 }
6448
6449 if (increment_max > INCREMENT_MAX)
6450 {
6451 log_error ("ERROR: Invalid increment-max specified");
6452
6453 return (-1);
6454 }
6455
6456 if (increment_min > increment_max)
6457 {
6458 log_error ("ERROR: Invalid increment-min specified");
6459
6460 return (-1);
6461 }
6462
6463 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6464 {
6465 log_error ("ERROR: increment is not allowed in attack-mode 0");
6466
6467 return (-1);
6468 }
6469
6470 if ((increment == 0) && (increment_min_chgd == 1))
6471 {
6472 log_error ("ERROR: increment-min is only supported together with increment switch");
6473
6474 return (-1);
6475 }
6476
6477 if ((increment == 0) && (increment_max_chgd == 1))
6478 {
6479 log_error ("ERROR: increment-max is only supported together with increment switch");
6480
6481 return (-1);
6482 }
6483
6484 if (rp_files_cnt && rp_gen)
6485 {
6486 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6487
6488 return (-1);
6489 }
6490
6491 if (rp_files_cnt || rp_gen)
6492 {
6493 if (attack_mode != ATTACK_MODE_STRAIGHT)
6494 {
6495 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6496
6497 return (-1);
6498 }
6499 }
6500
6501 if (rp_gen_func_min > rp_gen_func_max)
6502 {
6503 log_error ("ERROR: Invalid rp-gen-func-min specified");
6504
6505 return (-1);
6506 }
6507
6508 if (kernel_accel_chgd == 1)
6509 {
6510 if (force == 0)
6511 {
6512 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6513 log_info ("Please consider using the option -w instead");
6514 log_info ("You can use --force to override this but do not post error reports if you do so");
6515 log_info ("");
6516
6517 return (-1);
6518 }
6519
6520 if (kernel_accel < 1)
6521 {
6522 log_error ("ERROR: Invalid kernel-accel specified");
6523
6524 return (-1);
6525 }
6526
6527 if (kernel_accel > 1024)
6528 {
6529 log_error ("ERROR: Invalid kernel-accel specified");
6530
6531 return (-1);
6532 }
6533 }
6534
6535 if (kernel_loops_chgd == 1)
6536 {
6537 if (force == 0)
6538 {
6539 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6540 log_info ("Please consider using the option -w instead");
6541 log_info ("You can use --force to override this but do not post error reports if you do so");
6542 log_info ("");
6543
6544 return (-1);
6545 }
6546
6547 if (kernel_loops < 1)
6548 {
6549 log_error ("ERROR: Invalid kernel-loops specified");
6550
6551 return (-1);
6552 }
6553
6554 if (kernel_loops > 1024)
6555 {
6556 log_error ("ERROR: Invalid kernel-loops specified");
6557
6558 return (-1);
6559 }
6560 }
6561
6562 if ((workload_profile < 1) || (workload_profile > 4))
6563 {
6564 log_error ("ERROR: workload-profile %i not available", workload_profile);
6565
6566 return (-1);
6567 }
6568
6569 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6570 {
6571 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6572
6573 return (-1);
6574 }
6575
6576 if (show == 1 || left == 1)
6577 {
6578 attack_mode = ATTACK_MODE_NONE;
6579
6580 if (remove == 1)
6581 {
6582 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6583
6584 return (-1);
6585 }
6586
6587 if (potfile_disable == 1)
6588 {
6589 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6590
6591 return (-1);
6592 }
6593 }
6594
6595 uint attack_kern = ATTACK_KERN_NONE;
6596
6597 switch (attack_mode)
6598 {
6599 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6600 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6601 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6602 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6603 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6604 }
6605
6606 if (benchmark == 1)
6607 {
6608 if (myargv[optind] != 0)
6609 {
6610 log_error ("ERROR: Invalid argument for benchmark mode specified");
6611
6612 return (-1);
6613 }
6614
6615 if (attack_mode_chgd == 1)
6616 {
6617 if (attack_mode != ATTACK_MODE_BF)
6618 {
6619 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6620
6621 return (-1);
6622 }
6623 }
6624 }
6625 else
6626 {
6627 if (stdout_flag == 1) // no hash here
6628 {
6629 optind--;
6630 }
6631
6632 if (keyspace == 1)
6633 {
6634 int num_additional_params = 1;
6635
6636 if (attack_kern == ATTACK_KERN_COMBI)
6637 {
6638 num_additional_params = 2;
6639 }
6640
6641 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6642
6643 if (keyspace_wordlist_specified == 0) optind--;
6644 }
6645
6646 if (attack_kern == ATTACK_KERN_NONE)
6647 {
6648 if ((optind + 1) != myargc)
6649 {
6650 usage_mini_print (myargv[0]);
6651
6652 return (-1);
6653 }
6654 }
6655 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6656 {
6657 if ((optind + 1) > myargc)
6658 {
6659 usage_mini_print (myargv[0]);
6660
6661 return (-1);
6662 }
6663 }
6664 else if (attack_kern == ATTACK_KERN_COMBI)
6665 {
6666 if ((optind + 3) != myargc)
6667 {
6668 usage_mini_print (myargv[0]);
6669
6670 return (-1);
6671 }
6672 }
6673 else if (attack_kern == ATTACK_KERN_BF)
6674 {
6675 if ((optind + 1) > myargc)
6676 {
6677 usage_mini_print (myargv[0]);
6678
6679 return (-1);
6680 }
6681 }
6682 else
6683 {
6684 usage_mini_print (myargv[0]);
6685
6686 return (-1);
6687 }
6688 }
6689
6690 if (skip != 0 && limit != 0)
6691 {
6692 limit += skip;
6693 }
6694
6695 if (keyspace == 1)
6696 {
6697 if (show == 1)
6698 {
6699 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6700
6701 return (-1);
6702 }
6703 else if (left == 1)
6704 {
6705 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6706
6707 return (-1);
6708 }
6709
6710 potfile_disable = 1;
6711
6712 restore_disable = 1;
6713
6714 restore = 0;
6715
6716 weak_hash_threshold = 0;
6717
6718 quiet = 1;
6719 }
6720
6721 if (stdout_flag == 1)
6722 {
6723 status_timer = 0;
6724 restore_timer = 0;
6725 restore_disable = 1;
6726 restore = 0;
6727 potfile_disable = 1;
6728 weak_hash_threshold = 0;
6729 gpu_temp_disable = 1;
6730 hash_mode = 2000;
6731 quiet = 1;
6732 outfile_format = OUTFILE_FMT_PLAIN;
6733 kernel_accel = 1024;
6734 kernel_loops = 1024;
6735 force = 1;
6736 outfile_check_timer = 0;
6737 }
6738
6739 if (remove_timer_chgd == 1)
6740 {
6741 if (remove == 0)
6742 {
6743 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6744
6745 return (-1);
6746 }
6747
6748 if (remove_timer < 1)
6749 {
6750 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6751
6752 return (-1);
6753 }
6754 }
6755
6756 if (loopback == 1)
6757 {
6758 if (attack_mode == ATTACK_MODE_STRAIGHT)
6759 {
6760 if ((rp_files_cnt == 0) && (rp_gen == 0))
6761 {
6762 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6763
6764 return (-1);
6765 }
6766 }
6767 else
6768 {
6769 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6770
6771 return (-1);
6772 }
6773 }
6774
6775 if (debug_mode > 0)
6776 {
6777 if (attack_mode != ATTACK_MODE_STRAIGHT)
6778 {
6779 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6780
6781 return (-1);
6782 }
6783
6784 if ((rp_files_cnt == 0) && (rp_gen == 0))
6785 {
6786 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6787
6788 return (-1);
6789 }
6790 }
6791
6792 if (debug_mode > 4)
6793 {
6794 log_error ("ERROR: Invalid debug-mode specified");
6795
6796 return (-1);
6797 }
6798
6799 if (debug_file != NULL)
6800 {
6801 if (debug_mode < 1)
6802 {
6803 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6804
6805 return (-1);
6806 }
6807 }
6808
6809 if (induction_dir != NULL)
6810 {
6811 if (attack_mode == ATTACK_MODE_BF)
6812 {
6813 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6814
6815 return (-1);
6816 }
6817 }
6818
6819 if (attack_mode != ATTACK_MODE_STRAIGHT)
6820 {
6821 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6822 {
6823 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6824
6825 return (-1);
6826 }
6827
6828 weak_hash_threshold = 0;
6829 }
6830
6831 /**
6832 * induction directory
6833 */
6834
6835 char *induction_directory = NULL;
6836
6837 if (attack_mode != ATTACK_MODE_BF)
6838 {
6839 if (induction_dir == NULL)
6840 {
6841 induction_directory = (char *) mymalloc (session_size);
6842
6843 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6844
6845 // create induction folder if it does not already exist
6846
6847 if (keyspace == 0)
6848 {
6849 if (rmdir (induction_directory) == -1)
6850 {
6851 if (errno == ENOENT)
6852 {
6853 // good, we can ignore
6854 }
6855 else if (errno == ENOTEMPTY)
6856 {
6857 char *induction_directory_mv = (char *) mymalloc (session_size);
6858
6859 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6860
6861 if (rename (induction_directory, induction_directory_mv) != 0)
6862 {
6863 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6864
6865 return (-1);
6866 }
6867 }
6868 else
6869 {
6870 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6871
6872 return (-1);
6873 }
6874 }
6875
6876 if (mkdir (induction_directory, 0700) == -1)
6877 {
6878 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6879
6880 return (-1);
6881 }
6882 }
6883 }
6884 else
6885 {
6886 induction_directory = induction_dir;
6887 }
6888 }
6889
6890 data.induction_directory = induction_directory;
6891
6892 /**
6893 * loopback
6894 */
6895
6896 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6897
6898 char *loopback_file = (char *) mymalloc (loopback_size);
6899
6900 /**
6901 * tuning db
6902 */
6903
6904 char tuning_db_file[256] = { 0 };
6905
6906 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6907
6908 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6909
6910 /**
6911 * outfile-check directory
6912 */
6913
6914 char *outfile_check_directory = NULL;
6915
6916 if (outfile_check_dir == NULL)
6917 {
6918 outfile_check_directory = (char *) mymalloc (session_size);
6919
6920 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6921 }
6922 else
6923 {
6924 outfile_check_directory = outfile_check_dir;
6925 }
6926
6927 data.outfile_check_directory = outfile_check_directory;
6928
6929 if (keyspace == 0)
6930 {
6931 struct stat outfile_check_stat;
6932
6933 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6934 {
6935 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6936
6937 if (is_dir == 0)
6938 {
6939 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6940
6941 return (-1);
6942 }
6943 }
6944 else if (outfile_check_dir == NULL)
6945 {
6946 if (mkdir (outfile_check_directory, 0700) == -1)
6947 {
6948 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6949
6950 return (-1);
6951 }
6952 }
6953 }
6954
6955 /**
6956 * special other stuff
6957 */
6958
6959 if (hash_mode == 9710)
6960 {
6961 outfile_format = 5;
6962 outfile_format_chgd = 1;
6963 }
6964
6965 if (hash_mode == 9810)
6966 {
6967 outfile_format = 5;
6968 outfile_format_chgd = 1;
6969 }
6970
6971 if (hash_mode == 10410)
6972 {
6973 outfile_format = 5;
6974 outfile_format_chgd = 1;
6975 }
6976
6977 /**
6978 * store stuff
6979 */
6980
6981 data.hash_mode = hash_mode;
6982 data.restore = restore;
6983 data.restore_timer = restore_timer;
6984 data.restore_disable = restore_disable;
6985 data.status = status;
6986 data.status_timer = status_timer;
6987 data.machine_readable = machine_readable;
6988 data.loopback = loopback;
6989 data.runtime = runtime;
6990 data.remove = remove;
6991 data.remove_timer = remove_timer;
6992 data.debug_mode = debug_mode;
6993 data.debug_file = debug_file;
6994 data.username = username;
6995 data.quiet = quiet;
6996 data.outfile = outfile;
6997 data.outfile_format = outfile_format;
6998 data.outfile_autohex = outfile_autohex;
6999 data.hex_charset = hex_charset;
7000 data.hex_salt = hex_salt;
7001 data.hex_wordlist = hex_wordlist;
7002 data.separator = separator;
7003 data.rp_files = rp_files;
7004 data.rp_files_cnt = rp_files_cnt;
7005 data.rp_gen = rp_gen;
7006 data.rp_gen_seed = rp_gen_seed;
7007 data.force = force;
7008 data.benchmark = benchmark;
7009 data.skip = skip;
7010 data.limit = limit;
7011 #ifdef HAVE_HWMON
7012 data.powertune_enable = powertune_enable;
7013 #endif
7014 data.logfile_disable = logfile_disable;
7015 data.truecrypt_keyfiles = truecrypt_keyfiles;
7016 data.veracrypt_keyfiles = veracrypt_keyfiles;
7017 data.veracrypt_pim = veracrypt_pim;
7018 data.scrypt_tmto = scrypt_tmto;
7019 data.workload_profile = workload_profile;
7020
7021 /**
7022 * cpu affinity
7023 */
7024
7025 if (cpu_affinity)
7026 {
7027 set_cpu_affinity (cpu_affinity);
7028 }
7029
7030 if (rp_gen_seed_chgd == 0)
7031 {
7032 srand (proc_start);
7033 }
7034 else
7035 {
7036 srand (rp_gen_seed);
7037 }
7038
7039 /**
7040 * logfile init
7041 */
7042
7043 if (logfile_disable == 0)
7044 {
7045 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7046
7047 char *logfile = (char *) mymalloc (logfile_size);
7048
7049 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7050
7051 data.logfile = logfile;
7052
7053 char *topid = logfile_generate_topid ();
7054
7055 data.topid = topid;
7056 }
7057
7058 // logfile_append() checks for logfile_disable internally to make it easier from here
7059
7060 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7061 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7062 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7063 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7064 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7065 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7066 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7067 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7068 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7069 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
7070
7071 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7072 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7073 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7074 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7075 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7076 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7077 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7078 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7079
7080 logfile_top_msg ("START");
7081
7082 logfile_top_uint (attack_mode);
7083 logfile_top_uint (attack_kern);
7084 logfile_top_uint (benchmark);
7085 logfile_top_uint (stdout_flag);
7086 logfile_top_uint (bitmap_min);
7087 logfile_top_uint (bitmap_max);
7088 logfile_top_uint (debug_mode);
7089 logfile_top_uint (force);
7090 logfile_top_uint (kernel_accel);
7091 logfile_top_uint (kernel_loops);
7092 logfile_top_uint (gpu_temp_disable);
7093 #ifdef HAVE_HWMON
7094 logfile_top_uint (gpu_temp_abort);
7095 logfile_top_uint (gpu_temp_retain);
7096 #endif
7097 logfile_top_uint (hash_mode);
7098 logfile_top_uint (hex_charset);
7099 logfile_top_uint (hex_salt);
7100 logfile_top_uint (hex_wordlist);
7101 logfile_top_uint (increment);
7102 logfile_top_uint (increment_max);
7103 logfile_top_uint (increment_min);
7104 logfile_top_uint (keyspace);
7105 logfile_top_uint (left);
7106 logfile_top_uint (logfile_disable);
7107 logfile_top_uint (loopback);
7108 logfile_top_uint (markov_classic);
7109 logfile_top_uint (markov_disable);
7110 logfile_top_uint (markov_threshold);
7111 logfile_top_uint (outfile_autohex);
7112 logfile_top_uint (outfile_check_timer);
7113 logfile_top_uint (outfile_format);
7114 logfile_top_uint (potfile_disable);
7115 logfile_top_string (potfile_path);
7116 #if defined(HAVE_HWMON)
7117 logfile_top_uint (powertune_enable);
7118 #endif
7119 logfile_top_uint (scrypt_tmto);
7120 logfile_top_uint (quiet);
7121 logfile_top_uint (remove);
7122 logfile_top_uint (remove_timer);
7123 logfile_top_uint (restore);
7124 logfile_top_uint (restore_disable);
7125 logfile_top_uint (restore_timer);
7126 logfile_top_uint (rp_gen);
7127 logfile_top_uint (rp_gen_func_max);
7128 logfile_top_uint (rp_gen_func_min);
7129 logfile_top_uint (rp_gen_seed);
7130 logfile_top_uint (runtime);
7131 logfile_top_uint (segment_size);
7132 logfile_top_uint (show);
7133 logfile_top_uint (status);
7134 logfile_top_uint (machine_readable);
7135 logfile_top_uint (status_timer);
7136 logfile_top_uint (usage);
7137 logfile_top_uint (username);
7138 logfile_top_uint (version);
7139 logfile_top_uint (weak_hash_threshold);
7140 logfile_top_uint (workload_profile);
7141 logfile_top_uint64 (limit);
7142 logfile_top_uint64 (skip);
7143 logfile_top_char (separator);
7144 logfile_top_string (cpu_affinity);
7145 logfile_top_string (custom_charset_1);
7146 logfile_top_string (custom_charset_2);
7147 logfile_top_string (custom_charset_3);
7148 logfile_top_string (custom_charset_4);
7149 logfile_top_string (debug_file);
7150 logfile_top_string (opencl_devices);
7151 logfile_top_string (opencl_platforms);
7152 logfile_top_string (opencl_device_types);
7153 logfile_top_uint (opencl_vector_width);
7154 logfile_top_string (induction_dir);
7155 logfile_top_string (markov_hcstat);
7156 logfile_top_string (outfile);
7157 logfile_top_string (outfile_check_dir);
7158 logfile_top_string (rule_buf_l);
7159 logfile_top_string (rule_buf_r);
7160 logfile_top_string (session);
7161 logfile_top_string (truecrypt_keyfiles);
7162 logfile_top_string (veracrypt_keyfiles);
7163 logfile_top_uint (veracrypt_pim);
7164
7165 /**
7166 * Init OpenCL library loader
7167 */
7168
7169 if (keyspace == 0)
7170 {
7171 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7172
7173 ocl_init (ocl);
7174
7175 data.ocl = ocl;
7176 }
7177
7178 /**
7179 * OpenCL platform selection
7180 */
7181
7182 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7183
7184 /**
7185 * OpenCL device selection
7186 */
7187
7188 u32 devices_filter = setup_devices_filter (opencl_devices);
7189
7190 /**
7191 * OpenCL device type selection
7192 */
7193
7194 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7195
7196 /**
7197 * benchmark
7198 */
7199
7200 if (benchmark == 1)
7201 {
7202 /**
7203 * disable useless stuff for benchmark
7204 */
7205
7206 status_timer = 0;
7207 restore_timer = 0;
7208 restore_disable = 1;
7209 potfile_disable = 1;
7210 weak_hash_threshold = 0;
7211 gpu_temp_disable = 1;
7212 outfile_check_timer = 0;
7213
7214 #ifdef HAVE_HWMON
7215 if (powertune_enable == 1)
7216 {
7217 gpu_temp_disable = 0;
7218 }
7219 #endif
7220
7221 data.status_timer = status_timer;
7222 data.restore_timer = restore_timer;
7223 data.restore_disable = restore_disable;
7224 data.outfile_check_timer = outfile_check_timer;
7225
7226 /**
7227 * force attack mode to be bruteforce
7228 */
7229
7230 attack_mode = ATTACK_MODE_BF;
7231 attack_kern = ATTACK_KERN_BF;
7232
7233 if (workload_profile_chgd == 0)
7234 {
7235 workload_profile = 3;
7236
7237 data.workload_profile = workload_profile;
7238 }
7239 }
7240
7241 /**
7242 * config
7243 */
7244
7245 uint hash_type = 0;
7246 uint salt_type = 0;
7247 uint attack_exec = 0;
7248 uint opts_type = 0;
7249 uint kern_type = 0;
7250 uint dgst_size = 0;
7251 uint esalt_size = 0;
7252 uint opti_type = 0;
7253 uint dgst_pos0 = -1;
7254 uint dgst_pos1 = -1;
7255 uint dgst_pos2 = -1;
7256 uint dgst_pos3 = -1;
7257
7258 int (*parse_func) (char *, uint, hash_t *);
7259 int (*sort_by_digest) (const void *, const void *);
7260
7261 uint algorithm_pos = 0;
7262 uint algorithm_max = 1;
7263
7264 uint *algorithms = default_benchmark_algorithms;
7265
7266 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7267
7268 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7269 {
7270 /*
7271 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7272 * the following algos are skipped entirely
7273 */
7274
7275 if (algorithm_pos > 0)
7276 {
7277 local_free (rd);
7278
7279 rd = init_restore (argc, argv);
7280
7281 data.rd = rd;
7282 }
7283
7284 /**
7285 * update hash_mode in case of multihash benchmark
7286 */
7287
7288 if (benchmark == 1)
7289 {
7290 if (hash_mode_chgd == 0)
7291 {
7292 hash_mode = algorithms[algorithm_pos];
7293
7294 data.hash_mode = hash_mode;
7295 }
7296
7297 quiet = 1;
7298
7299 data.quiet = quiet;
7300 }
7301
7302 switch (hash_mode)
7303 {
7304 case 0: hash_type = HASH_TYPE_MD5;
7305 salt_type = SALT_TYPE_NONE;
7306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7307 opts_type = OPTS_TYPE_PT_GENERATE_LE
7308 | OPTS_TYPE_PT_ADD80
7309 | OPTS_TYPE_PT_ADDBITS14;
7310 kern_type = KERN_TYPE_MD5;
7311 dgst_size = DGST_SIZE_4_4;
7312 parse_func = md5_parse_hash;
7313 sort_by_digest = sort_by_digest_4_4;
7314 opti_type = OPTI_TYPE_ZERO_BYTE
7315 | OPTI_TYPE_PRECOMPUTE_INIT
7316 | OPTI_TYPE_PRECOMPUTE_MERKLE
7317 | OPTI_TYPE_MEET_IN_MIDDLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED
7320 | OPTI_TYPE_NOT_SALTED
7321 | OPTI_TYPE_RAW_HASH;
7322 dgst_pos0 = 0;
7323 dgst_pos1 = 3;
7324 dgst_pos2 = 2;
7325 dgst_pos3 = 1;
7326 break;
7327
7328 case 10: hash_type = HASH_TYPE_MD5;
7329 salt_type = SALT_TYPE_INTERN;
7330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7331 opts_type = OPTS_TYPE_PT_GENERATE_LE
7332 | OPTS_TYPE_ST_ADD80
7333 | OPTS_TYPE_ST_ADDBITS14;
7334 kern_type = KERN_TYPE_MD5_PWSLT;
7335 dgst_size = DGST_SIZE_4_4;
7336 parse_func = md5s_parse_hash;
7337 sort_by_digest = sort_by_digest_4_4;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_MEET_IN_MIDDLE
7342 | OPTI_TYPE_EARLY_SKIP
7343 | OPTI_TYPE_NOT_ITERATED
7344 | OPTI_TYPE_APPENDED_SALT
7345 | OPTI_TYPE_RAW_HASH;
7346 dgst_pos0 = 0;
7347 dgst_pos1 = 3;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 11: hash_type = HASH_TYPE_MD5;
7353 salt_type = SALT_TYPE_INTERN;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_LE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS14;
7358 kern_type = KERN_TYPE_MD5_PWSLT;
7359 dgst_size = DGST_SIZE_4_4;
7360 parse_func = joomla_parse_hash;
7361 sort_by_digest = sort_by_digest_4_4;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_MEET_IN_MIDDLE
7366 | OPTI_TYPE_EARLY_SKIP
7367 | OPTI_TYPE_NOT_ITERATED
7368 | OPTI_TYPE_APPENDED_SALT
7369 | OPTI_TYPE_RAW_HASH;
7370 dgst_pos0 = 0;
7371 dgst_pos1 = 3;
7372 dgst_pos2 = 2;
7373 dgst_pos3 = 1;
7374 break;
7375
7376 case 12: hash_type = HASH_TYPE_MD5;
7377 salt_type = SALT_TYPE_INTERN;
7378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7379 opts_type = OPTS_TYPE_PT_GENERATE_LE
7380 | OPTS_TYPE_ST_ADD80
7381 | OPTS_TYPE_ST_ADDBITS14;
7382 kern_type = KERN_TYPE_MD5_PWSLT;
7383 dgst_size = DGST_SIZE_4_4;
7384 parse_func = postgresql_parse_hash;
7385 sort_by_digest = sort_by_digest_4_4;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_MEET_IN_MIDDLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 0;
7395 dgst_pos1 = 3;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 20: hash_type = HASH_TYPE_MD5;
7401 salt_type = SALT_TYPE_INTERN;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_LE
7404 | OPTS_TYPE_PT_ADD80
7405 | OPTS_TYPE_PT_ADDBITS14;
7406 kern_type = KERN_TYPE_MD5_SLTPW;
7407 dgst_size = DGST_SIZE_4_4;
7408 parse_func = md5s_parse_hash;
7409 sort_by_digest = sort_by_digest_4_4;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_PREPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 0;
7418 dgst_pos1 = 3;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 21: hash_type = HASH_TYPE_MD5;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_LE
7427 | OPTS_TYPE_PT_ADD80
7428 | OPTS_TYPE_PT_ADDBITS14;
7429 kern_type = KERN_TYPE_MD5_SLTPW;
7430 dgst_size = DGST_SIZE_4_4;
7431 parse_func = osc_parse_hash;
7432 sort_by_digest = sort_by_digest_4_4;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_PREPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 0;
7441 dgst_pos1 = 3;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 22: hash_type = HASH_TYPE_MD5;
7447 salt_type = SALT_TYPE_EMBEDDED;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_LE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS14;
7452 kern_type = KERN_TYPE_MD5_SLTPW;
7453 dgst_size = DGST_SIZE_4_4;
7454 parse_func = netscreen_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 0;
7464 dgst_pos1 = 3;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 23: hash_type = HASH_TYPE_MD5;
7470 salt_type = SALT_TYPE_EMBEDDED;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_LE
7473 | OPTS_TYPE_PT_ADD80
7474 | OPTS_TYPE_PT_ADDBITS14;
7475 kern_type = KERN_TYPE_MD5_SLTPW;
7476 dgst_size = DGST_SIZE_4_4;
7477 parse_func = skype_parse_hash;
7478 sort_by_digest = sort_by_digest_4_4;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_PRECOMPUTE_INIT
7481 | OPTI_TYPE_PRECOMPUTE_MERKLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_PREPENDED_SALT
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 0;
7487 dgst_pos1 = 3;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 30: hash_type = HASH_TYPE_MD5;
7493 salt_type = SALT_TYPE_INTERN;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_LE
7496 | OPTS_TYPE_PT_UNICODE
7497 | OPTS_TYPE_ST_ADD80
7498 | OPTS_TYPE_ST_ADDBITS14;
7499 kern_type = KERN_TYPE_MD5_PWUSLT;
7500 dgst_size = DGST_SIZE_4_4;
7501 parse_func = md5s_parse_hash;
7502 sort_by_digest = sort_by_digest_4_4;
7503 opti_type = OPTI_TYPE_ZERO_BYTE
7504 | OPTI_TYPE_PRECOMPUTE_INIT
7505 | OPTI_TYPE_PRECOMPUTE_MERKLE
7506 | OPTI_TYPE_MEET_IN_MIDDLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_APPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 40: hash_type = HASH_TYPE_MD5;
7518 salt_type = SALT_TYPE_INTERN;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_LE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS14
7523 | OPTS_TYPE_PT_UNICODE;
7524 kern_type = KERN_TYPE_MD5_SLTPWU;
7525 dgst_size = DGST_SIZE_4_4;
7526 parse_func = md5s_parse_hash;
7527 sort_by_digest = sort_by_digest_4_4;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_PREPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 3;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 50: hash_type = HASH_TYPE_MD5;
7542 salt_type = SALT_TYPE_INTERN;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_LE
7545 | OPTS_TYPE_ST_ADD80
7546 | OPTS_TYPE_ST_ADDBITS14;
7547 kern_type = KERN_TYPE_HMACMD5_PW;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = hmacmd5_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_NOT_ITERATED;
7553 dgst_pos0 = 0;
7554 dgst_pos1 = 3;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 60: hash_type = HASH_TYPE_MD5;
7560 salt_type = SALT_TYPE_INTERN;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_LE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS14;
7565 kern_type = KERN_TYPE_HMACMD5_SLT;
7566 dgst_size = DGST_SIZE_4_4;
7567 parse_func = hmacmd5_parse_hash;
7568 sort_by_digest = sort_by_digest_4_4;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_NOT_ITERATED;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 3;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 1;
7575 break;
7576
7577 case 100: hash_type = HASH_TYPE_SHA1;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_PT_ADD80
7582 | OPTS_TYPE_PT_ADDBITS15;
7583 kern_type = KERN_TYPE_SHA1;
7584 dgst_size = DGST_SIZE_4_5;
7585 parse_func = sha1_parse_hash;
7586 sort_by_digest = sort_by_digest_4_5;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_PRECOMPUTE_INIT
7589 | OPTI_TYPE_PRECOMPUTE_MERKLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_NOT_SALTED
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 3;
7595 dgst_pos1 = 4;
7596 dgst_pos2 = 2;
7597 dgst_pos3 = 1;
7598 break;
7599
7600 case 101: hash_type = HASH_TYPE_SHA1;
7601 salt_type = SALT_TYPE_NONE;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_PT_ADD80
7605 | OPTS_TYPE_PT_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA1;
7607 dgst_size = DGST_SIZE_4_5;
7608 parse_func = sha1b64_parse_hash;
7609 sort_by_digest = sort_by_digest_4_5;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_NOT_SALTED
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 3;
7618 dgst_pos1 = 4;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 1;
7621 break;
7622
7623 case 110: hash_type = HASH_TYPE_SHA1;
7624 salt_type = SALT_TYPE_INTERN;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA1_PWSLT;
7630 dgst_size = DGST_SIZE_4_5;
7631 parse_func = sha1s_parse_hash;
7632 sort_by_digest = sort_by_digest_4_5;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 3;
7641 dgst_pos1 = 4;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 1;
7644 break;
7645
7646 case 111: hash_type = HASH_TYPE_SHA1;
7647 salt_type = SALT_TYPE_EMBEDDED;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_ST_ADD80
7651 | OPTS_TYPE_ST_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA1_PWSLT;
7653 dgst_size = DGST_SIZE_4_5;
7654 parse_func = sha1b64s_parse_hash;
7655 sort_by_digest = sort_by_digest_4_5;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_APPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 3;
7664 dgst_pos1 = 4;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 112: hash_type = HASH_TYPE_SHA1;
7670 salt_type = SALT_TYPE_INTERN;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_ST_ADD80
7674 | OPTS_TYPE_ST_ADDBITS15
7675 | OPTS_TYPE_ST_HEX;
7676 kern_type = KERN_TYPE_SHA1_PWSLT;
7677 dgst_size = DGST_SIZE_4_5;
7678 parse_func = oracles_parse_hash;
7679 sort_by_digest = sort_by_digest_4_5;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_APPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 4;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 120: hash_type = HASH_TYPE_SHA1;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS15;
7699 kern_type = KERN_TYPE_SHA1_SLTPW;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = sha1s_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_PREPENDED_SALT
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 4;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 1;
7714 break;
7715
7716 case 121: hash_type = HASH_TYPE_SHA1;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_PT_ADD80
7721 | OPTS_TYPE_PT_ADDBITS15
7722 | OPTS_TYPE_ST_LOWER;
7723 kern_type = KERN_TYPE_SHA1_SLTPW;
7724 dgst_size = DGST_SIZE_4_5;
7725 parse_func = smf_parse_hash;
7726 sort_by_digest = sort_by_digest_4_5;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_PREPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 4;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 1;
7738 break;
7739
7740 case 122: hash_type = HASH_TYPE_SHA1;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS15
7746 | OPTS_TYPE_ST_HEX;
7747 kern_type = KERN_TYPE_SHA1_SLTPW;
7748 dgst_size = DGST_SIZE_4_5;
7749 parse_func = osx1_parse_hash;
7750 sort_by_digest = sort_by_digest_4_5;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_PRECOMPUTE_INIT
7753 | OPTI_TYPE_PRECOMPUTE_MERKLE
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_PREPENDED_SALT
7757 | OPTI_TYPE_RAW_HASH;
7758 dgst_pos0 = 3;
7759 dgst_pos1 = 4;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 1;
7762 break;
7763
7764 case 124: hash_type = HASH_TYPE_SHA1;
7765 salt_type = SALT_TYPE_EMBEDDED;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15;
7770 kern_type = KERN_TYPE_SHA1_SLTPW;
7771 dgst_size = DGST_SIZE_4_5;
7772 parse_func = djangosha1_parse_hash;
7773 sort_by_digest = sort_by_digest_4_5;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_PREPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 125: hash_type = HASH_TYPE_SHA1;
7788 salt_type = SALT_TYPE_EMBEDDED;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS15
7793 | OPTS_TYPE_ST_HEX;
7794 kern_type = KERN_TYPE_SHA1_SLTPW;
7795 dgst_size = DGST_SIZE_4_5;
7796 parse_func = arubaos_parse_hash;
7797 sort_by_digest = sort_by_digest_4_5;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_PREPENDED_SALT
7804 | OPTI_TYPE_RAW_HASH;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 4;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 1;
7809 break;
7810
7811 case 130: hash_type = HASH_TYPE_SHA1;
7812 salt_type = SALT_TYPE_INTERN;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_UNICODE
7816 | OPTS_TYPE_ST_ADD80
7817 | OPTS_TYPE_ST_ADDBITS15;
7818 kern_type = KERN_TYPE_SHA1_PWUSLT;
7819 dgst_size = DGST_SIZE_4_5;
7820 parse_func = sha1s_parse_hash;
7821 sort_by_digest = sort_by_digest_4_5;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_APPENDED_SALT
7828 | OPTI_TYPE_RAW_HASH;
7829 dgst_pos0 = 3;
7830 dgst_pos1 = 4;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 1;
7833 break;
7834
7835 case 131: hash_type = HASH_TYPE_SHA1;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_BE
7839 | OPTS_TYPE_PT_UNICODE
7840 | OPTS_TYPE_PT_UPPER
7841 | OPTS_TYPE_ST_ADD80
7842 | OPTS_TYPE_ST_ADDBITS15
7843 | OPTS_TYPE_ST_HEX;
7844 kern_type = KERN_TYPE_SHA1_PWUSLT;
7845 dgst_size = DGST_SIZE_4_5;
7846 parse_func = mssql2000_parse_hash;
7847 sort_by_digest = sort_by_digest_4_5;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_EARLY_SKIP
7852 | OPTI_TYPE_NOT_ITERATED
7853 | OPTI_TYPE_APPENDED_SALT
7854 | OPTI_TYPE_RAW_HASH;
7855 dgst_pos0 = 3;
7856 dgst_pos1 = 4;
7857 dgst_pos2 = 2;
7858 dgst_pos3 = 1;
7859 break;
7860
7861 case 132: hash_type = HASH_TYPE_SHA1;
7862 salt_type = SALT_TYPE_EMBEDDED;
7863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7864 opts_type = OPTS_TYPE_PT_GENERATE_BE
7865 | OPTS_TYPE_PT_UNICODE
7866 | OPTS_TYPE_ST_ADD80
7867 | OPTS_TYPE_ST_ADDBITS15
7868 | OPTS_TYPE_ST_HEX;
7869 kern_type = KERN_TYPE_SHA1_PWUSLT;
7870 dgst_size = DGST_SIZE_4_5;
7871 parse_func = mssql2005_parse_hash;
7872 sort_by_digest = sort_by_digest_4_5;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_APPENDED_SALT
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 3;
7881 dgst_pos1 = 4;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 1;
7884 break;
7885
7886 case 133: hash_type = HASH_TYPE_SHA1;
7887 salt_type = SALT_TYPE_EMBEDDED;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_BE
7890 | OPTS_TYPE_PT_UNICODE
7891 | OPTS_TYPE_ST_ADD80
7892 | OPTS_TYPE_ST_ADDBITS15;
7893 kern_type = KERN_TYPE_SHA1_PWUSLT;
7894 dgst_size = DGST_SIZE_4_5;
7895 parse_func = peoplesoft_parse_hash;
7896 sort_by_digest = sort_by_digest_4_5;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_APPENDED_SALT
7903 | OPTI_TYPE_RAW_HASH;
7904 dgst_pos0 = 3;
7905 dgst_pos1 = 4;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 140: hash_type = HASH_TYPE_SHA1;
7911 salt_type = SALT_TYPE_INTERN;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_BE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS15
7916 | OPTS_TYPE_PT_UNICODE;
7917 kern_type = KERN_TYPE_SHA1_SLTPWU;
7918 dgst_size = DGST_SIZE_4_5;
7919 parse_func = sha1s_parse_hash;
7920 sort_by_digest = sort_by_digest_4_5;
7921 opti_type = OPTI_TYPE_ZERO_BYTE
7922 | OPTI_TYPE_PRECOMPUTE_INIT
7923 | OPTI_TYPE_PRECOMPUTE_MERKLE
7924 | OPTI_TYPE_EARLY_SKIP
7925 | OPTI_TYPE_NOT_ITERATED
7926 | OPTI_TYPE_PREPENDED_SALT
7927 | OPTI_TYPE_RAW_HASH;
7928 dgst_pos0 = 3;
7929 dgst_pos1 = 4;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 1;
7932 break;
7933
7934 case 141: hash_type = HASH_TYPE_SHA1;
7935 salt_type = SALT_TYPE_EMBEDDED;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_BE
7938 | OPTS_TYPE_PT_ADD80
7939 | OPTS_TYPE_PT_ADDBITS15
7940 | OPTS_TYPE_PT_UNICODE
7941 | OPTS_TYPE_ST_BASE64;
7942 kern_type = KERN_TYPE_SHA1_SLTPWU;
7943 dgst_size = DGST_SIZE_4_5;
7944 parse_func = episerver_parse_hash;
7945 sort_by_digest = sort_by_digest_4_5;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_INIT
7948 | OPTI_TYPE_PRECOMPUTE_MERKLE
7949 | OPTI_TYPE_EARLY_SKIP
7950 | OPTI_TYPE_NOT_ITERATED
7951 | OPTI_TYPE_PREPENDED_SALT
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 3;
7954 dgst_pos1 = 4;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 150: hash_type = HASH_TYPE_SHA1;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_ST_ADD80
7964 | OPTS_TYPE_ST_ADDBITS15;
7965 kern_type = KERN_TYPE_HMACSHA1_PW;
7966 dgst_size = DGST_SIZE_4_5;
7967 parse_func = hmacsha1_parse_hash;
7968 sort_by_digest = sort_by_digest_4_5;
7969 opti_type = OPTI_TYPE_ZERO_BYTE
7970 | OPTI_TYPE_NOT_ITERATED;
7971 dgst_pos0 = 3;
7972 dgst_pos1 = 4;
7973 dgst_pos2 = 2;
7974 dgst_pos3 = 1;
7975 break;
7976
7977 case 160: hash_type = HASH_TYPE_SHA1;
7978 salt_type = SALT_TYPE_INTERN;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_PT_ADD80
7982 | OPTS_TYPE_PT_ADDBITS15;
7983 kern_type = KERN_TYPE_HMACSHA1_SLT;
7984 dgst_size = DGST_SIZE_4_5;
7985 parse_func = hmacsha1_parse_hash;
7986 sort_by_digest = sort_by_digest_4_5;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_NOT_ITERATED;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 4;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 1;
7993 break;
7994
7995 case 190: hash_type = HASH_TYPE_SHA1;
7996 salt_type = SALT_TYPE_NONE;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS15;
8001 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8002 dgst_size = DGST_SIZE_4_5;
8003 parse_func = sha1linkedin_parse_hash;
8004 sort_by_digest = sort_by_digest_4_5;
8005 opti_type = OPTI_TYPE_ZERO_BYTE
8006 | OPTI_TYPE_PRECOMPUTE_INIT
8007 | OPTI_TYPE_EARLY_SKIP
8008 | OPTI_TYPE_NOT_ITERATED
8009 | OPTI_TYPE_NOT_SALTED;
8010 dgst_pos0 = 0;
8011 dgst_pos1 = 4;
8012 dgst_pos2 = 3;
8013 dgst_pos3 = 2;
8014 break;
8015
8016 case 200: hash_type = HASH_TYPE_MYSQL;
8017 salt_type = SALT_TYPE_NONE;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = 0;
8020 kern_type = KERN_TYPE_MYSQL;
8021 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8022 parse_func = mysql323_parse_hash;
8023 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8024 opti_type = OPTI_TYPE_ZERO_BYTE;
8025 dgst_pos0 = 0;
8026 dgst_pos1 = 1;
8027 dgst_pos2 = 2;
8028 dgst_pos3 = 3;
8029 break;
8030
8031 case 300: hash_type = HASH_TYPE_SHA1;
8032 salt_type = SALT_TYPE_NONE;
8033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8034 opts_type = OPTS_TYPE_PT_GENERATE_BE
8035 | OPTS_TYPE_PT_ADD80
8036 | OPTS_TYPE_PT_ADDBITS15;
8037 kern_type = KERN_TYPE_MYSQL41;
8038 dgst_size = DGST_SIZE_4_5;
8039 parse_func = sha1_parse_hash;
8040 sort_by_digest = sort_by_digest_4_5;
8041 opti_type = OPTI_TYPE_ZERO_BYTE
8042 | OPTI_TYPE_PRECOMPUTE_INIT
8043 | OPTI_TYPE_PRECOMPUTE_MERKLE
8044 | OPTI_TYPE_EARLY_SKIP
8045 | OPTI_TYPE_NOT_ITERATED
8046 | OPTI_TYPE_NOT_SALTED;
8047 dgst_pos0 = 3;
8048 dgst_pos1 = 4;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 1;
8051 break;
8052
8053 case 400: hash_type = HASH_TYPE_MD5;
8054 salt_type = SALT_TYPE_EMBEDDED;
8055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8057 kern_type = KERN_TYPE_PHPASS;
8058 dgst_size = DGST_SIZE_4_4;
8059 parse_func = phpass_parse_hash;
8060 sort_by_digest = sort_by_digest_4_4;
8061 opti_type = OPTI_TYPE_ZERO_BYTE
8062 | OPTI_TYPE_SLOW_HASH_SIMD;
8063 dgst_pos0 = 0;
8064 dgst_pos1 = 1;
8065 dgst_pos2 = 2;
8066 dgst_pos3 = 3;
8067 break;
8068
8069 case 500: hash_type = HASH_TYPE_MD5;
8070 salt_type = SALT_TYPE_EMBEDDED;
8071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8073 kern_type = KERN_TYPE_MD5CRYPT;
8074 dgst_size = DGST_SIZE_4_4;
8075 parse_func = md5crypt_parse_hash;
8076 sort_by_digest = sort_by_digest_4_4;
8077 opti_type = OPTI_TYPE_ZERO_BYTE;
8078 dgst_pos0 = 0;
8079 dgst_pos1 = 1;
8080 dgst_pos2 = 2;
8081 dgst_pos3 = 3;
8082 break;
8083
8084 case 501: hash_type = HASH_TYPE_MD5;
8085 salt_type = SALT_TYPE_EMBEDDED;
8086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8087 opts_type = OPTS_TYPE_PT_GENERATE_LE
8088 | OPTS_TYPE_HASH_COPY;
8089 kern_type = KERN_TYPE_MD5CRYPT;
8090 dgst_size = DGST_SIZE_4_4;
8091 parse_func = juniper_parse_hash;
8092 sort_by_digest = sort_by_digest_4_4;
8093 opti_type = OPTI_TYPE_ZERO_BYTE;
8094 dgst_pos0 = 0;
8095 dgst_pos1 = 1;
8096 dgst_pos2 = 2;
8097 dgst_pos3 = 3;
8098 break;
8099
8100 case 900: hash_type = HASH_TYPE_MD4;
8101 salt_type = SALT_TYPE_NONE;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_LE
8104 | OPTS_TYPE_PT_ADD80
8105 | OPTS_TYPE_PT_ADDBITS14;
8106 kern_type = KERN_TYPE_MD4;
8107 dgst_size = DGST_SIZE_4_4;
8108 parse_func = md4_parse_hash;
8109 sort_by_digest = sort_by_digest_4_4;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_MEET_IN_MIDDLE
8114 | OPTI_TYPE_EARLY_SKIP
8115 | OPTI_TYPE_NOT_ITERATED
8116 | OPTI_TYPE_NOT_SALTED
8117 | OPTI_TYPE_RAW_HASH;
8118 dgst_pos0 = 0;
8119 dgst_pos1 = 3;
8120 dgst_pos2 = 2;
8121 dgst_pos3 = 1;
8122 break;
8123
8124 case 1000: hash_type = HASH_TYPE_MD4;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_LE
8128 | OPTS_TYPE_PT_ADD80
8129 | OPTS_TYPE_PT_ADDBITS14
8130 | OPTS_TYPE_PT_UNICODE;
8131 kern_type = KERN_TYPE_MD4_PWU;
8132 dgst_size = DGST_SIZE_4_4;
8133 parse_func = md4_parse_hash;
8134 sort_by_digest = sort_by_digest_4_4;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_INIT
8137 | OPTI_TYPE_PRECOMPUTE_MERKLE
8138 | OPTI_TYPE_MEET_IN_MIDDLE
8139 | OPTI_TYPE_EARLY_SKIP
8140 | OPTI_TYPE_NOT_ITERATED
8141 | OPTI_TYPE_NOT_SALTED
8142 | OPTI_TYPE_RAW_HASH;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 3;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 1;
8147 break;
8148
8149 case 1100: hash_type = HASH_TYPE_MD4;
8150 salt_type = SALT_TYPE_INTERN;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14
8155 | OPTS_TYPE_PT_UNICODE
8156 | OPTS_TYPE_ST_ADD80
8157 | OPTS_TYPE_ST_UNICODE
8158 | OPTS_TYPE_ST_LOWER;
8159 kern_type = KERN_TYPE_MD44_PWUSLT;
8160 dgst_size = DGST_SIZE_4_4;
8161 parse_func = dcc_parse_hash;
8162 sort_by_digest = sort_by_digest_4_4;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_PRECOMPUTE_INIT
8165 | OPTI_TYPE_PRECOMPUTE_MERKLE
8166 | OPTI_TYPE_EARLY_SKIP
8167 | OPTI_TYPE_NOT_ITERATED;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174 case 1400: hash_type = HASH_TYPE_SHA256;
8175 salt_type = SALT_TYPE_NONE;
8176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_BE
8178 | OPTS_TYPE_PT_ADD80
8179 | OPTS_TYPE_PT_ADDBITS15;
8180 kern_type = KERN_TYPE_SHA256;
8181 dgst_size = DGST_SIZE_4_8;
8182 parse_func = sha256_parse_hash;
8183 sort_by_digest = sort_by_digest_4_8;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_PRECOMPUTE_INIT
8186 | OPTI_TYPE_PRECOMPUTE_MERKLE
8187 | OPTI_TYPE_EARLY_SKIP
8188 | OPTI_TYPE_NOT_ITERATED
8189 | OPTI_TYPE_NOT_SALTED
8190 | OPTI_TYPE_RAW_HASH;
8191 dgst_pos0 = 3;
8192 dgst_pos1 = 7;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 6;
8195 break;
8196
8197 case 1410: hash_type = HASH_TYPE_SHA256;
8198 salt_type = SALT_TYPE_INTERN;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_BE
8201 | OPTS_TYPE_ST_ADD80
8202 | OPTS_TYPE_ST_ADDBITS15;
8203 kern_type = KERN_TYPE_SHA256_PWSLT;
8204 dgst_size = DGST_SIZE_4_8;
8205 parse_func = sha256s_parse_hash;
8206 sort_by_digest = sort_by_digest_4_8;
8207 opti_type = OPTI_TYPE_ZERO_BYTE
8208 | OPTI_TYPE_PRECOMPUTE_INIT
8209 | OPTI_TYPE_PRECOMPUTE_MERKLE
8210 | OPTI_TYPE_EARLY_SKIP
8211 | OPTI_TYPE_NOT_ITERATED
8212 | OPTI_TYPE_APPENDED_SALT
8213 | OPTI_TYPE_RAW_HASH;
8214 dgst_pos0 = 3;
8215 dgst_pos1 = 7;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 6;
8218 break;
8219
8220 case 1420: hash_type = HASH_TYPE_SHA256;
8221 salt_type = SALT_TYPE_INTERN;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_BE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS15;
8226 kern_type = KERN_TYPE_SHA256_SLTPW;
8227 dgst_size = DGST_SIZE_4_8;
8228 parse_func = sha256s_parse_hash;
8229 sort_by_digest = sort_by_digest_4_8;
8230 opti_type = OPTI_TYPE_ZERO_BYTE
8231 | OPTI_TYPE_PRECOMPUTE_INIT
8232 | OPTI_TYPE_PRECOMPUTE_MERKLE
8233 | OPTI_TYPE_EARLY_SKIP
8234 | OPTI_TYPE_NOT_ITERATED
8235 | OPTI_TYPE_PREPENDED_SALT
8236 | OPTI_TYPE_RAW_HASH;
8237 dgst_pos0 = 3;
8238 dgst_pos1 = 7;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 6;
8241 break;
8242
8243 case 1421: hash_type = HASH_TYPE_SHA256;
8244 salt_type = SALT_TYPE_EMBEDDED;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_BE
8247 | OPTS_TYPE_PT_ADD80
8248 | OPTS_TYPE_PT_ADDBITS15;
8249 kern_type = KERN_TYPE_SHA256_SLTPW;
8250 dgst_size = DGST_SIZE_4_8;
8251 parse_func = hmailserver_parse_hash;
8252 sort_by_digest = sort_by_digest_4_8;
8253 opti_type = OPTI_TYPE_ZERO_BYTE
8254 | OPTI_TYPE_PRECOMPUTE_INIT
8255 | OPTI_TYPE_PRECOMPUTE_MERKLE
8256 | OPTI_TYPE_EARLY_SKIP
8257 | OPTI_TYPE_NOT_ITERATED
8258 | OPTI_TYPE_PREPENDED_SALT
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 3;
8261 dgst_pos1 = 7;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 6;
8264 break;
8265
8266 case 1430: hash_type = HASH_TYPE_SHA256;
8267 salt_type = SALT_TYPE_INTERN;
8268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_BE
8270 | OPTS_TYPE_PT_UNICODE
8271 | OPTS_TYPE_ST_ADD80
8272 | OPTS_TYPE_ST_ADDBITS15;
8273 kern_type = KERN_TYPE_SHA256_PWUSLT;
8274 dgst_size = DGST_SIZE_4_8;
8275 parse_func = sha256s_parse_hash;
8276 sort_by_digest = sort_by_digest_4_8;
8277 opti_type = OPTI_TYPE_ZERO_BYTE
8278 | OPTI_TYPE_PRECOMPUTE_INIT
8279 | OPTI_TYPE_PRECOMPUTE_MERKLE
8280 | OPTI_TYPE_EARLY_SKIP
8281 | OPTI_TYPE_NOT_ITERATED
8282 | OPTI_TYPE_APPENDED_SALT
8283 | OPTI_TYPE_RAW_HASH;
8284 dgst_pos0 = 3;
8285 dgst_pos1 = 7;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 6;
8288 break;
8289
8290 case 1440: hash_type = HASH_TYPE_SHA256;
8291 salt_type = SALT_TYPE_INTERN;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_BE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS15
8296 | OPTS_TYPE_PT_UNICODE;
8297 kern_type = KERN_TYPE_SHA256_SLTPWU;
8298 dgst_size = DGST_SIZE_4_8;
8299 parse_func = sha256s_parse_hash;
8300 sort_by_digest = sort_by_digest_4_8;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP
8305 | OPTI_TYPE_NOT_ITERATED
8306 | OPTI_TYPE_PREPENDED_SALT
8307 | OPTI_TYPE_RAW_HASH;
8308 dgst_pos0 = 3;
8309 dgst_pos1 = 7;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 6;
8312 break;
8313
8314 case 1441: hash_type = HASH_TYPE_SHA256;
8315 salt_type = SALT_TYPE_EMBEDDED;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_BE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS15
8320 | OPTS_TYPE_PT_UNICODE
8321 | OPTS_TYPE_ST_BASE64;
8322 kern_type = KERN_TYPE_SHA256_SLTPWU;
8323 dgst_size = DGST_SIZE_4_8;
8324 parse_func = episerver4_parse_hash;
8325 sort_by_digest = sort_by_digest_4_8;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_PREPENDED_SALT
8332 | OPTI_TYPE_RAW_HASH;
8333 dgst_pos0 = 3;
8334 dgst_pos1 = 7;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 6;
8337 break;
8338
8339 case 1450: hash_type = HASH_TYPE_SHA256;
8340 salt_type = SALT_TYPE_INTERN;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_ST_ADD80;
8344 kern_type = KERN_TYPE_HMACSHA256_PW;
8345 dgst_size = DGST_SIZE_4_8;
8346 parse_func = hmacsha256_parse_hash;
8347 sort_by_digest = sort_by_digest_4_8;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_NOT_ITERATED;
8350 dgst_pos0 = 3;
8351 dgst_pos1 = 7;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 6;
8354 break;
8355
8356 case 1460: hash_type = HASH_TYPE_SHA256;
8357 salt_type = SALT_TYPE_INTERN;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_PT_ADD80
8361 | OPTS_TYPE_PT_ADDBITS15;
8362 kern_type = KERN_TYPE_HMACSHA256_SLT;
8363 dgst_size = DGST_SIZE_4_8;
8364 parse_func = hmacsha256_parse_hash;
8365 sort_by_digest = sort_by_digest_4_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_NOT_ITERATED;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 7;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 6;
8372 break;
8373
8374 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_BITSLICE;
8379 kern_type = KERN_TYPE_DESCRYPT;
8380 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8381 parse_func = descrypt_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 1600: hash_type = HASH_TYPE_MD5;
8392 salt_type = SALT_TYPE_EMBEDDED;
8393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8395 kern_type = KERN_TYPE_APR1CRYPT;
8396 dgst_size = DGST_SIZE_4_4;
8397 parse_func = md5apr1_parse_hash;
8398 sort_by_digest = sort_by_digest_4_4;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 1700: hash_type = HASH_TYPE_SHA512;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_BE
8410 | OPTS_TYPE_PT_ADD80
8411 | OPTS_TYPE_PT_ADDBITS15;
8412 kern_type = KERN_TYPE_SHA512;
8413 dgst_size = DGST_SIZE_8_8;
8414 parse_func = sha512_parse_hash;
8415 sort_by_digest = sort_by_digest_8_8;
8416 opti_type = OPTI_TYPE_ZERO_BYTE
8417 | OPTI_TYPE_PRECOMPUTE_INIT
8418 | OPTI_TYPE_PRECOMPUTE_MERKLE
8419 | OPTI_TYPE_EARLY_SKIP
8420 | OPTI_TYPE_NOT_ITERATED
8421 | OPTI_TYPE_NOT_SALTED
8422 | OPTI_TYPE_USES_BITS_64
8423 | OPTI_TYPE_RAW_HASH;
8424 dgst_pos0 = 14;
8425 dgst_pos1 = 15;
8426 dgst_pos2 = 6;
8427 dgst_pos3 = 7;
8428 break;
8429
8430 case 1710: hash_type = HASH_TYPE_SHA512;
8431 salt_type = SALT_TYPE_INTERN;
8432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8433 opts_type = OPTS_TYPE_PT_GENERATE_BE
8434 | OPTS_TYPE_ST_ADD80
8435 | OPTS_TYPE_ST_ADDBITS15;
8436 kern_type = KERN_TYPE_SHA512_PWSLT;
8437 dgst_size = DGST_SIZE_8_8;
8438 parse_func = sha512s_parse_hash;
8439 sort_by_digest = sort_by_digest_8_8;
8440 opti_type = OPTI_TYPE_ZERO_BYTE
8441 | OPTI_TYPE_PRECOMPUTE_INIT
8442 | OPTI_TYPE_PRECOMPUTE_MERKLE
8443 | OPTI_TYPE_EARLY_SKIP
8444 | OPTI_TYPE_NOT_ITERATED
8445 | OPTI_TYPE_APPENDED_SALT
8446 | OPTI_TYPE_USES_BITS_64
8447 | OPTI_TYPE_RAW_HASH;
8448 dgst_pos0 = 14;
8449 dgst_pos1 = 15;
8450 dgst_pos2 = 6;
8451 dgst_pos3 = 7;
8452 break;
8453
8454 case 1711: hash_type = HASH_TYPE_SHA512;
8455 salt_type = SALT_TYPE_EMBEDDED;
8456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8457 opts_type = OPTS_TYPE_PT_GENERATE_BE
8458 | OPTS_TYPE_ST_ADD80
8459 | OPTS_TYPE_ST_ADDBITS15;
8460 kern_type = KERN_TYPE_SHA512_PWSLT;
8461 dgst_size = DGST_SIZE_8_8;
8462 parse_func = sha512b64s_parse_hash;
8463 sort_by_digest = sort_by_digest_8_8;
8464 opti_type = OPTI_TYPE_ZERO_BYTE
8465 | OPTI_TYPE_PRECOMPUTE_INIT
8466 | OPTI_TYPE_PRECOMPUTE_MERKLE
8467 | OPTI_TYPE_EARLY_SKIP
8468 | OPTI_TYPE_NOT_ITERATED
8469 | OPTI_TYPE_APPENDED_SALT
8470 | OPTI_TYPE_USES_BITS_64
8471 | OPTI_TYPE_RAW_HASH;
8472 dgst_pos0 = 14;
8473 dgst_pos1 = 15;
8474 dgst_pos2 = 6;
8475 dgst_pos3 = 7;
8476 break;
8477
8478 case 1720: hash_type = HASH_TYPE_SHA512;
8479 salt_type = SALT_TYPE_INTERN;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_BE
8482 | OPTS_TYPE_PT_ADD80
8483 | OPTS_TYPE_PT_ADDBITS15;
8484 kern_type = KERN_TYPE_SHA512_SLTPW;
8485 dgst_size = DGST_SIZE_8_8;
8486 parse_func = sha512s_parse_hash;
8487 sort_by_digest = sort_by_digest_8_8;
8488 opti_type = OPTI_TYPE_ZERO_BYTE
8489 | OPTI_TYPE_PRECOMPUTE_INIT
8490 | OPTI_TYPE_PRECOMPUTE_MERKLE
8491 | OPTI_TYPE_EARLY_SKIP
8492 | OPTI_TYPE_NOT_ITERATED
8493 | OPTI_TYPE_PREPENDED_SALT
8494 | OPTI_TYPE_USES_BITS_64
8495 | OPTI_TYPE_RAW_HASH;
8496 dgst_pos0 = 14;
8497 dgst_pos1 = 15;
8498 dgst_pos2 = 6;
8499 dgst_pos3 = 7;
8500 break;
8501
8502 case 1722: hash_type = HASH_TYPE_SHA512;
8503 salt_type = SALT_TYPE_EMBEDDED;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_BE
8506 | OPTS_TYPE_PT_ADD80
8507 | OPTS_TYPE_PT_ADDBITS15
8508 | OPTS_TYPE_ST_HEX;
8509 kern_type = KERN_TYPE_SHA512_SLTPW;
8510 dgst_size = DGST_SIZE_8_8;
8511 parse_func = osx512_parse_hash;
8512 sort_by_digest = sort_by_digest_8_8;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP
8517 | OPTI_TYPE_NOT_ITERATED
8518 | OPTI_TYPE_PREPENDED_SALT
8519 | OPTI_TYPE_USES_BITS_64
8520 | OPTI_TYPE_RAW_HASH;
8521 dgst_pos0 = 14;
8522 dgst_pos1 = 15;
8523 dgst_pos2 = 6;
8524 dgst_pos3 = 7;
8525 break;
8526
8527 case 1730: hash_type = HASH_TYPE_SHA512;
8528 salt_type = SALT_TYPE_INTERN;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_UNICODE
8532 | OPTS_TYPE_ST_ADD80
8533 | OPTS_TYPE_ST_ADDBITS15;
8534 kern_type = KERN_TYPE_SHA512_PWSLTU;
8535 dgst_size = DGST_SIZE_8_8;
8536 parse_func = sha512s_parse_hash;
8537 sort_by_digest = sort_by_digest_8_8;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_PRECOMPUTE_MERKLE
8541 | OPTI_TYPE_EARLY_SKIP
8542 | OPTI_TYPE_NOT_ITERATED
8543 | OPTI_TYPE_APPENDED_SALT
8544 | OPTI_TYPE_USES_BITS_64
8545 | OPTI_TYPE_RAW_HASH;
8546 dgst_pos0 = 14;
8547 dgst_pos1 = 15;
8548 dgst_pos2 = 6;
8549 dgst_pos3 = 7;
8550 break;
8551
8552 case 1731: hash_type = HASH_TYPE_SHA512;
8553 salt_type = SALT_TYPE_EMBEDDED;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_BE
8556 | OPTS_TYPE_PT_UNICODE
8557 | OPTS_TYPE_ST_ADD80
8558 | OPTS_TYPE_ST_ADDBITS15
8559 | OPTS_TYPE_ST_HEX;
8560 kern_type = KERN_TYPE_SHA512_PWSLTU;
8561 dgst_size = DGST_SIZE_8_8;
8562 parse_func = mssql2012_parse_hash;
8563 sort_by_digest = sort_by_digest_8_8;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_PRECOMPUTE_MERKLE
8567 | OPTI_TYPE_EARLY_SKIP
8568 | OPTI_TYPE_NOT_ITERATED
8569 | OPTI_TYPE_APPENDED_SALT
8570 | OPTI_TYPE_USES_BITS_64
8571 | OPTI_TYPE_RAW_HASH;
8572 dgst_pos0 = 14;
8573 dgst_pos1 = 15;
8574 dgst_pos2 = 6;
8575 dgst_pos3 = 7;
8576 break;
8577
8578 case 1740: hash_type = HASH_TYPE_SHA512;
8579 salt_type = SALT_TYPE_INTERN;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_BE
8582 | OPTS_TYPE_PT_ADD80
8583 | OPTS_TYPE_PT_ADDBITS15
8584 | OPTS_TYPE_PT_UNICODE;
8585 kern_type = KERN_TYPE_SHA512_SLTPWU;
8586 dgst_size = DGST_SIZE_8_8;
8587 parse_func = sha512s_parse_hash;
8588 sort_by_digest = sort_by_digest_8_8;
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_PRECOMPUTE_INIT
8591 | OPTI_TYPE_PRECOMPUTE_MERKLE
8592 | OPTI_TYPE_EARLY_SKIP
8593 | OPTI_TYPE_NOT_ITERATED
8594 | OPTI_TYPE_PREPENDED_SALT
8595 | OPTI_TYPE_USES_BITS_64
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 14;
8598 dgst_pos1 = 15;
8599 dgst_pos2 = 6;
8600 dgst_pos3 = 7;
8601 break;
8602
8603 case 1750: hash_type = HASH_TYPE_SHA512;
8604 salt_type = SALT_TYPE_INTERN;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_BE
8607 | OPTS_TYPE_ST_ADD80;
8608 kern_type = KERN_TYPE_HMACSHA512_PW;
8609 dgst_size = DGST_SIZE_8_8;
8610 parse_func = hmacsha512_parse_hash;
8611 sort_by_digest = sort_by_digest_8_8;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_USES_BITS_64
8614 | OPTI_TYPE_NOT_ITERATED;
8615 dgst_pos0 = 14;
8616 dgst_pos1 = 15;
8617 dgst_pos2 = 6;
8618 dgst_pos3 = 7;
8619 break;
8620
8621 case 1760: hash_type = HASH_TYPE_SHA512;
8622 salt_type = SALT_TYPE_INTERN;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_BE
8625 | OPTS_TYPE_PT_ADD80
8626 | OPTS_TYPE_PT_ADDBITS15;
8627 kern_type = KERN_TYPE_HMACSHA512_SLT;
8628 dgst_size = DGST_SIZE_8_8;
8629 parse_func = hmacsha512_parse_hash;
8630 sort_by_digest = sort_by_digest_8_8;
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_USES_BITS_64
8633 | OPTI_TYPE_NOT_ITERATED;
8634 dgst_pos0 = 14;
8635 dgst_pos1 = 15;
8636 dgst_pos2 = 6;
8637 dgst_pos3 = 7;
8638 break;
8639
8640 case 1800: hash_type = HASH_TYPE_SHA512;
8641 salt_type = SALT_TYPE_EMBEDDED;
8642 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8643 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8644 kern_type = KERN_TYPE_SHA512CRYPT;
8645 dgst_size = DGST_SIZE_8_8;
8646 parse_func = sha512crypt_parse_hash;
8647 sort_by_digest = sort_by_digest_8_8;
8648 opti_type = OPTI_TYPE_ZERO_BYTE
8649 | OPTI_TYPE_USES_BITS_64;
8650 dgst_pos0 = 0;
8651 dgst_pos1 = 1;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 3;
8654 break;
8655
8656 case 2000: hash_type = HASH_TYPE_STDOUT;
8657 salt_type = SALT_TYPE_NONE;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8660 kern_type = 0;
8661 dgst_size = DGST_SIZE_4_4;
8662 parse_func = NULL;
8663 sort_by_digest = NULL;
8664 opti_type = 0;
8665 dgst_pos0 = 0;
8666 dgst_pos1 = 0;
8667 dgst_pos2 = 0;
8668 dgst_pos3 = 0;
8669 break;
8670
8671 case 2100: hash_type = HASH_TYPE_DCC2;
8672 salt_type = SALT_TYPE_EMBEDDED;
8673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8674 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8675 | OPTS_TYPE_ST_LOWER
8676 | OPTS_TYPE_ST_UNICODE;
8677 kern_type = KERN_TYPE_DCC2;
8678 dgst_size = DGST_SIZE_4_4;
8679 parse_func = dcc2_parse_hash;
8680 sort_by_digest = sort_by_digest_4_4;
8681 opti_type = OPTI_TYPE_ZERO_BYTE
8682 | OPTI_TYPE_SLOW_HASH_SIMD;
8683 dgst_pos0 = 0;
8684 dgst_pos1 = 1;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 3;
8687 break;
8688
8689 case 2400: hash_type = HASH_TYPE_MD5;
8690 salt_type = SALT_TYPE_NONE;
8691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8693 kern_type = KERN_TYPE_MD5PIX;
8694 dgst_size = DGST_SIZE_4_4;
8695 parse_func = md5pix_parse_hash;
8696 sort_by_digest = sort_by_digest_4_4;
8697 opti_type = OPTI_TYPE_ZERO_BYTE
8698 | OPTI_TYPE_PRECOMPUTE_INIT
8699 | OPTI_TYPE_PRECOMPUTE_MERKLE
8700 | OPTI_TYPE_EARLY_SKIP
8701 | OPTI_TYPE_NOT_ITERATED
8702 | OPTI_TYPE_NOT_SALTED;
8703 dgst_pos0 = 0;
8704 dgst_pos1 = 3;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 1;
8707 break;
8708
8709 case 2410: hash_type = HASH_TYPE_MD5;
8710 salt_type = SALT_TYPE_INTERN;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8713 kern_type = KERN_TYPE_MD5ASA;
8714 dgst_size = DGST_SIZE_4_4;
8715 parse_func = md5asa_parse_hash;
8716 sort_by_digest = sort_by_digest_4_4;
8717 opti_type = OPTI_TYPE_ZERO_BYTE
8718 | OPTI_TYPE_PRECOMPUTE_INIT
8719 | OPTI_TYPE_PRECOMPUTE_MERKLE
8720 | OPTI_TYPE_EARLY_SKIP
8721 | OPTI_TYPE_NOT_ITERATED;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 3;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 1;
8726 break;
8727
8728 case 2500: hash_type = HASH_TYPE_WPA;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8732 kern_type = KERN_TYPE_WPA;
8733 dgst_size = DGST_SIZE_4_4;
8734 parse_func = wpa_parse_hash;
8735 sort_by_digest = sort_by_digest_4_4;
8736 opti_type = OPTI_TYPE_ZERO_BYTE
8737 | OPTI_TYPE_SLOW_HASH_SIMD;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 2600: hash_type = HASH_TYPE_MD5;
8745 salt_type = SALT_TYPE_VIRTUAL;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14
8750 | OPTS_TYPE_ST_ADD80;
8751 kern_type = KERN_TYPE_MD55_PWSLT1;
8752 dgst_size = DGST_SIZE_4_4;
8753 parse_func = md5md5_parse_hash;
8754 sort_by_digest = sort_by_digest_4_4;
8755 opti_type = OPTI_TYPE_ZERO_BYTE
8756 | OPTI_TYPE_PRECOMPUTE_INIT
8757 | OPTI_TYPE_PRECOMPUTE_MERKLE
8758 | OPTI_TYPE_EARLY_SKIP;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 3;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 1;
8763 break;
8764
8765 case 2611: hash_type = HASH_TYPE_MD5;
8766 salt_type = SALT_TYPE_INTERN;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE
8769 | OPTS_TYPE_PT_ADD80
8770 | OPTS_TYPE_PT_ADDBITS14
8771 | OPTS_TYPE_ST_ADD80;
8772 kern_type = KERN_TYPE_MD55_PWSLT1;
8773 dgst_size = DGST_SIZE_4_4;
8774 parse_func = vb3_parse_hash;
8775 sort_by_digest = sort_by_digest_4_4;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_PRECOMPUTE_INIT
8778 | OPTI_TYPE_PRECOMPUTE_MERKLE
8779 | OPTI_TYPE_EARLY_SKIP;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 3;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 1;
8784 break;
8785
8786 case 2612: hash_type = HASH_TYPE_MD5;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE
8790 | OPTS_TYPE_PT_ADD80
8791 | OPTS_TYPE_PT_ADDBITS14
8792 | OPTS_TYPE_ST_ADD80
8793 | OPTS_TYPE_ST_HEX;
8794 kern_type = KERN_TYPE_MD55_PWSLT1;
8795 dgst_size = DGST_SIZE_4_4;
8796 parse_func = phps_parse_hash;
8797 sort_by_digest = sort_by_digest_4_4;
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_PRECOMPUTE_INIT
8800 | OPTI_TYPE_PRECOMPUTE_MERKLE
8801 | OPTI_TYPE_EARLY_SKIP;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 3;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 1;
8806 break;
8807
8808 case 2711: hash_type = HASH_TYPE_MD5;
8809 salt_type = SALT_TYPE_INTERN;
8810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE
8812 | OPTS_TYPE_PT_ADD80
8813 | OPTS_TYPE_PT_ADDBITS14
8814 | OPTS_TYPE_ST_ADD80;
8815 kern_type = KERN_TYPE_MD55_PWSLT2;
8816 dgst_size = DGST_SIZE_4_4;
8817 parse_func = vb30_parse_hash;
8818 sort_by_digest = sort_by_digest_4_4;
8819 opti_type = OPTI_TYPE_ZERO_BYTE
8820 | OPTI_TYPE_PRECOMPUTE_INIT
8821 | OPTI_TYPE_EARLY_SKIP;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 3;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 1;
8826 break;
8827
8828 case 2811: hash_type = HASH_TYPE_MD5;
8829 salt_type = SALT_TYPE_INTERN;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE
8832 | OPTS_TYPE_PT_ADD80
8833 | OPTS_TYPE_PT_ADDBITS14;
8834 kern_type = KERN_TYPE_MD55_SLTPW;
8835 dgst_size = DGST_SIZE_4_4;
8836 parse_func = ipb2_parse_hash;
8837 sort_by_digest = sort_by_digest_4_4;
8838 opti_type = OPTI_TYPE_ZERO_BYTE
8839 | OPTI_TYPE_PRECOMPUTE_INIT
8840 | OPTI_TYPE_EARLY_SKIP;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 3;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 1;
8845 break;
8846
8847 case 3000: hash_type = HASH_TYPE_LM;
8848 salt_type = SALT_TYPE_NONE;
8849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE
8851 | OPTS_TYPE_PT_UPPER
8852 | OPTS_TYPE_PT_BITSLICE;
8853 kern_type = KERN_TYPE_LM;
8854 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8855 parse_func = lm_parse_hash;
8856 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 3100: hash_type = HASH_TYPE_ORACLEH;
8866 salt_type = SALT_TYPE_INTERN;
8867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE
8869 | OPTS_TYPE_PT_UPPER
8870 | OPTS_TYPE_ST_UPPER;
8871 kern_type = KERN_TYPE_ORACLEH;
8872 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8873 parse_func = oracleh_parse_hash;
8874 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8875 opti_type = OPTI_TYPE_ZERO_BYTE;
8876 dgst_pos0 = 0;
8877 dgst_pos1 = 1;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 3;
8880 break;
8881
8882 case 3200: hash_type = HASH_TYPE_BCRYPT;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE
8886 | OPTS_TYPE_ST_GENERATE_LE;
8887 kern_type = KERN_TYPE_BCRYPT;
8888 dgst_size = DGST_SIZE_4_6;
8889 parse_func = bcrypt_parse_hash;
8890 sort_by_digest = sort_by_digest_4_6;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 3710: hash_type = HASH_TYPE_MD5;
8899 salt_type = SALT_TYPE_INTERN;
8900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE
8902 | OPTS_TYPE_PT_ADD80
8903 | OPTS_TYPE_PT_ADDBITS14;
8904 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8905 dgst_size = DGST_SIZE_4_4;
8906 parse_func = md5s_parse_hash;
8907 sort_by_digest = sort_by_digest_4_4;
8908 opti_type = OPTI_TYPE_ZERO_BYTE
8909 | OPTI_TYPE_PRECOMPUTE_INIT
8910 | OPTI_TYPE_PRECOMPUTE_MERKLE
8911 | OPTI_TYPE_EARLY_SKIP;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 3;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 1;
8916 break;
8917
8918 case 3711: hash_type = HASH_TYPE_MD5;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE
8922 | OPTS_TYPE_PT_ADD80
8923 | OPTS_TYPE_PT_ADDBITS14;
8924 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8925 dgst_size = DGST_SIZE_4_4;
8926 parse_func = mediawiki_b_parse_hash;
8927 sort_by_digest = sort_by_digest_4_4;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_PRECOMPUTE_INIT
8930 | OPTI_TYPE_PRECOMPUTE_MERKLE
8931 | OPTI_TYPE_EARLY_SKIP;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 3;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 1;
8936 break;
8937
8938 case 3800: hash_type = HASH_TYPE_MD5;
8939 salt_type = SALT_TYPE_INTERN;
8940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE
8942 | OPTS_TYPE_ST_ADDBITS14;
8943 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = md5s_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_INIT
8949 | OPTI_TYPE_PRECOMPUTE_MERKLE
8950 | OPTI_TYPE_EARLY_SKIP
8951 | OPTI_TYPE_NOT_ITERATED
8952 | OPTI_TYPE_RAW_HASH;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 3;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 1;
8957 break;
8958
8959 case 4300: hash_type = HASH_TYPE_MD5;
8960 salt_type = SALT_TYPE_VIRTUAL;
8961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE
8963 | OPTS_TYPE_PT_ADD80
8964 | OPTS_TYPE_PT_ADDBITS14
8965 | OPTS_TYPE_ST_ADD80;
8966 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8967 dgst_size = DGST_SIZE_4_4;
8968 parse_func = md5md5_parse_hash;
8969 sort_by_digest = sort_by_digest_4_4;
8970 opti_type = OPTI_TYPE_ZERO_BYTE
8971 | OPTI_TYPE_PRECOMPUTE_INIT
8972 | OPTI_TYPE_PRECOMPUTE_MERKLE
8973 | OPTI_TYPE_EARLY_SKIP;
8974 dgst_pos0 = 0;
8975 dgst_pos1 = 3;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 1;
8978 break;
8979
8980
8981 case 4400: hash_type = HASH_TYPE_MD5;
8982 salt_type = SALT_TYPE_NONE;
8983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_BE
8985 | OPTS_TYPE_PT_ADD80
8986 | OPTS_TYPE_PT_ADDBITS15;
8987 kern_type = KERN_TYPE_MD5_SHA1;
8988 dgst_size = DGST_SIZE_4_4;
8989 parse_func = md5_parse_hash;
8990 sort_by_digest = sort_by_digest_4_4;
8991 opti_type = OPTI_TYPE_ZERO_BYTE
8992 | OPTI_TYPE_PRECOMPUTE_INIT
8993 | OPTI_TYPE_PRECOMPUTE_MERKLE
8994 | OPTI_TYPE_EARLY_SKIP
8995 | OPTI_TYPE_NOT_ITERATED
8996 | OPTI_TYPE_NOT_SALTED
8997 | OPTI_TYPE_RAW_HASH;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 3;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 1;
9002 break;
9003
9004 case 4500: hash_type = HASH_TYPE_SHA1;
9005 salt_type = SALT_TYPE_NONE;
9006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_BE
9008 | OPTS_TYPE_PT_ADD80
9009 | OPTS_TYPE_PT_ADDBITS15;
9010 kern_type = KERN_TYPE_SHA11;
9011 dgst_size = DGST_SIZE_4_5;
9012 parse_func = sha1_parse_hash;
9013 sort_by_digest = sort_by_digest_4_5;
9014 opti_type = OPTI_TYPE_ZERO_BYTE
9015 | OPTI_TYPE_PRECOMPUTE_INIT
9016 | OPTI_TYPE_PRECOMPUTE_MERKLE
9017 | OPTI_TYPE_EARLY_SKIP
9018 | OPTI_TYPE_NOT_SALTED;
9019 dgst_pos0 = 3;
9020 dgst_pos1 = 4;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 1;
9023 break;
9024
9025 case 4700: hash_type = HASH_TYPE_SHA1;
9026 salt_type = SALT_TYPE_NONE;
9027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE
9029 | OPTS_TYPE_PT_ADD80
9030 | OPTS_TYPE_PT_ADDBITS14;
9031 kern_type = KERN_TYPE_SHA1_MD5;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = sha1_parse_hash;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE
9036 | OPTI_TYPE_PRECOMPUTE_INIT
9037 | OPTI_TYPE_PRECOMPUTE_MERKLE
9038 | OPTI_TYPE_EARLY_SKIP
9039 | OPTI_TYPE_NOT_ITERATED
9040 | OPTI_TYPE_NOT_SALTED
9041 | OPTI_TYPE_RAW_HASH;
9042 dgst_pos0 = 3;
9043 dgst_pos1 = 4;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 1;
9046 break;
9047
9048 case 4800: hash_type = HASH_TYPE_MD5;
9049 salt_type = SALT_TYPE_EMBEDDED;
9050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_LE
9052 | OPTS_TYPE_PT_ADDBITS14;
9053 kern_type = KERN_TYPE_MD5_CHAP;
9054 dgst_size = DGST_SIZE_4_4;
9055 parse_func = chap_parse_hash;
9056 sort_by_digest = sort_by_digest_4_4;
9057 opti_type = OPTI_TYPE_ZERO_BYTE
9058 | OPTI_TYPE_PRECOMPUTE_INIT
9059 | OPTI_TYPE_PRECOMPUTE_MERKLE
9060 | OPTI_TYPE_MEET_IN_MIDDLE
9061 | OPTI_TYPE_EARLY_SKIP
9062 | OPTI_TYPE_NOT_ITERATED
9063 | OPTI_TYPE_RAW_HASH;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 3;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 1;
9068 break;
9069
9070 case 4900: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_INTERN;
9072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9074 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9075 dgst_size = DGST_SIZE_4_5;
9076 parse_func = sha1s_parse_hash;
9077 sort_by_digest = sort_by_digest_4_5;
9078 opti_type = OPTI_TYPE_ZERO_BYTE
9079 | OPTI_TYPE_PRECOMPUTE_INIT
9080 | OPTI_TYPE_PRECOMPUTE_MERKLE
9081 | OPTI_TYPE_EARLY_SKIP;
9082 dgst_pos0 = 3;
9083 dgst_pos1 = 4;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 1;
9086 break;
9087
9088 case 5000: hash_type = HASH_TYPE_KECCAK;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE
9092 | OPTS_TYPE_PT_ADD01;
9093 kern_type = KERN_TYPE_KECCAK;
9094 dgst_size = DGST_SIZE_8_25;
9095 parse_func = keccak_parse_hash;
9096 sort_by_digest = sort_by_digest_8_25;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_USES_BITS_64
9099 | OPTI_TYPE_RAW_HASH;
9100 dgst_pos0 = 2;
9101 dgst_pos1 = 3;
9102 dgst_pos2 = 4;
9103 dgst_pos3 = 5;
9104 break;
9105
9106 case 5100: hash_type = HASH_TYPE_MD5H;
9107 salt_type = SALT_TYPE_NONE;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE
9110 | OPTS_TYPE_PT_ADD80
9111 | OPTS_TYPE_PT_ADDBITS14;
9112 kern_type = KERN_TYPE_MD5H;
9113 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9114 parse_func = md5half_parse_hash;
9115 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9116 opti_type = OPTI_TYPE_ZERO_BYTE
9117 | OPTI_TYPE_RAW_HASH;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 5200: hash_type = HASH_TYPE_SHA256;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9128 kern_type = KERN_TYPE_PSAFE3;
9129 dgst_size = DGST_SIZE_4_8;
9130 parse_func = psafe3_parse_hash;
9131 sort_by_digest = sort_by_digest_4_8;
9132 opti_type = OPTI_TYPE_ZERO_BYTE;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 5300: hash_type = HASH_TYPE_MD5;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE
9143 | OPTS_TYPE_ST_ADD80;
9144 kern_type = KERN_TYPE_IKEPSK_MD5;
9145 dgst_size = DGST_SIZE_4_4;
9146 parse_func = ikepsk_md5_parse_hash;
9147 sort_by_digest = sort_by_digest_4_4;
9148 opti_type = OPTI_TYPE_ZERO_BYTE;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 3;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 1;
9153 break;
9154
9155 case 5400: hash_type = HASH_TYPE_SHA1;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_BE
9159 | OPTS_TYPE_ST_ADD80;
9160 kern_type = KERN_TYPE_IKEPSK_SHA1;
9161 dgst_size = DGST_SIZE_4_5;
9162 parse_func = ikepsk_sha1_parse_hash;
9163 sort_by_digest = sort_by_digest_4_5;
9164 opti_type = OPTI_TYPE_ZERO_BYTE;
9165 dgst_pos0 = 3;
9166 dgst_pos1 = 4;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 1;
9169 break;
9170
9171 case 5500: hash_type = HASH_TYPE_NETNTLM;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE
9175 | OPTS_TYPE_PT_ADD80
9176 | OPTS_TYPE_PT_ADDBITS14
9177 | OPTS_TYPE_PT_UNICODE
9178 | OPTS_TYPE_ST_HEX;
9179 kern_type = KERN_TYPE_NETNTLMv1;
9180 dgst_size = DGST_SIZE_4_4;
9181 parse_func = netntlmv1_parse_hash;
9182 sort_by_digest = sort_by_digest_4_4;
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9185 dgst_pos0 = 0;
9186 dgst_pos1 = 1;
9187 dgst_pos2 = 2;
9188 dgst_pos3 = 3;
9189 break;
9190
9191 case 5600: hash_type = HASH_TYPE_MD5;
9192 salt_type = SALT_TYPE_EMBEDDED;
9193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9194 opts_type = OPTS_TYPE_PT_GENERATE_LE
9195 | OPTS_TYPE_PT_ADD80
9196 | OPTS_TYPE_PT_ADDBITS14
9197 | OPTS_TYPE_PT_UNICODE;
9198 kern_type = KERN_TYPE_NETNTLMv2;
9199 dgst_size = DGST_SIZE_4_4;
9200 parse_func = netntlmv2_parse_hash;
9201 sort_by_digest = sort_by_digest_4_4;
9202 opti_type = OPTI_TYPE_ZERO_BYTE;
9203 dgst_pos0 = 0;
9204 dgst_pos1 = 3;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 1;
9207 break;
9208
9209 case 5700: hash_type = HASH_TYPE_SHA256;
9210 salt_type = SALT_TYPE_NONE;
9211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9212 opts_type = OPTS_TYPE_PT_GENERATE_BE
9213 | OPTS_TYPE_PT_ADD80
9214 | OPTS_TYPE_PT_ADDBITS15;
9215 kern_type = KERN_TYPE_SHA256;
9216 dgst_size = DGST_SIZE_4_8;
9217 parse_func = cisco4_parse_hash;
9218 sort_by_digest = sort_by_digest_4_8;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_PRECOMPUTE_INIT
9221 | OPTI_TYPE_PRECOMPUTE_MERKLE
9222 | OPTI_TYPE_EARLY_SKIP
9223 | OPTI_TYPE_NOT_ITERATED
9224 | OPTI_TYPE_NOT_SALTED
9225 | OPTI_TYPE_RAW_HASH;
9226 dgst_pos0 = 3;
9227 dgst_pos1 = 7;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 6;
9230 break;
9231
9232 case 5800: hash_type = HASH_TYPE_SHA1;
9233 salt_type = SALT_TYPE_INTERN;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9236 | OPTS_TYPE_ST_ADD80;
9237 kern_type = KERN_TYPE_ANDROIDPIN;
9238 dgst_size = DGST_SIZE_4_5;
9239 parse_func = androidpin_parse_hash;
9240 sort_by_digest = sort_by_digest_4_5;
9241 opti_type = OPTI_TYPE_ZERO_BYTE;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9249 salt_type = SALT_TYPE_NONE;
9250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE
9252 | OPTS_TYPE_PT_ADD80;
9253 kern_type = KERN_TYPE_RIPEMD160;
9254 dgst_size = DGST_SIZE_4_5;
9255 parse_func = ripemd160_parse_hash;
9256 sort_by_digest = sort_by_digest_4_5;
9257 opti_type = OPTI_TYPE_ZERO_BYTE;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 1;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 3;
9262 break;
9263
9264 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9265 salt_type = SALT_TYPE_NONE;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE
9268 | OPTS_TYPE_PT_ADD80;
9269 kern_type = KERN_TYPE_WHIRLPOOL;
9270 dgst_size = DGST_SIZE_4_16;
9271 parse_func = whirlpool_parse_hash;
9272 sort_by_digest = sort_by_digest_4_16;
9273 opti_type = OPTI_TYPE_ZERO_BYTE;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9284 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = truecrypt_parse_hash_2k;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE;
9289 dgst_pos0 = 0;
9290 dgst_pos1 = 1;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 3;
9293 break;
9294
9295 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9299 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9300 dgst_size = DGST_SIZE_4_5;
9301 parse_func = truecrypt_parse_hash_2k;
9302 sort_by_digest = sort_by_digest_4_5;
9303 opti_type = OPTI_TYPE_ZERO_BYTE;
9304 dgst_pos0 = 0;
9305 dgst_pos1 = 1;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 3;
9308 break;
9309
9310 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9314 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9315 dgst_size = DGST_SIZE_4_5;
9316 parse_func = truecrypt_parse_hash_2k;
9317 sort_by_digest = sort_by_digest_4_5;
9318 opti_type = OPTI_TYPE_ZERO_BYTE;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 6221: hash_type = HASH_TYPE_SHA512;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_TCSHA512_XTS512;
9330 dgst_size = DGST_SIZE_8_8;
9331 parse_func = truecrypt_parse_hash_1k;
9332 sort_by_digest = sort_by_digest_8_8;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_USES_BITS_64;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 6222: hash_type = HASH_TYPE_SHA512;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9345 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9346 dgst_size = DGST_SIZE_8_8;
9347 parse_func = truecrypt_parse_hash_1k;
9348 sort_by_digest = sort_by_digest_8_8;
9349 opti_type = OPTI_TYPE_ZERO_BYTE
9350 | OPTI_TYPE_USES_BITS_64;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 6223: hash_type = HASH_TYPE_SHA512;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9361 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9362 dgst_size = DGST_SIZE_8_8;
9363 parse_func = truecrypt_parse_hash_1k;
9364 sort_by_digest = sort_by_digest_8_8;
9365 opti_type = OPTI_TYPE_ZERO_BYTE
9366 | OPTI_TYPE_USES_BITS_64;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9377 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9378 dgst_size = DGST_SIZE_4_8;
9379 parse_func = truecrypt_parse_hash_1k;
9380 sort_by_digest = sort_by_digest_4_8;
9381 opti_type = OPTI_TYPE_ZERO_BYTE;
9382 dgst_pos0 = 0;
9383 dgst_pos1 = 1;
9384 dgst_pos2 = 2;
9385 dgst_pos3 = 3;
9386 break;
9387
9388 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9389 salt_type = SALT_TYPE_EMBEDDED;
9390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9392 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9393 dgst_size = DGST_SIZE_4_8;
9394 parse_func = truecrypt_parse_hash_1k;
9395 sort_by_digest = sort_by_digest_4_8;
9396 opti_type = OPTI_TYPE_ZERO_BYTE;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9407 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9408 dgst_size = DGST_SIZE_4_8;
9409 parse_func = truecrypt_parse_hash_1k;
9410 sort_by_digest = sort_by_digest_4_8;
9411 opti_type = OPTI_TYPE_ZERO_BYTE;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9422 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9423 dgst_size = DGST_SIZE_4_5;
9424 parse_func = truecrypt_parse_hash_1k;
9425 sort_by_digest = sort_by_digest_4_5;
9426 opti_type = OPTI_TYPE_ZERO_BYTE;
9427 dgst_pos0 = 0;
9428 dgst_pos1 = 1;
9429 dgst_pos2 = 2;
9430 dgst_pos3 = 3;
9431 break;
9432
9433 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9434 salt_type = SALT_TYPE_EMBEDDED;
9435 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9436 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9437 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = truecrypt_parse_hash_1k;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE;
9442 dgst_pos0 = 0;
9443 dgst_pos1 = 1;
9444 dgst_pos2 = 2;
9445 dgst_pos3 = 3;
9446 break;
9447
9448 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9452 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9453 dgst_size = DGST_SIZE_4_5;
9454 parse_func = truecrypt_parse_hash_1k;
9455 sort_by_digest = sort_by_digest_4_5;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 6300: hash_type = HASH_TYPE_MD5;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_MD5AIX;
9468 dgst_size = DGST_SIZE_4_4;
9469 parse_func = md5aix_parse_hash;
9470 sort_by_digest = sort_by_digest_4_4;
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 6400: hash_type = HASH_TYPE_SHA256;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9482 kern_type = KERN_TYPE_SHA256AIX;
9483 dgst_size = DGST_SIZE_4_8;
9484 parse_func = sha256aix_parse_hash;
9485 sort_by_digest = sort_by_digest_4_8;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 6500: hash_type = HASH_TYPE_SHA512;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9497 kern_type = KERN_TYPE_SHA512AIX;
9498 dgst_size = DGST_SIZE_8_8;
9499 parse_func = sha512aix_parse_hash;
9500 sort_by_digest = sort_by_digest_8_8;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_USES_BITS_64;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 6600: hash_type = HASH_TYPE_AES;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9513 kern_type = KERN_TYPE_AGILEKEY;
9514 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9515 parse_func = agilekey_parse_hash;
9516 sort_by_digest = sort_by_digest_4_5;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 6700: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9528 kern_type = KERN_TYPE_SHA1AIX;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = sha1aix_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 6800: hash_type = HASH_TYPE_AES;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9543 kern_type = KERN_TYPE_LASTPASS;
9544 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9545 parse_func = lastpass_parse_hash;
9546 sort_by_digest = sort_by_digest_4_8;
9547 opti_type = OPTI_TYPE_ZERO_BYTE;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 1;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 3;
9552 break;
9553
9554 case 6900: hash_type = HASH_TYPE_GOST;
9555 salt_type = SALT_TYPE_NONE;
9556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9558 kern_type = KERN_TYPE_GOST;
9559 dgst_size = DGST_SIZE_4_8;
9560 parse_func = gost_parse_hash;
9561 sort_by_digest = sort_by_digest_4_8;
9562 opti_type = OPTI_TYPE_ZERO_BYTE;
9563 dgst_pos0 = 0;
9564 dgst_pos1 = 1;
9565 dgst_pos2 = 2;
9566 dgst_pos3 = 3;
9567 break;
9568
9569 case 7100: hash_type = HASH_TYPE_SHA512;
9570 salt_type = SALT_TYPE_EMBEDDED;
9571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9572 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9573 kern_type = KERN_TYPE_PBKDF2_SHA512;
9574 dgst_size = DGST_SIZE_8_16;
9575 parse_func = sha512osx_parse_hash;
9576 sort_by_digest = sort_by_digest_8_16;
9577 opti_type = OPTI_TYPE_ZERO_BYTE
9578 | OPTI_TYPE_USES_BITS_64
9579 | OPTI_TYPE_SLOW_HASH_SIMD;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 7200: hash_type = HASH_TYPE_SHA512;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9590 kern_type = KERN_TYPE_PBKDF2_SHA512;
9591 dgst_size = DGST_SIZE_8_16;
9592 parse_func = sha512grub_parse_hash;
9593 sort_by_digest = sort_by_digest_8_16;
9594 opti_type = OPTI_TYPE_ZERO_BYTE
9595 | OPTI_TYPE_USES_BITS_64
9596 | OPTI_TYPE_SLOW_HASH_SIMD;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 7300: hash_type = HASH_TYPE_SHA1;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_BE
9607 | OPTS_TYPE_ST_ADD80
9608 | OPTS_TYPE_ST_ADDBITS15;
9609 kern_type = KERN_TYPE_RAKP;
9610 dgst_size = DGST_SIZE_4_5;
9611 parse_func = rakp_parse_hash;
9612 sort_by_digest = sort_by_digest_4_5;
9613 opti_type = OPTI_TYPE_ZERO_BYTE
9614 | OPTI_TYPE_NOT_ITERATED;
9615 dgst_pos0 = 3;
9616 dgst_pos1 = 4;
9617 dgst_pos2 = 2;
9618 dgst_pos3 = 1;
9619 break;
9620
9621 case 7400: hash_type = HASH_TYPE_SHA256;
9622 salt_type = SALT_TYPE_EMBEDDED;
9623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9624 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9625 kern_type = KERN_TYPE_SHA256CRYPT;
9626 dgst_size = DGST_SIZE_4_8;
9627 parse_func = sha256crypt_parse_hash;
9628 sort_by_digest = sort_by_digest_4_8;
9629 opti_type = OPTI_TYPE_ZERO_BYTE;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 1;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 3;
9634 break;
9635
9636 case 7500: hash_type = HASH_TYPE_KRB5PA;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9640 kern_type = KERN_TYPE_KRB5PA;
9641 dgst_size = DGST_SIZE_4_4;
9642 parse_func = krb5pa_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4;
9644 opti_type = OPTI_TYPE_ZERO_BYTE
9645 | OPTI_TYPE_NOT_ITERATED;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 7600: hash_type = HASH_TYPE_SHA1;
9653 salt_type = SALT_TYPE_INTERN;
9654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_BE
9656 | OPTS_TYPE_PT_ADD80
9657 | OPTS_TYPE_PT_ADDBITS15;
9658 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9659 dgst_size = DGST_SIZE_4_5;
9660 parse_func = redmine_parse_hash;
9661 sort_by_digest = sort_by_digest_4_5;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_PRECOMPUTE_INIT
9664 | OPTI_TYPE_EARLY_SKIP
9665 | OPTI_TYPE_NOT_ITERATED
9666 | OPTI_TYPE_PREPENDED_SALT;
9667 dgst_pos0 = 3;
9668 dgst_pos1 = 4;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 1;
9671 break;
9672
9673 case 7700: hash_type = HASH_TYPE_SAPB;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_PT_UPPER
9678 | OPTS_TYPE_ST_UPPER;
9679 kern_type = KERN_TYPE_SAPB;
9680 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9681 parse_func = sapb_parse_hash;
9682 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9683 opti_type = OPTI_TYPE_ZERO_BYTE
9684 | OPTI_TYPE_PRECOMPUTE_INIT
9685 | OPTI_TYPE_NOT_ITERATED;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 7800: hash_type = HASH_TYPE_SAPG;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_BE
9696 | OPTS_TYPE_ST_ADD80
9697 | OPTS_TYPE_ST_UPPER;
9698 kern_type = KERN_TYPE_SAPG;
9699 dgst_size = DGST_SIZE_4_5;
9700 parse_func = sapg_parse_hash;
9701 sort_by_digest = sort_by_digest_4_5;
9702 opti_type = OPTI_TYPE_ZERO_BYTE
9703 | OPTI_TYPE_PRECOMPUTE_INIT
9704 | OPTI_TYPE_NOT_ITERATED;
9705 dgst_pos0 = 3;
9706 dgst_pos1 = 4;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 1;
9709 break;
9710
9711 case 7900: hash_type = HASH_TYPE_SHA512;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9715 kern_type = KERN_TYPE_DRUPAL7;
9716 dgst_size = DGST_SIZE_8_8;
9717 parse_func = drupal7_parse_hash;
9718 sort_by_digest = sort_by_digest_8_8;
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_USES_BITS_64;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 8000: hash_type = HASH_TYPE_SHA256;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_BE
9731 | OPTS_TYPE_PT_UNICODE
9732 | OPTS_TYPE_ST_ADD80
9733 | OPTS_TYPE_ST_HEX;
9734 kern_type = KERN_TYPE_SYBASEASE;
9735 dgst_size = DGST_SIZE_4_8;
9736 parse_func = sybasease_parse_hash;
9737 sort_by_digest = sort_by_digest_4_8;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_PRECOMPUTE_INIT
9740 | OPTI_TYPE_EARLY_SKIP
9741 | OPTI_TYPE_NOT_ITERATED
9742 | OPTI_TYPE_RAW_HASH;
9743 dgst_pos0 = 3;
9744 dgst_pos1 = 7;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 6;
9747 break;
9748
9749 case 8100: hash_type = HASH_TYPE_SHA1;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9753 kern_type = KERN_TYPE_NETSCALER;
9754 dgst_size = DGST_SIZE_4_5;
9755 parse_func = netscaler_parse_hash;
9756 sort_by_digest = sort_by_digest_4_5;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_PRECOMPUTE_INIT
9759 | OPTI_TYPE_PRECOMPUTE_MERKLE
9760 | OPTI_TYPE_EARLY_SKIP
9761 | OPTI_TYPE_NOT_ITERATED
9762 | OPTI_TYPE_PREPENDED_SALT
9763 | OPTI_TYPE_RAW_HASH;
9764 dgst_pos0 = 3;
9765 dgst_pos1 = 4;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 1;
9768 break;
9769
9770 case 8200: hash_type = HASH_TYPE_SHA256;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9774 kern_type = KERN_TYPE_CLOUDKEY;
9775 dgst_size = DGST_SIZE_4_8;
9776 parse_func = cloudkey_parse_hash;
9777 sort_by_digest = sort_by_digest_4_8;
9778 opti_type = OPTI_TYPE_ZERO_BYTE;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 8300: hash_type = HASH_TYPE_SHA1;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_BE
9789 | OPTS_TYPE_ST_HEX
9790 | OPTS_TYPE_ST_ADD80;
9791 kern_type = KERN_TYPE_NSEC3;
9792 dgst_size = DGST_SIZE_4_5;
9793 parse_func = nsec3_parse_hash;
9794 sort_by_digest = sort_by_digest_4_5;
9795 opti_type = OPTI_TYPE_ZERO_BYTE;
9796 dgst_pos0 = 3;
9797 dgst_pos1 = 4;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 1;
9800 break;
9801
9802 case 8400: hash_type = HASH_TYPE_SHA1;
9803 salt_type = SALT_TYPE_INTERN;
9804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_BE
9806 | OPTS_TYPE_PT_ADD80
9807 | OPTS_TYPE_PT_ADDBITS15;
9808 kern_type = KERN_TYPE_WBB3;
9809 dgst_size = DGST_SIZE_4_5;
9810 parse_func = wbb3_parse_hash;
9811 sort_by_digest = sort_by_digest_4_5;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_PRECOMPUTE_INIT
9814 | OPTI_TYPE_NOT_ITERATED;
9815 dgst_pos0 = 3;
9816 dgst_pos1 = 4;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 1;
9819 break;
9820
9821 case 8500: hash_type = HASH_TYPE_DESRACF;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_LE
9825 | OPTS_TYPE_ST_UPPER;
9826 kern_type = KERN_TYPE_RACF;
9827 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9828 parse_func = racf_parse_hash;
9829 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9830 opti_type = OPTI_TYPE_ZERO_BYTE
9831 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9832 dgst_pos0 = 0;
9833 dgst_pos1 = 1;
9834 dgst_pos2 = 2;
9835 dgst_pos3 = 3;
9836 break;
9837
9838 case 8600: hash_type = HASH_TYPE_LOTUS5;
9839 salt_type = SALT_TYPE_NONE;
9840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9841 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9842 kern_type = KERN_TYPE_LOTUS5;
9843 dgst_size = DGST_SIZE_4_4;
9844 parse_func = lotus5_parse_hash;
9845 sort_by_digest = sort_by_digest_4_4;
9846 opti_type = OPTI_TYPE_EARLY_SKIP
9847 | OPTI_TYPE_NOT_ITERATED
9848 | OPTI_TYPE_NOT_SALTED
9849 | OPTI_TYPE_RAW_HASH;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 1;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 3;
9854 break;
9855
9856 case 8700: hash_type = HASH_TYPE_LOTUS6;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9860 kern_type = KERN_TYPE_LOTUS6;
9861 dgst_size = DGST_SIZE_4_4;
9862 parse_func = lotus6_parse_hash;
9863 sort_by_digest = sort_by_digest_4_4;
9864 opti_type = OPTI_TYPE_EARLY_SKIP
9865 | OPTI_TYPE_NOT_ITERATED
9866 | OPTI_TYPE_RAW_HASH;
9867 dgst_pos0 = 0;
9868 dgst_pos1 = 1;
9869 dgst_pos2 = 2;
9870 dgst_pos3 = 3;
9871 break;
9872
9873 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9874 salt_type = SALT_TYPE_EMBEDDED;
9875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9877 kern_type = KERN_TYPE_ANDROIDFDE;
9878 dgst_size = DGST_SIZE_4_4;
9879 parse_func = androidfde_parse_hash;
9880 sort_by_digest = sort_by_digest_4_4;
9881 opti_type = OPTI_TYPE_ZERO_BYTE;
9882 dgst_pos0 = 0;
9883 dgst_pos1 = 1;
9884 dgst_pos2 = 2;
9885 dgst_pos3 = 3;
9886 break;
9887
9888 case 8900: hash_type = HASH_TYPE_SCRYPT;
9889 salt_type = SALT_TYPE_EMBEDDED;
9890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9891 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9892 kern_type = KERN_TYPE_SCRYPT;
9893 dgst_size = DGST_SIZE_4_8;
9894 parse_func = scrypt_parse_hash;
9895 sort_by_digest = sort_by_digest_4_8;
9896 opti_type = OPTI_TYPE_ZERO_BYTE;
9897 dgst_pos0 = 0;
9898 dgst_pos1 = 1;
9899 dgst_pos2 = 2;
9900 dgst_pos3 = 3;
9901 break;
9902
9903 case 9000: hash_type = HASH_TYPE_SHA1;
9904 salt_type = SALT_TYPE_EMBEDDED;
9905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9906 opts_type = OPTS_TYPE_PT_GENERATE_LE
9907 | OPTS_TYPE_ST_GENERATE_LE;
9908 kern_type = KERN_TYPE_PSAFE2;
9909 dgst_size = DGST_SIZE_4_5;
9910 parse_func = psafe2_parse_hash;
9911 sort_by_digest = sort_by_digest_4_5;
9912 opti_type = OPTI_TYPE_ZERO_BYTE;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 1;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 3;
9917 break;
9918
9919 case 9100: hash_type = HASH_TYPE_LOTUS8;
9920 salt_type = SALT_TYPE_EMBEDDED;
9921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9923 kern_type = KERN_TYPE_LOTUS8;
9924 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9925 parse_func = lotus8_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9927 opti_type = OPTI_TYPE_ZERO_BYTE;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 1;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 3;
9932 break;
9933
9934 case 9200: hash_type = HASH_TYPE_SHA256;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9938 kern_type = KERN_TYPE_PBKDF2_SHA256;
9939 dgst_size = DGST_SIZE_4_32;
9940 parse_func = cisco8_parse_hash;
9941 sort_by_digest = sort_by_digest_4_32;
9942 opti_type = OPTI_TYPE_ZERO_BYTE
9943 | OPTI_TYPE_SLOW_HASH_SIMD;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 9300: hash_type = HASH_TYPE_SCRYPT;
9951 salt_type = SALT_TYPE_EMBEDDED;
9952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9954 kern_type = KERN_TYPE_SCRYPT;
9955 dgst_size = DGST_SIZE_4_8;
9956 parse_func = cisco9_parse_hash;
9957 sort_by_digest = sort_by_digest_4_8;
9958 opti_type = OPTI_TYPE_ZERO_BYTE;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9969 kern_type = KERN_TYPE_OFFICE2007;
9970 dgst_size = DGST_SIZE_4_4;
9971 parse_func = office2007_parse_hash;
9972 sort_by_digest = sort_by_digest_4_4;
9973 opti_type = OPTI_TYPE_ZERO_BYTE;
9974 dgst_pos0 = 0;
9975 dgst_pos1 = 1;
9976 dgst_pos2 = 2;
9977 dgst_pos3 = 3;
9978 break;
9979
9980 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9981 salt_type = SALT_TYPE_EMBEDDED;
9982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9983 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9984 kern_type = KERN_TYPE_OFFICE2010;
9985 dgst_size = DGST_SIZE_4_4;
9986 parse_func = office2010_parse_hash;
9987 sort_by_digest = sort_by_digest_4_4;
9988 opti_type = OPTI_TYPE_ZERO_BYTE;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9999 kern_type = KERN_TYPE_OFFICE2013;
10000 dgst_size = DGST_SIZE_4_4;
10001 parse_func = office2013_parse_hash;
10002 sort_by_digest = sort_by_digest_4_4;
10003 opti_type = OPTI_TYPE_ZERO_BYTE;
10004 dgst_pos0 = 0;
10005 dgst_pos1 = 1;
10006 dgst_pos2 = 2;
10007 dgst_pos3 = 3;
10008 break;
10009
10010 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10011 salt_type = SALT_TYPE_EMBEDDED;
10012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10013 opts_type = OPTS_TYPE_PT_GENERATE_LE
10014 | OPTS_TYPE_PT_ADD80
10015 | OPTS_TYPE_PT_UNICODE;
10016 kern_type = KERN_TYPE_OLDOFFICE01;
10017 dgst_size = DGST_SIZE_4_4;
10018 parse_func = oldoffice01_parse_hash;
10019 sort_by_digest = sort_by_digest_4_4;
10020 opti_type = OPTI_TYPE_ZERO_BYTE
10021 | OPTI_TYPE_PRECOMPUTE_INIT
10022 | OPTI_TYPE_NOT_ITERATED;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE
10033 | OPTS_TYPE_PT_ADD80;
10034 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10035 dgst_size = DGST_SIZE_4_4;
10036 parse_func = oldoffice01cm1_parse_hash;
10037 sort_by_digest = sort_by_digest_4_4;
10038 opti_type = OPTI_TYPE_ZERO_BYTE
10039 | OPTI_TYPE_PRECOMPUTE_INIT
10040 | OPTI_TYPE_NOT_ITERATED;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE
10051 | OPTS_TYPE_PT_ADD80
10052 | OPTS_TYPE_PT_UNICODE
10053 | OPTS_TYPE_PT_NEVERCRACK;
10054 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10055 dgst_size = DGST_SIZE_4_4;
10056 parse_func = oldoffice01cm2_parse_hash;
10057 sort_by_digest = sort_by_digest_4_4;
10058 opti_type = OPTI_TYPE_ZERO_BYTE
10059 | OPTI_TYPE_PRECOMPUTE_INIT
10060 | OPTI_TYPE_NOT_ITERATED;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_BE
10071 | OPTS_TYPE_PT_ADD80
10072 | OPTS_TYPE_PT_UNICODE;
10073 kern_type = KERN_TYPE_OLDOFFICE34;
10074 dgst_size = DGST_SIZE_4_4;
10075 parse_func = oldoffice34_parse_hash;
10076 sort_by_digest = sort_by_digest_4_4;
10077 opti_type = OPTI_TYPE_ZERO_BYTE
10078 | OPTI_TYPE_PRECOMPUTE_INIT
10079 | OPTI_TYPE_NOT_ITERATED;
10080 dgst_pos0 = 0;
10081 dgst_pos1 = 1;
10082 dgst_pos2 = 2;
10083 dgst_pos3 = 3;
10084 break;
10085
10086 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10087 salt_type = SALT_TYPE_EMBEDDED;
10088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10090 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10091 dgst_size = DGST_SIZE_4_4;
10092 parse_func = oldoffice34cm1_parse_hash;
10093 sort_by_digest = sort_by_digest_4_4;
10094 opti_type = OPTI_TYPE_ZERO_BYTE
10095 | OPTI_TYPE_PRECOMPUTE_INIT
10096 | OPTI_TYPE_NOT_ITERATED;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_BE
10107 | OPTS_TYPE_PT_ADD80
10108 | OPTS_TYPE_PT_UNICODE
10109 | OPTS_TYPE_PT_NEVERCRACK;
10110 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10111 dgst_size = DGST_SIZE_4_4;
10112 parse_func = oldoffice34cm2_parse_hash;
10113 sort_by_digest = sort_by_digest_4_4;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_PRECOMPUTE_INIT
10116 | OPTI_TYPE_NOT_ITERATED;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 9900: hash_type = HASH_TYPE_MD5;
10124 salt_type = SALT_TYPE_NONE;
10125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10127 kern_type = KERN_TYPE_RADMIN2;
10128 dgst_size = DGST_SIZE_4_4;
10129 parse_func = radmin2_parse_hash;
10130 sort_by_digest = sort_by_digest_4_4;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_PRECOMPUTE_INIT
10133 | OPTI_TYPE_EARLY_SKIP
10134 | OPTI_TYPE_NOT_ITERATED
10135 | OPTI_TYPE_NOT_SALTED;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 3;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 1;
10140 break;
10141
10142 case 10000: hash_type = HASH_TYPE_SHA256;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10146 kern_type = KERN_TYPE_PBKDF2_SHA256;
10147 dgst_size = DGST_SIZE_4_32;
10148 parse_func = djangopbkdf2_parse_hash;
10149 sort_by_digest = sort_by_digest_4_32;
10150 opti_type = OPTI_TYPE_ZERO_BYTE
10151 | OPTI_TYPE_SLOW_HASH_SIMD;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 10100: hash_type = HASH_TYPE_SIPHASH;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10162 kern_type = KERN_TYPE_SIPHASH;
10163 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10164 parse_func = siphash_parse_hash;
10165 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10166 opti_type = OPTI_TYPE_ZERO_BYTE
10167 | OPTI_TYPE_NOT_ITERATED
10168 | OPTI_TYPE_RAW_HASH;
10169 dgst_pos0 = 0;
10170 dgst_pos1 = 1;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 3;
10173 break;
10174
10175 case 10200: hash_type = HASH_TYPE_MD5;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE
10179 | OPTS_TYPE_ST_ADD80
10180 | OPTS_TYPE_ST_ADDBITS14;
10181 kern_type = KERN_TYPE_HMACMD5_PW;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = crammd5_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE
10186 | OPTI_TYPE_NOT_ITERATED;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 3;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 1;
10191 break;
10192
10193 case 10300: hash_type = HASH_TYPE_SHA1;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10197 kern_type = KERN_TYPE_SAPH_SHA1;
10198 dgst_size = DGST_SIZE_4_5;
10199 parse_func = saph_sha1_parse_hash;
10200 sort_by_digest = sort_by_digest_4_5;
10201 opti_type = OPTI_TYPE_ZERO_BYTE;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 10400: hash_type = HASH_TYPE_PDFU16;
10209 salt_type = SALT_TYPE_EMBEDDED;
10210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10212 kern_type = KERN_TYPE_PDF11;
10213 dgst_size = DGST_SIZE_4_4;
10214 parse_func = pdf11_parse_hash;
10215 sort_by_digest = sort_by_digest_4_4;
10216 opti_type = OPTI_TYPE_ZERO_BYTE
10217 | OPTI_TYPE_NOT_ITERATED;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 10410: hash_type = HASH_TYPE_PDFU16;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10228 kern_type = KERN_TYPE_PDF11CM1;
10229 dgst_size = DGST_SIZE_4_4;
10230 parse_func = pdf11cm1_parse_hash;
10231 sort_by_digest = sort_by_digest_4_4;
10232 opti_type = OPTI_TYPE_ZERO_BYTE
10233 | OPTI_TYPE_NOT_ITERATED;
10234 dgst_pos0 = 0;
10235 dgst_pos1 = 1;
10236 dgst_pos2 = 2;
10237 dgst_pos3 = 3;
10238 break;
10239
10240 case 10420: hash_type = HASH_TYPE_PDFU16;
10241 salt_type = SALT_TYPE_EMBEDDED;
10242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10244 kern_type = KERN_TYPE_PDF11CM2;
10245 dgst_size = DGST_SIZE_4_4;
10246 parse_func = pdf11cm2_parse_hash;
10247 sort_by_digest = sort_by_digest_4_4;
10248 opti_type = OPTI_TYPE_ZERO_BYTE
10249 | OPTI_TYPE_NOT_ITERATED;
10250 dgst_pos0 = 0;
10251 dgst_pos1 = 1;
10252 dgst_pos2 = 2;
10253 dgst_pos3 = 3;
10254 break;
10255
10256 case 10500: hash_type = HASH_TYPE_PDFU16;
10257 salt_type = SALT_TYPE_EMBEDDED;
10258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10260 kern_type = KERN_TYPE_PDF14;
10261 dgst_size = DGST_SIZE_4_4;
10262 parse_func = pdf14_parse_hash;
10263 sort_by_digest = sort_by_digest_4_4;
10264 opti_type = OPTI_TYPE_ZERO_BYTE
10265 | OPTI_TYPE_NOT_ITERATED;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 1;
10268 dgst_pos2 = 2;
10269 dgst_pos3 = 3;
10270 break;
10271
10272 case 10600: hash_type = HASH_TYPE_SHA256;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_BE
10276 | OPTS_TYPE_ST_ADD80
10277 | OPTS_TYPE_ST_ADDBITS15
10278 | OPTS_TYPE_HASH_COPY;
10279 kern_type = KERN_TYPE_SHA256_PWSLT;
10280 dgst_size = DGST_SIZE_4_8;
10281 parse_func = pdf17l3_parse_hash;
10282 sort_by_digest = sort_by_digest_4_8;
10283 opti_type = OPTI_TYPE_ZERO_BYTE
10284 | OPTI_TYPE_PRECOMPUTE_INIT
10285 | OPTI_TYPE_PRECOMPUTE_MERKLE
10286 | OPTI_TYPE_EARLY_SKIP
10287 | OPTI_TYPE_NOT_ITERATED
10288 | OPTI_TYPE_APPENDED_SALT
10289 | OPTI_TYPE_RAW_HASH;
10290 dgst_pos0 = 3;
10291 dgst_pos1 = 7;
10292 dgst_pos2 = 2;
10293 dgst_pos3 = 6;
10294 break;
10295
10296 case 10700: hash_type = HASH_TYPE_PDFU32;
10297 salt_type = SALT_TYPE_EMBEDDED;
10298 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10299 opts_type = OPTS_TYPE_PT_GENERATE_LE
10300 | OPTS_TYPE_HASH_COPY;
10301 kern_type = KERN_TYPE_PDF17L8;
10302 dgst_size = DGST_SIZE_4_8;
10303 parse_func = pdf17l8_parse_hash;
10304 sort_by_digest = sort_by_digest_4_8;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_NOT_ITERATED;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 case 10800: hash_type = HASH_TYPE_SHA384;
10314 salt_type = SALT_TYPE_NONE;
10315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_BE
10317 | OPTS_TYPE_PT_ADD80
10318 | OPTS_TYPE_PT_ADDBITS15;
10319 kern_type = KERN_TYPE_SHA384;
10320 dgst_size = DGST_SIZE_8_8;
10321 parse_func = sha384_parse_hash;
10322 sort_by_digest = sort_by_digest_8_8;
10323 opti_type = OPTI_TYPE_ZERO_BYTE
10324 | OPTI_TYPE_PRECOMPUTE_INIT
10325 | OPTI_TYPE_PRECOMPUTE_MERKLE
10326 | OPTI_TYPE_EARLY_SKIP
10327 | OPTI_TYPE_NOT_ITERATED
10328 | OPTI_TYPE_NOT_SALTED
10329 | OPTI_TYPE_USES_BITS_64
10330 | OPTI_TYPE_RAW_HASH;
10331 dgst_pos0 = 6;
10332 dgst_pos1 = 7;
10333 dgst_pos2 = 4;
10334 dgst_pos3 = 5;
10335 break;
10336
10337 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10338 salt_type = SALT_TYPE_EMBEDDED;
10339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10340 opts_type = OPTS_TYPE_PT_GENERATE_LE
10341 | OPTS_TYPE_ST_BASE64
10342 | OPTS_TYPE_HASH_COPY;
10343 kern_type = KERN_TYPE_PBKDF2_SHA256;
10344 dgst_size = DGST_SIZE_4_32;
10345 parse_func = pbkdf2_sha256_parse_hash;
10346 sort_by_digest = sort_by_digest_4_32;
10347 opti_type = OPTI_TYPE_ZERO_BYTE
10348 | OPTI_TYPE_SLOW_HASH_SIMD;
10349 dgst_pos0 = 0;
10350 dgst_pos1 = 1;
10351 dgst_pos2 = 2;
10352 dgst_pos3 = 3;
10353 break;
10354
10355 case 11000: hash_type = HASH_TYPE_MD5;
10356 salt_type = SALT_TYPE_INTERN;
10357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10358 opts_type = OPTS_TYPE_PT_GENERATE_LE
10359 | OPTS_TYPE_PT_ADD80;
10360 kern_type = KERN_TYPE_PRESTASHOP;
10361 dgst_size = DGST_SIZE_4_4;
10362 parse_func = prestashop_parse_hash;
10363 sort_by_digest = sort_by_digest_4_4;
10364 opti_type = OPTI_TYPE_ZERO_BYTE
10365 | OPTI_TYPE_PRECOMPUTE_INIT
10366 | OPTI_TYPE_NOT_ITERATED
10367 | OPTI_TYPE_PREPENDED_SALT;
10368 dgst_pos0 = 0;
10369 dgst_pos1 = 3;
10370 dgst_pos2 = 2;
10371 dgst_pos3 = 1;
10372 break;
10373
10374 case 11100: hash_type = HASH_TYPE_MD5;
10375 salt_type = SALT_TYPE_EMBEDDED;
10376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10377 opts_type = OPTS_TYPE_PT_GENERATE_LE
10378 | OPTS_TYPE_ST_ADD80;
10379 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10380 dgst_size = DGST_SIZE_4_4;
10381 parse_func = postgresql_auth_parse_hash;
10382 sort_by_digest = sort_by_digest_4_4;
10383 opti_type = OPTI_TYPE_ZERO_BYTE
10384 | OPTI_TYPE_PRECOMPUTE_INIT
10385 | OPTI_TYPE_PRECOMPUTE_MERKLE
10386 | OPTI_TYPE_EARLY_SKIP;
10387 dgst_pos0 = 0;
10388 dgst_pos1 = 3;
10389 dgst_pos2 = 2;
10390 dgst_pos3 = 1;
10391 break;
10392
10393 case 11200: hash_type = HASH_TYPE_SHA1;
10394 salt_type = SALT_TYPE_EMBEDDED;
10395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10396 opts_type = OPTS_TYPE_PT_GENERATE_BE
10397 | OPTS_TYPE_PT_ADD80
10398 | OPTS_TYPE_ST_HEX;
10399 kern_type = KERN_TYPE_MYSQL_AUTH;
10400 dgst_size = DGST_SIZE_4_5;
10401 parse_func = mysql_auth_parse_hash;
10402 sort_by_digest = sort_by_digest_4_5;
10403 opti_type = OPTI_TYPE_ZERO_BYTE
10404 | OPTI_TYPE_EARLY_SKIP;
10405 dgst_pos0 = 3;
10406 dgst_pos1 = 4;
10407 dgst_pos2 = 2;
10408 dgst_pos3 = 1;
10409 break;
10410
10411 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10412 salt_type = SALT_TYPE_EMBEDDED;
10413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10414 opts_type = OPTS_TYPE_PT_GENERATE_LE
10415 | OPTS_TYPE_ST_HEX
10416 | OPTS_TYPE_ST_ADD80;
10417 kern_type = KERN_TYPE_BITCOIN_WALLET;
10418 dgst_size = DGST_SIZE_4_4;
10419 parse_func = bitcoin_wallet_parse_hash;
10420 sort_by_digest = sort_by_digest_4_4;
10421 opti_type = OPTI_TYPE_ZERO_BYTE;
10422 dgst_pos0 = 0;
10423 dgst_pos1 = 1;
10424 dgst_pos2 = 2;
10425 dgst_pos3 = 3;
10426 break;
10427
10428 case 11400: hash_type = HASH_TYPE_MD5;
10429 salt_type = SALT_TYPE_EMBEDDED;
10430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE
10432 | OPTS_TYPE_PT_ADD80
10433 | OPTS_TYPE_HASH_COPY;
10434 kern_type = KERN_TYPE_SIP_AUTH;
10435 dgst_size = DGST_SIZE_4_4;
10436 parse_func = sip_auth_parse_hash;
10437 sort_by_digest = sort_by_digest_4_4;
10438 opti_type = OPTI_TYPE_ZERO_BYTE;
10439 dgst_pos0 = 0;
10440 dgst_pos1 = 3;
10441 dgst_pos2 = 2;
10442 dgst_pos3 = 1;
10443 break;
10444
10445 case 11500: hash_type = HASH_TYPE_CRC32;
10446 salt_type = SALT_TYPE_INTERN;
10447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10448 opts_type = OPTS_TYPE_PT_GENERATE_LE
10449 | OPTS_TYPE_ST_GENERATE_LE
10450 | OPTS_TYPE_ST_HEX;
10451 kern_type = KERN_TYPE_CRC32;
10452 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10453 parse_func = crc32_parse_hash;
10454 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10455 opti_type = OPTI_TYPE_ZERO_BYTE;
10456 dgst_pos0 = 0;
10457 dgst_pos1 = 1;
10458 dgst_pos2 = 2;
10459 dgst_pos3 = 3;
10460 break;
10461
10462 case 11600: hash_type = HASH_TYPE_AES;
10463 salt_type = SALT_TYPE_EMBEDDED;
10464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10465 opts_type = OPTS_TYPE_PT_GENERATE_LE
10466 | OPTS_TYPE_PT_NEVERCRACK;
10467 kern_type = KERN_TYPE_SEVEN_ZIP;
10468 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10469 parse_func = seven_zip_parse_hash;
10470 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10471 opti_type = OPTI_TYPE_ZERO_BYTE;
10472 dgst_pos0 = 0;
10473 dgst_pos1 = 1;
10474 dgst_pos2 = 2;
10475 dgst_pos3 = 3;
10476 break;
10477
10478 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10479 salt_type = SALT_TYPE_NONE;
10480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10481 opts_type = OPTS_TYPE_PT_GENERATE_LE
10482 | OPTS_TYPE_PT_ADD01;
10483 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10484 dgst_size = DGST_SIZE_4_8;
10485 parse_func = gost2012sbog_256_parse_hash;
10486 sort_by_digest = sort_by_digest_4_8;
10487 opti_type = OPTI_TYPE_ZERO_BYTE;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 1;
10490 dgst_pos2 = 2;
10491 dgst_pos3 = 3;
10492 break;
10493
10494 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10495 salt_type = SALT_TYPE_NONE;
10496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_LE
10498 | OPTS_TYPE_PT_ADD01;
10499 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10500 dgst_size = DGST_SIZE_4_16;
10501 parse_func = gost2012sbog_512_parse_hash;
10502 sort_by_digest = sort_by_digest_4_16;
10503 opti_type = OPTI_TYPE_ZERO_BYTE;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 1;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 3;
10508 break;
10509
10510 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10511 salt_type = SALT_TYPE_EMBEDDED;
10512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_LE
10514 | OPTS_TYPE_ST_BASE64
10515 | OPTS_TYPE_HASH_COPY;
10516 kern_type = KERN_TYPE_PBKDF2_MD5;
10517 dgst_size = DGST_SIZE_4_32;
10518 parse_func = pbkdf2_md5_parse_hash;
10519 sort_by_digest = sort_by_digest_4_32;
10520 opti_type = OPTI_TYPE_ZERO_BYTE
10521 | OPTI_TYPE_SLOW_HASH_SIMD;
10522 dgst_pos0 = 0;
10523 dgst_pos1 = 1;
10524 dgst_pos2 = 2;
10525 dgst_pos3 = 3;
10526 break;
10527
10528 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10529 salt_type = SALT_TYPE_EMBEDDED;
10530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10531 opts_type = OPTS_TYPE_PT_GENERATE_LE
10532 | OPTS_TYPE_ST_BASE64
10533 | OPTS_TYPE_HASH_COPY;
10534 kern_type = KERN_TYPE_PBKDF2_SHA1;
10535 dgst_size = DGST_SIZE_4_32;
10536 parse_func = pbkdf2_sha1_parse_hash;
10537 sort_by_digest = sort_by_digest_4_32;
10538 opti_type = OPTI_TYPE_ZERO_BYTE
10539 | OPTI_TYPE_SLOW_HASH_SIMD;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE
10550 | OPTS_TYPE_ST_BASE64
10551 | OPTS_TYPE_HASH_COPY;
10552 kern_type = KERN_TYPE_PBKDF2_SHA512;
10553 dgst_size = DGST_SIZE_8_16;
10554 parse_func = pbkdf2_sha512_parse_hash;
10555 sort_by_digest = sort_by_digest_8_16;
10556 opti_type = OPTI_TYPE_ZERO_BYTE
10557 | OPTI_TYPE_USES_BITS_64
10558 | OPTI_TYPE_SLOW_HASH_SIMD;
10559 dgst_pos0 = 0;
10560 dgst_pos1 = 1;
10561 dgst_pos2 = 2;
10562 dgst_pos3 = 3;
10563 break;
10564
10565 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10566 salt_type = SALT_TYPE_EMBEDDED;
10567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10568 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10569 kern_type = KERN_TYPE_ECRYPTFS;
10570 dgst_size = DGST_SIZE_8_8;
10571 parse_func = ecryptfs_parse_hash;
10572 sort_by_digest = sort_by_digest_8_8;
10573 opti_type = OPTI_TYPE_ZERO_BYTE
10574 | OPTI_TYPE_USES_BITS_64;
10575 dgst_pos0 = 0;
10576 dgst_pos1 = 1;
10577 dgst_pos2 = 2;
10578 dgst_pos3 = 3;
10579 break;
10580
10581 case 12300: hash_type = HASH_TYPE_ORACLET;
10582 salt_type = SALT_TYPE_EMBEDDED;
10583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10585 kern_type = KERN_TYPE_ORACLET;
10586 dgst_size = DGST_SIZE_8_16;
10587 parse_func = oraclet_parse_hash;
10588 sort_by_digest = sort_by_digest_8_16;
10589 opti_type = OPTI_TYPE_ZERO_BYTE
10590 | OPTI_TYPE_USES_BITS_64;
10591 dgst_pos0 = 0;
10592 dgst_pos1 = 1;
10593 dgst_pos2 = 2;
10594 dgst_pos3 = 3;
10595 break;
10596
10597 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10598 salt_type = SALT_TYPE_EMBEDDED;
10599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10601 kern_type = KERN_TYPE_BSDICRYPT;
10602 dgst_size = DGST_SIZE_4_4;
10603 parse_func = bsdicrypt_parse_hash;
10604 sort_by_digest = sort_by_digest_4_4;
10605 opti_type = OPTI_TYPE_ZERO_BYTE
10606 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10607 dgst_pos0 = 0;
10608 dgst_pos1 = 1;
10609 dgst_pos2 = 2;
10610 dgst_pos3 = 3;
10611 break;
10612
10613 case 12500: hash_type = HASH_TYPE_RAR3HP;
10614 salt_type = SALT_TYPE_EMBEDDED;
10615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10617 kern_type = KERN_TYPE_RAR3;
10618 dgst_size = DGST_SIZE_4_4;
10619 parse_func = rar3hp_parse_hash;
10620 sort_by_digest = sort_by_digest_4_4;
10621 opti_type = OPTI_TYPE_ZERO_BYTE;
10622 dgst_pos0 = 0;
10623 dgst_pos1 = 1;
10624 dgst_pos2 = 2;
10625 dgst_pos3 = 3;
10626 break;
10627
10628 case 12600: hash_type = HASH_TYPE_SHA256;
10629 salt_type = SALT_TYPE_INTERN;
10630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10631 opts_type = OPTS_TYPE_PT_GENERATE_BE
10632 | OPTS_TYPE_PT_ADD80;
10633 kern_type = KERN_TYPE_CF10;
10634 dgst_size = DGST_SIZE_4_8;
10635 parse_func = cf10_parse_hash;
10636 sort_by_digest = sort_by_digest_4_8;
10637 opti_type = OPTI_TYPE_ZERO_BYTE
10638 | OPTI_TYPE_PRECOMPUTE_INIT
10639 | OPTI_TYPE_EARLY_SKIP
10640 | OPTI_TYPE_NOT_ITERATED;
10641 dgst_pos0 = 3;
10642 dgst_pos1 = 7;
10643 dgst_pos2 = 2;
10644 dgst_pos3 = 6;
10645 break;
10646
10647 case 12700: hash_type = HASH_TYPE_AES;
10648 salt_type = SALT_TYPE_EMBEDDED;
10649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10650 opts_type = OPTS_TYPE_PT_GENERATE_LE
10651 | OPTS_TYPE_HASH_COPY;
10652 kern_type = KERN_TYPE_MYWALLET;
10653 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10654 parse_func = mywallet_parse_hash;
10655 sort_by_digest = sort_by_digest_4_5;
10656 opti_type = OPTI_TYPE_ZERO_BYTE;
10657 dgst_pos0 = 0;
10658 dgst_pos1 = 1;
10659 dgst_pos2 = 2;
10660 dgst_pos3 = 3;
10661 break;
10662
10663 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10664 salt_type = SALT_TYPE_EMBEDDED;
10665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10667 kern_type = KERN_TYPE_MS_DRSR;
10668 dgst_size = DGST_SIZE_4_8;
10669 parse_func = ms_drsr_parse_hash;
10670 sort_by_digest = sort_by_digest_4_8;
10671 opti_type = OPTI_TYPE_ZERO_BYTE;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10682 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10683 dgst_size = DGST_SIZE_4_8;
10684 parse_func = androidfde_samsung_parse_hash;
10685 sort_by_digest = sort_by_digest_4_8;
10686 opti_type = OPTI_TYPE_ZERO_BYTE;
10687 dgst_pos0 = 0;
10688 dgst_pos1 = 1;
10689 dgst_pos2 = 2;
10690 dgst_pos3 = 3;
10691 break;
10692
10693 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10694 salt_type = SALT_TYPE_EMBEDDED;
10695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10697 kern_type = KERN_TYPE_RAR5;
10698 dgst_size = DGST_SIZE_4_4;
10699 parse_func = rar5_parse_hash;
10700 sort_by_digest = sort_by_digest_4_4;
10701 opti_type = OPTI_TYPE_ZERO_BYTE;
10702 dgst_pos0 = 0;
10703 dgst_pos1 = 1;
10704 dgst_pos2 = 2;
10705 dgst_pos3 = 3;
10706 break;
10707
10708 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10709 salt_type = SALT_TYPE_EMBEDDED;
10710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10712 kern_type = KERN_TYPE_KRB5TGS;
10713 dgst_size = DGST_SIZE_4_4;
10714 parse_func = krb5tgs_parse_hash;
10715 sort_by_digest = sort_by_digest_4_4;
10716 opti_type = OPTI_TYPE_ZERO_BYTE
10717 | OPTI_TYPE_NOT_ITERATED;
10718 dgst_pos0 = 0;
10719 dgst_pos1 = 1;
10720 dgst_pos2 = 2;
10721 dgst_pos3 = 3;
10722 break;
10723
10724 case 13200: hash_type = HASH_TYPE_AES;
10725 salt_type = SALT_TYPE_EMBEDDED;
10726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10728 kern_type = KERN_TYPE_AXCRYPT;
10729 dgst_size = DGST_SIZE_4_4;
10730 parse_func = axcrypt_parse_hash;
10731 sort_by_digest = sort_by_digest_4_4;
10732 opti_type = OPTI_TYPE_ZERO_BYTE;
10733 dgst_pos0 = 0;
10734 dgst_pos1 = 1;
10735 dgst_pos2 = 2;
10736 dgst_pos3 = 3;
10737 break;
10738
10739 case 13300: hash_type = HASH_TYPE_SHA1;
10740 salt_type = SALT_TYPE_NONE;
10741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10742 opts_type = OPTS_TYPE_PT_GENERATE_BE
10743 | OPTS_TYPE_PT_ADD80
10744 | OPTS_TYPE_PT_ADDBITS15;
10745 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10746 dgst_size = DGST_SIZE_4_5;
10747 parse_func = sha1axcrypt_parse_hash;
10748 sort_by_digest = sort_by_digest_4_5;
10749 opti_type = OPTI_TYPE_ZERO_BYTE
10750 | OPTI_TYPE_PRECOMPUTE_INIT
10751 | OPTI_TYPE_EARLY_SKIP
10752 | OPTI_TYPE_NOT_ITERATED
10753 | OPTI_TYPE_NOT_SALTED;
10754 dgst_pos0 = 0;
10755 dgst_pos1 = 4;
10756 dgst_pos2 = 3;
10757 dgst_pos3 = 2;
10758 break;
10759
10760 case 13400: hash_type = HASH_TYPE_AES;
10761 salt_type = SALT_TYPE_EMBEDDED;
10762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10764 kern_type = KERN_TYPE_KEEPASS;
10765 dgst_size = DGST_SIZE_4_4;
10766 parse_func = keepass_parse_hash;
10767 sort_by_digest = sort_by_digest_4_4;
10768 opti_type = OPTI_TYPE_ZERO_BYTE;
10769 dgst_pos0 = 0;
10770 dgst_pos1 = 1;
10771 dgst_pos2 = 2;
10772 dgst_pos3 = 3;
10773 break;
10774
10775 case 13500: hash_type = HASH_TYPE_SHA1;
10776 salt_type = SALT_TYPE_EMBEDDED;
10777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10778 opts_type = OPTS_TYPE_PT_GENERATE_BE
10779 | OPTS_TYPE_PT_UNICODE
10780 | OPTS_TYPE_PT_ADD80;
10781 kern_type = KERN_TYPE_PSTOKEN;
10782 dgst_size = DGST_SIZE_4_5;
10783 parse_func = pstoken_parse_hash;
10784 sort_by_digest = sort_by_digest_4_5;
10785 opti_type = OPTI_TYPE_ZERO_BYTE
10786 | OPTI_TYPE_PRECOMPUTE_INIT
10787 | OPTI_TYPE_EARLY_SKIP
10788 | OPTI_TYPE_NOT_ITERATED
10789 | OPTI_TYPE_PREPENDED_SALT
10790 | OPTI_TYPE_RAW_HASH;
10791 dgst_pos0 = 3;
10792 dgst_pos1 = 4;
10793 dgst_pos2 = 2;
10794 dgst_pos3 = 1;
10795 break;
10796
10797 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10798 salt_type = SALT_TYPE_EMBEDDED;
10799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10801 kern_type = KERN_TYPE_ZIP2;
10802 dgst_size = DGST_SIZE_4_4;
10803 parse_func = zip2_parse_hash;
10804 sort_by_digest = sort_by_digest_4_4;
10805 opti_type = OPTI_TYPE_ZERO_BYTE;
10806 dgst_pos0 = 0;
10807 dgst_pos1 = 1;
10808 dgst_pos2 = 2;
10809 dgst_pos3 = 3;
10810 break;
10811
10812 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10813 salt_type = SALT_TYPE_EMBEDDED;
10814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10816 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10817 dgst_size = DGST_SIZE_4_5;
10818 parse_func = veracrypt_parse_hash_655331;
10819 sort_by_digest = sort_by_digest_4_5;
10820 opti_type = OPTI_TYPE_ZERO_BYTE;
10821 dgst_pos0 = 0;
10822 dgst_pos1 = 1;
10823 dgst_pos2 = 2;
10824 dgst_pos3 = 3;
10825 break;
10826
10827 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10828 salt_type = SALT_TYPE_EMBEDDED;
10829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10830 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10831 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10832 dgst_size = DGST_SIZE_4_5;
10833 parse_func = veracrypt_parse_hash_655331;
10834 sort_by_digest = sort_by_digest_4_5;
10835 opti_type = OPTI_TYPE_ZERO_BYTE;
10836 dgst_pos0 = 0;
10837 dgst_pos1 = 1;
10838 dgst_pos2 = 2;
10839 dgst_pos3 = 3;
10840 break;
10841
10842 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10843 salt_type = SALT_TYPE_EMBEDDED;
10844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10846 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10847 dgst_size = DGST_SIZE_4_5;
10848 parse_func = veracrypt_parse_hash_655331;
10849 sort_by_digest = sort_by_digest_4_5;
10850 opti_type = OPTI_TYPE_ZERO_BYTE;
10851 dgst_pos0 = 0;
10852 dgst_pos1 = 1;
10853 dgst_pos2 = 2;
10854 dgst_pos3 = 3;
10855 break;
10856
10857 case 13721: hash_type = HASH_TYPE_SHA512;
10858 salt_type = SALT_TYPE_EMBEDDED;
10859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10860 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10861 kern_type = KERN_TYPE_TCSHA512_XTS512;
10862 dgst_size = DGST_SIZE_8_8;
10863 parse_func = veracrypt_parse_hash_500000;
10864 sort_by_digest = sort_by_digest_8_8;
10865 opti_type = OPTI_TYPE_ZERO_BYTE
10866 | OPTI_TYPE_USES_BITS_64;
10867 dgst_pos0 = 0;
10868 dgst_pos1 = 1;
10869 dgst_pos2 = 2;
10870 dgst_pos3 = 3;
10871 break;
10872
10873 case 13722: hash_type = HASH_TYPE_SHA512;
10874 salt_type = SALT_TYPE_EMBEDDED;
10875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10876 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10877 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10878 dgst_size = DGST_SIZE_8_8;
10879 parse_func = veracrypt_parse_hash_500000;
10880 sort_by_digest = sort_by_digest_8_8;
10881 opti_type = OPTI_TYPE_ZERO_BYTE
10882 | OPTI_TYPE_USES_BITS_64;
10883 dgst_pos0 = 0;
10884 dgst_pos1 = 1;
10885 dgst_pos2 = 2;
10886 dgst_pos3 = 3;
10887 break;
10888
10889 case 13723: hash_type = HASH_TYPE_SHA512;
10890 salt_type = SALT_TYPE_EMBEDDED;
10891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10892 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10893 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10894 dgst_size = DGST_SIZE_8_8;
10895 parse_func = veracrypt_parse_hash_500000;
10896 sort_by_digest = sort_by_digest_8_8;
10897 opti_type = OPTI_TYPE_ZERO_BYTE
10898 | OPTI_TYPE_USES_BITS_64;
10899 dgst_pos0 = 0;
10900 dgst_pos1 = 1;
10901 dgst_pos2 = 2;
10902 dgst_pos3 = 3;
10903 break;
10904
10905 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10906 salt_type = SALT_TYPE_EMBEDDED;
10907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10909 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10910 dgst_size = DGST_SIZE_4_8;
10911 parse_func = veracrypt_parse_hash_500000;
10912 sort_by_digest = sort_by_digest_4_8;
10913 opti_type = OPTI_TYPE_ZERO_BYTE;
10914 dgst_pos0 = 0;
10915 dgst_pos1 = 1;
10916 dgst_pos2 = 2;
10917 dgst_pos3 = 3;
10918 break;
10919
10920 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10921 salt_type = SALT_TYPE_EMBEDDED;
10922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10923 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10924 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10925 dgst_size = DGST_SIZE_4_8;
10926 parse_func = veracrypt_parse_hash_500000;
10927 sort_by_digest = sort_by_digest_4_8;
10928 opti_type = OPTI_TYPE_ZERO_BYTE;
10929 dgst_pos0 = 0;
10930 dgst_pos1 = 1;
10931 dgst_pos2 = 2;
10932 dgst_pos3 = 3;
10933 break;
10934
10935 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10936 salt_type = SALT_TYPE_EMBEDDED;
10937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10938 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10939 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10940 dgst_size = DGST_SIZE_4_8;
10941 parse_func = veracrypt_parse_hash_500000;
10942 sort_by_digest = sort_by_digest_4_8;
10943 opti_type = OPTI_TYPE_ZERO_BYTE;
10944 dgst_pos0 = 0;
10945 dgst_pos1 = 1;
10946 dgst_pos2 = 2;
10947 dgst_pos3 = 3;
10948 break;
10949
10950 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10951 salt_type = SALT_TYPE_EMBEDDED;
10952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10954 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10955 dgst_size = DGST_SIZE_4_5;
10956 parse_func = veracrypt_parse_hash_327661;
10957 sort_by_digest = sort_by_digest_4_5;
10958 opti_type = OPTI_TYPE_ZERO_BYTE;
10959 dgst_pos0 = 0;
10960 dgst_pos1 = 1;
10961 dgst_pos2 = 2;
10962 dgst_pos3 = 3;
10963 break;
10964
10965 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10966 salt_type = SALT_TYPE_EMBEDDED;
10967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10969 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10970 dgst_size = DGST_SIZE_4_5;
10971 parse_func = veracrypt_parse_hash_327661;
10972 sort_by_digest = sort_by_digest_4_5;
10973 opti_type = OPTI_TYPE_ZERO_BYTE;
10974 dgst_pos0 = 0;
10975 dgst_pos1 = 1;
10976 dgst_pos2 = 2;
10977 dgst_pos3 = 3;
10978 break;
10979
10980 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10981 salt_type = SALT_TYPE_EMBEDDED;
10982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10983 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10984 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10985 dgst_size = DGST_SIZE_4_5;
10986 parse_func = veracrypt_parse_hash_327661;
10987 sort_by_digest = sort_by_digest_4_5;
10988 opti_type = OPTI_TYPE_ZERO_BYTE;
10989 dgst_pos0 = 0;
10990 dgst_pos1 = 1;
10991 dgst_pos2 = 2;
10992 dgst_pos3 = 3;
10993 break;
10994
10995 case 13751: hash_type = HASH_TYPE_SHA256;
10996 salt_type = SALT_TYPE_EMBEDDED;
10997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10998 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10999 kern_type = KERN_TYPE_VCSHA256_XTS512;
11000 dgst_size = DGST_SIZE_4_8;
11001 parse_func = veracrypt_parse_hash_500000;
11002 sort_by_digest = sort_by_digest_4_8;
11003 opti_type = OPTI_TYPE_ZERO_BYTE;
11004 dgst_pos0 = 0;
11005 dgst_pos1 = 1;
11006 dgst_pos2 = 2;
11007 dgst_pos3 = 3;
11008 break;
11009
11010 case 13752: hash_type = HASH_TYPE_SHA256;
11011 salt_type = SALT_TYPE_EMBEDDED;
11012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11013 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11014 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11015 dgst_size = DGST_SIZE_4_8;
11016 parse_func = veracrypt_parse_hash_500000;
11017 sort_by_digest = sort_by_digest_4_8;
11018 opti_type = OPTI_TYPE_ZERO_BYTE;
11019 dgst_pos0 = 0;
11020 dgst_pos1 = 1;
11021 dgst_pos2 = 2;
11022 dgst_pos3 = 3;
11023 break;
11024
11025 case 13753: hash_type = HASH_TYPE_SHA256;
11026 salt_type = SALT_TYPE_EMBEDDED;
11027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11028 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11029 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11030 dgst_size = DGST_SIZE_4_8;
11031 parse_func = veracrypt_parse_hash_500000;
11032 sort_by_digest = sort_by_digest_4_8;
11033 opti_type = OPTI_TYPE_ZERO_BYTE;
11034 dgst_pos0 = 0;
11035 dgst_pos1 = 1;
11036 dgst_pos2 = 2;
11037 dgst_pos3 = 3;
11038 break;
11039
11040 case 13761: hash_type = HASH_TYPE_SHA256;
11041 salt_type = SALT_TYPE_EMBEDDED;
11042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11043 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11044 kern_type = KERN_TYPE_VCSHA256_XTS512;
11045 dgst_size = DGST_SIZE_4_8;
11046 parse_func = veracrypt_parse_hash_200000;
11047 sort_by_digest = sort_by_digest_4_8;
11048 opti_type = OPTI_TYPE_ZERO_BYTE;
11049 dgst_pos0 = 0;
11050 dgst_pos1 = 1;
11051 dgst_pos2 = 2;
11052 dgst_pos3 = 3;
11053 break;
11054
11055 case 13762: hash_type = HASH_TYPE_SHA256;
11056 salt_type = SALT_TYPE_EMBEDDED;
11057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11059 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11060 dgst_size = DGST_SIZE_4_8;
11061 parse_func = veracrypt_parse_hash_200000;
11062 sort_by_digest = sort_by_digest_4_8;
11063 opti_type = OPTI_TYPE_ZERO_BYTE;
11064 dgst_pos0 = 0;
11065 dgst_pos1 = 1;
11066 dgst_pos2 = 2;
11067 dgst_pos3 = 3;
11068 break;
11069
11070 case 13763: hash_type = HASH_TYPE_SHA256;
11071 salt_type = SALT_TYPE_EMBEDDED;
11072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11073 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11074 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11075 dgst_size = DGST_SIZE_4_8;
11076 parse_func = veracrypt_parse_hash_200000;
11077 sort_by_digest = sort_by_digest_4_8;
11078 opti_type = OPTI_TYPE_ZERO_BYTE;
11079 dgst_pos0 = 0;
11080 dgst_pos1 = 1;
11081 dgst_pos2 = 2;
11082 dgst_pos3 = 3;
11083 break;
11084
11085 case 13800: hash_type = HASH_TYPE_SHA256;
11086 salt_type = SALT_TYPE_EMBEDDED;
11087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11088 opts_type = OPTS_TYPE_PT_GENERATE_BE
11089 | OPTS_TYPE_PT_UNICODE;
11090 kern_type = KERN_TYPE_WIN8PHONE;
11091 dgst_size = DGST_SIZE_4_8;
11092 parse_func = win8phone_parse_hash;
11093 sort_by_digest = sort_by_digest_4_8;
11094 opti_type = OPTI_TYPE_ZERO_BYTE
11095 | OPTI_TYPE_PRECOMPUTE_INIT
11096 | OPTI_TYPE_EARLY_SKIP
11097 | OPTI_TYPE_NOT_ITERATED
11098 | OPTI_TYPE_RAW_HASH;
11099 dgst_pos0 = 3;
11100 dgst_pos1 = 7;
11101 dgst_pos2 = 2;
11102 dgst_pos3 = 6;
11103 break;
11104
11105 default: usage_mini_print (PROGNAME); return (-1);
11106 }
11107
11108 /**
11109 * parser
11110 */
11111
11112 data.parse_func = parse_func;
11113
11114 /**
11115 * misc stuff
11116 */
11117
11118 if (hex_salt)
11119 {
11120 if (salt_type == SALT_TYPE_INTERN)
11121 {
11122 opts_type |= OPTS_TYPE_ST_HEX;
11123 }
11124 else
11125 {
11126 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11127
11128 return (-1);
11129 }
11130 }
11131
11132 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11133 | (salt_type == SALT_TYPE_EXTERN)
11134 | (salt_type == SALT_TYPE_EMBEDDED)
11135 | (salt_type == SALT_TYPE_VIRTUAL));
11136
11137 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11138
11139 data.hash_type = hash_type;
11140 data.attack_mode = attack_mode;
11141 data.attack_kern = attack_kern;
11142 data.attack_exec = attack_exec;
11143 data.kern_type = kern_type;
11144 data.opts_type = opts_type;
11145 data.dgst_size = dgst_size;
11146 data.salt_type = salt_type;
11147 data.isSalted = isSalted;
11148 data.sort_by_digest = sort_by_digest;
11149 data.dgst_pos0 = dgst_pos0;
11150 data.dgst_pos1 = dgst_pos1;
11151 data.dgst_pos2 = dgst_pos2;
11152 data.dgst_pos3 = dgst_pos3;
11153
11154 esalt_size = 0;
11155
11156 switch (hash_mode)
11157 {
11158 case 2500: esalt_size = sizeof (wpa_t); break;
11159 case 5300: esalt_size = sizeof (ikepsk_t); break;
11160 case 5400: esalt_size = sizeof (ikepsk_t); break;
11161 case 5500: esalt_size = sizeof (netntlm_t); break;
11162 case 5600: esalt_size = sizeof (netntlm_t); break;
11163 case 6211: esalt_size = sizeof (tc_t); break;
11164 case 6212: esalt_size = sizeof (tc_t); break;
11165 case 6213: esalt_size = sizeof (tc_t); break;
11166 case 6221: esalt_size = sizeof (tc_t); break;
11167 case 6222: esalt_size = sizeof (tc_t); break;
11168 case 6223: esalt_size = sizeof (tc_t); break;
11169 case 6231: esalt_size = sizeof (tc_t); break;
11170 case 6232: esalt_size = sizeof (tc_t); break;
11171 case 6233: esalt_size = sizeof (tc_t); break;
11172 case 6241: esalt_size = sizeof (tc_t); break;
11173 case 6242: esalt_size = sizeof (tc_t); break;
11174 case 6243: esalt_size = sizeof (tc_t); break;
11175 case 6600: esalt_size = sizeof (agilekey_t); break;
11176 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11177 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11178 case 7300: esalt_size = sizeof (rakp_t); break;
11179 case 7500: esalt_size = sizeof (krb5pa_t); break;
11180 case 8200: esalt_size = sizeof (cloudkey_t); break;
11181 case 8800: esalt_size = sizeof (androidfde_t); break;
11182 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11183 case 9400: esalt_size = sizeof (office2007_t); break;
11184 case 9500: esalt_size = sizeof (office2010_t); break;
11185 case 9600: esalt_size = sizeof (office2013_t); break;
11186 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11187 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11188 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11189 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11190 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11191 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11192 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11193 case 10200: esalt_size = sizeof (cram_md5_t); break;
11194 case 10400: esalt_size = sizeof (pdf_t); break;
11195 case 10410: esalt_size = sizeof (pdf_t); break;
11196 case 10420: esalt_size = sizeof (pdf_t); break;
11197 case 10500: esalt_size = sizeof (pdf_t); break;
11198 case 10600: esalt_size = sizeof (pdf_t); break;
11199 case 10700: esalt_size = sizeof (pdf_t); break;
11200 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11201 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11202 case 11400: esalt_size = sizeof (sip_t); break;
11203 case 11600: esalt_size = sizeof (seven_zip_t); break;
11204 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11205 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11206 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11207 case 13000: esalt_size = sizeof (rar5_t); break;
11208 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11209 case 13400: esalt_size = sizeof (keepass_t); break;
11210 case 13500: esalt_size = sizeof (pstoken_t); break;
11211 case 13600: esalt_size = sizeof (zip2_t); break;
11212 case 13711: esalt_size = sizeof (tc_t); break;
11213 case 13712: esalt_size = sizeof (tc_t); break;
11214 case 13713: esalt_size = sizeof (tc_t); break;
11215 case 13721: esalt_size = sizeof (tc_t); break;
11216 case 13722: esalt_size = sizeof (tc_t); break;
11217 case 13723: esalt_size = sizeof (tc_t); break;
11218 case 13731: esalt_size = sizeof (tc_t); break;
11219 case 13732: esalt_size = sizeof (tc_t); break;
11220 case 13733: esalt_size = sizeof (tc_t); break;
11221 case 13741: esalt_size = sizeof (tc_t); break;
11222 case 13742: esalt_size = sizeof (tc_t); break;
11223 case 13743: esalt_size = sizeof (tc_t); break;
11224 case 13751: esalt_size = sizeof (tc_t); break;
11225 case 13752: esalt_size = sizeof (tc_t); break;
11226 case 13753: esalt_size = sizeof (tc_t); break;
11227 case 13761: esalt_size = sizeof (tc_t); break;
11228 case 13762: esalt_size = sizeof (tc_t); break;
11229 case 13763: esalt_size = sizeof (tc_t); break;
11230 case 13800: esalt_size = sizeof (win8phone_t); break;
11231 }
11232
11233 data.esalt_size = esalt_size;
11234
11235 /**
11236 * choose dictionary parser
11237 */
11238
11239 if (hash_type == HASH_TYPE_LM)
11240 {
11241 get_next_word_func = get_next_word_lm;
11242 }
11243 else if (opts_type & OPTS_TYPE_PT_UPPER)
11244 {
11245 get_next_word_func = get_next_word_uc;
11246 }
11247 else
11248 {
11249 get_next_word_func = get_next_word_std;
11250 }
11251
11252 /**
11253 * dictstat
11254 */
11255
11256 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11257
11258 #ifdef _POSIX
11259 size_t dictstat_nmemb = 0;
11260 #endif
11261
11262 #ifdef _WIN
11263 uint dictstat_nmemb = 0;
11264 #endif
11265
11266 char dictstat[256] = { 0 };
11267
11268 FILE *dictstat_fp = NULL;
11269
11270 if (keyspace == 0)
11271 {
11272 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11273
11274 dictstat_fp = fopen (dictstat, "rb");
11275
11276 if (dictstat_fp)
11277 {
11278 #ifdef _POSIX
11279 struct stat tmpstat;
11280
11281 fstat (fileno (dictstat_fp), &tmpstat);
11282 #endif
11283
11284 #ifdef _WIN
11285 struct stat64 tmpstat;
11286
11287 _fstat64 (fileno (dictstat_fp), &tmpstat);
11288 #endif
11289
11290 if (tmpstat.st_mtime < COMPTIME)
11291 {
11292 /* with v0.15 the format changed so we have to ensure user is using a good version
11293 since there is no version-header in the dictstat file */
11294
11295 fclose (dictstat_fp);
11296
11297 unlink (dictstat);
11298 }
11299 else
11300 {
11301 while (!feof (dictstat_fp))
11302 {
11303 dictstat_t d;
11304
11305 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11306
11307 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11308
11309 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11310 {
11311 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11312
11313 return -1;
11314 }
11315 }
11316
11317 fclose (dictstat_fp);
11318 }
11319 }
11320 }
11321
11322 /**
11323 * potfile
11324 */
11325
11326 char potfile[256] = { 0 };
11327
11328 if (potfile_path == NULL)
11329 {
11330 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11331 }
11332 else
11333 {
11334 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11335 }
11336
11337 data.pot_fp = NULL;
11338
11339 FILE *out_fp = NULL;
11340 FILE *pot_fp = NULL;
11341
11342 if (show == 1 || left == 1)
11343 {
11344 pot_fp = fopen (potfile, "rb");
11345
11346 if (pot_fp == NULL)
11347 {
11348 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11349
11350 return (-1);
11351 }
11352
11353 if (outfile != NULL)
11354 {
11355 if ((out_fp = fopen (outfile, "ab")) == NULL)
11356 {
11357 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11358
11359 fclose (pot_fp);
11360
11361 return (-1);
11362 }
11363 }
11364 else
11365 {
11366 out_fp = stdout;
11367 }
11368 }
11369 else
11370 {
11371 if (potfile_disable == 0)
11372 {
11373 pot_fp = fopen (potfile, "ab");
11374
11375 if (pot_fp == NULL)
11376 {
11377 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11378
11379 return (-1);
11380 }
11381
11382 data.pot_fp = pot_fp;
11383 }
11384 }
11385
11386 pot_t *pot = NULL;
11387
11388 uint pot_cnt = 0;
11389 uint pot_avail = 0;
11390
11391 if (show == 1 || left == 1)
11392 {
11393 SUPPRESS_OUTPUT = 1;
11394
11395 pot_avail = count_lines (pot_fp);
11396
11397 rewind (pot_fp);
11398
11399 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11400
11401 uint pot_hashes_avail = 0;
11402
11403 uint line_num = 0;
11404
11405 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11406
11407 while (!feof (pot_fp))
11408 {
11409 line_num++;
11410
11411 int line_len = fgetl (pot_fp, line_buf);
11412
11413 if (line_len == 0) continue;
11414
11415 char *plain_buf = line_buf + line_len;
11416
11417 pot_t *pot_ptr = &pot[pot_cnt];
11418
11419 hash_t *hashes_buf = &pot_ptr->hash;
11420
11421 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11422 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11423
11424 if (pot_cnt == pot_hashes_avail)
11425 {
11426 uint pos = 0;
11427
11428 for (pos = 0; pos < INCR_POT; pos++)
11429 {
11430 if ((pot_cnt + pos) >= pot_avail) break;
11431
11432 pot_t *tmp_pot = &pot[pot_cnt + pos];
11433
11434 hash_t *tmp_hash = &tmp_pot->hash;
11435
11436 tmp_hash->digest = mymalloc (dgst_size);
11437
11438 if (isSalted)
11439 {
11440 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11441 }
11442
11443 if (esalt_size)
11444 {
11445 tmp_hash->esalt = mymalloc (esalt_size);
11446 }
11447
11448 pot_hashes_avail++;
11449 }
11450 }
11451
11452 int plain_len = 0;
11453
11454 int parser_status;
11455
11456 int iter = MAX_CUT_TRIES;
11457
11458 do
11459 {
11460 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11461 {
11462 if (line_buf[i] == ':')
11463 {
11464 line_len--;
11465
11466 break;
11467 }
11468 }
11469
11470 if (data.hash_mode != 2500)
11471 {
11472 parser_status = parse_func (line_buf, line_len, hashes_buf);
11473 }
11474 else
11475 {
11476 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11477
11478 if (line_len > max_salt_size)
11479 {
11480 parser_status = PARSER_GLOBAL_LENGTH;
11481 }
11482 else
11483 {
11484 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11485
11486 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11487
11488 hashes_buf->salt->salt_len = line_len;
11489
11490 parser_status = PARSER_OK;
11491 }
11492 }
11493
11494 // if NOT parsed without error, we add the ":" to the plain
11495
11496 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11497 {
11498 plain_len++;
11499 plain_buf--;
11500 }
11501
11502 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11503
11504 if (parser_status < PARSER_GLOBAL_ZERO)
11505 {
11506 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11507
11508 continue;
11509 }
11510
11511 if (plain_len >= 255) continue;
11512
11513 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11514
11515 pot_ptr->plain_len = plain_len;
11516
11517 pot_cnt++;
11518 }
11519
11520 myfree (line_buf);
11521
11522 fclose (pot_fp);
11523
11524 SUPPRESS_OUTPUT = 0;
11525
11526 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11527 }
11528
11529 /**
11530 * word len
11531 */
11532
11533 uint pw_min = PW_MIN;
11534 uint pw_max = PW_MAX;
11535
11536 switch (hash_mode)
11537 {
11538 case 125: if (pw_max > 32) pw_max = 32;
11539 break;
11540 case 400: if (pw_max > 40) pw_max = 40;
11541 break;
11542 case 500: if (pw_max > 16) pw_max = 16;
11543 break;
11544 case 1500: if (pw_max > 8) pw_max = 8;
11545 break;
11546 case 1600: if (pw_max > 16) pw_max = 16;
11547 break;
11548 case 1800: if (pw_max > 16) pw_max = 16;
11549 break;
11550 case 2100: if (pw_max > 16) pw_max = 16;
11551 break;
11552 case 2500: if (pw_min < 8) pw_min = 8;
11553 break;
11554 case 3000: if (pw_max > 7) pw_max = 7;
11555 break;
11556 case 5200: if (pw_max > 24) pw_max = 24;
11557 break;
11558 case 5800: if (pw_max > 16) pw_max = 16;
11559 break;
11560 case 6300: if (pw_max > 16) pw_max = 16;
11561 break;
11562 case 7400: if (pw_max > 16) pw_max = 16;
11563 break;
11564 case 7700: if (pw_max > 8) pw_max = 8;
11565 break;
11566 case 7900: if (pw_max > 48) pw_max = 48;
11567 break;
11568 case 8500: if (pw_max > 8) pw_max = 8;
11569 break;
11570 case 8600: if (pw_max > 16) pw_max = 16;
11571 break;
11572 case 9710: pw_min = 5;
11573 pw_max = 5;
11574 break;
11575 case 9810: pw_min = 5;
11576 pw_max = 5;
11577 break;
11578 case 10410: pw_min = 5;
11579 pw_max = 5;
11580 break;
11581 case 10300: if (pw_max < 3) pw_min = 3;
11582 if (pw_max > 40) pw_max = 40;
11583 break;
11584 case 10500: if (pw_max < 3) pw_min = 3;
11585 if (pw_max > 40) pw_max = 40;
11586 break;
11587 case 10700: if (pw_max > 16) pw_max = 16;
11588 break;
11589 case 11300: if (pw_max > 40) pw_max = 40;
11590 break;
11591 case 11600: if (pw_max > 32) pw_max = 32;
11592 break;
11593 case 12500: if (pw_max > 20) pw_max = 20;
11594 break;
11595 case 12800: if (pw_max > 24) pw_max = 24;
11596 break;
11597 }
11598
11599 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11600 {
11601 switch (attack_kern)
11602 {
11603 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11604 break;
11605 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11606 break;
11607 }
11608 }
11609
11610 /**
11611 * charsets : keep them together for more easy maintainnce
11612 */
11613
11614 cs_t mp_sys[6] = { { { 0 }, 0 } };
11615 cs_t mp_usr[4] = { { { 0 }, 0 } };
11616
11617 mp_setup_sys (mp_sys);
11618
11619 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11620 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11621 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11622 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11623
11624 /**
11625 * load hashes, part I: find input mode, count hashes
11626 */
11627
11628 uint hashlist_mode = 0;
11629 uint hashlist_format = HLFMT_HASHCAT;
11630
11631 uint hashes_avail = 0;
11632
11633 if ((benchmark == 0) && (stdout_flag == 0))
11634 {
11635 struct stat f;
11636
11637 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11638
11639 if ((hash_mode == 2500) ||
11640 (hash_mode == 5200) ||
11641 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11642 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11643 (hash_mode == 9000))
11644 {
11645 hashlist_mode = HL_MODE_ARG;
11646
11647 char *hashfile = myargv[optind];
11648
11649 data.hashfile = hashfile;
11650
11651 logfile_top_var_string ("target", hashfile);
11652 }
11653
11654 if (hashlist_mode == HL_MODE_ARG)
11655 {
11656 if (hash_mode == 2500)
11657 {
11658 struct stat st;
11659
11660 if (stat (data.hashfile, &st) == -1)
11661 {
11662 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11663
11664 return (-1);
11665 }
11666
11667 hashes_avail = st.st_size / sizeof (hccap_t);
11668 }
11669 else
11670 {
11671 hashes_avail = 1;
11672 }
11673 }
11674 else if (hashlist_mode == HL_MODE_FILE)
11675 {
11676 char *hashfile = myargv[optind];
11677
11678 data.hashfile = hashfile;
11679
11680 logfile_top_var_string ("target", hashfile);
11681
11682 FILE *fp = NULL;
11683
11684 if ((fp = fopen (hashfile, "rb")) == NULL)
11685 {
11686 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11687
11688 return (-1);
11689 }
11690
11691 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11692
11693 hashes_avail = count_lines (fp);
11694
11695 rewind (fp);
11696
11697 if (hashes_avail == 0)
11698 {
11699 log_error ("ERROR: hashfile is empty or corrupt");
11700
11701 fclose (fp);
11702
11703 return (-1);
11704 }
11705
11706 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11707
11708 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11709 {
11710 log_error ("ERROR: remove not supported in native hashfile-format mode");
11711
11712 fclose (fp);
11713
11714 return (-1);
11715 }
11716
11717 fclose (fp);
11718 }
11719 }
11720 else
11721 {
11722 hashlist_mode = HL_MODE_ARG;
11723
11724 hashes_avail = 1;
11725 }
11726
11727 if (hash_mode == 3000) hashes_avail *= 2;
11728
11729 data.hashlist_mode = hashlist_mode;
11730 data.hashlist_format = hashlist_format;
11731
11732 logfile_top_uint (hashlist_mode);
11733 logfile_top_uint (hashlist_format);
11734
11735 /**
11736 * load hashes, part II: allocate required memory, set pointers
11737 */
11738
11739 hash_t *hashes_buf = NULL;
11740 void *digests_buf = NULL;
11741 salt_t *salts_buf = NULL;
11742 void *esalts_buf = NULL;
11743
11744 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11745
11746 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11747
11748 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11749 {
11750 u32 hash_pos;
11751
11752 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11753 {
11754 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11755
11756 hashes_buf[hash_pos].hash_info = hash_info;
11757
11758 if (username && (remove || show || left))
11759 {
11760 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11761 }
11762
11763 if (benchmark)
11764 {
11765 hash_info->orighash = (char *) mymalloc (256);
11766 }
11767 }
11768 }
11769
11770 if (isSalted)
11771 {
11772 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11773
11774 if (esalt_size)
11775 {
11776 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11777 }
11778 }
11779 else
11780 {
11781 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11782 }
11783
11784 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11785 {
11786 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11787
11788 if (isSalted)
11789 {
11790 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11791
11792 if (esalt_size)
11793 {
11794 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11795 }
11796 }
11797 else
11798 {
11799 hashes_buf[hash_pos].salt = &salts_buf[0];
11800 }
11801 }
11802
11803 /**
11804 * load hashes, part III: parse hashes or generate them if benchmark
11805 */
11806
11807 uint hashes_cnt = 0;
11808
11809 if (benchmark == 0)
11810 {
11811 if (keyspace == 1)
11812 {
11813 // useless to read hash file for keyspace, cheat a little bit w/ optind
11814 }
11815 else if (stdout_flag == 1)
11816 {
11817 // useless to read hash file for stdout, cheat a little bit w/ optind
11818 }
11819 else if (hashes_avail == 0)
11820 {
11821 }
11822 else if (hashlist_mode == HL_MODE_ARG)
11823 {
11824 char *input_buf = myargv[optind];
11825
11826 uint input_len = strlen (input_buf);
11827
11828 logfile_top_var_string ("target", input_buf);
11829
11830 char *hash_buf = NULL;
11831 int hash_len = 0;
11832
11833 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11834
11835 bool hash_fmt_error = 0;
11836
11837 if (hash_len < 1) hash_fmt_error = 1;
11838 if (hash_buf == NULL) hash_fmt_error = 1;
11839
11840 if (hash_fmt_error)
11841 {
11842 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11843 }
11844 else
11845 {
11846 if (opts_type & OPTS_TYPE_HASH_COPY)
11847 {
11848 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11849
11850 hash_info_tmp->orighash = mystrdup (hash_buf);
11851 }
11852
11853 if (isSalted)
11854 {
11855 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11856 }
11857
11858 int parser_status = PARSER_OK;
11859
11860 if (hash_mode == 2500)
11861 {
11862 if (hash_len == 0)
11863 {
11864 log_error ("ERROR: hccap file not specified");
11865
11866 return (-1);
11867 }
11868
11869 hashlist_mode = HL_MODE_FILE;
11870
11871 data.hashlist_mode = hashlist_mode;
11872
11873 FILE *fp = fopen (hash_buf, "rb");
11874
11875 if (fp == NULL)
11876 {
11877 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11878
11879 return (-1);
11880 }
11881
11882 if (hashes_avail < 1)
11883 {
11884 log_error ("ERROR: hccap file is empty or corrupt");
11885
11886 fclose (fp);
11887
11888 return (-1);
11889 }
11890
11891 uint hccap_size = sizeof (hccap_t);
11892
11893 char *in = (char *) mymalloc (hccap_size);
11894
11895 while (!feof (fp))
11896 {
11897 int n = fread (in, hccap_size, 1, fp);
11898
11899 if (n != 1)
11900 {
11901 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11902
11903 break;
11904 }
11905
11906 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11907
11908 if (parser_status != PARSER_OK)
11909 {
11910 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11911
11912 continue;
11913 }
11914
11915 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11916
11917 if ((show == 1) || (left == 1))
11918 {
11919 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11920
11921 char *salt_ptr = (char *) tmp_salt->salt_buf;
11922
11923 int cur_pos = tmp_salt->salt_len;
11924 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11925
11926 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11927
11928 // do the appending task
11929
11930 snprintf (salt_ptr + cur_pos,
11931 rem_len,
11932 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11933 wpa->orig_mac1[0],
11934 wpa->orig_mac1[1],
11935 wpa->orig_mac1[2],
11936 wpa->orig_mac1[3],
11937 wpa->orig_mac1[4],
11938 wpa->orig_mac1[5],
11939 wpa->orig_mac2[0],
11940 wpa->orig_mac2[1],
11941 wpa->orig_mac2[2],
11942 wpa->orig_mac2[3],
11943 wpa->orig_mac2[4],
11944 wpa->orig_mac2[5]);
11945
11946 // memset () the remaining part of the salt
11947
11948 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11949 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11950
11951 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11952
11953 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11954 }
11955
11956 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11957 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11958
11959 hashes_cnt++;
11960 }
11961
11962 fclose (fp);
11963
11964 myfree (in);
11965 }
11966 else if (hash_mode == 3000)
11967 {
11968 if (hash_len == 32)
11969 {
11970 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11971
11972 hash_t *lm_hash_left = NULL;
11973
11974 if (parser_status == PARSER_OK)
11975 {
11976 lm_hash_left = &hashes_buf[hashes_cnt];
11977
11978 hashes_cnt++;
11979 }
11980 else
11981 {
11982 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11983 }
11984
11985 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11986
11987 hash_t *lm_hash_right = NULL;
11988
11989 if (parser_status == PARSER_OK)
11990 {
11991 lm_hash_right = &hashes_buf[hashes_cnt];
11992
11993 hashes_cnt++;
11994 }
11995 else
11996 {
11997 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11998 }
11999
12000 // show / left
12001
12002 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12003 {
12004 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
12005 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
12006 }
12007 }
12008 else
12009 {
12010 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12011
12012 if (parser_status == PARSER_OK)
12013 {
12014 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12015 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12016 }
12017
12018 if (parser_status == PARSER_OK)
12019 {
12020 hashes_cnt++;
12021 }
12022 else
12023 {
12024 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12025 }
12026 }
12027 }
12028 else
12029 {
12030 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12031
12032 if (parser_status == PARSER_OK)
12033 {
12034 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12035 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12036 }
12037
12038 if (parser_status == PARSER_OK)
12039 {
12040 hashes_cnt++;
12041 }
12042 else
12043 {
12044 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12045 }
12046 }
12047 }
12048 }
12049 else if (hashlist_mode == HL_MODE_FILE)
12050 {
12051 char *hashfile = data.hashfile;
12052
12053 FILE *fp;
12054
12055 if ((fp = fopen (hashfile, "rb")) == NULL)
12056 {
12057 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12058
12059 return (-1);
12060 }
12061
12062 uint line_num = 0;
12063
12064 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12065
12066 while (!feof (fp))
12067 {
12068 line_num++;
12069
12070 int line_len = fgetl (fp, line_buf);
12071
12072 if (line_len == 0) continue;
12073
12074 char *hash_buf = NULL;
12075 int hash_len = 0;
12076
12077 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12078
12079 bool hash_fmt_error = 0;
12080
12081 if (hash_len < 1) hash_fmt_error = 1;
12082 if (hash_buf == NULL) hash_fmt_error = 1;
12083
12084 if (hash_fmt_error)
12085 {
12086 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12087
12088 continue;
12089 }
12090
12091 if (username)
12092 {
12093 char *user_buf = NULL;
12094 int user_len = 0;
12095
12096 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12097
12098 if (remove || show)
12099 {
12100 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12101
12102 *user = (user_t *) mymalloc (sizeof (user_t));
12103
12104 user_t *user_ptr = *user;
12105
12106 if (user_buf != NULL)
12107 {
12108 user_ptr->user_name = mystrdup (user_buf);
12109 }
12110 else
12111 {
12112 user_ptr->user_name = mystrdup ("");
12113 }
12114
12115 user_ptr->user_len = user_len;
12116 }
12117 }
12118
12119 if (opts_type & OPTS_TYPE_HASH_COPY)
12120 {
12121 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12122
12123 hash_info_tmp->orighash = mystrdup (hash_buf);
12124 }
12125
12126 if (isSalted)
12127 {
12128 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12129 }
12130
12131 if (hash_mode == 3000)
12132 {
12133 if (hash_len == 32)
12134 {
12135 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12136
12137 if (parser_status < PARSER_GLOBAL_ZERO)
12138 {
12139 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12140
12141 continue;
12142 }
12143
12144 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12145
12146 hashes_cnt++;
12147
12148 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12149
12150 if (parser_status < PARSER_GLOBAL_ZERO)
12151 {
12152 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12153
12154 continue;
12155 }
12156
12157 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12158
12159 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
12160
12161 hashes_cnt++;
12162
12163 // show / left
12164
12165 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
12166 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
12167 }
12168 else
12169 {
12170 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12171
12172 if (parser_status < PARSER_GLOBAL_ZERO)
12173 {
12174 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12175
12176 continue;
12177 }
12178
12179 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
12180
12181 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12182 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12183
12184 hashes_cnt++;
12185 }
12186 }
12187 else
12188 {
12189 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12190
12191 if (parser_status < PARSER_GLOBAL_ZERO)
12192 {
12193 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12194
12195 continue;
12196 }
12197
12198 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
12199
12200 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12201 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12202
12203 hashes_cnt++;
12204 }
12205 }
12206
12207 myfree (line_buf);
12208
12209 fclose (fp);
12210
12211 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12212
12213 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12214 }
12215 }
12216 else
12217 {
12218 if (isSalted)
12219 {
12220 hashes_buf[0].salt->salt_len = 8;
12221
12222 // special salt handling
12223
12224 switch (hash_mode)
12225 {
12226 case 1500: hashes_buf[0].salt->salt_len = 2;
12227 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12228 break;
12229 case 1731: hashes_buf[0].salt->salt_len = 4;
12230 break;
12231 case 2410: hashes_buf[0].salt->salt_len = 4;
12232 break;
12233 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12234 break;
12235 case 3100: hashes_buf[0].salt->salt_len = 1;
12236 break;
12237 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12238 break;
12239 case 5800: hashes_buf[0].salt->salt_len = 16;
12240 break;
12241 case 6800: hashes_buf[0].salt->salt_len = 32;
12242 break;
12243 case 8400: hashes_buf[0].salt->salt_len = 40;
12244 break;
12245 case 8800: hashes_buf[0].salt->salt_len = 16;
12246 break;
12247 case 8900: hashes_buf[0].salt->salt_len = 16;
12248 hashes_buf[0].salt->scrypt_N = 1024;
12249 hashes_buf[0].salt->scrypt_r = 1;
12250 hashes_buf[0].salt->scrypt_p = 1;
12251 break;
12252 case 9100: hashes_buf[0].salt->salt_len = 16;
12253 break;
12254 case 9300: hashes_buf[0].salt->salt_len = 14;
12255 hashes_buf[0].salt->scrypt_N = 16384;
12256 hashes_buf[0].salt->scrypt_r = 1;
12257 hashes_buf[0].salt->scrypt_p = 1;
12258 break;
12259 case 9400: hashes_buf[0].salt->salt_len = 16;
12260 break;
12261 case 9500: hashes_buf[0].salt->salt_len = 16;
12262 break;
12263 case 9600: hashes_buf[0].salt->salt_len = 16;
12264 break;
12265 case 9700: hashes_buf[0].salt->salt_len = 16;
12266 break;
12267 case 9710: hashes_buf[0].salt->salt_len = 16;
12268 break;
12269 case 9720: hashes_buf[0].salt->salt_len = 16;
12270 break;
12271 case 9800: hashes_buf[0].salt->salt_len = 16;
12272 break;
12273 case 9810: hashes_buf[0].salt->salt_len = 16;
12274 break;
12275 case 9820: hashes_buf[0].salt->salt_len = 16;
12276 break;
12277 case 10300: hashes_buf[0].salt->salt_len = 12;
12278 break;
12279 case 11500: hashes_buf[0].salt->salt_len = 4;
12280 break;
12281 case 11600: hashes_buf[0].salt->salt_len = 4;
12282 break;
12283 case 12400: hashes_buf[0].salt->salt_len = 4;
12284 break;
12285 case 12500: hashes_buf[0].salt->salt_len = 8;
12286 break;
12287 case 12600: hashes_buf[0].salt->salt_len = 64;
12288 break;
12289 }
12290
12291 // special esalt handling
12292
12293 switch (hash_mode)
12294 {
12295 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12296 break;
12297 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12298 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12299 break;
12300 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12301 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12302 break;
12303 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12304 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12305 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12306 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12307 break;
12308 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12309 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12310 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12311 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12312 break;
12313 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12314 break;
12315 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12316 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12317 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12318 break;
12319 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12320 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12321 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12322 break;
12323 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12324 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12325 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12326 break;
12327 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12328 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12329 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12330 break;
12331 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12332 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12333 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12334 break;
12335 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12336 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12337 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12338 break;
12339 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12340 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12341 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12342 break;
12343 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12344 break;
12345 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12346 break;
12347 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12348 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12349 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12350 break;
12351 }
12352 }
12353
12354 // set hashfile
12355
12356 switch (hash_mode)
12357 {
12358 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12359 break;
12360 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12361 break;
12362 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12363 break;
12364 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12365 break;
12366 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12367 break;
12368 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12369 break;
12370 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12371 break;
12372 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12373 break;
12374 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12375 break;
12376 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12377 break;
12378 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12379 break;
12380 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12381 break;
12382 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12383 break;
12384 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12385 break;
12386 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12387 break;
12388 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12389 break;
12390 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12391 break;
12392 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12393 break;
12394 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12395 break;
12396 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12397 break;
12398 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12399 break;
12400 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12401 break;
12402 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12403 break;
12404 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12405 break;
12406 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12407 break;
12408 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12409 break;
12410 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12411 break;
12412 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12413 break;
12414 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12415 break;
12416 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12417 break;
12418 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12419 break;
12420 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12421 break;
12422 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12423 break;
12424 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12425 break;
12426 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12427 break;
12428 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12429 break;
12430 }
12431
12432 // set default iterations
12433
12434 switch (hash_mode)
12435 {
12436 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12437 break;
12438 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12439 break;
12440 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12441 break;
12442 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12443 break;
12444 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12445 break;
12446 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12447 break;
12448 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12449 break;
12450 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12451 break;
12452 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12453 break;
12454 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12455 break;
12456 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12457 break;
12458 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12459 break;
12460 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12461 break;
12462 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12463 break;
12464 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12465 break;
12466 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12467 break;
12468 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12469 break;
12470 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12471 break;
12472 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12473 break;
12474 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12475 break;
12476 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12477 break;
12478 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12479 break;
12480 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12481 break;
12482 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12483 break;
12484 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12485 break;
12486 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12487 break;
12488 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12489 break;
12490 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12491 break;
12492 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12493 break;
12494 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12495 break;
12496 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12497 break;
12498 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12499 break;
12500 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12501 break;
12502 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12503 break;
12504 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12505 break;
12506 case 8900: hashes_buf[0].salt->salt_iter = 1;
12507 break;
12508 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12509 break;
12510 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12511 break;
12512 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12513 break;
12514 case 9300: hashes_buf[0].salt->salt_iter = 1;
12515 break;
12516 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12517 break;
12518 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12519 break;
12520 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12521 break;
12522 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12523 break;
12524 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12525 break;
12526 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12527 break;
12528 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12529 break;
12530 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12531 break;
12532 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12533 break;
12534 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12535 break;
12536 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12537 break;
12538 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12539 break;
12540 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12541 break;
12542 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12543 break;
12544 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12545 break;
12546 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12547 break;
12548 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12549 break;
12550 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12551 break;
12552 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12553 break;
12554 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12555 break;
12556 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12557 break;
12558 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12559 break;
12560 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12561 break;
12562 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12563 break;
12564 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12565 break;
12566 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12567 break;
12568 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12569 break;
12570 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12571 break;
12572 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12573 break;
12574 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12575 break;
12576 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12577 break;
12578 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12579 break;
12580 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12581 break;
12582 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12583 break;
12584 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12585 break;
12586 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12587 break;
12588 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12589 break;
12590 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12591 break;
12592 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12593 break;
12594 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12595 break;
12596 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12597 break;
12598 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12599 break;
12600 }
12601
12602 hashes_cnt = 1;
12603 }
12604
12605 if (show == 1 || left == 1)
12606 {
12607 for (uint i = 0; i < pot_cnt; i++)
12608 {
12609 pot_t *pot_ptr = &pot[i];
12610
12611 hash_t *hashes_buf = &pot_ptr->hash;
12612
12613 local_free (hashes_buf->digest);
12614
12615 if (isSalted)
12616 {
12617 local_free (hashes_buf->salt);
12618 }
12619 }
12620
12621 local_free (pot);
12622
12623 if (data.quiet == 0) log_info_nn ("");
12624
12625 return (0);
12626 }
12627
12628 if ((keyspace == 0) && (stdout_flag == 0))
12629 {
12630 if (hashes_cnt == 0)
12631 {
12632 log_error ("ERROR: No hashes loaded");
12633
12634 return (-1);
12635 }
12636 }
12637
12638 /**
12639 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12640 */
12641
12642 if (data.outfile != NULL)
12643 {
12644 if (data.hashfile != NULL)
12645 {
12646 #ifdef _POSIX
12647 struct stat tmpstat_outfile;
12648 struct stat tmpstat_hashfile;
12649 #endif
12650
12651 #ifdef _WIN
12652 struct stat64 tmpstat_outfile;
12653 struct stat64 tmpstat_hashfile;
12654 #endif
12655
12656 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12657
12658 if (tmp_outfile_fp)
12659 {
12660 #ifdef _POSIX
12661 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12662 #endif
12663
12664 #ifdef _WIN
12665 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12666 #endif
12667
12668 fclose (tmp_outfile_fp);
12669 }
12670
12671 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12672
12673 if (tmp_hashfile_fp)
12674 {
12675 #ifdef _POSIX
12676 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12677 #endif
12678
12679 #ifdef _WIN
12680 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12681 #endif
12682
12683 fclose (tmp_hashfile_fp);
12684 }
12685
12686 if (tmp_outfile_fp && tmp_outfile_fp)
12687 {
12688 tmpstat_outfile.st_mode = 0;
12689 tmpstat_outfile.st_nlink = 0;
12690 tmpstat_outfile.st_uid = 0;
12691 tmpstat_outfile.st_gid = 0;
12692 tmpstat_outfile.st_rdev = 0;
12693 tmpstat_outfile.st_atime = 0;
12694
12695 tmpstat_hashfile.st_mode = 0;
12696 tmpstat_hashfile.st_nlink = 0;
12697 tmpstat_hashfile.st_uid = 0;
12698 tmpstat_hashfile.st_gid = 0;
12699 tmpstat_hashfile.st_rdev = 0;
12700 tmpstat_hashfile.st_atime = 0;
12701
12702 #ifdef _POSIX
12703 tmpstat_outfile.st_blksize = 0;
12704 tmpstat_outfile.st_blocks = 0;
12705
12706 tmpstat_hashfile.st_blksize = 0;
12707 tmpstat_hashfile.st_blocks = 0;
12708 #endif
12709
12710 #ifdef _POSIX
12711 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12712 {
12713 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12714
12715 return (-1);
12716 }
12717 #endif
12718
12719 #ifdef _WIN
12720 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12721 {
12722 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12723
12724 return (-1);
12725 }
12726 #endif
12727 }
12728 }
12729 }
12730
12731 /**
12732 * Remove duplicates
12733 */
12734
12735 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12736
12737 if (isSalted)
12738 {
12739 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12740 }
12741 else
12742 {
12743 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12744 }
12745
12746 uint hashes_cnt_orig = hashes_cnt;
12747
12748 hashes_cnt = 1;
12749
12750 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12751 {
12752 if (isSalted)
12753 {
12754 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12755 {
12756 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12757 }
12758 }
12759 else
12760 {
12761 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12762 }
12763
12764 if (hashes_pos > hashes_cnt)
12765 {
12766 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12767 }
12768
12769 hashes_cnt++;
12770 }
12771
12772 /**
12773 * Potfile removes
12774 */
12775
12776 uint potfile_remove_cracks = 0;
12777
12778 if (potfile_disable == 0)
12779 {
12780 hash_t hash_buf;
12781
12782 hash_buf.digest = mymalloc (dgst_size);
12783 hash_buf.salt = NULL;
12784 hash_buf.esalt = NULL;
12785 hash_buf.hash_info = NULL;
12786 hash_buf.cracked = 0;
12787
12788 if (isSalted)
12789 {
12790 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12791 }
12792
12793 if (esalt_size)
12794 {
12795 hash_buf.esalt = mymalloc (esalt_size);
12796 }
12797
12798 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12799
12800 // no solution for these special hash types (for instane because they use hashfile in output etc)
12801 if ((hash_mode != 5200) &&
12802 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12803 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12804 (hash_mode != 9000))
12805 {
12806 FILE *fp = fopen (potfile, "rb");
12807
12808 if (fp != NULL)
12809 {
12810 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12811
12812 // to be safe work with a copy (because of line_len loop, i etc)
12813 // moved up here because it's easier to handle continue case
12814 // it's just 64kb
12815
12816 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12817
12818 while (!feof (fp))
12819 {
12820 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12821
12822 if (ptr == NULL) break;
12823
12824 int line_len = strlen (line_buf);
12825
12826 if (line_len == 0) continue;
12827
12828 int iter = MAX_CUT_TRIES;
12829
12830 for (int i = line_len - 1; i && iter; i--, line_len--)
12831 {
12832 if (line_buf[i] != ':') continue;
12833
12834 if (isSalted)
12835 {
12836 memset (hash_buf.salt, 0, sizeof (salt_t));
12837 }
12838
12839 hash_t *found = NULL;
12840
12841 if (hash_mode == 6800)
12842 {
12843 if (i < 64) // 64 = 16 * uint in salt_buf[]
12844 {
12845 // manipulate salt_buf
12846 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12847
12848 hash_buf.salt->salt_len = i;
12849
12850 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12851 }
12852 }
12853 else if (hash_mode == 2500)
12854 {
12855 if (i < 64) // 64 = 16 * uint in salt_buf[]
12856 {
12857 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12858 // manipulate salt_buf
12859
12860 memcpy (line_buf_cpy, line_buf, i);
12861
12862 char *mac2_pos = strrchr (line_buf_cpy, ':');
12863
12864 if (mac2_pos == NULL) continue;
12865
12866 mac2_pos[0] = 0;
12867 mac2_pos++;
12868
12869 if (strlen (mac2_pos) != 12) continue;
12870
12871 char *mac1_pos = strrchr (line_buf_cpy, ':');
12872
12873 if (mac1_pos == NULL) continue;
12874
12875 mac1_pos[0] = 0;
12876 mac1_pos++;
12877
12878 if (strlen (mac1_pos) != 12) continue;
12879
12880 uint essid_length = mac1_pos - line_buf_cpy - 1;
12881
12882 // here we need the ESSID
12883 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12884
12885 hash_buf.salt->salt_len = essid_length;
12886
12887 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12888
12889 if (found)
12890 {
12891 wpa_t *wpa = (wpa_t *) found->esalt;
12892
12893 // compare hex string(s) vs binary MAC address(es)
12894
12895 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12896 {
12897 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12898 {
12899 found = NULL;
12900
12901 break;
12902 }
12903 }
12904
12905 // early skip ;)
12906 if (!found) continue;
12907
12908 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12909 {
12910 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12911 {
12912 found = NULL;
12913
12914 break;
12915 }
12916 }
12917 }
12918 }
12919 }
12920 else
12921 {
12922 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12923
12924 if (parser_status == PARSER_OK)
12925 {
12926 if (isSalted)
12927 {
12928 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12929 }
12930 else
12931 {
12932 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12933 }
12934 }
12935 }
12936
12937 if (found == NULL) continue;
12938
12939 if (!found->cracked) potfile_remove_cracks++;
12940
12941 found->cracked = 1;
12942
12943 if (found) break;
12944
12945 iter--;
12946 }
12947 }
12948
12949 myfree (line_buf_cpy);
12950
12951 myfree (line_buf);
12952
12953 fclose (fp);
12954 }
12955 }
12956
12957 if (esalt_size)
12958 {
12959 local_free (hash_buf.esalt);
12960 }
12961
12962 if (isSalted)
12963 {
12964 local_free (hash_buf.salt);
12965 }
12966
12967 local_free (hash_buf.digest);
12968 }
12969
12970 /**
12971 * Now generate all the buffers required for later
12972 */
12973
12974 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12975
12976 salt_t *salts_buf_new = NULL;
12977 void *esalts_buf_new = NULL;
12978
12979 if (isSalted)
12980 {
12981 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12982
12983 if (esalt_size)
12984 {
12985 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12986 }
12987 }
12988 else
12989 {
12990 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12991 }
12992
12993 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12994
12995 uint digests_cnt = hashes_cnt;
12996 uint digests_done = 0;
12997
12998 size_t size_digests = digests_cnt * dgst_size;
12999 size_t size_shown = digests_cnt * sizeof (uint);
13000
13001 uint *digests_shown = (uint *) mymalloc (size_shown);
13002 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13003
13004 uint salts_cnt = 0;
13005 uint salts_done = 0;
13006
13007 hashinfo_t **hash_info = NULL;
13008
13009 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13010 {
13011 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13012
13013 if (username && (remove || show))
13014 {
13015 uint user_pos;
13016
13017 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13018 {
13019 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13020
13021 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13022 }
13023 }
13024 }
13025
13026 uint *salts_shown = (uint *) mymalloc (size_shown);
13027
13028 salt_t *salt_buf;
13029
13030 {
13031 // copied from inner loop
13032
13033 salt_buf = &salts_buf_new[salts_cnt];
13034
13035 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13036
13037 if (esalt_size)
13038 {
13039 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13040 }
13041
13042 salt_buf->digests_cnt = 0;
13043 salt_buf->digests_done = 0;
13044 salt_buf->digests_offset = 0;
13045
13046 salts_cnt++;
13047 }
13048
13049 if (hashes_buf[0].cracked == 1)
13050 {
13051 digests_shown[0] = 1;
13052
13053 digests_done++;
13054
13055 salt_buf->digests_done++;
13056 }
13057
13058 salt_buf->digests_cnt++;
13059
13060 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13061
13062 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13063 {
13064 hash_info[0] = hashes_buf[0].hash_info;
13065 }
13066
13067 // copy from inner loop
13068
13069 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13070 {
13071 if (isSalted)
13072 {
13073 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13074 {
13075 salt_buf = &salts_buf_new[salts_cnt];
13076
13077 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13078
13079 if (esalt_size)
13080 {
13081 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13082 }
13083
13084 salt_buf->digests_cnt = 0;
13085 salt_buf->digests_done = 0;
13086 salt_buf->digests_offset = hashes_pos;
13087
13088 salts_cnt++;
13089 }
13090 }
13091
13092 if (hashes_buf[hashes_pos].cracked == 1)
13093 {
13094 digests_shown[hashes_pos] = 1;
13095
13096 digests_done++;
13097
13098 salt_buf->digests_done++;
13099 }
13100
13101 salt_buf->digests_cnt++;
13102
13103 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13104
13105 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13106 {
13107 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13108 }
13109 }
13110
13111 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13112 {
13113 salt_t *salt_buf = &salts_buf_new[salt_pos];
13114
13115 if (salt_buf->digests_done == salt_buf->digests_cnt)
13116 {
13117 salts_shown[salt_pos] = 1;
13118
13119 salts_done++;
13120 }
13121
13122 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13123 }
13124
13125 local_free (digests_buf);
13126 local_free (salts_buf);
13127 local_free (esalts_buf);
13128
13129 digests_buf = digests_buf_new;
13130 salts_buf = salts_buf_new;
13131 esalts_buf = esalts_buf_new;
13132
13133 local_free (hashes_buf);
13134
13135 /**
13136 * special modification not set from parser
13137 */
13138
13139 switch (hash_mode)
13140 {
13141 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13142 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13143 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13144 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13145 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13146 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13147 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13148 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13149 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13150 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13151 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13152 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13153 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13154 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13155 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13156 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13157 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13158 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13159 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13160 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13161 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13162 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13163 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13164 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13165 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13166 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13167 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13168 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13169 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13170 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13171 }
13172
13173 if (truecrypt_keyfiles)
13174 {
13175 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13176
13177 char *keyfiles = strdup (truecrypt_keyfiles);
13178
13179 char *keyfile = strtok (keyfiles, ",");
13180
13181 do
13182 {
13183 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13184
13185 } while ((keyfile = strtok (NULL, ",")) != NULL);
13186
13187 free (keyfiles);
13188 }
13189
13190 if (veracrypt_keyfiles)
13191 {
13192 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13193
13194 char *keyfiles = strdup (veracrypt_keyfiles);
13195
13196 char *keyfile = strtok (keyfiles, ",");
13197
13198 do
13199 {
13200 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13201
13202 } while ((keyfile = strtok (NULL, ",")) != NULL);
13203
13204 free (keyfiles);
13205 }
13206
13207 data.digests_cnt = digests_cnt;
13208 data.digests_done = digests_done;
13209 data.digests_buf = digests_buf;
13210 data.digests_shown = digests_shown;
13211 data.digests_shown_tmp = digests_shown_tmp;
13212
13213 data.salts_cnt = salts_cnt;
13214 data.salts_done = salts_done;
13215 data.salts_buf = salts_buf;
13216 data.salts_shown = salts_shown;
13217
13218 data.esalts_buf = esalts_buf;
13219 data.hash_info = hash_info;
13220
13221 /**
13222 * Automatic Optimizers
13223 */
13224
13225 if (salts_cnt == 1)
13226 opti_type |= OPTI_TYPE_SINGLE_SALT;
13227
13228 if (digests_cnt == 1)
13229 opti_type |= OPTI_TYPE_SINGLE_HASH;
13230
13231 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13232 opti_type |= OPTI_TYPE_NOT_ITERATED;
13233
13234 if (attack_mode == ATTACK_MODE_BF)
13235 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13236
13237 data.opti_type = opti_type;
13238
13239 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13240 {
13241 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13242 {
13243 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13244 {
13245 if (opts_type & OPTS_TYPE_ST_ADD80)
13246 {
13247 opts_type &= ~OPTS_TYPE_ST_ADD80;
13248 opts_type |= OPTS_TYPE_PT_ADD80;
13249 }
13250
13251 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13252 {
13253 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13254 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13255 }
13256
13257 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13258 {
13259 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13260 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13261 }
13262 }
13263 }
13264 }
13265
13266 /**
13267 * Some algorithm, like descrypt, can benefit from JIT compilation
13268 */
13269
13270 int force_jit_compilation = -1;
13271
13272 if (hash_mode == 8900)
13273 {
13274 force_jit_compilation = 8900;
13275 }
13276 else if (hash_mode == 9300)
13277 {
13278 force_jit_compilation = 8900;
13279 }
13280 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13281 {
13282 force_jit_compilation = 1500;
13283 }
13284
13285 /**
13286 * generate bitmap tables
13287 */
13288
13289 const uint bitmap_shift1 = 5;
13290 const uint bitmap_shift2 = 13;
13291
13292 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13293
13294 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13295 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13296 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13297 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13298 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13299 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13300 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13301 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13302
13303 uint bitmap_bits;
13304 uint bitmap_nums;
13305 uint bitmap_mask;
13306 uint bitmap_size;
13307
13308 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13309 {
13310 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13311
13312 bitmap_nums = 1 << bitmap_bits;
13313
13314 bitmap_mask = bitmap_nums - 1;
13315
13316 bitmap_size = bitmap_nums * sizeof (uint);
13317
13318 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13319
13320 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
13321 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
13322
13323 break;
13324 }
13325
13326 bitmap_nums = 1 << bitmap_bits;
13327
13328 bitmap_mask = bitmap_nums - 1;
13329
13330 bitmap_size = bitmap_nums * sizeof (uint);
13331
13332 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
13333 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
13334
13335 /**
13336 * prepare quick rule
13337 */
13338
13339 data.rule_buf_l = rule_buf_l;
13340 data.rule_buf_r = rule_buf_r;
13341
13342 int rule_len_l = (int) strlen (rule_buf_l);
13343 int rule_len_r = (int) strlen (rule_buf_r);
13344
13345 data.rule_len_l = rule_len_l;
13346 data.rule_len_r = rule_len_r;
13347
13348 /**
13349 * load rules
13350 */
13351
13352 uint *all_kernel_rules_cnt = NULL;
13353
13354 kernel_rule_t **all_kernel_rules_buf = NULL;
13355
13356 if (rp_files_cnt)
13357 {
13358 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13359
13360 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13361 }
13362
13363 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13364
13365 int rule_len = 0;
13366
13367 for (uint i = 0; i < rp_files_cnt; i++)
13368 {
13369 uint kernel_rules_avail = 0;
13370
13371 uint kernel_rules_cnt = 0;
13372
13373 kernel_rule_t *kernel_rules_buf = NULL;
13374
13375 char *rp_file = rp_files[i];
13376
13377 char in[BLOCK_SIZE] = { 0 };
13378 char out[BLOCK_SIZE] = { 0 };
13379
13380 FILE *fp = NULL;
13381
13382 uint rule_line = 0;
13383
13384 if ((fp = fopen (rp_file, "rb")) == NULL)
13385 {
13386 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13387
13388 return (-1);
13389 }
13390
13391 while (!feof (fp))
13392 {
13393 memset (rule_buf, 0, HCBUFSIZ);
13394
13395 rule_len = fgetl (fp, rule_buf);
13396
13397 rule_line++;
13398
13399 if (rule_len == 0) continue;
13400
13401 if (rule_buf[0] == '#') continue;
13402
13403 if (kernel_rules_avail == kernel_rules_cnt)
13404 {
13405 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13406
13407 kernel_rules_avail += INCR_RULES;
13408 }
13409
13410 memset (in, 0, BLOCK_SIZE);
13411 memset (out, 0, BLOCK_SIZE);
13412
13413 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13414
13415 if (result == -1)
13416 {
13417 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13418
13419 continue;
13420 }
13421
13422 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13423 {
13424 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13425
13426 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13427
13428 continue;
13429 }
13430
13431 /* its so slow
13432 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13433 {
13434 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13435
13436 continue;
13437 }
13438 */
13439
13440 kernel_rules_cnt++;
13441 }
13442
13443 fclose (fp);
13444
13445 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13446
13447 all_kernel_rules_buf[i] = kernel_rules_buf;
13448 }
13449
13450 /**
13451 * merge rules or automatic rule generator
13452 */
13453
13454 uint kernel_rules_cnt = 0;
13455
13456 kernel_rule_t *kernel_rules_buf = NULL;
13457
13458 if (attack_mode == ATTACK_MODE_STRAIGHT)
13459 {
13460 if (rp_files_cnt)
13461 {
13462 kernel_rules_cnt = 1;
13463
13464 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13465
13466 repeats[0] = kernel_rules_cnt;
13467
13468 for (uint i = 0; i < rp_files_cnt; i++)
13469 {
13470 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13471
13472 repeats[i + 1] = kernel_rules_cnt;
13473 }
13474
13475 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13476
13477 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13478
13479 for (uint i = 0; i < kernel_rules_cnt; i++)
13480 {
13481 uint out_pos = 0;
13482
13483 kernel_rule_t *out = &kernel_rules_buf[i];
13484
13485 for (uint j = 0; j < rp_files_cnt; j++)
13486 {
13487 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13488 uint in_pos;
13489
13490 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13491
13492 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13493 {
13494 if (out_pos == RULES_MAX - 1)
13495 {
13496 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13497
13498 break;
13499 }
13500
13501 out->cmds[out_pos] = in->cmds[in_pos];
13502 }
13503 }
13504 }
13505
13506 local_free (repeats);
13507 }
13508 else if (rp_gen)
13509 {
13510 uint kernel_rules_avail = 0;
13511
13512 while (kernel_rules_cnt < rp_gen)
13513 {
13514 if (kernel_rules_avail == kernel_rules_cnt)
13515 {
13516 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13517
13518 kernel_rules_avail += INCR_RULES;
13519 }
13520
13521 memset (rule_buf, 0, HCBUFSIZ);
13522
13523 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13524
13525 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13526
13527 kernel_rules_cnt++;
13528 }
13529 }
13530 }
13531
13532 myfree (rule_buf);
13533
13534 /**
13535 * generate NOP rules
13536 */
13537
13538 if (kernel_rules_cnt == 0)
13539 {
13540 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13541
13542 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13543
13544 kernel_rules_cnt++;
13545 }
13546
13547 data.kernel_rules_cnt = kernel_rules_cnt;
13548 data.kernel_rules_buf = kernel_rules_buf;
13549
13550 /**
13551 * OpenCL platforms: detect
13552 */
13553
13554 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13555 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13556
13557 cl_uint platforms_cnt = 0;
13558 cl_uint platform_devices_cnt = 0;
13559
13560 if (keyspace == 0)
13561 {
13562 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13563
13564 if (platforms_cnt == 0)
13565 {
13566 log_info ("");
13567 log_info ("ATTENTION! No OpenCL compatible platform found");
13568 log_info ("");
13569 log_info ("You're probably missing the OpenCL runtime installation");
13570 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13571 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13572 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13573 log_info ("");
13574
13575 return (-1);
13576 }
13577
13578 if (opencl_platforms_filter != (uint) -1)
13579 {
13580 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13581
13582 if (opencl_platforms_filter > platform_cnt_mask)
13583 {
13584 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13585
13586 return (-1);
13587 }
13588 }
13589 }
13590
13591 /**
13592 * OpenCL device types:
13593 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13594 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13595 */
13596
13597 if (opencl_device_types == NULL)
13598 {
13599 cl_device_type device_types_all = 0;
13600
13601 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13602 {
13603 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13604
13605 cl_platform_id platform = platforms[platform_id];
13606
13607 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13608
13609 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13610 {
13611 cl_device_id device = platform_devices[platform_devices_id];
13612
13613 cl_device_type device_type;
13614
13615 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13616
13617 device_types_all |= device_type;
13618 }
13619 }
13620
13621 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13622 {
13623 device_types_filter |= CL_DEVICE_TYPE_CPU;
13624 }
13625 }
13626
13627 /**
13628 * OpenCL devices: simply push all devices from all platforms into the same device array
13629 */
13630
13631 int need_adl = 0;
13632 int need_nvapi = 0;
13633 int need_nvml = 0;
13634
13635 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13636
13637 data.devices_param = devices_param;
13638
13639 uint devices_cnt = 0;
13640
13641 uint devices_active = 0;
13642
13643 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13644 {
13645 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13646
13647 cl_platform_id platform = platforms[platform_id];
13648
13649 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13650
13651 char platform_vendor[INFOSZ] = { 0 };
13652
13653 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13654
13655 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13656 // this causes trouble with vendor id based macros
13657 // we'll assign generic to those without special optimization available
13658
13659 cl_uint platform_vendor_id = 0;
13660
13661 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13662 {
13663 platform_vendor_id = VENDOR_ID_AMD;
13664 }
13665 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13666 {
13667 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13668 }
13669 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13670 {
13671 platform_vendor_id = VENDOR_ID_APPLE;
13672 }
13673 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13674 {
13675 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13676 }
13677 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13678 {
13679 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13680 }
13681 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13682 {
13683 platform_vendor_id = VENDOR_ID_MESA;
13684 }
13685 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13686 {
13687 platform_vendor_id = VENDOR_ID_NV;
13688 }
13689 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13690 {
13691 platform_vendor_id = VENDOR_ID_POCL;
13692 }
13693 else
13694 {
13695 platform_vendor_id = VENDOR_ID_GENERIC;
13696 }
13697
13698 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13699 {
13700 size_t param_value_size = 0;
13701
13702 const uint device_id = devices_cnt;
13703
13704 hc_device_param_t *device_param = &data.devices_param[device_id];
13705
13706 device_param->platform_vendor_id = platform_vendor_id;
13707
13708 device_param->device = platform_devices[platform_devices_id];
13709
13710 device_param->device_id = device_id;
13711
13712 device_param->platform_devices_id = platform_devices_id;
13713
13714 // device_type
13715
13716 cl_device_type device_type;
13717
13718 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13719
13720 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13721
13722 device_param->device_type = device_type;
13723
13724 // device_name
13725
13726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13727
13728 char *device_name = (char *) mymalloc (param_value_size);
13729
13730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13731
13732 device_param->device_name = device_name;
13733
13734 // device_vendor
13735
13736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13737
13738 char *device_vendor = (char *) mymalloc (param_value_size);
13739
13740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13741
13742 device_param->device_vendor = device_vendor;
13743
13744 cl_uint device_vendor_id = 0;
13745
13746 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13747 {
13748 device_vendor_id = VENDOR_ID_AMD;
13749 }
13750 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13751 {
13752 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13753 }
13754 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13755 {
13756 device_vendor_id = VENDOR_ID_APPLE;
13757 }
13758 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13759 {
13760 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13761 }
13762 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13763 {
13764 device_vendor_id = VENDOR_ID_INTEL_SDK;
13765 }
13766 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13767 {
13768 device_vendor_id = VENDOR_ID_MESA;
13769 }
13770 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13771 {
13772 device_vendor_id = VENDOR_ID_NV;
13773 }
13774 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13775 {
13776 device_vendor_id = VENDOR_ID_POCL;
13777 }
13778 else
13779 {
13780 device_vendor_id = VENDOR_ID_GENERIC;
13781 }
13782
13783 device_param->device_vendor_id = device_vendor_id;
13784
13785 // tuning db
13786
13787 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13788
13789 // device_version
13790
13791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13792
13793 char *device_version = (char *) mymalloc (param_value_size);
13794
13795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13796
13797 device_param->device_version = device_version;
13798
13799 // device_opencl_version
13800
13801 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13802
13803 char *device_opencl_version = (char *) mymalloc (param_value_size);
13804
13805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13806
13807 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13808
13809 myfree (device_opencl_version);
13810
13811 // vector_width
13812
13813 cl_uint vector_width;
13814
13815 if (opencl_vector_width_chgd == 0)
13816 {
13817 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13818 {
13819 if (opti_type & OPTI_TYPE_USES_BITS_64)
13820 {
13821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13822 }
13823 else
13824 {
13825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13826 }
13827 }
13828 else
13829 {
13830 vector_width = (cl_uint) tuningdb_entry->vector_width;
13831 }
13832 }
13833 else
13834 {
13835 vector_width = opencl_vector_width;
13836 }
13837
13838 if (vector_width > 16) vector_width = 16;
13839
13840 device_param->vector_width = vector_width;
13841
13842 // max_compute_units
13843
13844 cl_uint device_processors;
13845
13846 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13847
13848 device_param->device_processors = device_processors;
13849
13850 // device_maxmem_alloc
13851 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13852
13853 cl_ulong device_maxmem_alloc;
13854
13855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13856
13857 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13858
13859 // device_global_mem
13860
13861 cl_ulong device_global_mem;
13862
13863 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13864
13865 device_param->device_global_mem = device_global_mem;
13866
13867 // max_work_group_size
13868
13869 size_t device_maxworkgroup_size;
13870
13871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13872
13873 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13874
13875 // max_clock_frequency
13876
13877 cl_uint device_maxclock_frequency;
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13880
13881 device_param->device_maxclock_frequency = device_maxclock_frequency;
13882
13883 // device_endian_little
13884
13885 cl_bool device_endian_little;
13886
13887 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13888
13889 if (device_endian_little == CL_FALSE)
13890 {
13891 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13892
13893 device_param->skipped = 1;
13894 }
13895
13896 // device_available
13897
13898 cl_bool device_available;
13899
13900 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13901
13902 if (device_available == CL_FALSE)
13903 {
13904 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13905
13906 device_param->skipped = 1;
13907 }
13908
13909 // device_compiler_available
13910
13911 cl_bool device_compiler_available;
13912
13913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13914
13915 if (device_compiler_available == CL_FALSE)
13916 {
13917 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13918
13919 device_param->skipped = 1;
13920 }
13921
13922 // device_execution_capabilities
13923
13924 cl_device_exec_capabilities device_execution_capabilities;
13925
13926 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13927
13928 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13929 {
13930 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13931
13932 device_param->skipped = 1;
13933 }
13934
13935 // device_extensions
13936
13937 size_t device_extensions_size;
13938
13939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13940
13941 char *device_extensions = mymalloc (device_extensions_size + 1);
13942
13943 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13944
13945 if (strstr (device_extensions, "base_atomics") == 0)
13946 {
13947 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13948
13949 device_param->skipped = 1;
13950 }
13951
13952 if (strstr (device_extensions, "byte_addressable_store") == 0)
13953 {
13954 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13955
13956 device_param->skipped = 1;
13957 }
13958
13959 myfree (device_extensions);
13960
13961 // device_local_mem_size
13962
13963 cl_ulong device_local_mem_size;
13964
13965 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13966
13967 if (device_local_mem_size < 32768)
13968 {
13969 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13970
13971 device_param->skipped = 1;
13972 }
13973
13974 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13975 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13976 // This results in both utilizing it for 50%
13977 // However, Intel has much better SIMD control over their own hardware
13978 // It makes sense to give them full control over their own hardware
13979
13980 if (device_type & CL_DEVICE_TYPE_CPU)
13981 {
13982 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13983 {
13984 if (data.force == 0)
13985 {
13986 if (algorithm_pos == 0)
13987 {
13988 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13989 log_info (" You can use --force to override this but do not post error reports if you do so");
13990 }
13991
13992 device_param->skipped = 1;
13993 }
13994 }
13995 }
13996
13997 // skipped
13998
13999 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14000 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14001
14002 // driver_version
14003
14004 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14005
14006 char *driver_version = (char *) mymalloc (param_value_size);
14007
14008 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14009
14010 device_param->driver_version = driver_version;
14011
14012 // device_name_chksum
14013
14014 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14015
14016 #if __x86_64__
14017 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
14018 #else
14019 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
14020 #endif
14021
14022 uint device_name_digest[4] = { 0 };
14023
14024 md5_64 ((uint *) device_name_chksum, device_name_digest);
14025
14026 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14027
14028 device_param->device_name_chksum = device_name_chksum;
14029
14030 // device_processor_cores
14031
14032 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14033 {
14034 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14035 {
14036 need_adl = 1;
14037 }
14038
14039 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14040 {
14041 need_nvml = 1;
14042
14043 #ifdef _WIN
14044 need_nvapi = 1;
14045 #endif
14046 }
14047 }
14048
14049 // device_processor_cores
14050
14051 if (device_type & CL_DEVICE_TYPE_CPU)
14052 {
14053 cl_uint device_processor_cores = 1;
14054
14055 device_param->device_processor_cores = device_processor_cores;
14056 }
14057
14058 if (device_type & CL_DEVICE_TYPE_GPU)
14059 {
14060 if (device_vendor_id == VENDOR_ID_AMD)
14061 {
14062 cl_uint device_processor_cores = 0;
14063
14064 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14065
14066 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14067
14068 device_param->device_processor_cores = device_processor_cores;
14069 }
14070 else if (device_vendor_id == VENDOR_ID_NV)
14071 {
14072 cl_uint kernel_exec_timeout = 0;
14073
14074 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14075
14076 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14077
14078 device_param->kernel_exec_timeout = kernel_exec_timeout;
14079
14080 cl_uint device_processor_cores = 0;
14081
14082 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14083
14084 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14085
14086 device_param->device_processor_cores = device_processor_cores;
14087
14088 cl_uint sm_minor = 0;
14089 cl_uint sm_major = 0;
14090
14091 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14092 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14093
14094 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14095 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14096
14097 device_param->sm_minor = sm_minor;
14098 device_param->sm_major = sm_major;
14099 }
14100 else
14101 {
14102 cl_uint device_processor_cores = 1;
14103
14104 device_param->device_processor_cores = device_processor_cores;
14105 }
14106 }
14107
14108 // display results
14109
14110 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14111 {
14112 if (machine_readable == 0)
14113 {
14114 if (device_param->skipped == 0)
14115 {
14116 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14117 device_id + 1,
14118 device_name,
14119 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14120 (unsigned int) (device_global_mem / 1024 / 1024),
14121 (unsigned int) device_processors);
14122 }
14123 else
14124 {
14125 log_info ("Device #%u: %s, skipped",
14126 device_id + 1,
14127 device_name);
14128 }
14129 }
14130 }
14131
14132 // common driver check
14133
14134 if (device_param->skipped == 0)
14135 {
14136 if (device_type & CL_DEVICE_TYPE_GPU)
14137 {
14138 if (platform_vendor_id == VENDOR_ID_AMD)
14139 {
14140 int catalyst_check = (force == 1) ? 0 : 1;
14141
14142 int catalyst_warn = 0;
14143
14144 int catalyst_broken = 0;
14145
14146 if (catalyst_check == 1)
14147 {
14148 catalyst_warn = 1;
14149
14150 // v14.9 and higher
14151 if (atoi (device_param->driver_version) >= 1573)
14152 {
14153 catalyst_warn = 0;
14154 }
14155
14156 catalyst_check = 0;
14157 }
14158
14159 if (catalyst_broken == 1)
14160 {
14161 log_info ("");
14162 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14163 log_info ("It will pass over cracked hashes and does not report them as cracked");
14164 log_info ("You are STRONGLY encouraged not to use it");
14165 log_info ("You can use --force to override this but do not post error reports if you do so");
14166 log_info ("");
14167
14168 return (-1);
14169 }
14170
14171 if (catalyst_warn == 1)
14172 {
14173 log_info ("");
14174 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14175 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14176 log_info ("See hashcat's homepage for official supported catalyst drivers");
14177 #ifdef _WIN
14178 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14179 #endif
14180 log_info ("You can use --force to override this but do not post error reports if you do so");
14181 log_info ("");
14182
14183 return (-1);
14184 }
14185 }
14186 else if (platform_vendor_id == VENDOR_ID_NV)
14187 {
14188 if (device_param->kernel_exec_timeout != 0)
14189 {
14190 if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
14191 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14192 }
14193 }
14194 }
14195
14196 /* turns out pocl still creates segfaults (because of llvm)
14197 if (device_type & CL_DEVICE_TYPE_CPU)
14198 {
14199 if (platform_vendor_id == VENDOR_ID_AMD)
14200 {
14201 if (force == 0)
14202 {
14203 log_info ("");
14204 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14205 log_info ("You are STRONGLY encouraged not to use it");
14206 log_info ("You can use --force to override this but do not post error reports if you do so");
14207 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14208 log_info ("");
14209
14210 return (-1);
14211 }
14212 }
14213 }
14214 */
14215
14216 /**
14217 * kernel accel and loops tuning db adjustment
14218 */
14219
14220 device_param->kernel_accel_min = 1;
14221 device_param->kernel_accel_max = 1024;
14222
14223 device_param->kernel_loops_min = 1;
14224 device_param->kernel_loops_max = 1024;
14225
14226 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14227
14228 if (tuningdb_entry)
14229 {
14230 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14231 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14232
14233 if (_kernel_accel)
14234 {
14235 device_param->kernel_accel_min = _kernel_accel;
14236 device_param->kernel_accel_max = _kernel_accel;
14237 }
14238
14239 if (_kernel_loops)
14240 {
14241 if (workload_profile == 1)
14242 {
14243 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14244 }
14245 else if (workload_profile == 2)
14246 {
14247 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14248 }
14249
14250 device_param->kernel_loops_min = _kernel_loops;
14251 device_param->kernel_loops_max = _kernel_loops;
14252 }
14253 }
14254
14255 // commandline parameters overwrite tuningdb entries
14256
14257 if (kernel_accel)
14258 {
14259 device_param->kernel_accel_min = kernel_accel;
14260 device_param->kernel_accel_max = kernel_accel;
14261 }
14262
14263 if (kernel_loops)
14264 {
14265 device_param->kernel_loops_min = kernel_loops;
14266 device_param->kernel_loops_max = kernel_loops;
14267 }
14268
14269 /**
14270 * activate device
14271 */
14272
14273 devices_active++;
14274 }
14275
14276 // next please
14277
14278 devices_cnt++;
14279 }
14280 }
14281
14282 if (keyspace == 0 && devices_active == 0)
14283 {
14284 log_error ("ERROR: No devices found/left");
14285
14286 return (-1);
14287 }
14288
14289 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
14290
14291 if (devices_filter != (uint) -1)
14292 {
14293 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14294
14295 if (devices_filter > devices_cnt_mask)
14296 {
14297 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14298
14299 return (-1);
14300 }
14301 }
14302
14303 data.devices_cnt = devices_cnt;
14304
14305 data.devices_active = devices_active;
14306
14307 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14308 {
14309 if (machine_readable == 0)
14310 {
14311 log_info ("");
14312 }
14313 }
14314
14315 /**
14316 * HM devices: init
14317 */
14318
14319 #ifdef HAVE_HWMON
14320 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14321 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14322 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14323
14324 if (gpu_temp_disable == 0)
14325 {
14326 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14327 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14328 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14329
14330 data.hm_adl = NULL;
14331 data.hm_nvapi = NULL;
14332 data.hm_nvml = NULL;
14333
14334 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14335 {
14336 data.hm_nvml = nvml;
14337 }
14338
14339 if (data.hm_nvml)
14340 {
14341 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14342 {
14343 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14344
14345 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14346
14347 int tmp_out = 0;
14348
14349 for (int i = 0; i < tmp_in; i++)
14350 {
14351 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14352 }
14353
14354 for (int i = 0; i < tmp_out; i++)
14355 {
14356 unsigned int speed;
14357
14358 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14359
14360 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14361
14362 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14363 }
14364 }
14365 }
14366
14367 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14368 {
14369 data.hm_nvapi = nvapi;
14370 }
14371
14372 if (data.hm_nvapi)
14373 {
14374 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14375 {
14376 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14377
14378 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14379
14380 int tmp_out = 0;
14381
14382 for (int i = 0; i < tmp_in; i++)
14383 {
14384 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14385 }
14386 }
14387 }
14388
14389 if ((need_adl == 1) && (adl_init (adl) == 0))
14390 {
14391 data.hm_adl = adl;
14392 }
14393
14394 if (data.hm_adl)
14395 {
14396 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14397 {
14398 // total number of adapters
14399
14400 int hm_adapters_num;
14401
14402 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14403
14404 // adapter info
14405
14406 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14407
14408 if (lpAdapterInfo == NULL) return (-1);
14409
14410 // get a list (of ids of) valid/usable adapters
14411
14412 int num_adl_adapters = 0;
14413
14414 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14415
14416 if (num_adl_adapters > 0)
14417 {
14418 hc_thread_mutex_lock (mux_adl);
14419
14420 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14421
14422 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14423
14424 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14425 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14426
14427 hc_thread_mutex_unlock (mux_adl);
14428 }
14429
14430 myfree (valid_adl_device_list);
14431 myfree (lpAdapterInfo);
14432 }
14433 }
14434
14435 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14436 {
14437 gpu_temp_disable = 1;
14438 }
14439 }
14440
14441 /**
14442 * OpenCL devices: allocate buffer for device specific information
14443 */
14444
14445 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14446 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14447
14448 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14449
14450 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14451
14452 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14453
14454 /**
14455 * User-defined GPU temp handling
14456 */
14457
14458 if (gpu_temp_disable == 1)
14459 {
14460 gpu_temp_abort = 0;
14461 gpu_temp_retain = 0;
14462 }
14463
14464 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14465 {
14466 if (gpu_temp_abort < gpu_temp_retain)
14467 {
14468 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14469
14470 return (-1);
14471 }
14472 }
14473
14474 data.gpu_temp_disable = gpu_temp_disable;
14475 data.gpu_temp_abort = gpu_temp_abort;
14476 data.gpu_temp_retain = gpu_temp_retain;
14477 #endif
14478
14479 /**
14480 * enable custom signal handler(s)
14481 */
14482
14483 if (benchmark == 0)
14484 {
14485 hc_signal (sigHandler_default);
14486 }
14487 else
14488 {
14489 hc_signal (sigHandler_benchmark);
14490 }
14491
14492 /**
14493 * inform the user
14494 */
14495
14496 if (data.quiet == 0)
14497 {
14498 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14499
14500 log_info ("Bitmaps: %u bits, %u entries, 0x%08x mask, %u bytes, %u/%u rotates", bitmap_bits, bitmap_nums, bitmap_mask, bitmap_size, bitmap_shift1, bitmap_shift2);
14501
14502 if (attack_mode == ATTACK_MODE_STRAIGHT)
14503 {
14504 log_info ("Rules: %u", kernel_rules_cnt);
14505 }
14506
14507 if (opti_type)
14508 {
14509 log_info ("Applicable Optimizers:");
14510
14511 for (uint i = 0; i < 32; i++)
14512 {
14513 const uint opti_bit = 1u << i;
14514
14515 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14516 }
14517 }
14518
14519 /**
14520 * Watchdog and Temperature balance
14521 */
14522
14523 #ifdef HAVE_HWMON
14524 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14525 {
14526 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14527 }
14528
14529 if (gpu_temp_abort == 0)
14530 {
14531 log_info ("Watchdog: Temperature abort trigger disabled");
14532 }
14533 else
14534 {
14535 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14536 }
14537
14538 if (gpu_temp_retain == 0)
14539 {
14540 log_info ("Watchdog: Temperature retain trigger disabled");
14541 }
14542 else
14543 {
14544 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14545 }
14546
14547 if (data.quiet == 0) log_info ("");
14548 #endif
14549 }
14550
14551 #ifdef HAVE_HWMON
14552
14553 /**
14554 * HM devices: copy
14555 */
14556
14557 if (gpu_temp_disable == 0)
14558 {
14559 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14560 {
14561 hc_device_param_t *device_param = &data.devices_param[device_id];
14562
14563 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14564
14565 if (device_param->skipped) continue;
14566
14567 const uint platform_devices_id = device_param->platform_devices_id;
14568
14569 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14570 {
14571 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14572 data.hm_device[device_id].nvapi = 0;
14573 data.hm_device[device_id].nvml = 0;
14574 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14575 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14576 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14577 }
14578
14579 if (device_param->device_vendor_id == VENDOR_ID_NV)
14580 {
14581 data.hm_device[device_id].adl = 0;
14582 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14583 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14584 data.hm_device[device_id].od_version = 0;
14585 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14586 data.hm_device[device_id].fan_set_supported = 0;
14587 }
14588 }
14589 }
14590
14591 /**
14592 * powertune on user request
14593 */
14594
14595 if (powertune_enable == 1)
14596 {
14597 hc_thread_mutex_lock (mux_adl);
14598
14599 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14600 {
14601 hc_device_param_t *device_param = &data.devices_param[device_id];
14602
14603 if (device_param->skipped) continue;
14604
14605 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14606 {
14607 /**
14608 * Temporary fix:
14609 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14610 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14611 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14612 * Driver / ADL bug?
14613 */
14614
14615 if (data.hm_device[device_id].od_version == 6)
14616 {
14617 int ADL_rc;
14618
14619 // check powertune capabilities first, if not available then skip device
14620
14621 int powertune_supported = 0;
14622
14623 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14624 {
14625 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14626
14627 return (-1);
14628 }
14629
14630 // first backup current value, we will restore it later
14631
14632 if (powertune_supported != 0)
14633 {
14634 // powercontrol settings
14635
14636 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14637
14638 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14639 {
14640 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14641 }
14642
14643 if (ADL_rc != ADL_OK)
14644 {
14645 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14646
14647 return (-1);
14648 }
14649
14650 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14651 {
14652 log_error ("ERROR: Failed to set new ADL PowerControl values");
14653
14654 return (-1);
14655 }
14656
14657 // clocks
14658
14659 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14660
14661 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14662
14663 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14664 {
14665 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14666
14667 return (-1);
14668 }
14669
14670 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14671
14672 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14673
14674 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14675 {
14676 log_error ("ERROR: Failed to get ADL device capabilities");
14677
14678 return (-1);
14679 }
14680
14681 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14682 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14683
14684 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14685 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14686
14687 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14688 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14689
14690 // warning if profile has too low max values
14691
14692 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14693 {
14694 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14695 }
14696
14697 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14698 {
14699 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14700 }
14701
14702 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14703
14704 performance_state->iNumberOfPerformanceLevels = 2;
14705
14706 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14707 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14708 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14709 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14710
14711 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14712 {
14713 log_info ("ERROR: Failed to set ADL performance state");
14714
14715 return (-1);
14716 }
14717
14718 local_free (performance_state);
14719 }
14720
14721 // set powertune value only
14722
14723 if (powertune_supported != 0)
14724 {
14725 // powertune set
14726 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14727
14728 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14729 {
14730 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14731
14732 return (-1);
14733 }
14734
14735 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14736 {
14737 log_error ("ERROR: Failed to set new ADL PowerControl values");
14738
14739 return (-1);
14740 }
14741 }
14742 }
14743 }
14744
14745 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14746 {
14747 // first backup current value, we will restore it later
14748
14749 unsigned int limit;
14750
14751 int powertune_supported = 0;
14752
14753 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14754 {
14755 powertune_supported = 1;
14756 }
14757
14758 // if backup worked, activate the maximum allowed
14759
14760 if (powertune_supported != 0)
14761 {
14762 unsigned int minLimit;
14763 unsigned int maxLimit;
14764
14765 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14766 {
14767 if (maxLimit > 0)
14768 {
14769 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14770 {
14771 // now we can be sure we need to reset later
14772
14773 nvml_power_limit[device_id] = limit;
14774 }
14775 }
14776 }
14777 }
14778 }
14779 }
14780
14781 hc_thread_mutex_unlock (mux_adl);
14782 }
14783
14784 #endif // HAVE_HWMON
14785
14786 #ifdef DEBUG
14787 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14788 #endif
14789
14790 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14791
14792 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14793 {
14794 /**
14795 * host buffer
14796 */
14797
14798 hc_device_param_t *device_param = &data.devices_param[device_id];
14799
14800 if (device_param->skipped) continue;
14801
14802 /**
14803 * device properties
14804 */
14805
14806 const char *device_name_chksum = device_param->device_name_chksum;
14807 const u32 device_processors = device_param->device_processors;
14808 const u32 device_processor_cores = device_param->device_processor_cores;
14809
14810 /**
14811 * create context for each device
14812 */
14813
14814 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14815
14816 /**
14817 * create command-queue
14818 */
14819
14820 // not supported with NV
14821 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14822
14823 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14824
14825 /**
14826 * kernel threads: some algorithms need a fixed kernel-threads count
14827 * because of shared memory usage or bitslice
14828 * there needs to be some upper limit, otherwise there's too much overhead
14829 */
14830
14831 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14832
14833 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14834 {
14835 kernel_threads = KERNEL_THREADS_MAX_CPU;
14836 }
14837
14838 if (hash_mode == 1500) kernel_threads = 64; // DES
14839 if (hash_mode == 3000) kernel_threads = 64; // DES
14840 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14841 if (hash_mode == 7500) kernel_threads = 64; // RC4
14842 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14843 if (hash_mode == 9700) kernel_threads = 64; // RC4
14844 if (hash_mode == 9710) kernel_threads = 64; // RC4
14845 if (hash_mode == 9800) kernel_threads = 64; // RC4
14846 if (hash_mode == 9810) kernel_threads = 64; // RC4
14847 if (hash_mode == 10400) kernel_threads = 64; // RC4
14848 if (hash_mode == 10410) kernel_threads = 64; // RC4
14849 if (hash_mode == 10500) kernel_threads = 64; // RC4
14850 if (hash_mode == 13100) kernel_threads = 64; // RC4
14851
14852 device_param->kernel_threads = kernel_threads;
14853
14854 device_param->hardware_power = device_processors * kernel_threads;
14855
14856 /**
14857 * create input buffers on device : calculate size of fixed memory buffers
14858 */
14859
14860 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14861 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14862
14863 device_param->size_root_css = size_root_css;
14864 device_param->size_markov_css = size_markov_css;
14865
14866 size_t size_results = sizeof (uint);
14867
14868 device_param->size_results = size_results;
14869
14870 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14871 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14872
14873 size_t size_plains = digests_cnt * sizeof (plain_t);
14874 size_t size_salts = salts_cnt * sizeof (salt_t);
14875 size_t size_esalts = salts_cnt * esalt_size;
14876
14877 device_param->size_plains = size_plains;
14878 device_param->size_digests = size_digests;
14879 device_param->size_shown = size_shown;
14880 device_param->size_salts = size_salts;
14881
14882 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14883 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14884 size_t size_tm = 32 * sizeof (bs_word_t);
14885
14886 // scryptV stuff
14887
14888 size_t size_scryptV = 1;
14889
14890 if ((hash_mode == 8900) || (hash_mode == 9300))
14891 {
14892 uint tmto_start = 0;
14893 uint tmto_stop = 10;
14894
14895 if (scrypt_tmto)
14896 {
14897 tmto_start = scrypt_tmto;
14898 }
14899 else
14900 {
14901 // in case the user did not specify the tmto manually
14902 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14903 // but set the lower end only in case the user has a device with too less memory
14904
14905 if (hash_mode == 8900)
14906 {
14907 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14908 {
14909 tmto_start = 1;
14910 }
14911 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14912 {
14913 tmto_start = 2;
14914 }
14915 }
14916 else if (hash_mode == 9300)
14917 {
14918 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14919 {
14920 tmto_start = 2;
14921 }
14922 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14923 {
14924 tmto_start = 2;
14925 }
14926 }
14927 }
14928
14929 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14930 {
14931 // TODO: in theory the following calculation needs to be done per salt, not global
14932 // we assume all hashes have the same scrypt settings
14933
14934 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14935
14936 size_scryptV /= 1 << tmto;
14937
14938 size_scryptV *= device_processors * device_processor_cores;
14939
14940 if (size_scryptV > device_param->device_maxmem_alloc)
14941 {
14942 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14943
14944 continue;
14945 }
14946
14947 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14948 {
14949 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14950 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14951 }
14952
14953 break;
14954 }
14955
14956 if (data.salts_buf[0].scrypt_phy == 0)
14957 {
14958 log_error ("ERROR: can't allocate enough device memory");
14959
14960 return -1;
14961 }
14962
14963 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14964 }
14965
14966 /**
14967 * some algorithms need a fixed kernel-loops count
14968 */
14969
14970 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14971 {
14972 const u32 kernel_loops_fixed = 1024;
14973
14974 device_param->kernel_loops_min = kernel_loops_fixed;
14975 device_param->kernel_loops_max = kernel_loops_fixed;
14976 }
14977
14978 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14979 {
14980 const u32 kernel_loops_fixed = 1024;
14981
14982 device_param->kernel_loops_min = kernel_loops_fixed;
14983 device_param->kernel_loops_max = kernel_loops_fixed;
14984 }
14985
14986 if (hash_mode == 8900)
14987 {
14988 const u32 kernel_loops_fixed = 1;
14989
14990 device_param->kernel_loops_min = kernel_loops_fixed;
14991 device_param->kernel_loops_max = kernel_loops_fixed;
14992 }
14993
14994 if (hash_mode == 9300)
14995 {
14996 const u32 kernel_loops_fixed = 1;
14997
14998 device_param->kernel_loops_min = kernel_loops_fixed;
14999 device_param->kernel_loops_max = kernel_loops_fixed;
15000 }
15001
15002 if (hash_mode == 12500)
15003 {
15004 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15005
15006 device_param->kernel_loops_min = kernel_loops_fixed;
15007 device_param->kernel_loops_max = kernel_loops_fixed;
15008 }
15009
15010 /**
15011 * some algorithms have a maximum kernel-loops count
15012 */
15013
15014 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15015 {
15016 u32 innerloop_cnt = 0;
15017
15018 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15019 {
15020 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15021 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15022 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15023 }
15024 else
15025 {
15026 innerloop_cnt = data.salts_buf[0].salt_iter;
15027 }
15028
15029 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15030 (innerloop_cnt <= device_param->kernel_loops_max))
15031 {
15032 device_param->kernel_loops_max = innerloop_cnt;
15033 }
15034 }
15035
15036 u32 kernel_accel_min = device_param->kernel_accel_min;
15037 u32 kernel_accel_max = device_param->kernel_accel_max;
15038
15039 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15040
15041 size_t size_pws = 4;
15042 size_t size_tmps = 4;
15043 size_t size_hooks = 4;
15044
15045 while (kernel_accel_max >= kernel_accel_min)
15046 {
15047 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15048
15049 // size_pws
15050
15051 size_pws = kernel_power_max * sizeof (pw_t);
15052
15053 // size_tmps
15054
15055 switch (hash_mode)
15056 {
15057 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15058 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15059 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15060 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15061 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15062 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15063 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15064 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15065 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15066 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15067 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15068 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15069 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15070 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15071 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15072 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15073 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15074 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15075 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15076 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15077 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15078 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15079 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15080 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15081 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15082 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15083 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15084 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15085 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15086 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15087 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15088 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15089 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15090 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15091 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15092 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15093 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15094 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15095 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15096 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15097 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15098 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15099 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15100 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15101 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15102 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15103 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15104 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15105 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15106 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15107 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15108 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15109 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15110 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15111 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15112 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15113 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15114 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15115 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15116 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15117 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15118 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15119 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15120 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15121 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15122 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15123 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15124 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15125 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15126 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15127 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15128 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15129 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15130 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15131 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15132 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15133 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15134 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15135 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15136 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15137 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15138 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15139 };
15140
15141 // size_hooks
15142
15143 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15144 {
15145 switch (hash_mode)
15146 {
15147 }
15148 }
15149
15150 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15151 // if not, decrease amplifier and try again
15152
15153 int skip = 0;
15154
15155 const u64 size_total
15156 = bitmap_size
15157 + bitmap_size
15158 + bitmap_size
15159 + bitmap_size
15160 + bitmap_size
15161 + bitmap_size
15162 + bitmap_size
15163 + bitmap_size
15164 + size_bfs
15165 + size_combs
15166 + size_digests
15167 + size_esalts
15168 + size_hooks
15169 + size_markov_css
15170 + size_plains
15171 + size_pws
15172 + size_pws // not a bug
15173 + size_results
15174 + size_root_css
15175 + size_rules
15176 + size_rules_c
15177 + size_salts
15178 + size_scryptV
15179 + size_shown
15180 + size_tm
15181 + size_tmps;
15182
15183 // Don't ask me, ask AMD!
15184
15185 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15186 if (size_total > device_param->device_global_mem) skip = 1;
15187
15188 if (skip == 1)
15189 {
15190 kernel_accel_max--;
15191
15192 continue;
15193 }
15194
15195 break;
15196 }
15197
15198 /*
15199 if (kernel_accel_max == 0)
15200 {
15201 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15202
15203 return -1;
15204 }
15205 */
15206
15207 device_param->kernel_accel_min = kernel_accel_min;
15208 device_param->kernel_accel_max = kernel_accel_max;
15209
15210 /*
15211 if (kernel_accel_max < kernel_accel)
15212 {
15213 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15214
15215 device_param->kernel_accel = kernel_accel_max;
15216 }
15217 */
15218
15219 device_param->size_bfs = size_bfs;
15220 device_param->size_combs = size_combs;
15221 device_param->size_rules = size_rules;
15222 device_param->size_rules_c = size_rules_c;
15223 device_param->size_pws = size_pws;
15224 device_param->size_tmps = size_tmps;
15225 device_param->size_hooks = size_hooks;
15226
15227 /**
15228 * default building options
15229 */
15230
15231 char build_opts[1024] = { 0 };
15232
15233 // we don't have sm_* on vendors not NV but it doesn't matter
15234
15235 #if _WIN
15236 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15237 #else
15238 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15239 #endif
15240
15241 char build_opts_new[1024] = { 0 };
15242
15243 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15244
15245 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15246
15247 /*
15248 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15249 {
15250 // we do vectorizing much better than the auto-vectorizer
15251
15252 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15253
15254 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15255 }
15256 */
15257
15258 #ifdef DEBUG
15259 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15260 #endif
15261
15262 /**
15263 * main kernel
15264 */
15265
15266 {
15267 /**
15268 * kernel source filename
15269 */
15270
15271 char source_file[256] = { 0 };
15272
15273 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15274
15275 struct stat sst;
15276
15277 if (stat (source_file, &sst) == -1)
15278 {
15279 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15280
15281 return -1;
15282 }
15283
15284 /**
15285 * kernel cached filename
15286 */
15287
15288 char cached_file[256] = { 0 };
15289
15290 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15291
15292 int cached = 1;
15293
15294 struct stat cst;
15295
15296 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15297 {
15298 cached = 0;
15299 }
15300
15301 /**
15302 * kernel compile or load
15303 */
15304
15305 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15306
15307 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15308
15309 if (force_jit_compilation == -1)
15310 {
15311 if (cached == 0)
15312 {
15313 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15314
15315 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15316
15317 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15318
15319 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15320
15321 #ifdef DEBUG
15322 size_t build_log_size = 0;
15323
15324 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15325
15326 if (build_log_size > 1)
15327 {
15328 char *build_log = (char *) malloc (build_log_size + 1);
15329
15330 memset (build_log, 0, build_log_size + 1);
15331
15332 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15333
15334 puts (build_log);
15335
15336 free (build_log);
15337 }
15338 #endif
15339
15340 if (rc != 0)
15341 {
15342 device_param->skipped = true;
15343
15344 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15345
15346 continue;
15347 }
15348
15349 size_t binary_size;
15350
15351 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15352
15353 u8 *binary = (u8 *) mymalloc (binary_size);
15354
15355 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15356
15357 writeProgramBin (cached_file, binary, binary_size);
15358
15359 local_free (binary);
15360 }
15361 else
15362 {
15363 #ifdef DEBUG
15364 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15365 #endif
15366
15367 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15368
15369 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15370
15371 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15372 }
15373 }
15374 else
15375 {
15376 #ifdef DEBUG
15377 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15378 #endif
15379
15380 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15381
15382 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15383
15384 char build_opts_update[1024] = { 0 };
15385
15386 if (force_jit_compilation == 1500)
15387 {
15388 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15389 }
15390 else if (force_jit_compilation == 8900)
15391 {
15392 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15393 }
15394 else
15395 {
15396 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15397 }
15398
15399 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15400
15401 #ifdef DEBUG
15402 size_t build_log_size = 0;
15403
15404 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15405
15406 if (build_log_size > 1)
15407 {
15408 char *build_log = (char *) malloc (build_log_size + 1);
15409
15410 memset (build_log, 0, build_log_size + 1);
15411
15412 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15413
15414 puts (build_log);
15415
15416 free (build_log);
15417 }
15418 #endif
15419
15420 if (rc != 0)
15421 {
15422 device_param->skipped = true;
15423
15424 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15425 }
15426 }
15427
15428 local_free (kernel_lengths);
15429 local_free (kernel_sources[0]);
15430 local_free (kernel_sources);
15431 }
15432
15433 /**
15434 * word generator kernel
15435 */
15436
15437 if (attack_mode != ATTACK_MODE_STRAIGHT)
15438 {
15439 /**
15440 * kernel mp source filename
15441 */
15442
15443 char source_file[256] = { 0 };
15444
15445 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15446
15447 struct stat sst;
15448
15449 if (stat (source_file, &sst) == -1)
15450 {
15451 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15452
15453 return -1;
15454 }
15455
15456 /**
15457 * kernel mp cached filename
15458 */
15459
15460 char cached_file[256] = { 0 };
15461
15462 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15463
15464 int cached = 1;
15465
15466 struct stat cst;
15467
15468 if (stat (cached_file, &cst) == -1)
15469 {
15470 cached = 0;
15471 }
15472
15473 /**
15474 * kernel compile or load
15475 */
15476
15477 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15478
15479 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15480
15481 if (cached == 0)
15482 {
15483 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15484 if (quiet == 0) log_info ("");
15485
15486 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15487
15488 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15489
15490 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15491
15492 if (rc != 0)
15493 {
15494 device_param->skipped = true;
15495
15496 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15497
15498 continue;
15499 }
15500
15501 size_t binary_size;
15502
15503 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15504
15505 u8 *binary = (u8 *) mymalloc (binary_size);
15506
15507 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15508
15509 writeProgramBin (cached_file, binary, binary_size);
15510
15511 local_free (binary);
15512 }
15513 else
15514 {
15515 #ifdef DEBUG
15516 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15517 #endif
15518
15519 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15520
15521 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15522
15523 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15524 }
15525
15526 local_free (kernel_lengths);
15527 local_free (kernel_sources[0]);
15528 local_free (kernel_sources);
15529 }
15530
15531 /**
15532 * amplifier kernel
15533 */
15534
15535 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15536 {
15537
15538 }
15539 else
15540 {
15541 /**
15542 * kernel amp source filename
15543 */
15544
15545 char source_file[256] = { 0 };
15546
15547 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15548
15549 struct stat sst;
15550
15551 if (stat (source_file, &sst) == -1)
15552 {
15553 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15554
15555 return -1;
15556 }
15557
15558 /**
15559 * kernel amp cached filename
15560 */
15561
15562 char cached_file[256] = { 0 };
15563
15564 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15565
15566 int cached = 1;
15567
15568 struct stat cst;
15569
15570 if (stat (cached_file, &cst) == -1)
15571 {
15572 cached = 0;
15573 }
15574
15575 /**
15576 * kernel compile or load
15577 */
15578
15579 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15580
15581 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15582
15583 if (cached == 0)
15584 {
15585 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15586 if (quiet == 0) log_info ("");
15587
15588 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15589
15590 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15591
15592 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15593
15594 if (rc != 0)
15595 {
15596 device_param->skipped = true;
15597
15598 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15599
15600 continue;
15601 }
15602
15603 size_t binary_size;
15604
15605 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15606
15607 u8 *binary = (u8 *) mymalloc (binary_size);
15608
15609 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15610
15611 writeProgramBin (cached_file, binary, binary_size);
15612
15613 local_free (binary);
15614 }
15615 else
15616 {
15617 #ifdef DEBUG
15618 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15619 #endif
15620
15621 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15622
15623 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15624
15625 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15626 }
15627
15628 local_free (kernel_lengths);
15629 local_free (kernel_sources[0]);
15630 local_free (kernel_sources);
15631 }
15632
15633 // some algorithm collide too fast, make that impossible
15634
15635 if (benchmark == 1)
15636 {
15637 ((uint *) digests_buf)[0] = -1;
15638 ((uint *) digests_buf)[1] = -1;
15639 ((uint *) digests_buf)[2] = -1;
15640 ((uint *) digests_buf)[3] = -1;
15641 }
15642
15643 /**
15644 * global buffers
15645 */
15646
15647 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15648 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15649 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15650 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15651 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15652 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15653 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15654 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15655 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15656 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15657 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15658 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15659 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15660 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15661 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15662 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15663 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15664 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15665
15666 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
15667 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
15668 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
15669 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
15670 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
15671 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
15672 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
15673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
15674 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15675 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15676 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15677
15678 /**
15679 * special buffers
15680 */
15681
15682 if (attack_kern == ATTACK_KERN_STRAIGHT)
15683 {
15684 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15685 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15686
15687 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15688 }
15689 else if (attack_kern == ATTACK_KERN_COMBI)
15690 {
15691 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15692 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15693 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15694 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15695 }
15696 else if (attack_kern == ATTACK_KERN_BF)
15697 {
15698 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15699 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15700 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15701 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15702 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15703 }
15704
15705 if (size_esalts)
15706 {
15707 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15708
15709 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15710 }
15711
15712 /**
15713 * main host data
15714 */
15715
15716 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15717
15718 device_param->pws_buf = pws_buf;
15719
15720 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15721
15722 device_param->combs_buf = combs_buf;
15723
15724 void *hooks_buf = mymalloc (size_hooks);
15725
15726 device_param->hooks_buf = hooks_buf;
15727
15728 /**
15729 * kernel args
15730 */
15731
15732 device_param->kernel_params_buf32[21] = bitmap_mask;
15733 device_param->kernel_params_buf32[22] = bitmap_shift1;
15734 device_param->kernel_params_buf32[23] = bitmap_shift2;
15735 device_param->kernel_params_buf32[24] = 0; // salt_pos
15736 device_param->kernel_params_buf32[25] = 0; // loop_pos
15737 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15738 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15739 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15740 device_param->kernel_params_buf32[29] = 0; // digests_offset
15741 device_param->kernel_params_buf32[30] = 0; // combs_mode
15742 device_param->kernel_params_buf32[31] = 0; // gid_max
15743
15744 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15745 ? &device_param->d_pws_buf
15746 : &device_param->d_pws_amp_buf;
15747 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15748 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15749 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15750 device_param->kernel_params[ 4] = &device_param->d_tmps;
15751 device_param->kernel_params[ 5] = &device_param->d_hooks;
15752 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15753 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15754 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15755 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15756 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15757 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15758 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15759 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15760 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15761 device_param->kernel_params[15] = &device_param->d_digests_buf;
15762 device_param->kernel_params[16] = &device_param->d_digests_shown;
15763 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15764 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15765 device_param->kernel_params[19] = &device_param->d_result;
15766 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15767 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15768 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15769 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15770 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15771 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15772 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15773 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15774 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15775 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15776 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15777 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15778
15779 device_param->kernel_params_mp_buf64[3] = 0;
15780 device_param->kernel_params_mp_buf32[4] = 0;
15781 device_param->kernel_params_mp_buf32[5] = 0;
15782 device_param->kernel_params_mp_buf32[6] = 0;
15783 device_param->kernel_params_mp_buf32[7] = 0;
15784 device_param->kernel_params_mp_buf32[8] = 0;
15785
15786 device_param->kernel_params_mp[0] = NULL;
15787 device_param->kernel_params_mp[1] = NULL;
15788 device_param->kernel_params_mp[2] = NULL;
15789 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15790 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15791 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15792 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15793 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15794 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15795
15796 device_param->kernel_params_mp_l_buf64[3] = 0;
15797 device_param->kernel_params_mp_l_buf32[4] = 0;
15798 device_param->kernel_params_mp_l_buf32[5] = 0;
15799 device_param->kernel_params_mp_l_buf32[6] = 0;
15800 device_param->kernel_params_mp_l_buf32[7] = 0;
15801 device_param->kernel_params_mp_l_buf32[8] = 0;
15802 device_param->kernel_params_mp_l_buf32[9] = 0;
15803
15804 device_param->kernel_params_mp_l[0] = NULL;
15805 device_param->kernel_params_mp_l[1] = NULL;
15806 device_param->kernel_params_mp_l[2] = NULL;
15807 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15808 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15809 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15810 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15811 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15812 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15813 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15814
15815 device_param->kernel_params_mp_r_buf64[3] = 0;
15816 device_param->kernel_params_mp_r_buf32[4] = 0;
15817 device_param->kernel_params_mp_r_buf32[5] = 0;
15818 device_param->kernel_params_mp_r_buf32[6] = 0;
15819 device_param->kernel_params_mp_r_buf32[7] = 0;
15820 device_param->kernel_params_mp_r_buf32[8] = 0;
15821
15822 device_param->kernel_params_mp_r[0] = NULL;
15823 device_param->kernel_params_mp_r[1] = NULL;
15824 device_param->kernel_params_mp_r[2] = NULL;
15825 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15826 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15827 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15828 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15829 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15830 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15831
15832 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15833 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15834
15835 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15836 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15837 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15838 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15839 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15840 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15841 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15842
15843 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15844 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15845
15846 device_param->kernel_params_memset_buf32[1] = 0; // value
15847 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15848
15849 device_param->kernel_params_memset[0] = NULL;
15850 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15851 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15852
15853 /**
15854 * kernel name
15855 */
15856
15857 size_t kernel_wgs_tmp;
15858
15859 char kernel_name[64] = { 0 };
15860
15861 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15862 {
15863 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15864 {
15865 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15866
15867 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15868
15869 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15870
15871 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15872
15873 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15874
15875 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15876 }
15877 else
15878 {
15879 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15880
15881 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15882
15883 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15884
15885 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15886
15887 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15888
15889 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15890 }
15891
15892 if (data.attack_mode == ATTACK_MODE_BF)
15893 {
15894 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15895 {
15896 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15897
15898 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15899
15900 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15901 }
15902 }
15903 }
15904 else
15905 {
15906 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15907
15908 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15909
15910 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15911
15912 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15913
15914 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15915
15916 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15917
15918 if (opts_type & OPTS_TYPE_HOOK12)
15919 {
15920 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15921
15922 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15923
15924 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15925 }
15926
15927 if (opts_type & OPTS_TYPE_HOOK23)
15928 {
15929 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15930
15931 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15932
15933 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15934 }
15935 }
15936
15937 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15938 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15939 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15940
15941 for (uint i = 0; i <= 20; i++)
15942 {
15943 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15944 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15945 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15946
15947 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15948 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15949 }
15950
15951 for (uint i = 21; i <= 31; i++)
15952 {
15953 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15954 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15955 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15956
15957 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15958 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15959 }
15960
15961 // GPU memset
15962
15963 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15964
15965 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15966
15967 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15968 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15969 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15970
15971 // MP start
15972
15973 if (attack_mode == ATTACK_MODE_BF)
15974 {
15975 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15976 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15977
15978 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15979 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15980
15981 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15982 {
15983 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15984 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15985 }
15986 }
15987 else if (attack_mode == ATTACK_MODE_HYBRID1)
15988 {
15989 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15990
15991 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15992 }
15993 else if (attack_mode == ATTACK_MODE_HYBRID2)
15994 {
15995 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15996
15997 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15998 }
15999
16000 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16001 {
16002 // nothing to do
16003 }
16004 else
16005 {
16006 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16007
16008 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16009 }
16010
16011 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16012 {
16013 // nothing to do
16014 }
16015 else
16016 {
16017 for (uint i = 0; i < 5; i++)
16018 {
16019 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16020 }
16021
16022 for (uint i = 5; i < 7; i++)
16023 {
16024 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16025 }
16026 }
16027
16028 // maybe this has been updated by clGetKernelWorkGroupInfo()
16029 // value can only be decreased, so we don't need to reallocate buffers
16030
16031 device_param->kernel_threads = kernel_threads;
16032
16033 // zero some data buffers
16034
16035 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16036 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16037 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16038 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16039 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16040 run_kernel_bzero (device_param, device_param->d_result, size_results);
16041
16042 /**
16043 * special buffers
16044 */
16045
16046 if (attack_kern == ATTACK_KERN_STRAIGHT)
16047 {
16048 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16049 }
16050 else if (attack_kern == ATTACK_KERN_COMBI)
16051 {
16052 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16053 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16054 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16055 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16056 }
16057 else if (attack_kern == ATTACK_KERN_BF)
16058 {
16059 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16060 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16061 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16062 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16063 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16064 }
16065
16066 #if defined(HAVE_HWMON)
16067
16068 /**
16069 * Store initial fanspeed if gpu_temp_retain is enabled
16070 */
16071
16072 if (gpu_temp_disable == 0)
16073 {
16074 if (gpu_temp_retain != 0)
16075 {
16076 hc_thread_mutex_lock (mux_adl);
16077
16078 if (data.hm_device[device_id].fan_get_supported == 1)
16079 {
16080 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16081 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16082
16083 temp_retain_fanspeed_value[device_id] = fanspeed;
16084 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16085
16086 // we also set it to tell the OS we take control over the fan and it's automatic controller
16087 // if it was set to automatic. we do not control user-defined fanspeeds.
16088
16089 if (fanpolicy == 1)
16090 {
16091 data.hm_device[device_id].fan_set_supported = 1;
16092
16093 int rc = -1;
16094
16095 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16096 {
16097 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16098 }
16099 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16100 {
16101
16102 }
16103
16104 if (rc == 0)
16105 {
16106 data.hm_device[device_id].fan_set_supported = 1;
16107 }
16108 else
16109 {
16110 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16111
16112 data.hm_device[device_id].fan_set_supported = 0;
16113 }
16114 }
16115 else
16116 {
16117 data.hm_device[device_id].fan_set_supported = 0;
16118 }
16119 }
16120
16121 hc_thread_mutex_unlock (mux_adl);
16122 }
16123 }
16124
16125 #endif // HAVE_HWMON
16126 }
16127
16128 if (data.quiet == 0) log_info_nn ("");
16129
16130 /**
16131 * In benchmark-mode, inform user which algorithm is checked
16132 */
16133
16134 if (benchmark == 1)
16135 {
16136 if (machine_readable == 0)
16137 {
16138 quiet = 0;
16139
16140 data.quiet = quiet;
16141
16142 char *hash_type = strhashtype (data.hash_mode); // not a bug
16143
16144 log_info ("Hashtype: %s", hash_type);
16145 log_info ("");
16146 }
16147 }
16148
16149 /**
16150 * keep track of the progress
16151 */
16152
16153 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16154 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16155 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16156
16157 /**
16158 * open filehandles
16159 */
16160
16161 #if _WIN
16162 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16163 {
16164 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16165
16166 return (-1);
16167 }
16168
16169 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16170 {
16171 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16172
16173 return (-1);
16174 }
16175
16176 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16177 {
16178 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16179
16180 return (-1);
16181 }
16182 #endif
16183
16184 /**
16185 * dictionary pad
16186 */
16187
16188 segment_size *= (1024 * 1024);
16189
16190 data.segment_size = segment_size;
16191
16192 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16193
16194 wl_data->buf = (char *) mymalloc (segment_size);
16195 wl_data->avail = segment_size;
16196 wl_data->incr = segment_size;
16197 wl_data->cnt = 0;
16198 wl_data->pos = 0;
16199
16200 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16201
16202 data.wordlist_mode = wordlist_mode;
16203
16204 cs_t *css_buf = NULL;
16205 uint css_cnt = 0;
16206 uint dictcnt = 0;
16207 uint maskcnt = 1;
16208 char **masks = NULL;
16209 char **dictfiles = NULL;
16210
16211 uint mask_from_file = 0;
16212
16213 if (attack_mode == ATTACK_MODE_STRAIGHT)
16214 {
16215 if (wordlist_mode == WL_MODE_FILE)
16216 {
16217 int wls_left = myargc - (optind + 1);
16218
16219 for (int i = 0; i < wls_left; i++)
16220 {
16221 char *l0_filename = myargv[optind + 1 + i];
16222
16223 struct stat l0_stat;
16224
16225 if (stat (l0_filename, &l0_stat) == -1)
16226 {
16227 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16228
16229 return (-1);
16230 }
16231
16232 uint is_dir = S_ISDIR (l0_stat.st_mode);
16233
16234 if (is_dir == 0)
16235 {
16236 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16237
16238 dictcnt++;
16239
16240 dictfiles[dictcnt - 1] = l0_filename;
16241 }
16242 else
16243 {
16244 // do not allow --keyspace w/ a directory
16245
16246 if (keyspace == 1)
16247 {
16248 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16249
16250 return (-1);
16251 }
16252
16253 char **dictionary_files = NULL;
16254
16255 dictionary_files = scan_directory (l0_filename);
16256
16257 if (dictionary_files != NULL)
16258 {
16259 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16260
16261 for (int d = 0; dictionary_files[d] != NULL; d++)
16262 {
16263 char *l1_filename = dictionary_files[d];
16264
16265 struct stat l1_stat;
16266
16267 if (stat (l1_filename, &l1_stat) == -1)
16268 {
16269 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16270
16271 return (-1);
16272 }
16273
16274 if (S_ISREG (l1_stat.st_mode))
16275 {
16276 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16277
16278 dictcnt++;
16279
16280 dictfiles[dictcnt - 1] = strdup (l1_filename);
16281 }
16282 }
16283 }
16284
16285 local_free (dictionary_files);
16286 }
16287 }
16288
16289 if (dictcnt < 1)
16290 {
16291 log_error ("ERROR: No usable dictionary file found.");
16292
16293 return (-1);
16294 }
16295 }
16296 else if (wordlist_mode == WL_MODE_STDIN)
16297 {
16298 dictcnt = 1;
16299 }
16300 }
16301 else if (attack_mode == ATTACK_MODE_COMBI)
16302 {
16303 // display
16304
16305 char *dictfile1 = myargv[optind + 1 + 0];
16306 char *dictfile2 = myargv[optind + 1 + 1];
16307
16308 // find the bigger dictionary and use as base
16309
16310 FILE *fp1 = NULL;
16311 FILE *fp2 = NULL;
16312
16313 struct stat tmp_stat;
16314
16315 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16316 {
16317 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16318
16319 return (-1);
16320 }
16321
16322 if (stat (dictfile1, &tmp_stat) == -1)
16323 {
16324 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16325
16326 fclose (fp1);
16327
16328 return (-1);
16329 }
16330
16331 if (S_ISDIR (tmp_stat.st_mode))
16332 {
16333 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16334
16335 fclose (fp1);
16336
16337 return (-1);
16338 }
16339
16340 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16341 {
16342 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16343
16344 fclose (fp1);
16345
16346 return (-1);
16347 }
16348
16349 if (stat (dictfile2, &tmp_stat) == -1)
16350 {
16351 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16352
16353 fclose (fp1);
16354 fclose (fp2);
16355
16356 return (-1);
16357 }
16358
16359 if (S_ISDIR (tmp_stat.st_mode))
16360 {
16361 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16362
16363 fclose (fp1);
16364 fclose (fp2);
16365
16366 return (-1);
16367 }
16368
16369 data.combs_cnt = 1;
16370
16371 data.quiet = 1;
16372
16373 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16374
16375 data.quiet = quiet;
16376
16377 if (words1_cnt == 0)
16378 {
16379 log_error ("ERROR: %s: empty file", dictfile1);
16380
16381 fclose (fp1);
16382 fclose (fp2);
16383
16384 return (-1);
16385 }
16386
16387 data.combs_cnt = 1;
16388
16389 data.quiet = 1;
16390
16391 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16392
16393 data.quiet = quiet;
16394
16395 if (words2_cnt == 0)
16396 {
16397 log_error ("ERROR: %s: empty file", dictfile2);
16398
16399 fclose (fp1);
16400 fclose (fp2);
16401
16402 return (-1);
16403 }
16404
16405 fclose (fp1);
16406 fclose (fp2);
16407
16408 data.dictfile = dictfile1;
16409 data.dictfile2 = dictfile2;
16410
16411 if (words1_cnt >= words2_cnt)
16412 {
16413 data.combs_cnt = words2_cnt;
16414 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16415
16416 dictfiles = &data.dictfile;
16417
16418 dictcnt = 1;
16419 }
16420 else
16421 {
16422 data.combs_cnt = words1_cnt;
16423 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16424
16425 dictfiles = &data.dictfile2;
16426
16427 dictcnt = 1;
16428
16429 // we also have to switch wordlist related rules!
16430
16431 char *tmpc = data.rule_buf_l;
16432
16433 data.rule_buf_l = data.rule_buf_r;
16434 data.rule_buf_r = tmpc;
16435
16436 int tmpi = data.rule_len_l;
16437
16438 data.rule_len_l = data.rule_len_r;
16439 data.rule_len_r = tmpi;
16440 }
16441 }
16442 else if (attack_mode == ATTACK_MODE_BF)
16443 {
16444 char *mask = NULL;
16445
16446 maskcnt = 0;
16447
16448 if (benchmark == 0)
16449 {
16450 mask = myargv[optind + 1];
16451
16452 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16453
16454 if ((optind + 2) <= myargc)
16455 {
16456 struct stat file_stat;
16457
16458 if (stat (mask, &file_stat) == -1)
16459 {
16460 maskcnt = 1;
16461
16462 masks[maskcnt - 1] = mystrdup (mask);
16463 }
16464 else
16465 {
16466 int wls_left = myargc - (optind + 1);
16467
16468 uint masks_avail = INCR_MASKS;
16469
16470 for (int i = 0; i < wls_left; i++)
16471 {
16472 if (i != 0)
16473 {
16474 mask = myargv[optind + 1 + i];
16475
16476 if (stat (mask, &file_stat) == -1)
16477 {
16478 log_error ("ERROR: %s: %s", mask, strerror (errno));
16479
16480 return (-1);
16481 }
16482 }
16483
16484 uint is_file = S_ISREG (file_stat.st_mode);
16485
16486 if (is_file == 1)
16487 {
16488 FILE *mask_fp;
16489
16490 if ((mask_fp = fopen (mask, "r")) == NULL)
16491 {
16492 log_error ("ERROR: %s: %s", mask, strerror (errno));
16493
16494 return (-1);
16495 }
16496
16497 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16498
16499 while (!feof (mask_fp))
16500 {
16501 memset (line_buf, 0, HCBUFSIZ);
16502
16503 int line_len = fgetl (mask_fp, line_buf);
16504
16505 if (line_len == 0) continue;
16506
16507 if (line_buf[0] == '#') continue;
16508
16509 if (masks_avail == maskcnt)
16510 {
16511 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16512
16513 masks_avail += INCR_MASKS;
16514 }
16515
16516 masks[maskcnt] = mystrdup (line_buf);
16517
16518 maskcnt++;
16519 }
16520
16521 myfree (line_buf);
16522
16523 fclose (mask_fp);
16524 }
16525 else
16526 {
16527 log_error ("ERROR: %s: unsupported file-type", mask);
16528
16529 return (-1);
16530 }
16531 }
16532
16533 mask_from_file = 1;
16534 }
16535 }
16536 else
16537 {
16538 custom_charset_1 = (char *) "?l?d?u";
16539 custom_charset_2 = (char *) "?l?d";
16540 custom_charset_3 = (char *) "?l?d*!$@_";
16541
16542 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16543 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16544 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16545
16546 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16547
16548 wordlist_mode = WL_MODE_MASK;
16549
16550 data.wordlist_mode = wordlist_mode;
16551
16552 increment = 1;
16553
16554 maskcnt = 1;
16555 }
16556 }
16557 else
16558 {
16559 /**
16560 * generate full masks and charsets
16561 */
16562
16563 masks = (char **) mymalloc (sizeof (char *));
16564
16565 switch (hash_mode)
16566 {
16567 case 1731: pw_min = 5;
16568 pw_max = 5;
16569 mask = mystrdup ("?b?b?b?b?b");
16570 break;
16571 case 12500: pw_min = 5;
16572 pw_max = 5;
16573 mask = mystrdup ("?b?b?b?b?b");
16574 break;
16575 default: pw_min = 7;
16576 pw_max = 7;
16577 mask = mystrdup ("?b?b?b?b?b?b?b");
16578 break;
16579 }
16580
16581 maskcnt = 1;
16582
16583 masks[maskcnt - 1] = mystrdup (mask);
16584
16585 wordlist_mode = WL_MODE_MASK;
16586
16587 data.wordlist_mode = wordlist_mode;
16588
16589 increment = 1;
16590 }
16591
16592 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16593
16594 if (increment)
16595 {
16596 if (increment_min > pw_min) pw_min = increment_min;
16597
16598 if (increment_max < pw_max) pw_max = increment_max;
16599 }
16600 }
16601 else if (attack_mode == ATTACK_MODE_HYBRID1)
16602 {
16603 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16604
16605 // display
16606
16607 char *mask = myargv[myargc - 1];
16608
16609 maskcnt = 0;
16610
16611 masks = (char **) mymalloc (1 * sizeof (char *));
16612
16613 // mod
16614
16615 struct stat file_stat;
16616
16617 if (stat (mask, &file_stat) == -1)
16618 {
16619 maskcnt = 1;
16620
16621 masks[maskcnt - 1] = mystrdup (mask);
16622 }
16623 else
16624 {
16625 uint is_file = S_ISREG (file_stat.st_mode);
16626
16627 if (is_file == 1)
16628 {
16629 FILE *mask_fp;
16630
16631 if ((mask_fp = fopen (mask, "r")) == NULL)
16632 {
16633 log_error ("ERROR: %s: %s", mask, strerror (errno));
16634
16635 return (-1);
16636 }
16637
16638 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16639
16640 uint masks_avail = 1;
16641
16642 while (!feof (mask_fp))
16643 {
16644 memset (line_buf, 0, HCBUFSIZ);
16645
16646 int line_len = fgetl (mask_fp, line_buf);
16647
16648 if (line_len == 0) continue;
16649
16650 if (line_buf[0] == '#') continue;
16651
16652 if (masks_avail == maskcnt)
16653 {
16654 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16655
16656 masks_avail += INCR_MASKS;
16657 }
16658
16659 masks[maskcnt] = mystrdup (line_buf);
16660
16661 maskcnt++;
16662 }
16663
16664 myfree (line_buf);
16665
16666 fclose (mask_fp);
16667
16668 mask_from_file = 1;
16669 }
16670 else
16671 {
16672 maskcnt = 1;
16673
16674 masks[maskcnt - 1] = mystrdup (mask);
16675 }
16676 }
16677
16678 // base
16679
16680 int wls_left = myargc - (optind + 2);
16681
16682 for (int i = 0; i < wls_left; i++)
16683 {
16684 char *filename = myargv[optind + 1 + i];
16685
16686 struct stat file_stat;
16687
16688 if (stat (filename, &file_stat) == -1)
16689 {
16690 log_error ("ERROR: %s: %s", filename, strerror (errno));
16691
16692 return (-1);
16693 }
16694
16695 uint is_dir = S_ISDIR (file_stat.st_mode);
16696
16697 if (is_dir == 0)
16698 {
16699 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16700
16701 dictcnt++;
16702
16703 dictfiles[dictcnt - 1] = filename;
16704 }
16705 else
16706 {
16707 // do not allow --keyspace w/ a directory
16708
16709 if (keyspace == 1)
16710 {
16711 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16712
16713 return (-1);
16714 }
16715
16716 char **dictionary_files = NULL;
16717
16718 dictionary_files = scan_directory (filename);
16719
16720 if (dictionary_files != NULL)
16721 {
16722 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16723
16724 for (int d = 0; dictionary_files[d] != NULL; d++)
16725 {
16726 char *l1_filename = dictionary_files[d];
16727
16728 struct stat l1_stat;
16729
16730 if (stat (l1_filename, &l1_stat) == -1)
16731 {
16732 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16733
16734 return (-1);
16735 }
16736
16737 if (S_ISREG (l1_stat.st_mode))
16738 {
16739 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16740
16741 dictcnt++;
16742
16743 dictfiles[dictcnt - 1] = strdup (l1_filename);
16744 }
16745 }
16746 }
16747
16748 local_free (dictionary_files);
16749 }
16750 }
16751
16752 if (dictcnt < 1)
16753 {
16754 log_error ("ERROR: No usable dictionary file found.");
16755
16756 return (-1);
16757 }
16758
16759 if (increment)
16760 {
16761 maskcnt = 0;
16762
16763 uint mask_min = increment_min; // we can't reject smaller masks here
16764 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16765
16766 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16767 {
16768 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16769
16770 if (cur_mask == NULL) break;
16771
16772 masks[maskcnt] = cur_mask;
16773
16774 maskcnt++;
16775
16776 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16777 }
16778 }
16779 }
16780 else if (attack_mode == ATTACK_MODE_HYBRID2)
16781 {
16782 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16783
16784 // display
16785
16786 char *mask = myargv[optind + 1 + 0];
16787
16788 maskcnt = 0;
16789
16790 masks = (char **) mymalloc (1 * sizeof (char *));
16791
16792 // mod
16793
16794 struct stat file_stat;
16795
16796 if (stat (mask, &file_stat) == -1)
16797 {
16798 maskcnt = 1;
16799
16800 masks[maskcnt - 1] = mystrdup (mask);
16801 }
16802 else
16803 {
16804 uint is_file = S_ISREG (file_stat.st_mode);
16805
16806 if (is_file == 1)
16807 {
16808 FILE *mask_fp;
16809
16810 if ((mask_fp = fopen (mask, "r")) == NULL)
16811 {
16812 log_error ("ERROR: %s: %s", mask, strerror (errno));
16813
16814 return (-1);
16815 }
16816
16817 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16818
16819 uint masks_avail = 1;
16820
16821 while (!feof (mask_fp))
16822 {
16823 memset (line_buf, 0, HCBUFSIZ);
16824
16825 int line_len = fgetl (mask_fp, line_buf);
16826
16827 if (line_len == 0) continue;
16828
16829 if (line_buf[0] == '#') continue;
16830
16831 if (masks_avail == maskcnt)
16832 {
16833 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16834
16835 masks_avail += INCR_MASKS;
16836 }
16837
16838 masks[maskcnt] = mystrdup (line_buf);
16839
16840 maskcnt++;
16841 }
16842
16843 myfree (line_buf);
16844
16845 fclose (mask_fp);
16846
16847 mask_from_file = 1;
16848 }
16849 else
16850 {
16851 maskcnt = 1;
16852
16853 masks[maskcnt - 1] = mystrdup (mask);
16854 }
16855 }
16856
16857 // base
16858
16859 int wls_left = myargc - (optind + 2);
16860
16861 for (int i = 0; i < wls_left; i++)
16862 {
16863 char *filename = myargv[optind + 2 + i];
16864
16865 struct stat file_stat;
16866
16867 if (stat (filename, &file_stat) == -1)
16868 {
16869 log_error ("ERROR: %s: %s", filename, strerror (errno));
16870
16871 return (-1);
16872 }
16873
16874 uint is_dir = S_ISDIR (file_stat.st_mode);
16875
16876 if (is_dir == 0)
16877 {
16878 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16879
16880 dictcnt++;
16881
16882 dictfiles[dictcnt - 1] = filename;
16883 }
16884 else
16885 {
16886 // do not allow --keyspace w/ a directory
16887
16888 if (keyspace == 1)
16889 {
16890 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16891
16892 return (-1);
16893 }
16894
16895 char **dictionary_files = NULL;
16896
16897 dictionary_files = scan_directory (filename);
16898
16899 if (dictionary_files != NULL)
16900 {
16901 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16902
16903 for (int d = 0; dictionary_files[d] != NULL; d++)
16904 {
16905 char *l1_filename = dictionary_files[d];
16906
16907 struct stat l1_stat;
16908
16909 if (stat (l1_filename, &l1_stat) == -1)
16910 {
16911 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16912
16913 return (-1);
16914 }
16915
16916 if (S_ISREG (l1_stat.st_mode))
16917 {
16918 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16919
16920 dictcnt++;
16921
16922 dictfiles[dictcnt - 1] = strdup (l1_filename);
16923 }
16924 }
16925 }
16926
16927 local_free (dictionary_files);
16928 }
16929 }
16930
16931 if (dictcnt < 1)
16932 {
16933 log_error ("ERROR: No usable dictionary file found.");
16934
16935 return (-1);
16936 }
16937
16938 if (increment)
16939 {
16940 maskcnt = 0;
16941
16942 uint mask_min = increment_min; // we can't reject smaller masks here
16943 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16944
16945 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16946 {
16947 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16948
16949 if (cur_mask == NULL) break;
16950
16951 masks[maskcnt] = cur_mask;
16952
16953 maskcnt++;
16954
16955 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16956 }
16957 }
16958 }
16959
16960 data.pw_min = pw_min;
16961 data.pw_max = pw_max;
16962
16963 /**
16964 * weak hash check
16965 */
16966
16967 if (weak_hash_threshold >= salts_cnt)
16968 {
16969 hc_device_param_t *device_param = NULL;
16970
16971 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16972 {
16973 device_param = &data.devices_param[device_id];
16974
16975 if (device_param->skipped) continue;
16976
16977 break;
16978 }
16979
16980 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16981
16982 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16983 {
16984 weak_hash_check (device_param, salt_pos);
16985 }
16986
16987 // Display hack, guarantee that there is at least one \r before real start
16988
16989 //if (data.quiet == 0) log_info ("");
16990 }
16991
16992 /**
16993 * status and monitor threads
16994 */
16995
16996 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16997
16998 uint i_threads_cnt = 0;
16999
17000 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17001
17002 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17003 {
17004 if (stdout_flag == 0)
17005 {
17006 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17007
17008 i_threads_cnt++;
17009 }
17010 }
17011
17012 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17013
17014 uint ni_threads_cnt = 0;
17015
17016 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17017
17018 if (stdout_flag == 0)
17019 {
17020 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17021
17022 ni_threads_cnt++;
17023 }
17024
17025 /**
17026 * Outfile remove
17027 */
17028
17029 if (keyspace == 0)
17030 {
17031 if (outfile_check_timer != 0)
17032 {
17033 if (data.outfile_check_directory != NULL)
17034 {
17035 if ((hash_mode != 5200) &&
17036 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17037 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17038 (hash_mode != 9000))
17039 {
17040 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17041
17042 ni_threads_cnt++;
17043 }
17044 else
17045 {
17046 outfile_check_timer = 0;
17047 }
17048 }
17049 else
17050 {
17051 outfile_check_timer = 0;
17052 }
17053 }
17054 }
17055
17056 /**
17057 * Inform the user if we got some hashes remove because of the pot file remove feature
17058 */
17059
17060 if (data.quiet == 0)
17061 {
17062 if (potfile_remove_cracks > 0)
17063 {
17064 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17065 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17066 }
17067 }
17068
17069 data.outfile_check_timer = outfile_check_timer;
17070
17071 /**
17072 * main loop
17073 */
17074
17075 char **induction_dictionaries = NULL;
17076
17077 int induction_dictionaries_cnt = 0;
17078
17079 hcstat_table_t *root_table_buf = NULL;
17080 hcstat_table_t *markov_table_buf = NULL;
17081
17082 uint initial_restore_done = 0;
17083
17084 data.maskcnt = maskcnt;
17085
17086 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17087 {
17088 if (data.devices_status == STATUS_CRACKED) break;
17089
17090 data.devices_status = STATUS_INIT;
17091
17092 if (maskpos > rd->maskpos)
17093 {
17094 rd->dictpos = 0;
17095 }
17096
17097 rd->maskpos = maskpos;
17098 data.maskpos = maskpos;
17099
17100 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17101 {
17102 char *mask = masks[maskpos];
17103
17104 if (mask_from_file == 1)
17105 {
17106 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17107
17108 char *str_ptr;
17109 uint str_pos;
17110
17111 uint mask_offset = 0;
17112
17113 uint separator_cnt;
17114
17115 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17116 {
17117 str_ptr = strstr (mask + mask_offset, ",");
17118
17119 if (str_ptr == NULL) break;
17120
17121 str_pos = str_ptr - mask;
17122
17123 // escaped separator, i.e. "\,"
17124
17125 if (str_pos > 0)
17126 {
17127 if (mask[str_pos - 1] == '\\')
17128 {
17129 separator_cnt --;
17130
17131 mask_offset = str_pos + 1;
17132
17133 continue;
17134 }
17135 }
17136
17137 // reset the offset
17138
17139 mask_offset = 0;
17140
17141 mask[str_pos] = '\0';
17142
17143 switch (separator_cnt)
17144 {
17145 case 0:
17146 mp_reset_usr (mp_usr, 0);
17147
17148 custom_charset_1 = mask;
17149 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17150 break;
17151
17152 case 1:
17153 mp_reset_usr (mp_usr, 1);
17154
17155 custom_charset_2 = mask;
17156 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17157 break;
17158
17159 case 2:
17160 mp_reset_usr (mp_usr, 2);
17161
17162 custom_charset_3 = mask;
17163 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17164 break;
17165
17166 case 3:
17167 mp_reset_usr (mp_usr, 3);
17168
17169 custom_charset_4 = mask;
17170 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17171 break;
17172 }
17173
17174 mask = mask + str_pos + 1;
17175 }
17176 }
17177
17178 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17179 {
17180 if (maskpos > 0)
17181 {
17182 local_free (css_buf);
17183 local_free (data.root_css_buf);
17184 local_free (data.markov_css_buf);
17185
17186 local_free (masks[maskpos - 1]);
17187 }
17188
17189 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17190
17191 data.mask = mask;
17192 data.css_cnt = css_cnt;
17193 data.css_buf = css_buf;
17194
17195 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17196
17197 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17198
17199 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17200 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17201
17202 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17203
17204 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17205
17206 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17207 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17208
17209 data.root_css_buf = root_css_buf;
17210 data.markov_css_buf = markov_css_buf;
17211
17212 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17213
17214 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17215
17216 local_free (root_table_buf);
17217 local_free (markov_table_buf);
17218
17219 // args
17220
17221 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17222 {
17223 hc_device_param_t *device_param = &data.devices_param[device_id];
17224
17225 if (device_param->skipped) continue;
17226
17227 device_param->kernel_params_mp[0] = &device_param->d_combs;
17228 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17229 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17230
17231 device_param->kernel_params_mp_buf64[3] = 0;
17232 device_param->kernel_params_mp_buf32[4] = css_cnt;
17233 device_param->kernel_params_mp_buf32[5] = 0;
17234 device_param->kernel_params_mp_buf32[6] = 0;
17235 device_param->kernel_params_mp_buf32[7] = 0;
17236
17237 if (attack_mode == ATTACK_MODE_HYBRID1)
17238 {
17239 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17240 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17241 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17242 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17243 }
17244 else if (attack_mode == ATTACK_MODE_HYBRID2)
17245 {
17246 device_param->kernel_params_mp_buf32[5] = 0;
17247 device_param->kernel_params_mp_buf32[6] = 0;
17248 device_param->kernel_params_mp_buf32[7] = 0;
17249 }
17250
17251 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
17252 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
17253 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
17254
17255 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
17256 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
17257 }
17258 }
17259 else if (attack_mode == ATTACK_MODE_BF)
17260 {
17261 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17262
17263 if (increment)
17264 {
17265 for (uint i = 0; i < dictcnt; i++)
17266 {
17267 local_free (dictfiles[i]);
17268 }
17269
17270 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17271 {
17272 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17273
17274 if (l1_filename == NULL) break;
17275
17276 dictcnt++;
17277
17278 dictfiles[dictcnt - 1] = l1_filename;
17279 }
17280 }
17281 else
17282 {
17283 dictcnt++;
17284
17285 dictfiles[dictcnt - 1] = mask;
17286 }
17287
17288 if (dictcnt == 0)
17289 {
17290 log_error ("ERROR: Mask is too small");
17291
17292 return (-1);
17293 }
17294 }
17295 }
17296
17297 free (induction_dictionaries);
17298
17299 // induction_dictionaries_cnt = 0; // implied
17300
17301 if (attack_mode != ATTACK_MODE_BF)
17302 {
17303 if (keyspace == 0)
17304 {
17305 induction_dictionaries = scan_directory (induction_directory);
17306
17307 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17308 }
17309 }
17310
17311 if (induction_dictionaries_cnt)
17312 {
17313 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17314 }
17315
17316 /**
17317 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17318 */
17319 if (keyspace == 1)
17320 {
17321 if ((maskcnt > 1) || (dictcnt > 1))
17322 {
17323 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17324
17325 return (-1);
17326 }
17327 }
17328
17329 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17330 {
17331 char *subid = logfile_generate_subid ();
17332
17333 data.subid = subid;
17334
17335 logfile_sub_msg ("START");
17336
17337 data.devices_status = STATUS_INIT;
17338
17339 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17340 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17341 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17342
17343 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17344
17345 data.cpt_pos = 0;
17346
17347 data.cpt_start = time (NULL);
17348
17349 data.cpt_total = 0;
17350
17351 if (data.restore == 0)
17352 {
17353 rd->words_cur = skip;
17354
17355 skip = 0;
17356
17357 data.skip = 0;
17358 }
17359
17360 data.ms_paused = 0;
17361
17362 data.kernel_power_final = 0;
17363
17364 data.words_cur = rd->words_cur;
17365
17366 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17367 {
17368 hc_device_param_t *device_param = &data.devices_param[device_id];
17369
17370 if (device_param->skipped) continue;
17371
17372 device_param->speed_pos = 0;
17373
17374 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17375 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17376
17377 device_param->exec_pos = 0;
17378
17379 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17380
17381 device_param->outerloop_pos = 0;
17382 device_param->outerloop_left = 0;
17383 device_param->innerloop_pos = 0;
17384 device_param->innerloop_left = 0;
17385
17386 // some more resets:
17387
17388 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17389
17390 device_param->pws_cnt = 0;
17391
17392 device_param->words_off = 0;
17393 device_param->words_done = 0;
17394 }
17395
17396 // figure out some workload
17397
17398 if (attack_mode == ATTACK_MODE_STRAIGHT)
17399 {
17400 if (data.wordlist_mode == WL_MODE_FILE)
17401 {
17402 char *dictfile = NULL;
17403
17404 if (induction_dictionaries_cnt)
17405 {
17406 dictfile = induction_dictionaries[0];
17407 }
17408 else
17409 {
17410 dictfile = dictfiles[dictpos];
17411 }
17412
17413 data.dictfile = dictfile;
17414
17415 logfile_sub_string (dictfile);
17416
17417 for (uint i = 0; i < rp_files_cnt; i++)
17418 {
17419 logfile_sub_var_string ("rulefile", rp_files[i]);
17420 }
17421
17422 FILE *fd2 = fopen (dictfile, "rb");
17423
17424 if (fd2 == NULL)
17425 {
17426 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17427
17428 return (-1);
17429 }
17430
17431 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17432
17433 fclose (fd2);
17434
17435 if (data.words_cnt == 0)
17436 {
17437 if (data.devices_status == STATUS_CRACKED) break;
17438 if (data.devices_status == STATUS_ABORTED) break;
17439
17440 dictpos++;
17441
17442 continue;
17443 }
17444 }
17445 }
17446 else if (attack_mode == ATTACK_MODE_COMBI)
17447 {
17448 char *dictfile = data.dictfile;
17449 char *dictfile2 = data.dictfile2;
17450
17451 logfile_sub_string (dictfile);
17452 logfile_sub_string (dictfile2);
17453
17454 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17455 {
17456 FILE *fd2 = fopen (dictfile, "rb");
17457
17458 if (fd2 == NULL)
17459 {
17460 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17461
17462 return (-1);
17463 }
17464
17465 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17466
17467 fclose (fd2);
17468 }
17469 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17470 {
17471 FILE *fd2 = fopen (dictfile2, "rb");
17472
17473 if (fd2 == NULL)
17474 {
17475 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17476
17477 return (-1);
17478 }
17479
17480 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17481
17482 fclose (fd2);
17483 }
17484
17485 if (data.words_cnt == 0)
17486 {
17487 if (data.devices_status == STATUS_CRACKED) break;
17488 if (data.devices_status == STATUS_ABORTED) break;
17489
17490 dictpos++;
17491
17492 continue;
17493 }
17494 }
17495 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17496 {
17497 char *dictfile = NULL;
17498
17499 if (induction_dictionaries_cnt)
17500 {
17501 dictfile = induction_dictionaries[0];
17502 }
17503 else
17504 {
17505 dictfile = dictfiles[dictpos];
17506 }
17507
17508 data.dictfile = dictfile;
17509
17510 char *mask = data.mask;
17511
17512 logfile_sub_string (dictfile);
17513 logfile_sub_string (mask);
17514
17515 FILE *fd2 = fopen (dictfile, "rb");
17516
17517 if (fd2 == NULL)
17518 {
17519 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17520
17521 return (-1);
17522 }
17523
17524 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17525
17526 fclose (fd2);
17527
17528 if (data.words_cnt == 0)
17529 {
17530 if (data.devices_status == STATUS_CRACKED) break;
17531 if (data.devices_status == STATUS_ABORTED) break;
17532
17533 dictpos++;
17534
17535 continue;
17536 }
17537 }
17538 else if (attack_mode == ATTACK_MODE_BF)
17539 {
17540 local_free (css_buf);
17541 local_free (data.root_css_buf);
17542 local_free (data.markov_css_buf);
17543
17544 char *mask = dictfiles[dictpos];
17545
17546 logfile_sub_string (mask);
17547
17548 // base
17549
17550 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17551
17552 if (opts_type & OPTS_TYPE_PT_UNICODE)
17553 {
17554 uint css_cnt_unicode = css_cnt * 2;
17555
17556 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17557
17558 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17559 {
17560 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17561
17562 css_buf_unicode[j + 1].cs_buf[0] = 0;
17563 css_buf_unicode[j + 1].cs_len = 1;
17564 }
17565
17566 free (css_buf);
17567
17568 css_buf = css_buf_unicode;
17569 css_cnt = css_cnt_unicode;
17570 }
17571
17572 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17573
17574 uint mask_min = pw_min;
17575 uint mask_max = pw_max;
17576
17577 if (opts_type & OPTS_TYPE_PT_UNICODE)
17578 {
17579 mask_min *= 2;
17580 mask_max *= 2;
17581 }
17582
17583 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17584 {
17585 if (css_cnt < mask_min)
17586 {
17587 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17588 }
17589
17590 if (css_cnt > mask_max)
17591 {
17592 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17593 }
17594
17595 // skip to next mask
17596
17597 dictpos++;
17598
17599 rd->dictpos = dictpos;
17600
17601 logfile_sub_msg ("STOP");
17602
17603 continue;
17604 }
17605
17606 uint save_css_cnt = css_cnt;
17607
17608 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17609 {
17610 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17611 {
17612 uint salt_len = (uint) data.salts_buf[0].salt_len;
17613 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17614
17615 uint css_cnt_salt = css_cnt + salt_len;
17616
17617 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17618
17619 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17620
17621 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17622 {
17623 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17624 css_buf_salt[j].cs_len = 1;
17625 }
17626
17627 free (css_buf);
17628
17629 css_buf = css_buf_salt;
17630 css_cnt = css_cnt_salt;
17631 }
17632 }
17633
17634 data.mask = mask;
17635 data.css_cnt = css_cnt;
17636 data.css_buf = css_buf;
17637
17638 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17639
17640 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17641
17642 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17643
17644 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17645 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17646
17647 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17648
17649 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17650
17651 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17652 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17653
17654 data.root_css_buf = root_css_buf;
17655 data.markov_css_buf = markov_css_buf;
17656
17657 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17658
17659 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17660
17661 local_free (root_table_buf);
17662 local_free (markov_table_buf);
17663
17664 // copy + args
17665
17666 uint css_cnt_l = css_cnt;
17667 uint css_cnt_r;
17668
17669 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17670 {
17671 if (save_css_cnt < 6)
17672 {
17673 css_cnt_r = 1;
17674 }
17675 else if (save_css_cnt == 6)
17676 {
17677 css_cnt_r = 2;
17678 }
17679 else
17680 {
17681 if (opts_type & OPTS_TYPE_PT_UNICODE)
17682 {
17683 if (save_css_cnt == 8 || save_css_cnt == 10)
17684 {
17685 css_cnt_r = 2;
17686 }
17687 else
17688 {
17689 css_cnt_r = 4;
17690 }
17691 }
17692 else
17693 {
17694 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17695 {
17696 css_cnt_r = 3;
17697 }
17698 else
17699 {
17700 css_cnt_r = 4;
17701 }
17702 }
17703 }
17704 }
17705 else
17706 {
17707 css_cnt_r = 1;
17708
17709 /* unfinished code?
17710 int sum = css_buf[css_cnt_r - 1].cs_len;
17711
17712 for (uint i = 1; i < 4 && i < css_cnt; i++)
17713 {
17714 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17715
17716 css_cnt_r++;
17717
17718 sum *= css_buf[css_cnt_r - 1].cs_len;
17719 }
17720 */
17721 }
17722
17723 css_cnt_l -= css_cnt_r;
17724
17725 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17726
17727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17728 {
17729 hc_device_param_t *device_param = &data.devices_param[device_id];
17730
17731 if (device_param->skipped) continue;
17732
17733 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17734 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17735 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17736
17737 device_param->kernel_params_mp_l_buf64[3] = 0;
17738 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17739 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17740 device_param->kernel_params_mp_l_buf32[6] = 0;
17741 device_param->kernel_params_mp_l_buf32[7] = 0;
17742 device_param->kernel_params_mp_l_buf32[8] = 0;
17743
17744 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17745 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17746 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17747 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17748
17749 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17750 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17751 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17752
17753 device_param->kernel_params_mp_r_buf64[3] = 0;
17754 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17755 device_param->kernel_params_mp_r_buf32[5] = 0;
17756 device_param->kernel_params_mp_r_buf32[6] = 0;
17757 device_param->kernel_params_mp_r_buf32[7] = 0;
17758
17759 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
17760 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
17761 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
17762
17763 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
17764 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
17765 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
17766
17767 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
17768 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
17769 }
17770 }
17771
17772 u64 words_base = data.words_cnt;
17773
17774 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17775 {
17776 if (data.kernel_rules_cnt)
17777 {
17778 words_base /= data.kernel_rules_cnt;
17779 }
17780 }
17781 else if (data.attack_kern == ATTACK_KERN_COMBI)
17782 {
17783 if (data.combs_cnt)
17784 {
17785 words_base /= data.combs_cnt;
17786 }
17787 }
17788 else if (data.attack_kern == ATTACK_KERN_BF)
17789 {
17790 if (data.bfs_cnt)
17791 {
17792 words_base /= data.bfs_cnt;
17793 }
17794 }
17795
17796 data.words_base = words_base;
17797
17798 if (keyspace == 1)
17799 {
17800 log_info ("%llu", (unsigned long long int) words_base);
17801
17802 return (0);
17803 }
17804
17805 if (data.words_cur > data.words_base)
17806 {
17807 log_error ("ERROR: restore value greater keyspace");
17808
17809 return (-1);
17810 }
17811
17812 if (data.words_cur)
17813 {
17814 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17815 {
17816 for (uint i = 0; i < data.salts_cnt; i++)
17817 {
17818 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17819 }
17820 }
17821 else if (data.attack_kern == ATTACK_KERN_COMBI)
17822 {
17823 for (uint i = 0; i < data.salts_cnt; i++)
17824 {
17825 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17826 }
17827 }
17828 else if (data.attack_kern == ATTACK_KERN_BF)
17829 {
17830 for (uint i = 0; i < data.salts_cnt; i++)
17831 {
17832 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17833 }
17834 }
17835 }
17836
17837 /*
17838 * Update loopback file
17839 */
17840
17841 if (loopback == 1)
17842 {
17843 time_t now;
17844
17845 time (&now);
17846
17847 uint random_num = get_random_num (0, 9999);
17848
17849 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17850
17851 data.loopback_file = loopback_file;
17852 }
17853
17854 /*
17855 * Update dictionary statistic
17856 */
17857
17858 if (keyspace == 0)
17859 {
17860 dictstat_fp = fopen (dictstat, "wb");
17861
17862 if (dictstat_fp)
17863 {
17864 lock_file (dictstat_fp);
17865
17866 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17867
17868 fclose (dictstat_fp);
17869 }
17870 }
17871
17872 /**
17873 * create autotune threads
17874 */
17875
17876 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17877
17878 data.devices_status = STATUS_AUTOTUNE;
17879
17880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17881 {
17882 hc_device_param_t *device_param = &devices_param[device_id];
17883
17884 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17885 }
17886
17887 hc_thread_wait (data.devices_cnt, c_threads);
17888
17889 /*
17890 * Inform user about possible slow speeds
17891 */
17892
17893 uint hardware_power_all = 0;
17894
17895 uint kernel_power_all = 0;
17896
17897 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17898 {
17899 hc_device_param_t *device_param = &devices_param[device_id];
17900
17901 hardware_power_all += device_param->hardware_power;
17902
17903 kernel_power_all += device_param->kernel_power;
17904 }
17905
17906 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
17907
17908 data.kernel_power_all = kernel_power_all;
17909
17910 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17911 {
17912 if (data.words_base < kernel_power_all)
17913 {
17914 if (quiet == 0)
17915 {
17916 log_info ("ATTENTION!");
17917 log_info (" The wordlist or mask you are using is too small.");
17918 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17919 log_info (" The cracking speed will drop.");
17920 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17921 log_info ("");
17922 }
17923 }
17924 }
17925
17926 /**
17927 * create cracker threads
17928 */
17929
17930 data.devices_status = STATUS_RUNNING;
17931
17932 if (initial_restore_done == 0)
17933 {
17934 if (data.restore_disable == 0) cycle_restore ();
17935
17936 initial_restore_done = 1;
17937 }
17938
17939 hc_timer_set (&data.timer_running);
17940
17941 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17942 {
17943 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17944 {
17945 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17946 if (quiet == 0) fflush (stdout);
17947 }
17948 }
17949 else if (wordlist_mode == WL_MODE_STDIN)
17950 {
17951 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17952 if (data.quiet == 0) log_info ("");
17953 }
17954
17955 time_t runtime_start;
17956
17957 time (&runtime_start);
17958
17959 data.runtime_start = runtime_start;
17960
17961 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17962 {
17963 hc_device_param_t *device_param = &devices_param[device_id];
17964
17965 if (wordlist_mode == WL_MODE_STDIN)
17966 {
17967 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17968 }
17969 else
17970 {
17971 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17972 }
17973 }
17974
17975 hc_thread_wait (data.devices_cnt, c_threads);
17976
17977 local_free (c_threads);
17978
17979 data.restore = 0;
17980
17981 // finalize task
17982
17983 logfile_sub_var_uint ("status-after-work", data.devices_status);
17984
17985 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17986
17987 if (data.devices_status == STATUS_CRACKED) break;
17988 if (data.devices_status == STATUS_ABORTED) break;
17989
17990 if (data.devices_status == STATUS_BYPASS)
17991 {
17992 data.devices_status = STATUS_RUNNING;
17993 }
17994
17995 if (induction_dictionaries_cnt)
17996 {
17997 unlink (induction_dictionaries[0]);
17998 }
17999
18000 free (induction_dictionaries);
18001
18002 if (attack_mode != ATTACK_MODE_BF)
18003 {
18004 induction_dictionaries = scan_directory (induction_directory);
18005
18006 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18007 }
18008
18009 if (benchmark == 0)
18010 {
18011 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18012 {
18013 if (quiet == 0) clear_prompt ();
18014
18015 if (quiet == 0) log_info ("");
18016
18017 if (status == 1)
18018 {
18019 status_display ();
18020 }
18021 else
18022 {
18023 if (quiet == 0) status_display ();
18024 }
18025
18026 if (quiet == 0) log_info ("");
18027 }
18028 }
18029
18030 if (attack_mode == ATTACK_MODE_BF)
18031 {
18032 dictpos++;
18033
18034 rd->dictpos = dictpos;
18035 }
18036 else
18037 {
18038 if (induction_dictionaries_cnt)
18039 {
18040 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18041 }
18042 else
18043 {
18044 dictpos++;
18045
18046 rd->dictpos = dictpos;
18047 }
18048 }
18049
18050 time_t runtime_stop;
18051
18052 time (&runtime_stop);
18053
18054 data.runtime_stop = runtime_stop;
18055
18056 logfile_sub_uint (runtime_start);
18057 logfile_sub_uint (runtime_stop);
18058
18059 logfile_sub_msg ("STOP");
18060
18061 global_free (subid);
18062 }
18063
18064 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18065
18066 if (data.devices_status == STATUS_CRACKED) break;
18067 if (data.devices_status == STATUS_ABORTED) break;
18068 if (data.devices_status == STATUS_QUIT) break;
18069
18070 if (data.devices_status == STATUS_BYPASS)
18071 {
18072 data.devices_status = STATUS_RUNNING;
18073 }
18074 }
18075
18076 // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers
18077
18078 if (attack_mode == ATTACK_MODE_STRAIGHT)
18079 {
18080 if (data.wordlist_mode == WL_MODE_FILE)
18081 {
18082 if (data.dictfile == NULL)
18083 {
18084 if (dictfiles != NULL)
18085 {
18086 data.dictfile = dictfiles[0];
18087
18088 hc_timer_set (&data.timer_running);
18089 }
18090 }
18091 }
18092 }
18093 // NOTE: combi is okay because it is already set beforehand
18094 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18095 {
18096 if (data.dictfile == NULL)
18097 {
18098 if (dictfiles != NULL)
18099 {
18100 hc_timer_set (&data.timer_running);
18101
18102 data.dictfile = dictfiles[0];
18103 }
18104 }
18105 }
18106 else if (attack_mode == ATTACK_MODE_BF)
18107 {
18108 if (data.mask == NULL)
18109 {
18110 hc_timer_set (&data.timer_running);
18111
18112 data.mask = masks[0];
18113 }
18114 }
18115
18116 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18117 {
18118 data.devices_status = STATUS_EXHAUSTED;
18119 }
18120
18121 // if cracked / aborted remove last induction dictionary
18122
18123 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18124 {
18125 struct stat induct_stat;
18126
18127 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18128 {
18129 unlink (induction_dictionaries[file_pos]);
18130 }
18131 }
18132
18133 // wait for non-interactive threads
18134
18135 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18136 {
18137 hc_thread_wait (1, &ni_threads[thread_idx]);
18138 }
18139
18140 local_free (ni_threads);
18141
18142 // wait for interactive threads
18143
18144 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18145 {
18146 hc_thread_wait (1, &i_threads[thread_idx]);
18147 }
18148
18149 local_free (i_threads);
18150
18151 // we dont need restore file anymore
18152 if (data.restore_disable == 0)
18153 {
18154 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18155 {
18156 unlink (eff_restore_file);
18157 unlink (new_restore_file);
18158 }
18159 else
18160 {
18161 cycle_restore ();
18162 }
18163 }
18164
18165 // finally save left hashes
18166
18167 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18168 {
18169 save_hash ();
18170 }
18171
18172 /**
18173 * Clean up
18174 */
18175
18176 if (benchmark == 1)
18177 {
18178 status_benchmark ();
18179
18180 if (machine_readable == 0)
18181 {
18182 log_info ("");
18183 }
18184 }
18185 else
18186 {
18187 if (quiet == 0) clear_prompt ();
18188
18189 if (quiet == 0) log_info ("");
18190
18191 if (status == 1)
18192 {
18193 status_display ();
18194 }
18195 else
18196 {
18197 if (quiet == 0) status_display ();
18198 }
18199
18200 if (quiet == 0) log_info ("");
18201 }
18202
18203 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18204 {
18205 hc_device_param_t *device_param = &data.devices_param[device_id];
18206
18207 if (device_param->skipped) continue;
18208
18209 local_free (device_param->combs_buf);
18210
18211 local_free (device_param->hooks_buf);
18212
18213 local_free (device_param->device_name);
18214
18215 local_free (device_param->device_name_chksum);
18216
18217 local_free (device_param->device_version);
18218
18219 local_free (device_param->driver_version);
18220
18221 if (device_param->pws_buf) myfree (device_param->pws_buf);
18222 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18223 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18224 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18225 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18226 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18227 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18228 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18229 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18230 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18231 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18232 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18233 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18234 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18235 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18236 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18237 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18238 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18239 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18240 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18241 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18242 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18243 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18244 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18245 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18246 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18247 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18248 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18249 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18250
18251 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18252 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18253 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18254 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18255 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18256 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18257 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18258 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18259 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18260 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18261 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18262
18263 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18264 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18265 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18266
18267 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18268 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18269 }
18270
18271 // reset default fan speed
18272
18273 #ifdef HAVE_HWMON
18274 if (gpu_temp_disable == 0)
18275 {
18276 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18277 {
18278 hc_thread_mutex_lock (mux_adl);
18279
18280 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18281 {
18282 hc_device_param_t *device_param = &data.devices_param[device_id];
18283
18284 if (device_param->skipped) continue;
18285
18286 if (data.hm_device[device_id].fan_set_supported == 1)
18287 {
18288 int fanspeed = temp_retain_fanspeed_value[device_id];
18289 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18290
18291 if (fanpolicy == 1)
18292 {
18293 int rc = -1;
18294
18295 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18296 {
18297 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18298 }
18299 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18300 {
18301
18302 }
18303
18304 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18305 }
18306 }
18307 }
18308
18309 hc_thread_mutex_unlock (mux_adl);
18310 }
18311 }
18312
18313 // reset power tuning
18314
18315 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18316 {
18317 hc_thread_mutex_lock (mux_adl);
18318
18319 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18320 {
18321 hc_device_param_t *device_param = &data.devices_param[device_id];
18322
18323 if (device_param->skipped) continue;
18324
18325 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18326 {
18327 if (data.hm_device[device_id].od_version == 6)
18328 {
18329 // check powertune capabilities first, if not available then skip device
18330
18331 int powertune_supported = 0;
18332
18333 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18334 {
18335 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18336
18337 return (-1);
18338 }
18339
18340 if (powertune_supported != 0)
18341 {
18342 // powercontrol settings
18343
18344 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18345 {
18346 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18347
18348 return (-1);
18349 }
18350
18351 // clocks
18352
18353 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18354
18355 performance_state->iNumberOfPerformanceLevels = 2;
18356
18357 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18358 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18359 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18360 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18361
18362 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18363 {
18364 log_info ("ERROR: Failed to restore ADL performance state");
18365
18366 return (-1);
18367 }
18368
18369 local_free (performance_state);
18370 }
18371 }
18372 }
18373
18374 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18375 {
18376 unsigned int limit = nvml_power_limit[device_id];
18377
18378 if (limit > 0)
18379 {
18380 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18381 }
18382 }
18383 }
18384
18385 hc_thread_mutex_unlock (mux_adl);
18386 }
18387
18388 if (gpu_temp_disable == 0)
18389 {
18390 if (data.hm_nvml)
18391 {
18392 hm_NVML_nvmlShutdown (data.hm_nvml);
18393
18394 nvml_close (data.hm_nvml);
18395
18396 data.hm_nvml = NULL;
18397 }
18398
18399 if (data.hm_adl)
18400 {
18401 hm_ADL_Main_Control_Destroy (data.hm_adl);
18402
18403 adl_close (data.hm_adl);
18404
18405 data.hm_adl = NULL;
18406 }
18407 }
18408 #endif // HAVE_HWMON
18409
18410 // free memory
18411
18412 local_free (masks);
18413
18414 local_free (dictstat_base);
18415
18416 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18417 {
18418 pot_t *pot_ptr = &pot[pot_pos];
18419
18420 hash_t *hash = &pot_ptr->hash;
18421
18422 local_free (hash->digest);
18423
18424 if (isSalted)
18425 {
18426 local_free (hash->salt);
18427 }
18428 }
18429
18430 local_free (pot);
18431
18432 local_free (all_kernel_rules_cnt);
18433 local_free (all_kernel_rules_buf);
18434
18435 local_free (wl_data->buf);
18436 local_free (wl_data);
18437
18438 local_free (bitmap_s1_a);
18439 local_free (bitmap_s1_b);
18440 local_free (bitmap_s1_c);
18441 local_free (bitmap_s1_d);
18442 local_free (bitmap_s2_a);
18443 local_free (bitmap_s2_b);
18444 local_free (bitmap_s2_c);
18445 local_free (bitmap_s2_d);
18446
18447 #ifdef HAVE_HWMON
18448 local_free (temp_retain_fanspeed_value);
18449 local_free (od_clock_mem_status);
18450 local_free (od_power_control_status);
18451 local_free (nvml_power_limit);
18452 #endif
18453
18454 global_free (devices_param);
18455
18456 global_free (kernel_rules_buf);
18457
18458 global_free (root_css_buf);
18459 global_free (markov_css_buf);
18460
18461 global_free (digests_buf);
18462 global_free (digests_shown);
18463 global_free (digests_shown_tmp);
18464
18465 global_free (salts_buf);
18466 global_free (salts_shown);
18467
18468 global_free (esalts_buf);
18469
18470 global_free (words_progress_done);
18471 global_free (words_progress_rejected);
18472 global_free (words_progress_restored);
18473
18474 if (pot_fp) fclose (pot_fp);
18475
18476 if (data.devices_status == STATUS_QUIT) break;
18477 }
18478
18479 // destroy others mutex
18480
18481 hc_thread_mutex_delete (mux_dispatcher);
18482 hc_thread_mutex_delete (mux_counter);
18483 hc_thread_mutex_delete (mux_display);
18484 hc_thread_mutex_delete (mux_adl);
18485
18486 // free memory
18487
18488 local_free (eff_restore_file);
18489 local_free (new_restore_file);
18490
18491 local_free (rd);
18492
18493 // tuning db
18494
18495 tuning_db_destroy (tuning_db);
18496
18497 // loopback
18498
18499 local_free (loopback_file);
18500
18501 if (loopback == 1) unlink (loopback_file);
18502
18503 // induction directory
18504
18505 if (induction_dir == NULL)
18506 {
18507 if (attack_mode != ATTACK_MODE_BF)
18508 {
18509 if (rmdir (induction_directory) == -1)
18510 {
18511 if (errno == ENOENT)
18512 {
18513 // good, we can ignore
18514 }
18515 else if (errno == ENOTEMPTY)
18516 {
18517 // good, we can ignore
18518 }
18519 else
18520 {
18521 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18522
18523 return (-1);
18524 }
18525 }
18526
18527 local_free (induction_directory);
18528 }
18529 }
18530
18531 // outfile-check directory
18532
18533 if (outfile_check_dir == NULL)
18534 {
18535 if (rmdir (outfile_check_directory) == -1)
18536 {
18537 if (errno == ENOENT)
18538 {
18539 // good, we can ignore
18540 }
18541 else if (errno == ENOTEMPTY)
18542 {
18543 // good, we can ignore
18544 }
18545 else
18546 {
18547 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18548
18549 return (-1);
18550 }
18551 }
18552
18553 local_free (outfile_check_directory);
18554 }
18555
18556 time_t proc_stop;
18557
18558 time (&proc_stop);
18559
18560 logfile_top_uint (proc_start);
18561 logfile_top_uint (proc_stop);
18562
18563 logfile_top_msg ("STOP");
18564
18565 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18566 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18567
18568 if (data.ocl) ocl_close (data.ocl);
18569
18570 if (data.devices_status == STATUS_ABORTED) return 2;
18571 if (data.devices_status == STATUS_QUIT) return 2;
18572 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18573 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18574 if (data.devices_status == STATUS_CRACKED) return 0;
18575
18576 return -1;
18577 }
Hashcat additions to support pwdhash