projects / hashcat.git / blob
? search:


c3091300e65087dd51a998dbdf3112d10e7010bd
[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[3] = { 8, 16, 96 };
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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "=======",
353 "Options",
354 "=======",
355 "",
356 "* General:",
357 "",
358 " -m, --hash-type=NUM Hash-type, see references below",
359 " -a, --attack-mode=NUM Attack-mode, see references below",
360 " -V, --version Print version",
361 " -h, --help Print help",
362 " --quiet Suppress output",
363 "",
364 "* Misc:",
365 "",
366 " --hex-charset Assume charset is given in hex",
367 " --hex-salt Assume salt is given in hex",
368 " --hex-wordlist Assume words in wordlist is given in hex",
369 " --force Ignore warnings",
370 " --status Enable automatic update of the status-screen",
371 " --status-timer=NUM Seconds between status-screen update",
372 " --status-automat Display the status view in a machine readable format",
373 " --loopback Add new plains to induct directory",
374 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
375 "",
376 "* Markov:",
377 "",
378 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
379 " --markov-disable Disables markov-chains, emulates classic brute-force",
380 " --markov-classic Enables classic markov-chains, no per-position enhancement",
381 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
382 "",
383 "* Session:",
384 "",
385 " --runtime=NUM Abort session after NUM seconds of runtime",
386 " --session=STR Define specific session name",
387 " --restore Restore session from --session",
388 " --restore-disable Do not write restore file",
389 "",
390 "* Files:",
391 "",
392 " -o, --outfile=FILE Define outfile for recovered hash",
393 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
394 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
395 " --outfile-check-timer=NUM Seconds between outfile checks",
396 " -p, --separator=CHAR Separator char for hashlists and outfile",
397 " --show Show cracked passwords only",
398 " --left Show un-cracked passwords only",
399 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
400 " --remove Enable remove of hash once it is cracked",
401 " --remove-timer=NUM Update input hash file each NUM seconds",
402 " --potfile-disable Do not write potfile",
403 " --potfile-path Specific path to potfile",
404 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
405 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
406 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
407 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
408 " --logfile-disable Disable the logfile",
409 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
410 " --veracrypt-keyfiles=FILE Keyfiles used, separate with comma",
411 " --veracrypt-pim=NUM VeraCrypt personal iterations multiplier",
412 "",
413 "* Resources:",
414 "",
415 " -b, --benchmark Run benchmark",
416 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
417 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
418 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
419 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
420 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
421 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
422 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
423 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
424 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
425 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
426 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
427 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
428 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
429 #ifdef HAVE_HWMON
430 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
431 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
432 #ifdef HAVE_ADL
433 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
434 #endif
435 #endif
436 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
437 "",
438 "* Distributed:",
439 "",
440 " -s, --skip=NUM Skip number of words",
441 " -l, --limit=NUM Limit number of words",
442 " --keyspace Show keyspace base:mod values and quit",
443 "",
444 "* Rules:",
445 "",
446 " -j, --rule-left=RULE Single rule applied to each word from left dict",
447 " -k, --rule-right=RULE Single rule applied to each word from right dict",
448 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
449 " -g, --generate-rules=NUM Generate NUM random rules",
450 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
451 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
452 " --generate-rules-seed=NUM Force RNG seed to NUM",
453 "",
454 "* Custom charsets:",
455 "",
456 " -1, --custom-charset1=CS User-defined charsets",
457 " -2, --custom-charset2=CS Example:",
458 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
459 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
460 "",
461 "* Increment:",
462 "",
463 " -i, --increment Enable increment mode",
464 " --increment-min=NUM Start incrementing at NUM",
465 " --increment-max=NUM Stop incrementing at NUM",
466 "",
467 "==========",
468 "References",
469 "==========",
470 "",
471 "* Workload Profile:",
472 "",
473 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
474 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
475 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
476 "",
477 "* OpenCL device-types:",
478 "",
479 " 1 = CPU devices",
480 " 2 = GPU devices",
481 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
482 "",
483 "* Outfile Formats:",
484 "",
485 " 1 = hash[:salt]",
486 " 2 = plain",
487 " 3 = hash[:salt]:plain",
488 " 4 = hex_plain",
489 " 5 = hash[:salt]:hex_plain",
490 " 6 = plain:hex_plain",
491 " 7 = hash[:salt]:plain:hex_plain",
492 " 8 = crackpos",
493 " 9 = hash[:salt]:crackpos",
494 " 10 = plain:crackpos",
495 " 11 = hash[:salt]:plain:crackpos",
496 " 12 = hex_plain:crackpos",
497 " 13 = hash[:salt]:hex_plain:crackpos",
498 " 14 = plain:hex_plain:crackpos",
499 " 15 = hash[:salt]:plain:hex_plain:crackpos",
500 "",
501 "* Debug mode output formats (for hybrid mode only, by using rules):",
502 "",
503 " 1 = save finding rule",
504 " 2 = save original word",
505 " 3 = save original word and finding rule",
506 " 4 = save original word, finding rule and modified plain",
507 "",
508 "* Built-in charsets:",
509 "",
510 " ?l = abcdefghijklmnopqrstuvwxyz",
511 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
512 " ?d = 0123456789",
513 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
514 " ?a = ?l?u?d?s",
515 " ?b = 0x00 - 0xff",
516 "",
517 "* Attack modes:",
518 "",
519 " 0 = Straight",
520 " 1 = Combination",
521 " 3 = Brute-force",
522 " 6 = Hybrid dict + mask",
523 " 7 = Hybrid mask + dict",
524 "",
525 "* Hash types:",
526 "",
527 "[[ Roll-your-own: Raw Hashes ]]",
528 "",
529 " 900 = MD4",
530 " 0 = MD5",
531 " 5100 = Half MD5",
532 " 100 = SHA1",
533 " 10800 = SHA-384",
534 " 1400 = SHA-256",
535 " 1700 = SHA-512",
536 " 5000 = SHA-3(Keccak)",
537 " 10100 = SipHash",
538 " 6000 = RipeMD160",
539 " 6100 = Whirlpool",
540 " 6900 = GOST R 34.11-94",
541 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
542 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
543 "",
544 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
545 "",
546 " 10 = md5($pass.$salt)",
547 " 20 = md5($salt.$pass)",
548 " 30 = md5(unicode($pass).$salt)",
549 " 40 = md5($salt.unicode($pass))",
550 " 3800 = md5($salt.$pass.$salt)",
551 " 3710 = md5($salt.md5($pass))",
552 " 2600 = md5(md5($pass)",
553 " 4300 = md5(strtoupper(md5($pass)))",
554 " 4400 = md5(sha1($pass))",
555 " 110 = sha1($pass.$salt)",
556 " 120 = sha1($salt.$pass)",
557 " 130 = sha1(unicode($pass).$salt)",
558 " 140 = sha1($salt.unicode($pass))",
559 " 4500 = sha1(sha1($pass)",
560 " 4700 = sha1(md5($pass))",
561 " 4900 = sha1($salt.$pass.$salt)",
562 " 1410 = sha256($pass.$salt)",
563 " 1420 = sha256($salt.$pass)",
564 " 1430 = sha256(unicode($pass).$salt)",
565 " 1440 = sha256($salt.unicode($pass))",
566 " 1710 = sha512($pass.$salt)",
567 " 1720 = sha512($salt.$pass)",
568 " 1730 = sha512(unicode($pass).$salt)",
569 " 1740 = sha512($salt.unicode($pass))",
570 "",
571 "[[ Roll-your-own: Authenticated Hashes ]]",
572 "",
573 " 50 = HMAC-MD5 (key = $pass)",
574 " 60 = HMAC-MD5 (key = $salt)",
575 " 150 = HMAC-SHA1 (key = $pass)",
576 " 160 = HMAC-SHA1 (key = $salt)",
577 " 1450 = HMAC-SHA256 (key = $pass)",
578 " 1460 = HMAC-SHA256 (key = $salt)",
579 " 1750 = HMAC-SHA512 (key = $pass)",
580 " 1760 = HMAC-SHA512 (key = $salt)",
581 "",
582 "[[ Generic KDF ]]",
583 "",
584 " 400 = phpass",
585 " 8900 = scrypt",
586 " 11900 = PBKDF2-HMAC-MD5",
587 " 12000 = PBKDF2-HMAC-SHA1",
588 " 10900 = PBKDF2-HMAC-SHA256",
589 " 12100 = PBKDF2-HMAC-SHA512",
590 "",
591 "[[ Network protocols, Challenge-Response ]]",
592 "",
593 " 23 = Skype",
594 " 2500 = WPA/WPA2",
595 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
596 " 5300 = IKE-PSK MD5",
597 " 5400 = IKE-PSK SHA1",
598 " 5500 = NetNTLMv1",
599 " 5500 = NetNTLMv1 + ESS",
600 " 5600 = NetNTLMv2",
601 " 7300 = IPMI2 RAKP HMAC-SHA1",
602 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
603 " 8300 = DNSSEC (NSEC3)",
604 " 10200 = Cram MD5",
605 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
606 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
607 " 11400 = SIP digest authentication (MD5)",
608 " 13100 = Kerberos 5 TGS-REP etype 23",
609 "",
610 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
611 "",
612 " 121 = SMF (Simple Machines Forum)",
613 " 400 = phpBB3",
614 " 2611 = vBulletin < v3.8.5",
615 " 2711 = vBulletin > v3.8.5",
616 " 2811 = MyBB",
617 " 2811 = IPB (Invison Power Board)",
618 " 8400 = WBB3 (Woltlab Burning Board)",
619 " 11 = Joomla < 2.5.18",
620 " 400 = Joomla > 2.5.18",
621 " 400 = Wordpress",
622 " 2612 = PHPS",
623 " 7900 = Drupal7",
624 " 21 = osCommerce",
625 " 21 = xt:Commerce",
626 " 11000 = PrestaShop",
627 " 124 = Django (SHA-1)",
628 " 10000 = Django (PBKDF2-SHA256)",
629 " 3711 = Mediawiki B type",
630 " 7600 = Redmine",
631 "",
632 "[[ Database Server ]]",
633 "",
634 " 12 = PostgreSQL",
635 " 131 = MSSQL(2000)",
636 " 132 = MSSQL(2005)",
637 " 1731 = MSSQL(2012)",
638 " 1731 = MSSQL(2014)",
639 " 200 = MySQL323",
640 " 300 = MySQL4.1/MySQL5",
641 " 3100 = Oracle H: Type (Oracle 7+)",
642 " 112 = Oracle S: Type (Oracle 11+)",
643 " 12300 = Oracle T: Type (Oracle 12+)",
644 " 8000 = Sybase ASE",
645 "",
646 "[[ HTTP, SMTP, LDAP Server ]]",
647 "",
648 " 141 = EPiServer 6.x < v4",
649 " 1441 = EPiServer 6.x > v4",
650 " 1600 = Apache $apr1$",
651 " 12600 = ColdFusion 10+",
652 " 1421 = hMailServer",
653 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
654 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
655 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
656 "",
657 "[[ Checksums ]]",
658 "",
659 " 11500 = CRC32",
660 "",
661 "[[ Operating-Systems ]]",
662 "",
663 " 3000 = LM",
664 " 1000 = NTLM",
665 " 1100 = Domain Cached Credentials (DCC), MS Cache",
666 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
667 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
668 " 1500 = descrypt, DES(Unix), Traditional DES",
669 " 12400 = BSDiCrypt, Extended DES",
670 " 500 = md5crypt $1$, MD5(Unix)",
671 " 3200 = bcrypt $2*$, Blowfish(Unix)",
672 " 7400 = sha256crypt $5$, SHA256(Unix)",
673 " 1800 = sha512crypt $6$, SHA512(Unix)",
674 " 122 = OSX v10.4",
675 " 122 = OSX v10.5",
676 " 122 = OSX v10.6",
677 " 1722 = OSX v10.7",
678 " 7100 = OSX v10.8",
679 " 7100 = OSX v10.9",
680 " 7100 = OSX v10.10",
681 " 6300 = AIX {smd5}",
682 " 6700 = AIX {ssha1}",
683 " 6400 = AIX {ssha256}",
684 " 6500 = AIX {ssha512}",
685 " 2400 = Cisco-PIX",
686 " 2410 = Cisco-ASA",
687 " 500 = Cisco-IOS $1$",
688 " 5700 = Cisco-IOS $4$",
689 " 9200 = Cisco-IOS $8$",
690 " 9300 = Cisco-IOS $9$",
691 " 22 = Juniper Netscreen/SSG (ScreenOS)",
692 " 501 = Juniper IVE",
693 " 5800 = Android PIN",
694 " 8100 = Citrix Netscaler",
695 " 8500 = RACF",
696 " 7200 = GRUB 2",
697 " 9900 = Radmin2",
698 " 125 = ArubaOS",
699 "",
700 "[[ Enterprise Application Software (EAS) ]]",
701 "",
702 " 7700 = SAP CODVN B (BCODE)",
703 " 7800 = SAP CODVN F/G (PASSCODE)",
704 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
705 " 8600 = Lotus Notes/Domino 5",
706 " 8700 = Lotus Notes/Domino 6",
707 " 9100 = Lotus Notes/Domino 8",
708 " 133 = PeopleSoft",
709 " 13500 = PeopleSoft Token",
710 "",
711 "[[ Archives ]]",
712 "",
713 " 11600 = 7-Zip",
714 " 12500 = RAR3-hp",
715 " 13000 = RAR5",
716 " 13200 = AxCrypt",
717 " 13300 = AxCrypt in memory SHA1",
718 " 13600 = WinZip",
719 "",
720 "[[ Full-Disk encryptions (FDE) ]]",
721 "",
722 " 62XY = TrueCrypt",
723 " X = 1 = PBKDF2-HMAC-RipeMD160",
724 " X = 2 = PBKDF2-HMAC-SHA512",
725 " X = 3 = PBKDF2-HMAC-Whirlpool",
726 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
727 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
728 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
729 " Y = 3 = XTS 1536 bit (Ciphers: All)",
730 " 8800 = Android FDE < v4.3",
731 " 12900 = Android FDE (Samsung DEK)",
732 " 12200 = eCryptfs",
733 " 137XY = VeraCrypt",
734 " X = 1 = PBKDF2-HMAC-RipeMD160",
735 " X = 2 = PBKDF2-HMAC-SHA512",
736 " X = 3 = PBKDF2-HMAC-Whirlpool",
737 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
738 " X = 5 = PBKDF2-HMAC-SHA256",
739 " X = 6 = PBKDF2-HMAC-SHA256 + boot-mode",
740 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
741 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
742 " Y = 3 = XTS 1536 bit (Ciphers: All)",
743 "",
744 "[[ Documents ]]",
745 "",
746 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
747 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
748 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
749 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
750 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
751 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
752 " 9400 = MS Office 2007",
753 " 9500 = MS Office 2010",
754 " 9600 = MS Office 2013",
755 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
756 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
757 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
758 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
759 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
760 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
761 "",
762 "[[ Password Managers ]]",
763 "",
764 " 9000 = Password Safe v2",
765 " 5200 = Password Safe v3",
766 " 6800 = Lastpass",
767 " 6600 = 1Password, agilekeychain",
768 " 8200 = 1Password, cloudkeychain",
769 " 11300 = Bitcoin/Litecoin wallet.dat",
770 " 12700 = Blockchain, My Wallet",
771 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
772 "",
773 NULL
774 };
775
776 /**
777 * hashcat specific functions
778 */
779
780 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
781 {
782 int exec_pos = (int) device_param->exec_pos - last_num_entries;
783
784 if (exec_pos < 0) exec_pos += EXEC_CACHE;
785
786 double exec_ms_sum = 0;
787
788 int exec_ms_cnt = 0;
789
790 for (int i = 0; i < last_num_entries; i++)
791 {
792 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
793
794 if (exec_ms)
795 {
796 exec_ms_sum += exec_ms;
797
798 exec_ms_cnt++;
799 }
800 }
801
802 if (exec_ms_cnt == 0) return 0;
803
804 return exec_ms_sum / exec_ms_cnt;
805 }
806
807 void status_display_automat ()
808 {
809 FILE *out = stdout;
810
811 fprintf (out, "STATUS\t%u\t", data.devices_status);
812
813 /**
814 * speed new
815 */
816
817 fprintf (out, "SPEED\t");
818
819 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
820 {
821 hc_device_param_t *device_param = &data.devices_param[device_id];
822
823 if (device_param->skipped) continue;
824
825 u64 speed_cnt = 0;
826 double speed_ms = 0;
827
828 for (int i = 0; i < SPEED_CACHE; i++)
829 {
830 speed_cnt += device_param->speed_cnt[i];
831 speed_ms += device_param->speed_ms[i];
832 }
833
834 speed_cnt /= SPEED_CACHE;
835 speed_ms /= SPEED_CACHE;
836
837 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
838 }
839
840 /**
841 * exec time
842 */
843
844 fprintf (out, "EXEC_RUNTIME\t");
845
846 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
847 {
848 hc_device_param_t *device_param = &data.devices_param[device_id];
849
850 if (device_param->skipped) continue;
851
852 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
853
854 fprintf (out, "%f\t", exec_ms_avg);
855 }
856
857 /**
858 * words_cur
859 */
860
861 u64 words_cur = get_lowest_words_done ();
862
863 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
864
865 /**
866 * counter
867 */
868
869 u64 progress_total = data.words_cnt * data.salts_cnt;
870
871 u64 all_done = 0;
872 u64 all_rejected = 0;
873 u64 all_restored = 0;
874
875 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
876 {
877 all_done += data.words_progress_done[salt_pos];
878 all_rejected += data.words_progress_rejected[salt_pos];
879 all_restored += data.words_progress_restored[salt_pos];
880 }
881
882 u64 progress_cur = all_restored + all_done + all_rejected;
883 u64 progress_end = progress_total;
884
885 u64 progress_skip = 0;
886
887 if (data.skip)
888 {
889 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
890
891 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
892 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
893 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
894 }
895
896 if (data.limit)
897 {
898 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
899
900 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
901 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
902 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
903 }
904
905 u64 progress_cur_relative_skip = progress_cur - progress_skip;
906 u64 progress_end_relative_skip = progress_end - progress_skip;
907
908 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
909
910 /**
911 * cracks
912 */
913
914 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
915 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
916
917 /**
918 * temperature
919 */
920
921 #ifdef HAVE_HWMON
922 if (data.gpu_temp_disable == 0)
923 {
924 fprintf (out, "TEMP\t");
925
926 hc_thread_mutex_lock (mux_adl);
927
928 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
929 {
930 hc_device_param_t *device_param = &data.devices_param[device_id];
931
932 if (device_param->skipped) continue;
933
934 int temp = hm_get_temperature_with_device_id (device_id);
935
936 fprintf (out, "%d\t", temp);
937 }
938
939 hc_thread_mutex_unlock (mux_adl);
940 }
941 #endif // HAVE_HWMON
942
943 /**
944 * flush
945 */
946
947 #ifdef _WIN
948 fputc ('\r', out);
949 fputc ('\n', out);
950 #endif
951
952 #ifdef _POSIX
953 fputc ('\n', out);
954 #endif
955
956 fflush (out);
957 }
958
959 void status_display ()
960 {
961 if (data.devices_status == STATUS_INIT) return;
962 if (data.devices_status == STATUS_STARTING) return;
963 if (data.devices_status == STATUS_BYPASS) return;
964
965 if (data.status_automat == 1)
966 {
967 status_display_automat ();
968
969 return;
970 }
971
972 char tmp_buf[1000] = { 0 };
973
974 uint tmp_len = 0;
975
976 log_info ("Session.Name...: %s", data.session);
977
978 char *status_type = strstatus (data.devices_status);
979
980 uint hash_mode = data.hash_mode;
981
982 char *hash_type = strhashtype (hash_mode); // not a bug
983
984 log_info ("Status.........: %s", status_type);
985
986 /**
987 * show rules
988 */
989
990 if (data.rp_files_cnt)
991 {
992 uint i;
993
994 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
995 {
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
997 }
998
999 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
1000
1001 log_info ("Rules.Type.....: %s", tmp_buf);
1002
1003 tmp_len = 0;
1004 }
1005
1006 if (data.rp_gen)
1007 {
1008 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
1009
1010 if (data.rp_gen_seed)
1011 {
1012 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
1013 }
1014 }
1015
1016 /**
1017 * show input
1018 */
1019
1020 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1021 {
1022 if (data.wordlist_mode == WL_MODE_FILE)
1023 {
1024 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1025 }
1026 else if (data.wordlist_mode == WL_MODE_STDIN)
1027 {
1028 log_info ("Input.Mode.....: Pipe");
1029 }
1030 }
1031 else if (data.attack_mode == ATTACK_MODE_COMBI)
1032 {
1033 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1034 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_BF)
1037 {
1038 char *mask = data.mask;
1039
1040 if (mask != NULL)
1041 {
1042 uint mask_len = data.css_cnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1045
1046 if (mask_len > 0)
1047 {
1048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1049 {
1050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1051 {
1052 mask_len -= data.salts_buf[0].salt_len;
1053 }
1054 }
1055
1056 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1057
1058 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1059 }
1060
1061 if (data.maskcnt > 1)
1062 {
1063 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1064
1065 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1066 }
1067
1068 log_info ("Input.Mode.....: %s", tmp_buf);
1069 }
1070
1071 tmp_len = 0;
1072 }
1073 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1074 {
1075 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1076 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1077 }
1078 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1079 {
1080 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1081 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1082 }
1083
1084 if (data.digests_cnt == 1)
1085 {
1086 if (data.hash_mode == 2500)
1087 {
1088 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1089
1090 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1091 (char *) data.salts_buf[0].salt_buf,
1092 wpa->orig_mac1[0],
1093 wpa->orig_mac1[1],
1094 wpa->orig_mac1[2],
1095 wpa->orig_mac1[3],
1096 wpa->orig_mac1[4],
1097 wpa->orig_mac1[5],
1098 wpa->orig_mac2[0],
1099 wpa->orig_mac2[1],
1100 wpa->orig_mac2[2],
1101 wpa->orig_mac2[3],
1102 wpa->orig_mac2[4],
1103 wpa->orig_mac2[5]);
1104 }
1105 else if (data.hash_mode == 5200)
1106 {
1107 log_info ("Hash.Target....: File (%s)", data.hashfile);
1108 }
1109 else if (data.hash_mode == 9000)
1110 {
1111 log_info ("Hash.Target....: File (%s)", data.hashfile);
1112 }
1113 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1114 {
1115 log_info ("Hash.Target....: File (%s)", data.hashfile);
1116 }
1117 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 else
1122 {
1123 char out_buf[HCBUFSIZ] = { 0 };
1124
1125 ascii_digest (out_buf, 0, 0);
1126
1127 // limit length
1128 if (strlen (out_buf) > 40)
1129 {
1130 out_buf[41] = '.';
1131 out_buf[42] = '.';
1132 out_buf[43] = '.';
1133 out_buf[44] = 0;
1134 }
1135
1136 log_info ("Hash.Target....: %s", out_buf);
1137 }
1138 }
1139 else
1140 {
1141 if (data.hash_mode == 3000)
1142 {
1143 char out_buf1[32] = { 0 };
1144 char out_buf2[32] = { 0 };
1145
1146 ascii_digest (out_buf1, 0, 0);
1147 ascii_digest (out_buf2, 0, 1);
1148
1149 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1150 }
1151 else
1152 {
1153 log_info ("Hash.Target....: File (%s)", data.hashfile);
1154 }
1155 }
1156
1157 log_info ("Hash.Type......: %s", hash_type);
1158
1159 /**
1160 * speed new
1161 */
1162
1163 u64 speed_cnt[DEVICES_MAX] = { 0 };
1164 double speed_ms[DEVICES_MAX] = { 0 };
1165
1166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1167 {
1168 hc_device_param_t *device_param = &data.devices_param[device_id];
1169
1170 if (device_param->skipped) continue;
1171
1172 speed_cnt[device_id] = 0;
1173 speed_ms[device_id] = 0;
1174
1175 for (int i = 0; i < SPEED_CACHE; i++)
1176 {
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 double hashes_all_ms = 0;
1186
1187 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 double ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 double ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 double ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 u64 progress_total = data.words_cnt * data.salts_cnt;
1297
1298 u64 all_done = 0;
1299 u64 all_rejected = 0;
1300 u64 all_restored = 0;
1301
1302 u64 progress_noneed = 0;
1303
1304 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1305 {
1306 all_done += data.words_progress_done[salt_pos];
1307 all_rejected += data.words_progress_rejected[salt_pos];
1308 all_restored += data.words_progress_restored[salt_pos];
1309
1310 // Important for ETA only
1311
1312 if (data.salts_shown[salt_pos] == 1)
1313 {
1314 const u64 all = data.words_progress_done[salt_pos]
1315 + data.words_progress_rejected[salt_pos]
1316 + data.words_progress_restored[salt_pos];
1317
1318 const u64 left = data.words_cnt - all;
1319
1320 progress_noneed += left;
1321 }
1322 }
1323
1324 u64 progress_cur = all_restored + all_done + all_rejected;
1325 u64 progress_end = progress_total;
1326
1327 u64 progress_skip = 0;
1328
1329 if (data.skip)
1330 {
1331 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1336 }
1337
1338 if (data.limit)
1339 {
1340 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1341
1342 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1344 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1345 }
1346
1347 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1348 u64 progress_end_relative_skip = progress_end - progress_skip;
1349
1350 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1351 {
1352 if (data.devices_status != STATUS_CRACKED)
1353 {
1354 #ifdef WIN
1355 __time64_t sec_etc = 0;
1356 #else
1357 time_t sec_etc = 0;
1358 #endif
1359
1360 if (hashes_all_ms)
1361 {
1362 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1363
1364 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1365
1366 sec_etc = ms_left / 1000;
1367 }
1368
1369 if (sec_etc == 0)
1370 {
1371 //log_info ("Time.Estimated.: 0 secs");
1372 }
1373 else if ((u64) sec_etc > ETC_MAX)
1374 {
1375 log_info ("Time.Estimated.: > 10 Years");
1376 }
1377 else
1378 {
1379 char display_etc[32] = { 0 };
1380
1381 struct tm tm_etc;
1382
1383 struct tm *tmp = NULL;
1384
1385 #ifdef WIN
1386
1387 tmp = _gmtime64 (&sec_etc);
1388
1389 #else
1390
1391 tmp = gmtime (&sec_etc);
1392
1393 #endif
1394
1395 if (tmp != NULL)
1396 {
1397 memset (&tm_etc, 0, sizeof (tm_etc));
1398
1399 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1400
1401 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1402
1403 time_t now;
1404
1405 time (&now);
1406
1407 now += sec_etc;
1408
1409 char *etc = ctime (&now);
1410
1411 size_t etc_len = strlen (etc);
1412
1413 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1414 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1415
1416 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1417 }
1418 }
1419 }
1420 }
1421
1422 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1423 {
1424 hc_device_param_t *device_param = &data.devices_param[device_id];
1425
1426 if (device_param->skipped) continue;
1427
1428 char display_dev_cur[16] = { 0 };
1429
1430 strncpy (display_dev_cur, "0.00", 4);
1431
1432 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1433
1434 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1435 }
1436
1437 char display_all_cur[16] = { 0 };
1438
1439 strncpy (display_all_cur, "0.00", 4);
1440
1441 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1442
1443 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1444
1445 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1446 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1447
1448 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);
1449
1450 // crack-per-time
1451
1452 if (data.digests_cnt > 100)
1453 {
1454 time_t now = time (NULL);
1455
1456 int cpt_cur_min = 0;
1457 int cpt_cur_hour = 0;
1458 int cpt_cur_day = 0;
1459
1460 for (int i = 0; i < CPT_BUF; i++)
1461 {
1462 const uint cracked = data.cpt_buf[i].cracked;
1463 const time_t timestamp = data.cpt_buf[i].timestamp;
1464
1465 if ((timestamp + 60) > now)
1466 {
1467 cpt_cur_min += cracked;
1468 }
1469
1470 if ((timestamp + 3600) > now)
1471 {
1472 cpt_cur_hour += cracked;
1473 }
1474
1475 if ((timestamp + 86400) > now)
1476 {
1477 cpt_cur_day += cracked;
1478 }
1479 }
1480
1481 double ms_real = ms_running - ms_paused;
1482
1483 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1484 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1485 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1486
1487 if ((data.cpt_start + 86400) < now)
1488 {
1489 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1490 cpt_cur_min,
1491 cpt_cur_hour,
1492 cpt_cur_day,
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 else if ((data.cpt_start + 3600) < now)
1498 {
1499 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1500 cpt_cur_min,
1501 cpt_cur_hour,
1502 cpt_avg_min,
1503 cpt_avg_hour,
1504 cpt_avg_day);
1505 }
1506 else if ((data.cpt_start + 60) < now)
1507 {
1508 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1509 cpt_cur_min,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else
1515 {
1516 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_avg_min,
1518 cpt_avg_hour,
1519 cpt_avg_day);
1520 }
1521 }
1522
1523 // Restore point
1524
1525 u64 restore_point = get_lowest_words_done ();
1526
1527 u64 restore_total = data.words_base;
1528
1529 float percent_restore = 0;
1530
1531 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1532
1533 if (progress_end_relative_skip)
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1538 float percent_rejected = 0.0;
1539
1540 if (progress_cur)
1541 {
1542 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1543 }
1544
1545 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);
1546 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1547
1548 if (data.restore_disable == 0)
1549 {
1550 if (percent_finished != 1)
1551 {
1552 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1553 }
1554 }
1555 }
1556 }
1557 else
1558 {
1559 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1560 {
1561 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563
1564 if (data.restore_disable == 0)
1565 {
1566 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567 }
1568 }
1569 else
1570 {
1571 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1572 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1573
1574 // --restore not allowed if stdin is used -- really? why?
1575
1576 //if (data.restore_disable == 0)
1577 //{
1578 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1579 //}
1580 }
1581 }
1582
1583 #ifdef HAVE_HWMON
1584 if (data.gpu_temp_disable == 0)
1585 {
1586 hc_thread_mutex_lock (mux_adl);
1587
1588 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1589 {
1590 hc_device_param_t *device_param = &data.devices_param[device_id];
1591
1592 if (device_param->skipped) continue;
1593
1594 #define HM_STR_BUF_SIZE 255
1595
1596 if (data.hm_device[device_id].fan_supported == 1)
1597 {
1598 char utilization[HM_STR_BUF_SIZE] = { 0 };
1599 char temperature[HM_STR_BUF_SIZE] = { 0 };
1600 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1601
1602 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1603 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1604
1605 if (device_param->vendor_id == VENDOR_ID_AMD)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609 else if (device_param->vendor_id == VENDOR_ID_NV)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613
1614 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1615 }
1616 else
1617 {
1618 char utilization[HM_STR_BUF_SIZE] = { 0 };
1619 char temperature[HM_STR_BUF_SIZE] = { 0 };
1620
1621 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1622 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1623
1624 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1625 }
1626 }
1627
1628 hc_thread_mutex_unlock (mux_adl);
1629 }
1630 #endif // HAVE_HWMON
1631 }
1632
1633 static void status_benchmark_automat ()
1634 {
1635 u64 speed_cnt[DEVICES_MAX] = { 0 };
1636 double speed_ms[DEVICES_MAX] = { 0 };
1637
1638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1639 {
1640 hc_device_param_t *device_param = &data.devices_param[device_id];
1641
1642 if (device_param->skipped) continue;
1643
1644 speed_cnt[device_id] = device_param->speed_cnt[0];
1645 speed_ms[device_id] = device_param->speed_ms[0];
1646 }
1647
1648 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1649
1650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1651 {
1652 hc_device_param_t *device_param = &data.devices_param[device_id];
1653
1654 if (device_param->skipped) continue;
1655
1656 hashes_dev_ms[device_id] = 0;
1657
1658 if (speed_ms[device_id])
1659 {
1660 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1661 }
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1671 }
1672 }
1673
1674 static void status_benchmark ()
1675 {
1676 if (data.devices_status == STATUS_INIT) return;
1677 if (data.devices_status == STATUS_STARTING) return;
1678 if (data.devices_status == STATUS_BYPASS) return;
1679
1680 if (data.status_automat == 1)
1681 {
1682 status_benchmark_automat ();
1683
1684 return;
1685 }
1686
1687 u64 speed_cnt[DEVICES_MAX] = { 0 };
1688 double speed_ms[DEVICES_MAX] = { 0 };
1689
1690 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1691 {
1692 hc_device_param_t *device_param = &data.devices_param[device_id];
1693
1694 if (device_param->skipped) continue;
1695
1696 speed_cnt[device_id] = device_param->speed_cnt[0];
1697 speed_ms[device_id] = device_param->speed_ms[0];
1698 }
1699
1700 double hashes_all_ms = 0;
1701
1702 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 hashes_dev_ms[device_id] = 0;
1711
1712 if (speed_ms[device_id])
1713 {
1714 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1715
1716 hashes_all_ms += hashes_dev_ms[device_id];
1717 }
1718 }
1719
1720 /**
1721 * exec time
1722 */
1723
1724 double exec_all_ms[DEVICES_MAX] = { 0 };
1725
1726 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1727 {
1728 hc_device_param_t *device_param = &data.devices_param[device_id];
1729
1730 if (device_param->skipped) continue;
1731
1732 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1733
1734 exec_all_ms[device_id] = exec_ms_avg;
1735 }
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 char display_dev_cur[16] = { 0 };
1744
1745 strncpy (display_dev_cur, "0.00", 4);
1746
1747 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1748
1749 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1750 }
1751
1752 char display_all_cur[16] = { 0 };
1753
1754 strncpy (display_all_cur, "0.00", 4);
1755
1756 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1757
1758 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1759 }
1760
1761 /**
1762 * hashcat -only- functions
1763 */
1764
1765 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1766 {
1767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1768 {
1769 if (attack_kern == ATTACK_KERN_STRAIGHT)
1770 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1771 else if (attack_kern == ATTACK_KERN_COMBI)
1772 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1773 else if (attack_kern == ATTACK_KERN_BF)
1774 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1775 }
1776 else
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1778 }
1779
1780 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)
1781 {
1782 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1783 {
1784 if (attack_kern == ATTACK_KERN_STRAIGHT)
1785 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1786 else if (attack_kern == ATTACK_KERN_COMBI)
1787 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1788 else if (attack_kern == ATTACK_KERN_BF)
1789 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1790 }
1791 else
1792 {
1793 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1794 }
1795 }
1796
1797 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1798 {
1799 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1802 }
1803 else
1804 {
1805 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1806 }
1807 }
1808
1809 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)
1810 {
1811 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1812 {
1813 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1814 }
1815 else
1816 {
1817 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1818 }
1819 }
1820
1821 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1822 {
1823 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1824 }
1825
1826 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1827 {
1828 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1829 }
1830
1831 static uint convert_from_hex (char *line_buf, const uint line_len)
1832 {
1833 if (line_len & 1) return (line_len); // not in hex
1834
1835 if (data.hex_wordlist == 1)
1836 {
1837 uint i;
1838 uint j;
1839
1840 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1841 {
1842 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1843 }
1844
1845 memset (line_buf + i, 0, line_len - i);
1846
1847 return (i);
1848 }
1849 else if (line_len >= 6) // $HEX[] = 6
1850 {
1851 if (line_buf[0] != '$') return (line_len);
1852 if (line_buf[1] != 'H') return (line_len);
1853 if (line_buf[2] != 'E') return (line_len);
1854 if (line_buf[3] != 'X') return (line_len);
1855 if (line_buf[4] != '[') return (line_len);
1856 if (line_buf[line_len - 1] != ']') return (line_len);
1857
1858 uint i;
1859 uint j;
1860
1861 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1862 {
1863 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1864 }
1865
1866 memset (line_buf + i, 0, line_len - i);
1867
1868 return (i);
1869 }
1870
1871 return (line_len);
1872 }
1873
1874 static void clear_prompt ()
1875 {
1876 fputc ('\r', stdout);
1877
1878 for (size_t i = 0; i < strlen (PROMPT); i++)
1879 {
1880 fputc (' ', stdout);
1881 }
1882
1883 fputc ('\r', stdout);
1884
1885 fflush (stdout);
1886 }
1887
1888 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1889 {
1890 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);
1891 }
1892
1893 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1894 {
1895 char *outfile = data.outfile;
1896 uint quiet = data.quiet;
1897 FILE *pot_fp = data.pot_fp;
1898 uint loopback = data.loopback;
1899 uint debug_mode = data.debug_mode;
1900 char *debug_file = data.debug_file;
1901
1902 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1903 int debug_rule_len = 0; // -1 error
1904 uint debug_plain_len = 0;
1905
1906 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1907
1908 // hash
1909
1910 char out_buf[HCBUFSIZ] = { 0 };
1911
1912 const u32 salt_pos = plain->salt_pos;
1913 const u32 digest_pos = plain->digest_pos; // relative
1914 const u32 gidvid = plain->gidvid;
1915 const u32 il_pos = plain->il_pos;
1916
1917 ascii_digest (out_buf, salt_pos, digest_pos);
1918
1919 // plain
1920
1921 u64 crackpos = device_param->words_off;
1922
1923 uint plain_buf[16] = { 0 };
1924
1925 u8 *plain_ptr = (u8 *) plain_buf;
1926
1927 unsigned int plain_len = 0;
1928
1929 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1930 {
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidvid, &pw);
1934
1935 for (int i = 0; i < 16; i++)
1936 {
1937 plain_buf[i] = pw.i[i];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 const uint off = device_param->innerloop_pos + il_pos;
1943
1944 if (debug_mode > 0)
1945 {
1946 debug_rule_len = 0;
1947
1948 // save rule
1949 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1950 {
1951 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1952
1953 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1954 }
1955
1956 // save plain
1957 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1958 {
1959 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1960
1961 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1962
1963 debug_plain_len = plain_len;
1964 }
1965 }
1966
1967 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1968
1969 crackpos += gidvid;
1970 crackpos *= data.kernel_rules_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (plain_len > data.pw_max) plain_len = data.pw_max;
1974 }
1975 else if (data.attack_mode == ATTACK_MODE_COMBI)
1976 {
1977 pw_t pw;
1978
1979 gidd_to_pw_t (device_param, gidvid, &pw);
1980
1981 for (int i = 0; i < 16; i++)
1982 {
1983 plain_buf[i] = pw.i[i];
1984 }
1985
1986 plain_len = pw.pw_len;
1987
1988 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1989 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1990
1991 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1992 {
1993 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1994 }
1995 else
1996 {
1997 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1998
1999 memcpy (plain_ptr, comb_buf, comb_len);
2000 }
2001
2002 plain_len += comb_len;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.combs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007
2008 if (data.pw_max != PW_DICTMAX1)
2009 {
2010 if (plain_len > data.pw_max) plain_len = data.pw_max;
2011 }
2012 }
2013 else if (data.attack_mode == ATTACK_MODE_BF)
2014 {
2015 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2016 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2017
2018 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2019 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2020
2021 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2022 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2023
2024 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2025 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2026
2027 plain_len = data.css_cnt;
2028
2029 crackpos += gidvid;
2030 crackpos *= data.bfs_cnt;
2031 crackpos += device_param->innerloop_pos + il_pos;
2032 }
2033 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2034 {
2035 pw_t pw;
2036
2037 gidd_to_pw_t (device_param, gidvid, &pw);
2038
2039 for (int i = 0; i < 16; i++)
2040 {
2041 plain_buf[i] = pw.i[i];
2042 }
2043
2044 plain_len = pw.pw_len;
2045
2046 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2047
2048 uint start = 0;
2049 uint stop = device_param->kernel_params_mp_buf32[4];
2050
2051 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2052
2053 plain_len += start + stop;
2054
2055 crackpos += gidvid;
2056 crackpos *= data.combs_cnt;
2057 crackpos += device_param->innerloop_pos + il_pos;
2058
2059 if (data.pw_max != PW_DICTMAX1)
2060 {
2061 if (plain_len > data.pw_max) plain_len = data.pw_max;
2062 }
2063 }
2064 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2065 {
2066 pw_t pw;
2067
2068 gidd_to_pw_t (device_param, gidvid, &pw);
2069
2070 for (int i = 0; i < 16; i++)
2071 {
2072 plain_buf[i] = pw.i[i];
2073 }
2074
2075 plain_len = pw.pw_len;
2076
2077 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2078
2079 uint start = 0;
2080 uint stop = device_param->kernel_params_mp_buf32[4];
2081
2082 memmove (plain_ptr + stop, plain_ptr, plain_len);
2083
2084 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097
2098 if (data.attack_mode == ATTACK_MODE_BF)
2099 {
2100 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2101 {
2102 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2103 {
2104 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2105 {
2106 plain_len = plain_len - data.salts_buf[0].salt_len;
2107 }
2108 }
2109
2110 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2111 {
2112 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2113 {
2114 plain_ptr[j] = plain_ptr[i];
2115 }
2116
2117 plain_len = plain_len / 2;
2118 }
2119 }
2120 }
2121
2122 // if enabled, update also the potfile
2123
2124 if (pot_fp)
2125 {
2126 lock_file (pot_fp);
2127
2128 fprintf (pot_fp, "%s:", out_buf);
2129
2130 format_plain (pot_fp, plain_ptr, plain_len, 1);
2131
2132 fputc ('\n', pot_fp);
2133
2134 fflush (pot_fp);
2135
2136 unlock_file (pot_fp);
2137 }
2138
2139 // outfile
2140
2141 FILE *out_fp = NULL;
2142
2143 if (outfile != NULL)
2144 {
2145 if ((out_fp = fopen (outfile, "ab")) == NULL)
2146 {
2147 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2148
2149 out_fp = stdout;
2150 }
2151 lock_file (out_fp);
2152 }
2153 else
2154 {
2155 out_fp = stdout;
2156
2157 if (quiet == 0) clear_prompt ();
2158 }
2159
2160 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2161
2162 if (outfile != NULL)
2163 {
2164 if (out_fp != stdout)
2165 {
2166 fclose (out_fp);
2167 }
2168 }
2169 else
2170 {
2171 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2172 {
2173 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2174 {
2175 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2176 if (quiet == 0) fflush (stdout);
2177 }
2178 }
2179 }
2180
2181 // loopback
2182
2183 if (loopback)
2184 {
2185 char *loopback_file = data.loopback_file;
2186
2187 FILE *fb_fp = NULL;
2188
2189 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2190 {
2191 lock_file (fb_fp);
2192
2193 format_plain (fb_fp, plain_ptr, plain_len, 1);
2194
2195 fputc ('\n', fb_fp);
2196
2197 fclose (fb_fp);
2198 }
2199 }
2200
2201 // (rule) debug mode
2202
2203 // the next check implies that:
2204 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2205 // - debug_mode > 0
2206
2207 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2208 {
2209 if (debug_rule_len < 0) debug_rule_len = 0;
2210
2211 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2212
2213 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2214
2215 if ((quiet == 0) && (debug_file == NULL))
2216 {
2217 fprintf (stdout, "%s", PROMPT);
2218
2219 fflush (stdout);
2220 }
2221 }
2222 }
2223
2224 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2225 {
2226 salt_t *salt_buf = &data.salts_buf[salt_pos];
2227
2228 u32 num_cracked;
2229
2230 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2231
2232 if (num_cracked)
2233 {
2234 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2235
2236 log_info_nn ("");
2237
2238 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2239
2240 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);
2241
2242 uint cpt_cracked = 0;
2243
2244 for (uint i = 0; i < num_cracked; i++)
2245 {
2246 const uint hash_pos = cracked[i].hash_pos;
2247
2248 if (data.digests_shown[hash_pos] == 1) continue;
2249
2250 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2251 {
2252 data.digests_shown[hash_pos] = 1;
2253
2254 data.digests_done++;
2255
2256 cpt_cracked++;
2257
2258 salt_buf->digests_done++;
2259
2260 if (salt_buf->digests_done == salt_buf->digests_cnt)
2261 {
2262 data.salts_shown[salt_pos] = 1;
2263
2264 data.salts_done++;
2265 }
2266 }
2267
2268 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2269
2270 check_hash (device_param, &cracked[i]);
2271 }
2272
2273 myfree (cracked);
2274
2275 if (cpt_cracked > 0)
2276 {
2277 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2278 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2279
2280 data.cpt_pos++;
2281
2282 data.cpt_total += cpt_cracked;
2283
2284 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2285 }
2286
2287 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2288 {
2289 // we need to reset cracked state on the device
2290 // otherwise host thinks again and again the hash was cracked
2291 // and returns invalid password each time
2292
2293 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2294
2295 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);
2296 }
2297
2298 num_cracked = 0;
2299
2300 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2301 }
2302 }
2303
2304 static void save_hash ()
2305 {
2306 char *hashfile = data.hashfile;
2307
2308 char new_hashfile[256] = { 0 };
2309 char old_hashfile[256] = { 0 };
2310
2311 snprintf (new_hashfile, 255, "%s.new", hashfile);
2312 snprintf (old_hashfile, 255, "%s.old", hashfile);
2313
2314 unlink (new_hashfile);
2315
2316 char separator = data.separator;
2317
2318 FILE *fp = fopen (new_hashfile, "wb");
2319
2320 if (fp == NULL)
2321 {
2322 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2328 {
2329 if (data.salts_shown[salt_pos] == 1) continue;
2330
2331 salt_t *salt_buf = &data.salts_buf[salt_pos];
2332
2333 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2334 {
2335 uint idx = salt_buf->digests_offset + digest_pos;
2336
2337 if (data.digests_shown[idx] == 1) continue;
2338
2339 if (data.hash_mode != 2500)
2340 {
2341 char out_buf[HCBUFSIZ] = { 0 };
2342
2343 if (data.username == 1)
2344 {
2345 user_t *user = data.hash_info[idx]->user;
2346
2347 uint i;
2348
2349 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2350
2351 fputc (separator, fp);
2352 }
2353
2354 ascii_digest (out_buf, salt_pos, digest_pos);
2355
2356 fputs (out_buf, fp);
2357
2358 log_out (fp, "");
2359 }
2360 else
2361 {
2362 hccap_t hccap;
2363
2364 to_hccap_t (&hccap, salt_pos, digest_pos);
2365
2366 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2367 }
2368 }
2369 }
2370
2371 fflush (fp);
2372
2373 fclose (fp);
2374
2375 unlink (old_hashfile);
2376
2377 if (rename (hashfile, old_hashfile) != 0)
2378 {
2379 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2380
2381 exit (-1);
2382 }
2383
2384 unlink (hashfile);
2385
2386 if (rename (new_hashfile, hashfile) != 0)
2387 {
2388 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2389
2390 exit (-1);
2391 }
2392
2393 unlink (old_hashfile);
2394 }
2395
2396 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2397 {
2398 // function called only in case kernel_power_all > words_left
2399
2400 float kernel_power_div = (float) (total_left) / kernel_power_all;
2401
2402 kernel_power_div += kernel_power_div / 100;
2403
2404 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2405
2406 while (kernel_power_new < total_left)
2407 {
2408 kernel_power_div += kernel_power_div / 100;
2409
2410 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2411 }
2412
2413 if (data.quiet == 0)
2414 {
2415 clear_prompt ();
2416
2417 //log_info ("");
2418
2419 log_info ("INFO: approaching final keyspace, workload adjusted");
2420 log_info ("");
2421
2422 fprintf (stdout, "%s", PROMPT);
2423
2424 fflush (stdout);
2425 }
2426
2427 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2428
2429 return kernel_power_div;
2430 }
2431
2432 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2433 {
2434 uint num_elements = num;
2435
2436 device_param->kernel_params_buf32[30] = data.combs_mode;
2437 device_param->kernel_params_buf32[31] = num;
2438
2439 uint kernel_threads = device_param->kernel_threads;
2440
2441 while (num_elements % kernel_threads) num_elements++;
2442
2443 cl_kernel kernel = NULL;
2444
2445 switch (kern_run)
2446 {
2447 case KERN_RUN_1: kernel = device_param->kernel1; break;
2448 case KERN_RUN_12: kernel = device_param->kernel12; break;
2449 case KERN_RUN_2: kernel = device_param->kernel2; break;
2450 case KERN_RUN_23: kernel = device_param->kernel23; break;
2451 case KERN_RUN_3: kernel = device_param->kernel3; break;
2452 }
2453
2454 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2455 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2456 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2457 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2458 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2459 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2460 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2461 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2462 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2463 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2464 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2465
2466 cl_event event;
2467
2468 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2469 {
2470 const size_t global_work_size[3] = { num_elements, 32, 1 };
2471 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2472
2473 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2474 }
2475 else
2476 {
2477 if (kern_run == KERN_RUN_2)
2478 {
2479 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2480 {
2481 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2482 }
2483 }
2484
2485 while (num_elements % kernel_threads) num_elements++;
2486
2487 const size_t global_work_size[3] = { num_elements, 1, 1 };
2488 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2489
2490 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2491 }
2492
2493 hc_clFlush (data.ocl, device_param->command_queue);
2494
2495 hc_clWaitForEvents (data.ocl, 1, &event);
2496
2497 if (event_update)
2498 {
2499 cl_ulong time_start;
2500 cl_ulong time_end;
2501
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2503 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2504
2505 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2506
2507 uint exec_pos = device_param->exec_pos;
2508
2509 device_param->exec_ms[exec_pos] = exec_time;
2510
2511 exec_pos++;
2512
2513 if (exec_pos == EXEC_CACHE)
2514 {
2515 exec_pos = 0;
2516 }
2517
2518 device_param->exec_pos = exec_pos;
2519 }
2520
2521 hc_clReleaseEvent (data.ocl, event);
2522
2523 hc_clFinish (data.ocl, device_param->command_queue);
2524 }
2525
2526 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2527 {
2528 uint num_elements = num;
2529
2530 switch (kern_run)
2531 {
2532 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2533 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2534 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2535 }
2536
2537 // causes problems with special threads like in bcrypt
2538 // const uint kernel_threads = device_param->kernel_threads;
2539
2540 uint kernel_threads = device_param->kernel_threads;
2541
2542 while (num_elements % kernel_threads) num_elements++;
2543
2544 cl_kernel kernel = NULL;
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2549 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2550 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2551 }
2552
2553 switch (kern_run)
2554 {
2555 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2561 break;
2562 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2568 break;
2569 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2570 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2571 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2572 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2573 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2574 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2575 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2576 break;
2577 }
2578
2579 const size_t global_work_size[3] = { num_elements, 1, 1 };
2580 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2581
2582 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2583
2584 hc_clFlush (data.ocl, device_param->command_queue);
2585
2586 hc_clFinish (data.ocl, device_param->command_queue);
2587 }
2588
2589 static void run_kernel_tm (hc_device_param_t *device_param)
2590 {
2591 const uint num_elements = 1024; // fixed
2592
2593 uint kernel_threads = 32;
2594
2595 cl_kernel kernel = device_param->kernel_tm;
2596
2597 const size_t global_work_size[3] = { num_elements, 1, 1 };
2598 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2599
2600 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2601
2602 hc_clFlush (data.ocl, device_param->command_queue);
2603
2604 hc_clFinish (data.ocl, device_param->command_queue);
2605 }
2606
2607 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2608 {
2609 uint num_elements = num;
2610
2611 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2612 device_param->kernel_params_amp_buf32[6] = num_elements;
2613
2614 // causes problems with special threads like in bcrypt
2615 // const uint kernel_threads = device_param->kernel_threads;
2616
2617 uint kernel_threads = device_param->kernel_threads;
2618
2619 while (num_elements % kernel_threads) num_elements++;
2620
2621 cl_kernel kernel = device_param->kernel_amp;
2622
2623 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2624 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2625
2626 const size_t global_work_size[3] = { num_elements, 1, 1 };
2627 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2628
2629 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2630
2631 hc_clFlush (data.ocl, device_param->command_queue);
2632
2633 hc_clFinish (data.ocl, device_param->command_queue);
2634 }
2635
2636 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2637 {
2638 int rc = -1;
2639
2640 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2641 {
2642 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2643
2644 const cl_uchar zero = 0;
2645
2646 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2647 }
2648
2649 if (rc != 0)
2650 {
2651 // NOTE: clEnqueueFillBuffer () always fails with -59
2652 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2653 // How's that possible, OpenCL 1.2 support is advertised??
2654 // We need to workaround...
2655
2656 #define FILLSZ 0x100000
2657
2658 char *tmp = (char *) mymalloc (FILLSZ);
2659
2660 for (size_t i = 0; i < size; i += FILLSZ)
2661 {
2662 const size_t left = size - i;
2663
2664 const size_t fillsz = MIN (FILLSZ, left);
2665
2666 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2667 }
2668
2669 myfree (tmp);
2670 }
2671 }
2672
2673 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)
2674 {
2675 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2676 {
2677 if (attack_mode == ATTACK_MODE_BF)
2678 {
2679 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2680 {
2681 const uint size_tm = 32 * sizeof (bs_word_t);
2682
2683 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2684
2685 run_kernel_tm (device_param);
2686
2687 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);
2688 }
2689 }
2690
2691 if (highest_pw_len < 16)
2692 {
2693 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2694 }
2695 else if (highest_pw_len < 32)
2696 {
2697 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2698 }
2699 else
2700 {
2701 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2702 }
2703 }
2704 else
2705 {
2706 run_kernel_amp (device_param, pws_cnt);
2707
2708 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2709
2710 if (opts_type & OPTS_TYPE_HOOK12)
2711 {
2712 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2713 }
2714
2715 uint iter = salt_buf->salt_iter;
2716
2717 uint loop_step = device_param->kernel_loops;
2718
2719 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2720 {
2721 uint loop_left = iter - loop_pos;
2722
2723 loop_left = MIN (loop_left, loop_step);
2724
2725 device_param->kernel_params_buf32[25] = loop_pos;
2726 device_param->kernel_params_buf32[26] = loop_left;
2727
2728 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2729
2730 if (data.devices_status == STATUS_CRACKED) break;
2731 if (data.devices_status == STATUS_ABORTED) break;
2732 if (data.devices_status == STATUS_QUIT) break;
2733
2734 /**
2735 * speed
2736 */
2737
2738 const float iter_part = (float) (loop_pos + loop_left) / iter;
2739
2740 const u64 perf_sum_all = pws_cnt * iter_part;
2741
2742 double speed_ms;
2743
2744 hc_timer_get (device_param->timer_speed, speed_ms);
2745
2746 const u32 speed_pos = device_param->speed_pos;
2747
2748 device_param->speed_cnt[speed_pos] = perf_sum_all;
2749
2750 device_param->speed_ms[speed_pos] = speed_ms;
2751
2752 if (data.benchmark == 1)
2753 {
2754 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2755 }
2756 }
2757
2758 if (opts_type & OPTS_TYPE_HOOK23)
2759 {
2760 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2761
2762 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);
2763
2764 // do something with data
2765
2766 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);
2767 }
2768
2769 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2770 }
2771 }
2772
2773 static int run_rule_engine (const int rule_len, const char *rule_buf)
2774 {
2775 if (rule_len == 0)
2776 {
2777 return 0;
2778 }
2779 else if (rule_len == 1)
2780 {
2781 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2782 }
2783
2784 return 1;
2785 }
2786
2787 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2788 {
2789 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2790 {
2791 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);
2792 }
2793 else if (data.attack_kern == ATTACK_KERN_COMBI)
2794 {
2795 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2796 {
2797 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2798 {
2799 for (u32 i = 0; i < pws_cnt; i++)
2800 {
2801 const u32 pw_len = device_param->pws_buf[i].pw_len;
2802
2803 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2804
2805 ptr[pw_len] = 0x01;
2806 }
2807 }
2808 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2809 {
2810 for (u32 i = 0; i < pws_cnt; i++)
2811 {
2812 const u32 pw_len = device_param->pws_buf[i].pw_len;
2813
2814 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2815
2816 ptr[pw_len] = 0x80;
2817 }
2818 }
2819 }
2820
2821 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);
2822 }
2823 else if (data.attack_kern == ATTACK_KERN_BF)
2824 {
2825 const u64 off = device_param->words_off;
2826
2827 device_param->kernel_params_mp_l_buf64[3] = off;
2828
2829 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2830 }
2831 }
2832
2833 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2834 {
2835 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2836
2837 device_param->kernel_params_buf32[25] = 0;
2838 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2839 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2840
2841 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2842 {
2843 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2844 }
2845 else
2846 {
2847 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2848 }
2849
2850 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2851
2852 return exec_ms_prev;
2853 }
2854
2855 static void autotune (hc_device_param_t *device_param)
2856 {
2857 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2858
2859 const u32 kernel_accel_min = device_param->kernel_accel_min;
2860 const u32 kernel_accel_max = device_param->kernel_accel_max;
2861
2862 const u32 kernel_loops_min = device_param->kernel_loops_min;
2863 const u32 kernel_loops_max = device_param->kernel_loops_max;
2864
2865 u32 kernel_accel = kernel_accel_min;
2866 u32 kernel_loops = kernel_loops_min;
2867
2868 // init some fake words
2869
2870 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2871
2872 for (u32 i = 0; i < kernel_power_max; i++)
2873 {
2874 device_param->pws_buf[i].i[0] = i;
2875 device_param->pws_buf[i].i[1] = 0x01234567;
2876 device_param->pws_buf[i].pw_len = 7;
2877 }
2878
2879 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);
2880
2881 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2882 {
2883 run_kernel_amp (device_param, kernel_power_max);
2884 }
2885
2886 // begin actual testing
2887
2888 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2889
2890 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2891 {
2892 // we do this in case the user specified a fixed -u and -n on the commandline
2893 // so we have a cached kernel for benchmark
2894
2895 try_run (device_param, kernel_accel, kernel_loops);
2896 try_run (device_param, kernel_accel, kernel_loops);
2897 try_run (device_param, kernel_accel, kernel_loops);
2898 try_run (device_param, kernel_accel, kernel_loops);
2899 try_run (device_param, kernel_accel, kernel_loops);
2900 }
2901
2902 // first find out highest kernel-loops that stays below target_ms
2903
2904 #define STEPS_CNT 10
2905
2906 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2907 {
2908 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2909
2910 if (exec_ms < target_ms) break;
2911 }
2912
2913 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2914
2915 if (kernel_accel_min < kernel_accel_max)
2916 {
2917 for (int i = 0; i < STEPS_CNT; i++)
2918 {
2919 const u32 kernel_accel_try = 1 << i;
2920
2921 if (kernel_accel_try < kernel_accel_min) continue;
2922 if (kernel_accel_try > kernel_accel_max) break;
2923
2924 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2925
2926 if (exec_ms > target_ms) break;
2927
2928 exec_ms_final = exec_ms;
2929
2930 kernel_accel = kernel_accel_try;
2931 }
2932 }
2933
2934 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2935 // in such a case the above function would not create any change
2936 // we'll use the runtime to find out if we're allow to do last improvement
2937
2938 if (exec_ms_final > 0)
2939 {
2940 if ((exec_ms_final * 2) <= target_ms)
2941 {
2942 const double exec_left = target_ms / exec_ms_final;
2943
2944 const double accel_left = kernel_accel_max / kernel_accel;
2945
2946 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2947
2948 if (exec_accel_min >= 2)
2949 {
2950 kernel_accel *= exec_accel_min;
2951 }
2952 }
2953 }
2954
2955 // balancing the workload turns out to be very efficient
2956
2957 if (kernel_loops_min != kernel_loops_max)
2958 {
2959 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2960
2961 u32 sqrtv;
2962
2963 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2964 {
2965 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2966 }
2967
2968 const u32 kernel_accel_try = sqrtv;
2969 const u32 kernel_loops_try = sqrtv;
2970
2971 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2972 {
2973 kernel_accel = kernel_accel_try;
2974 kernel_loops = kernel_loops_try;
2975 }
2976 }
2977
2978 // reset fake words
2979
2980 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2981
2982 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);
2983 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);
2984
2985 // reset timer
2986
2987 device_param->exec_pos = 0;
2988
2989 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2990
2991 // store
2992
2993 device_param->kernel_accel = kernel_accel;
2994 device_param->kernel_loops = kernel_loops;
2995
2996 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2997
2998 device_param->kernel_power = kernel_power;
2999
3000 #ifdef DEBUG
3001
3002 if (data.quiet == 0)
3003 {
3004 clear_prompt ();
3005
3006 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3007 "Device #%u: autotuned kernel-loops to %u\n",
3008 device_param->device_id + 1, kernel_accel,
3009 device_param->device_id + 1, kernel_loops);
3010
3011 fprintf (stdout, "%s", PROMPT);
3012
3013 fflush (stdout);
3014 }
3015
3016 #endif
3017 }
3018
3019 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3020 {
3021 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3022
3023 // init speed timer
3024
3025 uint speed_pos = device_param->speed_pos;
3026
3027 #ifdef _POSIX
3028 if (device_param->timer_speed.tv_sec == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 #ifdef _WIN
3035 if (device_param->timer_speed.QuadPart == 0)
3036 {
3037 hc_timer_set (&device_param->timer_speed);
3038 }
3039 #endif
3040
3041 // find higest password length, this is for optimization stuff
3042
3043 uint highest_pw_len = 0;
3044
3045 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3046 {
3047 }
3048 else if (data.attack_kern == ATTACK_KERN_COMBI)
3049 {
3050 }
3051 else if (data.attack_kern == ATTACK_KERN_BF)
3052 {
3053 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3054 + device_param->kernel_params_mp_l_buf32[5];
3055 }
3056
3057 // iteration type
3058
3059 uint innerloop_step = 0;
3060 uint innerloop_cnt = 0;
3061
3062 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3063 else innerloop_step = 1;
3064
3065 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3066 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3067 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3068
3069 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3070
3071 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3072 {
3073 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3074
3075 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3076
3077 if (data.devices_status == STATUS_CRACKED) break;
3078 if (data.devices_status == STATUS_ABORTED) break;
3079 if (data.devices_status == STATUS_QUIT) break;
3080 if (data.devices_status == STATUS_BYPASS) break;
3081
3082 salt_t *salt_buf = &data.salts_buf[salt_pos];
3083
3084 device_param->kernel_params_buf32[24] = salt_pos;
3085 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3086 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3087
3088 FILE *combs_fp = device_param->combs_fp;
3089
3090 if (data.attack_mode == ATTACK_MODE_COMBI)
3091 {
3092 rewind (combs_fp);
3093 }
3094
3095 // innerloops
3096
3097 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3098 {
3099 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3100
3101 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3102
3103 if (data.devices_status == STATUS_CRACKED) break;
3104 if (data.devices_status == STATUS_ABORTED) break;
3105 if (data.devices_status == STATUS_QUIT) break;
3106 if (data.devices_status == STATUS_BYPASS) break;
3107
3108 uint innerloop_left = innerloop_cnt - innerloop_pos;
3109
3110 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3111
3112 device_param->innerloop_pos = innerloop_pos;
3113 device_param->innerloop_left = innerloop_left;
3114
3115 device_param->kernel_params_buf32[27] = innerloop_left;
3116
3117 // i think we can get rid of this
3118 if (innerloop_left == 0)
3119 {
3120 puts ("bug, how should this happen????\n");
3121
3122 continue;
3123 }
3124
3125 if (data.salts_shown[salt_pos] == 1)
3126 {
3127 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3128
3129 continue;
3130 }
3131
3132 // initialize amplifiers
3133
3134 if (data.attack_mode == ATTACK_MODE_COMBI)
3135 {
3136 uint i = 0;
3137
3138 while (i < innerloop_left)
3139 {
3140 if (feof (combs_fp)) break;
3141
3142 int line_len = fgetl (combs_fp, line_buf);
3143
3144 if (line_len >= PW_MAX1) continue;
3145
3146 line_len = convert_from_hex (line_buf, line_len);
3147
3148 char *line_buf_new = line_buf;
3149
3150 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3151 {
3152 char rule_buf_out[BLOCK_SIZE] = { 0 };
3153
3154 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3155
3156 if (rule_len_out < 0)
3157 {
3158 data.words_progress_rejected[salt_pos] += pws_cnt;
3159
3160 continue;
3161 }
3162
3163 line_len = rule_len_out;
3164
3165 line_buf_new = rule_buf_out;
3166 }
3167
3168 line_len = MIN (line_len, PW_DICTMAX);
3169
3170 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3171
3172 memcpy (ptr, line_buf_new, line_len);
3173
3174 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3175
3176 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3177 {
3178 uppercase (ptr, line_len);
3179 }
3180
3181 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3182 {
3183 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3184 {
3185 ptr[line_len] = 0x80;
3186 }
3187
3188 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3189 {
3190 ptr[line_len] = 0x01;
3191 }
3192 }
3193
3194 device_param->combs_buf[i].pw_len = line_len;
3195
3196 i++;
3197 }
3198
3199 for (uint j = i; j < innerloop_left; j++)
3200 {
3201 device_param->combs_buf[j].i[0] = 0;
3202 device_param->combs_buf[j].i[1] = 0;
3203 device_param->combs_buf[j].i[2] = 0;
3204 device_param->combs_buf[j].i[3] = 0;
3205 device_param->combs_buf[j].i[4] = 0;
3206 device_param->combs_buf[j].i[5] = 0;
3207 device_param->combs_buf[j].i[6] = 0;
3208 device_param->combs_buf[j].i[7] = 0;
3209
3210 device_param->combs_buf[j].pw_len = 0;
3211 }
3212
3213 innerloop_left = i;
3214 }
3215 else if (data.attack_mode == ATTACK_MODE_BF)
3216 {
3217 u64 off = innerloop_pos;
3218
3219 device_param->kernel_params_mp_r_buf64[3] = off;
3220
3221 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3222 }
3223 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3224 {
3225 u64 off = innerloop_pos;
3226
3227 device_param->kernel_params_mp_buf64[3] = off;
3228
3229 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3230 }
3231 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3232 {
3233 u64 off = innerloop_pos;
3234
3235 device_param->kernel_params_mp_buf64[3] = off;
3236
3237 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3238 }
3239
3240 // copy amplifiers
3241
3242 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3243 {
3244 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);
3245 }
3246 else if (data.attack_mode == ATTACK_MODE_COMBI)
3247 {
3248 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);
3249 }
3250 else if (data.attack_mode == ATTACK_MODE_BF)
3251 {
3252 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);
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3255 {
3256 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);
3257 }
3258 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3259 {
3260 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);
3261 }
3262
3263 if (data.benchmark == 1)
3264 {
3265 hc_timer_set (&device_param->timer_speed);
3266 }
3267
3268 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3269
3270 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3271
3272 if (data.devices_status == STATUS_CRACKED) break;
3273 if (data.devices_status == STATUS_ABORTED) break;
3274 if (data.devices_status == STATUS_QUIT) break;
3275
3276 /**
3277 * result
3278 */
3279
3280 hc_thread_mutex_lock (mux_display);
3281
3282 check_cracked (device_param, salt_pos);
3283
3284 hc_thread_mutex_unlock (mux_display);
3285
3286 /**
3287 * progress
3288 */
3289
3290 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3291
3292 hc_thread_mutex_lock (mux_counter);
3293
3294 data.words_progress_done[salt_pos] += perf_sum_all;
3295
3296 hc_thread_mutex_unlock (mux_counter);
3297
3298 /**
3299 * speed
3300 */
3301
3302 double speed_ms;
3303
3304 hc_timer_get (device_param->timer_speed, speed_ms);
3305
3306 hc_timer_set (&device_param->timer_speed);
3307
3308 hc_thread_mutex_lock (mux_display);
3309
3310 // current speed
3311
3312 device_param->speed_cnt[speed_pos] = perf_sum_all;
3313
3314 device_param->speed_ms[speed_pos] = speed_ms;
3315
3316 hc_thread_mutex_unlock (mux_display);
3317
3318 speed_pos++;
3319
3320 if (speed_pos == SPEED_CACHE)
3321 {
3322 speed_pos = 0;
3323 }
3324
3325 /**
3326 * benchmark
3327 */
3328
3329 if (data.benchmark == 1) break;
3330 }
3331 }
3332
3333 device_param->speed_pos = speed_pos;
3334
3335 myfree (line_buf);
3336 }
3337
3338 static void load_segment (wl_data_t *wl_data, FILE *fd)
3339 {
3340 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3341
3342 wl_data->pos = 0;
3343
3344 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3345
3346 wl_data->buf[wl_data->cnt] = 0;
3347
3348 if (wl_data->cnt == 0) return;
3349
3350 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3351
3352 while (!feof (fd))
3353 {
3354 if (wl_data->cnt == wl_data->avail)
3355 {
3356 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3357
3358 wl_data->avail += wl_data->incr;
3359 }
3360
3361 const int c = fgetc (fd);
3362
3363 if (c == EOF) break;
3364
3365 wl_data->buf[wl_data->cnt] = (char) c;
3366
3367 wl_data->cnt++;
3368
3369 if (c == '\n') break;
3370 }
3371
3372 // ensure stream ends with a newline
3373
3374 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3375 {
3376 wl_data->cnt++;
3377
3378 wl_data->buf[wl_data->cnt - 1] = '\n';
3379 }
3380
3381 return;
3382 }
3383
3384 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3385 {
3386 char *ptr = buf;
3387
3388 for (u32 i = 0; i < sz; i++, ptr++)
3389 {
3390 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3391
3392 if (i == 7)
3393 {
3394 *off = i;
3395 *len = i;
3396
3397 return;
3398 }
3399
3400 if (*ptr != '\n') continue;
3401
3402 *off = i + 1;
3403
3404 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3405
3406 *len = i;
3407
3408 return;
3409 }
3410
3411 *off = sz;
3412 *len = sz;
3413 }
3414
3415 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3416 {
3417 char *ptr = buf;
3418
3419 for (u32 i = 0; i < sz; i++, ptr++)
3420 {
3421 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3422
3423 if (*ptr != '\n') continue;
3424
3425 *off = i + 1;
3426
3427 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3428
3429 *len = i;
3430
3431 return;
3432 }
3433
3434 *off = sz;
3435 *len = sz;
3436 }
3437
3438 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3439 {
3440 char *ptr = buf;
3441
3442 for (u32 i = 0; i < sz; i++, ptr++)
3443 {
3444 if (*ptr != '\n') continue;
3445
3446 *off = i + 1;
3447
3448 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3449
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 *off = sz;
3456 *len = sz;
3457 }
3458
3459 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3460 {
3461 while (wl_data->pos < wl_data->cnt)
3462 {
3463 uint off;
3464 uint len;
3465
3466 char *ptr = wl_data->buf + wl_data->pos;
3467
3468 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3469
3470 wl_data->pos += off;
3471
3472 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3473 {
3474 char rule_buf_out[BLOCK_SIZE] = { 0 };
3475
3476 int rule_len_out = -1;
3477
3478 if (len < BLOCK_SIZE)
3479 {
3480 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3481 }
3482
3483 if (rule_len_out < 0)
3484 {
3485 continue;
3486 }
3487
3488 if (rule_len_out > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493 else
3494 {
3495 if (len > PW_MAX)
3496 {
3497 continue;
3498 }
3499 }
3500
3501 *out_buf = ptr;
3502 *out_len = len;
3503
3504 return;
3505 }
3506
3507 if (feof (fd))
3508 {
3509 fprintf (stderr, "BUG feof()!!\n");
3510
3511 return;
3512 }
3513
3514 load_segment (wl_data, fd);
3515
3516 get_next_word (wl_data, fd, out_buf, out_len);
3517 }
3518
3519 #ifdef _POSIX
3520 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3521 #endif
3522
3523 #ifdef _WIN
3524 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3525 #endif
3526 {
3527 hc_signal (NULL);
3528
3529 dictstat_t d;
3530
3531 d.cnt = 0;
3532
3533 #ifdef _POSIX
3534 fstat (fileno (fd), &d.stat);
3535 #endif
3536
3537 #ifdef _WIN
3538 _fstat64 (fileno (fd), &d.stat);
3539 #endif
3540
3541 d.stat.st_mode = 0;
3542 d.stat.st_nlink = 0;
3543 d.stat.st_uid = 0;
3544 d.stat.st_gid = 0;
3545 d.stat.st_rdev = 0;
3546 d.stat.st_atime = 0;
3547
3548 #ifdef _POSIX
3549 d.stat.st_blksize = 0;
3550 d.stat.st_blocks = 0;
3551 #endif
3552
3553 if (d.stat.st_size == 0) return 0;
3554
3555 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3556
3557 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3558 {
3559 if (d_cache)
3560 {
3561 u64 cnt = d_cache->cnt;
3562
3563 u64 keyspace = cnt;
3564
3565 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3566 {
3567 keyspace *= data.kernel_rules_cnt;
3568 }
3569 else if (data.attack_kern == ATTACK_KERN_COMBI)
3570 {
3571 keyspace *= data.combs_cnt;
3572 }
3573
3574 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);
3575 if (data.quiet == 0) log_info ("");
3576
3577 hc_signal (sigHandler_default);
3578
3579 return (keyspace);
3580 }
3581 }
3582
3583 time_t now = 0;
3584 time_t prev = 0;
3585
3586 u64 comp = 0;
3587 u64 cnt = 0;
3588 u64 cnt2 = 0;
3589
3590 while (!feof (fd))
3591 {
3592 load_segment (wl_data, fd);
3593
3594 comp += wl_data->cnt;
3595
3596 u32 i = 0;
3597
3598 while (i < wl_data->cnt)
3599 {
3600 u32 len;
3601 u32 off;
3602
3603 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3604
3605 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3606 {
3607 char rule_buf_out[BLOCK_SIZE] = { 0 };
3608
3609 int rule_len_out = -1;
3610
3611 if (len < BLOCK_SIZE)
3612 {
3613 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3614 }
3615
3616 if (rule_len_out < 0)
3617 {
3618 len = PW_MAX1;
3619 }
3620 else
3621 {
3622 len = rule_len_out;
3623 }
3624 }
3625
3626 if (len < PW_MAX1)
3627 {
3628 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3629 {
3630 cnt += data.kernel_rules_cnt;
3631 }
3632 else if (data.attack_kern == ATTACK_KERN_COMBI)
3633 {
3634 cnt += data.combs_cnt;
3635 }
3636
3637 d.cnt++;
3638 }
3639
3640 i += off;
3641
3642 cnt2++;
3643 }
3644
3645 time (&now);
3646
3647 if ((now - prev) == 0) continue;
3648
3649 float percent = (float) comp / (float) d.stat.st_size;
3650
3651 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);
3652
3653 time (&prev);
3654 }
3655
3656 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);
3657 if (data.quiet == 0) log_info ("");
3658
3659 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3660
3661 hc_signal (sigHandler_default);
3662
3663 return (cnt);
3664 }
3665
3666 static void *thread_monitor (void *p)
3667 {
3668 uint runtime_check = 0;
3669 uint remove_check = 0;
3670 uint status_check = 0;
3671 uint restore_check = 0;
3672
3673 uint restore_left = data.restore_timer;
3674 uint remove_left = data.remove_timer;
3675 uint status_left = data.status_timer;
3676
3677 #ifdef HAVE_HWMON
3678 uint hwmon_check = 0;
3679
3680 // these variables are mainly used for fan control (AMD only)
3681
3682 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3683
3684 // temperature controller "loopback" values
3685
3686 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3687 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3688
3689 #ifdef HAVE_ADL
3690 int temp_threshold = 1; // degrees celcius
3691
3692 int fan_speed_min = 15; // in percentage
3693 int fan_speed_max = 100;
3694 #endif // HAVE_ADL
3695
3696 time_t last_temp_check_time;
3697 #endif // HAVE_HWMON
3698
3699 uint sleep_time = 1;
3700
3701 if (data.runtime)
3702 {
3703 runtime_check = 1;
3704 }
3705
3706 if (data.restore_timer)
3707 {
3708 restore_check = 1;
3709 }
3710
3711 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3712 {
3713 remove_check = 1;
3714 }
3715
3716 if (data.status == 1)
3717 {
3718 status_check = 1;
3719 }
3720
3721 #ifdef HAVE_HWMON
3722 if (data.gpu_temp_disable == 0)
3723 {
3724 time (&last_temp_check_time);
3725
3726 hwmon_check = 1;
3727 }
3728 #endif
3729
3730 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3731 {
3732 #ifdef HAVE_HWMON
3733 if (hwmon_check == 0)
3734 #endif
3735 return (p);
3736 }
3737
3738 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3739 {
3740 hc_sleep (sleep_time);
3741
3742 if (data.devices_status != STATUS_RUNNING) continue;
3743
3744 #ifdef HAVE_HWMON
3745 if (hwmon_check == 1)
3746 {
3747 hc_thread_mutex_lock (mux_adl);
3748
3749 time_t temp_check_time;
3750
3751 time (&temp_check_time);
3752
3753 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3754
3755 if (Ta == 0) Ta = 1;
3756
3757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3758 {
3759 hc_device_param_t *device_param = &data.devices_param[device_id];
3760
3761 if (device_param->skipped) continue;
3762
3763 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3764
3765 const int temperature = hm_get_temperature_with_device_id (device_id);
3766
3767 if (temperature > (int) data.gpu_temp_abort)
3768 {
3769 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3770
3771 if (data.devices_status != STATUS_QUIT) myabort ();
3772
3773 break;
3774 }
3775
3776 #ifdef HAVE_ADL
3777 const int gpu_temp_retain = data.gpu_temp_retain;
3778
3779 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3780 {
3781 if (data.hm_device[device_id].fan_supported == 1)
3782 {
3783 int temp_cur = temperature;
3784
3785 int temp_diff_new = gpu_temp_retain - temp_cur;
3786
3787 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3788
3789 // calculate Ta value (time difference in seconds between the last check and this check)
3790
3791 last_temp_check_time = temp_check_time;
3792
3793 float Kp = 1.8;
3794 float Ki = 0.005;
3795 float Kd = 6;
3796
3797 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3798
3799 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);
3800
3801 if (abs (fan_diff_required) >= temp_threshold)
3802 {
3803 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3804
3805 int fan_speed_level = fan_speed_cur;
3806
3807 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3808
3809 int fan_speed_new = fan_speed_level - fan_diff_required;
3810
3811 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3812 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3813
3814 if (fan_speed_new != fan_speed_cur)
3815 {
3816 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3817 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3818
3819 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3820 {
3821 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3822
3823 fan_speed_chgd[device_id] = 1;
3824 }
3825
3826 temp_diff_old[device_id] = temp_diff_new;
3827 }
3828 }
3829 }
3830 }
3831 #endif // HAVE_ADL
3832 }
3833
3834 hc_thread_mutex_unlock (mux_adl);
3835 }
3836 #endif // HAVE_HWMON
3837
3838 if (restore_check == 1)
3839 {
3840 restore_left--;
3841
3842 if (restore_left == 0)
3843 {
3844 if (data.restore_disable == 0) cycle_restore ();
3845
3846 restore_left = data.restore_timer;
3847 }
3848 }
3849
3850 if ((runtime_check == 1) && (data.runtime_start > 0))
3851 {
3852 time_t runtime_cur;
3853
3854 time (&runtime_cur);
3855
3856 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3857
3858 if (runtime_left <= 0)
3859 {
3860 if (data.benchmark == 0)
3861 {
3862 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3863 }
3864
3865 if (data.devices_status != STATUS_QUIT) myabort ();
3866 }
3867 }
3868
3869 if (remove_check == 1)
3870 {
3871 remove_left--;
3872
3873 if (remove_left == 0)
3874 {
3875 if (data.digests_saved != data.digests_done)
3876 {
3877 data.digests_saved = data.digests_done;
3878
3879 save_hash ();
3880 }
3881
3882 remove_left = data.remove_timer;
3883 }
3884 }
3885
3886 if (status_check == 1)
3887 {
3888 status_left--;
3889
3890 if (status_left == 0)
3891 {
3892 hc_thread_mutex_lock (mux_display);
3893
3894 if (data.quiet == 0) clear_prompt ();
3895
3896 if (data.quiet == 0) log_info ("");
3897
3898 status_display ();
3899
3900 if (data.quiet == 0) log_info ("");
3901
3902 hc_thread_mutex_unlock (mux_display);
3903
3904 status_left = data.status_timer;
3905 }
3906 }
3907 }
3908
3909 #ifdef HAVE_HWMON
3910 myfree (fan_speed_chgd);
3911
3912 myfree (temp_diff_old);
3913 myfree (temp_diff_sum);
3914 #endif
3915
3916 p = NULL;
3917
3918 return (p);
3919 }
3920
3921 static void *thread_outfile_remove (void *p)
3922 {
3923 // some hash-dependent constants
3924 char *outfile_dir = data.outfile_check_directory;
3925 uint dgst_size = data.dgst_size;
3926 uint isSalted = data.isSalted;
3927 uint esalt_size = data.esalt_size;
3928 uint hash_mode = data.hash_mode;
3929
3930 uint outfile_check_timer = data.outfile_check_timer;
3931
3932 char separator = data.separator;
3933
3934 // some hash-dependent functions
3935 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3936 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3937
3938 // buffers
3939 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3940
3941 hash_buf.digest = mymalloc (dgst_size);
3942
3943 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3944
3945 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3946
3947 uint digest_buf[64] = { 0 };
3948
3949 outfile_data_t *out_info = NULL;
3950
3951 char **out_files = NULL;
3952
3953 time_t folder_mtime = 0;
3954
3955 int out_cnt = 0;
3956
3957 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3958
3959 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3960 {
3961 hc_sleep (1);
3962
3963 if (data.devices_status != STATUS_RUNNING) continue;
3964
3965 check_left--;
3966
3967 if (check_left == 0)
3968 {
3969 struct stat outfile_check_stat;
3970
3971 if (stat (outfile_dir, &outfile_check_stat) == 0)
3972 {
3973 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3974
3975 if (is_dir == 1)
3976 {
3977 if (outfile_check_stat.st_mtime > folder_mtime)
3978 {
3979 char **out_files_new = scan_directory (outfile_dir);
3980
3981 int out_cnt_new = count_dictionaries (out_files_new);
3982
3983 outfile_data_t *out_info_new = NULL;
3984
3985 if (out_cnt_new > 0)
3986 {
3987 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3988
3989 for (int i = 0; i < out_cnt_new; i++)
3990 {
3991 out_info_new[i].file_name = out_files_new[i];
3992
3993 // check if there are files that we have seen/checked before (and not changed)
3994
3995 for (int j = 0; j < out_cnt; j++)
3996 {
3997 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3998 {
3999 struct stat outfile_stat;
4000
4001 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4002 {
4003 if (outfile_stat.st_ctime == out_info[j].ctime)
4004 {
4005 out_info_new[i].ctime = out_info[j].ctime;
4006 out_info_new[i].seek = out_info[j].seek;
4007 }
4008 }
4009 }
4010 }
4011 }
4012 }
4013
4014 local_free (out_info);
4015 local_free (out_files);
4016
4017 out_files = out_files_new;
4018 out_cnt = out_cnt_new;
4019 out_info = out_info_new;
4020
4021 folder_mtime = outfile_check_stat.st_mtime;
4022 }
4023
4024 for (int j = 0; j < out_cnt; j++)
4025 {
4026 FILE *fp = fopen (out_info[j].file_name, "rb");
4027
4028 if (fp != NULL)
4029 {
4030 //hc_thread_mutex_lock (mux_display);
4031
4032 #ifdef _POSIX
4033 struct stat outfile_stat;
4034
4035 fstat (fileno (fp), &outfile_stat);
4036 #endif
4037
4038 #ifdef _WIN
4039 struct stat64 outfile_stat;
4040
4041 _fstat64 (fileno (fp), &outfile_stat);
4042 #endif
4043
4044 if (outfile_stat.st_ctime > out_info[j].ctime)
4045 {
4046 out_info[j].ctime = outfile_stat.st_ctime;
4047 out_info[j].seek = 0;
4048 }
4049
4050 fseek (fp, out_info[j].seek, SEEK_SET);
4051
4052 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4053
4054 while (!feof (fp))
4055 {
4056 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4057
4058 if (ptr == NULL) break;
4059
4060 int line_len = strlen (line_buf);
4061
4062 if (line_len <= 0) continue;
4063
4064 int iter = MAX_CUT_TRIES;
4065
4066 for (uint i = line_len - 1; i && iter; i--, line_len--)
4067 {
4068 if (line_buf[i] != separator) continue;
4069
4070 int parser_status = PARSER_OK;
4071
4072 if ((hash_mode != 2500) && (hash_mode != 6800))
4073 {
4074 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4075 }
4076
4077 uint found = 0;
4078
4079 if (parser_status == PARSER_OK)
4080 {
4081 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4082 {
4083 if (data.salts_shown[salt_pos] == 1) continue;
4084
4085 salt_t *salt_buf = &data.salts_buf[salt_pos];
4086
4087 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4088 {
4089 uint idx = salt_buf->digests_offset + digest_pos;
4090
4091 if (data.digests_shown[idx] == 1) continue;
4092
4093 uint cracked = 0;
4094
4095 if (hash_mode == 6800)
4096 {
4097 if (i == salt_buf->salt_len)
4098 {
4099 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4100 }
4101 }
4102 else if (hash_mode == 2500)
4103 {
4104 // BSSID : MAC1 : MAC2 (:plain)
4105 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4106 {
4107 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4108
4109 if (!cracked) continue;
4110
4111 // now compare MAC1 and MAC2 too, since we have this additional info
4112 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4113 char *mac2_pos = mac1_pos + 12 + 1;
4114
4115 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4116 wpa_t *wpa = &wpas[salt_pos];
4117
4118 // compare hex string(s) vs binary MAC address(es)
4119
4120 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4121 {
4122 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4123 {
4124 cracked = 0;
4125
4126 break;
4127 }
4128 }
4129
4130 // early skip ;)
4131 if (!cracked) continue;
4132
4133 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4134 {
4135 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4136 {
4137 cracked = 0;
4138
4139 break;
4140 }
4141 }
4142 }
4143 }
4144 else
4145 {
4146 char *digests_buf_ptr = (char *) data.digests_buf;
4147
4148 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4149
4150 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4151 }
4152
4153 if (cracked == 1)
4154 {
4155 found = 1;
4156
4157 data.digests_shown[idx] = 1;
4158
4159 data.digests_done++;
4160
4161 salt_buf->digests_done++;
4162
4163 if (salt_buf->digests_done == salt_buf->digests_cnt)
4164 {
4165 data.salts_shown[salt_pos] = 1;
4166
4167 data.salts_done++;
4168
4169 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4170 }
4171 }
4172 }
4173
4174 if (data.devices_status == STATUS_CRACKED) break;
4175 }
4176 }
4177
4178 if (found) break;
4179
4180 if (data.devices_status == STATUS_CRACKED) break;
4181
4182 iter--;
4183 }
4184
4185 if (data.devices_status == STATUS_CRACKED) break;
4186 }
4187
4188 myfree (line_buf);
4189
4190 out_info[j].seek = ftell (fp);
4191
4192 //hc_thread_mutex_unlock (mux_display);
4193
4194 fclose (fp);
4195 }
4196 }
4197 }
4198 }
4199
4200 check_left = outfile_check_timer;
4201 }
4202 }
4203
4204 if (esalt_size) local_free (hash_buf.esalt);
4205
4206 if (isSalted) local_free (hash_buf.salt);
4207
4208 local_free (hash_buf.digest);
4209
4210 local_free (out_info);
4211
4212 local_free (out_files);
4213
4214 p = NULL;
4215
4216 return (p);
4217 }
4218
4219 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4220 {
4221 if (device_param->pws_cnt < device_param->kernel_power)
4222 {
4223 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4224
4225 u8 *ptr = (u8 *) pw->i;
4226
4227 memcpy (ptr, pw_buf, pw_len);
4228
4229 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4230
4231 pw->pw_len = pw_len;
4232
4233 device_param->pws_cnt++;
4234 }
4235 else
4236 {
4237 fprintf (stderr, "BUG pw_add()!!\n");
4238
4239 return;
4240 }
4241 }
4242
4243 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4244 {
4245 hc_thread_mutex_lock (mux_dispatcher);
4246
4247 const u64 words_cur = data.words_cur;
4248 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4249
4250 device_param->words_off = words_cur;
4251
4252 const u64 words_left = words_base - words_cur;
4253
4254 if (allow_div)
4255 {
4256 if (data.kernel_power_all > words_left)
4257 {
4258 if (data.kernel_power_div == 0)
4259 {
4260 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4261 }
4262 }
4263
4264 if (data.kernel_power_div)
4265 {
4266 if (device_param->kernel_power == device_param->kernel_power_user)
4267 {
4268 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4269
4270 if (kernel_power_new < device_param->kernel_power)
4271 {
4272 device_param->kernel_power = kernel_power_new;
4273 }
4274 }
4275 }
4276 }
4277
4278 const uint kernel_power = device_param->kernel_power;
4279
4280 uint work = MIN (words_left, kernel_power);
4281
4282 work = MIN (work, max);
4283
4284 data.words_cur += work;
4285
4286 hc_thread_mutex_unlock (mux_dispatcher);
4287
4288 return work;
4289 }
4290
4291 static void *thread_calc_stdin (void *p)
4292 {
4293 hc_device_param_t *device_param = (hc_device_param_t *) p;
4294
4295 if (device_param->skipped) return NULL;
4296
4297 autotune (device_param);
4298
4299 char *buf = (char *) mymalloc (HCBUFSIZ);
4300
4301 const uint attack_kern = data.attack_kern;
4302
4303 const uint kernel_power = device_param->kernel_power;
4304
4305 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4306 {
4307 hc_thread_mutex_lock (mux_dispatcher);
4308
4309 if (feof (stdin) != 0)
4310 {
4311 hc_thread_mutex_unlock (mux_dispatcher);
4312
4313 break;
4314 }
4315
4316 uint words_cur = 0;
4317
4318 while (words_cur < kernel_power)
4319 {
4320 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4321
4322 if (line_buf == NULL) break;
4323
4324 uint line_len = in_superchop (line_buf);
4325
4326 line_len = convert_from_hex (line_buf, line_len);
4327
4328 // post-process rule engine
4329
4330 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4331 {
4332 char rule_buf_out[BLOCK_SIZE] = { 0 };
4333
4334 int rule_len_out = -1;
4335
4336 if (line_len < BLOCK_SIZE)
4337 {
4338 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4339 }
4340
4341 if (rule_len_out < 0) continue;
4342
4343 line_buf = rule_buf_out;
4344 line_len = rule_len_out;
4345 }
4346
4347 if (line_len > PW_MAX)
4348 {
4349 continue;
4350 }
4351
4352 if (attack_kern == ATTACK_KERN_STRAIGHT)
4353 {
4354 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4355 {
4356 hc_thread_mutex_lock (mux_counter);
4357
4358 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4359 {
4360 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4361 }
4362
4363 hc_thread_mutex_unlock (mux_counter);
4364
4365 continue;
4366 }
4367 }
4368 else if (attack_kern == ATTACK_KERN_COMBI)
4369 {
4370 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4371 // since we still need to combine the plains
4372
4373 if (line_len > data.pw_max)
4374 {
4375 hc_thread_mutex_lock (mux_counter);
4376
4377 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4378 {
4379 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4380 }
4381
4382 hc_thread_mutex_unlock (mux_counter);
4383
4384 continue;
4385 }
4386 }
4387
4388 pw_add (device_param, (u8 *) line_buf, line_len);
4389
4390 words_cur++;
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396 }
4397
4398 hc_thread_mutex_unlock (mux_dispatcher);
4399
4400 if (data.devices_status == STATUS_CRACKED) break;
4401 if (data.devices_status == STATUS_ABORTED) break;
4402 if (data.devices_status == STATUS_QUIT) break;
4403 if (data.devices_status == STATUS_BYPASS) break;
4404
4405 // flush
4406
4407 const uint pws_cnt = device_param->pws_cnt;
4408
4409 if (pws_cnt)
4410 {
4411 run_copy (device_param, pws_cnt);
4412
4413 run_cracker (device_param, pws_cnt);
4414
4415 device_param->pws_cnt = 0;
4416
4417 /*
4418 still required?
4419 if (attack_kern == ATTACK_KERN_STRAIGHT)
4420 {
4421 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4422 }
4423 else if (attack_kern == ATTACK_KERN_COMBI)
4424 {
4425 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4426 }
4427 */
4428 }
4429 }
4430
4431 device_param->kernel_accel = 0;
4432 device_param->kernel_loops = 0;
4433
4434 myfree (buf);
4435
4436 return NULL;
4437 }
4438
4439 static void *thread_calc (void *p)
4440 {
4441 hc_device_param_t *device_param = (hc_device_param_t *) p;
4442
4443 if (device_param->skipped) return NULL;
4444
4445 autotune (device_param);
4446
4447 const uint attack_mode = data.attack_mode;
4448 const uint attack_kern = data.attack_kern;
4449
4450 if (attack_mode == ATTACK_MODE_BF)
4451 {
4452 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4453 {
4454 const uint work = get_work (device_param, -1, true);
4455
4456 if (work == 0) break;
4457
4458 const u64 words_off = device_param->words_off;
4459 const u64 words_fin = words_off + work;
4460
4461 const uint pws_cnt = work;
4462
4463 device_param->pws_cnt = pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pws_cnt);
4470
4471 device_param->pws_cnt = 0;
4472
4473 /*
4474 still required?
4475 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4476 */
4477 }
4478
4479 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4480
4481 if (data.devices_status == STATUS_CRACKED) break;
4482 if (data.devices_status == STATUS_ABORTED) break;
4483 if (data.devices_status == STATUS_QUIT) break;
4484 if (data.devices_status == STATUS_BYPASS) break;
4485
4486 if (data.benchmark == 1) break;
4487
4488 device_param->words_done = words_fin;
4489 }
4490 }
4491 else
4492 {
4493 const uint segment_size = data.segment_size;
4494
4495 char *dictfile = data.dictfile;
4496
4497 if (attack_mode == ATTACK_MODE_COMBI)
4498 {
4499 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4500 {
4501 dictfile = data.dictfile2;
4502 }
4503 }
4504
4505 FILE *fd = fopen (dictfile, "rb");
4506
4507 if (fd == NULL)
4508 {
4509 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4510
4511 return NULL;
4512 }
4513
4514 if (attack_mode == ATTACK_MODE_COMBI)
4515 {
4516 const uint combs_mode = data.combs_mode;
4517
4518 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4519 {
4520 const char *dictfilec = data.dictfile2;
4521
4522 FILE *combs_fp = fopen (dictfilec, "rb");
4523
4524 if (combs_fp == NULL)
4525 {
4526 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4527
4528 fclose (fd);
4529
4530 return NULL;
4531 }
4532
4533 device_param->combs_fp = combs_fp;
4534 }
4535 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4536 {
4537 const char *dictfilec = data.dictfile;
4538
4539 FILE *combs_fp = fopen (dictfilec, "rb");
4540
4541 if (combs_fp == NULL)
4542 {
4543 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4544
4545 fclose (fd);
4546
4547 return NULL;
4548 }
4549
4550 device_param->combs_fp = combs_fp;
4551 }
4552 }
4553
4554 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4555
4556 wl_data->buf = (char *) mymalloc (segment_size);
4557 wl_data->avail = segment_size;
4558 wl_data->incr = segment_size;
4559 wl_data->cnt = 0;
4560 wl_data->pos = 0;
4561
4562 u64 words_cur = 0;
4563
4564 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4565 {
4566 u64 words_off = 0;
4567 u64 words_fin = 0;
4568
4569 bool allow_div = true;
4570
4571 u64 max = -1;
4572
4573 while (max)
4574 {
4575 const uint work = get_work (device_param, max, allow_div);
4576
4577 allow_div = false;
4578
4579 if (work == 0) break;
4580
4581 words_off = device_param->words_off;
4582 words_fin = words_off + work;
4583
4584 char *line_buf;
4585 uint line_len;
4586
4587 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4588
4589 max = 0;
4590
4591 for ( ; words_cur < words_fin; words_cur++)
4592 {
4593 get_next_word (wl_data, fd, &line_buf, &line_len);
4594
4595 line_len = convert_from_hex (line_buf, line_len);
4596
4597 // post-process rule engine
4598
4599 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4600 {
4601 char rule_buf_out[BLOCK_SIZE] = { 0 };
4602
4603 int rule_len_out = -1;
4604
4605 if (line_len < BLOCK_SIZE)
4606 {
4607 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4608 }
4609
4610 if (rule_len_out < 0) continue;
4611
4612 line_buf = rule_buf_out;
4613 line_len = rule_len_out;
4614 }
4615
4616 if (attack_kern == ATTACK_KERN_STRAIGHT)
4617 {
4618 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4619 {
4620 max++;
4621
4622 hc_thread_mutex_lock (mux_counter);
4623
4624 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4625 {
4626 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4627 }
4628
4629 hc_thread_mutex_unlock (mux_counter);
4630
4631 continue;
4632 }
4633 }
4634 else if (attack_kern == ATTACK_KERN_COMBI)
4635 {
4636 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4637 // since we still need to combine the plains
4638
4639 if (line_len > data.pw_max)
4640 {
4641 max++;
4642
4643 hc_thread_mutex_lock (mux_counter);
4644
4645 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4646 {
4647 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4648 }
4649
4650 hc_thread_mutex_unlock (mux_counter);
4651
4652 continue;
4653 }
4654 }
4655
4656 pw_add (device_param, (u8 *) line_buf, line_len);
4657
4658 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4659
4660 if (data.devices_status == STATUS_CRACKED) break;
4661 if (data.devices_status == STATUS_ABORTED) break;
4662 if (data.devices_status == STATUS_QUIT) break;
4663 if (data.devices_status == STATUS_BYPASS) break;
4664 }
4665
4666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4667
4668 if (data.devices_status == STATUS_CRACKED) break;
4669 if (data.devices_status == STATUS_ABORTED) break;
4670 if (data.devices_status == STATUS_QUIT) break;
4671 if (data.devices_status == STATUS_BYPASS) break;
4672 }
4673
4674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677 if (data.devices_status == STATUS_ABORTED) break;
4678 if (data.devices_status == STATUS_QUIT) break;
4679 if (data.devices_status == STATUS_BYPASS) break;
4680
4681 //
4682 // flush
4683 //
4684
4685 const uint pws_cnt = device_param->pws_cnt;
4686
4687 if (pws_cnt)
4688 {
4689 run_copy (device_param, pws_cnt);
4690
4691 run_cracker (device_param, pws_cnt);
4692
4693 device_param->pws_cnt = 0;
4694
4695 /*
4696 still required?
4697 if (attack_kern == ATTACK_KERN_STRAIGHT)
4698 {
4699 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4700 }
4701 else if (attack_kern == ATTACK_KERN_COMBI)
4702 {
4703 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4704 }
4705 */
4706 }
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714
4715 if (words_fin == 0) break;
4716
4717 device_param->words_done = words_fin;
4718 }
4719
4720 if (attack_mode == ATTACK_MODE_COMBI)
4721 {
4722 fclose (device_param->combs_fp);
4723 }
4724
4725 free (wl_data->buf);
4726 free (wl_data);
4727
4728 fclose (fd);
4729 }
4730
4731 device_param->kernel_accel = 0;
4732 device_param->kernel_loops = 0;
4733
4734 return NULL;
4735 }
4736
4737 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4738 {
4739 if (!device_param)
4740 {
4741 log_error ("ERROR: %s : Invalid argument", __func__);
4742
4743 exit (-1);
4744 }
4745
4746 salt_t *salt_buf = &data.salts_buf[salt_pos];
4747
4748 device_param->kernel_params_buf32[24] = salt_pos;
4749 device_param->kernel_params_buf32[27] = 1;
4750 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4751 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4752 device_param->kernel_params_buf32[30] = 0;
4753 device_param->kernel_params_buf32[31] = 1;
4754
4755 char *dictfile_old = data.dictfile;
4756
4757 const char *weak_hash_check = "weak-hash-check";
4758
4759 data.dictfile = (char *) weak_hash_check;
4760
4761 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4762
4763 data.kernel_rules_buf[0].cmds[0] = 0;
4764
4765 /**
4766 * run the kernel
4767 */
4768
4769 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4770 {
4771 run_kernel (KERN_RUN_1, device_param, 1, false);
4772 }
4773 else
4774 {
4775 run_kernel (KERN_RUN_1, device_param, 1, false);
4776
4777 uint loop_step = 16;
4778
4779 const uint iter = salt_buf->salt_iter;
4780
4781 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4782 {
4783 uint loop_left = iter - loop_pos;
4784
4785 loop_left = MIN (loop_left, loop_step);
4786
4787 device_param->kernel_params_buf32[25] = loop_pos;
4788 device_param->kernel_params_buf32[26] = loop_left;
4789
4790 run_kernel (KERN_RUN_2, device_param, 1, false);
4791 }
4792
4793 run_kernel (KERN_RUN_3, device_param, 1, false);
4794 }
4795
4796 /**
4797 * result
4798 */
4799
4800 check_cracked (device_param, salt_pos);
4801
4802 /**
4803 * cleanup
4804 */
4805
4806 device_param->kernel_params_buf32[24] = 0;
4807 device_param->kernel_params_buf32[25] = 0;
4808 device_param->kernel_params_buf32[26] = 0;
4809 device_param->kernel_params_buf32[27] = 0;
4810 device_param->kernel_params_buf32[28] = 0;
4811 device_param->kernel_params_buf32[29] = 0;
4812 device_param->kernel_params_buf32[30] = 0;
4813 device_param->kernel_params_buf32[31] = 0;
4814
4815 data.dictfile = dictfile_old;
4816
4817 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4818 }
4819
4820 // hlfmt hashcat
4821
4822 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4823 {
4824 if (data.username == 0)
4825 {
4826 *hashbuf_pos = line_buf;
4827 *hashbuf_len = line_len;
4828 }
4829 else
4830 {
4831 char *pos = line_buf;
4832 int len = line_len;
4833
4834 for (int i = 0; i < line_len; i++, pos++, len--)
4835 {
4836 if (line_buf[i] == data.separator)
4837 {
4838 pos++;
4839
4840 len--;
4841
4842 break;
4843 }
4844 }
4845
4846 *hashbuf_pos = pos;
4847 *hashbuf_len = len;
4848 }
4849 }
4850
4851 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4852 {
4853 char *pos = NULL;
4854 int len = 0;
4855
4856 int sep_cnt = 0;
4857
4858 for (int i = 0; i < line_len; i++)
4859 {
4860 if (line_buf[i] == data.separator)
4861 {
4862 sep_cnt++;
4863
4864 continue;
4865 }
4866
4867 if (sep_cnt == 0)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874
4875 *userbuf_pos = pos;
4876 *userbuf_len = len;
4877 }
4878
4879 // hlfmt pwdump
4880
4881 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4882 {
4883 int sep_cnt = 0;
4884
4885 int sep2_len = 0;
4886 int sep3_len = 0;
4887
4888 for (int i = 0; i < line_len; i++)
4889 {
4890 if (line_buf[i] == ':')
4891 {
4892 sep_cnt++;
4893
4894 continue;
4895 }
4896
4897 if (sep_cnt == 2) sep2_len++;
4898 if (sep_cnt == 3) sep3_len++;
4899 }
4900
4901 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4902
4903 return 0;
4904 }
4905
4906 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4907 {
4908 char *pos = NULL;
4909 int len = 0;
4910
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':')
4916 {
4917 sep_cnt++;
4918
4919 continue;
4920 }
4921
4922 if (data.hash_mode == 1000)
4923 {
4924 if (sep_cnt == 3)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931 else if (data.hash_mode == 3000)
4932 {
4933 if (sep_cnt == 2)
4934 {
4935 if (pos == NULL) pos = line_buf + i;
4936
4937 len++;
4938 }
4939 }
4940 }
4941
4942 *hashbuf_pos = pos;
4943 *hashbuf_len = len;
4944 }
4945
4946 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4947 {
4948 char *pos = NULL;
4949 int len = 0;
4950
4951 int sep_cnt = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (sep_cnt == 0)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969
4970 *userbuf_pos = pos;
4971 *userbuf_len = len;
4972 }
4973
4974 // hlfmt passwd
4975
4976 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4977 {
4978 int sep_cnt = 0;
4979
4980 char sep5_first = 0;
4981 char sep6_first = 0;
4982
4983 for (int i = 0; i < line_len; i++)
4984 {
4985 if (line_buf[i] == ':')
4986 {
4987 sep_cnt++;
4988
4989 continue;
4990 }
4991
4992 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4993 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4994 }
4995
4996 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4997
4998 return 0;
4999 }
5000
5001 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5002 {
5003 char *pos = NULL;
5004 int len = 0;
5005
5006 int sep_cnt = 0;
5007
5008 for (int i = 0; i < line_len; i++)
5009 {
5010 if (line_buf[i] == ':')
5011 {
5012 sep_cnt++;
5013
5014 continue;
5015 }
5016
5017 if (sep_cnt == 1)
5018 {
5019 if (pos == NULL) pos = line_buf + i;
5020
5021 len++;
5022 }
5023 }
5024
5025 *hashbuf_pos = pos;
5026 *hashbuf_len = len;
5027 }
5028
5029 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5030 {
5031 char *pos = NULL;
5032 int len = 0;
5033
5034 int sep_cnt = 0;
5035
5036 for (int i = 0; i < line_len; i++)
5037 {
5038 if (line_buf[i] == ':')
5039 {
5040 sep_cnt++;
5041
5042 continue;
5043 }
5044
5045 if (sep_cnt == 0)
5046 {
5047 if (pos == NULL) pos = line_buf + i;
5048
5049 len++;
5050 }
5051 }
5052
5053 *userbuf_pos = pos;
5054 *userbuf_len = len;
5055 }
5056
5057 // hlfmt shadow
5058
5059 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5060 {
5061 int sep_cnt = 0;
5062
5063 for (int i = 0; i < line_len; i++)
5064 {
5065 if (line_buf[i] == ':') sep_cnt++;
5066 }
5067
5068 if (sep_cnt == 8) return 1;
5069
5070 return 0;
5071 }
5072
5073 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5074 {
5075 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5076 }
5077
5078 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5079 {
5080 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5081 }
5082
5083 // hlfmt main
5084
5085 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5086 {
5087 switch (hashfile_format)
5088 {
5089 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5090 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5091 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5092 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5093 }
5094 }
5095
5096 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5097 {
5098 switch (hashfile_format)
5099 {
5100 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5101 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5102 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5103 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5104 }
5105 }
5106
5107 char *strhlfmt (const uint hashfile_format)
5108 {
5109 switch (hashfile_format)
5110 {
5111 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5112 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5113 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5114 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5115 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5116 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5117 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5118 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5119 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5120 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5121 }
5122
5123 return ((char *) "Unknown");
5124 }
5125
5126 static uint hlfmt_detect (FILE *fp, uint max_check)
5127 {
5128 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5129
5130 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5131 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5132
5133 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5134
5135 uint num_check = 0;
5136
5137 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5138
5139 while (!feof (fp))
5140 {
5141 int line_len = fgetl (fp, line_buf);
5142
5143 if (line_len == 0) continue;
5144
5145 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5146 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5147 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5148
5149 if (num_check == max_check) break;
5150
5151 num_check++;
5152 }
5153
5154 myfree (line_buf);
5155
5156 uint hashlist_format = HLFMT_HASHCAT;
5157
5158 for (int i = 1; i < HLFMTS_CNT; i++)
5159 {
5160 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5161
5162 hashlist_format = i;
5163 }
5164
5165 free (formats_cnt);
5166
5167 return hashlist_format;
5168 }
5169
5170 /**
5171 * some further helper function
5172 */
5173
5174 // wrapper around mymalloc for ADL
5175
5176 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5177 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5178 {
5179 return mymalloc (iSize);
5180 }
5181 #endif
5182
5183 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)
5184 {
5185 u64 collisions = 0;
5186
5187 const uint dgst_pos0 = data.dgst_pos0;
5188 const uint dgst_pos1 = data.dgst_pos1;
5189 const uint dgst_pos2 = data.dgst_pos2;
5190 const uint dgst_pos3 = data.dgst_pos3;
5191
5192 memset (bitmap_a, 0, bitmap_size);
5193 memset (bitmap_b, 0, bitmap_size);
5194 memset (bitmap_c, 0, bitmap_size);
5195 memset (bitmap_d, 0, bitmap_size);
5196
5197 for (uint i = 0; i < digests_cnt; i++)
5198 {
5199 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5200
5201 uint *digest_ptr = (uint *) digests_buf_ptr;
5202
5203 digests_buf_ptr += dgst_size;
5204
5205 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5206 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5207 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5208 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5209
5210 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5211 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5212 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5213 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5214
5215 if (bitmap_a[idx0] & val0) collisions++;
5216 if (bitmap_b[idx1] & val1) collisions++;
5217 if (bitmap_c[idx2] & val2) collisions++;
5218 if (bitmap_d[idx3] & val3) collisions++;
5219
5220 bitmap_a[idx0] |= val0;
5221 bitmap_b[idx1] |= val1;
5222 bitmap_c[idx2] |= val2;
5223 bitmap_d[idx3] |= val3;
5224
5225 if (collisions >= collisions_max) return 0x7fffffff;
5226 }
5227
5228 return collisions;
5229 }
5230
5231 /**
5232 * main
5233 */
5234
5235 int main (int argc, char **argv)
5236 {
5237 /**
5238 * To help users a bit
5239 */
5240
5241 char *compute = getenv ("COMPUTE");
5242
5243 if (compute)
5244 {
5245 static char display[100];
5246
5247 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5248
5249 putenv (display);
5250 }
5251 else
5252 {
5253 if (getenv ("DISPLAY") == NULL)
5254 putenv ((char *) "DISPLAY=:0");
5255 }
5256
5257 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5258 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5259
5260 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5261 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5262
5263 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5264 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5265
5266 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5267 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5268
5269 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5270 putenv ((char *) "POCL_KERNEL_CACHE=0");
5271
5272 umask (077);
5273
5274 /**
5275 * Real init
5276 */
5277
5278 memset (&data, 0, sizeof (hc_global_data_t));
5279
5280 time_t proc_start;
5281
5282 time (&proc_start);
5283
5284 data.proc_start = proc_start;
5285
5286 int myargc = argc;
5287 char **myargv = argv;
5288
5289 hc_thread_mutex_init (mux_dispatcher);
5290 hc_thread_mutex_init (mux_counter);
5291 hc_thread_mutex_init (mux_display);
5292 hc_thread_mutex_init (mux_adl);
5293
5294 /**
5295 * commandline parameters
5296 */
5297
5298 uint usage = USAGE;
5299 uint version = VERSION;
5300 uint quiet = QUIET;
5301 uint benchmark = BENCHMARK;
5302 uint show = SHOW;
5303 uint left = LEFT;
5304 uint username = USERNAME;
5305 uint remove = REMOVE;
5306 uint remove_timer = REMOVE_TIMER;
5307 u64 skip = SKIP;
5308 u64 limit = LIMIT;
5309 uint keyspace = KEYSPACE;
5310 uint potfile_disable = POTFILE_DISABLE;
5311 char *potfile_path = NULL;
5312 uint debug_mode = DEBUG_MODE;
5313 char *debug_file = NULL;
5314 char *induction_dir = NULL;
5315 char *outfile_check_dir = NULL;
5316 uint force = FORCE;
5317 uint runtime = RUNTIME;
5318 uint hash_mode = HASH_MODE;
5319 uint attack_mode = ATTACK_MODE;
5320 uint markov_disable = MARKOV_DISABLE;
5321 uint markov_classic = MARKOV_CLASSIC;
5322 uint markov_threshold = MARKOV_THRESHOLD;
5323 char *markov_hcstat = NULL;
5324 char *outfile = NULL;
5325 uint outfile_format = OUTFILE_FORMAT;
5326 uint outfile_autohex = OUTFILE_AUTOHEX;
5327 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5328 uint restore = RESTORE;
5329 uint restore_timer = RESTORE_TIMER;
5330 uint restore_disable = RESTORE_DISABLE;
5331 uint status = STATUS;
5332 uint status_timer = STATUS_TIMER;
5333 uint status_automat = STATUS_AUTOMAT;
5334 uint loopback = LOOPBACK;
5335 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5336 char *session = NULL;
5337 uint hex_charset = HEX_CHARSET;
5338 uint hex_salt = HEX_SALT;
5339 uint hex_wordlist = HEX_WORDLIST;
5340 uint rp_gen = RP_GEN;
5341 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5342 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5343 uint rp_gen_seed = RP_GEN_SEED;
5344 char *rule_buf_l = (char *) RULE_BUF_L;
5345 char *rule_buf_r = (char *) RULE_BUF_R;
5346 uint increment = INCREMENT;
5347 uint increment_min = INCREMENT_MIN;
5348 uint increment_max = INCREMENT_MAX;
5349 char *cpu_affinity = NULL;
5350 OCL_PTR *ocl = NULL;
5351 char *opencl_devices = NULL;
5352 char *opencl_platforms = NULL;
5353 char *opencl_device_types = NULL;
5354 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5355 char *truecrypt_keyfiles = NULL;
5356 char *veracrypt_keyfiles = NULL;
5357 uint veracrypt_pim = 0;
5358 uint workload_profile = WORKLOAD_PROFILE;
5359 uint kernel_accel = KERNEL_ACCEL;
5360 uint kernel_loops = KERNEL_LOOPS;
5361 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5362 #ifdef HAVE_HWMON
5363 uint gpu_temp_abort = GPU_TEMP_ABORT;
5364 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5365 #ifdef HAVE_ADL
5366 uint powertune_enable = POWERTUNE_ENABLE;
5367 #endif
5368 #endif
5369 uint logfile_disable = LOGFILE_DISABLE;
5370 uint segment_size = SEGMENT_SIZE;
5371 uint scrypt_tmto = SCRYPT_TMTO;
5372 char separator = SEPARATOR;
5373 uint bitmap_min = BITMAP_MIN;
5374 uint bitmap_max = BITMAP_MAX;
5375 char *custom_charset_1 = NULL;
5376 char *custom_charset_2 = NULL;
5377 char *custom_charset_3 = NULL;
5378 char *custom_charset_4 = NULL;
5379
5380 #define IDX_HELP 'h'
5381 #define IDX_VERSION 'V'
5382 #define IDX_VERSION_LOWER 'v'
5383 #define IDX_QUIET 0xff02
5384 #define IDX_SHOW 0xff03
5385 #define IDX_LEFT 0xff04
5386 #define IDX_REMOVE 0xff05
5387 #define IDX_REMOVE_TIMER 0xff37
5388 #define IDX_SKIP 's'
5389 #define IDX_LIMIT 'l'
5390 #define IDX_KEYSPACE 0xff35
5391 #define IDX_POTFILE_DISABLE 0xff06
5392 #define IDX_POTFILE_PATH 0xffe0
5393 #define IDX_DEBUG_MODE 0xff43
5394 #define IDX_DEBUG_FILE 0xff44
5395 #define IDX_INDUCTION_DIR 0xff46
5396 #define IDX_OUTFILE_CHECK_DIR 0xff47
5397 #define IDX_USERNAME 0xff07
5398 #define IDX_FORCE 0xff08
5399 #define IDX_RUNTIME 0xff09
5400 #define IDX_BENCHMARK 'b'
5401 #define IDX_HASH_MODE 'm'
5402 #define IDX_ATTACK_MODE 'a'
5403 #define IDX_RP_FILE 'r'
5404 #define IDX_RP_GEN 'g'
5405 #define IDX_RP_GEN_FUNC_MIN 0xff10
5406 #define IDX_RP_GEN_FUNC_MAX 0xff11
5407 #define IDX_RP_GEN_SEED 0xff34
5408 #define IDX_RULE_BUF_L 'j'
5409 #define IDX_RULE_BUF_R 'k'
5410 #define IDX_INCREMENT 'i'
5411 #define IDX_INCREMENT_MIN 0xff12
5412 #define IDX_INCREMENT_MAX 0xff13
5413 #define IDX_OUTFILE 'o'
5414 #define IDX_OUTFILE_FORMAT 0xff14
5415 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5416 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5417 #define IDX_RESTORE 0xff15
5418 #define IDX_RESTORE_DISABLE 0xff27
5419 #define IDX_STATUS 0xff17
5420 #define IDX_STATUS_TIMER 0xff18
5421 #define IDX_STATUS_AUTOMAT 0xff50
5422 #define IDX_LOOPBACK 0xff38
5423 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5424 #define IDX_SESSION 0xff19
5425 #define IDX_HEX_CHARSET 0xff20
5426 #define IDX_HEX_SALT 0xff21
5427 #define IDX_HEX_WORDLIST 0xff40
5428 #define IDX_MARKOV_DISABLE 0xff22
5429 #define IDX_MARKOV_CLASSIC 0xff23
5430 #define IDX_MARKOV_THRESHOLD 't'
5431 #define IDX_MARKOV_HCSTAT 0xff24
5432 #define IDX_CPU_AFFINITY 0xff25
5433 #define IDX_OPENCL_DEVICES 'd'
5434 #define IDX_OPENCL_PLATFORMS 0xff72
5435 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5436 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5437 #define IDX_WORKLOAD_PROFILE 'w'
5438 #define IDX_KERNEL_ACCEL 'n'
5439 #define IDX_KERNEL_LOOPS 'u'
5440 #define IDX_GPU_TEMP_DISABLE 0xff29
5441 #define IDX_GPU_TEMP_ABORT 0xff30
5442 #define IDX_GPU_TEMP_RETAIN 0xff31
5443 #define IDX_POWERTUNE_ENABLE 0xff41
5444 #define IDX_LOGFILE_DISABLE 0xff51
5445 #define IDX_TRUECRYPT_KEYFILES 0xff52
5446 #define IDX_VERACRYPT_KEYFILES 0xff53
5447 #define IDX_VERACRYPT_PIM 0xff54
5448 #define IDX_SCRYPT_TMTO 0xff61
5449 #define IDX_SEGMENT_SIZE 'c'
5450 #define IDX_SEPARATOR 'p'
5451 #define IDX_BITMAP_MIN 0xff70
5452 #define IDX_BITMAP_MAX 0xff71
5453 #define IDX_CUSTOM_CHARSET_1 '1'
5454 #define IDX_CUSTOM_CHARSET_2 '2'
5455 #define IDX_CUSTOM_CHARSET_3 '3'
5456 #define IDX_CUSTOM_CHARSET_4 '4'
5457
5458 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5459
5460 struct option long_options[] =
5461 {
5462 {"help", no_argument, 0, IDX_HELP},
5463 {"version", no_argument, 0, IDX_VERSION},
5464 {"quiet", no_argument, 0, IDX_QUIET},
5465 {"show", no_argument, 0, IDX_SHOW},
5466 {"left", no_argument, 0, IDX_LEFT},
5467 {"username", no_argument, 0, IDX_USERNAME},
5468 {"remove", no_argument, 0, IDX_REMOVE},
5469 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5470 {"skip", required_argument, 0, IDX_SKIP},
5471 {"limit", required_argument, 0, IDX_LIMIT},
5472 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5473 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5474 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5475 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5476 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5477 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5478 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5479 {"force", no_argument, 0, IDX_FORCE},
5480 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5481 {"restore", no_argument, 0, IDX_RESTORE},
5482 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5483 {"status", no_argument, 0, IDX_STATUS},
5484 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5485 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5486 {"loopback", no_argument, 0, IDX_LOOPBACK},
5487 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5488 {"session", required_argument, 0, IDX_SESSION},
5489 {"runtime", required_argument, 0, IDX_RUNTIME},
5490 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5491 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5492 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5493 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5494 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5495 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5496 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5497 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5498 {"rules-file", required_argument, 0, IDX_RP_FILE},
5499 {"outfile", required_argument, 0, IDX_OUTFILE},
5500 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5501 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5502 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5503 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5504 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5505 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5506 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5507 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5508 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5509 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5510 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5511 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5512 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5513 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5514 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5515 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5516 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5517 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5518 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5519 #ifdef HAVE_HWMON
5520 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5521 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5522 #ifdef HAVE_ADL
5523 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5524 #endif
5525 #endif // HAVE_HWMON
5526 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5527 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5528 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5529 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5530 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5531 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5532 {"seperator", required_argument, 0, IDX_SEPARATOR},
5533 {"separator", required_argument, 0, IDX_SEPARATOR},
5534 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5535 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5536 {"increment", no_argument, 0, IDX_INCREMENT},
5537 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5538 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5539 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5540 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5541 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5542 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5543 {0, 0, 0, 0}
5544 };
5545
5546 uint rp_files_cnt = 0;
5547
5548 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5549
5550 int option_index = 0;
5551 int c = -1;
5552
5553 optind = 1;
5554 optopt = 0;
5555
5556 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5557 {
5558 switch (c)
5559 {
5560 case IDX_HELP: usage = 1; break;
5561 case IDX_VERSION:
5562 case IDX_VERSION_LOWER: version = 1; break;
5563 case IDX_RESTORE: restore = 1; break;
5564 case IDX_SESSION: session = optarg; break;
5565 case IDX_SHOW: show = 1; break;
5566 case IDX_LEFT: left = 1; break;
5567 case '?': return (-1);
5568 }
5569 }
5570
5571 if (optopt != 0)
5572 {
5573 log_error ("ERROR: Invalid argument specified");
5574
5575 return (-1);
5576 }
5577
5578 /**
5579 * exit functions
5580 */
5581
5582 if (version)
5583 {
5584 log_info ("%s", VERSION_TAG);
5585
5586 return (0);
5587 }
5588
5589 if (usage)
5590 {
5591 usage_big_print (PROGNAME);
5592
5593 return (0);
5594 }
5595
5596 /**
5597 * session needs to be set, always!
5598 */
5599
5600 if (session == NULL) session = (char *) PROGNAME;
5601
5602 /**
5603 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5604 */
5605
5606 char *exec_path = get_exec_path ();
5607
5608 #ifdef LINUX
5609
5610 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5611 char *resolved_exec_path = realpath (exec_path, NULL);
5612
5613 char *install_dir = get_install_dir (resolved_exec_path);
5614 char *profile_dir = NULL;
5615 char *session_dir = NULL;
5616 char *shared_dir = NULL;
5617
5618 if (strcmp (install_dir, resolved_install_folder) == 0)
5619 {
5620 struct passwd *pw = getpwuid (getuid ());
5621
5622 const char *homedir = pw->pw_dir;
5623
5624 profile_dir = get_profile_dir (homedir);
5625 session_dir = get_session_dir (profile_dir);
5626 shared_dir = strdup (SHARED_FOLDER);
5627
5628 mkdir (profile_dir, 0700);
5629 mkdir (session_dir, 0700);
5630 }
5631 else
5632 {
5633 profile_dir = install_dir;
5634 session_dir = install_dir;
5635 shared_dir = install_dir;
5636 }
5637
5638 myfree (resolved_install_folder);
5639 myfree (resolved_exec_path);
5640
5641 #else
5642
5643 char *install_dir = get_install_dir (exec_path);
5644 char *profile_dir = install_dir;
5645 char *session_dir = install_dir;
5646 char *shared_dir = install_dir;
5647
5648 #endif
5649
5650 data.install_dir = install_dir;
5651 data.profile_dir = profile_dir;
5652 data.session_dir = session_dir;
5653 data.shared_dir = shared_dir;
5654
5655 myfree (exec_path);
5656
5657 /**
5658 * kernel cache, we need to make sure folder exist
5659 */
5660
5661 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5662
5663 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5664
5665 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5666
5667 mkdir (kernels_folder, 0700);
5668
5669 myfree (kernels_folder);
5670
5671 /**
5672 * session
5673 */
5674
5675 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5676
5677 data.session = session;
5678
5679 char *eff_restore_file = (char *) mymalloc (session_size);
5680 char *new_restore_file = (char *) mymalloc (session_size);
5681
5682 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5683 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5684
5685 data.eff_restore_file = eff_restore_file;
5686 data.new_restore_file = new_restore_file;
5687
5688 if (((show == 1) || (left == 1)) && (restore == 1))
5689 {
5690 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5691 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5692
5693 return (-1);
5694 }
5695
5696 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5697 if ((show == 1) || (left == 1))
5698 {
5699 restore_disable = 1;
5700
5701 restore = 0;
5702 }
5703
5704 data.restore_disable = restore_disable;
5705
5706 restore_data_t *rd = init_restore (argc, argv);
5707
5708 data.rd = rd;
5709
5710 /**
5711 * restore file
5712 */
5713
5714 if (restore == 1)
5715 {
5716 read_restore (eff_restore_file, rd);
5717
5718 if (rd->version_bin < RESTORE_MIN)
5719 {
5720 log_error ("ERROR: Incompatible restore-file version");
5721
5722 return (-1);
5723 }
5724
5725 myargc = rd->argc;
5726 myargv = rd->argv;
5727
5728 #ifdef _POSIX
5729 rd->pid = getpid ();
5730 #elif _WIN
5731 rd->pid = GetCurrentProcessId ();
5732 #endif
5733 }
5734
5735 uint hash_mode_chgd = 0;
5736 uint runtime_chgd = 0;
5737 uint kernel_loops_chgd = 0;
5738 uint kernel_accel_chgd = 0;
5739 uint attack_mode_chgd = 0;
5740 uint outfile_format_chgd = 0;
5741 uint rp_gen_seed_chgd = 0;
5742 uint remove_timer_chgd = 0;
5743 uint increment_min_chgd = 0;
5744 uint increment_max_chgd = 0;
5745 uint workload_profile_chgd = 0;
5746 uint opencl_vector_width_chgd = 0;
5747
5748 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5749 uint gpu_temp_retain_chgd = 0;
5750 uint gpu_temp_abort_chgd = 0;
5751 #endif
5752
5753 optind = 1;
5754 optopt = 0;
5755 option_index = 0;
5756
5757 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5758 {
5759 switch (c)
5760 {
5761 //case IDX_HELP: usage = 1; break;
5762 //case IDX_VERSION: version = 1; break;
5763 //case IDX_RESTORE: restore = 1; break;
5764 case IDX_QUIET: quiet = 1; break;
5765 //case IDX_SHOW: show = 1; break;
5766 case IDX_SHOW: break;
5767 //case IDX_LEFT: left = 1; break;
5768 case IDX_LEFT: break;
5769 case IDX_USERNAME: username = 1; break;
5770 case IDX_REMOVE: remove = 1; break;
5771 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5772 remove_timer_chgd = 1; break;
5773 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5774 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5775 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5776 case IDX_DEBUG_FILE: debug_file = optarg; break;
5777 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5778 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5779 case IDX_FORCE: force = 1; break;
5780 case IDX_SKIP: skip = atoll (optarg); break;
5781 case IDX_LIMIT: limit = atoll (optarg); break;
5782 case IDX_KEYSPACE: keyspace = 1; break;
5783 case IDX_BENCHMARK: benchmark = 1; break;
5784 case IDX_RESTORE: break;
5785 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5786 case IDX_STATUS: status = 1; break;
5787 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5788 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5789 case IDX_LOOPBACK: loopback = 1; break;
5790 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5791 //case IDX_SESSION: session = optarg; break;
5792 case IDX_SESSION: break;
5793 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5794 hash_mode_chgd = 1; break;
5795 case IDX_RUNTIME: runtime = atoi (optarg);
5796 runtime_chgd = 1; break;
5797 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5798 attack_mode_chgd = 1; break;
5799 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5800 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5801 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5802 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5803 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5804 rp_gen_seed_chgd = 1; break;
5805 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5806 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5807 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5808 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5809 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5810 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5811 case IDX_OUTFILE: outfile = optarg; break;
5812 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5813 outfile_format_chgd = 1; break;
5814 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5815 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5816 case IDX_HEX_CHARSET: hex_charset = 1; break;
5817 case IDX_HEX_SALT: hex_salt = 1; break;
5818 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5819 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5820 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5821 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5822 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5823 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5824 opencl_vector_width_chgd = 1; break;
5825 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5826 workload_profile_chgd = 1; break;
5827 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5828 kernel_accel_chgd = 1; break;
5829 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5830 kernel_loops_chgd = 1; break;
5831 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5832 #ifdef HAVE_HWMON
5833 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5834 #ifdef HAVE_ADL
5835 gpu_temp_abort_chgd = 1;
5836 #endif
5837 break;
5838 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5839 #ifdef HAVE_ADL
5840 gpu_temp_retain_chgd = 1;
5841 #endif
5842 break;
5843 #ifdef HAVE_ADL
5844 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5845 #endif
5846 #endif // HAVE_HWMON
5847 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5848 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5849 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5850 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5851 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5852 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5853 case IDX_SEPARATOR: separator = optarg[0]; break;
5854 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5855 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5856 case IDX_INCREMENT: increment = 1; break;
5857 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5858 increment_min_chgd = 1; break;
5859 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5860 increment_max_chgd = 1; break;
5861 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5862 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5863 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5864 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5865
5866 default:
5867 log_error ("ERROR: Invalid argument specified");
5868 return (-1);
5869 }
5870 }
5871
5872 if (optopt != 0)
5873 {
5874 log_error ("ERROR: Invalid argument specified");
5875
5876 return (-1);
5877 }
5878
5879 /**
5880 * Inform user things getting started,
5881 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5882 * - we do not need to check algorithm_pos
5883 */
5884
5885 if (quiet == 0)
5886 {
5887 if (benchmark == 1)
5888 {
5889 if (status_automat == 0)
5890 {
5891 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5892 log_info ("");
5893 }
5894 else
5895 {
5896 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5897 }
5898 }
5899 else if (restore == 1)
5900 {
5901 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5902 log_info ("");
5903 }
5904 else
5905 {
5906 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5907 log_info ("");
5908 }
5909 }
5910
5911 /**
5912 * sanity check
5913 */
5914
5915 if (attack_mode > 7)
5916 {
5917 log_error ("ERROR: Invalid attack-mode specified");
5918
5919 return (-1);
5920 }
5921
5922 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5923 {
5924 log_error ("ERROR: Invalid runtime specified");
5925
5926 return (-1);
5927 }
5928
5929 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5930 {
5931 log_error ("ERROR: Invalid hash-type specified");
5932
5933 return (-1);
5934 }
5935
5936 // renamed hash modes
5937
5938 if (hash_mode_chgd)
5939 {
5940 int n = -1;
5941
5942 switch (hash_mode)
5943 {
5944 case 123: n = 124;
5945 break;
5946 }
5947
5948 if (n >= 0)
5949 {
5950 log_error ("Old -m specified, use -m %d instead", n);
5951
5952 return (-1);
5953 }
5954 }
5955
5956 if (username == 1)
5957 {
5958 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5959 {
5960 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5961
5962 return (-1);
5963 }
5964 }
5965
5966 if (outfile_format > 16)
5967 {
5968 log_error ("ERROR: Invalid outfile-format specified");
5969
5970 return (-1);
5971 }
5972
5973 if (left == 1)
5974 {
5975 if (outfile_format_chgd == 1)
5976 {
5977 if (outfile_format > 1)
5978 {
5979 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5980
5981 return (-1);
5982 }
5983 }
5984 else
5985 {
5986 outfile_format = OUTFILE_FMT_HASH;
5987 }
5988 }
5989
5990 if (show == 1)
5991 {
5992 if (outfile_format_chgd == 1)
5993 {
5994 if ((outfile_format > 7) && (outfile_format < 16))
5995 {
5996 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5997
5998 return (-1);
5999 }
6000 }
6001 }
6002
6003 if (increment_min < INCREMENT_MIN)
6004 {
6005 log_error ("ERROR: Invalid increment-min specified");
6006
6007 return (-1);
6008 }
6009
6010 if (increment_max > INCREMENT_MAX)
6011 {
6012 log_error ("ERROR: Invalid increment-max specified");
6013
6014 return (-1);
6015 }
6016
6017 if (increment_min > increment_max)
6018 {
6019 log_error ("ERROR: Invalid increment-min specified");
6020
6021 return (-1);
6022 }
6023
6024 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6025 {
6026 log_error ("ERROR: increment is not allowed in attack-mode 0");
6027
6028 return (-1);
6029 }
6030
6031 if ((increment == 0) && (increment_min_chgd == 1))
6032 {
6033 log_error ("ERROR: increment-min is only supported together with increment switch");
6034
6035 return (-1);
6036 }
6037
6038 if ((increment == 0) && (increment_max_chgd == 1))
6039 {
6040 log_error ("ERROR: increment-max is only supported together with increment switch");
6041
6042 return (-1);
6043 }
6044
6045 if (rp_files_cnt && rp_gen)
6046 {
6047 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6048
6049 return (-1);
6050 }
6051
6052 if (rp_files_cnt || rp_gen)
6053 {
6054 if (attack_mode != ATTACK_MODE_STRAIGHT)
6055 {
6056 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6057
6058 return (-1);
6059 }
6060 }
6061
6062 if (rp_gen_func_min > rp_gen_func_max)
6063 {
6064 log_error ("ERROR: Invalid rp-gen-func-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if (kernel_accel_chgd == 1)
6070 {
6071 if (kernel_accel < 1)
6072 {
6073 log_error ("ERROR: Invalid kernel-accel specified");
6074
6075 return (-1);
6076 }
6077
6078 if (kernel_accel > 1024)
6079 {
6080 log_error ("ERROR: Invalid kernel-accel specified");
6081
6082 return (-1);
6083 }
6084 }
6085
6086 if (kernel_loops_chgd == 1)
6087 {
6088 if (kernel_loops < 1)
6089 {
6090 log_error ("ERROR: Invalid kernel-loops specified");
6091
6092 return (-1);
6093 }
6094
6095 if (kernel_loops > 1024)
6096 {
6097 log_error ("ERROR: Invalid kernel-loops specified");
6098
6099 return (-1);
6100 }
6101 }
6102
6103 if ((workload_profile < 1) || (workload_profile > 3))
6104 {
6105 log_error ("ERROR: workload-profile %i not available", workload_profile);
6106
6107 return (-1);
6108 }
6109
6110 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6111 {
6112 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6113
6114 return (-1);
6115 }
6116
6117 if (show == 1 || left == 1)
6118 {
6119 attack_mode = ATTACK_MODE_NONE;
6120
6121 if (remove == 1)
6122 {
6123 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6124
6125 return (-1);
6126 }
6127
6128 if (potfile_disable == 1)
6129 {
6130 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6131
6132 return (-1);
6133 }
6134 }
6135
6136 uint attack_kern = ATTACK_KERN_NONE;
6137
6138 switch (attack_mode)
6139 {
6140 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6141 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6142 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6143 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6144 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6145 }
6146
6147 if (benchmark == 0)
6148 {
6149 if (keyspace == 1)
6150 {
6151 int num_additional_params = 1;
6152
6153 if (attack_kern == ATTACK_KERN_COMBI)
6154 {
6155 num_additional_params = 2;
6156 }
6157
6158 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6159
6160 if (keyspace_wordlist_specified == 0) optind--;
6161 }
6162
6163 if (attack_kern == ATTACK_KERN_NONE)
6164 {
6165 if ((optind + 1) != myargc)
6166 {
6167 usage_mini_print (myargv[0]);
6168
6169 return (-1);
6170 }
6171 }
6172 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6173 {
6174 if ((optind + 1) > myargc)
6175 {
6176 usage_mini_print (myargv[0]);
6177
6178 return (-1);
6179 }
6180 }
6181 else if (attack_kern == ATTACK_KERN_COMBI)
6182 {
6183 if ((optind + 3) != myargc)
6184 {
6185 usage_mini_print (myargv[0]);
6186
6187 return (-1);
6188 }
6189 }
6190 else if (attack_kern == ATTACK_KERN_BF)
6191 {
6192 if ((optind + 1) > myargc)
6193 {
6194 usage_mini_print (myargv[0]);
6195
6196 return (-1);
6197 }
6198 }
6199 else
6200 {
6201 usage_mini_print (myargv[0]);
6202
6203 return (-1);
6204 }
6205 }
6206 else
6207 {
6208 if (myargv[optind] != 0)
6209 {
6210 log_error ("ERROR: Invalid argument for benchmark mode specified");
6211
6212 return (-1);
6213 }
6214
6215 if (attack_mode_chgd == 1)
6216 {
6217 if (attack_mode != ATTACK_MODE_BF)
6218 {
6219 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6220
6221 return (-1);
6222 }
6223 }
6224 }
6225
6226 if (skip != 0 && limit != 0)
6227 {
6228 limit += skip;
6229 }
6230
6231 if (keyspace == 1)
6232 {
6233 if (show == 1)
6234 {
6235 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6236
6237 return (-1);
6238 }
6239 else if (left == 1)
6240 {
6241 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6242
6243 return (-1);
6244 }
6245
6246 potfile_disable = 1;
6247
6248 restore_disable = 1;
6249
6250 restore = 0;
6251
6252 weak_hash_threshold = 0;
6253
6254 quiet = 1;
6255 }
6256
6257 if (remove_timer_chgd == 1)
6258 {
6259 if (remove == 0)
6260 {
6261 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6262
6263 return (-1);
6264 }
6265
6266 if (remove_timer < 1)
6267 {
6268 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6269
6270 return (-1);
6271 }
6272 }
6273
6274 if (loopback == 1)
6275 {
6276 if (attack_mode == ATTACK_MODE_STRAIGHT)
6277 {
6278 if ((rp_files_cnt == 0) && (rp_gen == 0))
6279 {
6280 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6281
6282 return (-1);
6283 }
6284 }
6285 else
6286 {
6287 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6288
6289 return (-1);
6290 }
6291 }
6292
6293 if (debug_mode > 0)
6294 {
6295 if (attack_mode != ATTACK_MODE_STRAIGHT)
6296 {
6297 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6298
6299 return (-1);
6300 }
6301
6302 if ((rp_files_cnt == 0) && (rp_gen == 0))
6303 {
6304 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6305
6306 return (-1);
6307 }
6308 }
6309
6310 if (debug_mode > 4)
6311 {
6312 log_error ("ERROR: Invalid debug-mode specified");
6313
6314 return (-1);
6315 }
6316
6317 if (debug_file != NULL)
6318 {
6319 if (debug_mode < 1)
6320 {
6321 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6322
6323 return (-1);
6324 }
6325 }
6326
6327 if (induction_dir != NULL)
6328 {
6329 if (attack_mode == ATTACK_MODE_BF)
6330 {
6331 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6332
6333 return (-1);
6334 }
6335 }
6336
6337 if (attack_mode != ATTACK_MODE_STRAIGHT)
6338 {
6339 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6340 {
6341 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6342
6343 return (-1);
6344 }
6345
6346 weak_hash_threshold = 0;
6347 }
6348
6349 /**
6350 * induction directory
6351 */
6352
6353 char *induction_directory = NULL;
6354
6355 if (attack_mode != ATTACK_MODE_BF)
6356 {
6357 if (induction_dir == NULL)
6358 {
6359 induction_directory = (char *) mymalloc (session_size);
6360
6361 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6362
6363 // create induction folder if it does not already exist
6364
6365 if (keyspace == 0)
6366 {
6367 if (rmdir (induction_directory) == -1)
6368 {
6369 if (errno == ENOENT)
6370 {
6371 // good, we can ignore
6372 }
6373 else if (errno == ENOTEMPTY)
6374 {
6375 char *induction_directory_mv = (char *) mymalloc (session_size);
6376
6377 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6378
6379 if (rename (induction_directory, induction_directory_mv) != 0)
6380 {
6381 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6382
6383 return (-1);
6384 }
6385 }
6386 else
6387 {
6388 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6389
6390 return (-1);
6391 }
6392 }
6393
6394 if (mkdir (induction_directory, 0700) == -1)
6395 {
6396 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6397
6398 return (-1);
6399 }
6400 }
6401 }
6402 else
6403 {
6404 induction_directory = induction_dir;
6405 }
6406 }
6407
6408 data.induction_directory = induction_directory;
6409
6410 /**
6411 * loopback
6412 */
6413
6414 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6415
6416 char *loopback_file = (char *) mymalloc (loopback_size);
6417
6418 /**
6419 * tuning db
6420 */
6421
6422 char tuning_db_file[256] = { 0 };
6423
6424 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6425
6426 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6427
6428 /**
6429 * outfile-check directory
6430 */
6431
6432 char *outfile_check_directory = NULL;
6433
6434 if (outfile_check_dir == NULL)
6435 {
6436 outfile_check_directory = (char *) mymalloc (session_size);
6437
6438 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6439 }
6440 else
6441 {
6442 outfile_check_directory = outfile_check_dir;
6443 }
6444
6445 data.outfile_check_directory = outfile_check_directory;
6446
6447 if (keyspace == 0)
6448 {
6449 struct stat outfile_check_stat;
6450
6451 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6452 {
6453 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6454
6455 if (is_dir == 0)
6456 {
6457 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6458
6459 return (-1);
6460 }
6461 }
6462 else if (outfile_check_dir == NULL)
6463 {
6464 if (mkdir (outfile_check_directory, 0700) == -1)
6465 {
6466 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6467
6468 return (-1);
6469 }
6470 }
6471 }
6472
6473 /**
6474 * special other stuff
6475 */
6476
6477 if (hash_mode == 9710)
6478 {
6479 outfile_format = 5;
6480 outfile_format_chgd = 1;
6481 }
6482
6483 if (hash_mode == 9810)
6484 {
6485 outfile_format = 5;
6486 outfile_format_chgd = 1;
6487 }
6488
6489 if (hash_mode == 10410)
6490 {
6491 outfile_format = 5;
6492 outfile_format_chgd = 1;
6493 }
6494
6495 /**
6496 * store stuff
6497 */
6498
6499 data.hash_mode = hash_mode;
6500 data.restore = restore;
6501 data.restore_timer = restore_timer;
6502 data.restore_disable = restore_disable;
6503 data.status = status;
6504 data.status_timer = status_timer;
6505 data.status_automat = status_automat;
6506 data.loopback = loopback;
6507 data.runtime = runtime;
6508 data.remove = remove;
6509 data.remove_timer = remove_timer;
6510 data.debug_mode = debug_mode;
6511 data.debug_file = debug_file;
6512 data.username = username;
6513 data.quiet = quiet;
6514 data.outfile = outfile;
6515 data.outfile_format = outfile_format;
6516 data.outfile_autohex = outfile_autohex;
6517 data.hex_charset = hex_charset;
6518 data.hex_salt = hex_salt;
6519 data.hex_wordlist = hex_wordlist;
6520 data.separator = separator;
6521 data.rp_files = rp_files;
6522 data.rp_files_cnt = rp_files_cnt;
6523 data.rp_gen = rp_gen;
6524 data.rp_gen_seed = rp_gen_seed;
6525 data.force = force;
6526 data.benchmark = benchmark;
6527 data.skip = skip;
6528 data.limit = limit;
6529 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6530 data.powertune_enable = powertune_enable;
6531 #endif
6532 data.logfile_disable = logfile_disable;
6533 data.truecrypt_keyfiles = truecrypt_keyfiles;
6534 data.veracrypt_keyfiles = veracrypt_keyfiles;
6535 data.veracrypt_pim = veracrypt_pim;
6536 data.scrypt_tmto = scrypt_tmto;
6537 data.workload_profile = workload_profile;
6538
6539 /**
6540 * cpu affinity
6541 */
6542
6543 if (cpu_affinity)
6544 {
6545 set_cpu_affinity (cpu_affinity);
6546 }
6547
6548 if (rp_gen_seed_chgd == 0)
6549 {
6550 srand (proc_start);
6551 }
6552 else
6553 {
6554 srand (rp_gen_seed);
6555 }
6556
6557 /**
6558 * logfile init
6559 */
6560
6561 if (logfile_disable == 0)
6562 {
6563 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6564
6565 char *logfile = (char *) mymalloc (logfile_size);
6566
6567 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6568
6569 data.logfile = logfile;
6570
6571 char *topid = logfile_generate_topid ();
6572
6573 data.topid = topid;
6574 }
6575
6576 // logfile_append() checks for logfile_disable internally to make it easier from here
6577
6578 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6579 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6580 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6581 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6582 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6583 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6584 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6585 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6586 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6587 #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));
6588
6589 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6590 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6591 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6592 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6593 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6594 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6595 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6596 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6597
6598 logfile_top_msg ("START");
6599
6600 logfile_top_uint (attack_mode);
6601 logfile_top_uint (attack_kern);
6602 logfile_top_uint (benchmark);
6603 logfile_top_uint (bitmap_min);
6604 logfile_top_uint (bitmap_max);
6605 logfile_top_uint (debug_mode);
6606 logfile_top_uint (force);
6607 logfile_top_uint (kernel_accel);
6608 logfile_top_uint (kernel_loops);
6609 logfile_top_uint (gpu_temp_disable);
6610 #ifdef HAVE_HWMON
6611 logfile_top_uint (gpu_temp_abort);
6612 logfile_top_uint (gpu_temp_retain);
6613 #endif
6614 logfile_top_uint (hash_mode);
6615 logfile_top_uint (hex_charset);
6616 logfile_top_uint (hex_salt);
6617 logfile_top_uint (hex_wordlist);
6618 logfile_top_uint (increment);
6619 logfile_top_uint (increment_max);
6620 logfile_top_uint (increment_min);
6621 logfile_top_uint (keyspace);
6622 logfile_top_uint (left);
6623 logfile_top_uint (logfile_disable);
6624 logfile_top_uint (loopback);
6625 logfile_top_uint (markov_classic);
6626 logfile_top_uint (markov_disable);
6627 logfile_top_uint (markov_threshold);
6628 logfile_top_uint (outfile_autohex);
6629 logfile_top_uint (outfile_check_timer);
6630 logfile_top_uint (outfile_format);
6631 logfile_top_uint (potfile_disable);
6632 logfile_top_string (potfile_path);
6633 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6634 logfile_top_uint (powertune_enable);
6635 #endif
6636 logfile_top_uint (scrypt_tmto);
6637 logfile_top_uint (quiet);
6638 logfile_top_uint (remove);
6639 logfile_top_uint (remove_timer);
6640 logfile_top_uint (restore);
6641 logfile_top_uint (restore_disable);
6642 logfile_top_uint (restore_timer);
6643 logfile_top_uint (rp_gen);
6644 logfile_top_uint (rp_gen_func_max);
6645 logfile_top_uint (rp_gen_func_min);
6646 logfile_top_uint (rp_gen_seed);
6647 logfile_top_uint (runtime);
6648 logfile_top_uint (segment_size);
6649 logfile_top_uint (show);
6650 logfile_top_uint (status);
6651 logfile_top_uint (status_automat);
6652 logfile_top_uint (status_timer);
6653 logfile_top_uint (usage);
6654 logfile_top_uint (username);
6655 logfile_top_uint (version);
6656 logfile_top_uint (weak_hash_threshold);
6657 logfile_top_uint (workload_profile);
6658 logfile_top_uint64 (limit);
6659 logfile_top_uint64 (skip);
6660 logfile_top_char (separator);
6661 logfile_top_string (cpu_affinity);
6662 logfile_top_string (custom_charset_1);
6663 logfile_top_string (custom_charset_2);
6664 logfile_top_string (custom_charset_3);
6665 logfile_top_string (custom_charset_4);
6666 logfile_top_string (debug_file);
6667 logfile_top_string (opencl_devices);
6668 logfile_top_string (opencl_platforms);
6669 logfile_top_string (opencl_device_types);
6670 logfile_top_uint (opencl_vector_width);
6671 logfile_top_string (induction_dir);
6672 logfile_top_string (markov_hcstat);
6673 logfile_top_string (outfile);
6674 logfile_top_string (outfile_check_dir);
6675 logfile_top_string (rule_buf_l);
6676 logfile_top_string (rule_buf_r);
6677 logfile_top_string (session);
6678 logfile_top_string (truecrypt_keyfiles);
6679 logfile_top_string (veracrypt_keyfiles);
6680 logfile_top_uint (veracrypt_pim);
6681
6682 /**
6683 * Init OpenCL library loader
6684 */
6685
6686 if (keyspace == 0)
6687 {
6688 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6689
6690 ocl_init (ocl);
6691
6692 data.ocl = ocl;
6693 }
6694
6695 /**
6696 * OpenCL platform selection
6697 */
6698
6699 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6700
6701 /**
6702 * OpenCL device selection
6703 */
6704
6705 u32 devices_filter = setup_devices_filter (opencl_devices);
6706
6707 /**
6708 * OpenCL device type selection
6709 */
6710
6711 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6712
6713 /**
6714 * benchmark
6715 */
6716
6717 if (benchmark == 1)
6718 {
6719 /**
6720 * disable useless stuff for benchmark
6721 */
6722
6723 status_timer = 0;
6724 restore_timer = 0;
6725 restore_disable = 1;
6726 potfile_disable = 1;
6727 weak_hash_threshold = 0;
6728 gpu_temp_disable = 1;
6729
6730 data.status_timer = status_timer;
6731 data.restore_timer = restore_timer;
6732 data.restore_disable = restore_disable;
6733
6734 /**
6735 * force attack mode to be bruteforce
6736 */
6737
6738 attack_mode = ATTACK_MODE_BF;
6739 attack_kern = ATTACK_KERN_BF;
6740
6741 if (workload_profile_chgd == 0)
6742 {
6743 workload_profile = 3;
6744
6745 data.workload_profile = workload_profile;
6746 }
6747 }
6748
6749 /**
6750 * config
6751 */
6752
6753 uint hash_type = 0;
6754 uint salt_type = 0;
6755 uint attack_exec = 0;
6756 uint opts_type = 0;
6757 uint kern_type = 0;
6758 uint dgst_size = 0;
6759 uint esalt_size = 0;
6760 uint opti_type = 0;
6761 uint dgst_pos0 = -1;
6762 uint dgst_pos1 = -1;
6763 uint dgst_pos2 = -1;
6764 uint dgst_pos3 = -1;
6765
6766 int (*parse_func) (char *, uint, hash_t *);
6767 int (*sort_by_digest) (const void *, const void *);
6768
6769 uint algorithm_pos = 0;
6770 uint algorithm_max = 1;
6771
6772 uint *algorithms = default_benchmark_algorithms;
6773
6774 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6775
6776 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6777 {
6778 /*
6779 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6780 * the following algos are skipped entirely
6781 */
6782
6783 if (algorithm_pos > 0)
6784 {
6785 local_free (rd);
6786
6787 rd = init_restore (argc, argv);
6788
6789 data.rd = rd;
6790 }
6791
6792 /**
6793 * update hash_mode in case of multihash benchmark
6794 */
6795
6796 if (benchmark == 1)
6797 {
6798 if (hash_mode_chgd == 0)
6799 {
6800 hash_mode = algorithms[algorithm_pos];
6801
6802 data.hash_mode = hash_mode;
6803 }
6804
6805 quiet = 1;
6806
6807 data.quiet = quiet;
6808 }
6809
6810 switch (hash_mode)
6811 {
6812 case 0: hash_type = HASH_TYPE_MD5;
6813 salt_type = SALT_TYPE_NONE;
6814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6815 opts_type = OPTS_TYPE_PT_GENERATE_LE
6816 | OPTS_TYPE_PT_ADD80
6817 | OPTS_TYPE_PT_ADDBITS14;
6818 kern_type = KERN_TYPE_MD5;
6819 dgst_size = DGST_SIZE_4_4;
6820 parse_func = md5_parse_hash;
6821 sort_by_digest = sort_by_digest_4_4;
6822 opti_type = OPTI_TYPE_ZERO_BYTE
6823 | OPTI_TYPE_PRECOMPUTE_INIT
6824 | OPTI_TYPE_PRECOMPUTE_MERKLE
6825 | OPTI_TYPE_MEET_IN_MIDDLE
6826 | OPTI_TYPE_EARLY_SKIP
6827 | OPTI_TYPE_NOT_ITERATED
6828 | OPTI_TYPE_NOT_SALTED
6829 | OPTI_TYPE_RAW_HASH;
6830 dgst_pos0 = 0;
6831 dgst_pos1 = 3;
6832 dgst_pos2 = 2;
6833 dgst_pos3 = 1;
6834 break;
6835
6836 case 10: hash_type = HASH_TYPE_MD5;
6837 salt_type = SALT_TYPE_INTERN;
6838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6839 opts_type = OPTS_TYPE_PT_GENERATE_LE
6840 | OPTS_TYPE_ST_ADD80
6841 | OPTS_TYPE_ST_ADDBITS14;
6842 kern_type = KERN_TYPE_MD5_PWSLT;
6843 dgst_size = DGST_SIZE_4_4;
6844 parse_func = md5s_parse_hash;
6845 sort_by_digest = sort_by_digest_4_4;
6846 opti_type = OPTI_TYPE_ZERO_BYTE
6847 | OPTI_TYPE_PRECOMPUTE_INIT
6848 | OPTI_TYPE_PRECOMPUTE_MERKLE
6849 | OPTI_TYPE_MEET_IN_MIDDLE
6850 | OPTI_TYPE_EARLY_SKIP
6851 | OPTI_TYPE_NOT_ITERATED
6852 | OPTI_TYPE_APPENDED_SALT
6853 | OPTI_TYPE_RAW_HASH;
6854 dgst_pos0 = 0;
6855 dgst_pos1 = 3;
6856 dgst_pos2 = 2;
6857 dgst_pos3 = 1;
6858 break;
6859
6860 case 11: hash_type = HASH_TYPE_MD5;
6861 salt_type = SALT_TYPE_INTERN;
6862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6863 opts_type = OPTS_TYPE_PT_GENERATE_LE
6864 | OPTS_TYPE_ST_ADD80
6865 | OPTS_TYPE_ST_ADDBITS14;
6866 kern_type = KERN_TYPE_MD5_PWSLT;
6867 dgst_size = DGST_SIZE_4_4;
6868 parse_func = joomla_parse_hash;
6869 sort_by_digest = sort_by_digest_4_4;
6870 opti_type = OPTI_TYPE_ZERO_BYTE
6871 | OPTI_TYPE_PRECOMPUTE_INIT
6872 | OPTI_TYPE_PRECOMPUTE_MERKLE
6873 | OPTI_TYPE_MEET_IN_MIDDLE
6874 | OPTI_TYPE_EARLY_SKIP
6875 | OPTI_TYPE_NOT_ITERATED
6876 | OPTI_TYPE_APPENDED_SALT
6877 | OPTI_TYPE_RAW_HASH;
6878 dgst_pos0 = 0;
6879 dgst_pos1 = 3;
6880 dgst_pos2 = 2;
6881 dgst_pos3 = 1;
6882 break;
6883
6884 case 12: hash_type = HASH_TYPE_MD5;
6885 salt_type = SALT_TYPE_INTERN;
6886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6887 opts_type = OPTS_TYPE_PT_GENERATE_LE
6888 | OPTS_TYPE_ST_ADD80
6889 | OPTS_TYPE_ST_ADDBITS14;
6890 kern_type = KERN_TYPE_MD5_PWSLT;
6891 dgst_size = DGST_SIZE_4_4;
6892 parse_func = postgresql_parse_hash;
6893 sort_by_digest = sort_by_digest_4_4;
6894 opti_type = OPTI_TYPE_ZERO_BYTE
6895 | OPTI_TYPE_PRECOMPUTE_INIT
6896 | OPTI_TYPE_PRECOMPUTE_MERKLE
6897 | OPTI_TYPE_MEET_IN_MIDDLE
6898 | OPTI_TYPE_EARLY_SKIP
6899 | OPTI_TYPE_NOT_ITERATED
6900 | OPTI_TYPE_APPENDED_SALT
6901 | OPTI_TYPE_RAW_HASH;
6902 dgst_pos0 = 0;
6903 dgst_pos1 = 3;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 20: hash_type = HASH_TYPE_MD5;
6909 salt_type = SALT_TYPE_INTERN;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_LE
6912 | OPTS_TYPE_PT_ADD80
6913 | OPTS_TYPE_PT_ADDBITS14;
6914 kern_type = KERN_TYPE_MD5_SLTPW;
6915 dgst_size = DGST_SIZE_4_4;
6916 parse_func = md5s_parse_hash;
6917 sort_by_digest = sort_by_digest_4_4;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_PREPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 0;
6926 dgst_pos1 = 3;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 21: hash_type = HASH_TYPE_MD5;
6932 salt_type = SALT_TYPE_INTERN;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_LE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS14;
6937 kern_type = KERN_TYPE_MD5_SLTPW;
6938 dgst_size = DGST_SIZE_4_4;
6939 parse_func = osc_parse_hash;
6940 sort_by_digest = sort_by_digest_4_4;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_EARLY_SKIP
6945 | OPTI_TYPE_NOT_ITERATED
6946 | OPTI_TYPE_PREPENDED_SALT
6947 | OPTI_TYPE_RAW_HASH;
6948 dgst_pos0 = 0;
6949 dgst_pos1 = 3;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 22: hash_type = HASH_TYPE_MD5;
6955 salt_type = SALT_TYPE_EMBEDDED;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_LE
6958 | OPTS_TYPE_PT_ADD80
6959 | OPTS_TYPE_PT_ADDBITS14;
6960 kern_type = KERN_TYPE_MD5_SLTPW;
6961 dgst_size = DGST_SIZE_4_4;
6962 parse_func = netscreen_parse_hash;
6963 sort_by_digest = sort_by_digest_4_4;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_PREPENDED_SALT
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 0;
6972 dgst_pos1 = 3;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 23: hash_type = HASH_TYPE_MD5;
6978 salt_type = SALT_TYPE_EMBEDDED;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_LE
6981 | OPTS_TYPE_PT_ADD80
6982 | OPTS_TYPE_PT_ADDBITS14;
6983 kern_type = KERN_TYPE_MD5_SLTPW;
6984 dgst_size = DGST_SIZE_4_4;
6985 parse_func = skype_parse_hash;
6986 sort_by_digest = sort_by_digest_4_4;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_PREPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 0;
6995 dgst_pos1 = 3;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 30: hash_type = HASH_TYPE_MD5;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_LE
7004 | OPTS_TYPE_PT_UNICODE
7005 | OPTS_TYPE_ST_ADD80
7006 | OPTS_TYPE_ST_ADDBITS14;
7007 kern_type = KERN_TYPE_MD5_PWUSLT;
7008 dgst_size = DGST_SIZE_4_4;
7009 parse_func = md5s_parse_hash;
7010 sort_by_digest = sort_by_digest_4_4;
7011 opti_type = OPTI_TYPE_ZERO_BYTE
7012 | OPTI_TYPE_PRECOMPUTE_INIT
7013 | OPTI_TYPE_PRECOMPUTE_MERKLE
7014 | OPTI_TYPE_MEET_IN_MIDDLE
7015 | OPTI_TYPE_EARLY_SKIP
7016 | OPTI_TYPE_NOT_ITERATED
7017 | OPTI_TYPE_APPENDED_SALT
7018 | OPTI_TYPE_RAW_HASH;
7019 dgst_pos0 = 0;
7020 dgst_pos1 = 3;
7021 dgst_pos2 = 2;
7022 dgst_pos3 = 1;
7023 break;
7024
7025 case 40: hash_type = HASH_TYPE_MD5;
7026 salt_type = SALT_TYPE_INTERN;
7027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7028 opts_type = OPTS_TYPE_PT_GENERATE_LE
7029 | OPTS_TYPE_PT_ADD80
7030 | OPTS_TYPE_PT_ADDBITS14
7031 | OPTS_TYPE_PT_UNICODE;
7032 kern_type = KERN_TYPE_MD5_SLTPWU;
7033 dgst_size = DGST_SIZE_4_4;
7034 parse_func = md5s_parse_hash;
7035 sort_by_digest = sort_by_digest_4_4;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_PRECOMPUTE_INIT
7038 | OPTI_TYPE_PRECOMPUTE_MERKLE
7039 | OPTI_TYPE_EARLY_SKIP
7040 | OPTI_TYPE_NOT_ITERATED
7041 | OPTI_TYPE_PREPENDED_SALT
7042 | OPTI_TYPE_RAW_HASH;
7043 dgst_pos0 = 0;
7044 dgst_pos1 = 3;
7045 dgst_pos2 = 2;
7046 dgst_pos3 = 1;
7047 break;
7048
7049 case 50: hash_type = HASH_TYPE_MD5;
7050 salt_type = SALT_TYPE_INTERN;
7051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7052 opts_type = OPTS_TYPE_PT_GENERATE_LE
7053 | OPTS_TYPE_ST_ADD80
7054 | OPTS_TYPE_ST_ADDBITS14;
7055 kern_type = KERN_TYPE_HMACMD5_PW;
7056 dgst_size = DGST_SIZE_4_4;
7057 parse_func = hmacmd5_parse_hash;
7058 sort_by_digest = sort_by_digest_4_4;
7059 opti_type = OPTI_TYPE_ZERO_BYTE
7060 | OPTI_TYPE_NOT_ITERATED;
7061 dgst_pos0 = 0;
7062 dgst_pos1 = 3;
7063 dgst_pos2 = 2;
7064 dgst_pos3 = 1;
7065 break;
7066
7067 case 60: hash_type = HASH_TYPE_MD5;
7068 salt_type = SALT_TYPE_INTERN;
7069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7070 opts_type = OPTS_TYPE_PT_GENERATE_LE
7071 | OPTS_TYPE_PT_ADD80
7072 | OPTS_TYPE_PT_ADDBITS14;
7073 kern_type = KERN_TYPE_HMACMD5_SLT;
7074 dgst_size = DGST_SIZE_4_4;
7075 parse_func = hmacmd5_parse_hash;
7076 sort_by_digest = sort_by_digest_4_4;
7077 opti_type = OPTI_TYPE_ZERO_BYTE
7078 | OPTI_TYPE_NOT_ITERATED;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 100: hash_type = HASH_TYPE_SHA1;
7086 salt_type = SALT_TYPE_NONE;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_BE
7089 | OPTS_TYPE_PT_ADD80
7090 | OPTS_TYPE_PT_ADDBITS15;
7091 kern_type = KERN_TYPE_SHA1;
7092 dgst_size = DGST_SIZE_4_5;
7093 parse_func = sha1_parse_hash;
7094 sort_by_digest = sort_by_digest_4_5;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_PRECOMPUTE_INIT
7097 | OPTI_TYPE_PRECOMPUTE_MERKLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_NOT_SALTED
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 3;
7103 dgst_pos1 = 4;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 101: hash_type = HASH_TYPE_SHA1;
7109 salt_type = SALT_TYPE_NONE;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_BE
7112 | OPTS_TYPE_PT_ADD80
7113 | OPTS_TYPE_PT_ADDBITS15;
7114 kern_type = KERN_TYPE_SHA1;
7115 dgst_size = DGST_SIZE_4_5;
7116 parse_func = sha1b64_parse_hash;
7117 sort_by_digest = sort_by_digest_4_5;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_NOT_SALTED
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 110: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS15;
7137 kern_type = KERN_TYPE_SHA1_PWSLT;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = sha1s_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_PRECOMPUTE_INIT
7143 | OPTI_TYPE_PRECOMPUTE_MERKLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_APPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 3;
7149 dgst_pos1 = 4;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 111: hash_type = HASH_TYPE_SHA1;
7155 salt_type = SALT_TYPE_EMBEDDED;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_BE
7158 | OPTS_TYPE_ST_ADD80
7159 | OPTS_TYPE_ST_ADDBITS15;
7160 kern_type = KERN_TYPE_SHA1_PWSLT;
7161 dgst_size = DGST_SIZE_4_5;
7162 parse_func = sha1b64s_parse_hash;
7163 sort_by_digest = sort_by_digest_4_5;
7164 opti_type = OPTI_TYPE_ZERO_BYTE
7165 | OPTI_TYPE_PRECOMPUTE_INIT
7166 | OPTI_TYPE_PRECOMPUTE_MERKLE
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_APPENDED_SALT
7170 | OPTI_TYPE_RAW_HASH;
7171 dgst_pos0 = 3;
7172 dgst_pos1 = 4;
7173 dgst_pos2 = 2;
7174 dgst_pos3 = 1;
7175 break;
7176
7177 case 112: hash_type = HASH_TYPE_SHA1;
7178 salt_type = SALT_TYPE_INTERN;
7179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7180 opts_type = OPTS_TYPE_PT_GENERATE_BE
7181 | OPTS_TYPE_ST_ADD80
7182 | OPTS_TYPE_ST_ADDBITS15
7183 | OPTS_TYPE_ST_HEX;
7184 kern_type = KERN_TYPE_SHA1_PWSLT;
7185 dgst_size = DGST_SIZE_4_5;
7186 parse_func = oracles_parse_hash;
7187 sort_by_digest = sort_by_digest_4_5;
7188 opti_type = OPTI_TYPE_ZERO_BYTE
7189 | OPTI_TYPE_PRECOMPUTE_INIT
7190 | OPTI_TYPE_PRECOMPUTE_MERKLE
7191 | OPTI_TYPE_EARLY_SKIP
7192 | OPTI_TYPE_NOT_ITERATED
7193 | OPTI_TYPE_APPENDED_SALT
7194 | OPTI_TYPE_RAW_HASH;
7195 dgst_pos0 = 3;
7196 dgst_pos1 = 4;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 120: hash_type = HASH_TYPE_SHA1;
7202 salt_type = SALT_TYPE_INTERN;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_BE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS15;
7207 kern_type = KERN_TYPE_SHA1_SLTPW;
7208 dgst_size = DGST_SIZE_4_5;
7209 parse_func = sha1s_parse_hash;
7210 sort_by_digest = sort_by_digest_4_5;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED
7216 | OPTI_TYPE_PREPENDED_SALT
7217 | OPTI_TYPE_RAW_HASH;
7218 dgst_pos0 = 3;
7219 dgst_pos1 = 4;
7220 dgst_pos2 = 2;
7221 dgst_pos3 = 1;
7222 break;
7223
7224 case 121: hash_type = HASH_TYPE_SHA1;
7225 salt_type = SALT_TYPE_INTERN;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = OPTS_TYPE_PT_GENERATE_BE
7228 | OPTS_TYPE_PT_ADD80
7229 | OPTS_TYPE_PT_ADDBITS15
7230 | OPTS_TYPE_ST_LOWER;
7231 kern_type = KERN_TYPE_SHA1_SLTPW;
7232 dgst_size = DGST_SIZE_4_5;
7233 parse_func = smf_parse_hash;
7234 sort_by_digest = sort_by_digest_4_5;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_EARLY_SKIP
7239 | OPTI_TYPE_NOT_ITERATED
7240 | OPTI_TYPE_PREPENDED_SALT
7241 | OPTI_TYPE_RAW_HASH;
7242 dgst_pos0 = 3;
7243 dgst_pos1 = 4;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 122: hash_type = HASH_TYPE_SHA1;
7249 salt_type = SALT_TYPE_EMBEDDED;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_BE
7252 | OPTS_TYPE_PT_ADD80
7253 | OPTS_TYPE_PT_ADDBITS15
7254 | OPTS_TYPE_ST_HEX;
7255 kern_type = KERN_TYPE_SHA1_SLTPW;
7256 dgst_size = DGST_SIZE_4_5;
7257 parse_func = osx1_parse_hash;
7258 sort_by_digest = sort_by_digest_4_5;
7259 opti_type = OPTI_TYPE_ZERO_BYTE
7260 | OPTI_TYPE_PRECOMPUTE_INIT
7261 | OPTI_TYPE_PRECOMPUTE_MERKLE
7262 | OPTI_TYPE_EARLY_SKIP
7263 | OPTI_TYPE_NOT_ITERATED
7264 | OPTI_TYPE_PREPENDED_SALT
7265 | OPTI_TYPE_RAW_HASH;
7266 dgst_pos0 = 3;
7267 dgst_pos1 = 4;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 124: hash_type = HASH_TYPE_SHA1;
7273 salt_type = SALT_TYPE_EMBEDDED;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_BE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS15;
7278 kern_type = KERN_TYPE_SHA1_SLTPW;
7279 dgst_size = DGST_SIZE_4_5;
7280 parse_func = djangosha1_parse_hash;
7281 sort_by_digest = sort_by_digest_4_5;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 3;
7290 dgst_pos1 = 4;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 125: hash_type = HASH_TYPE_SHA1;
7296 salt_type = SALT_TYPE_EMBEDDED;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_BE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS15
7301 | OPTS_TYPE_ST_HEX;
7302 kern_type = KERN_TYPE_SHA1_SLTPW;
7303 dgst_size = DGST_SIZE_4_5;
7304 parse_func = arubaos_parse_hash;
7305 sort_by_digest = sort_by_digest_4_5;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_EARLY_SKIP
7310 | OPTI_TYPE_NOT_ITERATED
7311 | OPTI_TYPE_PREPENDED_SALT
7312 | OPTI_TYPE_RAW_HASH;
7313 dgst_pos0 = 3;
7314 dgst_pos1 = 4;
7315 dgst_pos2 = 2;
7316 dgst_pos3 = 1;
7317 break;
7318
7319 case 130: hash_type = HASH_TYPE_SHA1;
7320 salt_type = SALT_TYPE_INTERN;
7321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7322 opts_type = OPTS_TYPE_PT_GENERATE_BE
7323 | OPTS_TYPE_PT_UNICODE
7324 | OPTS_TYPE_ST_ADD80
7325 | OPTS_TYPE_ST_ADDBITS15;
7326 kern_type = KERN_TYPE_SHA1_PWUSLT;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = sha1s_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_PRECOMPUTE_INIT
7332 | OPTI_TYPE_PRECOMPUTE_MERKLE
7333 | OPTI_TYPE_EARLY_SKIP
7334 | OPTI_TYPE_NOT_ITERATED
7335 | OPTI_TYPE_APPENDED_SALT
7336 | OPTI_TYPE_RAW_HASH;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 4;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 1;
7341 break;
7342
7343 case 131: hash_type = HASH_TYPE_SHA1;
7344 salt_type = SALT_TYPE_EMBEDDED;
7345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_UNICODE
7348 | OPTS_TYPE_PT_UPPER
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15
7351 | OPTS_TYPE_ST_HEX;
7352 kern_type = KERN_TYPE_SHA1_PWUSLT;
7353 dgst_size = DGST_SIZE_4_5;
7354 parse_func = mssql2000_parse_hash;
7355 sort_by_digest = sort_by_digest_4_5;
7356 opti_type = OPTI_TYPE_ZERO_BYTE
7357 | OPTI_TYPE_PRECOMPUTE_INIT
7358 | OPTI_TYPE_PRECOMPUTE_MERKLE
7359 | OPTI_TYPE_EARLY_SKIP
7360 | OPTI_TYPE_NOT_ITERATED
7361 | OPTI_TYPE_APPENDED_SALT
7362 | OPTI_TYPE_RAW_HASH;
7363 dgst_pos0 = 3;
7364 dgst_pos1 = 4;
7365 dgst_pos2 = 2;
7366 dgst_pos3 = 1;
7367 break;
7368
7369 case 132: hash_type = HASH_TYPE_SHA1;
7370 salt_type = SALT_TYPE_EMBEDDED;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = OPTS_TYPE_PT_GENERATE_BE
7373 | OPTS_TYPE_PT_UNICODE
7374 | OPTS_TYPE_ST_ADD80
7375 | OPTS_TYPE_ST_ADDBITS15
7376 | OPTS_TYPE_ST_HEX;
7377 kern_type = KERN_TYPE_SHA1_PWUSLT;
7378 dgst_size = DGST_SIZE_4_5;
7379 parse_func = mssql2005_parse_hash;
7380 sort_by_digest = sort_by_digest_4_5;
7381 opti_type = OPTI_TYPE_ZERO_BYTE
7382 | OPTI_TYPE_PRECOMPUTE_INIT
7383 | OPTI_TYPE_PRECOMPUTE_MERKLE
7384 | OPTI_TYPE_EARLY_SKIP
7385 | OPTI_TYPE_NOT_ITERATED
7386 | OPTI_TYPE_APPENDED_SALT
7387 | OPTI_TYPE_RAW_HASH;
7388 dgst_pos0 = 3;
7389 dgst_pos1 = 4;
7390 dgst_pos2 = 2;
7391 dgst_pos3 = 1;
7392 break;
7393
7394 case 133: hash_type = HASH_TYPE_SHA1;
7395 salt_type = SALT_TYPE_EMBEDDED;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_BE
7398 | OPTS_TYPE_PT_UNICODE
7399 | OPTS_TYPE_ST_ADD80
7400 | OPTS_TYPE_ST_ADDBITS15;
7401 kern_type = KERN_TYPE_SHA1_PWUSLT;
7402 dgst_size = DGST_SIZE_4_5;
7403 parse_func = peoplesoft_parse_hash;
7404 sort_by_digest = sort_by_digest_4_5;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_APPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 3;
7413 dgst_pos1 = 4;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 1;
7416 break;
7417
7418 case 140: hash_type = HASH_TYPE_SHA1;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_BE
7422 | OPTS_TYPE_PT_ADD80
7423 | OPTS_TYPE_PT_ADDBITS15
7424 | OPTS_TYPE_PT_UNICODE;
7425 kern_type = KERN_TYPE_SHA1_SLTPWU;
7426 dgst_size = DGST_SIZE_4_5;
7427 parse_func = sha1s_parse_hash;
7428 sort_by_digest = sort_by_digest_4_5;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_PREPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 4;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 1;
7440 break;
7441
7442 case 141: hash_type = HASH_TYPE_SHA1;
7443 salt_type = SALT_TYPE_EMBEDDED;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15
7448 | OPTS_TYPE_PT_UNICODE
7449 | OPTS_TYPE_ST_BASE64;
7450 kern_type = KERN_TYPE_SHA1_SLTPWU;
7451 dgst_size = DGST_SIZE_4_5;
7452 parse_func = episerver_parse_hash;
7453 sort_by_digest = sort_by_digest_4_5;
7454 opti_type = OPTI_TYPE_ZERO_BYTE
7455 | OPTI_TYPE_PRECOMPUTE_INIT
7456 | OPTI_TYPE_PRECOMPUTE_MERKLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_PREPENDED_SALT
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 3;
7462 dgst_pos1 = 4;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 150: hash_type = HASH_TYPE_SHA1;
7468 salt_type = SALT_TYPE_INTERN;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_BE
7471 | OPTS_TYPE_ST_ADD80
7472 | OPTS_TYPE_ST_ADDBITS15;
7473 kern_type = KERN_TYPE_HMACSHA1_PW;
7474 dgst_size = DGST_SIZE_4_5;
7475 parse_func = hmacsha1_parse_hash;
7476 sort_by_digest = sort_by_digest_4_5;
7477 opti_type = OPTI_TYPE_ZERO_BYTE
7478 | OPTI_TYPE_NOT_ITERATED;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 160: hash_type = HASH_TYPE_SHA1;
7486 salt_type = SALT_TYPE_INTERN;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15;
7491 kern_type = KERN_TYPE_HMACSHA1_SLT;
7492 dgst_size = DGST_SIZE_4_5;
7493 parse_func = hmacsha1_parse_hash;
7494 sort_by_digest = sort_by_digest_4_5;
7495 opti_type = OPTI_TYPE_ZERO_BYTE
7496 | OPTI_TYPE_NOT_ITERATED;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 4;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 1;
7501 break;
7502
7503 case 190: hash_type = HASH_TYPE_SHA1;
7504 salt_type = SALT_TYPE_NONE;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_PT_ADD80
7508 | OPTS_TYPE_PT_ADDBITS15;
7509 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7510 dgst_size = DGST_SIZE_4_5;
7511 parse_func = sha1linkedin_parse_hash;
7512 sort_by_digest = sort_by_digest_4_5;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_PRECOMPUTE_INIT
7515 | OPTI_TYPE_EARLY_SKIP
7516 | OPTI_TYPE_NOT_ITERATED
7517 | OPTI_TYPE_NOT_SALTED;
7518 dgst_pos0 = 0;
7519 dgst_pos1 = 4;
7520 dgst_pos2 = 3;
7521 dgst_pos3 = 2;
7522 break;
7523
7524 case 200: hash_type = HASH_TYPE_MYSQL;
7525 salt_type = SALT_TYPE_NONE;
7526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7527 opts_type = 0;
7528 kern_type = KERN_TYPE_MYSQL;
7529 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7530 parse_func = mysql323_parse_hash;
7531 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7532 opti_type = OPTI_TYPE_ZERO_BYTE;
7533 dgst_pos0 = 0;
7534 dgst_pos1 = 1;
7535 dgst_pos2 = 2;
7536 dgst_pos3 = 3;
7537 break;
7538
7539 case 300: hash_type = HASH_TYPE_SHA1;
7540 salt_type = SALT_TYPE_NONE;
7541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7542 opts_type = OPTS_TYPE_PT_GENERATE_BE
7543 | OPTS_TYPE_PT_ADD80
7544 | OPTS_TYPE_PT_ADDBITS15;
7545 kern_type = KERN_TYPE_MYSQL41;
7546 dgst_size = DGST_SIZE_4_5;
7547 parse_func = sha1_parse_hash;
7548 sort_by_digest = sort_by_digest_4_5;
7549 opti_type = OPTI_TYPE_ZERO_BYTE
7550 | OPTI_TYPE_PRECOMPUTE_INIT
7551 | OPTI_TYPE_PRECOMPUTE_MERKLE
7552 | OPTI_TYPE_EARLY_SKIP
7553 | OPTI_TYPE_NOT_ITERATED
7554 | OPTI_TYPE_NOT_SALTED;
7555 dgst_pos0 = 3;
7556 dgst_pos1 = 4;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 1;
7559 break;
7560
7561 case 400: hash_type = HASH_TYPE_MD5;
7562 salt_type = SALT_TYPE_EMBEDDED;
7563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7565 kern_type = KERN_TYPE_PHPASS;
7566 dgst_size = DGST_SIZE_4_4;
7567 parse_func = phpass_parse_hash;
7568 sort_by_digest = sort_by_digest_4_4;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_SLOW_HASH_SIMD;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 1;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 3;
7575 break;
7576
7577 case 500: hash_type = HASH_TYPE_MD5;
7578 salt_type = SALT_TYPE_EMBEDDED;
7579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7581 kern_type = KERN_TYPE_MD5CRYPT;
7582 dgst_size = DGST_SIZE_4_4;
7583 parse_func = md5crypt_parse_hash;
7584 sort_by_digest = sort_by_digest_4_4;
7585 opti_type = OPTI_TYPE_ZERO_BYTE;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 1;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 3;
7590 break;
7591
7592 case 501: hash_type = HASH_TYPE_MD5;
7593 salt_type = SALT_TYPE_EMBEDDED;
7594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_LE
7596 | OPTS_TYPE_HASH_COPY;
7597 kern_type = KERN_TYPE_MD5CRYPT;
7598 dgst_size = DGST_SIZE_4_4;
7599 parse_func = juniper_parse_hash;
7600 sort_by_digest = sort_by_digest_4_4;
7601 opti_type = OPTI_TYPE_ZERO_BYTE;
7602 dgst_pos0 = 0;
7603 dgst_pos1 = 1;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 3;
7606 break;
7607
7608 case 900: hash_type = HASH_TYPE_MD4;
7609 salt_type = SALT_TYPE_NONE;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_LE
7612 | OPTS_TYPE_PT_ADD80
7613 | OPTS_TYPE_PT_ADDBITS14;
7614 kern_type = KERN_TYPE_MD4;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = md4_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE
7619 | OPTI_TYPE_PRECOMPUTE_INIT
7620 | OPTI_TYPE_PRECOMPUTE_MERKLE
7621 | OPTI_TYPE_MEET_IN_MIDDLE
7622 | OPTI_TYPE_EARLY_SKIP
7623 | OPTI_TYPE_NOT_ITERATED
7624 | OPTI_TYPE_NOT_SALTED
7625 | OPTI_TYPE_RAW_HASH;
7626 dgst_pos0 = 0;
7627 dgst_pos1 = 3;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 1;
7630 break;
7631
7632 case 1000: hash_type = HASH_TYPE_MD4;
7633 salt_type = SALT_TYPE_NONE;
7634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE
7636 | OPTS_TYPE_PT_ADD80
7637 | OPTS_TYPE_PT_ADDBITS14
7638 | OPTS_TYPE_PT_UNICODE;
7639 kern_type = KERN_TYPE_MD4_PWU;
7640 dgst_size = DGST_SIZE_4_4;
7641 parse_func = md4_parse_hash;
7642 sort_by_digest = sort_by_digest_4_4;
7643 opti_type = OPTI_TYPE_ZERO_BYTE
7644 | OPTI_TYPE_PRECOMPUTE_INIT
7645 | OPTI_TYPE_PRECOMPUTE_MERKLE
7646 | OPTI_TYPE_MEET_IN_MIDDLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_NOT_SALTED
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 0;
7652 dgst_pos1 = 3;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 1;
7655 break;
7656
7657 case 1100: hash_type = HASH_TYPE_MD4;
7658 salt_type = SALT_TYPE_INTERN;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_LE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS14
7663 | OPTS_TYPE_PT_UNICODE
7664 | OPTS_TYPE_ST_ADD80
7665 | OPTS_TYPE_ST_UNICODE
7666 | OPTS_TYPE_ST_LOWER;
7667 kern_type = KERN_TYPE_MD44_PWUSLT;
7668 dgst_size = DGST_SIZE_4_4;
7669 parse_func = dcc_parse_hash;
7670 sort_by_digest = sort_by_digest_4_4;
7671 opti_type = OPTI_TYPE_ZERO_BYTE
7672 | OPTI_TYPE_PRECOMPUTE_INIT
7673 | OPTI_TYPE_PRECOMPUTE_MERKLE
7674 | OPTI_TYPE_EARLY_SKIP
7675 | OPTI_TYPE_NOT_ITERATED;
7676 dgst_pos0 = 0;
7677 dgst_pos1 = 3;
7678 dgst_pos2 = 2;
7679 dgst_pos3 = 1;
7680 break;
7681
7682 case 1400: hash_type = HASH_TYPE_SHA256;
7683 salt_type = SALT_TYPE_NONE;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_BE
7686 | OPTS_TYPE_PT_ADD80
7687 | OPTS_TYPE_PT_ADDBITS15;
7688 kern_type = KERN_TYPE_SHA256;
7689 dgst_size = DGST_SIZE_4_8;
7690 parse_func = sha256_parse_hash;
7691 sort_by_digest = sort_by_digest_4_8;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_PRECOMPUTE_INIT
7694 | OPTI_TYPE_PRECOMPUTE_MERKLE
7695 | OPTI_TYPE_EARLY_SKIP
7696 | OPTI_TYPE_NOT_ITERATED
7697 | OPTI_TYPE_NOT_SALTED
7698 | OPTI_TYPE_RAW_HASH;
7699 dgst_pos0 = 3;
7700 dgst_pos1 = 7;
7701 dgst_pos2 = 2;
7702 dgst_pos3 = 6;
7703 break;
7704
7705 case 1410: hash_type = HASH_TYPE_SHA256;
7706 salt_type = SALT_TYPE_INTERN;
7707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7708 opts_type = OPTS_TYPE_PT_GENERATE_BE
7709 | OPTS_TYPE_ST_ADD80
7710 | OPTS_TYPE_ST_ADDBITS15;
7711 kern_type = KERN_TYPE_SHA256_PWSLT;
7712 dgst_size = DGST_SIZE_4_8;
7713 parse_func = sha256s_parse_hash;
7714 sort_by_digest = sort_by_digest_4_8;
7715 opti_type = OPTI_TYPE_ZERO_BYTE
7716 | OPTI_TYPE_PRECOMPUTE_INIT
7717 | OPTI_TYPE_PRECOMPUTE_MERKLE
7718 | OPTI_TYPE_EARLY_SKIP
7719 | OPTI_TYPE_NOT_ITERATED
7720 | OPTI_TYPE_APPENDED_SALT
7721 | OPTI_TYPE_RAW_HASH;
7722 dgst_pos0 = 3;
7723 dgst_pos1 = 7;
7724 dgst_pos2 = 2;
7725 dgst_pos3 = 6;
7726 break;
7727
7728 case 1420: hash_type = HASH_TYPE_SHA256;
7729 salt_type = SALT_TYPE_INTERN;
7730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7731 opts_type = OPTS_TYPE_PT_GENERATE_BE
7732 | OPTS_TYPE_PT_ADD80
7733 | OPTS_TYPE_PT_ADDBITS15;
7734 kern_type = KERN_TYPE_SHA256_SLTPW;
7735 dgst_size = DGST_SIZE_4_8;
7736 parse_func = sha256s_parse_hash;
7737 sort_by_digest = sort_by_digest_4_8;
7738 opti_type = OPTI_TYPE_ZERO_BYTE
7739 | OPTI_TYPE_PRECOMPUTE_INIT
7740 | OPTI_TYPE_PRECOMPUTE_MERKLE
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED
7743 | OPTI_TYPE_PREPENDED_SALT
7744 | OPTI_TYPE_RAW_HASH;
7745 dgst_pos0 = 3;
7746 dgst_pos1 = 7;
7747 dgst_pos2 = 2;
7748 dgst_pos3 = 6;
7749 break;
7750
7751 case 1421: hash_type = HASH_TYPE_SHA256;
7752 salt_type = SALT_TYPE_EMBEDDED;
7753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7754 opts_type = OPTS_TYPE_PT_GENERATE_BE
7755 | OPTS_TYPE_PT_ADD80
7756 | OPTS_TYPE_PT_ADDBITS15;
7757 kern_type = KERN_TYPE_SHA256_SLTPW;
7758 dgst_size = DGST_SIZE_4_8;
7759 parse_func = hmailserver_parse_hash;
7760 sort_by_digest = sort_by_digest_4_8;
7761 opti_type = OPTI_TYPE_ZERO_BYTE
7762 | OPTI_TYPE_PRECOMPUTE_INIT
7763 | OPTI_TYPE_PRECOMPUTE_MERKLE
7764 | OPTI_TYPE_EARLY_SKIP
7765 | OPTI_TYPE_NOT_ITERATED
7766 | OPTI_TYPE_PREPENDED_SALT
7767 | OPTI_TYPE_RAW_HASH;
7768 dgst_pos0 = 3;
7769 dgst_pos1 = 7;
7770 dgst_pos2 = 2;
7771 dgst_pos3 = 6;
7772 break;
7773
7774 case 1430: hash_type = HASH_TYPE_SHA256;
7775 salt_type = SALT_TYPE_INTERN;
7776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7777 opts_type = OPTS_TYPE_PT_GENERATE_BE
7778 | OPTS_TYPE_PT_UNICODE
7779 | OPTS_TYPE_ST_ADD80
7780 | OPTS_TYPE_ST_ADDBITS15;
7781 kern_type = KERN_TYPE_SHA256_PWUSLT;
7782 dgst_size = DGST_SIZE_4_8;
7783 parse_func = sha256s_parse_hash;
7784 sort_by_digest = sort_by_digest_4_8;
7785 opti_type = OPTI_TYPE_ZERO_BYTE
7786 | OPTI_TYPE_PRECOMPUTE_INIT
7787 | OPTI_TYPE_PRECOMPUTE_MERKLE
7788 | OPTI_TYPE_EARLY_SKIP
7789 | OPTI_TYPE_NOT_ITERATED
7790 | OPTI_TYPE_APPENDED_SALT
7791 | OPTI_TYPE_RAW_HASH;
7792 dgst_pos0 = 3;
7793 dgst_pos1 = 7;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 6;
7796 break;
7797
7798 case 1440: hash_type = HASH_TYPE_SHA256;
7799 salt_type = SALT_TYPE_INTERN;
7800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_BE
7802 | OPTS_TYPE_PT_ADD80
7803 | OPTS_TYPE_PT_ADDBITS15
7804 | OPTS_TYPE_PT_UNICODE;
7805 kern_type = KERN_TYPE_SHA256_SLTPWU;
7806 dgst_size = DGST_SIZE_4_8;
7807 parse_func = sha256s_parse_hash;
7808 sort_by_digest = sort_by_digest_4_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED
7814 | OPTI_TYPE_PREPENDED_SALT
7815 | OPTI_TYPE_RAW_HASH;
7816 dgst_pos0 = 3;
7817 dgst_pos1 = 7;
7818 dgst_pos2 = 2;
7819 dgst_pos3 = 6;
7820 break;
7821
7822 case 1441: hash_type = HASH_TYPE_SHA256;
7823 salt_type = SALT_TYPE_EMBEDDED;
7824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7825 opts_type = OPTS_TYPE_PT_GENERATE_BE
7826 | OPTS_TYPE_PT_ADD80
7827 | OPTS_TYPE_PT_ADDBITS15
7828 | OPTS_TYPE_PT_UNICODE
7829 | OPTS_TYPE_ST_BASE64;
7830 kern_type = KERN_TYPE_SHA256_SLTPWU;
7831 dgst_size = DGST_SIZE_4_8;
7832 parse_func = episerver4_parse_hash;
7833 sort_by_digest = sort_by_digest_4_8;
7834 opti_type = OPTI_TYPE_ZERO_BYTE
7835 | OPTI_TYPE_PRECOMPUTE_INIT
7836 | OPTI_TYPE_PRECOMPUTE_MERKLE
7837 | OPTI_TYPE_EARLY_SKIP
7838 | OPTI_TYPE_NOT_ITERATED
7839 | OPTI_TYPE_PREPENDED_SALT
7840 | OPTI_TYPE_RAW_HASH;
7841 dgst_pos0 = 3;
7842 dgst_pos1 = 7;
7843 dgst_pos2 = 2;
7844 dgst_pos3 = 6;
7845 break;
7846
7847 case 1450: hash_type = HASH_TYPE_SHA256;
7848 salt_type = SALT_TYPE_INTERN;
7849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7850 opts_type = OPTS_TYPE_PT_GENERATE_BE
7851 | OPTS_TYPE_ST_ADD80;
7852 kern_type = KERN_TYPE_HMACSHA256_PW;
7853 dgst_size = DGST_SIZE_4_8;
7854 parse_func = hmacsha256_parse_hash;
7855 sort_by_digest = sort_by_digest_4_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_NOT_ITERATED;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 7;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 6;
7862 break;
7863
7864 case 1460: hash_type = HASH_TYPE_SHA256;
7865 salt_type = SALT_TYPE_INTERN;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_ADD80
7869 | OPTS_TYPE_PT_ADDBITS15;
7870 kern_type = KERN_TYPE_HMACSHA256_SLT;
7871 dgst_size = DGST_SIZE_4_8;
7872 parse_func = hmacsha256_parse_hash;
7873 sort_by_digest = sort_by_digest_4_8;
7874 opti_type = OPTI_TYPE_ZERO_BYTE
7875 | OPTI_TYPE_NOT_ITERATED;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 7;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 6;
7880 break;
7881
7882 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7883 salt_type = SALT_TYPE_EMBEDDED;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_LE
7886 | OPTS_TYPE_PT_BITSLICE;
7887 kern_type = KERN_TYPE_DESCRYPT;
7888 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7889 parse_func = descrypt_parse_hash;
7890 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7891 opti_type = OPTI_TYPE_ZERO_BYTE
7892 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7893 dgst_pos0 = 0;
7894 dgst_pos1 = 1;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 3;
7897 break;
7898
7899 case 1600: hash_type = HASH_TYPE_MD5;
7900 salt_type = SALT_TYPE_EMBEDDED;
7901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7903 kern_type = KERN_TYPE_APR1CRYPT;
7904 dgst_size = DGST_SIZE_4_4;
7905 parse_func = md5apr1_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4;
7907 opti_type = OPTI_TYPE_ZERO_BYTE;
7908 dgst_pos0 = 0;
7909 dgst_pos1 = 1;
7910 dgst_pos2 = 2;
7911 dgst_pos3 = 3;
7912 break;
7913
7914 case 1700: hash_type = HASH_TYPE_SHA512;
7915 salt_type = SALT_TYPE_NONE;
7916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7917 opts_type = OPTS_TYPE_PT_GENERATE_BE
7918 | OPTS_TYPE_PT_ADD80
7919 | OPTS_TYPE_PT_ADDBITS15;
7920 kern_type = KERN_TYPE_SHA512;
7921 dgst_size = DGST_SIZE_8_8;
7922 parse_func = sha512_parse_hash;
7923 sort_by_digest = sort_by_digest_8_8;
7924 opti_type = OPTI_TYPE_ZERO_BYTE
7925 | OPTI_TYPE_PRECOMPUTE_INIT
7926 | OPTI_TYPE_PRECOMPUTE_MERKLE
7927 | OPTI_TYPE_EARLY_SKIP
7928 | OPTI_TYPE_NOT_ITERATED
7929 | OPTI_TYPE_NOT_SALTED
7930 | OPTI_TYPE_USES_BITS_64
7931 | OPTI_TYPE_RAW_HASH;
7932 dgst_pos0 = 14;
7933 dgst_pos1 = 15;
7934 dgst_pos2 = 6;
7935 dgst_pos3 = 7;
7936 break;
7937
7938 case 1710: hash_type = HASH_TYPE_SHA512;
7939 salt_type = SALT_TYPE_INTERN;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_BE
7942 | OPTS_TYPE_ST_ADD80
7943 | OPTS_TYPE_ST_ADDBITS15;
7944 kern_type = KERN_TYPE_SHA512_PWSLT;
7945 dgst_size = DGST_SIZE_8_8;
7946 parse_func = sha512s_parse_hash;
7947 sort_by_digest = sort_by_digest_8_8;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_APPENDED_SALT
7954 | OPTI_TYPE_USES_BITS_64
7955 | OPTI_TYPE_RAW_HASH;
7956 dgst_pos0 = 14;
7957 dgst_pos1 = 15;
7958 dgst_pos2 = 6;
7959 dgst_pos3 = 7;
7960 break;
7961
7962 case 1711: hash_type = HASH_TYPE_SHA512;
7963 salt_type = SALT_TYPE_EMBEDDED;
7964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7965 opts_type = OPTS_TYPE_PT_GENERATE_BE
7966 | OPTS_TYPE_ST_ADD80
7967 | OPTS_TYPE_ST_ADDBITS15;
7968 kern_type = KERN_TYPE_SHA512_PWSLT;
7969 dgst_size = DGST_SIZE_8_8;
7970 parse_func = sha512b64s_parse_hash;
7971 sort_by_digest = sort_by_digest_8_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_APPENDED_SALT
7978 | OPTI_TYPE_USES_BITS_64
7979 | OPTI_TYPE_RAW_HASH;
7980 dgst_pos0 = 14;
7981 dgst_pos1 = 15;
7982 dgst_pos2 = 6;
7983 dgst_pos3 = 7;
7984 break;
7985
7986 case 1720: hash_type = HASH_TYPE_SHA512;
7987 salt_type = SALT_TYPE_INTERN;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_PT_ADD80
7991 | OPTS_TYPE_PT_ADDBITS15;
7992 kern_type = KERN_TYPE_SHA512_SLTPW;
7993 dgst_size = DGST_SIZE_8_8;
7994 parse_func = sha512s_parse_hash;
7995 sort_by_digest = sort_by_digest_8_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_PREPENDED_SALT
8002 | OPTI_TYPE_USES_BITS_64
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 14;
8005 dgst_pos1 = 15;
8006 dgst_pos2 = 6;
8007 dgst_pos3 = 7;
8008 break;
8009
8010 case 1722: hash_type = HASH_TYPE_SHA512;
8011 salt_type = SALT_TYPE_EMBEDDED;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_PT_ADD80
8015 | OPTS_TYPE_PT_ADDBITS15
8016 | OPTS_TYPE_ST_HEX;
8017 kern_type = KERN_TYPE_SHA512_SLTPW;
8018 dgst_size = DGST_SIZE_8_8;
8019 parse_func = osx512_parse_hash;
8020 sort_by_digest = sort_by_digest_8_8;
8021 opti_type = OPTI_TYPE_ZERO_BYTE
8022 | OPTI_TYPE_PRECOMPUTE_INIT
8023 | OPTI_TYPE_PRECOMPUTE_MERKLE
8024 | OPTI_TYPE_EARLY_SKIP
8025 | OPTI_TYPE_NOT_ITERATED
8026 | OPTI_TYPE_PREPENDED_SALT
8027 | OPTI_TYPE_USES_BITS_64
8028 | OPTI_TYPE_RAW_HASH;
8029 dgst_pos0 = 14;
8030 dgst_pos1 = 15;
8031 dgst_pos2 = 6;
8032 dgst_pos3 = 7;
8033 break;
8034
8035 case 1730: hash_type = HASH_TYPE_SHA512;
8036 salt_type = SALT_TYPE_INTERN;
8037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8038 opts_type = OPTS_TYPE_PT_GENERATE_BE
8039 | OPTS_TYPE_PT_UNICODE
8040 | OPTS_TYPE_ST_ADD80
8041 | OPTS_TYPE_ST_ADDBITS15;
8042 kern_type = KERN_TYPE_SHA512_PWSLTU;
8043 dgst_size = DGST_SIZE_8_8;
8044 parse_func = sha512s_parse_hash;
8045 sort_by_digest = sort_by_digest_8_8;
8046 opti_type = OPTI_TYPE_ZERO_BYTE
8047 | OPTI_TYPE_PRECOMPUTE_INIT
8048 | OPTI_TYPE_PRECOMPUTE_MERKLE
8049 | OPTI_TYPE_EARLY_SKIP
8050 | OPTI_TYPE_NOT_ITERATED
8051 | OPTI_TYPE_APPENDED_SALT
8052 | OPTI_TYPE_USES_BITS_64
8053 | OPTI_TYPE_RAW_HASH;
8054 dgst_pos0 = 14;
8055 dgst_pos1 = 15;
8056 dgst_pos2 = 6;
8057 dgst_pos3 = 7;
8058 break;
8059
8060 case 1731: hash_type = HASH_TYPE_SHA512;
8061 salt_type = SALT_TYPE_EMBEDDED;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_BE
8064 | OPTS_TYPE_PT_UNICODE
8065 | OPTS_TYPE_ST_ADD80
8066 | OPTS_TYPE_ST_ADDBITS15
8067 | OPTS_TYPE_ST_HEX;
8068 kern_type = KERN_TYPE_SHA512_PWSLTU;
8069 dgst_size = DGST_SIZE_8_8;
8070 parse_func = mssql2012_parse_hash;
8071 sort_by_digest = sort_by_digest_8_8;
8072 opti_type = OPTI_TYPE_ZERO_BYTE
8073 | OPTI_TYPE_PRECOMPUTE_INIT
8074 | OPTI_TYPE_PRECOMPUTE_MERKLE
8075 | OPTI_TYPE_EARLY_SKIP
8076 | OPTI_TYPE_NOT_ITERATED
8077 | OPTI_TYPE_APPENDED_SALT
8078 | OPTI_TYPE_USES_BITS_64
8079 | OPTI_TYPE_RAW_HASH;
8080 dgst_pos0 = 14;
8081 dgst_pos1 = 15;
8082 dgst_pos2 = 6;
8083 dgst_pos3 = 7;
8084 break;
8085
8086 case 1740: hash_type = HASH_TYPE_SHA512;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_BE
8090 | OPTS_TYPE_PT_ADD80
8091 | OPTS_TYPE_PT_ADDBITS15
8092 | OPTS_TYPE_PT_UNICODE;
8093 kern_type = KERN_TYPE_SHA512_SLTPWU;
8094 dgst_size = DGST_SIZE_8_8;
8095 parse_func = sha512s_parse_hash;
8096 sort_by_digest = sort_by_digest_8_8;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_PRECOMPUTE_INIT
8099 | OPTI_TYPE_PRECOMPUTE_MERKLE
8100 | OPTI_TYPE_EARLY_SKIP
8101 | OPTI_TYPE_NOT_ITERATED
8102 | OPTI_TYPE_PREPENDED_SALT
8103 | OPTI_TYPE_USES_BITS_64
8104 | OPTI_TYPE_RAW_HASH;
8105 dgst_pos0 = 14;
8106 dgst_pos1 = 15;
8107 dgst_pos2 = 6;
8108 dgst_pos3 = 7;
8109 break;
8110
8111 case 1750: hash_type = HASH_TYPE_SHA512;
8112 salt_type = SALT_TYPE_INTERN;
8113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8114 opts_type = OPTS_TYPE_PT_GENERATE_BE
8115 | OPTS_TYPE_ST_ADD80;
8116 kern_type = KERN_TYPE_HMACSHA512_PW;
8117 dgst_size = DGST_SIZE_8_8;
8118 parse_func = hmacsha512_parse_hash;
8119 sort_by_digest = sort_by_digest_8_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_USES_BITS_64
8122 | OPTI_TYPE_NOT_ITERATED;
8123 dgst_pos0 = 14;
8124 dgst_pos1 = 15;
8125 dgst_pos2 = 6;
8126 dgst_pos3 = 7;
8127 break;
8128
8129 case 1760: hash_type = HASH_TYPE_SHA512;
8130 salt_type = SALT_TYPE_INTERN;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_BE
8133 | OPTS_TYPE_PT_ADD80
8134 | OPTS_TYPE_PT_ADDBITS15;
8135 kern_type = KERN_TYPE_HMACSHA512_SLT;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = hmacsha512_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_USES_BITS_64
8141 | OPTI_TYPE_NOT_ITERATED;
8142 dgst_pos0 = 14;
8143 dgst_pos1 = 15;
8144 dgst_pos2 = 6;
8145 dgst_pos3 = 7;
8146 break;
8147
8148 case 1800: hash_type = HASH_TYPE_SHA512;
8149 salt_type = SALT_TYPE_EMBEDDED;
8150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8152 kern_type = KERN_TYPE_SHA512CRYPT;
8153 dgst_size = DGST_SIZE_8_8;
8154 parse_func = sha512crypt_parse_hash;
8155 sort_by_digest = sort_by_digest_8_8;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_USES_BITS_64;
8158 dgst_pos0 = 0;
8159 dgst_pos1 = 1;
8160 dgst_pos2 = 2;
8161 dgst_pos3 = 3;
8162 break;
8163
8164 case 2100: hash_type = HASH_TYPE_DCC2;
8165 salt_type = SALT_TYPE_EMBEDDED;
8166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_ST_LOWER
8169 | OPTS_TYPE_ST_UNICODE;
8170 kern_type = KERN_TYPE_DCC2;
8171 dgst_size = DGST_SIZE_4_4;
8172 parse_func = dcc2_parse_hash;
8173 sort_by_digest = sort_by_digest_4_4;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_SLOW_HASH_SIMD;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 1;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 3;
8180 break;
8181
8182 case 2400: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_NONE;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8186 kern_type = KERN_TYPE_MD5PIX;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = md5pix_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP
8194 | OPTI_TYPE_NOT_ITERATED
8195 | OPTI_TYPE_NOT_SALTED;
8196 dgst_pos0 = 0;
8197 dgst_pos1 = 3;
8198 dgst_pos2 = 2;
8199 dgst_pos3 = 1;
8200 break;
8201
8202 case 2410: hash_type = HASH_TYPE_MD5;
8203 salt_type = SALT_TYPE_INTERN;
8204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8206 kern_type = KERN_TYPE_MD5ASA;
8207 dgst_size = DGST_SIZE_4_4;
8208 parse_func = md5asa_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_PRECOMPUTE_INIT
8212 | OPTI_TYPE_PRECOMPUTE_MERKLE
8213 | OPTI_TYPE_EARLY_SKIP
8214 | OPTI_TYPE_NOT_ITERATED;
8215 dgst_pos0 = 0;
8216 dgst_pos1 = 3;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 1;
8219 break;
8220
8221 case 2500: hash_type = HASH_TYPE_WPA;
8222 salt_type = SALT_TYPE_EMBEDDED;
8223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8225 kern_type = KERN_TYPE_WPA;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = wpa_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_SLOW_HASH_SIMD;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 1;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 3;
8235 break;
8236
8237 case 2600: hash_type = HASH_TYPE_MD5;
8238 salt_type = SALT_TYPE_VIRTUAL;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS14
8243 | OPTS_TYPE_ST_ADD80;
8244 kern_type = KERN_TYPE_MD55_PWSLT1;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = md5md5_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_EARLY_SKIP;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 2611: hash_type = HASH_TYPE_MD5;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE
8262 | OPTS_TYPE_PT_ADD80
8263 | OPTS_TYPE_PT_ADDBITS14
8264 | OPTS_TYPE_ST_ADD80;
8265 kern_type = KERN_TYPE_MD55_PWSLT1;
8266 dgst_size = DGST_SIZE_4_4;
8267 parse_func = vb3_parse_hash;
8268 sort_by_digest = sort_by_digest_4_4;
8269 opti_type = OPTI_TYPE_ZERO_BYTE
8270 | OPTI_TYPE_PRECOMPUTE_INIT
8271 | OPTI_TYPE_PRECOMPUTE_MERKLE
8272 | OPTI_TYPE_EARLY_SKIP;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 2612: hash_type = HASH_TYPE_MD5;
8280 salt_type = SALT_TYPE_EMBEDDED;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_LE
8283 | OPTS_TYPE_PT_ADD80
8284 | OPTS_TYPE_PT_ADDBITS14
8285 | OPTS_TYPE_ST_ADD80
8286 | OPTS_TYPE_ST_HEX;
8287 kern_type = KERN_TYPE_MD55_PWSLT1;
8288 dgst_size = DGST_SIZE_4_4;
8289 parse_func = phps_parse_hash;
8290 sort_by_digest = sort_by_digest_4_4;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_PRECOMPUTE_INIT
8293 | OPTI_TYPE_PRECOMPUTE_MERKLE
8294 | OPTI_TYPE_EARLY_SKIP;
8295 dgst_pos0 = 0;
8296 dgst_pos1 = 3;
8297 dgst_pos2 = 2;
8298 dgst_pos3 = 1;
8299 break;
8300
8301 case 2711: hash_type = HASH_TYPE_MD5;
8302 salt_type = SALT_TYPE_INTERN;
8303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8304 opts_type = OPTS_TYPE_PT_GENERATE_LE
8305 | OPTS_TYPE_PT_ADD80
8306 | OPTS_TYPE_PT_ADDBITS14
8307 | OPTS_TYPE_ST_ADD80;
8308 kern_type = KERN_TYPE_MD55_PWSLT2;
8309 dgst_size = DGST_SIZE_4_4;
8310 parse_func = vb30_parse_hash;
8311 sort_by_digest = sort_by_digest_4_4;
8312 opti_type = OPTI_TYPE_ZERO_BYTE
8313 | OPTI_TYPE_PRECOMPUTE_INIT
8314 | OPTI_TYPE_EARLY_SKIP;
8315 dgst_pos0 = 0;
8316 dgst_pos1 = 3;
8317 dgst_pos2 = 2;
8318 dgst_pos3 = 1;
8319 break;
8320
8321 case 2811: hash_type = HASH_TYPE_MD5;
8322 salt_type = SALT_TYPE_INTERN;
8323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_LE
8325 | OPTS_TYPE_PT_ADD80
8326 | OPTS_TYPE_PT_ADDBITS14;
8327 kern_type = KERN_TYPE_MD55_SLTPW;
8328 dgst_size = DGST_SIZE_4_4;
8329 parse_func = ipb2_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_INIT
8333 | OPTI_TYPE_EARLY_SKIP;
8334 dgst_pos0 = 0;
8335 dgst_pos1 = 3;
8336 dgst_pos2 = 2;
8337 dgst_pos3 = 1;
8338 break;
8339
8340 case 3000: hash_type = HASH_TYPE_LM;
8341 salt_type = SALT_TYPE_NONE;
8342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8343 opts_type = OPTS_TYPE_PT_GENERATE_LE
8344 | OPTS_TYPE_PT_UPPER
8345 | OPTS_TYPE_PT_BITSLICE;
8346 kern_type = KERN_TYPE_LM;
8347 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8348 parse_func = lm_parse_hash;
8349 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8350 opti_type = OPTI_TYPE_ZERO_BYTE
8351 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 1;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 3;
8356 break;
8357
8358 case 3100: hash_type = HASH_TYPE_ORACLEH;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_PT_UPPER
8363 | OPTS_TYPE_ST_UPPER;
8364 kern_type = KERN_TYPE_ORACLEH;
8365 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8366 parse_func = oracleh_parse_hash;
8367 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8368 opti_type = OPTI_TYPE_ZERO_BYTE;
8369 dgst_pos0 = 0;
8370 dgst_pos1 = 1;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 3;
8373 break;
8374
8375 case 3200: hash_type = HASH_TYPE_BCRYPT;
8376 salt_type = SALT_TYPE_EMBEDDED;
8377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_LE
8379 | OPTS_TYPE_ST_GENERATE_LE;
8380 kern_type = KERN_TYPE_BCRYPT;
8381 dgst_size = DGST_SIZE_4_6;
8382 parse_func = bcrypt_parse_hash;
8383 sort_by_digest = sort_by_digest_4_6;
8384 opti_type = OPTI_TYPE_ZERO_BYTE;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 3710: hash_type = HASH_TYPE_MD5;
8392 salt_type = SALT_TYPE_INTERN;
8393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE
8395 | OPTS_TYPE_PT_ADD80
8396 | OPTS_TYPE_PT_ADDBITS14;
8397 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = md5s_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE
8402 | OPTI_TYPE_PRECOMPUTE_INIT
8403 | OPTI_TYPE_PRECOMPUTE_MERKLE
8404 | OPTI_TYPE_EARLY_SKIP;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 3;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 1;
8409 break;
8410
8411 case 3711: hash_type = HASH_TYPE_MD5;
8412 salt_type = SALT_TYPE_EMBEDDED;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_ADD80
8416 | OPTS_TYPE_PT_ADDBITS14;
8417 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8418 dgst_size = DGST_SIZE_4_4;
8419 parse_func = mediawiki_b_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4;
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_INIT
8423 | OPTI_TYPE_PRECOMPUTE_MERKLE
8424 | OPTI_TYPE_EARLY_SKIP;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 3;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 1;
8429 break;
8430
8431 case 3800: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_INTERN;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_ST_ADDBITS14;
8436 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8437 dgst_size = DGST_SIZE_4_4;
8438 parse_func = md5s_parse_hash;
8439 sort_by_digest = sort_by_digest_4_4;
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_RAW_HASH;
8446 dgst_pos0 = 0;
8447 dgst_pos1 = 3;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 1;
8450 break;
8451
8452 case 4300: hash_type = HASH_TYPE_MD5;
8453 salt_type = SALT_TYPE_VIRTUAL;
8454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_LE
8456 | OPTS_TYPE_PT_ADD80
8457 | OPTS_TYPE_PT_ADDBITS14
8458 | OPTS_TYPE_ST_ADD80;
8459 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8460 dgst_size = DGST_SIZE_4_4;
8461 parse_func = md5md5_parse_hash;
8462 sort_by_digest = sort_by_digest_4_4;
8463 opti_type = OPTI_TYPE_ZERO_BYTE
8464 | OPTI_TYPE_PRECOMPUTE_INIT
8465 | OPTI_TYPE_PRECOMPUTE_MERKLE
8466 | OPTI_TYPE_EARLY_SKIP;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 3;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 1;
8471 break;
8472
8473
8474 case 4400: hash_type = HASH_TYPE_MD5;
8475 salt_type = SALT_TYPE_NONE;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_BE
8478 | OPTS_TYPE_PT_ADD80
8479 | OPTS_TYPE_PT_ADDBITS15;
8480 kern_type = KERN_TYPE_MD5_SHA1;
8481 dgst_size = DGST_SIZE_4_4;
8482 parse_func = md5_parse_hash;
8483 sort_by_digest = sort_by_digest_4_4;
8484 opti_type = OPTI_TYPE_ZERO_BYTE
8485 | OPTI_TYPE_PRECOMPUTE_INIT
8486 | OPTI_TYPE_PRECOMPUTE_MERKLE
8487 | OPTI_TYPE_EARLY_SKIP
8488 | OPTI_TYPE_NOT_ITERATED
8489 | OPTI_TYPE_NOT_SALTED
8490 | OPTI_TYPE_RAW_HASH;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 3;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 4500: hash_type = HASH_TYPE_SHA1;
8498 salt_type = SALT_TYPE_NONE;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_BE
8501 | OPTS_TYPE_PT_ADD80
8502 | OPTS_TYPE_PT_ADDBITS15;
8503 kern_type = KERN_TYPE_SHA11;
8504 dgst_size = DGST_SIZE_4_5;
8505 parse_func = sha1_parse_hash;
8506 sort_by_digest = sort_by_digest_4_5;
8507 opti_type = OPTI_TYPE_ZERO_BYTE
8508 | OPTI_TYPE_PRECOMPUTE_INIT
8509 | OPTI_TYPE_PRECOMPUTE_MERKLE
8510 | OPTI_TYPE_EARLY_SKIP
8511 | OPTI_TYPE_NOT_SALTED;
8512 dgst_pos0 = 3;
8513 dgst_pos1 = 4;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 1;
8516 break;
8517
8518 case 4700: hash_type = HASH_TYPE_SHA1;
8519 salt_type = SALT_TYPE_NONE;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE
8522 | OPTS_TYPE_PT_ADD80
8523 | OPTS_TYPE_PT_ADDBITS14;
8524 kern_type = KERN_TYPE_SHA1_MD5;
8525 dgst_size = DGST_SIZE_4_5;
8526 parse_func = sha1_parse_hash;
8527 sort_by_digest = sort_by_digest_4_5;
8528 opti_type = OPTI_TYPE_ZERO_BYTE
8529 | OPTI_TYPE_PRECOMPUTE_INIT
8530 | OPTI_TYPE_PRECOMPUTE_MERKLE
8531 | OPTI_TYPE_EARLY_SKIP
8532 | OPTI_TYPE_NOT_ITERATED
8533 | OPTI_TYPE_NOT_SALTED
8534 | OPTI_TYPE_RAW_HASH;
8535 dgst_pos0 = 3;
8536 dgst_pos1 = 4;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 1;
8539 break;
8540
8541 case 4800: hash_type = HASH_TYPE_MD5;
8542 salt_type = SALT_TYPE_EMBEDDED;
8543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE
8545 | OPTS_TYPE_PT_ADDBITS14;
8546 kern_type = KERN_TYPE_MD5_CHAP;
8547 dgst_size = DGST_SIZE_4_4;
8548 parse_func = chap_parse_hash;
8549 sort_by_digest = sort_by_digest_4_4;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_PRECOMPUTE_INIT
8552 | OPTI_TYPE_PRECOMPUTE_MERKLE
8553 | OPTI_TYPE_MEET_IN_MIDDLE
8554 | OPTI_TYPE_EARLY_SKIP
8555 | OPTI_TYPE_NOT_ITERATED
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 3;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 4900: hash_type = HASH_TYPE_SHA1;
8564 salt_type = SALT_TYPE_INTERN;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8567 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8568 dgst_size = DGST_SIZE_4_5;
8569 parse_func = sha1s_parse_hash;
8570 sort_by_digest = sort_by_digest_4_5;
8571 opti_type = OPTI_TYPE_ZERO_BYTE
8572 | OPTI_TYPE_PRECOMPUTE_INIT
8573 | OPTI_TYPE_PRECOMPUTE_MERKLE
8574 | OPTI_TYPE_EARLY_SKIP;
8575 dgst_pos0 = 3;
8576 dgst_pos1 = 4;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 1;
8579 break;
8580
8581 case 5000: hash_type = HASH_TYPE_KECCAK;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_ADD01;
8586 kern_type = KERN_TYPE_KECCAK;
8587 dgst_size = DGST_SIZE_8_25;
8588 parse_func = keccak_parse_hash;
8589 sort_by_digest = sort_by_digest_8_25;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_USES_BITS_64
8592 | OPTI_TYPE_RAW_HASH;
8593 dgst_pos0 = 2;
8594 dgst_pos1 = 3;
8595 dgst_pos2 = 4;
8596 dgst_pos3 = 5;
8597 break;
8598
8599 case 5100: hash_type = HASH_TYPE_MD5H;
8600 salt_type = SALT_TYPE_NONE;
8601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE
8603 | OPTS_TYPE_PT_ADD80
8604 | OPTS_TYPE_PT_ADDBITS14;
8605 kern_type = KERN_TYPE_MD5H;
8606 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8607 parse_func = md5half_parse_hash;
8608 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8609 opti_type = OPTI_TYPE_ZERO_BYTE
8610 | OPTI_TYPE_RAW_HASH;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 5200: hash_type = HASH_TYPE_SHA256;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8621 kern_type = KERN_TYPE_PSAFE3;
8622 dgst_size = DGST_SIZE_4_8;
8623 parse_func = psafe3_parse_hash;
8624 sort_by_digest = sort_by_digest_4_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 5300: hash_type = HASH_TYPE_MD5;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_ST_ADD80;
8637 kern_type = KERN_TYPE_IKEPSK_MD5;
8638 dgst_size = DGST_SIZE_4_4;
8639 parse_func = ikepsk_md5_parse_hash;
8640 sort_by_digest = sort_by_digest_4_4;
8641 opti_type = OPTI_TYPE_ZERO_BYTE;
8642 dgst_pos0 = 0;
8643 dgst_pos1 = 3;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 1;
8646 break;
8647
8648 case 5400: hash_type = HASH_TYPE_SHA1;
8649 salt_type = SALT_TYPE_EMBEDDED;
8650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8651 opts_type = OPTS_TYPE_PT_GENERATE_BE
8652 | OPTS_TYPE_ST_ADD80;
8653 kern_type = KERN_TYPE_IKEPSK_SHA1;
8654 dgst_size = DGST_SIZE_4_5;
8655 parse_func = ikepsk_sha1_parse_hash;
8656 sort_by_digest = sort_by_digest_4_5;
8657 opti_type = OPTI_TYPE_ZERO_BYTE;
8658 dgst_pos0 = 3;
8659 dgst_pos1 = 4;
8660 dgst_pos2 = 2;
8661 dgst_pos3 = 1;
8662 break;
8663
8664 case 5500: hash_type = HASH_TYPE_NETNTLM;
8665 salt_type = SALT_TYPE_EMBEDDED;
8666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8667 opts_type = OPTS_TYPE_PT_GENERATE_LE
8668 | OPTS_TYPE_PT_ADD80
8669 | OPTS_TYPE_PT_ADDBITS14
8670 | OPTS_TYPE_PT_UNICODE
8671 | OPTS_TYPE_ST_HEX;
8672 kern_type = KERN_TYPE_NETNTLMv1;
8673 dgst_size = DGST_SIZE_4_4;
8674 parse_func = netntlmv1_parse_hash;
8675 sort_by_digest = sort_by_digest_4_4;
8676 opti_type = OPTI_TYPE_ZERO_BYTE
8677 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8678 dgst_pos0 = 0;
8679 dgst_pos1 = 1;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 3;
8682 break;
8683
8684 case 5600: hash_type = HASH_TYPE_MD5;
8685 salt_type = SALT_TYPE_EMBEDDED;
8686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8687 opts_type = OPTS_TYPE_PT_GENERATE_LE
8688 | OPTS_TYPE_PT_ADD80
8689 | OPTS_TYPE_PT_ADDBITS14
8690 | OPTS_TYPE_PT_UNICODE;
8691 kern_type = KERN_TYPE_NETNTLMv2;
8692 dgst_size = DGST_SIZE_4_4;
8693 parse_func = netntlmv2_parse_hash;
8694 sort_by_digest = sort_by_digest_4_4;
8695 opti_type = OPTI_TYPE_ZERO_BYTE;
8696 dgst_pos0 = 0;
8697 dgst_pos1 = 3;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 1;
8700 break;
8701
8702 case 5700: hash_type = HASH_TYPE_SHA256;
8703 salt_type = SALT_TYPE_NONE;
8704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_BE
8706 | OPTS_TYPE_PT_ADD80
8707 | OPTS_TYPE_PT_ADDBITS15;
8708 kern_type = KERN_TYPE_SHA256;
8709 dgst_size = DGST_SIZE_4_8;
8710 parse_func = cisco4_parse_hash;
8711 sort_by_digest = sort_by_digest_4_8;
8712 opti_type = OPTI_TYPE_ZERO_BYTE
8713 | OPTI_TYPE_PRECOMPUTE_INIT
8714 | OPTI_TYPE_PRECOMPUTE_MERKLE
8715 | OPTI_TYPE_EARLY_SKIP
8716 | OPTI_TYPE_NOT_ITERATED
8717 | OPTI_TYPE_NOT_SALTED
8718 | OPTI_TYPE_RAW_HASH;
8719 dgst_pos0 = 3;
8720 dgst_pos1 = 7;
8721 dgst_pos2 = 2;
8722 dgst_pos3 = 6;
8723 break;
8724
8725 case 5800: hash_type = HASH_TYPE_SHA1;
8726 salt_type = SALT_TYPE_INTERN;
8727 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8728 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8729 | OPTS_TYPE_ST_ADD80;
8730 kern_type = KERN_TYPE_ANDROIDPIN;
8731 dgst_size = DGST_SIZE_4_5;
8732 parse_func = androidpin_parse_hash;
8733 sort_by_digest = sort_by_digest_4_5;
8734 opti_type = OPTI_TYPE_ZERO_BYTE;
8735 dgst_pos0 = 0;
8736 dgst_pos1 = 1;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 3;
8739 break;
8740
8741 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8742 salt_type = SALT_TYPE_NONE;
8743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE
8745 | OPTS_TYPE_PT_ADD80;
8746 kern_type = KERN_TYPE_RIPEMD160;
8747 dgst_size = DGST_SIZE_4_5;
8748 parse_func = ripemd160_parse_hash;
8749 sort_by_digest = sort_by_digest_4_5;
8750 opti_type = OPTI_TYPE_ZERO_BYTE;
8751 dgst_pos0 = 0;
8752 dgst_pos1 = 1;
8753 dgst_pos2 = 2;
8754 dgst_pos3 = 3;
8755 break;
8756
8757 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8758 salt_type = SALT_TYPE_NONE;
8759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_BE
8761 | OPTS_TYPE_PT_ADD80;
8762 kern_type = KERN_TYPE_WHIRLPOOL;
8763 dgst_size = DGST_SIZE_4_16;
8764 parse_func = whirlpool_parse_hash;
8765 sort_by_digest = sort_by_digest_4_16;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8777 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8778 dgst_size = DGST_SIZE_4_5;
8779 parse_func = truecrypt_parse_hash_2k;
8780 sort_by_digest = sort_by_digest_4_5;
8781 opti_type = OPTI_TYPE_ZERO_BYTE;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8792 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8793 dgst_size = DGST_SIZE_4_5;
8794 parse_func = truecrypt_parse_hash_2k;
8795 sort_by_digest = sort_by_digest_4_5;
8796 opti_type = OPTI_TYPE_ZERO_BYTE;
8797 dgst_pos0 = 0;
8798 dgst_pos1 = 1;
8799 dgst_pos2 = 2;
8800 dgst_pos3 = 3;
8801 break;
8802
8803 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8804 salt_type = SALT_TYPE_EMBEDDED;
8805 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8807 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8808 dgst_size = DGST_SIZE_4_5;
8809 parse_func = truecrypt_parse_hash_2k;
8810 sort_by_digest = sort_by_digest_4_5;
8811 opti_type = OPTI_TYPE_ZERO_BYTE;
8812 dgst_pos0 = 0;
8813 dgst_pos1 = 1;
8814 dgst_pos2 = 2;
8815 dgst_pos3 = 3;
8816 break;
8817
8818 case 6221: hash_type = HASH_TYPE_SHA512;
8819 salt_type = SALT_TYPE_EMBEDDED;
8820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8821 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8822 kern_type = KERN_TYPE_TCSHA512_XTS512;
8823 dgst_size = DGST_SIZE_8_8;
8824 parse_func = truecrypt_parse_hash_1k;
8825 sort_by_digest = sort_by_digest_8_8;
8826 opti_type = OPTI_TYPE_ZERO_BYTE
8827 | OPTI_TYPE_USES_BITS_64;
8828 dgst_pos0 = 0;
8829 dgst_pos1 = 1;
8830 dgst_pos2 = 2;
8831 dgst_pos3 = 3;
8832 break;
8833
8834 case 6222: hash_type = HASH_TYPE_SHA512;
8835 salt_type = SALT_TYPE_EMBEDDED;
8836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8838 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8839 dgst_size = DGST_SIZE_8_8;
8840 parse_func = truecrypt_parse_hash_1k;
8841 sort_by_digest = sort_by_digest_8_8;
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_USES_BITS_64;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 6223: hash_type = HASH_TYPE_SHA512;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8854 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8855 dgst_size = DGST_SIZE_8_8;
8856 parse_func = truecrypt_parse_hash_1k;
8857 sort_by_digest = sort_by_digest_8_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE
8859 | OPTI_TYPE_USES_BITS_64;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 1;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 3;
8864 break;
8865
8866 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8867 salt_type = SALT_TYPE_EMBEDDED;
8868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8870 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8871 dgst_size = DGST_SIZE_4_8;
8872 parse_func = truecrypt_parse_hash_1k;
8873 sort_by_digest = sort_by_digest_4_8;
8874 opti_type = OPTI_TYPE_ZERO_BYTE;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 1;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 3;
8879 break;
8880
8881 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8885 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8886 dgst_size = DGST_SIZE_4_8;
8887 parse_func = truecrypt_parse_hash_1k;
8888 sort_by_digest = sort_by_digest_4_8;
8889 opti_type = OPTI_TYPE_ZERO_BYTE;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 1;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 3;
8894 break;
8895
8896 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8900 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8901 dgst_size = DGST_SIZE_4_8;
8902 parse_func = truecrypt_parse_hash_1k;
8903 sort_by_digest = sort_by_digest_4_8;
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8915 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8916 dgst_size = DGST_SIZE_4_5;
8917 parse_func = truecrypt_parse_hash_1k;
8918 sort_by_digest = sort_by_digest_4_5;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8930 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8931 dgst_size = DGST_SIZE_4_5;
8932 parse_func = truecrypt_parse_hash_1k;
8933 sort_by_digest = sort_by_digest_4_5;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8945 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8946 dgst_size = DGST_SIZE_4_5;
8947 parse_func = truecrypt_parse_hash_1k;
8948 sort_by_digest = sort_by_digest_4_5;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6300: hash_type = HASH_TYPE_MD5;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_MD5AIX;
8961 dgst_size = DGST_SIZE_4_4;
8962 parse_func = md5aix_parse_hash;
8963 sort_by_digest = sort_by_digest_4_4;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6400: hash_type = HASH_TYPE_SHA256;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8975 kern_type = KERN_TYPE_SHA256AIX;
8976 dgst_size = DGST_SIZE_4_8;
8977 parse_func = sha256aix_parse_hash;
8978 sort_by_digest = sort_by_digest_4_8;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6500: hash_type = HASH_TYPE_SHA512;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8990 kern_type = KERN_TYPE_SHA512AIX;
8991 dgst_size = DGST_SIZE_8_8;
8992 parse_func = sha512aix_parse_hash;
8993 sort_by_digest = sort_by_digest_8_8;
8994 opti_type = OPTI_TYPE_ZERO_BYTE
8995 | OPTI_TYPE_USES_BITS_64;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 6600: hash_type = HASH_TYPE_AES;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9006 kern_type = KERN_TYPE_AGILEKEY;
9007 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9008 parse_func = agilekey_parse_hash;
9009 sort_by_digest = sort_by_digest_4_5;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 6700: hash_type = HASH_TYPE_SHA1;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9021 kern_type = KERN_TYPE_SHA1AIX;
9022 dgst_size = DGST_SIZE_4_5;
9023 parse_func = sha1aix_parse_hash;
9024 sort_by_digest = sort_by_digest_4_5;
9025 opti_type = OPTI_TYPE_ZERO_BYTE;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 1;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 3;
9030 break;
9031
9032 case 6800: hash_type = HASH_TYPE_AES;
9033 salt_type = SALT_TYPE_EMBEDDED;
9034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9036 kern_type = KERN_TYPE_LASTPASS;
9037 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9038 parse_func = lastpass_parse_hash;
9039 sort_by_digest = sort_by_digest_4_8;
9040 opti_type = OPTI_TYPE_ZERO_BYTE;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 1;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 3;
9045 break;
9046
9047 case 6900: hash_type = HASH_TYPE_GOST;
9048 salt_type = SALT_TYPE_NONE;
9049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9051 kern_type = KERN_TYPE_GOST;
9052 dgst_size = DGST_SIZE_4_8;
9053 parse_func = gost_parse_hash;
9054 sort_by_digest = sort_by_digest_4_8;
9055 opti_type = OPTI_TYPE_ZERO_BYTE;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 7100: hash_type = HASH_TYPE_SHA512;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9066 kern_type = KERN_TYPE_PBKDF2_SHA512;
9067 dgst_size = DGST_SIZE_8_16;
9068 parse_func = sha512osx_parse_hash;
9069 sort_by_digest = sort_by_digest_8_16;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_USES_BITS_64
9072 | OPTI_TYPE_SLOW_HASH_SIMD;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 1;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 3;
9077 break;
9078
9079 case 7200: hash_type = HASH_TYPE_SHA512;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9083 kern_type = KERN_TYPE_PBKDF2_SHA512;
9084 dgst_size = DGST_SIZE_8_16;
9085 parse_func = sha512grub_parse_hash;
9086 sort_by_digest = sort_by_digest_8_16;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_USES_BITS_64
9089 | OPTI_TYPE_SLOW_HASH_SIMD;
9090 dgst_pos0 = 0;
9091 dgst_pos1 = 1;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 3;
9094 break;
9095
9096 case 7300: hash_type = HASH_TYPE_SHA1;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9099 opts_type = OPTS_TYPE_PT_GENERATE_BE
9100 | OPTS_TYPE_ST_ADD80
9101 | OPTS_TYPE_ST_ADDBITS15;
9102 kern_type = KERN_TYPE_RAKP;
9103 dgst_size = DGST_SIZE_4_5;
9104 parse_func = rakp_parse_hash;
9105 sort_by_digest = sort_by_digest_4_5;
9106 opti_type = OPTI_TYPE_ZERO_BYTE
9107 | OPTI_TYPE_NOT_ITERATED;
9108 dgst_pos0 = 3;
9109 dgst_pos1 = 4;
9110 dgst_pos2 = 2;
9111 dgst_pos3 = 1;
9112 break;
9113
9114 case 7400: hash_type = HASH_TYPE_SHA256;
9115 salt_type = SALT_TYPE_EMBEDDED;
9116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9117 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9118 kern_type = KERN_TYPE_SHA256CRYPT;
9119 dgst_size = DGST_SIZE_4_8;
9120 parse_func = sha256crypt_parse_hash;
9121 sort_by_digest = sort_by_digest_4_8;
9122 opti_type = OPTI_TYPE_ZERO_BYTE;
9123 dgst_pos0 = 0;
9124 dgst_pos1 = 1;
9125 dgst_pos2 = 2;
9126 dgst_pos3 = 3;
9127 break;
9128
9129 case 7500: hash_type = HASH_TYPE_KRB5PA;
9130 salt_type = SALT_TYPE_EMBEDDED;
9131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9133 kern_type = KERN_TYPE_KRB5PA;
9134 dgst_size = DGST_SIZE_4_4;
9135 parse_func = krb5pa_parse_hash;
9136 sort_by_digest = sort_by_digest_4_4;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_NOT_ITERATED;
9139 dgst_pos0 = 0;
9140 dgst_pos1 = 1;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 3;
9143 break;
9144
9145 case 7600: hash_type = HASH_TYPE_SHA1;
9146 salt_type = SALT_TYPE_INTERN;
9147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_BE
9149 | OPTS_TYPE_PT_ADD80
9150 | OPTS_TYPE_PT_ADDBITS15;
9151 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9152 dgst_size = DGST_SIZE_4_5;
9153 parse_func = redmine_parse_hash;
9154 sort_by_digest = sort_by_digest_4_5;
9155 opti_type = OPTI_TYPE_ZERO_BYTE
9156 | OPTI_TYPE_PRECOMPUTE_INIT
9157 | OPTI_TYPE_EARLY_SKIP
9158 | OPTI_TYPE_NOT_ITERATED
9159 | OPTI_TYPE_PREPENDED_SALT;
9160 dgst_pos0 = 3;
9161 dgst_pos1 = 4;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 1;
9164 break;
9165
9166 case 7700: hash_type = HASH_TYPE_SAPB;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9169 opts_type = OPTS_TYPE_PT_GENERATE_LE
9170 | OPTS_TYPE_PT_UPPER
9171 | OPTS_TYPE_ST_UPPER;
9172 kern_type = KERN_TYPE_SAPB;
9173 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9174 parse_func = sapb_parse_hash;
9175 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9176 opti_type = OPTI_TYPE_ZERO_BYTE
9177 | OPTI_TYPE_PRECOMPUTE_INIT
9178 | OPTI_TYPE_NOT_ITERATED;
9179 dgst_pos0 = 0;
9180 dgst_pos1 = 1;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 3;
9183 break;
9184
9185 case 7800: hash_type = HASH_TYPE_SAPG;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_BE
9189 | OPTS_TYPE_ST_ADD80
9190 | OPTS_TYPE_ST_UPPER;
9191 kern_type = KERN_TYPE_SAPG;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = sapg_parse_hash;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_PRECOMPUTE_INIT
9197 | OPTI_TYPE_NOT_ITERATED;
9198 dgst_pos0 = 3;
9199 dgst_pos1 = 4;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 1;
9202 break;
9203
9204 case 7900: hash_type = HASH_TYPE_SHA512;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9208 kern_type = KERN_TYPE_DRUPAL7;
9209 dgst_size = DGST_SIZE_8_8;
9210 parse_func = drupal7_parse_hash;
9211 sort_by_digest = sort_by_digest_8_8;
9212 opti_type = OPTI_TYPE_ZERO_BYTE
9213 | OPTI_TYPE_USES_BITS_64;
9214 dgst_pos0 = 0;
9215 dgst_pos1 = 1;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 3;
9218 break;
9219
9220 case 8000: hash_type = HASH_TYPE_SHA256;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_BE
9224 | OPTS_TYPE_PT_UNICODE
9225 | OPTS_TYPE_ST_ADD80
9226 | OPTS_TYPE_ST_HEX;
9227 kern_type = KERN_TYPE_SYBASEASE;
9228 dgst_size = DGST_SIZE_4_8;
9229 parse_func = sybasease_parse_hash;
9230 sort_by_digest = sort_by_digest_4_8;
9231 opti_type = OPTI_TYPE_ZERO_BYTE
9232 | OPTI_TYPE_PRECOMPUTE_INIT
9233 | OPTI_TYPE_EARLY_SKIP
9234 | OPTI_TYPE_NOT_ITERATED
9235 | OPTI_TYPE_RAW_HASH;
9236 dgst_pos0 = 3;
9237 dgst_pos1 = 7;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 6;
9240 break;
9241
9242 case 8100: hash_type = HASH_TYPE_SHA1;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9246 kern_type = KERN_TYPE_NETSCALER;
9247 dgst_size = DGST_SIZE_4_5;
9248 parse_func = netscaler_parse_hash;
9249 sort_by_digest = sort_by_digest_4_5;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_PRECOMPUTE_INIT
9252 | OPTI_TYPE_PRECOMPUTE_MERKLE
9253 | OPTI_TYPE_EARLY_SKIP
9254 | OPTI_TYPE_NOT_ITERATED
9255 | OPTI_TYPE_PREPENDED_SALT
9256 | OPTI_TYPE_RAW_HASH;
9257 dgst_pos0 = 3;
9258 dgst_pos1 = 4;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 1;
9261 break;
9262
9263 case 8200: hash_type = HASH_TYPE_SHA256;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9267 kern_type = KERN_TYPE_CLOUDKEY;
9268 dgst_size = DGST_SIZE_4_8;
9269 parse_func = cloudkey_parse_hash;
9270 sort_by_digest = sort_by_digest_4_8;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 8300: hash_type = HASH_TYPE_SHA1;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_BE
9282 | OPTS_TYPE_ST_HEX
9283 | OPTS_TYPE_ST_ADD80;
9284 kern_type = KERN_TYPE_NSEC3;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = nsec3_parse_hash;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE;
9289 dgst_pos0 = 3;
9290 dgst_pos1 = 4;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 1;
9293 break;
9294
9295 case 8400: hash_type = HASH_TYPE_SHA1;
9296 salt_type = SALT_TYPE_INTERN;
9297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_BE
9299 | OPTS_TYPE_PT_ADD80
9300 | OPTS_TYPE_PT_ADDBITS15;
9301 kern_type = KERN_TYPE_WBB3;
9302 dgst_size = DGST_SIZE_4_5;
9303 parse_func = wbb3_parse_hash;
9304 sort_by_digest = sort_by_digest_4_5;
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_PRECOMPUTE_INIT
9307 | OPTI_TYPE_NOT_ITERATED;
9308 dgst_pos0 = 3;
9309 dgst_pos1 = 4;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 1;
9312 break;
9313
9314 case 8500: hash_type = HASH_TYPE_DESRACF;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE
9318 | OPTS_TYPE_ST_UPPER;
9319 kern_type = KERN_TYPE_RACF;
9320 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9321 parse_func = racf_parse_hash;
9322 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9323 opti_type = OPTI_TYPE_ZERO_BYTE
9324 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 8600: hash_type = HASH_TYPE_LOTUS5;
9332 salt_type = SALT_TYPE_NONE;
9333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9335 kern_type = KERN_TYPE_LOTUS5;
9336 dgst_size = DGST_SIZE_4_4;
9337 parse_func = lotus5_parse_hash;
9338 sort_by_digest = sort_by_digest_4_4;
9339 opti_type = OPTI_TYPE_EARLY_SKIP
9340 | OPTI_TYPE_NOT_ITERATED
9341 | OPTI_TYPE_NOT_SALTED
9342 | OPTI_TYPE_RAW_HASH;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 8700: hash_type = HASH_TYPE_LOTUS6;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9353 kern_type = KERN_TYPE_LOTUS6;
9354 dgst_size = DGST_SIZE_4_4;
9355 parse_func = lotus6_parse_hash;
9356 sort_by_digest = sort_by_digest_4_4;
9357 opti_type = OPTI_TYPE_EARLY_SKIP
9358 | OPTI_TYPE_NOT_ITERATED
9359 | OPTI_TYPE_RAW_HASH;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9367 salt_type = SALT_TYPE_EMBEDDED;
9368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9370 kern_type = KERN_TYPE_ANDROIDFDE;
9371 dgst_size = DGST_SIZE_4_4;
9372 parse_func = androidfde_parse_hash;
9373 sort_by_digest = sort_by_digest_4_4;
9374 opti_type = OPTI_TYPE_ZERO_BYTE;
9375 dgst_pos0 = 0;
9376 dgst_pos1 = 1;
9377 dgst_pos2 = 2;
9378 dgst_pos3 = 3;
9379 break;
9380
9381 case 8900: hash_type = HASH_TYPE_SCRYPT;
9382 salt_type = SALT_TYPE_EMBEDDED;
9383 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9384 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9385 kern_type = KERN_TYPE_SCRYPT;
9386 dgst_size = DGST_SIZE_4_8;
9387 parse_func = scrypt_parse_hash;
9388 sort_by_digest = sort_by_digest_4_8;
9389 opti_type = OPTI_TYPE_ZERO_BYTE;
9390 dgst_pos0 = 0;
9391 dgst_pos1 = 1;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 3;
9394 break;
9395
9396 case 9000: hash_type = HASH_TYPE_SHA1;
9397 salt_type = SALT_TYPE_EMBEDDED;
9398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_LE
9400 | OPTS_TYPE_ST_GENERATE_LE;
9401 kern_type = KERN_TYPE_PSAFE2;
9402 dgst_size = DGST_SIZE_4_5;
9403 parse_func = psafe2_parse_hash;
9404 sort_by_digest = sort_by_digest_4_5;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 9100: hash_type = HASH_TYPE_LOTUS8;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_LOTUS8;
9417 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9418 parse_func = lotus8_parse_hash;
9419 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 9200: hash_type = HASH_TYPE_SHA256;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9431 kern_type = KERN_TYPE_PBKDF2_SHA256;
9432 dgst_size = DGST_SIZE_4_32;
9433 parse_func = cisco8_parse_hash;
9434 sort_by_digest = sort_by_digest_4_32;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_SLOW_HASH_SIMD;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 9300: hash_type = HASH_TYPE_SCRYPT;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9447 kern_type = KERN_TYPE_SCRYPT;
9448 dgst_size = DGST_SIZE_4_8;
9449 parse_func = cisco9_parse_hash;
9450 sort_by_digest = sort_by_digest_4_8;
9451 opti_type = OPTI_TYPE_ZERO_BYTE;
9452 dgst_pos0 = 0;
9453 dgst_pos1 = 1;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 3;
9456 break;
9457
9458 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9462 kern_type = KERN_TYPE_OFFICE2007;
9463 dgst_size = DGST_SIZE_4_4;
9464 parse_func = office2007_parse_hash;
9465 sort_by_digest = sort_by_digest_4_4;
9466 opti_type = OPTI_TYPE_ZERO_BYTE;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9477 kern_type = KERN_TYPE_OFFICE2010;
9478 dgst_size = DGST_SIZE_4_4;
9479 parse_func = office2010_parse_hash;
9480 sort_by_digest = sort_by_digest_4_4;
9481 opti_type = OPTI_TYPE_ZERO_BYTE;
9482 dgst_pos0 = 0;
9483 dgst_pos1 = 1;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 3;
9486 break;
9487
9488 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9492 kern_type = KERN_TYPE_OFFICE2013;
9493 dgst_size = DGST_SIZE_4_4;
9494 parse_func = office2013_parse_hash;
9495 sort_by_digest = sort_by_digest_4_4;
9496 opti_type = OPTI_TYPE_ZERO_BYTE;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_PT_ADD80
9508 | OPTS_TYPE_PT_UNICODE;
9509 kern_type = KERN_TYPE_OLDOFFICE01;
9510 dgst_size = DGST_SIZE_4_4;
9511 parse_func = oldoffice01_parse_hash;
9512 sort_by_digest = sort_by_digest_4_4;
9513 opti_type = OPTI_TYPE_ZERO_BYTE
9514 | OPTI_TYPE_PRECOMPUTE_INIT
9515 | OPTI_TYPE_NOT_ITERATED;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 1;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 3;
9520 break;
9521
9522 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE
9526 | OPTS_TYPE_PT_ADD80;
9527 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = oldoffice01cm1_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE
9546 | OPTS_TYPE_PT_NEVERCRACK;
9547 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9548 dgst_size = DGST_SIZE_4_4;
9549 parse_func = oldoffice01cm2_parse_hash;
9550 sort_by_digest = sort_by_digest_4_4;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_BE
9564 | OPTS_TYPE_PT_ADD80
9565 | OPTS_TYPE_PT_UNICODE;
9566 kern_type = KERN_TYPE_OLDOFFICE34;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = oldoffice34_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_PRECOMPUTE_INIT
9572 | OPTI_TYPE_NOT_ITERATED;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9583 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9584 dgst_size = DGST_SIZE_4_4;
9585 parse_func = oldoffice34cm1_parse_hash;
9586 sort_by_digest = sort_by_digest_4_4;
9587 opti_type = OPTI_TYPE_ZERO_BYTE
9588 | OPTI_TYPE_PRECOMPUTE_INIT
9589 | OPTI_TYPE_NOT_ITERATED;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_BE
9600 | OPTS_TYPE_PT_ADD80
9601 | OPTS_TYPE_PT_UNICODE
9602 | OPTS_TYPE_PT_NEVERCRACK;
9603 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = oldoffice34cm2_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9900: hash_type = HASH_TYPE_MD5;
9617 salt_type = SALT_TYPE_NONE;
9618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_RADMIN2;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = radmin2_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_EARLY_SKIP
9627 | OPTI_TYPE_NOT_ITERATED
9628 | OPTI_TYPE_NOT_SALTED;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 3;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 1;
9633 break;
9634
9635 case 10000: hash_type = HASH_TYPE_SHA256;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9639 kern_type = KERN_TYPE_PBKDF2_SHA256;
9640 dgst_size = DGST_SIZE_4_32;
9641 parse_func = djangopbkdf2_parse_hash;
9642 sort_by_digest = sort_by_digest_4_32;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_SLOW_HASH_SIMD;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 10100: hash_type = HASH_TYPE_SIPHASH;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_SIPHASH;
9656 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9657 parse_func = siphash_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_NOT_ITERATED
9661 | OPTI_TYPE_RAW_HASH;
9662 dgst_pos0 = 0;
9663 dgst_pos1 = 1;
9664 dgst_pos2 = 2;
9665 dgst_pos3 = 3;
9666 break;
9667
9668 case 10200: hash_type = HASH_TYPE_MD5;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_LE
9672 | OPTS_TYPE_ST_ADD80
9673 | OPTS_TYPE_ST_ADDBITS14;
9674 kern_type = KERN_TYPE_HMACMD5_PW;
9675 dgst_size = DGST_SIZE_4_4;
9676 parse_func = crammd5_parse_hash;
9677 sort_by_digest = sort_by_digest_4_4;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_NOT_ITERATED;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 3;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 1;
9684 break;
9685
9686 case 10300: hash_type = HASH_TYPE_SHA1;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9690 kern_type = KERN_TYPE_SAPH_SHA1;
9691 dgst_size = DGST_SIZE_4_5;
9692 parse_func = saph_sha1_parse_hash;
9693 sort_by_digest = sort_by_digest_4_5;
9694 opti_type = OPTI_TYPE_ZERO_BYTE;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 10400: hash_type = HASH_TYPE_PDFU16;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9705 kern_type = KERN_TYPE_PDF11;
9706 dgst_size = DGST_SIZE_4_4;
9707 parse_func = pdf11_parse_hash;
9708 sort_by_digest = sort_by_digest_4_4;
9709 opti_type = OPTI_TYPE_ZERO_BYTE
9710 | OPTI_TYPE_NOT_ITERATED;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 10410: hash_type = HASH_TYPE_PDFU16;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_PDF11CM1;
9722 dgst_size = DGST_SIZE_4_4;
9723 parse_func = pdf11cm1_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4;
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_NOT_ITERATED;
9727 dgst_pos0 = 0;
9728 dgst_pos1 = 1;
9729 dgst_pos2 = 2;
9730 dgst_pos3 = 3;
9731 break;
9732
9733 case 10420: hash_type = HASH_TYPE_PDFU16;
9734 salt_type = SALT_TYPE_EMBEDDED;
9735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9737 kern_type = KERN_TYPE_PDF11CM2;
9738 dgst_size = DGST_SIZE_4_4;
9739 parse_func = pdf11cm2_parse_hash;
9740 sort_by_digest = sort_by_digest_4_4;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_NOT_ITERATED;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 10500: hash_type = HASH_TYPE_PDFU16;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9753 kern_type = KERN_TYPE_PDF14;
9754 dgst_size = DGST_SIZE_4_4;
9755 parse_func = pdf14_parse_hash;
9756 sort_by_digest = sort_by_digest_4_4;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_NOT_ITERATED;
9759 dgst_pos0 = 0;
9760 dgst_pos1 = 1;
9761 dgst_pos2 = 2;
9762 dgst_pos3 = 3;
9763 break;
9764
9765 case 10600: hash_type = HASH_TYPE_SHA256;
9766 salt_type = SALT_TYPE_EMBEDDED;
9767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9768 opts_type = OPTS_TYPE_PT_GENERATE_BE
9769 | OPTS_TYPE_ST_ADD80
9770 | OPTS_TYPE_ST_ADDBITS15
9771 | OPTS_TYPE_HASH_COPY;
9772 kern_type = KERN_TYPE_SHA256_PWSLT;
9773 dgst_size = DGST_SIZE_4_8;
9774 parse_func = pdf17l3_parse_hash;
9775 sort_by_digest = sort_by_digest_4_8;
9776 opti_type = OPTI_TYPE_ZERO_BYTE
9777 | OPTI_TYPE_PRECOMPUTE_INIT
9778 | OPTI_TYPE_PRECOMPUTE_MERKLE
9779 | OPTI_TYPE_EARLY_SKIP
9780 | OPTI_TYPE_NOT_ITERATED
9781 | OPTI_TYPE_APPENDED_SALT
9782 | OPTI_TYPE_RAW_HASH;
9783 dgst_pos0 = 3;
9784 dgst_pos1 = 7;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 6;
9787 break;
9788
9789 case 10700: hash_type = HASH_TYPE_PDFU32;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE
9793 | OPTS_TYPE_HASH_COPY;
9794 kern_type = KERN_TYPE_PDF17L8;
9795 dgst_size = DGST_SIZE_4_8;
9796 parse_func = pdf17l8_parse_hash;
9797 sort_by_digest = sort_by_digest_4_8;
9798 opti_type = OPTI_TYPE_ZERO_BYTE
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 10800: hash_type = HASH_TYPE_SHA384;
9807 salt_type = SALT_TYPE_NONE;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_BE
9810 | OPTS_TYPE_PT_ADD80
9811 | OPTS_TYPE_PT_ADDBITS15;
9812 kern_type = KERN_TYPE_SHA384;
9813 dgst_size = DGST_SIZE_8_8;
9814 parse_func = sha384_parse_hash;
9815 sort_by_digest = sort_by_digest_8_8;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_PRECOMPUTE_MERKLE
9819 | OPTI_TYPE_EARLY_SKIP
9820 | OPTI_TYPE_NOT_ITERATED
9821 | OPTI_TYPE_NOT_SALTED
9822 | OPTI_TYPE_USES_BITS_64
9823 | OPTI_TYPE_RAW_HASH;
9824 dgst_pos0 = 6;
9825 dgst_pos1 = 7;
9826 dgst_pos2 = 4;
9827 dgst_pos3 = 5;
9828 break;
9829
9830 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9831 salt_type = SALT_TYPE_EMBEDDED;
9832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_LE
9834 | OPTS_TYPE_ST_BASE64
9835 | OPTS_TYPE_HASH_COPY;
9836 kern_type = KERN_TYPE_PBKDF2_SHA256;
9837 dgst_size = DGST_SIZE_4_32;
9838 parse_func = pbkdf2_sha256_parse_hash;
9839 sort_by_digest = sort_by_digest_4_32;
9840 opti_type = OPTI_TYPE_ZERO_BYTE
9841 | OPTI_TYPE_SLOW_HASH_SIMD;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 1;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 3;
9846 break;
9847
9848 case 11000: hash_type = HASH_TYPE_MD5;
9849 salt_type = SALT_TYPE_INTERN;
9850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_PT_ADD80;
9853 kern_type = KERN_TYPE_PRESTASHOP;
9854 dgst_size = DGST_SIZE_4_4;
9855 parse_func = prestashop_parse_hash;
9856 sort_by_digest = sort_by_digest_4_4;
9857 opti_type = OPTI_TYPE_ZERO_BYTE
9858 | OPTI_TYPE_PRECOMPUTE_INIT
9859 | OPTI_TYPE_NOT_ITERATED
9860 | OPTI_TYPE_PREPENDED_SALT;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 3;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 1;
9865 break;
9866
9867 case 11100: hash_type = HASH_TYPE_MD5;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE
9871 | OPTS_TYPE_ST_ADD80;
9872 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9873 dgst_size = DGST_SIZE_4_4;
9874 parse_func = postgresql_auth_parse_hash;
9875 sort_by_digest = sort_by_digest_4_4;
9876 opti_type = OPTI_TYPE_ZERO_BYTE
9877 | OPTI_TYPE_PRECOMPUTE_INIT
9878 | OPTI_TYPE_PRECOMPUTE_MERKLE
9879 | OPTI_TYPE_EARLY_SKIP;
9880 dgst_pos0 = 0;
9881 dgst_pos1 = 3;
9882 dgst_pos2 = 2;
9883 dgst_pos3 = 1;
9884 break;
9885
9886 case 11200: hash_type = HASH_TYPE_SHA1;
9887 salt_type = SALT_TYPE_EMBEDDED;
9888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_BE
9890 | OPTS_TYPE_PT_ADD80
9891 | OPTS_TYPE_ST_HEX;
9892 kern_type = KERN_TYPE_MYSQL_AUTH;
9893 dgst_size = DGST_SIZE_4_5;
9894 parse_func = mysql_auth_parse_hash;
9895 sort_by_digest = sort_by_digest_4_5;
9896 opti_type = OPTI_TYPE_ZERO_BYTE
9897 | OPTI_TYPE_EARLY_SKIP;
9898 dgst_pos0 = 3;
9899 dgst_pos1 = 4;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 1;
9902 break;
9903
9904 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9905 salt_type = SALT_TYPE_EMBEDDED;
9906 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_LE
9908 | OPTS_TYPE_ST_HEX
9909 | OPTS_TYPE_ST_ADD80;
9910 kern_type = KERN_TYPE_BITCOIN_WALLET;
9911 dgst_size = DGST_SIZE_4_4;
9912 parse_func = bitcoin_wallet_parse_hash;
9913 sort_by_digest = sort_by_digest_4_4;
9914 opti_type = OPTI_TYPE_ZERO_BYTE;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 11400: hash_type = HASH_TYPE_MD5;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE
9925 | OPTS_TYPE_PT_ADD80
9926 | OPTS_TYPE_HASH_COPY;
9927 kern_type = KERN_TYPE_SIP_AUTH;
9928 dgst_size = DGST_SIZE_4_4;
9929 parse_func = sip_auth_parse_hash;
9930 sort_by_digest = sort_by_digest_4_4;
9931 opti_type = OPTI_TYPE_ZERO_BYTE;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 3;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 11500: hash_type = HASH_TYPE_CRC32;
9939 salt_type = SALT_TYPE_INTERN;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_ST_GENERATE_LE
9943 | OPTS_TYPE_ST_HEX;
9944 kern_type = KERN_TYPE_CRC32;
9945 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9946 parse_func = crc32_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9948 opti_type = OPTI_TYPE_ZERO_BYTE;
9949 dgst_pos0 = 0;
9950 dgst_pos1 = 1;
9951 dgst_pos2 = 2;
9952 dgst_pos3 = 3;
9953 break;
9954
9955 case 11600: hash_type = HASH_TYPE_AES;
9956 salt_type = SALT_TYPE_EMBEDDED;
9957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9958 opts_type = OPTS_TYPE_PT_GENERATE_LE
9959 | OPTS_TYPE_PT_NEVERCRACK;
9960 kern_type = KERN_TYPE_SEVEN_ZIP;
9961 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9962 parse_func = seven_zip_parse_hash;
9963 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9964 opti_type = OPTI_TYPE_ZERO_BYTE;
9965 dgst_pos0 = 0;
9966 dgst_pos1 = 1;
9967 dgst_pos2 = 2;
9968 dgst_pos3 = 3;
9969 break;
9970
9971 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9972 salt_type = SALT_TYPE_NONE;
9973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9974 opts_type = OPTS_TYPE_PT_GENERATE_LE
9975 | OPTS_TYPE_PT_ADD01;
9976 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9977 dgst_size = DGST_SIZE_4_8;
9978 parse_func = gost2012sbog_256_parse_hash;
9979 sort_by_digest = sort_by_digest_4_8;
9980 opti_type = OPTI_TYPE_ZERO_BYTE;
9981 dgst_pos0 = 0;
9982 dgst_pos1 = 1;
9983 dgst_pos2 = 2;
9984 dgst_pos3 = 3;
9985 break;
9986
9987 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9988 salt_type = SALT_TYPE_NONE;
9989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9990 opts_type = OPTS_TYPE_PT_GENERATE_LE
9991 | OPTS_TYPE_PT_ADD01;
9992 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9993 dgst_size = DGST_SIZE_4_16;
9994 parse_func = gost2012sbog_512_parse_hash;
9995 sort_by_digest = sort_by_digest_4_16;
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10004 salt_type = SALT_TYPE_EMBEDDED;
10005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_ST_BASE64
10008 | OPTS_TYPE_HASH_COPY;
10009 kern_type = KERN_TYPE_PBKDF2_MD5;
10010 dgst_size = DGST_SIZE_4_32;
10011 parse_func = pbkdf2_md5_parse_hash;
10012 sort_by_digest = sort_by_digest_4_32;
10013 opti_type = OPTI_TYPE_ZERO_BYTE
10014 | OPTI_TYPE_SLOW_HASH_SIMD;
10015 dgst_pos0 = 0;
10016 dgst_pos1 = 1;
10017 dgst_pos2 = 2;
10018 dgst_pos3 = 3;
10019 break;
10020
10021 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10022 salt_type = SALT_TYPE_EMBEDDED;
10023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10024 opts_type = OPTS_TYPE_PT_GENERATE_LE
10025 | OPTS_TYPE_ST_BASE64
10026 | OPTS_TYPE_HASH_COPY;
10027 kern_type = KERN_TYPE_PBKDF2_SHA1;
10028 dgst_size = DGST_SIZE_4_32;
10029 parse_func = pbkdf2_sha1_parse_hash;
10030 sort_by_digest = sort_by_digest_4_32;
10031 opti_type = OPTI_TYPE_ZERO_BYTE
10032 | OPTI_TYPE_SLOW_HASH_SIMD;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10040 salt_type = SALT_TYPE_EMBEDDED;
10041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE
10043 | OPTS_TYPE_ST_BASE64
10044 | OPTS_TYPE_HASH_COPY;
10045 kern_type = KERN_TYPE_PBKDF2_SHA512;
10046 dgst_size = DGST_SIZE_8_16;
10047 parse_func = pbkdf2_sha512_parse_hash;
10048 sort_by_digest = sort_by_digest_8_16;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_USES_BITS_64
10051 | OPTI_TYPE_SLOW_HASH_SIMD;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10059 salt_type = SALT_TYPE_EMBEDDED;
10060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10062 kern_type = KERN_TYPE_ECRYPTFS;
10063 dgst_size = DGST_SIZE_8_8;
10064 parse_func = ecryptfs_parse_hash;
10065 sort_by_digest = sort_by_digest_8_8;
10066 opti_type = OPTI_TYPE_ZERO_BYTE
10067 | OPTI_TYPE_USES_BITS_64;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 12300: hash_type = HASH_TYPE_ORACLET;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10078 kern_type = KERN_TYPE_ORACLET;
10079 dgst_size = DGST_SIZE_8_16;
10080 parse_func = oraclet_parse_hash;
10081 sort_by_digest = sort_by_digest_8_16;
10082 opti_type = OPTI_TYPE_ZERO_BYTE
10083 | OPTI_TYPE_USES_BITS_64;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10094 kern_type = KERN_TYPE_BSDICRYPT;
10095 dgst_size = DGST_SIZE_4_4;
10096 parse_func = bsdicrypt_parse_hash;
10097 sort_by_digest = sort_by_digest_4_4;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 1;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 3;
10104 break;
10105
10106 case 12500: hash_type = HASH_TYPE_RAR3HP;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10110 kern_type = KERN_TYPE_RAR3;
10111 dgst_size = DGST_SIZE_4_4;
10112 parse_func = rar3hp_parse_hash;
10113 sort_by_digest = sort_by_digest_4_4;
10114 opti_type = OPTI_TYPE_ZERO_BYTE;
10115 dgst_pos0 = 0;
10116 dgst_pos1 = 1;
10117 dgst_pos2 = 2;
10118 dgst_pos3 = 3;
10119 break;
10120
10121 case 12600: hash_type = HASH_TYPE_SHA256;
10122 salt_type = SALT_TYPE_INTERN;
10123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10124 opts_type = OPTS_TYPE_PT_GENERATE_BE
10125 | OPTS_TYPE_PT_ADD80;
10126 kern_type = KERN_TYPE_CF10;
10127 dgst_size = DGST_SIZE_4_8;
10128 parse_func = cf10_parse_hash;
10129 sort_by_digest = sort_by_digest_4_8;
10130 opti_type = OPTI_TYPE_ZERO_BYTE
10131 | OPTI_TYPE_PRECOMPUTE_INIT
10132 | OPTI_TYPE_EARLY_SKIP
10133 | OPTI_TYPE_NOT_ITERATED;
10134 dgst_pos0 = 3;
10135 dgst_pos1 = 7;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 6;
10138 break;
10139
10140 case 12700: hash_type = HASH_TYPE_AES;
10141 salt_type = SALT_TYPE_EMBEDDED;
10142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10143 opts_type = OPTS_TYPE_PT_GENERATE_LE
10144 | OPTS_TYPE_HASH_COPY;
10145 kern_type = KERN_TYPE_MYWALLET;
10146 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10147 parse_func = mywallet_parse_hash;
10148 sort_by_digest = sort_by_digest_4_5;
10149 opti_type = OPTI_TYPE_ZERO_BYTE;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10160 kern_type = KERN_TYPE_MS_DRSR;
10161 dgst_size = DGST_SIZE_4_8;
10162 parse_func = ms_drsr_parse_hash;
10163 sort_by_digest = sort_by_digest_4_8;
10164 opti_type = OPTI_TYPE_ZERO_BYTE;
10165 dgst_pos0 = 0;
10166 dgst_pos1 = 1;
10167 dgst_pos2 = 2;
10168 dgst_pos3 = 3;
10169 break;
10170
10171 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10172 salt_type = SALT_TYPE_EMBEDDED;
10173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10175 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10176 dgst_size = DGST_SIZE_4_8;
10177 parse_func = androidfde_samsung_parse_hash;
10178 sort_by_digest = sort_by_digest_4_8;
10179 opti_type = OPTI_TYPE_ZERO_BYTE;
10180 dgst_pos0 = 0;
10181 dgst_pos1 = 1;
10182 dgst_pos2 = 2;
10183 dgst_pos3 = 3;
10184 break;
10185
10186 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10187 salt_type = SALT_TYPE_EMBEDDED;
10188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10189 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10190 kern_type = KERN_TYPE_RAR5;
10191 dgst_size = DGST_SIZE_4_4;
10192 parse_func = rar5_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4;
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10205 kern_type = KERN_TYPE_KRB5TGS;
10206 dgst_size = DGST_SIZE_4_4;
10207 parse_func = krb5tgs_parse_hash;
10208 sort_by_digest = sort_by_digest_4_4;
10209 opti_type = OPTI_TYPE_ZERO_BYTE
10210 | OPTI_TYPE_NOT_ITERATED;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 13200: hash_type = HASH_TYPE_AES;
10218 salt_type = SALT_TYPE_EMBEDDED;
10219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10221 kern_type = KERN_TYPE_AXCRYPT;
10222 dgst_size = DGST_SIZE_4_4;
10223 parse_func = axcrypt_parse_hash;
10224 sort_by_digest = sort_by_digest_4_4;
10225 opti_type = OPTI_TYPE_ZERO_BYTE;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 case 13300: hash_type = HASH_TYPE_SHA1;
10233 salt_type = SALT_TYPE_NONE;
10234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10235 opts_type = OPTS_TYPE_PT_GENERATE_BE
10236 | OPTS_TYPE_PT_ADD80
10237 | OPTS_TYPE_PT_ADDBITS15;
10238 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10239 dgst_size = DGST_SIZE_4_5;
10240 parse_func = sha1axcrypt_parse_hash;
10241 sort_by_digest = sort_by_digest_4_5;
10242 opti_type = OPTI_TYPE_ZERO_BYTE
10243 | OPTI_TYPE_PRECOMPUTE_INIT
10244 | OPTI_TYPE_EARLY_SKIP
10245 | OPTI_TYPE_NOT_ITERATED
10246 | OPTI_TYPE_NOT_SALTED;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 4;
10249 dgst_pos2 = 3;
10250 dgst_pos3 = 2;
10251 break;
10252
10253 case 13400: hash_type = HASH_TYPE_AES;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_KEEPASS;
10258 dgst_size = DGST_SIZE_4_4;
10259 parse_func = keepass_parse_hash;
10260 sort_by_digest = sort_by_digest_4_4;
10261 opti_type = OPTI_TYPE_ZERO_BYTE;
10262 dgst_pos0 = 0;
10263 dgst_pos1 = 1;
10264 dgst_pos2 = 2;
10265 dgst_pos3 = 3;
10266 break;
10267
10268 case 13500: hash_type = HASH_TYPE_SHA1;
10269 salt_type = SALT_TYPE_EMBEDDED;
10270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10271 opts_type = OPTS_TYPE_PT_GENERATE_BE
10272 | OPTS_TYPE_PT_UNICODE
10273 | OPTS_TYPE_PT_ADD80;
10274 kern_type = KERN_TYPE_PSTOKEN;
10275 dgst_size = DGST_SIZE_4_5;
10276 parse_func = pstoken_parse_hash;
10277 sort_by_digest = sort_by_digest_4_5;
10278 opti_type = OPTI_TYPE_ZERO_BYTE
10279 | OPTI_TYPE_PRECOMPUTE_INIT
10280 | OPTI_TYPE_EARLY_SKIP
10281 | OPTI_TYPE_NOT_ITERATED
10282 | OPTI_TYPE_PREPENDED_SALT
10283 | OPTI_TYPE_RAW_HASH;
10284 dgst_pos0 = 3;
10285 dgst_pos1 = 4;
10286 dgst_pos2 = 2;
10287 dgst_pos3 = 1;
10288 break;
10289
10290 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10291 salt_type = SALT_TYPE_EMBEDDED;
10292 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10293 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10294 kern_type = KERN_TYPE_ZIP2;
10295 dgst_size = DGST_SIZE_4_4;
10296 parse_func = zip2_parse_hash;
10297 sort_by_digest = sort_by_digest_4_4;
10298 opti_type = OPTI_TYPE_ZERO_BYTE;
10299 dgst_pos0 = 0;
10300 dgst_pos1 = 1;
10301 dgst_pos2 = 2;
10302 dgst_pos3 = 3;
10303 break;
10304
10305 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10306 salt_type = SALT_TYPE_EMBEDDED;
10307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10309 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10310 dgst_size = DGST_SIZE_4_5;
10311 parse_func = veracrypt_parse_hash_655331;
10312 sort_by_digest = sort_by_digest_4_5;
10313 opti_type = OPTI_TYPE_ZERO_BYTE;
10314 dgst_pos0 = 0;
10315 dgst_pos1 = 1;
10316 dgst_pos2 = 2;
10317 dgst_pos3 = 3;
10318 break;
10319
10320 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10321 salt_type = SALT_TYPE_EMBEDDED;
10322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10324 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10325 dgst_size = DGST_SIZE_4_5;
10326 parse_func = veracrypt_parse_hash_655331;
10327 sort_by_digest = sort_by_digest_4_5;
10328 opti_type = OPTI_TYPE_ZERO_BYTE;
10329 dgst_pos0 = 0;
10330 dgst_pos1 = 1;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 3;
10333 break;
10334
10335 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10336 salt_type = SALT_TYPE_EMBEDDED;
10337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10339 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10340 dgst_size = DGST_SIZE_4_5;
10341 parse_func = veracrypt_parse_hash_655331;
10342 sort_by_digest = sort_by_digest_4_5;
10343 opti_type = OPTI_TYPE_ZERO_BYTE;
10344 dgst_pos0 = 0;
10345 dgst_pos1 = 1;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 3;
10348 break;
10349
10350 case 13721: hash_type = HASH_TYPE_SHA512;
10351 salt_type = SALT_TYPE_EMBEDDED;
10352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10354 kern_type = KERN_TYPE_TCSHA512_XTS512;
10355 dgst_size = DGST_SIZE_8_8;
10356 parse_func = veracrypt_parse_hash_500000;
10357 sort_by_digest = sort_by_digest_8_8;
10358 opti_type = OPTI_TYPE_ZERO_BYTE
10359 | OPTI_TYPE_USES_BITS_64;
10360 dgst_pos0 = 0;
10361 dgst_pos1 = 1;
10362 dgst_pos2 = 2;
10363 dgst_pos3 = 3;
10364 break;
10365
10366 case 13722: hash_type = HASH_TYPE_SHA512;
10367 salt_type = SALT_TYPE_EMBEDDED;
10368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10369 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10370 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10371 dgst_size = DGST_SIZE_8_8;
10372 parse_func = veracrypt_parse_hash_500000;
10373 sort_by_digest = sort_by_digest_8_8;
10374 opti_type = OPTI_TYPE_ZERO_BYTE
10375 | OPTI_TYPE_USES_BITS_64;
10376 dgst_pos0 = 0;
10377 dgst_pos1 = 1;
10378 dgst_pos2 = 2;
10379 dgst_pos3 = 3;
10380 break;
10381
10382 case 13723: hash_type = HASH_TYPE_SHA512;
10383 salt_type = SALT_TYPE_EMBEDDED;
10384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10385 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10386 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10387 dgst_size = DGST_SIZE_8_8;
10388 parse_func = veracrypt_parse_hash_500000;
10389 sort_by_digest = sort_by_digest_8_8;
10390 opti_type = OPTI_TYPE_ZERO_BYTE
10391 | OPTI_TYPE_USES_BITS_64;
10392 dgst_pos0 = 0;
10393 dgst_pos1 = 1;
10394 dgst_pos2 = 2;
10395 dgst_pos3 = 3;
10396 break;
10397
10398 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10399 salt_type = SALT_TYPE_EMBEDDED;
10400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10401 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10402 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10403 dgst_size = DGST_SIZE_4_8;
10404 parse_func = veracrypt_parse_hash_500000;
10405 sort_by_digest = sort_by_digest_4_8;
10406 opti_type = OPTI_TYPE_ZERO_BYTE;
10407 dgst_pos0 = 0;
10408 dgst_pos1 = 1;
10409 dgst_pos2 = 2;
10410 dgst_pos3 = 3;
10411 break;
10412
10413 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10414 salt_type = SALT_TYPE_EMBEDDED;
10415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10417 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10418 dgst_size = DGST_SIZE_4_8;
10419 parse_func = veracrypt_parse_hash_500000;
10420 sort_by_digest = sort_by_digest_4_8;
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 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10429 salt_type = SALT_TYPE_EMBEDDED;
10430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10432 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10433 dgst_size = DGST_SIZE_4_8;
10434 parse_func = veracrypt_parse_hash_500000;
10435 sort_by_digest = sort_by_digest_4_8;
10436 opti_type = OPTI_TYPE_ZERO_BYTE;
10437 dgst_pos0 = 0;
10438 dgst_pos1 = 1;
10439 dgst_pos2 = 2;
10440 dgst_pos3 = 3;
10441 break;
10442
10443 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10444 salt_type = SALT_TYPE_EMBEDDED;
10445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10447 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10448 dgst_size = DGST_SIZE_4_5;
10449 parse_func = veracrypt_parse_hash_327661;
10450 sort_by_digest = sort_by_digest_4_5;
10451 opti_type = OPTI_TYPE_ZERO_BYTE;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10462 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10463 dgst_size = DGST_SIZE_4_5;
10464 parse_func = veracrypt_parse_hash_327661;
10465 sort_by_digest = sort_by_digest_4_5;
10466 opti_type = OPTI_TYPE_ZERO_BYTE;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10474 salt_type = SALT_TYPE_EMBEDDED;
10475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10477 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10478 dgst_size = DGST_SIZE_4_5;
10479 parse_func = veracrypt_parse_hash_327661;
10480 sort_by_digest = sort_by_digest_4_5;
10481 opti_type = OPTI_TYPE_ZERO_BYTE;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 1;
10484 dgst_pos2 = 2;
10485 dgst_pos3 = 3;
10486 break;
10487
10488 case 13751: hash_type = HASH_TYPE_SHA256;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10492 kern_type = KERN_TYPE_VCSHA256_XTS512;
10493 dgst_size = DGST_SIZE_4_8;
10494 parse_func = veracrypt_parse_hash_500000;
10495 sort_by_digest = sort_by_digest_4_8;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 13752: hash_type = HASH_TYPE_SHA256;
10504 salt_type = SALT_TYPE_EMBEDDED;
10505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10507 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10508 dgst_size = DGST_SIZE_4_8;
10509 parse_func = veracrypt_parse_hash_500000;
10510 sort_by_digest = sort_by_digest_4_8;
10511 opti_type = OPTI_TYPE_ZERO_BYTE;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 1;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 3;
10516 break;
10517
10518 case 13753: hash_type = HASH_TYPE_SHA256;
10519 salt_type = SALT_TYPE_EMBEDDED;
10520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10522 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10523 dgst_size = DGST_SIZE_4_8;
10524 parse_func = veracrypt_parse_hash_500000;
10525 sort_by_digest = sort_by_digest_4_8;
10526 opti_type = OPTI_TYPE_ZERO_BYTE;
10527 dgst_pos0 = 0;
10528 dgst_pos1 = 1;
10529 dgst_pos2 = 2;
10530 dgst_pos3 = 3;
10531 break;
10532
10533 case 13761: hash_type = HASH_TYPE_SHA256;
10534 salt_type = SALT_TYPE_EMBEDDED;
10535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10537 kern_type = KERN_TYPE_VCSHA256_XTS512;
10538 dgst_size = DGST_SIZE_4_8;
10539 parse_func = veracrypt_parse_hash_200000;
10540 sort_by_digest = sort_by_digest_4_8;
10541 opti_type = OPTI_TYPE_ZERO_BYTE;
10542 dgst_pos0 = 0;
10543 dgst_pos1 = 1;
10544 dgst_pos2 = 2;
10545 dgst_pos3 = 3;
10546 break;
10547
10548 case 13762: hash_type = HASH_TYPE_SHA256;
10549 salt_type = SALT_TYPE_EMBEDDED;
10550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10552 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10553 dgst_size = DGST_SIZE_4_8;
10554 parse_func = veracrypt_parse_hash_200000;
10555 sort_by_digest = sort_by_digest_4_8;
10556 opti_type = OPTI_TYPE_ZERO_BYTE;
10557 dgst_pos0 = 0;
10558 dgst_pos1 = 1;
10559 dgst_pos2 = 2;
10560 dgst_pos3 = 3;
10561 break;
10562
10563 case 13763: hash_type = HASH_TYPE_SHA256;
10564 salt_type = SALT_TYPE_EMBEDDED;
10565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10566 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10567 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10568 dgst_size = DGST_SIZE_4_8;
10569 parse_func = veracrypt_parse_hash_200000;
10570 sort_by_digest = sort_by_digest_4_8;
10571 opti_type = OPTI_TYPE_ZERO_BYTE;
10572 dgst_pos0 = 0;
10573 dgst_pos1 = 1;
10574 dgst_pos2 = 2;
10575 dgst_pos3 = 3;
10576 break;
10577
10578
10579 default: usage_mini_print (PROGNAME); return (-1);
10580 }
10581
10582 /**
10583 * parser
10584 */
10585
10586 data.parse_func = parse_func;
10587
10588 /**
10589 * misc stuff
10590 */
10591
10592 if (hex_salt)
10593 {
10594 if (salt_type == SALT_TYPE_INTERN)
10595 {
10596 opts_type |= OPTS_TYPE_ST_HEX;
10597 }
10598 else
10599 {
10600 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10601
10602 return (-1);
10603 }
10604 }
10605
10606 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10607 | (salt_type == SALT_TYPE_EXTERN)
10608 | (salt_type == SALT_TYPE_EMBEDDED)
10609 | (salt_type == SALT_TYPE_VIRTUAL));
10610
10611 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10612
10613 data.hash_type = hash_type;
10614 data.attack_mode = attack_mode;
10615 data.attack_kern = attack_kern;
10616 data.attack_exec = attack_exec;
10617 data.kern_type = kern_type;
10618 data.opts_type = opts_type;
10619 data.dgst_size = dgst_size;
10620 data.salt_type = salt_type;
10621 data.isSalted = isSalted;
10622 data.sort_by_digest = sort_by_digest;
10623 data.dgst_pos0 = dgst_pos0;
10624 data.dgst_pos1 = dgst_pos1;
10625 data.dgst_pos2 = dgst_pos2;
10626 data.dgst_pos3 = dgst_pos3;
10627
10628 esalt_size = 0;
10629
10630 switch (hash_mode)
10631 {
10632 case 2500: esalt_size = sizeof (wpa_t); break;
10633 case 5300: esalt_size = sizeof (ikepsk_t); break;
10634 case 5400: esalt_size = sizeof (ikepsk_t); break;
10635 case 5500: esalt_size = sizeof (netntlm_t); break;
10636 case 5600: esalt_size = sizeof (netntlm_t); break;
10637 case 6211: esalt_size = sizeof (tc_t); break;
10638 case 6212: esalt_size = sizeof (tc_t); break;
10639 case 6213: esalt_size = sizeof (tc_t); break;
10640 case 6221: esalt_size = sizeof (tc_t); break;
10641 case 6222: esalt_size = sizeof (tc_t); break;
10642 case 6223: esalt_size = sizeof (tc_t); break;
10643 case 6231: esalt_size = sizeof (tc_t); break;
10644 case 6232: esalt_size = sizeof (tc_t); break;
10645 case 6233: esalt_size = sizeof (tc_t); break;
10646 case 6241: esalt_size = sizeof (tc_t); break;
10647 case 6242: esalt_size = sizeof (tc_t); break;
10648 case 6243: esalt_size = sizeof (tc_t); break;
10649 case 6600: esalt_size = sizeof (agilekey_t); break;
10650 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10651 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10652 case 7300: esalt_size = sizeof (rakp_t); break;
10653 case 7500: esalt_size = sizeof (krb5pa_t); break;
10654 case 8200: esalt_size = sizeof (cloudkey_t); break;
10655 case 8800: esalt_size = sizeof (androidfde_t); break;
10656 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10657 case 9400: esalt_size = sizeof (office2007_t); break;
10658 case 9500: esalt_size = sizeof (office2010_t); break;
10659 case 9600: esalt_size = sizeof (office2013_t); break;
10660 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10661 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10662 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10663 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10664 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10665 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10666 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10667 case 10200: esalt_size = sizeof (cram_md5_t); break;
10668 case 10400: esalt_size = sizeof (pdf_t); break;
10669 case 10410: esalt_size = sizeof (pdf_t); break;
10670 case 10420: esalt_size = sizeof (pdf_t); break;
10671 case 10500: esalt_size = sizeof (pdf_t); break;
10672 case 10600: esalt_size = sizeof (pdf_t); break;
10673 case 10700: esalt_size = sizeof (pdf_t); break;
10674 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10675 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10676 case 11400: esalt_size = sizeof (sip_t); break;
10677 case 11600: esalt_size = sizeof (seven_zip_t); break;
10678 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10679 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10680 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10681 case 13000: esalt_size = sizeof (rar5_t); break;
10682 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10683 case 13400: esalt_size = sizeof (keepass_t); break;
10684 case 13500: esalt_size = sizeof (pstoken_t); break;
10685 case 13600: esalt_size = sizeof (zip2_t); break;
10686 case 13711: esalt_size = sizeof (tc_t); break;
10687 case 13712: esalt_size = sizeof (tc_t); break;
10688 case 13713: esalt_size = sizeof (tc_t); break;
10689 case 13721: esalt_size = sizeof (tc_t); break;
10690 case 13722: esalt_size = sizeof (tc_t); break;
10691 case 13723: esalt_size = sizeof (tc_t); break;
10692 case 13731: esalt_size = sizeof (tc_t); break;
10693 case 13732: esalt_size = sizeof (tc_t); break;
10694 case 13733: esalt_size = sizeof (tc_t); break;
10695 case 13741: esalt_size = sizeof (tc_t); break;
10696 case 13742: esalt_size = sizeof (tc_t); break;
10697 case 13743: esalt_size = sizeof (tc_t); break;
10698 case 13751: esalt_size = sizeof (tc_t); break;
10699 case 13752: esalt_size = sizeof (tc_t); break;
10700 case 13753: esalt_size = sizeof (tc_t); break;
10701 case 13761: esalt_size = sizeof (tc_t); break;
10702 case 13762: esalt_size = sizeof (tc_t); break;
10703 case 13763: esalt_size = sizeof (tc_t); break;
10704 }
10705
10706 data.esalt_size = esalt_size;
10707
10708 /**
10709 * choose dictionary parser
10710 */
10711
10712 if (hash_type == HASH_TYPE_LM)
10713 {
10714 get_next_word_func = get_next_word_lm;
10715 }
10716 else if (opts_type & OPTS_TYPE_PT_UPPER)
10717 {
10718 get_next_word_func = get_next_word_uc;
10719 }
10720 else
10721 {
10722 get_next_word_func = get_next_word_std;
10723 }
10724
10725 /**
10726 * dictstat
10727 */
10728
10729 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10730
10731 #ifdef _POSIX
10732 size_t dictstat_nmemb = 0;
10733 #endif
10734
10735 #ifdef _WIN
10736 uint dictstat_nmemb = 0;
10737 #endif
10738
10739 char dictstat[256] = { 0 };
10740
10741 FILE *dictstat_fp = NULL;
10742
10743 if (keyspace == 0)
10744 {
10745 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10746
10747 dictstat_fp = fopen (dictstat, "rb");
10748
10749 if (dictstat_fp)
10750 {
10751 #ifdef _POSIX
10752 struct stat tmpstat;
10753
10754 fstat (fileno (dictstat_fp), &tmpstat);
10755 #endif
10756
10757 #ifdef _WIN
10758 struct stat64 tmpstat;
10759
10760 _fstat64 (fileno (dictstat_fp), &tmpstat);
10761 #endif
10762
10763 if (tmpstat.st_mtime < COMPTIME)
10764 {
10765 /* with v0.15 the format changed so we have to ensure user is using a good version
10766 since there is no version-header in the dictstat file */
10767
10768 fclose (dictstat_fp);
10769
10770 unlink (dictstat);
10771 }
10772 else
10773 {
10774 while (!feof (dictstat_fp))
10775 {
10776 dictstat_t d;
10777
10778 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10779
10780 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10781
10782 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10783 {
10784 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10785
10786 return -1;
10787 }
10788 }
10789
10790 fclose (dictstat_fp);
10791 }
10792 }
10793 }
10794
10795 /**
10796 * potfile
10797 */
10798
10799 char potfile[256] = { 0 };
10800
10801 if (potfile_path == NULL)
10802 {
10803 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10804 }
10805 else
10806 {
10807 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10808 }
10809
10810 data.pot_fp = NULL;
10811
10812 FILE *out_fp = NULL;
10813 FILE *pot_fp = NULL;
10814
10815 if (show == 1 || left == 1)
10816 {
10817 pot_fp = fopen (potfile, "rb");
10818
10819 if (pot_fp == NULL)
10820 {
10821 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10822
10823 return (-1);
10824 }
10825
10826 if (outfile != NULL)
10827 {
10828 if ((out_fp = fopen (outfile, "ab")) == NULL)
10829 {
10830 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10831
10832 fclose (pot_fp);
10833
10834 return (-1);
10835 }
10836 }
10837 else
10838 {
10839 out_fp = stdout;
10840 }
10841 }
10842 else
10843 {
10844 if (potfile_disable == 0)
10845 {
10846 pot_fp = fopen (potfile, "ab");
10847
10848 if (pot_fp == NULL)
10849 {
10850 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10851
10852 return (-1);
10853 }
10854
10855 data.pot_fp = pot_fp;
10856 }
10857 }
10858
10859 pot_t *pot = NULL;
10860
10861 uint pot_cnt = 0;
10862 uint pot_avail = 0;
10863
10864 if (show == 1 || left == 1)
10865 {
10866 SUPPRESS_OUTPUT = 1;
10867
10868 pot_avail = count_lines (pot_fp);
10869
10870 rewind (pot_fp);
10871
10872 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10873
10874 uint pot_hashes_avail = 0;
10875
10876 uint line_num = 0;
10877
10878 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10879
10880 while (!feof (pot_fp))
10881 {
10882 line_num++;
10883
10884 int line_len = fgetl (pot_fp, line_buf);
10885
10886 if (line_len == 0) continue;
10887
10888 char *plain_buf = line_buf + line_len;
10889
10890 pot_t *pot_ptr = &pot[pot_cnt];
10891
10892 hash_t *hashes_buf = &pot_ptr->hash;
10893
10894 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10895 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10896
10897 if (pot_cnt == pot_hashes_avail)
10898 {
10899 uint pos = 0;
10900
10901 for (pos = 0; pos < INCR_POT; pos++)
10902 {
10903 if ((pot_cnt + pos) >= pot_avail) break;
10904
10905 pot_t *tmp_pot = &pot[pot_cnt + pos];
10906
10907 hash_t *tmp_hash = &tmp_pot->hash;
10908
10909 tmp_hash->digest = mymalloc (dgst_size);
10910
10911 if (isSalted)
10912 {
10913 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10914 }
10915
10916 if (esalt_size)
10917 {
10918 tmp_hash->esalt = mymalloc (esalt_size);
10919 }
10920
10921 pot_hashes_avail++;
10922 }
10923 }
10924
10925 int plain_len = 0;
10926
10927 int parser_status;
10928
10929 int iter = MAX_CUT_TRIES;
10930
10931 do
10932 {
10933 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10934 {
10935 if (line_buf[i] == ':')
10936 {
10937 line_len--;
10938
10939 break;
10940 }
10941 }
10942
10943 if (data.hash_mode != 2500)
10944 {
10945 parser_status = parse_func (line_buf, line_len, hashes_buf);
10946 }
10947 else
10948 {
10949 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10950
10951 if (line_len > max_salt_size)
10952 {
10953 parser_status = PARSER_GLOBAL_LENGTH;
10954 }
10955 else
10956 {
10957 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10958
10959 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10960
10961 hashes_buf->salt->salt_len = line_len;
10962
10963 parser_status = PARSER_OK;
10964 }
10965 }
10966
10967 // if NOT parsed without error, we add the ":" to the plain
10968
10969 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10970 {
10971 plain_len++;
10972 plain_buf--;
10973 }
10974
10975 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10976
10977 if (parser_status < PARSER_GLOBAL_ZERO)
10978 {
10979 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10980
10981 continue;
10982 }
10983
10984 if (plain_len >= 255) continue;
10985
10986 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10987
10988 pot_ptr->plain_len = plain_len;
10989
10990 pot_cnt++;
10991 }
10992
10993 myfree (line_buf);
10994
10995 fclose (pot_fp);
10996
10997 SUPPRESS_OUTPUT = 0;
10998
10999 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11000 }
11001
11002 /**
11003 * word len
11004 */
11005
11006 uint pw_min = PW_MIN;
11007 uint pw_max = PW_MAX;
11008
11009 switch (hash_mode)
11010 {
11011 case 125: if (pw_max > 32) pw_max = 32;
11012 break;
11013 case 400: if (pw_max > 40) pw_max = 40;
11014 break;
11015 case 500: if (pw_max > 16) pw_max = 16;
11016 break;
11017 case 1500: if (pw_max > 8) pw_max = 8;
11018 break;
11019 case 1600: if (pw_max > 16) pw_max = 16;
11020 break;
11021 case 1800: if (pw_max > 16) pw_max = 16;
11022 break;
11023 case 2100: if (pw_max > 16) pw_max = 16;
11024 break;
11025 case 2500: if (pw_min < 8) pw_min = 8;
11026 break;
11027 case 3000: if (pw_max > 7) pw_max = 7;
11028 break;
11029 case 5200: if (pw_max > 24) pw_max = 24;
11030 break;
11031 case 5800: if (pw_max > 16) pw_max = 16;
11032 break;
11033 case 6300: if (pw_max > 16) pw_max = 16;
11034 break;
11035 case 7400: if (pw_max > 16) pw_max = 16;
11036 break;
11037 case 7900: if (pw_max > 48) pw_max = 48;
11038 break;
11039 case 8500: if (pw_max > 8) pw_max = 8;
11040 break;
11041 case 8600: if (pw_max > 16) pw_max = 16;
11042 break;
11043 case 9710: pw_min = 5;
11044 pw_max = 5;
11045 break;
11046 case 9810: pw_min = 5;
11047 pw_max = 5;
11048 break;
11049 case 10410: pw_min = 5;
11050 pw_max = 5;
11051 break;
11052 case 10300: if (pw_max < 3) pw_min = 3;
11053 if (pw_max > 40) pw_max = 40;
11054 break;
11055 case 10500: if (pw_max < 3) pw_min = 3;
11056 if (pw_max > 40) pw_max = 40;
11057 break;
11058 case 10700: if (pw_max > 16) pw_max = 16;
11059 break;
11060 case 11300: if (pw_max > 40) pw_max = 40;
11061 break;
11062 case 11600: if (pw_max > 32) pw_max = 32;
11063 break;
11064 case 12500: if (pw_max > 20) pw_max = 20;
11065 break;
11066 case 12800: if (pw_max > 24) pw_max = 24;
11067 break;
11068 }
11069
11070 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11071 {
11072 switch (attack_kern)
11073 {
11074 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11075 break;
11076 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11077 break;
11078 }
11079 }
11080
11081 /**
11082 * charsets : keep them together for more easy maintainnce
11083 */
11084
11085 cs_t mp_sys[6] = { { { 0 }, 0 } };
11086 cs_t mp_usr[4] = { { { 0 }, 0 } };
11087
11088 mp_setup_sys (mp_sys);
11089
11090 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11091 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11092 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11093 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11094
11095 /**
11096 * load hashes, part I: find input mode, count hashes
11097 */
11098
11099 uint hashlist_mode = 0;
11100 uint hashlist_format = HLFMT_HASHCAT;
11101
11102 uint hashes_avail = 0;
11103
11104 if (benchmark == 0)
11105 {
11106 struct stat f;
11107
11108 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11109
11110 if ((hash_mode == 2500) ||
11111 (hash_mode == 5200) ||
11112 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11113 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11114 (hash_mode == 9000))
11115 {
11116 hashlist_mode = HL_MODE_ARG;
11117
11118 char *hashfile = myargv[optind];
11119
11120 data.hashfile = hashfile;
11121
11122 logfile_top_var_string ("target", hashfile);
11123 }
11124
11125 if (hashlist_mode == HL_MODE_ARG)
11126 {
11127 if (hash_mode == 2500)
11128 {
11129 struct stat st;
11130
11131 if (stat (data.hashfile, &st) == -1)
11132 {
11133 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11134
11135 return (-1);
11136 }
11137
11138 hashes_avail = st.st_size / sizeof (hccap_t);
11139 }
11140 else
11141 {
11142 hashes_avail = 1;
11143 }
11144 }
11145 else if (hashlist_mode == HL_MODE_FILE)
11146 {
11147 char *hashfile = myargv[optind];
11148
11149 data.hashfile = hashfile;
11150
11151 logfile_top_var_string ("target", hashfile);
11152
11153 FILE *fp = NULL;
11154
11155 if ((fp = fopen (hashfile, "rb")) == NULL)
11156 {
11157 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11158
11159 return (-1);
11160 }
11161
11162 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11163
11164 hashes_avail = count_lines (fp);
11165
11166 rewind (fp);
11167
11168 if (hashes_avail == 0)
11169 {
11170 log_error ("ERROR: hashfile is empty or corrupt");
11171
11172 fclose (fp);
11173
11174 return (-1);
11175 }
11176
11177 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11178
11179 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11180 {
11181 log_error ("ERROR: remove not supported in native hashfile-format mode");
11182
11183 fclose (fp);
11184
11185 return (-1);
11186 }
11187
11188 fclose (fp);
11189 }
11190 }
11191 else
11192 {
11193 hashlist_mode = HL_MODE_ARG;
11194
11195 hashes_avail = 1;
11196 }
11197
11198 if (hash_mode == 3000) hashes_avail *= 2;
11199
11200 data.hashlist_mode = hashlist_mode;
11201 data.hashlist_format = hashlist_format;
11202
11203 logfile_top_uint (hashlist_mode);
11204 logfile_top_uint (hashlist_format);
11205
11206 /**
11207 * load hashes, part II: allocate required memory, set pointers
11208 */
11209
11210 hash_t *hashes_buf = NULL;
11211 void *digests_buf = NULL;
11212 salt_t *salts_buf = NULL;
11213 void *esalts_buf = NULL;
11214
11215 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11216
11217 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11218
11219 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11220 {
11221 u32 hash_pos;
11222
11223 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11224 {
11225 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11226
11227 hashes_buf[hash_pos].hash_info = hash_info;
11228
11229 if (username && (remove || show || left))
11230 {
11231 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11232 }
11233
11234 if (benchmark)
11235 {
11236 hash_info->orighash = (char *) mymalloc (256);
11237 }
11238 }
11239 }
11240
11241 if (isSalted)
11242 {
11243 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11244
11245 if (esalt_size)
11246 {
11247 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11248 }
11249 }
11250 else
11251 {
11252 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11253 }
11254
11255 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11256 {
11257 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11258
11259 if (isSalted)
11260 {
11261 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11262
11263 if (esalt_size)
11264 {
11265 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11266 }
11267 }
11268 else
11269 {
11270 hashes_buf[hash_pos].salt = &salts_buf[0];
11271 }
11272 }
11273
11274 /**
11275 * load hashes, part III: parse hashes or generate them if benchmark
11276 */
11277
11278 uint hashes_cnt = 0;
11279
11280 if (benchmark == 0)
11281 {
11282 if (keyspace == 1)
11283 {
11284 // useless to read hash file for keyspace, cheat a little bit w/ optind
11285 }
11286 else if (hashes_avail == 0)
11287 {
11288 }
11289 else if (hashlist_mode == HL_MODE_ARG)
11290 {
11291 char *input_buf = myargv[optind];
11292
11293 uint input_len = strlen (input_buf);
11294
11295 logfile_top_var_string ("target", input_buf);
11296
11297 char *hash_buf = NULL;
11298 int hash_len = 0;
11299
11300 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11301
11302 bool hash_fmt_error = 0;
11303
11304 if (hash_len < 1) hash_fmt_error = 1;
11305 if (hash_buf == NULL) hash_fmt_error = 1;
11306
11307 if (hash_fmt_error)
11308 {
11309 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11310 }
11311 else
11312 {
11313 if (opts_type & OPTS_TYPE_HASH_COPY)
11314 {
11315 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11316
11317 hash_info_tmp->orighash = mystrdup (hash_buf);
11318 }
11319
11320 if (isSalted)
11321 {
11322 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11323 }
11324
11325 int parser_status = PARSER_OK;
11326
11327 if (hash_mode == 2500)
11328 {
11329 if (hash_len == 0)
11330 {
11331 log_error ("ERROR: hccap file not specified");
11332
11333 return (-1);
11334 }
11335
11336 hashlist_mode = HL_MODE_FILE;
11337
11338 data.hashlist_mode = hashlist_mode;
11339
11340 FILE *fp = fopen (hash_buf, "rb");
11341
11342 if (fp == NULL)
11343 {
11344 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11345
11346 return (-1);
11347 }
11348
11349 if (hashes_avail < 1)
11350 {
11351 log_error ("ERROR: hccap file is empty or corrupt");
11352
11353 fclose (fp);
11354
11355 return (-1);
11356 }
11357
11358 uint hccap_size = sizeof (hccap_t);
11359
11360 char *in = (char *) mymalloc (hccap_size);
11361
11362 while (!feof (fp))
11363 {
11364 int n = fread (in, hccap_size, 1, fp);
11365
11366 if (n != 1)
11367 {
11368 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11369
11370 break;
11371 }
11372
11373 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11374
11375 if (parser_status != PARSER_OK)
11376 {
11377 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11378
11379 continue;
11380 }
11381
11382 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11383
11384 if ((show == 1) || (left == 1))
11385 {
11386 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11387
11388 char *salt_ptr = (char *) tmp_salt->salt_buf;
11389
11390 int cur_pos = tmp_salt->salt_len;
11391 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11392
11393 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11394
11395 // do the appending task
11396
11397 snprintf (salt_ptr + cur_pos,
11398 rem_len,
11399 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11400 wpa->orig_mac1[0],
11401 wpa->orig_mac1[1],
11402 wpa->orig_mac1[2],
11403 wpa->orig_mac1[3],
11404 wpa->orig_mac1[4],
11405 wpa->orig_mac1[5],
11406 wpa->orig_mac2[0],
11407 wpa->orig_mac2[1],
11408 wpa->orig_mac2[2],
11409 wpa->orig_mac2[3],
11410 wpa->orig_mac2[4],
11411 wpa->orig_mac2[5]);
11412
11413 // memset () the remaining part of the salt
11414
11415 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11416 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11417
11418 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11419
11420 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11421 }
11422
11423 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);
11424 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);
11425
11426 hashes_cnt++;
11427 }
11428
11429 fclose (fp);
11430
11431 myfree (in);
11432 }
11433 else if (hash_mode == 3000)
11434 {
11435 if (hash_len == 32)
11436 {
11437 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11438
11439 hash_t *lm_hash_left = NULL;
11440
11441 if (parser_status == PARSER_OK)
11442 {
11443 lm_hash_left = &hashes_buf[hashes_cnt];
11444
11445 hashes_cnt++;
11446 }
11447 else
11448 {
11449 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11450 }
11451
11452 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11453
11454 hash_t *lm_hash_right = NULL;
11455
11456 if (parser_status == PARSER_OK)
11457 {
11458 lm_hash_right = &hashes_buf[hashes_cnt];
11459
11460 hashes_cnt++;
11461 }
11462 else
11463 {
11464 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11465 }
11466
11467 // show / left
11468
11469 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11470 {
11471 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);
11472 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);
11473 }
11474 }
11475 else
11476 {
11477 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11478
11479 if (parser_status == PARSER_OK)
11480 {
11481 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11482 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11483 }
11484
11485 if (parser_status == PARSER_OK)
11486 {
11487 hashes_cnt++;
11488 }
11489 else
11490 {
11491 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11492 }
11493 }
11494 }
11495 else
11496 {
11497 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11498
11499 if (parser_status == PARSER_OK)
11500 {
11501 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11502 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11503 }
11504
11505 if (parser_status == PARSER_OK)
11506 {
11507 hashes_cnt++;
11508 }
11509 else
11510 {
11511 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11512 }
11513 }
11514 }
11515 }
11516 else if (hashlist_mode == HL_MODE_FILE)
11517 {
11518 char *hashfile = data.hashfile;
11519
11520 FILE *fp;
11521
11522 if ((fp = fopen (hashfile, "rb")) == NULL)
11523 {
11524 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11525
11526 return (-1);
11527 }
11528
11529 uint line_num = 0;
11530
11531 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11532
11533 while (!feof (fp))
11534 {
11535 line_num++;
11536
11537 int line_len = fgetl (fp, line_buf);
11538
11539 if (line_len == 0) continue;
11540
11541 char *hash_buf = NULL;
11542 int hash_len = 0;
11543
11544 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11545
11546 bool hash_fmt_error = 0;
11547
11548 if (hash_len < 1) hash_fmt_error = 1;
11549 if (hash_buf == NULL) hash_fmt_error = 1;
11550
11551 if (hash_fmt_error)
11552 {
11553 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11554
11555 continue;
11556 }
11557
11558 if (username)
11559 {
11560 char *user_buf = NULL;
11561 int user_len = 0;
11562
11563 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11564
11565 if (remove || show)
11566 {
11567 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11568
11569 *user = (user_t *) mymalloc (sizeof (user_t));
11570
11571 user_t *user_ptr = *user;
11572
11573 if (user_buf != NULL)
11574 {
11575 user_ptr->user_name = mystrdup (user_buf);
11576 }
11577 else
11578 {
11579 user_ptr->user_name = mystrdup ("");
11580 }
11581
11582 user_ptr->user_len = user_len;
11583 }
11584 }
11585
11586 if (opts_type & OPTS_TYPE_HASH_COPY)
11587 {
11588 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11589
11590 hash_info_tmp->orighash = mystrdup (hash_buf);
11591 }
11592
11593 if (isSalted)
11594 {
11595 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11596 }
11597
11598 if (hash_mode == 3000)
11599 {
11600 if (hash_len == 32)
11601 {
11602 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11603
11604 if (parser_status < PARSER_GLOBAL_ZERO)
11605 {
11606 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11607
11608 continue;
11609 }
11610
11611 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11612
11613 hashes_cnt++;
11614
11615 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11616
11617 if (parser_status < PARSER_GLOBAL_ZERO)
11618 {
11619 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11620
11621 continue;
11622 }
11623
11624 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11625
11626 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);
11627
11628 hashes_cnt++;
11629
11630 // show / left
11631
11632 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);
11633 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);
11634 }
11635 else
11636 {
11637 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11638
11639 if (parser_status < PARSER_GLOBAL_ZERO)
11640 {
11641 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11642
11643 continue;
11644 }
11645
11646 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);
11647
11648 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11649 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11650
11651 hashes_cnt++;
11652 }
11653 }
11654 else
11655 {
11656 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11657
11658 if (parser_status < PARSER_GLOBAL_ZERO)
11659 {
11660 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11661
11662 continue;
11663 }
11664
11665 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);
11666
11667 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11668 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11669
11670 hashes_cnt++;
11671 }
11672 }
11673
11674 myfree (line_buf);
11675
11676 fclose (fp);
11677
11678 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11679
11680 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11681 }
11682 }
11683 else
11684 {
11685 if (isSalted)
11686 {
11687 hashes_buf[0].salt->salt_len = 8;
11688
11689 // special salt handling
11690
11691 switch (hash_mode)
11692 {
11693 case 1500: hashes_buf[0].salt->salt_len = 2;
11694 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11695 break;
11696 case 1731: hashes_buf[0].salt->salt_len = 4;
11697 break;
11698 case 2410: hashes_buf[0].salt->salt_len = 4;
11699 break;
11700 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11701 break;
11702 case 3100: hashes_buf[0].salt->salt_len = 1;
11703 break;
11704 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11705 break;
11706 case 5800: hashes_buf[0].salt->salt_len = 16;
11707 break;
11708 case 6800: hashes_buf[0].salt->salt_len = 32;
11709 break;
11710 case 8400: hashes_buf[0].salt->salt_len = 40;
11711 break;
11712 case 8800: hashes_buf[0].salt->salt_len = 16;
11713 break;
11714 case 8900: hashes_buf[0].salt->salt_len = 16;
11715 hashes_buf[0].salt->scrypt_N = 1024;
11716 hashes_buf[0].salt->scrypt_r = 1;
11717 hashes_buf[0].salt->scrypt_p = 1;
11718 break;
11719 case 9100: hashes_buf[0].salt->salt_len = 16;
11720 break;
11721 case 9300: hashes_buf[0].salt->salt_len = 14;
11722 hashes_buf[0].salt->scrypt_N = 16384;
11723 hashes_buf[0].salt->scrypt_r = 1;
11724 hashes_buf[0].salt->scrypt_p = 1;
11725 break;
11726 case 9400: hashes_buf[0].salt->salt_len = 16;
11727 break;
11728 case 9500: hashes_buf[0].salt->salt_len = 16;
11729 break;
11730 case 9600: hashes_buf[0].salt->salt_len = 16;
11731 break;
11732 case 9700: hashes_buf[0].salt->salt_len = 16;
11733 break;
11734 case 9710: hashes_buf[0].salt->salt_len = 16;
11735 break;
11736 case 9720: hashes_buf[0].salt->salt_len = 16;
11737 break;
11738 case 9800: hashes_buf[0].salt->salt_len = 16;
11739 break;
11740 case 9810: hashes_buf[0].salt->salt_len = 16;
11741 break;
11742 case 9820: hashes_buf[0].salt->salt_len = 16;
11743 break;
11744 case 10300: hashes_buf[0].salt->salt_len = 12;
11745 break;
11746 case 11500: hashes_buf[0].salt->salt_len = 4;
11747 break;
11748 case 11600: hashes_buf[0].salt->salt_len = 4;
11749 break;
11750 case 12400: hashes_buf[0].salt->salt_len = 4;
11751 break;
11752 case 12500: hashes_buf[0].salt->salt_len = 8;
11753 break;
11754 case 12600: hashes_buf[0].salt->salt_len = 64;
11755 break;
11756 }
11757
11758 // special esalt handling
11759
11760 switch (hash_mode)
11761 {
11762 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11763 break;
11764 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11765 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11766 break;
11767 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11768 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11769 break;
11770 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11771 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11772 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11773 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11774 break;
11775 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11776 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11777 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11778 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11779 break;
11780 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11781 break;
11782 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11783 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11784 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11785 break;
11786 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11787 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11788 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11789 break;
11790 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11791 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11792 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11793 break;
11794 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11795 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11796 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11797 break;
11798 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11799 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11800 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11801 break;
11802 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11803 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11804 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11805 break;
11806 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11807 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11808 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11809 break;
11810 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11811 break;
11812 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11813 break;
11814 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11815 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11816 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11817 break;
11818 }
11819 }
11820
11821 // set hashfile
11822
11823 switch (hash_mode)
11824 {
11825 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11826 break;
11827 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11828 break;
11829 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11830 break;
11831 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11832 break;
11833 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11834 break;
11835 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11836 break;
11837 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11838 break;
11839 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11840 break;
11841 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11842 break;
11843 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11844 break;
11845 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11846 break;
11847 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11848 break;
11849 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11850 break;
11851 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11852 break;
11853 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11854 break;
11855 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11856 break;
11857 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11858 break;
11859 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11860 break;
11861 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11862 break;
11863 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11864 break;
11865 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11866 break;
11867 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11868 break;
11869 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11870 break;
11871 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11872 break;
11873 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11874 break;
11875 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11876 break;
11877 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11878 break;
11879 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11880 break;
11881 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11882 break;
11883 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11884 break;
11885 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11886 break;
11887 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11888 break;
11889 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 }
11898
11899 // set default iterations
11900
11901 switch (hash_mode)
11902 {
11903 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11904 break;
11905 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11906 break;
11907 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11908 break;
11909 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11910 break;
11911 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11912 break;
11913 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11914 break;
11915 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11916 break;
11917 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11918 break;
11919 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11920 break;
11921 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11922 break;
11923 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11924 break;
11925 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11926 break;
11927 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11928 break;
11929 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11930 break;
11931 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11932 break;
11933 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11934 break;
11935 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11936 break;
11937 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11938 break;
11939 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11940 break;
11941 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11942 break;
11943 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11944 break;
11945 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11946 break;
11947 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11948 break;
11949 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11950 break;
11951 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11952 break;
11953 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11954 break;
11955 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11956 break;
11957 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11958 break;
11959 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11960 break;
11961 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11962 break;
11963 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11964 break;
11965 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11966 break;
11967 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11968 break;
11969 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11970 break;
11971 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11972 break;
11973 case 8900: hashes_buf[0].salt->salt_iter = 1;
11974 break;
11975 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11976 break;
11977 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11978 break;
11979 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11980 break;
11981 case 9300: hashes_buf[0].salt->salt_iter = 1;
11982 break;
11983 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11984 break;
11985 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11986 break;
11987 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11988 break;
11989 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11990 break;
11991 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11992 break;
11993 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11994 break;
11995 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11996 break;
11997 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11998 break;
11999 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12000 break;
12001 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12002 break;
12003 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12004 break;
12005 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12006 break;
12007 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12008 break;
12009 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12010 break;
12011 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12012 break;
12013 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12014 break;
12015 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12016 break;
12017 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12018 break;
12019 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12020 break;
12021 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12022 break;
12023 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12024 break;
12025 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12026 break;
12027 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12028 break;
12029 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12030 break;
12031 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12032 break;
12033 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12034 break;
12035 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12036 break;
12037 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12038 break;
12039 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12040 break;
12041 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12042 break;
12043 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12044 break;
12045 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12046 break;
12047 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12048 break;
12049 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12050 break;
12051 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12052 break;
12053 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12054 break;
12055 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12056 break;
12057 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12058 break;
12059 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12060 break;
12061 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12062 break;
12063 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12064 break;
12065 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12066 break;
12067 }
12068
12069 hashes_cnt = 1;
12070 }
12071
12072 if (show == 1 || left == 1)
12073 {
12074 for (uint i = 0; i < pot_cnt; i++)
12075 {
12076 pot_t *pot_ptr = &pot[i];
12077
12078 hash_t *hashes_buf = &pot_ptr->hash;
12079
12080 local_free (hashes_buf->digest);
12081
12082 if (isSalted)
12083 {
12084 local_free (hashes_buf->salt);
12085 }
12086 }
12087
12088 local_free (pot);
12089
12090 if (data.quiet == 0) log_info_nn ("");
12091
12092 return (0);
12093 }
12094
12095 if (keyspace == 0)
12096 {
12097 if (hashes_cnt == 0)
12098 {
12099 log_error ("ERROR: No hashes loaded");
12100
12101 return (-1);
12102 }
12103 }
12104
12105 /**
12106 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12107 */
12108
12109 if (data.outfile != NULL)
12110 {
12111 if (data.hashfile != NULL)
12112 {
12113 #ifdef _POSIX
12114 struct stat tmpstat_outfile;
12115 struct stat tmpstat_hashfile;
12116 #endif
12117
12118 #ifdef _WIN
12119 struct stat64 tmpstat_outfile;
12120 struct stat64 tmpstat_hashfile;
12121 #endif
12122
12123 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12124
12125 if (tmp_outfile_fp)
12126 {
12127 #ifdef _POSIX
12128 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12129 #endif
12130
12131 #ifdef _WIN
12132 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12133 #endif
12134
12135 fclose (tmp_outfile_fp);
12136 }
12137
12138 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12139
12140 if (tmp_hashfile_fp)
12141 {
12142 #ifdef _POSIX
12143 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12144 #endif
12145
12146 #ifdef _WIN
12147 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12148 #endif
12149
12150 fclose (tmp_hashfile_fp);
12151 }
12152
12153 if (tmp_outfile_fp && tmp_outfile_fp)
12154 {
12155 tmpstat_outfile.st_mode = 0;
12156 tmpstat_outfile.st_nlink = 0;
12157 tmpstat_outfile.st_uid = 0;
12158 tmpstat_outfile.st_gid = 0;
12159 tmpstat_outfile.st_rdev = 0;
12160 tmpstat_outfile.st_atime = 0;
12161
12162 tmpstat_hashfile.st_mode = 0;
12163 tmpstat_hashfile.st_nlink = 0;
12164 tmpstat_hashfile.st_uid = 0;
12165 tmpstat_hashfile.st_gid = 0;
12166 tmpstat_hashfile.st_rdev = 0;
12167 tmpstat_hashfile.st_atime = 0;
12168
12169 #ifdef _POSIX
12170 tmpstat_outfile.st_blksize = 0;
12171 tmpstat_outfile.st_blocks = 0;
12172
12173 tmpstat_hashfile.st_blksize = 0;
12174 tmpstat_hashfile.st_blocks = 0;
12175 #endif
12176
12177 #ifdef _POSIX
12178 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12179 {
12180 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12181
12182 return (-1);
12183 }
12184 #endif
12185
12186 #ifdef _WIN
12187 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12188 {
12189 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12190
12191 return (-1);
12192 }
12193 #endif
12194 }
12195 }
12196 }
12197
12198 /**
12199 * Remove duplicates
12200 */
12201
12202 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12203
12204 if (isSalted)
12205 {
12206 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12207 }
12208 else
12209 {
12210 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12211 }
12212
12213 uint hashes_cnt_orig = hashes_cnt;
12214
12215 hashes_cnt = 1;
12216
12217 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12218 {
12219 if (isSalted)
12220 {
12221 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12222 {
12223 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12224 }
12225 }
12226 else
12227 {
12228 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12229 }
12230
12231 if (hashes_pos > hashes_cnt)
12232 {
12233 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12234 }
12235
12236 hashes_cnt++;
12237 }
12238
12239 /**
12240 * Potfile removes
12241 */
12242
12243 uint potfile_remove_cracks = 0;
12244
12245 if (potfile_disable == 0)
12246 {
12247 hash_t hash_buf;
12248
12249 hash_buf.digest = mymalloc (dgst_size);
12250 hash_buf.salt = NULL;
12251 hash_buf.esalt = NULL;
12252 hash_buf.hash_info = NULL;
12253 hash_buf.cracked = 0;
12254
12255 if (isSalted)
12256 {
12257 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12258 }
12259
12260 if (esalt_size)
12261 {
12262 hash_buf.esalt = mymalloc (esalt_size);
12263 }
12264
12265 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12266
12267 // no solution for these special hash types (for instane because they use hashfile in output etc)
12268 if ((hash_mode != 5200) &&
12269 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12270 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12271 (hash_mode != 9000))
12272 {
12273 FILE *fp = fopen (potfile, "rb");
12274
12275 if (fp != NULL)
12276 {
12277 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12278
12279 // to be safe work with a copy (because of line_len loop, i etc)
12280 // moved up here because it's easier to handle continue case
12281 // it's just 64kb
12282
12283 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12284
12285 while (!feof (fp))
12286 {
12287 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12288
12289 if (ptr == NULL) break;
12290
12291 int line_len = strlen (line_buf);
12292
12293 if (line_len == 0) continue;
12294
12295 int iter = MAX_CUT_TRIES;
12296
12297 for (int i = line_len - 1; i && iter; i--, line_len--)
12298 {
12299 if (line_buf[i] != ':') continue;
12300
12301 if (isSalted)
12302 {
12303 memset (hash_buf.salt, 0, sizeof (salt_t));
12304 }
12305
12306 hash_t *found = NULL;
12307
12308 if (hash_mode == 6800)
12309 {
12310 if (i < 64) // 64 = 16 * uint in salt_buf[]
12311 {
12312 // manipulate salt_buf
12313 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12314
12315 hash_buf.salt->salt_len = i;
12316
12317 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12318 }
12319 }
12320 else if (hash_mode == 2500)
12321 {
12322 if (i < 64) // 64 = 16 * uint in salt_buf[]
12323 {
12324 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12325 // manipulate salt_buf
12326
12327 memcpy (line_buf_cpy, line_buf, i);
12328
12329 char *mac2_pos = strrchr (line_buf_cpy, ':');
12330
12331 if (mac2_pos == NULL) continue;
12332
12333 mac2_pos[0] = 0;
12334 mac2_pos++;
12335
12336 if (strlen (mac2_pos) != 12) continue;
12337
12338 char *mac1_pos = strrchr (line_buf_cpy, ':');
12339
12340 if (mac1_pos == NULL) continue;
12341
12342 mac1_pos[0] = 0;
12343 mac1_pos++;
12344
12345 if (strlen (mac1_pos) != 12) continue;
12346
12347 uint essid_length = mac1_pos - line_buf_cpy - 1;
12348
12349 // here we need the ESSID
12350 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12351
12352 hash_buf.salt->salt_len = essid_length;
12353
12354 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12355
12356 if (found)
12357 {
12358 wpa_t *wpa = (wpa_t *) found->esalt;
12359
12360 // compare hex string(s) vs binary MAC address(es)
12361
12362 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12363 {
12364 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12365 {
12366 found = NULL;
12367
12368 break;
12369 }
12370 }
12371
12372 // early skip ;)
12373 if (!found) continue;
12374
12375 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12376 {
12377 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12378 {
12379 found = NULL;
12380
12381 break;
12382 }
12383 }
12384 }
12385 }
12386 }
12387 else
12388 {
12389 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12390
12391 if (parser_status == PARSER_OK)
12392 {
12393 if (isSalted)
12394 {
12395 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12396 }
12397 else
12398 {
12399 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12400 }
12401 }
12402 }
12403
12404 if (found == NULL) continue;
12405
12406 if (!found->cracked) potfile_remove_cracks++;
12407
12408 found->cracked = 1;
12409
12410 if (found) break;
12411
12412 iter--;
12413 }
12414 }
12415
12416 myfree (line_buf_cpy);
12417
12418 myfree (line_buf);
12419
12420 fclose (fp);
12421 }
12422 }
12423
12424 if (esalt_size)
12425 {
12426 local_free (hash_buf.esalt);
12427 }
12428
12429 if (isSalted)
12430 {
12431 local_free (hash_buf.salt);
12432 }
12433
12434 local_free (hash_buf.digest);
12435 }
12436
12437 /**
12438 * Now generate all the buffers required for later
12439 */
12440
12441 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12442
12443 salt_t *salts_buf_new = NULL;
12444 void *esalts_buf_new = NULL;
12445
12446 if (isSalted)
12447 {
12448 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12449
12450 if (esalt_size)
12451 {
12452 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12453 }
12454 }
12455 else
12456 {
12457 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12458 }
12459
12460 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12461
12462 uint digests_cnt = hashes_cnt;
12463 uint digests_done = 0;
12464
12465 size_t size_digests = digests_cnt * dgst_size;
12466 size_t size_shown = digests_cnt * sizeof (uint);
12467
12468 uint *digests_shown = (uint *) mymalloc (size_shown);
12469 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12470
12471 uint salts_cnt = 0;
12472 uint salts_done = 0;
12473
12474 hashinfo_t **hash_info = NULL;
12475
12476 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12477 {
12478 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12479
12480 if (username && (remove || show))
12481 {
12482 uint user_pos;
12483
12484 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12485 {
12486 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12487
12488 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12489 }
12490 }
12491 }
12492
12493 uint *salts_shown = (uint *) mymalloc (size_shown);
12494
12495 salt_t *salt_buf;
12496
12497 {
12498 // copied from inner loop
12499
12500 salt_buf = &salts_buf_new[salts_cnt];
12501
12502 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12503
12504 if (esalt_size)
12505 {
12506 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12507 }
12508
12509 salt_buf->digests_cnt = 0;
12510 salt_buf->digests_done = 0;
12511 salt_buf->digests_offset = 0;
12512
12513 salts_cnt++;
12514 }
12515
12516 if (hashes_buf[0].cracked == 1)
12517 {
12518 digests_shown[0] = 1;
12519
12520 digests_done++;
12521
12522 salt_buf->digests_done++;
12523 }
12524
12525 salt_buf->digests_cnt++;
12526
12527 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12528
12529 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12530 {
12531 hash_info[0] = hashes_buf[0].hash_info;
12532 }
12533
12534 // copy from inner loop
12535
12536 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12537 {
12538 if (isSalted)
12539 {
12540 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12541 {
12542 salt_buf = &salts_buf_new[salts_cnt];
12543
12544 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12545
12546 if (esalt_size)
12547 {
12548 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12549 }
12550
12551 salt_buf->digests_cnt = 0;
12552 salt_buf->digests_done = 0;
12553 salt_buf->digests_offset = hashes_pos;
12554
12555 salts_cnt++;
12556 }
12557 }
12558
12559 if (hashes_buf[hashes_pos].cracked == 1)
12560 {
12561 digests_shown[hashes_pos] = 1;
12562
12563 digests_done++;
12564
12565 salt_buf->digests_done++;
12566 }
12567
12568 salt_buf->digests_cnt++;
12569
12570 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12571
12572 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12573 {
12574 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12575 }
12576 }
12577
12578 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12579 {
12580 salt_t *salt_buf = &salts_buf_new[salt_pos];
12581
12582 if (salt_buf->digests_done == salt_buf->digests_cnt)
12583 {
12584 salts_shown[salt_pos] = 1;
12585
12586 salts_done++;
12587 }
12588
12589 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12590 }
12591
12592 local_free (digests_buf);
12593 local_free (salts_buf);
12594 local_free (esalts_buf);
12595
12596 digests_buf = digests_buf_new;
12597 salts_buf = salts_buf_new;
12598 esalts_buf = esalts_buf_new;
12599
12600 local_free (hashes_buf);
12601
12602 /**
12603 * special modification not set from parser
12604 */
12605
12606 switch (hash_mode)
12607 {
12608 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12609 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12610 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12611 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12612 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12613 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12614 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12615 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12616 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12617 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12618 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12619 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12620 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12621 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12622 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12623 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12624 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12625 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12626 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12627 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12628 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12629 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12630 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12631 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12632 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12633 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12634 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12635 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12636 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12637 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12638 }
12639
12640 if (truecrypt_keyfiles)
12641 {
12642 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12643
12644 char *keyfiles = strdup (truecrypt_keyfiles);
12645
12646 char *keyfile = strtok (keyfiles, ",");
12647
12648 do
12649 {
12650 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12651
12652 } while ((keyfile = strtok (NULL, ",")) != NULL);
12653
12654 free (keyfiles);
12655 }
12656
12657 if (veracrypt_keyfiles)
12658 {
12659 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12660
12661 char *keyfiles = strdup (veracrypt_keyfiles);
12662
12663 char *keyfile = strtok (keyfiles, ",");
12664
12665 do
12666 {
12667 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12668
12669 } while ((keyfile = strtok (NULL, ",")) != NULL);
12670
12671 free (keyfiles);
12672 }
12673
12674 data.digests_cnt = digests_cnt;
12675 data.digests_done = digests_done;
12676 data.digests_buf = digests_buf;
12677 data.digests_shown = digests_shown;
12678 data.digests_shown_tmp = digests_shown_tmp;
12679
12680 data.salts_cnt = salts_cnt;
12681 data.salts_done = salts_done;
12682 data.salts_buf = salts_buf;
12683 data.salts_shown = salts_shown;
12684
12685 data.esalts_buf = esalts_buf;
12686 data.hash_info = hash_info;
12687
12688 /**
12689 * Automatic Optimizers
12690 */
12691
12692 if (salts_cnt == 1)
12693 opti_type |= OPTI_TYPE_SINGLE_SALT;
12694
12695 if (digests_cnt == 1)
12696 opti_type |= OPTI_TYPE_SINGLE_HASH;
12697
12698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12699 opti_type |= OPTI_TYPE_NOT_ITERATED;
12700
12701 if (attack_mode == ATTACK_MODE_BF)
12702 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12703
12704 data.opti_type = opti_type;
12705
12706 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12707 {
12708 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12709 {
12710 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12711 {
12712 if (opts_type & OPTS_TYPE_ST_ADD80)
12713 {
12714 opts_type &= ~OPTS_TYPE_ST_ADD80;
12715 opts_type |= OPTS_TYPE_PT_ADD80;
12716 }
12717
12718 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12719 {
12720 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12721 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12722 }
12723
12724 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12725 {
12726 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12727 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12728 }
12729 }
12730 }
12731 }
12732
12733 /**
12734 * Some algorithm, like descrypt, can benefit from JIT compilation
12735 */
12736
12737 int force_jit_compilation = -1;
12738
12739 if (hash_mode == 8900)
12740 {
12741 force_jit_compilation = 8900;
12742 }
12743 else if (hash_mode == 9300)
12744 {
12745 force_jit_compilation = 8900;
12746 }
12747 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12748 {
12749 force_jit_compilation = 1500;
12750 }
12751
12752 /**
12753 * generate bitmap tables
12754 */
12755
12756 const uint bitmap_shift1 = 5;
12757 const uint bitmap_shift2 = 13;
12758
12759 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12760
12761 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12762 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12763 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12764 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12765 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12766 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12767 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12768 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12769
12770 uint bitmap_bits;
12771 uint bitmap_nums;
12772 uint bitmap_mask;
12773 uint bitmap_size;
12774
12775 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12776 {
12777 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12778
12779 bitmap_nums = 1 << bitmap_bits;
12780
12781 bitmap_mask = bitmap_nums - 1;
12782
12783 bitmap_size = bitmap_nums * sizeof (uint);
12784
12785 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12786
12787 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;
12788 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;
12789
12790 break;
12791 }
12792
12793 bitmap_nums = 1 << bitmap_bits;
12794
12795 bitmap_mask = bitmap_nums - 1;
12796
12797 bitmap_size = bitmap_nums * sizeof (uint);
12798
12799 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);
12800 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);
12801
12802 /**
12803 * prepare quick rule
12804 */
12805
12806 data.rule_buf_l = rule_buf_l;
12807 data.rule_buf_r = rule_buf_r;
12808
12809 int rule_len_l = (int) strlen (rule_buf_l);
12810 int rule_len_r = (int) strlen (rule_buf_r);
12811
12812 data.rule_len_l = rule_len_l;
12813 data.rule_len_r = rule_len_r;
12814
12815 /**
12816 * load rules
12817 */
12818
12819 uint *all_kernel_rules_cnt = NULL;
12820
12821 kernel_rule_t **all_kernel_rules_buf = NULL;
12822
12823 if (rp_files_cnt)
12824 {
12825 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12826
12827 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12828 }
12829
12830 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12831
12832 int rule_len = 0;
12833
12834 for (uint i = 0; i < rp_files_cnt; i++)
12835 {
12836 uint kernel_rules_avail = 0;
12837
12838 uint kernel_rules_cnt = 0;
12839
12840 kernel_rule_t *kernel_rules_buf = NULL;
12841
12842 char *rp_file = rp_files[i];
12843
12844 char in[BLOCK_SIZE] = { 0 };
12845 char out[BLOCK_SIZE] = { 0 };
12846
12847 FILE *fp = NULL;
12848
12849 uint rule_line = 0;
12850
12851 if ((fp = fopen (rp_file, "rb")) == NULL)
12852 {
12853 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12854
12855 return (-1);
12856 }
12857
12858 while (!feof (fp))
12859 {
12860 memset (rule_buf, 0, HCBUFSIZ);
12861
12862 rule_len = fgetl (fp, rule_buf);
12863
12864 rule_line++;
12865
12866 if (rule_len == 0) continue;
12867
12868 if (rule_buf[0] == '#') continue;
12869
12870 if (kernel_rules_avail == kernel_rules_cnt)
12871 {
12872 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12873
12874 kernel_rules_avail += INCR_RULES;
12875 }
12876
12877 memset (in, 0, BLOCK_SIZE);
12878 memset (out, 0, BLOCK_SIZE);
12879
12880 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12881
12882 if (result == -1)
12883 {
12884 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12885
12886 continue;
12887 }
12888
12889 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12890 {
12891 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12892
12893 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12894
12895 continue;
12896 }
12897
12898 /* its so slow
12899 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12900 {
12901 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12902
12903 continue;
12904 }
12905 */
12906
12907 kernel_rules_cnt++;
12908 }
12909
12910 fclose (fp);
12911
12912 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12913
12914 all_kernel_rules_buf[i] = kernel_rules_buf;
12915 }
12916
12917 /**
12918 * merge rules or automatic rule generator
12919 */
12920
12921 uint kernel_rules_cnt = 0;
12922
12923 kernel_rule_t *kernel_rules_buf = NULL;
12924
12925 if (attack_mode == ATTACK_MODE_STRAIGHT)
12926 {
12927 if (rp_files_cnt)
12928 {
12929 kernel_rules_cnt = 1;
12930
12931 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12932
12933 repeats[0] = kernel_rules_cnt;
12934
12935 for (uint i = 0; i < rp_files_cnt; i++)
12936 {
12937 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12938
12939 repeats[i + 1] = kernel_rules_cnt;
12940 }
12941
12942 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12943
12944 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12945
12946 for (uint i = 0; i < kernel_rules_cnt; i++)
12947 {
12948 uint out_pos = 0;
12949
12950 kernel_rule_t *out = &kernel_rules_buf[i];
12951
12952 for (uint j = 0; j < rp_files_cnt; j++)
12953 {
12954 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12955 uint in_pos;
12956
12957 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12958
12959 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12960 {
12961 if (out_pos == RULES_MAX - 1)
12962 {
12963 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12964
12965 break;
12966 }
12967
12968 out->cmds[out_pos] = in->cmds[in_pos];
12969 }
12970 }
12971 }
12972
12973 local_free (repeats);
12974 }
12975 else if (rp_gen)
12976 {
12977 uint kernel_rules_avail = 0;
12978
12979 while (kernel_rules_cnt < rp_gen)
12980 {
12981 if (kernel_rules_avail == kernel_rules_cnt)
12982 {
12983 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12984
12985 kernel_rules_avail += INCR_RULES;
12986 }
12987
12988 memset (rule_buf, 0, HCBUFSIZ);
12989
12990 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12991
12992 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12993
12994 kernel_rules_cnt++;
12995 }
12996 }
12997 }
12998
12999 myfree (rule_buf);
13000
13001 /**
13002 * generate NOP rules
13003 */
13004
13005 if (kernel_rules_cnt == 0)
13006 {
13007 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13008
13009 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13010
13011 kernel_rules_cnt++;
13012 }
13013
13014 data.kernel_rules_cnt = kernel_rules_cnt;
13015 data.kernel_rules_buf = kernel_rules_buf;
13016
13017 /**
13018 * OpenCL platforms: detect
13019 */
13020
13021 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13022 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13023
13024 cl_uint platforms_cnt = 0;
13025 cl_uint platform_devices_cnt = 0;
13026
13027 if (keyspace == 0)
13028 {
13029 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13030
13031 if (platforms_cnt == 0)
13032 {
13033 log_info ("");
13034 log_info ("ATTENTION! No OpenCL compatible platform found");
13035 log_info ("");
13036 log_info ("You're probably missing the OpenCL runtime installation");
13037 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13038 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13039 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13040 log_info ("");
13041
13042 return (-1);
13043 }
13044
13045 if (opencl_platforms_filter != (uint) -1)
13046 {
13047 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13048
13049 if (opencl_platforms_filter > platform_cnt_mask)
13050 {
13051 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13052
13053 return (-1);
13054 }
13055 }
13056 }
13057
13058 /**
13059 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13060 */
13061
13062 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13063 {
13064 cl_platform_id platform = platforms[platform_id];
13065
13066 char platform_vendor[INFOSZ] = { 0 };
13067
13068 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13069
13070 #ifdef HAVE_HWMON
13071 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13072 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13073 {
13074 // make sure that we do not directly control the fan for NVidia
13075
13076 gpu_temp_retain = 0;
13077
13078 data.gpu_temp_retain = gpu_temp_retain;
13079 }
13080 #endif // HAVE_NVML || HAVE_NVAPI
13081 #endif
13082 }
13083
13084 /**
13085 * OpenCL device types:
13086 * 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.
13087 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13088 */
13089
13090 if (opencl_device_types == NULL)
13091 {
13092 cl_device_type device_types_all = 0;
13093
13094 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13095 {
13096 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13097
13098 cl_platform_id platform = platforms[platform_id];
13099
13100 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13101
13102 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13103 {
13104 cl_device_id device = platform_devices[platform_devices_id];
13105
13106 cl_device_type device_type;
13107
13108 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13109
13110 device_types_all |= device_type;
13111 }
13112 }
13113
13114 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13115 {
13116 device_types_filter |= CL_DEVICE_TYPE_CPU;
13117 }
13118 }
13119
13120 /**
13121 * OpenCL devices: simply push all devices from all platforms into the same device array
13122 */
13123
13124 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13125
13126 data.devices_param = devices_param;
13127
13128 uint devices_cnt = 0;
13129
13130 uint devices_active = 0;
13131
13132 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13133 {
13134 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13135
13136 cl_platform_id platform = platforms[platform_id];
13137
13138 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13139
13140 char platform_vendor[INFOSZ] = { 0 };
13141
13142 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13143
13144 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13145 // this causes trouble with vendor id based macros
13146 // we'll assign generic to those without special optimization available
13147
13148 cl_uint vendor_id = 0;
13149
13150 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13151 {
13152 vendor_id = VENDOR_ID_AMD;
13153 }
13154 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13155 {
13156 vendor_id = VENDOR_ID_APPLE;
13157 }
13158 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13159 {
13160 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13161 }
13162 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13163 {
13164 vendor_id = VENDOR_ID_INTEL_SDK;
13165 }
13166 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13167 {
13168 vendor_id = VENDOR_ID_MESA;
13169 }
13170 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13171 {
13172 vendor_id = VENDOR_ID_NV;
13173 }
13174 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13175 {
13176 vendor_id = VENDOR_ID_POCL;
13177 }
13178 else
13179 {
13180 vendor_id = VENDOR_ID_GENERIC;
13181 }
13182
13183 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13184 {
13185 size_t param_value_size = 0;
13186
13187 const uint device_id = devices_cnt;
13188
13189 hc_device_param_t *device_param = &data.devices_param[device_id];
13190
13191 device_param->vendor_id = vendor_id;
13192
13193 device_param->device = platform_devices[platform_devices_id];
13194
13195 device_param->device_id = device_id;
13196
13197 device_param->platform_devices_id = platform_devices_id;
13198
13199 // device_type
13200
13201 cl_device_type device_type;
13202
13203 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13204
13205 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13206
13207 device_param->device_type = device_type;
13208
13209 // device_name
13210
13211 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13212
13213 char *device_name = (char *) mymalloc (param_value_size);
13214
13215 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13216
13217 device_param->device_name = device_name;
13218
13219 // tuning db
13220
13221 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13222
13223 // device_version
13224
13225 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13226
13227 char *device_version = (char *) mymalloc (param_value_size);
13228
13229 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13230
13231 device_param->device_version = device_version;
13232
13233 // device_opencl_version
13234
13235 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13236
13237 char *device_opencl_version = (char *) mymalloc (param_value_size);
13238
13239 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13240
13241 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13242
13243 myfree (device_opencl_version);
13244
13245 // vector_width
13246
13247 cl_uint vector_width;
13248
13249 if (opencl_vector_width_chgd == 0)
13250 {
13251 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13252 {
13253 if (opti_type & OPTI_TYPE_USES_BITS_64)
13254 {
13255 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13256 }
13257 else
13258 {
13259 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13260 }
13261 }
13262 else
13263 {
13264 vector_width = (cl_uint) tuningdb_entry->vector_width;
13265 }
13266 }
13267 else
13268 {
13269 vector_width = opencl_vector_width;
13270 }
13271
13272 if (vector_width > 16) vector_width = 16;
13273
13274 device_param->vector_width = vector_width;
13275
13276 // max_compute_units
13277
13278 cl_uint device_processors;
13279
13280 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13281
13282 device_param->device_processors = device_processors;
13283
13284 // device_maxmem_alloc
13285 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13286
13287 cl_ulong device_maxmem_alloc;
13288
13289 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13290
13291 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13292
13293 // device_global_mem
13294
13295 cl_ulong device_global_mem;
13296
13297 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13298
13299 device_param->device_global_mem = device_global_mem;
13300
13301 // max_work_group_size
13302
13303 size_t device_maxworkgroup_size;
13304
13305 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13306
13307 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13308
13309 // max_clock_frequency
13310
13311 cl_uint device_maxclock_frequency;
13312
13313 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13314
13315 device_param->device_maxclock_frequency = device_maxclock_frequency;
13316
13317 // device_endian_little
13318
13319 cl_bool device_endian_little;
13320
13321 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13322
13323 if (device_endian_little == CL_FALSE)
13324 {
13325 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13326
13327 device_param->skipped = 1;
13328 }
13329
13330 // device_available
13331
13332 cl_bool device_available;
13333
13334 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13335
13336 if (device_available == CL_FALSE)
13337 {
13338 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13339
13340 device_param->skipped = 1;
13341 }
13342
13343 // device_compiler_available
13344
13345 cl_bool device_compiler_available;
13346
13347 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13348
13349 if (device_compiler_available == CL_FALSE)
13350 {
13351 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13352
13353 device_param->skipped = 1;
13354 }
13355
13356 // device_execution_capabilities
13357
13358 cl_device_exec_capabilities device_execution_capabilities;
13359
13360 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13361
13362 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13363 {
13364 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13365
13366 device_param->skipped = 1;
13367 }
13368
13369 // device_extensions
13370
13371 size_t device_extensions_size;
13372
13373 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13374
13375 char *device_extensions = mymalloc (device_extensions_size + 1);
13376
13377 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13378
13379 if (strstr (device_extensions, "base_atomics") == 0)
13380 {
13381 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13382
13383 device_param->skipped = 1;
13384 }
13385
13386 if (strstr (device_extensions, "byte_addressable_store") == 0)
13387 {
13388 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13389
13390 device_param->skipped = 1;
13391 }
13392
13393 myfree (device_extensions);
13394
13395 // device_local_mem_size
13396
13397 cl_ulong device_local_mem_size;
13398
13399 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13400
13401 if (device_local_mem_size < 32768)
13402 {
13403 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13404
13405 device_param->skipped = 1;
13406 }
13407
13408
13409 // skipped
13410
13411 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13412 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13413
13414 // driver_version
13415
13416 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13417
13418 char *driver_version = (char *) mymalloc (param_value_size);
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13421
13422 device_param->driver_version = driver_version;
13423
13424 // device_name_chksum
13425
13426 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13427
13428 #if __x86_64__
13429 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13430 #else
13431 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13432 #endif
13433
13434 uint device_name_digest[4] = { 0 };
13435
13436 md5_64 ((uint *) device_name_chksum, device_name_digest);
13437
13438 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13439
13440 device_param->device_name_chksum = device_name_chksum;
13441
13442 // device_processor_cores
13443
13444 if (device_type & CL_DEVICE_TYPE_CPU)
13445 {
13446 cl_uint device_processor_cores = 1;
13447
13448 device_param->device_processor_cores = device_processor_cores;
13449 }
13450
13451 if (device_type & CL_DEVICE_TYPE_GPU)
13452 {
13453 if (vendor_id == VENDOR_ID_AMD)
13454 {
13455 cl_uint device_processor_cores = 0;
13456
13457 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13460
13461 device_param->device_processor_cores = device_processor_cores;
13462 }
13463 else if (vendor_id == VENDOR_ID_NV)
13464 {
13465 cl_uint kernel_exec_timeout = 0;
13466
13467 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13468
13469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13470
13471 device_param->kernel_exec_timeout = kernel_exec_timeout;
13472
13473 cl_uint device_processor_cores = 0;
13474
13475 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13476
13477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13478
13479 device_param->device_processor_cores = device_processor_cores;
13480
13481 cl_uint sm_minor = 0;
13482 cl_uint sm_major = 0;
13483
13484 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13485 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13486
13487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13488 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13489
13490 device_param->sm_minor = sm_minor;
13491 device_param->sm_major = sm_major;
13492 }
13493 else
13494 {
13495 cl_uint device_processor_cores = 1;
13496
13497 device_param->device_processor_cores = device_processor_cores;
13498 }
13499 }
13500
13501 // display results
13502
13503 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13504 {
13505 if (status_automat == 0)
13506 {
13507 if (device_param->skipped == 0)
13508 {
13509 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13510 device_id + 1,
13511 device_name,
13512 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13513 (unsigned int) (device_global_mem / 1024 / 1024),
13514 (unsigned int) (device_maxclock_frequency),
13515 (unsigned int) device_processors);
13516 }
13517 else
13518 {
13519 log_info ("Device #%u: %s, skipped",
13520 device_id + 1,
13521 device_name);
13522 }
13523 }
13524 }
13525
13526 // common driver check
13527
13528 if (device_param->skipped == 0)
13529 {
13530 if (device_type & CL_DEVICE_TYPE_GPU)
13531 {
13532 if (vendor_id == VENDOR_ID_AMD)
13533 {
13534 int catalyst_check = (force == 1) ? 0 : 1;
13535
13536 int catalyst_warn = 0;
13537
13538 int catalyst_broken = 0;
13539
13540 if (catalyst_check == 1)
13541 {
13542 catalyst_warn = 1;
13543
13544 // v14.9 and higher
13545 if (atoi (device_param->driver_version) >= 1573)
13546 {
13547 catalyst_warn = 0;
13548 }
13549
13550 catalyst_check = 0;
13551 }
13552
13553 if (catalyst_broken == 1)
13554 {
13555 log_info ("");
13556 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13557 log_info ("It will pass over cracked hashes and does not report them as cracked");
13558 log_info ("You are STRONGLY encouraged not to use it");
13559 log_info ("You can use --force to override this but do not post error reports if you do so");
13560 log_info ("");
13561
13562 return (-1);
13563 }
13564
13565 if (catalyst_warn == 1)
13566 {
13567 log_info ("");
13568 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13569 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13570 log_info ("See hashcat's homepage for official supported catalyst drivers");
13571 #ifdef _WIN
13572 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13573 #endif
13574 log_info ("You can use --force to override this but do not post error reports if you do so");
13575 log_info ("");
13576
13577 return (-1);
13578 }
13579 }
13580 else if (vendor_id == VENDOR_ID_NV)
13581 {
13582 if (device_param->kernel_exec_timeout != 0)
13583 {
13584 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);
13585 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13586 }
13587 }
13588 }
13589
13590 if (device_type & CL_DEVICE_TYPE_CPU)
13591 {
13592 if (vendor_id == VENDOR_ID_AMD)
13593 {
13594 if (force == 0)
13595 {
13596 log_info ("");
13597 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13598 log_info ("You are STRONGLY encouraged not to use it");
13599 log_info ("You can use --force to override this but do not post error reports if you do so");
13600 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13601 log_info ("");
13602
13603 return (-1);
13604 }
13605 }
13606 }
13607
13608 /**
13609 * kernel accel and loops tuning db adjustment
13610 */
13611
13612 device_param->kernel_accel_min = 1;
13613 device_param->kernel_accel_max = 1024;
13614
13615 device_param->kernel_loops_min = 1;
13616 device_param->kernel_loops_max = 1024;
13617
13618 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13619
13620 if (tuningdb_entry)
13621 {
13622 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13623 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13624
13625 if (_kernel_accel)
13626 {
13627 device_param->kernel_accel_min = _kernel_accel;
13628 device_param->kernel_accel_max = _kernel_accel;
13629 }
13630
13631 if (_kernel_loops)
13632 {
13633 if (workload_profile == 1)
13634 {
13635 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13636 }
13637 else if (workload_profile == 2)
13638 {
13639 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13640 }
13641
13642 device_param->kernel_loops_min = _kernel_loops;
13643 device_param->kernel_loops_max = _kernel_loops;
13644 }
13645 }
13646
13647 // commandline parameters overwrite tuningdb entries
13648
13649 if (kernel_accel)
13650 {
13651 device_param->kernel_accel_min = kernel_accel;
13652 device_param->kernel_accel_max = kernel_accel;
13653 }
13654
13655 if (kernel_loops)
13656 {
13657 device_param->kernel_loops_min = kernel_loops;
13658 device_param->kernel_loops_max = kernel_loops;
13659 }
13660
13661 /**
13662 * activate device
13663 */
13664
13665 devices_active++;
13666 }
13667
13668 // next please
13669
13670 devices_cnt++;
13671 }
13672 }
13673
13674 if (keyspace == 0 && devices_active == 0)
13675 {
13676 log_error ("ERROR: No devices found/left");
13677
13678 return (-1);
13679 }
13680
13681 // 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)
13682
13683 if (devices_filter != (uint) -1)
13684 {
13685 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13686
13687 if (devices_filter > devices_cnt_mask)
13688 {
13689 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13690
13691 return (-1);
13692 }
13693 }
13694
13695 data.devices_cnt = devices_cnt;
13696
13697 data.devices_active = devices_active;
13698
13699 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13700 {
13701 if (status_automat == 0)
13702 {
13703 log_info ("");
13704 }
13705 }
13706
13707 /**
13708 * HM devices: init
13709 */
13710
13711 #ifdef HAVE_HWMON
13712 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13713 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13714 #endif
13715
13716 #ifdef HAVE_ADL
13717 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13718 #endif
13719
13720 if (gpu_temp_disable == 0)
13721 {
13722 #if defined(WIN) && defined(HAVE_NVAPI)
13723 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13724
13725 if (nvapi_init (nvapi) == 0)
13726 data.hm_nv = nvapi;
13727
13728 if (data.hm_nv)
13729 {
13730 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13731 {
13732 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13733
13734 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13735
13736 int tmp_out = 0;
13737
13738 for (int i = 0; i < tmp_in; i++)
13739 {
13740 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13741 }
13742
13743 for (int i = 0; i < tmp_out; i++)
13744 {
13745 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13746
13747 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13748
13749 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13750 }
13751 }
13752 }
13753 #endif // WIN && HAVE_NVAPI
13754
13755 #if defined(LINUX) && defined(HAVE_NVML)
13756 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13757
13758 if (nvml_init (nvml) == 0)
13759 data.hm_nv = nvml;
13760
13761 if (data.hm_nv)
13762 {
13763 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13764 {
13765 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13766
13767 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13768
13769 int tmp_out = 0;
13770
13771 for (int i = 0; i < tmp_in; i++)
13772 {
13773 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13774 }
13775
13776 for (int i = 0; i < tmp_out; i++)
13777 {
13778 unsigned int speed;
13779
13780 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13781 }
13782 }
13783 }
13784 #endif // LINUX && HAVE_NVML
13785
13786 data.hm_amd = NULL;
13787
13788 #ifdef HAVE_ADL
13789 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13790
13791 if (adl_init (adl) == 0)
13792 data.hm_amd = adl;
13793
13794 if (data.hm_amd)
13795 {
13796 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13797 {
13798 // total number of adapters
13799
13800 int hm_adapters_num;
13801
13802 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13803
13804 // adapter info
13805
13806 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13807
13808 if (lpAdapterInfo == NULL) return (-1);
13809
13810 // get a list (of ids of) valid/usable adapters
13811
13812 int num_adl_adapters = 0;
13813
13814 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13815
13816 if (num_adl_adapters > 0)
13817 {
13818 hc_thread_mutex_lock (mux_adl);
13819
13820 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13821
13822 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13823
13824 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13825 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13826
13827 hc_thread_mutex_unlock (mux_adl);
13828 }
13829
13830 myfree (valid_adl_device_list);
13831 myfree (lpAdapterInfo);
13832 }
13833 }
13834 #endif // HAVE_ADL
13835
13836 if (data.hm_amd == NULL && data.hm_nv == NULL)
13837 {
13838 gpu_temp_disable = 1;
13839 }
13840 }
13841
13842 /**
13843 * OpenCL devices: allocate buffer for device specific information
13844 */
13845
13846 #ifdef HAVE_HWMON
13847 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13848
13849 #ifdef HAVE_ADL
13850 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13851
13852 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13853 #endif // ADL
13854 #endif
13855
13856 /**
13857 * enable custom signal handler(s)
13858 */
13859
13860 if (benchmark == 0)
13861 {
13862 hc_signal (sigHandler_default);
13863 }
13864 else
13865 {
13866 hc_signal (sigHandler_benchmark);
13867 }
13868
13869 /**
13870 * User-defined GPU temp handling
13871 */
13872
13873 #ifdef HAVE_HWMON
13874 if (gpu_temp_disable == 1)
13875 {
13876 gpu_temp_abort = 0;
13877 gpu_temp_retain = 0;
13878 }
13879
13880 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13881 {
13882 if (gpu_temp_abort < gpu_temp_retain)
13883 {
13884 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13885
13886 return (-1);
13887 }
13888 }
13889
13890 data.gpu_temp_disable = gpu_temp_disable;
13891 data.gpu_temp_abort = gpu_temp_abort;
13892 data.gpu_temp_retain = gpu_temp_retain;
13893 #endif
13894
13895 /**
13896 * inform the user
13897 */
13898
13899 if (data.quiet == 0)
13900 {
13901 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13902
13903 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);
13904
13905 if (attack_mode == ATTACK_MODE_STRAIGHT)
13906 {
13907 log_info ("Rules: %u", kernel_rules_cnt);
13908 }
13909
13910 if (opti_type)
13911 {
13912 log_info ("Applicable Optimizers:");
13913
13914 for (uint i = 0; i < 32; i++)
13915 {
13916 const uint opti_bit = 1u << i;
13917
13918 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13919 }
13920 }
13921
13922 /**
13923 * Watchdog and Temperature balance
13924 */
13925
13926 #ifdef HAVE_HWMON
13927 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13928 {
13929 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13930 }
13931
13932 if (gpu_temp_abort == 0)
13933 {
13934 log_info ("Watchdog: Temperature abort trigger disabled");
13935 }
13936 else
13937 {
13938 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13939 }
13940
13941 if (gpu_temp_retain == 0)
13942 {
13943 log_info ("Watchdog: Temperature retain trigger disabled");
13944 }
13945 else
13946 {
13947 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13948 }
13949
13950 if (data.quiet == 0) log_info ("");
13951 #endif
13952 }
13953
13954 /**
13955 * HM devices: copy
13956 */
13957
13958 if (gpu_temp_disable == 0)
13959 {
13960 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13961 {
13962 hc_device_param_t *device_param = &data.devices_param[device_id];
13963
13964 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13965
13966 if (device_param->skipped) continue;
13967
13968 const uint platform_devices_id = device_param->platform_devices_id;
13969
13970 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13971 if (device_param->vendor_id == VENDOR_ID_NV)
13972 {
13973 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13974 }
13975 #endif
13976
13977 #ifdef HAVE_ADL
13978 if (device_param->vendor_id == VENDOR_ID_AMD)
13979 {
13980 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13981 }
13982 #endif
13983 }
13984 }
13985
13986 /*
13987 * Temporary fix:
13988 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13989 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13990 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13991 * Driver / ADL bug?
13992 */
13993
13994 #ifdef HAVE_ADL
13995 if (powertune_enable == 1)
13996 {
13997 hc_thread_mutex_lock (mux_adl);
13998
13999 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14000 {
14001 hc_device_param_t *device_param = &data.devices_param[device_id];
14002
14003 if (device_param->skipped) continue;
14004
14005 if (data.hm_device[device_id].od_version == 6)
14006 {
14007 // set powertune value only
14008
14009 int powertune_supported = 0;
14010
14011 int ADL_rc = 0;
14012
14013 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14014 {
14015 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14016
14017 return (-1);
14018 }
14019
14020 if (powertune_supported != 0)
14021 {
14022 // powertune set
14023 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14024
14025 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14026 {
14027 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14028
14029 return (-1);
14030 }
14031
14032 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14033 {
14034 log_error ("ERROR: Failed to set new ADL PowerControl values");
14035
14036 return (-1);
14037 }
14038 }
14039 }
14040 }
14041
14042 hc_thread_mutex_unlock (mux_adl);
14043 }
14044 #endif // HAVE_ADK
14045 #endif // HAVE_HWMON
14046
14047 #ifdef DEBUG
14048 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14049 #endif
14050
14051 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14052
14053 uint kernel_power_all = 0;
14054
14055 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14056 {
14057 /**
14058 * host buffer
14059 */
14060
14061 hc_device_param_t *device_param = &data.devices_param[device_id];
14062
14063 if (device_param->skipped) continue;
14064
14065 /**
14066 * device properties
14067 */
14068
14069 const char *device_name_chksum = device_param->device_name_chksum;
14070 const u32 device_processors = device_param->device_processors;
14071 const u32 device_processor_cores = device_param->device_processor_cores;
14072
14073 /**
14074 * create context for each device
14075 */
14076
14077 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14078
14079 /**
14080 * create command-queue
14081 */
14082
14083 // not supported with NV
14084 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14085
14086 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14087
14088 /**
14089 * kernel threads: some algorithms need a fixed kernel-threads count
14090 * because of shared memory usage or bitslice
14091 * there needs to be some upper limit, otherwise there's too much overhead
14092 */
14093
14094 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14095
14096 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14097 {
14098 kernel_threads = KERNEL_THREADS_MAX_CPU;
14099 }
14100
14101 if (hash_mode == 1500) kernel_threads = 64; // DES
14102 if (hash_mode == 3000) kernel_threads = 64; // DES
14103 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14104 if (hash_mode == 7500) kernel_threads = 64; // RC4
14105 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14106 if (hash_mode == 9700) kernel_threads = 64; // RC4
14107 if (hash_mode == 9710) kernel_threads = 64; // RC4
14108 if (hash_mode == 9800) kernel_threads = 64; // RC4
14109 if (hash_mode == 9810) kernel_threads = 64; // RC4
14110 if (hash_mode == 10400) kernel_threads = 64; // RC4
14111 if (hash_mode == 10410) kernel_threads = 64; // RC4
14112 if (hash_mode == 10500) kernel_threads = 64; // RC4
14113 if (hash_mode == 13100) kernel_threads = 64; // RC4
14114
14115 /**
14116 * create input buffers on device : calculate size of fixed memory buffers
14117 */
14118
14119 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14120 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14121
14122 device_param->size_root_css = size_root_css;
14123 device_param->size_markov_css = size_markov_css;
14124
14125 size_t size_results = sizeof (uint);
14126
14127 device_param->size_results = size_results;
14128
14129 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14130 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14131
14132 size_t size_plains = digests_cnt * sizeof (plain_t);
14133 size_t size_salts = salts_cnt * sizeof (salt_t);
14134 size_t size_esalts = salts_cnt * esalt_size;
14135
14136 device_param->size_plains = size_plains;
14137 device_param->size_digests = size_digests;
14138 device_param->size_shown = size_shown;
14139 device_param->size_salts = size_salts;
14140
14141 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14142 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14143 size_t size_tm = 32 * sizeof (bs_word_t);
14144
14145 // scryptV stuff
14146
14147 size_t size_scryptV = 1;
14148
14149 if ((hash_mode == 8900) || (hash_mode == 9300))
14150 {
14151 uint tmto_start = 0;
14152 uint tmto_stop = 10;
14153
14154 if (scrypt_tmto)
14155 {
14156 tmto_start = scrypt_tmto;
14157 }
14158 else
14159 {
14160 // in case the user did not specify the tmto manually
14161 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14162 // but set the lower end only in case the user has a device with too less memory
14163
14164 if (hash_mode == 8900)
14165 {
14166 if (device_param->vendor_id == VENDOR_ID_AMD)
14167 {
14168 tmto_start = 1;
14169 }
14170 else if (device_param->vendor_id == VENDOR_ID_NV)
14171 {
14172 tmto_start = 2;
14173 }
14174 }
14175 else if (hash_mode == 9300)
14176 {
14177 if (device_param->vendor_id == VENDOR_ID_AMD)
14178 {
14179 tmto_start = 2;
14180 }
14181 else if (device_param->vendor_id == VENDOR_ID_NV)
14182 {
14183 tmto_start = 2;
14184 }
14185 }
14186 }
14187
14188 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14189 {
14190 // TODO: in theory the following calculation needs to be done per salt, not global
14191 // we assume all hashes have the same scrypt settings
14192
14193 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14194
14195 size_scryptV /= 1 << tmto;
14196
14197 size_scryptV *= device_processors * device_processor_cores;
14198
14199 if (size_scryptV > device_param->device_maxmem_alloc)
14200 {
14201 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14202
14203 continue;
14204 }
14205
14206 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14207 {
14208 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14209 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14210 }
14211
14212 break;
14213 }
14214
14215 if (data.salts_buf[0].scrypt_phy == 0)
14216 {
14217 log_error ("ERROR: can't allocate enough device memory");
14218
14219 return -1;
14220 }
14221
14222 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14223 }
14224
14225 /**
14226 * some algorithms need a fixed kernel-loops count
14227 */
14228
14229 if (hash_mode == 1500)
14230 {
14231 const u32 kernel_loops_fixed = 1024;
14232
14233 device_param->kernel_loops_min = kernel_loops_fixed;
14234 device_param->kernel_loops_max = kernel_loops_fixed;
14235 }
14236
14237 if (hash_mode == 3000)
14238 {
14239 const u32 kernel_loops_fixed = 1024;
14240
14241 device_param->kernel_loops_min = kernel_loops_fixed;
14242 device_param->kernel_loops_max = kernel_loops_fixed;
14243 }
14244
14245 if (hash_mode == 8900)
14246 {
14247 const u32 kernel_loops_fixed = 1;
14248
14249 device_param->kernel_loops_min = kernel_loops_fixed;
14250 device_param->kernel_loops_max = kernel_loops_fixed;
14251 }
14252
14253 if (hash_mode == 9300)
14254 {
14255 const u32 kernel_loops_fixed = 1;
14256
14257 device_param->kernel_loops_min = kernel_loops_fixed;
14258 device_param->kernel_loops_max = kernel_loops_fixed;
14259 }
14260
14261 if (hash_mode == 12500)
14262 {
14263 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14264
14265 device_param->kernel_loops_min = kernel_loops_fixed;
14266 device_param->kernel_loops_max = kernel_loops_fixed;
14267 }
14268
14269 /**
14270 * some algorithms have a maximum kernel-loops count
14271 */
14272
14273 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14274 {
14275 u32 innerloop_cnt = 0;
14276
14277 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14278 {
14279 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14280 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14281 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14282 }
14283 else
14284 {
14285 innerloop_cnt = data.salts_buf[0].salt_iter;
14286 }
14287
14288 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14289 (innerloop_cnt <= device_param->kernel_loops_max))
14290 {
14291 device_param->kernel_loops_max = innerloop_cnt;
14292 }
14293 }
14294
14295 /**
14296 * some algorithms need a special kernel-accel
14297 */
14298
14299 if (hash_mode == 8900)
14300 {
14301 device_param->kernel_accel_min = 1;
14302 device_param->kernel_accel_max = 64;
14303 }
14304
14305 if (hash_mode == 9300)
14306 {
14307 device_param->kernel_accel_min = 1;
14308 device_param->kernel_accel_max = 64;
14309 }
14310
14311 u32 kernel_accel_min = device_param->kernel_accel_min;
14312 u32 kernel_accel_max = device_param->kernel_accel_max;
14313
14314 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14315
14316 size_t size_pws = 4;
14317 size_t size_tmps = 4;
14318 size_t size_hooks = 4;
14319
14320 while (kernel_accel_max >= kernel_accel_min)
14321 {
14322 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14323
14324 // size_pws
14325
14326 size_pws = kernel_power_max * sizeof (pw_t);
14327
14328 // size_tmps
14329
14330 switch (hash_mode)
14331 {
14332 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14333 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14334 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14335 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14336 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14337 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14338 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14339 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14340 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14341 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14342 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14343 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14344 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14345 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14346 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14347 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14348 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14349 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14350 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14351 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14352 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14353 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14354 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14355 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14356 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14357 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14358 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14359 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14360 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14361 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14362 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14363 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14364 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14365 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14366 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14367 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14368 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14369 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14370 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14371 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14372 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14373 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14374 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14375 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14376 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14377 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14378 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14379 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14380 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14381 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14382 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14383 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14384 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14385 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14386 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14387 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14388 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14389 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14390 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14391 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14392 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14393 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14394 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14395 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14396 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14397 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14398 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14399 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14400 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14401 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14402 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14403 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14404 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14405 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14406 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14407 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14408 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14409 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14410 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14411 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14412 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14413 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14414 };
14415
14416 // size_hooks
14417
14418 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14419 {
14420 // none yet
14421 }
14422
14423 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14424 // if not, decrease amplifier and try again
14425
14426 int skip = 0;
14427
14428 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14429 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14430 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14431
14432 if (( bitmap_size
14433 + bitmap_size
14434 + bitmap_size
14435 + bitmap_size
14436 + bitmap_size
14437 + bitmap_size
14438 + bitmap_size
14439 + bitmap_size
14440 + size_bfs
14441 + size_combs
14442 + size_digests
14443 + size_esalts
14444 + size_hooks
14445 + size_markov_css
14446 + size_plains
14447 + size_pws
14448 + size_pws // not a bug
14449 + size_results
14450 + size_root_css
14451 + size_rules
14452 + size_rules_c
14453 + size_salts
14454 + size_scryptV
14455 + size_shown
14456 + size_tm
14457 + size_tmps) > device_param->device_global_mem) skip = 1;
14458
14459 if (skip == 1)
14460 {
14461 kernel_accel_max--;
14462
14463 continue;
14464 }
14465
14466 break;
14467 }
14468
14469 /*
14470 if (kernel_accel_max == 0)
14471 {
14472 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14473
14474 return -1;
14475 }
14476 */
14477
14478 device_param->kernel_accel_min = kernel_accel_min;
14479 device_param->kernel_accel_max = kernel_accel_max;
14480
14481 /*
14482 if (kernel_accel_max < kernel_accel)
14483 {
14484 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14485
14486 device_param->kernel_accel = kernel_accel_max;
14487 }
14488 */
14489
14490 device_param->size_bfs = size_bfs;
14491 device_param->size_combs = size_combs;
14492 device_param->size_rules = size_rules;
14493 device_param->size_rules_c = size_rules_c;
14494 device_param->size_pws = size_pws;
14495 device_param->size_tmps = size_tmps;
14496 device_param->size_hooks = size_hooks;
14497
14498 // do not confuse kernel_accel_max with kernel_accel here
14499
14500 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14501
14502 device_param->kernel_threads = kernel_threads;
14503 device_param->kernel_power_user = kernel_power;
14504
14505 kernel_power_all += kernel_power;
14506
14507 /**
14508 * default building options
14509 */
14510
14511 char build_opts[1024] = { 0 };
14512
14513 // we don't have sm_* on vendors not NV but it doesn't matter
14514
14515 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14516
14517 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14518 {
14519 // we do vectorizing much better than the auto-vectorizer
14520
14521 char build_opts_new[1024] = { 0 };
14522
14523 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14524
14525 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14526 }
14527
14528 #ifdef DEBUG
14529 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14530 #endif
14531
14532 /**
14533 * main kernel
14534 */
14535
14536 {
14537 /**
14538 * kernel source filename
14539 */
14540
14541 char source_file[256] = { 0 };
14542
14543 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14544
14545 struct stat sst;
14546
14547 if (stat (source_file, &sst) == -1)
14548 {
14549 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14550
14551 return -1;
14552 }
14553
14554 /**
14555 * kernel cached filename
14556 */
14557
14558 char cached_file[256] = { 0 };
14559
14560 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14561
14562 int cached = 1;
14563
14564 struct stat cst;
14565
14566 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14567 {
14568 cached = 0;
14569 }
14570
14571 /**
14572 * kernel compile or load
14573 */
14574
14575 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14576
14577 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14578
14579 if (force_jit_compilation == -1)
14580 {
14581 if (cached == 0)
14582 {
14583 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14584
14585 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14586
14587 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14588
14589 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14590
14591 #ifdef DEBUG
14592 size_t build_log_size = 0;
14593
14594 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14595
14596 if (build_log_size > 1)
14597 {
14598 char *build_log = (char *) malloc (build_log_size + 1);
14599
14600 memset (build_log, 0, build_log_size + 1);
14601
14602 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14603
14604 puts (build_log);
14605
14606 free (build_log);
14607 }
14608 #endif
14609
14610 if (rc != 0)
14611 {
14612 device_param->skipped = true;
14613
14614 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14615
14616 continue;
14617 }
14618
14619 size_t binary_size;
14620
14621 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14622
14623 u8 *binary = (u8 *) mymalloc (binary_size);
14624
14625 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14626
14627 writeProgramBin (cached_file, binary, binary_size);
14628
14629 local_free (binary);
14630 }
14631 else
14632 {
14633 #ifdef DEBUG
14634 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14635 #endif
14636
14637 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14638
14639 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14640
14641 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14642 }
14643 }
14644 else
14645 {
14646 #ifdef DEBUG
14647 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14648 #endif
14649
14650 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14651
14652 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14653
14654 char build_opts_update[1024] = { 0 };
14655
14656 if (force_jit_compilation == 1500)
14657 {
14658 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14659 }
14660 else if (force_jit_compilation == 8900)
14661 {
14662 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);
14663 }
14664 else
14665 {
14666 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14667 }
14668
14669 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14670
14671 #ifdef DEBUG
14672 size_t build_log_size = 0;
14673
14674 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14675
14676 if (build_log_size > 1)
14677 {
14678 char *build_log = (char *) malloc (build_log_size + 1);
14679
14680 memset (build_log, 0, build_log_size + 1);
14681
14682 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14683
14684 puts (build_log);
14685
14686 free (build_log);
14687 }
14688 #endif
14689
14690 if (rc != 0)
14691 {
14692 device_param->skipped = true;
14693
14694 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14695 }
14696 }
14697
14698 local_free (kernel_lengths);
14699 local_free (kernel_sources[0]);
14700 local_free (kernel_sources);
14701 }
14702
14703 /**
14704 * word generator kernel
14705 */
14706
14707 if (attack_mode != ATTACK_MODE_STRAIGHT)
14708 {
14709 /**
14710 * kernel mp source filename
14711 */
14712
14713 char source_file[256] = { 0 };
14714
14715 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14716
14717 struct stat sst;
14718
14719 if (stat (source_file, &sst) == -1)
14720 {
14721 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14722
14723 return -1;
14724 }
14725
14726 /**
14727 * kernel mp cached filename
14728 */
14729
14730 char cached_file[256] = { 0 };
14731
14732 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14733
14734 int cached = 1;
14735
14736 struct stat cst;
14737
14738 if (stat (cached_file, &cst) == -1)
14739 {
14740 cached = 0;
14741 }
14742
14743 /**
14744 * kernel compile or load
14745 */
14746
14747 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14748
14749 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14750
14751 if (cached == 0)
14752 {
14753 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14754 if (quiet == 0) log_info ("");
14755
14756 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14757
14758 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14759
14760 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14761
14762 if (rc != 0)
14763 {
14764 device_param->skipped = true;
14765
14766 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14767
14768 continue;
14769 }
14770
14771 size_t binary_size;
14772
14773 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14774
14775 u8 *binary = (u8 *) mymalloc (binary_size);
14776
14777 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14778
14779 writeProgramBin (cached_file, binary, binary_size);
14780
14781 local_free (binary);
14782 }
14783 else
14784 {
14785 #ifdef DEBUG
14786 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14787 #endif
14788
14789 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14790
14791 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14792
14793 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14794 }
14795
14796 local_free (kernel_lengths);
14797 local_free (kernel_sources[0]);
14798 local_free (kernel_sources);
14799 }
14800
14801 /**
14802 * amplifier kernel
14803 */
14804
14805 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14806 {
14807
14808 }
14809 else
14810 {
14811 /**
14812 * kernel amp source filename
14813 */
14814
14815 char source_file[256] = { 0 };
14816
14817 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14818
14819 struct stat sst;
14820
14821 if (stat (source_file, &sst) == -1)
14822 {
14823 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14824
14825 return -1;
14826 }
14827
14828 /**
14829 * kernel amp cached filename
14830 */
14831
14832 char cached_file[256] = { 0 };
14833
14834 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14835
14836 int cached = 1;
14837
14838 struct stat cst;
14839
14840 if (stat (cached_file, &cst) == -1)
14841 {
14842 cached = 0;
14843 }
14844
14845 /**
14846 * kernel compile or load
14847 */
14848
14849 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14850
14851 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14852
14853 if (cached == 0)
14854 {
14855 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14856 if (quiet == 0) log_info ("");
14857
14858 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14859
14860 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14861
14862 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14863
14864 if (rc != 0)
14865 {
14866 device_param->skipped = true;
14867
14868 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14869
14870 continue;
14871 }
14872
14873 size_t binary_size;
14874
14875 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14876
14877 u8 *binary = (u8 *) mymalloc (binary_size);
14878
14879 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14880
14881 writeProgramBin (cached_file, binary, binary_size);
14882
14883 local_free (binary);
14884 }
14885 else
14886 {
14887 #ifdef DEBUG
14888 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14889 #endif
14890
14891 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14892
14893 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14894
14895 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14896 }
14897
14898 local_free (kernel_lengths);
14899 local_free (kernel_sources[0]);
14900 local_free (kernel_sources);
14901 }
14902
14903 // some algorithm collide too fast, make that impossible
14904
14905 if (benchmark == 1)
14906 {
14907 ((uint *) digests_buf)[0] = -1;
14908 ((uint *) digests_buf)[1] = -1;
14909 ((uint *) digests_buf)[2] = -1;
14910 ((uint *) digests_buf)[3] = -1;
14911 }
14912
14913 /**
14914 * global buffers
14915 */
14916
14917 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14918 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14919 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14920 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14921 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14922 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14923 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14924 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14925 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14926 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14927 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14928 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14929 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14930 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14931 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14932 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14933 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14934 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14935
14936 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);
14937 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);
14938 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);
14939 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);
14940 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);
14941 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);
14942 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);
14943 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);
14944 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14945 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14946 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14947
14948 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14949 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14950 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14951 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14952 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14953 run_kernel_bzero (device_param, device_param->d_result, size_results);
14954
14955 /**
14956 * special buffers
14957 */
14958
14959 if (attack_kern == ATTACK_KERN_STRAIGHT)
14960 {
14961 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14962 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14963
14964 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14965
14966 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14967 }
14968 else if (attack_kern == ATTACK_KERN_COMBI)
14969 {
14970 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14971 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14972 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14973 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14974
14975 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14976 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14977 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14978 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14979 }
14980 else if (attack_kern == ATTACK_KERN_BF)
14981 {
14982 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14983 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14984 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14985 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14986 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14987
14988 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14989 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14990 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14991 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14992 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14993 }
14994
14995 if (size_esalts)
14996 {
14997 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14998
14999 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15000 }
15001
15002 /**
15003 * main host data
15004 */
15005
15006 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15007
15008 device_param->pws_buf = pws_buf;
15009
15010 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15011
15012 device_param->combs_buf = combs_buf;
15013
15014 void *hooks_buf = mymalloc (size_hooks);
15015
15016 device_param->hooks_buf = hooks_buf;
15017
15018 /**
15019 * kernel args
15020 */
15021
15022 device_param->kernel_params_buf32[21] = bitmap_mask;
15023 device_param->kernel_params_buf32[22] = bitmap_shift1;
15024 device_param->kernel_params_buf32[23] = bitmap_shift2;
15025 device_param->kernel_params_buf32[24] = 0; // salt_pos
15026 device_param->kernel_params_buf32[25] = 0; // loop_pos
15027 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15028 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15029 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15030 device_param->kernel_params_buf32[29] = 0; // digests_offset
15031 device_param->kernel_params_buf32[30] = 0; // combs_mode
15032 device_param->kernel_params_buf32[31] = 0; // gid_max
15033
15034 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15035 ? &device_param->d_pws_buf
15036 : &device_param->d_pws_amp_buf;
15037 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15038 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15039 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15040 device_param->kernel_params[ 4] = &device_param->d_tmps;
15041 device_param->kernel_params[ 5] = &device_param->d_hooks;
15042 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15043 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15044 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15045 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15046 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15047 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15048 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15049 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15050 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15051 device_param->kernel_params[15] = &device_param->d_digests_buf;
15052 device_param->kernel_params[16] = &device_param->d_digests_shown;
15053 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15054 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15055 device_param->kernel_params[19] = &device_param->d_result;
15056 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15057 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15058 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15059 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15060 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15061 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15062 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15063 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15064 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15065 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15066 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15067 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15068
15069 device_param->kernel_params_mp_buf64[3] = 0;
15070 device_param->kernel_params_mp_buf32[4] = 0;
15071 device_param->kernel_params_mp_buf32[5] = 0;
15072 device_param->kernel_params_mp_buf32[6] = 0;
15073 device_param->kernel_params_mp_buf32[7] = 0;
15074 device_param->kernel_params_mp_buf32[8] = 0;
15075
15076 device_param->kernel_params_mp[0] = NULL;
15077 device_param->kernel_params_mp[1] = NULL;
15078 device_param->kernel_params_mp[2] = NULL;
15079 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15080 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15081 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15082 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15083 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15084 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15085
15086 device_param->kernel_params_mp_l_buf64[3] = 0;
15087 device_param->kernel_params_mp_l_buf32[4] = 0;
15088 device_param->kernel_params_mp_l_buf32[5] = 0;
15089 device_param->kernel_params_mp_l_buf32[6] = 0;
15090 device_param->kernel_params_mp_l_buf32[7] = 0;
15091 device_param->kernel_params_mp_l_buf32[8] = 0;
15092 device_param->kernel_params_mp_l_buf32[9] = 0;
15093
15094 device_param->kernel_params_mp_l[0] = NULL;
15095 device_param->kernel_params_mp_l[1] = NULL;
15096 device_param->kernel_params_mp_l[2] = NULL;
15097 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15098 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15099 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15100 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15101 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15102 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15103 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15104
15105 device_param->kernel_params_mp_r_buf64[3] = 0;
15106 device_param->kernel_params_mp_r_buf32[4] = 0;
15107 device_param->kernel_params_mp_r_buf32[5] = 0;
15108 device_param->kernel_params_mp_r_buf32[6] = 0;
15109 device_param->kernel_params_mp_r_buf32[7] = 0;
15110 device_param->kernel_params_mp_r_buf32[8] = 0;
15111
15112 device_param->kernel_params_mp_r[0] = NULL;
15113 device_param->kernel_params_mp_r[1] = NULL;
15114 device_param->kernel_params_mp_r[2] = NULL;
15115 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15116 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15117 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15118 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15119 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15120 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15121
15122 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15123 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15124
15125 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15126 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15127 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15128 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15129 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15130 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15131 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15132
15133 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15134 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15135
15136 /**
15137 * kernel name
15138 */
15139
15140 size_t kernel_wgs_tmp;
15141
15142 char kernel_name[64] = { 0 };
15143
15144 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15145 {
15146 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15147 {
15148 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15149
15150 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15151
15152 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15153
15154 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15155
15156 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15157
15158 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15159 }
15160 else
15161 {
15162 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15163
15164 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15165
15166 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15167
15168 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15169
15170 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15171
15172 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15173 }
15174
15175 if (data.attack_mode == ATTACK_MODE_BF)
15176 {
15177 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15178 {
15179 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15180
15181 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15182
15183 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);
15184 }
15185 }
15186 }
15187 else
15188 {
15189 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15190
15191 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15192
15193 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15194
15195 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15196
15197 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15198
15199 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15200
15201 if (opts_type & OPTS_TYPE_HOOK12)
15202 {
15203 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15204
15205 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15206
15207 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);
15208 }
15209
15210 if (opts_type & OPTS_TYPE_HOOK23)
15211 {
15212 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15213
15214 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15215
15216 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);
15217 }
15218 }
15219
15220 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);
15221 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);
15222 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);
15223
15224 for (uint i = 0; i <= 20; i++)
15225 {
15226 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15227 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15228 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15229
15230 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15231 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15232 }
15233
15234 for (uint i = 21; i <= 31; i++)
15235 {
15236 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15237 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15238 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15239
15240 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15241 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15242 }
15243
15244 if (attack_mode == ATTACK_MODE_BF)
15245 {
15246 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15247 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15248
15249 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);
15250 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);
15251
15252 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15253 {
15254 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15255 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15256 }
15257 }
15258 else if (attack_mode == ATTACK_MODE_HYBRID1)
15259 {
15260 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15261
15262 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);
15263 }
15264 else if (attack_mode == ATTACK_MODE_HYBRID2)
15265 {
15266 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15267
15268 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);
15269 }
15270
15271 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15272 {
15273 // nothing to do
15274 }
15275 else
15276 {
15277 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15278
15279 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);
15280 }
15281
15282 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15283 {
15284 // nothing to do
15285 }
15286 else
15287 {
15288 for (uint i = 0; i < 5; i++)
15289 {
15290 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15291 }
15292
15293 for (uint i = 5; i < 7; i++)
15294 {
15295 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15296 }
15297 }
15298
15299 // maybe this has been updated by clGetKernelWorkGroupInfo()
15300 // value can only be decreased, so we don't need to reallocate buffers
15301
15302 device_param->kernel_threads = kernel_threads;
15303
15304 /**
15305 * Store initial fanspeed if gpu_temp_retain is enabled
15306 */
15307
15308 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15309 int gpu_temp_retain_set = 0;
15310
15311 if (gpu_temp_disable == 0)
15312 {
15313 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15314 {
15315 hc_thread_mutex_lock (mux_adl);
15316
15317 if (data.hm_device[device_id].fan_supported == 1)
15318 {
15319 if (gpu_temp_retain_chgd == 0)
15320 {
15321 uint cur_temp = 0;
15322 uint default_temp = 0;
15323
15324 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15325
15326 if (ADL_rc == ADL_OK)
15327 {
15328 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15329
15330 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15331
15332 // special case with multi gpu setups: always use minimum retain
15333
15334 if (gpu_temp_retain_set == 0)
15335 {
15336 gpu_temp_retain = gpu_temp_retain_target;
15337 gpu_temp_retain_set = 1;
15338 }
15339 else
15340 {
15341 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15342 }
15343
15344 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15345 }
15346 }
15347
15348 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15349
15350 temp_retain_fanspeed_value[device_id] = fan_speed;
15351
15352 if (fan_speed == -1)
15353 {
15354 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15355
15356 temp_retain_fanspeed_value[device_id] = 0;
15357 }
15358 }
15359
15360 hc_thread_mutex_unlock (mux_adl);
15361 }
15362 }
15363
15364 /**
15365 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15366 */
15367
15368 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15369 {
15370 hc_thread_mutex_lock (mux_adl);
15371
15372 if (data.hm_device[device_id].od_version == 6)
15373 {
15374 int ADL_rc;
15375
15376 // check powertune capabilities first, if not available then skip device
15377
15378 int powertune_supported = 0;
15379
15380 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15381 {
15382 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15383
15384 return (-1);
15385 }
15386
15387 if (powertune_supported != 0)
15388 {
15389 // powercontrol settings
15390
15391 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15392
15393 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15394 {
15395 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15396 }
15397
15398 if (ADL_rc != ADL_OK)
15399 {
15400 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15401
15402 return (-1);
15403 }
15404
15405 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15406 {
15407 log_error ("ERROR: Failed to set new ADL PowerControl values");
15408
15409 return (-1);
15410 }
15411
15412 // clocks
15413
15414 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15415
15416 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15417
15418 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15419 {
15420 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15421
15422 return (-1);
15423 }
15424
15425 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15426
15427 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15428
15429 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15430 {
15431 log_error ("ERROR: Failed to get ADL device capabilities");
15432
15433 return (-1);
15434 }
15435
15436 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15437 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15438
15439 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15440 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15441
15442 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15443 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15444
15445 // warning if profile has too low max values
15446
15447 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15448 {
15449 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15450 }
15451
15452 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15453 {
15454 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15455 }
15456
15457 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15458
15459 performance_state->iNumberOfPerformanceLevels = 2;
15460
15461 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15462 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15463 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15464 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15465
15466 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15467 {
15468 log_info ("ERROR: Failed to set ADL performance state");
15469
15470 return (-1);
15471 }
15472
15473 local_free (performance_state);
15474 }
15475 }
15476
15477 hc_thread_mutex_unlock (mux_adl);
15478 }
15479 #endif // HAVE_HWMON && HAVE_ADL
15480 }
15481
15482 data.kernel_power_all = kernel_power_all;
15483
15484 if (data.quiet == 0) log_info_nn ("");
15485
15486 /**
15487 * In benchmark-mode, inform user which algorithm is checked
15488 */
15489
15490 if (benchmark == 1)
15491 {
15492 if (status_automat == 0)
15493 {
15494 quiet = 0;
15495
15496 data.quiet = quiet;
15497
15498 char *hash_type = strhashtype (data.hash_mode); // not a bug
15499
15500 log_info ("Hashtype: %s", hash_type);
15501 log_info ("");
15502 }
15503 }
15504
15505 /**
15506 * keep track of the progress
15507 */
15508
15509 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15510 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15511 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15512
15513 /**
15514 * open filehandles
15515 */
15516
15517 #if _WIN
15518 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15519 {
15520 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15521
15522 return (-1);
15523 }
15524
15525 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15526 {
15527 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15528
15529 return (-1);
15530 }
15531
15532 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15533 {
15534 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15535
15536 return (-1);
15537 }
15538 #endif
15539
15540 /**
15541 * dictionary pad
15542 */
15543
15544 segment_size *= (1024 * 1024);
15545
15546 data.segment_size = segment_size;
15547
15548 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15549
15550 wl_data->buf = (char *) mymalloc (segment_size);
15551 wl_data->avail = segment_size;
15552 wl_data->incr = segment_size;
15553 wl_data->cnt = 0;
15554 wl_data->pos = 0;
15555
15556 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15557
15558 data.wordlist_mode = wordlist_mode;
15559
15560 cs_t *css_buf = NULL;
15561 uint css_cnt = 0;
15562 uint dictcnt = 0;
15563 uint maskcnt = 1;
15564 char **masks = NULL;
15565 char **dictfiles = NULL;
15566
15567 uint mask_from_file = 0;
15568
15569 if (attack_mode == ATTACK_MODE_STRAIGHT)
15570 {
15571 if (wordlist_mode == WL_MODE_FILE)
15572 {
15573 int wls_left = myargc - (optind + 1);
15574
15575 for (int i = 0; i < wls_left; i++)
15576 {
15577 char *l0_filename = myargv[optind + 1 + i];
15578
15579 struct stat l0_stat;
15580
15581 if (stat (l0_filename, &l0_stat) == -1)
15582 {
15583 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15584
15585 return (-1);
15586 }
15587
15588 uint is_dir = S_ISDIR (l0_stat.st_mode);
15589
15590 if (is_dir == 0)
15591 {
15592 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15593
15594 dictcnt++;
15595
15596 dictfiles[dictcnt - 1] = l0_filename;
15597 }
15598 else
15599 {
15600 // do not allow --keyspace w/ a directory
15601
15602 if (keyspace == 1)
15603 {
15604 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15605
15606 return (-1);
15607 }
15608
15609 char **dictionary_files = NULL;
15610
15611 dictionary_files = scan_directory (l0_filename);
15612
15613 if (dictionary_files != NULL)
15614 {
15615 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15616
15617 for (int d = 0; dictionary_files[d] != NULL; d++)
15618 {
15619 char *l1_filename = dictionary_files[d];
15620
15621 struct stat l1_stat;
15622
15623 if (stat (l1_filename, &l1_stat) == -1)
15624 {
15625 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15626
15627 return (-1);
15628 }
15629
15630 if (S_ISREG (l1_stat.st_mode))
15631 {
15632 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15633
15634 dictcnt++;
15635
15636 dictfiles[dictcnt - 1] = strdup (l1_filename);
15637 }
15638 }
15639 }
15640
15641 local_free (dictionary_files);
15642 }
15643 }
15644
15645 if (dictcnt < 1)
15646 {
15647 log_error ("ERROR: No usable dictionary file found.");
15648
15649 return (-1);
15650 }
15651 }
15652 else if (wordlist_mode == WL_MODE_STDIN)
15653 {
15654 dictcnt = 1;
15655 }
15656 }
15657 else if (attack_mode == ATTACK_MODE_COMBI)
15658 {
15659 // display
15660
15661 char *dictfile1 = myargv[optind + 1 + 0];
15662 char *dictfile2 = myargv[optind + 1 + 1];
15663
15664 // find the bigger dictionary and use as base
15665
15666 FILE *fp1 = NULL;
15667 FILE *fp2 = NULL;
15668
15669 struct stat tmp_stat;
15670
15671 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15672 {
15673 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15674
15675 return (-1);
15676 }
15677
15678 if (stat (dictfile1, &tmp_stat) == -1)
15679 {
15680 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15681
15682 fclose (fp1);
15683
15684 return (-1);
15685 }
15686
15687 if (S_ISDIR (tmp_stat.st_mode))
15688 {
15689 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15690
15691 fclose (fp1);
15692
15693 return (-1);
15694 }
15695
15696 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15697 {
15698 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15699
15700 fclose (fp1);
15701
15702 return (-1);
15703 }
15704
15705 if (stat (dictfile2, &tmp_stat) == -1)
15706 {
15707 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15708
15709 fclose (fp1);
15710 fclose (fp2);
15711
15712 return (-1);
15713 }
15714
15715 if (S_ISDIR (tmp_stat.st_mode))
15716 {
15717 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15718
15719 fclose (fp1);
15720 fclose (fp2);
15721
15722 return (-1);
15723 }
15724
15725 data.combs_cnt = 1;
15726
15727 data.quiet = 1;
15728
15729 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15730
15731 data.quiet = quiet;
15732
15733 if (words1_cnt == 0)
15734 {
15735 log_error ("ERROR: %s: empty file", dictfile1);
15736
15737 fclose (fp1);
15738 fclose (fp2);
15739
15740 return (-1);
15741 }
15742
15743 data.combs_cnt = 1;
15744
15745 data.quiet = 1;
15746
15747 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15748
15749 data.quiet = quiet;
15750
15751 if (words2_cnt == 0)
15752 {
15753 log_error ("ERROR: %s: empty file", dictfile2);
15754
15755 fclose (fp1);
15756 fclose (fp2);
15757
15758 return (-1);
15759 }
15760
15761 fclose (fp1);
15762 fclose (fp2);
15763
15764 data.dictfile = dictfile1;
15765 data.dictfile2 = dictfile2;
15766
15767 if (words1_cnt >= words2_cnt)
15768 {
15769 data.combs_cnt = words2_cnt;
15770 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15771
15772 dictfiles = &data.dictfile;
15773
15774 dictcnt = 1;
15775 }
15776 else
15777 {
15778 data.combs_cnt = words1_cnt;
15779 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15780
15781 dictfiles = &data.dictfile2;
15782
15783 dictcnt = 1;
15784
15785 // we also have to switch wordlist related rules!
15786
15787 char *tmpc = data.rule_buf_l;
15788
15789 data.rule_buf_l = data.rule_buf_r;
15790 data.rule_buf_r = tmpc;
15791
15792 int tmpi = data.rule_len_l;
15793
15794 data.rule_len_l = data.rule_len_r;
15795 data.rule_len_r = tmpi;
15796 }
15797 }
15798 else if (attack_mode == ATTACK_MODE_BF)
15799 {
15800 char *mask = NULL;
15801
15802 maskcnt = 0;
15803
15804 if (benchmark == 0)
15805 {
15806 mask = myargv[optind + 1];
15807
15808 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15809
15810 if ((optind + 2) <= myargc)
15811 {
15812 struct stat file_stat;
15813
15814 if (stat (mask, &file_stat) == -1)
15815 {
15816 maskcnt = 1;
15817
15818 masks[maskcnt - 1] = mystrdup (mask);
15819 }
15820 else
15821 {
15822 int wls_left = myargc - (optind + 1);
15823
15824 uint masks_avail = INCR_MASKS;
15825
15826 for (int i = 0; i < wls_left; i++)
15827 {
15828 if (i != 0)
15829 {
15830 mask = myargv[optind + 1 + i];
15831
15832 if (stat (mask, &file_stat) == -1)
15833 {
15834 log_error ("ERROR: %s: %s", mask, strerror (errno));
15835
15836 return (-1);
15837 }
15838 }
15839
15840 uint is_file = S_ISREG (file_stat.st_mode);
15841
15842 if (is_file == 1)
15843 {
15844 FILE *mask_fp;
15845
15846 if ((mask_fp = fopen (mask, "r")) == NULL)
15847 {
15848 log_error ("ERROR: %s: %s", mask, strerror (errno));
15849
15850 return (-1);
15851 }
15852
15853 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15854
15855 while (!feof (mask_fp))
15856 {
15857 memset (line_buf, 0, HCBUFSIZ);
15858
15859 int line_len = fgetl (mask_fp, line_buf);
15860
15861 if (line_len == 0) continue;
15862
15863 if (line_buf[0] == '#') continue;
15864
15865 if (masks_avail == maskcnt)
15866 {
15867 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15868
15869 masks_avail += INCR_MASKS;
15870 }
15871
15872 masks[maskcnt] = mystrdup (line_buf);
15873
15874 maskcnt++;
15875 }
15876
15877 myfree (line_buf);
15878
15879 fclose (mask_fp);
15880 }
15881 else
15882 {
15883 log_error ("ERROR: %s: unsupported file-type", mask);
15884
15885 return (-1);
15886 }
15887 }
15888
15889 mask_from_file = 1;
15890 }
15891 }
15892 else
15893 {
15894 custom_charset_1 = (char *) "?l?d?u";
15895 custom_charset_2 = (char *) "?l?d";
15896 custom_charset_3 = (char *) "?l?d*!$@_";
15897
15898 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15899 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15900 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15901
15902 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15903
15904 wordlist_mode = WL_MODE_MASK;
15905
15906 data.wordlist_mode = wordlist_mode;
15907
15908 increment = 1;
15909
15910 maskcnt = 1;
15911 }
15912 }
15913 else
15914 {
15915 /**
15916 * generate full masks and charsets
15917 */
15918
15919 masks = (char **) mymalloc (sizeof (char *));
15920
15921 switch (hash_mode)
15922 {
15923 case 1731: pw_min = 5;
15924 pw_max = 5;
15925 mask = mystrdup ("?b?b?b?b?b");
15926 break;
15927 case 12500: pw_min = 5;
15928 pw_max = 5;
15929 mask = mystrdup ("?b?b?b?b?b");
15930 break;
15931 default: pw_min = 7;
15932 pw_max = 7;
15933 mask = mystrdup ("?b?b?b?b?b?b?b");
15934 break;
15935 }
15936
15937 maskcnt = 1;
15938
15939 masks[maskcnt - 1] = mystrdup (mask);
15940
15941 wordlist_mode = WL_MODE_MASK;
15942
15943 data.wordlist_mode = wordlist_mode;
15944
15945 increment = 1;
15946 }
15947
15948 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15949
15950 if (increment)
15951 {
15952 if (increment_min > pw_min) pw_min = increment_min;
15953
15954 if (increment_max < pw_max) pw_max = increment_max;
15955 }
15956 }
15957 else if (attack_mode == ATTACK_MODE_HYBRID1)
15958 {
15959 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15960
15961 // display
15962
15963 char *mask = myargv[myargc - 1];
15964
15965 maskcnt = 0;
15966
15967 masks = (char **) mymalloc (1 * sizeof (char *));
15968
15969 // mod
15970
15971 struct stat file_stat;
15972
15973 if (stat (mask, &file_stat) == -1)
15974 {
15975 maskcnt = 1;
15976
15977 masks[maskcnt - 1] = mystrdup (mask);
15978 }
15979 else
15980 {
15981 uint is_file = S_ISREG (file_stat.st_mode);
15982
15983 if (is_file == 1)
15984 {
15985 FILE *mask_fp;
15986
15987 if ((mask_fp = fopen (mask, "r")) == NULL)
15988 {
15989 log_error ("ERROR: %s: %s", mask, strerror (errno));
15990
15991 return (-1);
15992 }
15993
15994 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15995
15996 uint masks_avail = 1;
15997
15998 while (!feof (mask_fp))
15999 {
16000 memset (line_buf, 0, HCBUFSIZ);
16001
16002 int line_len = fgetl (mask_fp, line_buf);
16003
16004 if (line_len == 0) continue;
16005
16006 if (line_buf[0] == '#') continue;
16007
16008 if (masks_avail == maskcnt)
16009 {
16010 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16011
16012 masks_avail += INCR_MASKS;
16013 }
16014
16015 masks[maskcnt] = mystrdup (line_buf);
16016
16017 maskcnt++;
16018 }
16019
16020 myfree (line_buf);
16021
16022 fclose (mask_fp);
16023
16024 mask_from_file = 1;
16025 }
16026 else
16027 {
16028 maskcnt = 1;
16029
16030 masks[maskcnt - 1] = mystrdup (mask);
16031 }
16032 }
16033
16034 // base
16035
16036 int wls_left = myargc - (optind + 2);
16037
16038 for (int i = 0; i < wls_left; i++)
16039 {
16040 char *filename = myargv[optind + 1 + i];
16041
16042 struct stat file_stat;
16043
16044 if (stat (filename, &file_stat) == -1)
16045 {
16046 log_error ("ERROR: %s: %s", filename, strerror (errno));
16047
16048 return (-1);
16049 }
16050
16051 uint is_dir = S_ISDIR (file_stat.st_mode);
16052
16053 if (is_dir == 0)
16054 {
16055 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16056
16057 dictcnt++;
16058
16059 dictfiles[dictcnt - 1] = filename;
16060 }
16061 else
16062 {
16063 // do not allow --keyspace w/ a directory
16064
16065 if (keyspace == 1)
16066 {
16067 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16068
16069 return (-1);
16070 }
16071
16072 char **dictionary_files = NULL;
16073
16074 dictionary_files = scan_directory (filename);
16075
16076 if (dictionary_files != NULL)
16077 {
16078 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16079
16080 for (int d = 0; dictionary_files[d] != NULL; d++)
16081 {
16082 char *l1_filename = dictionary_files[d];
16083
16084 struct stat l1_stat;
16085
16086 if (stat (l1_filename, &l1_stat) == -1)
16087 {
16088 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16089
16090 return (-1);
16091 }
16092
16093 if (S_ISREG (l1_stat.st_mode))
16094 {
16095 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16096
16097 dictcnt++;
16098
16099 dictfiles[dictcnt - 1] = strdup (l1_filename);
16100 }
16101 }
16102 }
16103
16104 local_free (dictionary_files);
16105 }
16106 }
16107
16108 if (dictcnt < 1)
16109 {
16110 log_error ("ERROR: No usable dictionary file found.");
16111
16112 return (-1);
16113 }
16114
16115 if (increment)
16116 {
16117 maskcnt = 0;
16118
16119 uint mask_min = increment_min; // we can't reject smaller masks here
16120 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16121
16122 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16123 {
16124 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16125
16126 if (cur_mask == NULL) break;
16127
16128 masks[maskcnt] = cur_mask;
16129
16130 maskcnt++;
16131
16132 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16133 }
16134 }
16135 }
16136 else if (attack_mode == ATTACK_MODE_HYBRID2)
16137 {
16138 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16139
16140 // display
16141
16142 char *mask = myargv[optind + 1 + 0];
16143
16144 maskcnt = 0;
16145
16146 masks = (char **) mymalloc (1 * sizeof (char *));
16147
16148 // mod
16149
16150 struct stat file_stat;
16151
16152 if (stat (mask, &file_stat) == -1)
16153 {
16154 maskcnt = 1;
16155
16156 masks[maskcnt - 1] = mystrdup (mask);
16157 }
16158 else
16159 {
16160 uint is_file = S_ISREG (file_stat.st_mode);
16161
16162 if (is_file == 1)
16163 {
16164 FILE *mask_fp;
16165
16166 if ((mask_fp = fopen (mask, "r")) == NULL)
16167 {
16168 log_error ("ERROR: %s: %s", mask, strerror (errno));
16169
16170 return (-1);
16171 }
16172
16173 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16174
16175 uint masks_avail = 1;
16176
16177 while (!feof (mask_fp))
16178 {
16179 memset (line_buf, 0, HCBUFSIZ);
16180
16181 int line_len = fgetl (mask_fp, line_buf);
16182
16183 if (line_len == 0) continue;
16184
16185 if (line_buf[0] == '#') continue;
16186
16187 if (masks_avail == maskcnt)
16188 {
16189 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16190
16191 masks_avail += INCR_MASKS;
16192 }
16193
16194 masks[maskcnt] = mystrdup (line_buf);
16195
16196 maskcnt++;
16197 }
16198
16199 myfree (line_buf);
16200
16201 fclose (mask_fp);
16202
16203 mask_from_file = 1;
16204 }
16205 else
16206 {
16207 maskcnt = 1;
16208
16209 masks[maskcnt - 1] = mystrdup (mask);
16210 }
16211 }
16212
16213 // base
16214
16215 int wls_left = myargc - (optind + 2);
16216
16217 for (int i = 0; i < wls_left; i++)
16218 {
16219 char *filename = myargv[optind + 2 + i];
16220
16221 struct stat file_stat;
16222
16223 if (stat (filename, &file_stat) == -1)
16224 {
16225 log_error ("ERROR: %s: %s", filename, strerror (errno));
16226
16227 return (-1);
16228 }
16229
16230 uint is_dir = S_ISDIR (file_stat.st_mode);
16231
16232 if (is_dir == 0)
16233 {
16234 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16235
16236 dictcnt++;
16237
16238 dictfiles[dictcnt - 1] = filename;
16239 }
16240 else
16241 {
16242 // do not allow --keyspace w/ a directory
16243
16244 if (keyspace == 1)
16245 {
16246 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16247
16248 return (-1);
16249 }
16250
16251 char **dictionary_files = NULL;
16252
16253 dictionary_files = scan_directory (filename);
16254
16255 if (dictionary_files != NULL)
16256 {
16257 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16258
16259 for (int d = 0; dictionary_files[d] != NULL; d++)
16260 {
16261 char *l1_filename = dictionary_files[d];
16262
16263 struct stat l1_stat;
16264
16265 if (stat (l1_filename, &l1_stat) == -1)
16266 {
16267 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16268
16269 return (-1);
16270 }
16271
16272 if (S_ISREG (l1_stat.st_mode))
16273 {
16274 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16275
16276 dictcnt++;
16277
16278 dictfiles[dictcnt - 1] = strdup (l1_filename);
16279 }
16280 }
16281 }
16282
16283 local_free (dictionary_files);
16284 }
16285 }
16286
16287 if (dictcnt < 1)
16288 {
16289 log_error ("ERROR: No usable dictionary file found.");
16290
16291 return (-1);
16292 }
16293
16294 if (increment)
16295 {
16296 maskcnt = 0;
16297
16298 uint mask_min = increment_min; // we can't reject smaller masks here
16299 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16300
16301 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16302 {
16303 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16304
16305 if (cur_mask == NULL) break;
16306
16307 masks[maskcnt] = cur_mask;
16308
16309 maskcnt++;
16310
16311 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16312 }
16313 }
16314 }
16315
16316 data.pw_min = pw_min;
16317 data.pw_max = pw_max;
16318
16319 /**
16320 * weak hash check
16321 */
16322
16323 if (weak_hash_threshold >= salts_cnt)
16324 {
16325 hc_device_param_t *device_param = NULL;
16326
16327 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16328 {
16329 device_param = &data.devices_param[device_id];
16330
16331 if (device_param->skipped) continue;
16332
16333 break;
16334 }
16335
16336 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16337
16338 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16339 {
16340 weak_hash_check (device_param, salt_pos);
16341 }
16342
16343 // Display hack, guarantee that there is at least one \r before real start
16344
16345 //if (data.quiet == 0) log_info ("");
16346 }
16347
16348 /**
16349 * status and monitor threads
16350 */
16351
16352 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16353
16354 hc_thread_t i_thread = 0;
16355
16356 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16357 {
16358 hc_thread_create (i_thread, thread_keypress, &benchmark);
16359 }
16360
16361 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16362
16363 uint ni_threads_cnt = 0;
16364
16365 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16366
16367 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16368
16369 ni_threads_cnt++;
16370
16371 /**
16372 * Outfile remove
16373 */
16374
16375 if (keyspace == 0)
16376 {
16377 if (outfile_check_timer != 0)
16378 {
16379 if (data.outfile_check_directory != NULL)
16380 {
16381 if ((hash_mode != 5200) &&
16382 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16383 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16384 (hash_mode != 9000))
16385 {
16386 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16387
16388 ni_threads_cnt++;
16389 }
16390 else
16391 {
16392 outfile_check_timer = 0;
16393 }
16394 }
16395 else
16396 {
16397 outfile_check_timer = 0;
16398 }
16399 }
16400 }
16401
16402 /**
16403 * Inform the user if we got some hashes remove because of the pot file remove feature
16404 */
16405
16406 if (data.quiet == 0)
16407 {
16408 if (potfile_remove_cracks > 0)
16409 {
16410 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16411 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16412 }
16413 }
16414
16415 data.outfile_check_timer = outfile_check_timer;
16416
16417 /**
16418 * main loop
16419 */
16420
16421 char **induction_dictionaries = NULL;
16422
16423 int induction_dictionaries_cnt = 0;
16424
16425 hcstat_table_t *root_table_buf = NULL;
16426 hcstat_table_t *markov_table_buf = NULL;
16427
16428 uint initial_restore_done = 0;
16429
16430 data.maskcnt = maskcnt;
16431
16432 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16433 {
16434 if (data.devices_status == STATUS_CRACKED) break;
16435
16436 data.devices_status = STATUS_INIT;
16437
16438 if (maskpos > rd->maskpos)
16439 {
16440 rd->dictpos = 0;
16441 }
16442
16443 rd->maskpos = maskpos;
16444 data.maskpos = maskpos;
16445
16446 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16447 {
16448 char *mask = masks[maskpos];
16449
16450 if (mask_from_file == 1)
16451 {
16452 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16453
16454 char *str_ptr;
16455 uint str_pos;
16456
16457 uint mask_offset = 0;
16458
16459 uint separator_cnt;
16460
16461 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16462 {
16463 str_ptr = strstr (mask + mask_offset, ",");
16464
16465 if (str_ptr == NULL) break;
16466
16467 str_pos = str_ptr - mask;
16468
16469 // escaped separator, i.e. "\,"
16470
16471 if (str_pos > 0)
16472 {
16473 if (mask[str_pos - 1] == '\\')
16474 {
16475 separator_cnt --;
16476
16477 mask_offset = str_pos + 1;
16478
16479 continue;
16480 }
16481 }
16482
16483 // reset the offset
16484
16485 mask_offset = 0;
16486
16487 mask[str_pos] = '\0';
16488
16489 switch (separator_cnt)
16490 {
16491 case 0:
16492 mp_reset_usr (mp_usr, 0);
16493
16494 custom_charset_1 = mask;
16495 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16496 break;
16497
16498 case 1:
16499 mp_reset_usr (mp_usr, 1);
16500
16501 custom_charset_2 = mask;
16502 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16503 break;
16504
16505 case 2:
16506 mp_reset_usr (mp_usr, 2);
16507
16508 custom_charset_3 = mask;
16509 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16510 break;
16511
16512 case 3:
16513 mp_reset_usr (mp_usr, 3);
16514
16515 custom_charset_4 = mask;
16516 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16517 break;
16518 }
16519
16520 mask = mask + str_pos + 1;
16521 }
16522 }
16523
16524 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16525 {
16526 if (maskpos > 0)
16527 {
16528 local_free (css_buf);
16529 local_free (data.root_css_buf);
16530 local_free (data.markov_css_buf);
16531
16532 local_free (masks[maskpos - 1]);
16533 }
16534
16535 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16536
16537 data.mask = mask;
16538 data.css_cnt = css_cnt;
16539 data.css_buf = css_buf;
16540
16541 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16542
16543 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16544
16545 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16546 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16547
16548 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16549
16550 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16551
16552 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16553 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16554
16555 data.root_css_buf = root_css_buf;
16556 data.markov_css_buf = markov_css_buf;
16557
16558 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16559
16560 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16561
16562 local_free (root_table_buf);
16563 local_free (markov_table_buf);
16564
16565 // args
16566
16567 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16568 {
16569 hc_device_param_t *device_param = &data.devices_param[device_id];
16570
16571 if (device_param->skipped) continue;
16572
16573 device_param->kernel_params_mp[0] = &device_param->d_combs;
16574 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16575 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16576
16577 device_param->kernel_params_mp_buf64[3] = 0;
16578 device_param->kernel_params_mp_buf32[4] = css_cnt;
16579 device_param->kernel_params_mp_buf32[5] = 0;
16580 device_param->kernel_params_mp_buf32[6] = 0;
16581 device_param->kernel_params_mp_buf32[7] = 0;
16582
16583 if (attack_mode == ATTACK_MODE_HYBRID1)
16584 {
16585 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16586 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16587 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16588 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16589 }
16590 else if (attack_mode == ATTACK_MODE_HYBRID2)
16591 {
16592 device_param->kernel_params_mp_buf32[5] = 0;
16593 device_param->kernel_params_mp_buf32[6] = 0;
16594 device_param->kernel_params_mp_buf32[7] = 0;
16595 }
16596
16597 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]);
16598 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]);
16599 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]);
16600
16601 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);
16602 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);
16603 }
16604 }
16605 else if (attack_mode == ATTACK_MODE_BF)
16606 {
16607 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16608
16609 if (increment)
16610 {
16611 for (uint i = 0; i < dictcnt; i++)
16612 {
16613 local_free (dictfiles[i]);
16614 }
16615
16616 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16617 {
16618 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16619
16620 if (l1_filename == NULL) break;
16621
16622 dictcnt++;
16623
16624 dictfiles[dictcnt - 1] = l1_filename;
16625 }
16626 }
16627 else
16628 {
16629 dictcnt++;
16630
16631 dictfiles[dictcnt - 1] = mask;
16632 }
16633
16634 if (dictcnt == 0)
16635 {
16636 log_error ("ERROR: Mask is too small");
16637
16638 return (-1);
16639 }
16640 }
16641 }
16642
16643 free (induction_dictionaries);
16644
16645 // induction_dictionaries_cnt = 0; // implied
16646
16647 if (attack_mode != ATTACK_MODE_BF)
16648 {
16649 if (keyspace == 0)
16650 {
16651 induction_dictionaries = scan_directory (induction_directory);
16652
16653 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16654 }
16655 }
16656
16657 if (induction_dictionaries_cnt)
16658 {
16659 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16660 }
16661
16662 /**
16663 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16664 */
16665 if (keyspace == 1)
16666 {
16667 if ((maskcnt > 1) || (dictcnt > 1))
16668 {
16669 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16670
16671 return (-1);
16672 }
16673 }
16674
16675 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16676 {
16677 char *subid = logfile_generate_subid ();
16678
16679 data.subid = subid;
16680
16681 logfile_sub_msg ("START");
16682
16683 data.devices_status = STATUS_INIT;
16684
16685 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16686 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16687 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16688
16689 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16690
16691 data.cpt_pos = 0;
16692
16693 data.cpt_start = time (NULL);
16694
16695 data.cpt_total = 0;
16696
16697 if (data.restore == 0)
16698 {
16699 rd->words_cur = skip;
16700
16701 skip = 0;
16702
16703 data.skip = 0;
16704 }
16705
16706 data.ms_paused = 0;
16707
16708 data.words_cur = rd->words_cur;
16709
16710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16711 {
16712 hc_device_param_t *device_param = &data.devices_param[device_id];
16713
16714 if (device_param->skipped) continue;
16715
16716 device_param->speed_pos = 0;
16717
16718 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16719 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16720
16721 device_param->exec_pos = 0;
16722
16723 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16724
16725 device_param->kernel_power = device_param->kernel_power_user;
16726
16727 device_param->outerloop_pos = 0;
16728 device_param->outerloop_left = 0;
16729 device_param->innerloop_pos = 0;
16730 device_param->innerloop_left = 0;
16731
16732 // some more resets:
16733
16734 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16735
16736 device_param->pws_cnt = 0;
16737
16738 device_param->words_off = 0;
16739 device_param->words_done = 0;
16740 }
16741
16742 data.kernel_power_div = 0;
16743
16744 // figure out some workload
16745
16746 if (attack_mode == ATTACK_MODE_STRAIGHT)
16747 {
16748 if (data.wordlist_mode == WL_MODE_FILE)
16749 {
16750 char *dictfile = NULL;
16751
16752 if (induction_dictionaries_cnt)
16753 {
16754 dictfile = induction_dictionaries[0];
16755 }
16756 else
16757 {
16758 dictfile = dictfiles[dictpos];
16759 }
16760
16761 data.dictfile = dictfile;
16762
16763 logfile_sub_string (dictfile);
16764
16765 for (uint i = 0; i < rp_files_cnt; i++)
16766 {
16767 logfile_sub_var_string ("rulefile", rp_files[i]);
16768 }
16769
16770 FILE *fd2 = fopen (dictfile, "rb");
16771
16772 if (fd2 == NULL)
16773 {
16774 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16775
16776 return (-1);
16777 }
16778
16779 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16780
16781 fclose (fd2);
16782
16783 if (data.words_cnt == 0)
16784 {
16785 if (data.devices_status == STATUS_CRACKED) break;
16786 if (data.devices_status == STATUS_ABORTED) break;
16787
16788 dictpos++;
16789
16790 continue;
16791 }
16792 }
16793 }
16794 else if (attack_mode == ATTACK_MODE_COMBI)
16795 {
16796 char *dictfile = data.dictfile;
16797 char *dictfile2 = data.dictfile2;
16798
16799 logfile_sub_string (dictfile);
16800 logfile_sub_string (dictfile2);
16801
16802 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16803 {
16804 FILE *fd2 = fopen (dictfile, "rb");
16805
16806 if (fd2 == NULL)
16807 {
16808 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16809
16810 return (-1);
16811 }
16812
16813 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16814
16815 fclose (fd2);
16816 }
16817 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16818 {
16819 FILE *fd2 = fopen (dictfile2, "rb");
16820
16821 if (fd2 == NULL)
16822 {
16823 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16824
16825 return (-1);
16826 }
16827
16828 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16829
16830 fclose (fd2);
16831 }
16832
16833 if (data.words_cnt == 0)
16834 {
16835 if (data.devices_status == STATUS_CRACKED) break;
16836 if (data.devices_status == STATUS_ABORTED) break;
16837
16838 dictpos++;
16839
16840 continue;
16841 }
16842 }
16843 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16844 {
16845 char *dictfile = NULL;
16846
16847 if (induction_dictionaries_cnt)
16848 {
16849 dictfile = induction_dictionaries[0];
16850 }
16851 else
16852 {
16853 dictfile = dictfiles[dictpos];
16854 }
16855
16856 data.dictfile = dictfile;
16857
16858 char *mask = data.mask;
16859
16860 logfile_sub_string (dictfile);
16861 logfile_sub_string (mask);
16862
16863 FILE *fd2 = fopen (dictfile, "rb");
16864
16865 if (fd2 == NULL)
16866 {
16867 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16868
16869 return (-1);
16870 }
16871
16872 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16873
16874 fclose (fd2);
16875
16876 if (data.words_cnt == 0)
16877 {
16878 if (data.devices_status == STATUS_CRACKED) break;
16879 if (data.devices_status == STATUS_ABORTED) break;
16880
16881 dictpos++;
16882
16883 continue;
16884 }
16885 }
16886 else if (attack_mode == ATTACK_MODE_BF)
16887 {
16888 local_free (css_buf);
16889 local_free (data.root_css_buf);
16890 local_free (data.markov_css_buf);
16891
16892 char *mask = dictfiles[dictpos];
16893
16894 logfile_sub_string (mask);
16895
16896 // base
16897
16898 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16899
16900 if (opts_type & OPTS_TYPE_PT_UNICODE)
16901 {
16902 uint css_cnt_unicode = css_cnt * 2;
16903
16904 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16905
16906 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16907 {
16908 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16909
16910 css_buf_unicode[j + 1].cs_buf[0] = 0;
16911 css_buf_unicode[j + 1].cs_len = 1;
16912 }
16913
16914 free (css_buf);
16915
16916 css_buf = css_buf_unicode;
16917 css_cnt = css_cnt_unicode;
16918 }
16919
16920 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16921
16922 uint mask_min = pw_min;
16923 uint mask_max = pw_max;
16924
16925 if (opts_type & OPTS_TYPE_PT_UNICODE)
16926 {
16927 mask_min *= 2;
16928 mask_max *= 2;
16929 }
16930
16931 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16932 {
16933 if (css_cnt < mask_min)
16934 {
16935 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16936 }
16937
16938 if (css_cnt > mask_max)
16939 {
16940 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16941 }
16942
16943 // skip to next mask
16944
16945 dictpos++;
16946
16947 rd->dictpos = dictpos;
16948
16949 logfile_sub_msg ("STOP");
16950
16951 continue;
16952 }
16953
16954 uint save_css_cnt = css_cnt;
16955
16956 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16957 {
16958 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16959 {
16960 uint salt_len = (uint) data.salts_buf[0].salt_len;
16961 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16962
16963 uint css_cnt_salt = css_cnt + salt_len;
16964
16965 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16966
16967 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16968
16969 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16970 {
16971 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16972 css_buf_salt[j].cs_len = 1;
16973 }
16974
16975 free (css_buf);
16976
16977 css_buf = css_buf_salt;
16978 css_cnt = css_cnt_salt;
16979 }
16980 }
16981
16982 data.mask = mask;
16983 data.css_cnt = css_cnt;
16984 data.css_buf = css_buf;
16985
16986 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16987
16988 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16989
16990 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16991
16992 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16993 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16994
16995 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16996
16997 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16998
16999 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17000 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17001
17002 data.root_css_buf = root_css_buf;
17003 data.markov_css_buf = markov_css_buf;
17004
17005 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17006
17007 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17008
17009 local_free (root_table_buf);
17010 local_free (markov_table_buf);
17011
17012 // copy + args
17013
17014 uint css_cnt_l = css_cnt;
17015 uint css_cnt_r;
17016
17017 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17018 {
17019 if (save_css_cnt < 6)
17020 {
17021 css_cnt_r = 1;
17022 }
17023 else if (save_css_cnt == 6)
17024 {
17025 css_cnt_r = 2;
17026 }
17027 else
17028 {
17029 if (opts_type & OPTS_TYPE_PT_UNICODE)
17030 {
17031 if (save_css_cnt == 8 || save_css_cnt == 10)
17032 {
17033 css_cnt_r = 2;
17034 }
17035 else
17036 {
17037 css_cnt_r = 4;
17038 }
17039 }
17040 else
17041 {
17042 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17043 {
17044 css_cnt_r = 3;
17045 }
17046 else
17047 {
17048 css_cnt_r = 4;
17049 }
17050 }
17051 }
17052 }
17053 else
17054 {
17055 css_cnt_r = 1;
17056
17057 /* unfinished code?
17058 int sum = css_buf[css_cnt_r - 1].cs_len;
17059
17060 for (uint i = 1; i < 4 && i < css_cnt; i++)
17061 {
17062 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17063
17064 css_cnt_r++;
17065
17066 sum *= css_buf[css_cnt_r - 1].cs_len;
17067 }
17068 */
17069 }
17070
17071 css_cnt_l -= css_cnt_r;
17072
17073 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17074
17075 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17076 {
17077 hc_device_param_t *device_param = &data.devices_param[device_id];
17078
17079 if (device_param->skipped) continue;
17080
17081 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17082 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17083 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17084
17085 device_param->kernel_params_mp_l_buf64[3] = 0;
17086 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17087 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17088 device_param->kernel_params_mp_l_buf32[6] = 0;
17089 device_param->kernel_params_mp_l_buf32[7] = 0;
17090 device_param->kernel_params_mp_l_buf32[8] = 0;
17091
17092 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17093 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17094 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17095 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17096
17097 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17098 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17099 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17100
17101 device_param->kernel_params_mp_r_buf64[3] = 0;
17102 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17103 device_param->kernel_params_mp_r_buf32[5] = 0;
17104 device_param->kernel_params_mp_r_buf32[6] = 0;
17105 device_param->kernel_params_mp_r_buf32[7] = 0;
17106
17107 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]);
17108 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]);
17109 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]);
17110
17111 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]);
17112 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]);
17113 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]);
17114
17115 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);
17116 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);
17117 }
17118 }
17119
17120 u64 words_base = data.words_cnt;
17121
17122 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17123 {
17124 if (data.kernel_rules_cnt)
17125 {
17126 words_base /= data.kernel_rules_cnt;
17127 }
17128 }
17129 else if (data.attack_kern == ATTACK_KERN_COMBI)
17130 {
17131 if (data.combs_cnt)
17132 {
17133 words_base /= data.combs_cnt;
17134 }
17135 }
17136 else if (data.attack_kern == ATTACK_KERN_BF)
17137 {
17138 if (data.bfs_cnt)
17139 {
17140 words_base /= data.bfs_cnt;
17141 }
17142 }
17143
17144 data.words_base = words_base;
17145
17146 if (keyspace == 1)
17147 {
17148 log_info ("%llu", (unsigned long long int) words_base);
17149
17150 return (0);
17151 }
17152
17153 if (data.words_cur > data.words_base)
17154 {
17155 log_error ("ERROR: restore value greater keyspace");
17156
17157 return (-1);
17158 }
17159
17160 if (data.words_cur)
17161 {
17162 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17163 {
17164 for (uint i = 0; i < data.salts_cnt; i++)
17165 {
17166 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17167 }
17168 }
17169 else if (data.attack_kern == ATTACK_KERN_COMBI)
17170 {
17171 for (uint i = 0; i < data.salts_cnt; i++)
17172 {
17173 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17174 }
17175 }
17176 else if (data.attack_kern == ATTACK_KERN_BF)
17177 {
17178 for (uint i = 0; i < data.salts_cnt; i++)
17179 {
17180 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17181 }
17182 }
17183 }
17184
17185 /*
17186 * Inform user about possible slow speeds
17187 */
17188
17189 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17190 {
17191 if (data.words_base < kernel_power_all)
17192 {
17193 if (quiet == 0)
17194 {
17195 log_info ("ATTENTION!");
17196 log_info (" The wordlist or mask you are using is too small.");
17197 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17198 log_info (" The cracking speed will drop.");
17199 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17200 log_info ("");
17201 }
17202 }
17203 }
17204
17205 /*
17206 * Update loopback file
17207 */
17208
17209 if (loopback == 1)
17210 {
17211 time_t now;
17212
17213 time (&now);
17214
17215 uint random_num = get_random_num (0, 9999);
17216
17217 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17218
17219 data.loopback_file = loopback_file;
17220 }
17221
17222 /*
17223 * Update dictionary statistic
17224 */
17225
17226 if (keyspace == 0)
17227 {
17228 dictstat_fp = fopen (dictstat, "wb");
17229
17230 if (dictstat_fp)
17231 {
17232 lock_file (dictstat_fp);
17233
17234 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17235
17236 fclose (dictstat_fp);
17237 }
17238 }
17239
17240 data.devices_status = STATUS_RUNNING;
17241
17242 if (initial_restore_done == 0)
17243 {
17244 if (data.restore_disable == 0) cycle_restore ();
17245
17246 initial_restore_done = 1;
17247 }
17248
17249 hc_timer_set (&data.timer_running);
17250
17251 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17252 {
17253 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17254 {
17255 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17256 if (quiet == 0) fflush (stdout);
17257 }
17258 }
17259 else if (wordlist_mode == WL_MODE_STDIN)
17260 {
17261 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17262 if (data.quiet == 0) log_info ("");
17263 }
17264
17265 time_t runtime_start;
17266
17267 time (&runtime_start);
17268
17269 data.runtime_start = runtime_start;
17270
17271 /**
17272 * create cracker threads
17273 */
17274
17275 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17276
17277 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17278 {
17279 hc_device_param_t *device_param = &devices_param[device_id];
17280
17281 if (wordlist_mode == WL_MODE_STDIN)
17282 {
17283 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17284 }
17285 else
17286 {
17287 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17288 }
17289 }
17290
17291 // wait for crack threads to exit
17292
17293 hc_thread_wait (data.devices_cnt, c_threads);
17294
17295 local_free (c_threads);
17296
17297 data.restore = 0;
17298
17299 // finalize task
17300
17301 logfile_sub_var_uint ("status-after-work", data.devices_status);
17302
17303 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17304
17305 if (data.devices_status == STATUS_CRACKED) break;
17306 if (data.devices_status == STATUS_ABORTED) break;
17307
17308 if (data.devices_status == STATUS_BYPASS)
17309 {
17310 data.devices_status = STATUS_RUNNING;
17311 }
17312
17313 if (induction_dictionaries_cnt)
17314 {
17315 unlink (induction_dictionaries[0]);
17316 }
17317
17318 free (induction_dictionaries);
17319
17320 if (attack_mode != ATTACK_MODE_BF)
17321 {
17322 induction_dictionaries = scan_directory (induction_directory);
17323
17324 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17325 }
17326
17327 if (benchmark == 0)
17328 {
17329 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17330 {
17331 if (quiet == 0) clear_prompt ();
17332
17333 if (quiet == 0) log_info ("");
17334
17335 if (status == 1)
17336 {
17337 status_display ();
17338 }
17339 else
17340 {
17341 if (quiet == 0) status_display ();
17342 }
17343
17344 if (quiet == 0) log_info ("");
17345 }
17346 }
17347
17348 if (attack_mode == ATTACK_MODE_BF)
17349 {
17350 dictpos++;
17351
17352 rd->dictpos = dictpos;
17353 }
17354 else
17355 {
17356 if (induction_dictionaries_cnt)
17357 {
17358 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17359 }
17360 else
17361 {
17362 dictpos++;
17363
17364 rd->dictpos = dictpos;
17365 }
17366 }
17367
17368 time_t runtime_stop;
17369
17370 time (&runtime_stop);
17371
17372 data.runtime_stop = runtime_stop;
17373
17374 logfile_sub_uint (runtime_start);
17375 logfile_sub_uint (runtime_stop);
17376
17377 logfile_sub_msg ("STOP");
17378
17379 global_free (subid);
17380 }
17381
17382 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17383
17384 if (data.devices_status == STATUS_CRACKED) break;
17385 if (data.devices_status == STATUS_ABORTED) break;
17386 if (data.devices_status == STATUS_QUIT) break;
17387
17388 if (data.devices_status == STATUS_BYPASS)
17389 {
17390 data.devices_status = STATUS_RUNNING;
17391 }
17392 }
17393
17394 // 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
17395
17396 if (attack_mode == ATTACK_MODE_STRAIGHT)
17397 {
17398 if (data.wordlist_mode == WL_MODE_FILE)
17399 {
17400 if (data.dictfile == NULL)
17401 {
17402 if (dictfiles != NULL)
17403 {
17404 data.dictfile = dictfiles[0];
17405
17406 hc_timer_set (&data.timer_running);
17407 }
17408 }
17409 }
17410 }
17411 // NOTE: combi is okay because it is already set beforehand
17412 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17413 {
17414 if (data.dictfile == NULL)
17415 {
17416 if (dictfiles != NULL)
17417 {
17418 hc_timer_set (&data.timer_running);
17419
17420 data.dictfile = dictfiles[0];
17421 }
17422 }
17423 }
17424 else if (attack_mode == ATTACK_MODE_BF)
17425 {
17426 if (data.mask == NULL)
17427 {
17428 hc_timer_set (&data.timer_running);
17429
17430 data.mask = masks[0];
17431 }
17432 }
17433
17434 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17435 {
17436 data.devices_status = STATUS_EXHAUSTED;
17437 }
17438
17439 // if cracked / aborted remove last induction dictionary
17440
17441 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17442 {
17443 struct stat induct_stat;
17444
17445 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17446 {
17447 unlink (induction_dictionaries[file_pos]);
17448 }
17449 }
17450
17451 // wait for non-interactive threads
17452
17453 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17454 {
17455 hc_thread_wait (1, &ni_threads[thread_idx]);
17456 }
17457
17458 local_free (ni_threads);
17459
17460 // wait for interactive threads
17461
17462 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17463 {
17464 hc_thread_wait (1, &i_thread);
17465 }
17466
17467 // we dont need restore file anymore
17468 if (data.restore_disable == 0)
17469 {
17470 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17471 {
17472 unlink (eff_restore_file);
17473 unlink (new_restore_file);
17474 }
17475 else
17476 {
17477 cycle_restore ();
17478 }
17479 }
17480
17481 // finally save left hashes
17482
17483 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17484 {
17485 save_hash ();
17486 }
17487
17488 /**
17489 * Clean up
17490 */
17491
17492 if (benchmark == 1)
17493 {
17494 status_benchmark ();
17495
17496 if (status_automat == 0)
17497 {
17498 log_info ("");
17499 }
17500 }
17501 else
17502 {
17503 if (quiet == 0) clear_prompt ();
17504
17505 if (quiet == 0) log_info ("");
17506
17507 if (status == 1)
17508 {
17509 status_display ();
17510 }
17511 else
17512 {
17513 if (quiet == 0) status_display ();
17514 }
17515
17516 if (quiet == 0) log_info ("");
17517 }
17518
17519 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17520 {
17521 hc_device_param_t *device_param = &data.devices_param[device_id];
17522
17523 if (device_param->skipped) continue;
17524
17525 local_free (device_param->combs_buf);
17526
17527 local_free (device_param->hooks_buf);
17528
17529 local_free (device_param->device_name);
17530
17531 local_free (device_param->device_name_chksum);
17532
17533 local_free (device_param->device_version);
17534
17535 local_free (device_param->driver_version);
17536
17537 if (device_param->pws_buf) myfree (device_param->pws_buf);
17538 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17539 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17540 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17541 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17542 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17543 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17544 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17545 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17546 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17547 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17548 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17549 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17550 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17551 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17552 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17553 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17554 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17555 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17556 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17557 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17558 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17559 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17560 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17561 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17562 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17563 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17564 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17565 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17566
17567 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17568 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17569 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17570 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17571 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17572 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17573 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17574 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17575 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17576 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17577
17578 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17579 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17580 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17581
17582 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17583 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17584 }
17585
17586 // reset default fan speed
17587
17588 #ifdef HAVE_HWMON
17589 if (gpu_temp_disable == 0)
17590 {
17591 #ifdef HAVE_ADL
17592 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17593 {
17594 hc_thread_mutex_lock (mux_adl);
17595
17596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17597 {
17598 hc_device_param_t *device_param = &data.devices_param[device_id];
17599
17600 if (device_param->skipped) continue;
17601
17602 if (data.hm_device[device_id].fan_supported == 1)
17603 {
17604 int fanspeed = temp_retain_fanspeed_value[device_id];
17605
17606 if (fanspeed == -1) continue;
17607
17608 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17609
17610 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17611 }
17612 }
17613
17614 hc_thread_mutex_unlock (mux_adl);
17615 }
17616 #endif // HAVE_ADL
17617 }
17618
17619 #ifdef HAVE_ADL
17620 // reset power tuning
17621
17622 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17623 {
17624 hc_thread_mutex_lock (mux_adl);
17625
17626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17627 {
17628 hc_device_param_t *device_param = &data.devices_param[device_id];
17629
17630 if (device_param->skipped) continue;
17631
17632 if (data.hm_device[device_id].od_version == 6)
17633 {
17634 // check powertune capabilities first, if not available then skip device
17635
17636 int powertune_supported = 0;
17637
17638 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17639 {
17640 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17641
17642 return (-1);
17643 }
17644
17645 if (powertune_supported != 0)
17646 {
17647 // powercontrol settings
17648
17649 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17650 {
17651 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17652
17653 return (-1);
17654 }
17655
17656 // clocks
17657
17658 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17659
17660 performance_state->iNumberOfPerformanceLevels = 2;
17661
17662 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17663 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17664 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17665 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17666
17667 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17668 {
17669 log_info ("ERROR: Failed to restore ADL performance state");
17670
17671 return (-1);
17672 }
17673
17674 local_free (performance_state);
17675 }
17676 }
17677 }
17678
17679 hc_thread_mutex_unlock (mux_adl);
17680 }
17681 #endif // HAVE_ADL
17682
17683 if (gpu_temp_disable == 0)
17684 {
17685 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17686 if (data.hm_nv)
17687 {
17688 #if defined(LINUX) && defined(HAVE_NVML)
17689
17690 hm_NVML_nvmlShutdown (data.hm_nv);
17691
17692 nvml_close (data.hm_nv);
17693
17694 #elif defined(WIN) && (HAVE_NVAPI)
17695
17696 hm_NvAPI_Unload (data.hm_nv);
17697
17698 nvapi_close (data.hm_nv);
17699
17700 #endif
17701
17702 data.hm_nv = NULL;
17703 }
17704 #endif
17705
17706 #ifdef HAVE_ADL
17707 if (data.hm_amd)
17708 {
17709 hm_ADL_Main_Control_Destroy (data.hm_amd);
17710
17711 adl_close (data.hm_amd);
17712 data.hm_amd = NULL;
17713 }
17714 #endif
17715 }
17716 #endif // HAVE_HWMON
17717
17718 // free memory
17719
17720 local_free (masks);
17721
17722 local_free (dictstat_base);
17723
17724 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17725 {
17726 pot_t *pot_ptr = &pot[pot_pos];
17727
17728 hash_t *hash = &pot_ptr->hash;
17729
17730 local_free (hash->digest);
17731
17732 if (isSalted)
17733 {
17734 local_free (hash->salt);
17735 }
17736 }
17737
17738 local_free (pot);
17739
17740 local_free (all_kernel_rules_cnt);
17741 local_free (all_kernel_rules_buf);
17742
17743 local_free (wl_data->buf);
17744 local_free (wl_data);
17745
17746 local_free (bitmap_s1_a);
17747 local_free (bitmap_s1_b);
17748 local_free (bitmap_s1_c);
17749 local_free (bitmap_s1_d);
17750 local_free (bitmap_s2_a);
17751 local_free (bitmap_s2_b);
17752 local_free (bitmap_s2_c);
17753 local_free (bitmap_s2_d);
17754
17755 #ifdef HAVE_HWMON
17756 local_free (temp_retain_fanspeed_value);
17757 #ifdef HAVE_ADL
17758 local_free (od_clock_mem_status);
17759 local_free (od_power_control_status);
17760 #endif // ADL
17761 #endif
17762
17763 global_free (devices_param);
17764
17765 global_free (kernel_rules_buf);
17766
17767 global_free (root_css_buf);
17768 global_free (markov_css_buf);
17769
17770 global_free (digests_buf);
17771 global_free (digests_shown);
17772 global_free (digests_shown_tmp);
17773
17774 global_free (salts_buf);
17775 global_free (salts_shown);
17776
17777 global_free (esalts_buf);
17778
17779 global_free (words_progress_done);
17780 global_free (words_progress_rejected);
17781 global_free (words_progress_restored);
17782
17783 if (pot_fp) fclose (pot_fp);
17784
17785 if (data.devices_status == STATUS_QUIT) break;
17786 }
17787
17788 // destroy others mutex
17789
17790 hc_thread_mutex_delete (mux_dispatcher);
17791 hc_thread_mutex_delete (mux_counter);
17792 hc_thread_mutex_delete (mux_display);
17793 hc_thread_mutex_delete (mux_adl);
17794
17795 // free memory
17796
17797 local_free (eff_restore_file);
17798 local_free (new_restore_file);
17799
17800 local_free (rd);
17801
17802 // tuning db
17803
17804 tuning_db_destroy (tuning_db);
17805
17806 // loopback
17807
17808 local_free (loopback_file);
17809
17810 if (loopback == 1) unlink (loopback_file);
17811
17812 // induction directory
17813
17814 if (induction_dir == NULL)
17815 {
17816 if (attack_mode != ATTACK_MODE_BF)
17817 {
17818 if (rmdir (induction_directory) == -1)
17819 {
17820 if (errno == ENOENT)
17821 {
17822 // good, we can ignore
17823 }
17824 else if (errno == ENOTEMPTY)
17825 {
17826 // good, we can ignore
17827 }
17828 else
17829 {
17830 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17831
17832 return (-1);
17833 }
17834 }
17835
17836 local_free (induction_directory);
17837 }
17838 }
17839
17840 // outfile-check directory
17841
17842 if (outfile_check_dir == NULL)
17843 {
17844 if (rmdir (outfile_check_directory) == -1)
17845 {
17846 if (errno == ENOENT)
17847 {
17848 // good, we can ignore
17849 }
17850 else if (errno == ENOTEMPTY)
17851 {
17852 // good, we can ignore
17853 }
17854 else
17855 {
17856 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17857
17858 return (-1);
17859 }
17860 }
17861
17862 local_free (outfile_check_directory);
17863 }
17864
17865 time_t proc_stop;
17866
17867 time (&proc_stop);
17868
17869 logfile_top_uint (proc_start);
17870 logfile_top_uint (proc_stop);
17871
17872 logfile_top_msg ("STOP");
17873
17874 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17875 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17876
17877 if (data.ocl) ocl_close (data.ocl);
17878
17879 if (data.devices_status == STATUS_ABORTED) return 2;
17880 if (data.devices_status == STATUS_QUIT) return 2;
17881 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17882 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17883 if (data.devices_status == STATUS_CRACKED) return 0;
17884
17885 return -1;
17886 }
Hashcat additions to support pwdhash