projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix some indents
[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 #ifdef HAVE_HWMON
6530 #ifdef HAVE_ADL
6531 data.powertune_enable = powertune_enable;
6532 #endif
6533 #endif
6534 data.logfile_disable = logfile_disable;
6535 data.truecrypt_keyfiles = truecrypt_keyfiles;
6536 data.veracrypt_keyfiles = veracrypt_keyfiles;
6537 data.veracrypt_pim = veracrypt_pim;
6538 data.scrypt_tmto = scrypt_tmto;
6539 data.workload_profile = workload_profile;
6540
6541 /**
6542 * cpu affinity
6543 */
6544
6545 if (cpu_affinity)
6546 {
6547 set_cpu_affinity (cpu_affinity);
6548 }
6549
6550 if (rp_gen_seed_chgd == 0)
6551 {
6552 srand (proc_start);
6553 }
6554 else
6555 {
6556 srand (rp_gen_seed);
6557 }
6558
6559 /**
6560 * logfile init
6561 */
6562
6563 if (logfile_disable == 0)
6564 {
6565 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6566
6567 char *logfile = (char *) mymalloc (logfile_size);
6568
6569 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6570
6571 data.logfile = logfile;
6572
6573 char *topid = logfile_generate_topid ();
6574
6575 data.topid = topid;
6576 }
6577
6578 // logfile_append() checks for logfile_disable internally to make it easier from here
6579
6580 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6581 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6582 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6583 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6584 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6585 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6586 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6587 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6588 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6589 #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));
6590
6591 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6592 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6593 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6594 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6595 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6596 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6597 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6598 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6599
6600 logfile_top_msg ("START");
6601
6602 logfile_top_uint (attack_mode);
6603 logfile_top_uint (attack_kern);
6604 logfile_top_uint (benchmark);
6605 logfile_top_uint (bitmap_min);
6606 logfile_top_uint (bitmap_max);
6607 logfile_top_uint (debug_mode);
6608 logfile_top_uint (force);
6609 logfile_top_uint (kernel_accel);
6610 logfile_top_uint (kernel_loops);
6611 logfile_top_uint (gpu_temp_disable);
6612 #ifdef HAVE_HWMON
6613 logfile_top_uint (gpu_temp_abort);
6614 logfile_top_uint (gpu_temp_retain);
6615 #endif
6616 logfile_top_uint (hash_mode);
6617 logfile_top_uint (hex_charset);
6618 logfile_top_uint (hex_salt);
6619 logfile_top_uint (hex_wordlist);
6620 logfile_top_uint (increment);
6621 logfile_top_uint (increment_max);
6622 logfile_top_uint (increment_min);
6623 logfile_top_uint (keyspace);
6624 logfile_top_uint (left);
6625 logfile_top_uint (logfile_disable);
6626 logfile_top_uint (loopback);
6627 logfile_top_uint (markov_classic);
6628 logfile_top_uint (markov_disable);
6629 logfile_top_uint (markov_threshold);
6630 logfile_top_uint (outfile_autohex);
6631 logfile_top_uint (outfile_check_timer);
6632 logfile_top_uint (outfile_format);
6633 logfile_top_uint (potfile_disable);
6634 logfile_top_string (potfile_path);
6635 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6636 logfile_top_uint (powertune_enable);
6637 #endif
6638 logfile_top_uint (scrypt_tmto);
6639 logfile_top_uint (quiet);
6640 logfile_top_uint (remove);
6641 logfile_top_uint (remove_timer);
6642 logfile_top_uint (restore);
6643 logfile_top_uint (restore_disable);
6644 logfile_top_uint (restore_timer);
6645 logfile_top_uint (rp_gen);
6646 logfile_top_uint (rp_gen_func_max);
6647 logfile_top_uint (rp_gen_func_min);
6648 logfile_top_uint (rp_gen_seed);
6649 logfile_top_uint (runtime);
6650 logfile_top_uint (segment_size);
6651 logfile_top_uint (show);
6652 logfile_top_uint (status);
6653 logfile_top_uint (status_automat);
6654 logfile_top_uint (status_timer);
6655 logfile_top_uint (usage);
6656 logfile_top_uint (username);
6657 logfile_top_uint (version);
6658 logfile_top_uint (weak_hash_threshold);
6659 logfile_top_uint (workload_profile);
6660 logfile_top_uint64 (limit);
6661 logfile_top_uint64 (skip);
6662 logfile_top_char (separator);
6663 logfile_top_string (cpu_affinity);
6664 logfile_top_string (custom_charset_1);
6665 logfile_top_string (custom_charset_2);
6666 logfile_top_string (custom_charset_3);
6667 logfile_top_string (custom_charset_4);
6668 logfile_top_string (debug_file);
6669 logfile_top_string (opencl_devices);
6670 logfile_top_string (opencl_platforms);
6671 logfile_top_string (opencl_device_types);
6672 logfile_top_uint (opencl_vector_width);
6673 logfile_top_string (induction_dir);
6674 logfile_top_string (markov_hcstat);
6675 logfile_top_string (outfile);
6676 logfile_top_string (outfile_check_dir);
6677 logfile_top_string (rule_buf_l);
6678 logfile_top_string (rule_buf_r);
6679 logfile_top_string (session);
6680 logfile_top_string (truecrypt_keyfiles);
6681 logfile_top_string (veracrypt_keyfiles);
6682 logfile_top_uint (veracrypt_pim);
6683
6684 /**
6685 * Init OpenCL library loader
6686 */
6687
6688 if (keyspace == 0)
6689 {
6690 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6691
6692 ocl_init (ocl);
6693
6694 data.ocl = ocl;
6695 }
6696
6697 /**
6698 * OpenCL platform selection
6699 */
6700
6701 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6702
6703 /**
6704 * OpenCL device selection
6705 */
6706
6707 u32 devices_filter = setup_devices_filter (opencl_devices);
6708
6709 /**
6710 * OpenCL device type selection
6711 */
6712
6713 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6714
6715 /**
6716 * benchmark
6717 */
6718
6719 if (benchmark == 1)
6720 {
6721 /**
6722 * disable useless stuff for benchmark
6723 */
6724
6725 status_timer = 0;
6726 restore_timer = 0;
6727 restore_disable = 1;
6728 potfile_disable = 1;
6729 weak_hash_threshold = 0;
6730 gpu_temp_disable = 1;
6731
6732 data.status_timer = status_timer;
6733 data.restore_timer = restore_timer;
6734 data.restore_disable = restore_disable;
6735
6736 /**
6737 * force attack mode to be bruteforce
6738 */
6739
6740 attack_mode = ATTACK_MODE_BF;
6741 attack_kern = ATTACK_KERN_BF;
6742
6743 if (workload_profile_chgd == 0)
6744 {
6745 workload_profile = 3;
6746
6747 data.workload_profile = workload_profile;
6748 }
6749 }
6750
6751 /**
6752 * config
6753 */
6754
6755 uint hash_type = 0;
6756 uint salt_type = 0;
6757 uint attack_exec = 0;
6758 uint opts_type = 0;
6759 uint kern_type = 0;
6760 uint dgst_size = 0;
6761 uint esalt_size = 0;
6762 uint opti_type = 0;
6763 uint dgst_pos0 = -1;
6764 uint dgst_pos1 = -1;
6765 uint dgst_pos2 = -1;
6766 uint dgst_pos3 = -1;
6767
6768 int (*parse_func) (char *, uint, hash_t *);
6769 int (*sort_by_digest) (const void *, const void *);
6770
6771 uint algorithm_pos = 0;
6772 uint algorithm_max = 1;
6773
6774 uint *algorithms = default_benchmark_algorithms;
6775
6776 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6777
6778 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6779 {
6780 /*
6781 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6782 * the following algos are skipped entirely
6783 */
6784
6785 if (algorithm_pos > 0)
6786 {
6787 local_free (rd);
6788
6789 rd = init_restore (argc, argv);
6790
6791 data.rd = rd;
6792 }
6793
6794 /**
6795 * update hash_mode in case of multihash benchmark
6796 */
6797
6798 if (benchmark == 1)
6799 {
6800 if (hash_mode_chgd == 0)
6801 {
6802 hash_mode = algorithms[algorithm_pos];
6803
6804 data.hash_mode = hash_mode;
6805 }
6806
6807 quiet = 1;
6808
6809 data.quiet = quiet;
6810 }
6811
6812 switch (hash_mode)
6813 {
6814 case 0: hash_type = HASH_TYPE_MD5;
6815 salt_type = SALT_TYPE_NONE;
6816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6817 opts_type = OPTS_TYPE_PT_GENERATE_LE
6818 | OPTS_TYPE_PT_ADD80
6819 | OPTS_TYPE_PT_ADDBITS14;
6820 kern_type = KERN_TYPE_MD5;
6821 dgst_size = DGST_SIZE_4_4;
6822 parse_func = md5_parse_hash;
6823 sort_by_digest = sort_by_digest_4_4;
6824 opti_type = OPTI_TYPE_ZERO_BYTE
6825 | OPTI_TYPE_PRECOMPUTE_INIT
6826 | OPTI_TYPE_PRECOMPUTE_MERKLE
6827 | OPTI_TYPE_MEET_IN_MIDDLE
6828 | OPTI_TYPE_EARLY_SKIP
6829 | OPTI_TYPE_NOT_ITERATED
6830 | OPTI_TYPE_NOT_SALTED
6831 | OPTI_TYPE_RAW_HASH;
6832 dgst_pos0 = 0;
6833 dgst_pos1 = 3;
6834 dgst_pos2 = 2;
6835 dgst_pos3 = 1;
6836 break;
6837
6838 case 10: hash_type = HASH_TYPE_MD5;
6839 salt_type = SALT_TYPE_INTERN;
6840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6841 opts_type = OPTS_TYPE_PT_GENERATE_LE
6842 | OPTS_TYPE_ST_ADD80
6843 | OPTS_TYPE_ST_ADDBITS14;
6844 kern_type = KERN_TYPE_MD5_PWSLT;
6845 dgst_size = DGST_SIZE_4_4;
6846 parse_func = md5s_parse_hash;
6847 sort_by_digest = sort_by_digest_4_4;
6848 opti_type = OPTI_TYPE_ZERO_BYTE
6849 | OPTI_TYPE_PRECOMPUTE_INIT
6850 | OPTI_TYPE_PRECOMPUTE_MERKLE
6851 | OPTI_TYPE_MEET_IN_MIDDLE
6852 | OPTI_TYPE_EARLY_SKIP
6853 | OPTI_TYPE_NOT_ITERATED
6854 | OPTI_TYPE_APPENDED_SALT
6855 | OPTI_TYPE_RAW_HASH;
6856 dgst_pos0 = 0;
6857 dgst_pos1 = 3;
6858 dgst_pos2 = 2;
6859 dgst_pos3 = 1;
6860 break;
6861
6862 case 11: hash_type = HASH_TYPE_MD5;
6863 salt_type = SALT_TYPE_INTERN;
6864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6865 opts_type = OPTS_TYPE_PT_GENERATE_LE
6866 | OPTS_TYPE_ST_ADD80
6867 | OPTS_TYPE_ST_ADDBITS14;
6868 kern_type = KERN_TYPE_MD5_PWSLT;
6869 dgst_size = DGST_SIZE_4_4;
6870 parse_func = joomla_parse_hash;
6871 sort_by_digest = sort_by_digest_4_4;
6872 opti_type = OPTI_TYPE_ZERO_BYTE
6873 | OPTI_TYPE_PRECOMPUTE_INIT
6874 | OPTI_TYPE_PRECOMPUTE_MERKLE
6875 | OPTI_TYPE_MEET_IN_MIDDLE
6876 | OPTI_TYPE_EARLY_SKIP
6877 | OPTI_TYPE_NOT_ITERATED
6878 | OPTI_TYPE_APPENDED_SALT
6879 | OPTI_TYPE_RAW_HASH;
6880 dgst_pos0 = 0;
6881 dgst_pos1 = 3;
6882 dgst_pos2 = 2;
6883 dgst_pos3 = 1;
6884 break;
6885
6886 case 12: hash_type = HASH_TYPE_MD5;
6887 salt_type = SALT_TYPE_INTERN;
6888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6889 opts_type = OPTS_TYPE_PT_GENERATE_LE
6890 | OPTS_TYPE_ST_ADD80
6891 | OPTS_TYPE_ST_ADDBITS14;
6892 kern_type = KERN_TYPE_MD5_PWSLT;
6893 dgst_size = DGST_SIZE_4_4;
6894 parse_func = postgresql_parse_hash;
6895 sort_by_digest = sort_by_digest_4_4;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_MEET_IN_MIDDLE
6900 | OPTI_TYPE_EARLY_SKIP
6901 | OPTI_TYPE_NOT_ITERATED
6902 | OPTI_TYPE_APPENDED_SALT
6903 | OPTI_TYPE_RAW_HASH;
6904 dgst_pos0 = 0;
6905 dgst_pos1 = 3;
6906 dgst_pos2 = 2;
6907 dgst_pos3 = 1;
6908 break;
6909
6910 case 20: hash_type = HASH_TYPE_MD5;
6911 salt_type = SALT_TYPE_INTERN;
6912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6913 opts_type = OPTS_TYPE_PT_GENERATE_LE
6914 | OPTS_TYPE_PT_ADD80
6915 | OPTS_TYPE_PT_ADDBITS14;
6916 kern_type = KERN_TYPE_MD5_SLTPW;
6917 dgst_size = DGST_SIZE_4_4;
6918 parse_func = md5s_parse_hash;
6919 sort_by_digest = sort_by_digest_4_4;
6920 opti_type = OPTI_TYPE_ZERO_BYTE
6921 | OPTI_TYPE_PRECOMPUTE_INIT
6922 | OPTI_TYPE_PRECOMPUTE_MERKLE
6923 | OPTI_TYPE_EARLY_SKIP
6924 | OPTI_TYPE_NOT_ITERATED
6925 | OPTI_TYPE_PREPENDED_SALT
6926 | OPTI_TYPE_RAW_HASH;
6927 dgst_pos0 = 0;
6928 dgst_pos1 = 3;
6929 dgst_pos2 = 2;
6930 dgst_pos3 = 1;
6931 break;
6932
6933 case 21: hash_type = HASH_TYPE_MD5;
6934 salt_type = SALT_TYPE_INTERN;
6935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6936 opts_type = OPTS_TYPE_PT_GENERATE_LE
6937 | OPTS_TYPE_PT_ADD80
6938 | OPTS_TYPE_PT_ADDBITS14;
6939 kern_type = KERN_TYPE_MD5_SLTPW;
6940 dgst_size = DGST_SIZE_4_4;
6941 parse_func = osc_parse_hash;
6942 sort_by_digest = sort_by_digest_4_4;
6943 opti_type = OPTI_TYPE_ZERO_BYTE
6944 | OPTI_TYPE_PRECOMPUTE_INIT
6945 | OPTI_TYPE_PRECOMPUTE_MERKLE
6946 | OPTI_TYPE_EARLY_SKIP
6947 | OPTI_TYPE_NOT_ITERATED
6948 | OPTI_TYPE_PREPENDED_SALT
6949 | OPTI_TYPE_RAW_HASH;
6950 dgst_pos0 = 0;
6951 dgst_pos1 = 3;
6952 dgst_pos2 = 2;
6953 dgst_pos3 = 1;
6954 break;
6955
6956 case 22: hash_type = HASH_TYPE_MD5;
6957 salt_type = SALT_TYPE_EMBEDDED;
6958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6959 opts_type = OPTS_TYPE_PT_GENERATE_LE
6960 | OPTS_TYPE_PT_ADD80
6961 | OPTS_TYPE_PT_ADDBITS14;
6962 kern_type = KERN_TYPE_MD5_SLTPW;
6963 dgst_size = DGST_SIZE_4_4;
6964 parse_func = netscreen_parse_hash;
6965 sort_by_digest = sort_by_digest_4_4;
6966 opti_type = OPTI_TYPE_ZERO_BYTE
6967 | OPTI_TYPE_PRECOMPUTE_INIT
6968 | OPTI_TYPE_PRECOMPUTE_MERKLE
6969 | OPTI_TYPE_EARLY_SKIP
6970 | OPTI_TYPE_NOT_ITERATED
6971 | OPTI_TYPE_PREPENDED_SALT
6972 | OPTI_TYPE_RAW_HASH;
6973 dgst_pos0 = 0;
6974 dgst_pos1 = 3;
6975 dgst_pos2 = 2;
6976 dgst_pos3 = 1;
6977 break;
6978
6979 case 23: hash_type = HASH_TYPE_MD5;
6980 salt_type = SALT_TYPE_EMBEDDED;
6981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6982 opts_type = OPTS_TYPE_PT_GENERATE_LE
6983 | OPTS_TYPE_PT_ADD80
6984 | OPTS_TYPE_PT_ADDBITS14;
6985 kern_type = KERN_TYPE_MD5_SLTPW;
6986 dgst_size = DGST_SIZE_4_4;
6987 parse_func = skype_parse_hash;
6988 sort_by_digest = sort_by_digest_4_4;
6989 opti_type = OPTI_TYPE_ZERO_BYTE
6990 | OPTI_TYPE_PRECOMPUTE_INIT
6991 | OPTI_TYPE_PRECOMPUTE_MERKLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_PREPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 0;
6997 dgst_pos1 = 3;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 30: hash_type = HASH_TYPE_MD5;
7003 salt_type = SALT_TYPE_INTERN;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_LE
7006 | OPTS_TYPE_PT_UNICODE
7007 | OPTS_TYPE_ST_ADD80
7008 | OPTS_TYPE_ST_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5_PWUSLT;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = md5s_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_MEET_IN_MIDDLE
7017 | OPTI_TYPE_EARLY_SKIP
7018 | OPTI_TYPE_NOT_ITERATED
7019 | OPTI_TYPE_APPENDED_SALT
7020 | OPTI_TYPE_RAW_HASH;
7021 dgst_pos0 = 0;
7022 dgst_pos1 = 3;
7023 dgst_pos2 = 2;
7024 dgst_pos3 = 1;
7025 break;
7026
7027 case 40: hash_type = HASH_TYPE_MD5;
7028 salt_type = SALT_TYPE_INTERN;
7029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7030 opts_type = OPTS_TYPE_PT_GENERATE_LE
7031 | OPTS_TYPE_PT_ADD80
7032 | OPTS_TYPE_PT_ADDBITS14
7033 | OPTS_TYPE_PT_UNICODE;
7034 kern_type = KERN_TYPE_MD5_SLTPWU;
7035 dgst_size = DGST_SIZE_4_4;
7036 parse_func = md5s_parse_hash;
7037 sort_by_digest = sort_by_digest_4_4;
7038 opti_type = OPTI_TYPE_ZERO_BYTE
7039 | OPTI_TYPE_PRECOMPUTE_INIT
7040 | OPTI_TYPE_PRECOMPUTE_MERKLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_PREPENDED_SALT
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 0;
7046 dgst_pos1 = 3;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 50: hash_type = HASH_TYPE_MD5;
7052 salt_type = SALT_TYPE_INTERN;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_LE
7055 | OPTS_TYPE_ST_ADD80
7056 | OPTS_TYPE_ST_ADDBITS14;
7057 kern_type = KERN_TYPE_HMACMD5_PW;
7058 dgst_size = DGST_SIZE_4_4;
7059 parse_func = hmacmd5_parse_hash;
7060 sort_by_digest = sort_by_digest_4_4;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_NOT_ITERATED;
7063 dgst_pos0 = 0;
7064 dgst_pos1 = 3;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 60: hash_type = HASH_TYPE_MD5;
7070 salt_type = SALT_TYPE_INTERN;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_LE
7073 | OPTS_TYPE_PT_ADD80
7074 | OPTS_TYPE_PT_ADDBITS14;
7075 kern_type = KERN_TYPE_HMACMD5_SLT;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = hmacmd5_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_NOT_ITERATED;
7081 dgst_pos0 = 0;
7082 dgst_pos1 = 3;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 100: hash_type = HASH_TYPE_SHA1;
7088 salt_type = SALT_TYPE_NONE;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_BE
7091 | OPTS_TYPE_PT_ADD80
7092 | OPTS_TYPE_PT_ADDBITS15;
7093 kern_type = KERN_TYPE_SHA1;
7094 dgst_size = DGST_SIZE_4_5;
7095 parse_func = sha1_parse_hash;
7096 sort_by_digest = sort_by_digest_4_5;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_PRECOMPUTE_INIT
7099 | OPTI_TYPE_PRECOMPUTE_MERKLE
7100 | OPTI_TYPE_EARLY_SKIP
7101 | OPTI_TYPE_NOT_ITERATED
7102 | OPTI_TYPE_NOT_SALTED
7103 | OPTI_TYPE_RAW_HASH;
7104 dgst_pos0 = 3;
7105 dgst_pos1 = 4;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 101: hash_type = HASH_TYPE_SHA1;
7111 salt_type = SALT_TYPE_NONE;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_BE
7114 | OPTS_TYPE_PT_ADD80
7115 | OPTS_TYPE_PT_ADDBITS15;
7116 kern_type = KERN_TYPE_SHA1;
7117 dgst_size = DGST_SIZE_4_5;
7118 parse_func = sha1b64_parse_hash;
7119 sort_by_digest = sort_by_digest_4_5;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_EARLY_SKIP
7124 | OPTI_TYPE_NOT_ITERATED
7125 | OPTI_TYPE_NOT_SALTED
7126 | OPTI_TYPE_RAW_HASH;
7127 dgst_pos0 = 3;
7128 dgst_pos1 = 4;
7129 dgst_pos2 = 2;
7130 dgst_pos3 = 1;
7131 break;
7132
7133 case 110: hash_type = HASH_TYPE_SHA1;
7134 salt_type = SALT_TYPE_INTERN;
7135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7136 opts_type = OPTS_TYPE_PT_GENERATE_BE
7137 | OPTS_TYPE_ST_ADD80
7138 | OPTS_TYPE_ST_ADDBITS15;
7139 kern_type = KERN_TYPE_SHA1_PWSLT;
7140 dgst_size = DGST_SIZE_4_5;
7141 parse_func = sha1s_parse_hash;
7142 sort_by_digest = sort_by_digest_4_5;
7143 opti_type = OPTI_TYPE_ZERO_BYTE
7144 | OPTI_TYPE_PRECOMPUTE_INIT
7145 | OPTI_TYPE_PRECOMPUTE_MERKLE
7146 | OPTI_TYPE_EARLY_SKIP
7147 | OPTI_TYPE_NOT_ITERATED
7148 | OPTI_TYPE_APPENDED_SALT
7149 | OPTI_TYPE_RAW_HASH;
7150 dgst_pos0 = 3;
7151 dgst_pos1 = 4;
7152 dgst_pos2 = 2;
7153 dgst_pos3 = 1;
7154 break;
7155
7156 case 111: hash_type = HASH_TYPE_SHA1;
7157 salt_type = SALT_TYPE_EMBEDDED;
7158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7159 opts_type = OPTS_TYPE_PT_GENERATE_BE
7160 | OPTS_TYPE_ST_ADD80
7161 | OPTS_TYPE_ST_ADDBITS15;
7162 kern_type = KERN_TYPE_SHA1_PWSLT;
7163 dgst_size = DGST_SIZE_4_5;
7164 parse_func = sha1b64s_parse_hash;
7165 sort_by_digest = sort_by_digest_4_5;
7166 opti_type = OPTI_TYPE_ZERO_BYTE
7167 | OPTI_TYPE_PRECOMPUTE_INIT
7168 | OPTI_TYPE_PRECOMPUTE_MERKLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_APPENDED_SALT
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 112: hash_type = HASH_TYPE_SHA1;
7180 salt_type = SALT_TYPE_INTERN;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_BE
7183 | OPTS_TYPE_ST_ADD80
7184 | OPTS_TYPE_ST_ADDBITS15
7185 | OPTS_TYPE_ST_HEX;
7186 kern_type = KERN_TYPE_SHA1_PWSLT;
7187 dgst_size = DGST_SIZE_4_5;
7188 parse_func = oracles_parse_hash;
7189 sort_by_digest = sort_by_digest_4_5;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_APPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 120: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_INTERN;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS15;
7209 kern_type = KERN_TYPE_SHA1_SLTPW;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1s_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_PREPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 3;
7221 dgst_pos1 = 4;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 121: hash_type = HASH_TYPE_SHA1;
7227 salt_type = SALT_TYPE_INTERN;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_BE
7230 | OPTS_TYPE_PT_ADD80
7231 | OPTS_TYPE_PT_ADDBITS15
7232 | OPTS_TYPE_ST_LOWER;
7233 kern_type = KERN_TYPE_SHA1_SLTPW;
7234 dgst_size = DGST_SIZE_4_5;
7235 parse_func = smf_parse_hash;
7236 sort_by_digest = sort_by_digest_4_5;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_EARLY_SKIP
7241 | OPTI_TYPE_NOT_ITERATED
7242 | OPTI_TYPE_PREPENDED_SALT
7243 | OPTI_TYPE_RAW_HASH;
7244 dgst_pos0 = 3;
7245 dgst_pos1 = 4;
7246 dgst_pos2 = 2;
7247 dgst_pos3 = 1;
7248 break;
7249
7250 case 122: hash_type = HASH_TYPE_SHA1;
7251 salt_type = SALT_TYPE_EMBEDDED;
7252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7253 opts_type = OPTS_TYPE_PT_GENERATE_BE
7254 | OPTS_TYPE_PT_ADD80
7255 | OPTS_TYPE_PT_ADDBITS15
7256 | OPTS_TYPE_ST_HEX;
7257 kern_type = KERN_TYPE_SHA1_SLTPW;
7258 dgst_size = DGST_SIZE_4_5;
7259 parse_func = osx1_parse_hash;
7260 sort_by_digest = sort_by_digest_4_5;
7261 opti_type = OPTI_TYPE_ZERO_BYTE
7262 | OPTI_TYPE_PRECOMPUTE_INIT
7263 | OPTI_TYPE_PRECOMPUTE_MERKLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_PREPENDED_SALT
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 3;
7269 dgst_pos1 = 4;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 124: hash_type = HASH_TYPE_SHA1;
7275 salt_type = SALT_TYPE_EMBEDDED;
7276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_BE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS15;
7280 kern_type = KERN_TYPE_SHA1_SLTPW;
7281 dgst_size = DGST_SIZE_4_5;
7282 parse_func = djangosha1_parse_hash;
7283 sort_by_digest = sort_by_digest_4_5;
7284 opti_type = OPTI_TYPE_ZERO_BYTE
7285 | OPTI_TYPE_PRECOMPUTE_INIT
7286 | OPTI_TYPE_PRECOMPUTE_MERKLE
7287 | OPTI_TYPE_EARLY_SKIP
7288 | OPTI_TYPE_NOT_ITERATED
7289 | OPTI_TYPE_PREPENDED_SALT
7290 | OPTI_TYPE_RAW_HASH;
7291 dgst_pos0 = 3;
7292 dgst_pos1 = 4;
7293 dgst_pos2 = 2;
7294 dgst_pos3 = 1;
7295 break;
7296
7297 case 125: hash_type = HASH_TYPE_SHA1;
7298 salt_type = SALT_TYPE_EMBEDDED;
7299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7300 opts_type = OPTS_TYPE_PT_GENERATE_BE
7301 | OPTS_TYPE_PT_ADD80
7302 | OPTS_TYPE_PT_ADDBITS15
7303 | OPTS_TYPE_ST_HEX;
7304 kern_type = KERN_TYPE_SHA1_SLTPW;
7305 dgst_size = DGST_SIZE_4_5;
7306 parse_func = arubaos_parse_hash;
7307 sort_by_digest = sort_by_digest_4_5;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_PREPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 130: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_INTERN;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_UNICODE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA1_PWUSLT;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = sha1s_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_APPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 131: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_EMBEDDED;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_UNICODE
7350 | OPTS_TYPE_PT_UPPER
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS15
7353 | OPTS_TYPE_ST_HEX;
7354 kern_type = KERN_TYPE_SHA1_PWUSLT;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = mssql2000_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_APPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 4;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 132: hash_type = HASH_TYPE_SHA1;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_ST_ADD80
7377 | OPTS_TYPE_ST_ADDBITS15
7378 | OPTS_TYPE_ST_HEX;
7379 kern_type = KERN_TYPE_SHA1_PWUSLT;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = mssql2005_parse_hash;
7382 sort_by_digest = sort_by_digest_4_5;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_APPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 4;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 133: hash_type = HASH_TYPE_SHA1;
7397 salt_type = SALT_TYPE_EMBEDDED;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_UNICODE
7401 | OPTS_TYPE_ST_ADD80
7402 | OPTS_TYPE_ST_ADDBITS15;
7403 kern_type = KERN_TYPE_SHA1_PWUSLT;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = peoplesoft_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_APPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 140: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_INTERN;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_ADD80
7425 | OPTS_TYPE_PT_ADDBITS15
7426 | OPTS_TYPE_PT_UNICODE;
7427 kern_type = KERN_TYPE_SHA1_SLTPWU;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = sha1s_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_PREPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 141: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_EMBEDDED;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_PT_ADD80
7449 | OPTS_TYPE_PT_ADDBITS15
7450 | OPTS_TYPE_PT_UNICODE
7451 | OPTS_TYPE_ST_BASE64;
7452 kern_type = KERN_TYPE_SHA1_SLTPWU;
7453 dgst_size = DGST_SIZE_4_5;
7454 parse_func = episerver_parse_hash;
7455 sort_by_digest = sort_by_digest_4_5;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 3;
7464 dgst_pos1 = 4;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 150: hash_type = HASH_TYPE_SHA1;
7470 salt_type = SALT_TYPE_INTERN;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_BE
7473 | OPTS_TYPE_ST_ADD80
7474 | OPTS_TYPE_ST_ADDBITS15;
7475 kern_type = KERN_TYPE_HMACSHA1_PW;
7476 dgst_size = DGST_SIZE_4_5;
7477 parse_func = hmacsha1_parse_hash;
7478 sort_by_digest = sort_by_digest_4_5;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_NOT_ITERATED;
7481 dgst_pos0 = 3;
7482 dgst_pos1 = 4;
7483 dgst_pos2 = 2;
7484 dgst_pos3 = 1;
7485 break;
7486
7487 case 160: hash_type = HASH_TYPE_SHA1;
7488 salt_type = SALT_TYPE_INTERN;
7489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7490 opts_type = OPTS_TYPE_PT_GENERATE_BE
7491 | OPTS_TYPE_PT_ADD80
7492 | OPTS_TYPE_PT_ADDBITS15;
7493 kern_type = KERN_TYPE_HMACSHA1_SLT;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = hmacsha1_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_NOT_ITERATED;
7499 dgst_pos0 = 3;
7500 dgst_pos1 = 4;
7501 dgst_pos2 = 2;
7502 dgst_pos3 = 1;
7503 break;
7504
7505 case 190: hash_type = HASH_TYPE_SHA1;
7506 salt_type = SALT_TYPE_NONE;
7507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7508 opts_type = OPTS_TYPE_PT_GENERATE_BE
7509 | OPTS_TYPE_PT_ADD80
7510 | OPTS_TYPE_PT_ADDBITS15;
7511 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7512 dgst_size = DGST_SIZE_4_5;
7513 parse_func = sha1linkedin_parse_hash;
7514 sort_by_digest = sort_by_digest_4_5;
7515 opti_type = OPTI_TYPE_ZERO_BYTE
7516 | OPTI_TYPE_PRECOMPUTE_INIT
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_NOT_SALTED;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 4;
7522 dgst_pos2 = 3;
7523 dgst_pos3 = 2;
7524 break;
7525
7526 case 200: hash_type = HASH_TYPE_MYSQL;
7527 salt_type = SALT_TYPE_NONE;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = 0;
7530 kern_type = KERN_TYPE_MYSQL;
7531 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7532 parse_func = mysql323_parse_hash;
7533 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7534 opti_type = OPTI_TYPE_ZERO_BYTE;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 1;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 3;
7539 break;
7540
7541 case 300: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_NONE;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15;
7547 kern_type = KERN_TYPE_MYSQL41;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = sha1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_EARLY_SKIP
7555 | OPTI_TYPE_NOT_ITERATED
7556 | OPTI_TYPE_NOT_SALTED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 400: hash_type = HASH_TYPE_MD5;
7564 salt_type = SALT_TYPE_EMBEDDED;
7565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7567 kern_type = KERN_TYPE_PHPASS;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = phpass_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_SLOW_HASH_SIMD;
7573 dgst_pos0 = 0;
7574 dgst_pos1 = 1;
7575 dgst_pos2 = 2;
7576 dgst_pos3 = 3;
7577 break;
7578
7579 case 500: hash_type = HASH_TYPE_MD5;
7580 salt_type = SALT_TYPE_EMBEDDED;
7581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7583 kern_type = KERN_TYPE_MD5CRYPT;
7584 dgst_size = DGST_SIZE_4_4;
7585 parse_func = md5crypt_parse_hash;
7586 sort_by_digest = sort_by_digest_4_4;
7587 opti_type = OPTI_TYPE_ZERO_BYTE;
7588 dgst_pos0 = 0;
7589 dgst_pos1 = 1;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 3;
7592 break;
7593
7594 case 501: hash_type = HASH_TYPE_MD5;
7595 salt_type = SALT_TYPE_EMBEDDED;
7596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_LE
7598 | OPTS_TYPE_HASH_COPY;
7599 kern_type = KERN_TYPE_MD5CRYPT;
7600 dgst_size = DGST_SIZE_4_4;
7601 parse_func = juniper_parse_hash;
7602 sort_by_digest = sort_by_digest_4_4;
7603 opti_type = OPTI_TYPE_ZERO_BYTE;
7604 dgst_pos0 = 0;
7605 dgst_pos1 = 1;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 3;
7608 break;
7609
7610 case 900: hash_type = HASH_TYPE_MD4;
7611 salt_type = SALT_TYPE_NONE;
7612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_LE
7614 | OPTS_TYPE_PT_ADD80
7615 | OPTS_TYPE_PT_ADDBITS14;
7616 kern_type = KERN_TYPE_MD4;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = md4_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_MEET_IN_MIDDLE
7624 | OPTI_TYPE_EARLY_SKIP
7625 | OPTI_TYPE_NOT_ITERATED
7626 | OPTI_TYPE_NOT_SALTED
7627 | OPTI_TYPE_RAW_HASH;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 3;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 1;
7632 break;
7633
7634 case 1000: hash_type = HASH_TYPE_MD4;
7635 salt_type = SALT_TYPE_NONE;
7636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_PT_ADD80
7639 | OPTS_TYPE_PT_ADDBITS14
7640 | OPTS_TYPE_PT_UNICODE;
7641 kern_type = KERN_TYPE_MD4_PWU;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = md4_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_PRECOMPUTE_INIT
7647 | OPTI_TYPE_PRECOMPUTE_MERKLE
7648 | OPTI_TYPE_MEET_IN_MIDDLE
7649 | OPTI_TYPE_EARLY_SKIP
7650 | OPTI_TYPE_NOT_ITERATED
7651 | OPTI_TYPE_NOT_SALTED
7652 | OPTI_TYPE_RAW_HASH;
7653 dgst_pos0 = 0;
7654 dgst_pos1 = 3;
7655 dgst_pos2 = 2;
7656 dgst_pos3 = 1;
7657 break;
7658
7659 case 1100: hash_type = HASH_TYPE_MD4;
7660 salt_type = SALT_TYPE_INTERN;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_LE
7663 | OPTS_TYPE_PT_ADD80
7664 | OPTS_TYPE_PT_ADDBITS14
7665 | OPTS_TYPE_PT_UNICODE
7666 | OPTS_TYPE_ST_ADD80
7667 | OPTS_TYPE_ST_UNICODE
7668 | OPTS_TYPE_ST_LOWER;
7669 kern_type = KERN_TYPE_MD44_PWUSLT;
7670 dgst_size = DGST_SIZE_4_4;
7671 parse_func = dcc_parse_hash;
7672 sort_by_digest = sort_by_digest_4_4;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_EARLY_SKIP
7677 | OPTI_TYPE_NOT_ITERATED;
7678 dgst_pos0 = 0;
7679 dgst_pos1 = 3;
7680 dgst_pos2 = 2;
7681 dgst_pos3 = 1;
7682 break;
7683
7684 case 1400: hash_type = HASH_TYPE_SHA256;
7685 salt_type = SALT_TYPE_NONE;
7686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7687 opts_type = OPTS_TYPE_PT_GENERATE_BE
7688 | OPTS_TYPE_PT_ADD80
7689 | OPTS_TYPE_PT_ADDBITS15;
7690 kern_type = KERN_TYPE_SHA256;
7691 dgst_size = DGST_SIZE_4_8;
7692 parse_func = sha256_parse_hash;
7693 sort_by_digest = sort_by_digest_4_8;
7694 opti_type = OPTI_TYPE_ZERO_BYTE
7695 | OPTI_TYPE_PRECOMPUTE_INIT
7696 | OPTI_TYPE_PRECOMPUTE_MERKLE
7697 | OPTI_TYPE_EARLY_SKIP
7698 | OPTI_TYPE_NOT_ITERATED
7699 | OPTI_TYPE_NOT_SALTED
7700 | OPTI_TYPE_RAW_HASH;
7701 dgst_pos0 = 3;
7702 dgst_pos1 = 7;
7703 dgst_pos2 = 2;
7704 dgst_pos3 = 6;
7705 break;
7706
7707 case 1410: hash_type = HASH_TYPE_SHA256;
7708 salt_type = SALT_TYPE_INTERN;
7709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7710 opts_type = OPTS_TYPE_PT_GENERATE_BE
7711 | OPTS_TYPE_ST_ADD80
7712 | OPTS_TYPE_ST_ADDBITS15;
7713 kern_type = KERN_TYPE_SHA256_PWSLT;
7714 dgst_size = DGST_SIZE_4_8;
7715 parse_func = sha256s_parse_hash;
7716 sort_by_digest = sort_by_digest_4_8;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_APPENDED_SALT
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 7;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 6;
7728 break;
7729
7730 case 1420: hash_type = HASH_TYPE_SHA256;
7731 salt_type = SALT_TYPE_INTERN;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_SHA256_SLTPW;
7737 dgst_size = DGST_SIZE_4_8;
7738 parse_func = sha256s_parse_hash;
7739 sort_by_digest = sort_by_digest_4_8;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_PRECOMPUTE_MERKLE
7743 | OPTI_TYPE_EARLY_SKIP
7744 | OPTI_TYPE_NOT_ITERATED
7745 | OPTI_TYPE_PREPENDED_SALT
7746 | OPTI_TYPE_RAW_HASH;
7747 dgst_pos0 = 3;
7748 dgst_pos1 = 7;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 6;
7751 break;
7752
7753 case 1421: hash_type = HASH_TYPE_SHA256;
7754 salt_type = SALT_TYPE_EMBEDDED;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_PT_ADD80
7758 | OPTS_TYPE_PT_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA256_SLTPW;
7760 dgst_size = DGST_SIZE_4_8;
7761 parse_func = hmailserver_parse_hash;
7762 sort_by_digest = sort_by_digest_4_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_PREPENDED_SALT
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 7;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 6;
7774 break;
7775
7776 case 1430: hash_type = HASH_TYPE_SHA256;
7777 salt_type = SALT_TYPE_INTERN;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_PT_UNICODE
7781 | OPTS_TYPE_ST_ADD80
7782 | OPTS_TYPE_ST_ADDBITS15;
7783 kern_type = KERN_TYPE_SHA256_PWUSLT;
7784 dgst_size = DGST_SIZE_4_8;
7785 parse_func = sha256s_parse_hash;
7786 sort_by_digest = sort_by_digest_4_8;
7787 opti_type = OPTI_TYPE_ZERO_BYTE
7788 | OPTI_TYPE_PRECOMPUTE_INIT
7789 | OPTI_TYPE_PRECOMPUTE_MERKLE
7790 | OPTI_TYPE_EARLY_SKIP
7791 | OPTI_TYPE_NOT_ITERATED
7792 | OPTI_TYPE_APPENDED_SALT
7793 | OPTI_TYPE_RAW_HASH;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 7;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 6;
7798 break;
7799
7800 case 1440: hash_type = HASH_TYPE_SHA256;
7801 salt_type = SALT_TYPE_INTERN;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_BE
7804 | OPTS_TYPE_PT_ADD80
7805 | OPTS_TYPE_PT_ADDBITS15
7806 | OPTS_TYPE_PT_UNICODE;
7807 kern_type = KERN_TYPE_SHA256_SLTPWU;
7808 dgst_size = DGST_SIZE_4_8;
7809 parse_func = sha256s_parse_hash;
7810 sort_by_digest = sort_by_digest_4_8;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_PRECOMPUTE_INIT
7813 | OPTI_TYPE_PRECOMPUTE_MERKLE
7814 | OPTI_TYPE_EARLY_SKIP
7815 | OPTI_TYPE_NOT_ITERATED
7816 | OPTI_TYPE_PREPENDED_SALT
7817 | OPTI_TYPE_RAW_HASH;
7818 dgst_pos0 = 3;
7819 dgst_pos1 = 7;
7820 dgst_pos2 = 2;
7821 dgst_pos3 = 6;
7822 break;
7823
7824 case 1441: hash_type = HASH_TYPE_SHA256;
7825 salt_type = SALT_TYPE_EMBEDDED;
7826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7827 opts_type = OPTS_TYPE_PT_GENERATE_BE
7828 | OPTS_TYPE_PT_ADD80
7829 | OPTS_TYPE_PT_ADDBITS15
7830 | OPTS_TYPE_PT_UNICODE
7831 | OPTS_TYPE_ST_BASE64;
7832 kern_type = KERN_TYPE_SHA256_SLTPWU;
7833 dgst_size = DGST_SIZE_4_8;
7834 parse_func = episerver4_parse_hash;
7835 sort_by_digest = sort_by_digest_4_8;
7836 opti_type = OPTI_TYPE_ZERO_BYTE
7837 | OPTI_TYPE_PRECOMPUTE_INIT
7838 | OPTI_TYPE_PRECOMPUTE_MERKLE
7839 | OPTI_TYPE_EARLY_SKIP
7840 | OPTI_TYPE_NOT_ITERATED
7841 | OPTI_TYPE_PREPENDED_SALT
7842 | OPTI_TYPE_RAW_HASH;
7843 dgst_pos0 = 3;
7844 dgst_pos1 = 7;
7845 dgst_pos2 = 2;
7846 dgst_pos3 = 6;
7847 break;
7848
7849 case 1450: hash_type = HASH_TYPE_SHA256;
7850 salt_type = SALT_TYPE_INTERN;
7851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7852 opts_type = OPTS_TYPE_PT_GENERATE_BE
7853 | OPTS_TYPE_ST_ADD80;
7854 kern_type = KERN_TYPE_HMACSHA256_PW;
7855 dgst_size = DGST_SIZE_4_8;
7856 parse_func = hmacsha256_parse_hash;
7857 sort_by_digest = sort_by_digest_4_8;
7858 opti_type = OPTI_TYPE_ZERO_BYTE
7859 | OPTI_TYPE_NOT_ITERATED;
7860 dgst_pos0 = 3;
7861 dgst_pos1 = 7;
7862 dgst_pos2 = 2;
7863 dgst_pos3 = 6;
7864 break;
7865
7866 case 1460: hash_type = HASH_TYPE_SHA256;
7867 salt_type = SALT_TYPE_INTERN;
7868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7869 opts_type = OPTS_TYPE_PT_GENERATE_BE
7870 | OPTS_TYPE_PT_ADD80
7871 | OPTS_TYPE_PT_ADDBITS15;
7872 kern_type = KERN_TYPE_HMACSHA256_SLT;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = hmacsha256_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_NOT_ITERATED;
7878 dgst_pos0 = 3;
7879 dgst_pos1 = 7;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 6;
7882 break;
7883
7884 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7885 salt_type = SALT_TYPE_EMBEDDED;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_LE
7888 | OPTS_TYPE_PT_BITSLICE;
7889 kern_type = KERN_TYPE_DESCRYPT;
7890 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7891 parse_func = descrypt_parse_hash;
7892 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7893 opti_type = OPTI_TYPE_ZERO_BYTE
7894 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7895 dgst_pos0 = 0;
7896 dgst_pos1 = 1;
7897 dgst_pos2 = 2;
7898 dgst_pos3 = 3;
7899 break;
7900
7901 case 1600: hash_type = HASH_TYPE_MD5;
7902 salt_type = SALT_TYPE_EMBEDDED;
7903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7905 kern_type = KERN_TYPE_APR1CRYPT;
7906 dgst_size = DGST_SIZE_4_4;
7907 parse_func = md5apr1_parse_hash;
7908 sort_by_digest = sort_by_digest_4_4;
7909 opti_type = OPTI_TYPE_ZERO_BYTE;
7910 dgst_pos0 = 0;
7911 dgst_pos1 = 1;
7912 dgst_pos2 = 2;
7913 dgst_pos3 = 3;
7914 break;
7915
7916 case 1700: hash_type = HASH_TYPE_SHA512;
7917 salt_type = SALT_TYPE_NONE;
7918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7919 opts_type = OPTS_TYPE_PT_GENERATE_BE
7920 | OPTS_TYPE_PT_ADD80
7921 | OPTS_TYPE_PT_ADDBITS15;
7922 kern_type = KERN_TYPE_SHA512;
7923 dgst_size = DGST_SIZE_8_8;
7924 parse_func = sha512_parse_hash;
7925 sort_by_digest = sort_by_digest_8_8;
7926 opti_type = OPTI_TYPE_ZERO_BYTE
7927 | OPTI_TYPE_PRECOMPUTE_INIT
7928 | OPTI_TYPE_PRECOMPUTE_MERKLE
7929 | OPTI_TYPE_EARLY_SKIP
7930 | OPTI_TYPE_NOT_ITERATED
7931 | OPTI_TYPE_NOT_SALTED
7932 | OPTI_TYPE_USES_BITS_64
7933 | OPTI_TYPE_RAW_HASH;
7934 dgst_pos0 = 14;
7935 dgst_pos1 = 15;
7936 dgst_pos2 = 6;
7937 dgst_pos3 = 7;
7938 break;
7939
7940 case 1710: hash_type = HASH_TYPE_SHA512;
7941 salt_type = SALT_TYPE_INTERN;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_ST_ADD80
7945 | OPTS_TYPE_ST_ADDBITS15;
7946 kern_type = KERN_TYPE_SHA512_PWSLT;
7947 dgst_size = DGST_SIZE_8_8;
7948 parse_func = sha512s_parse_hash;
7949 sort_by_digest = sort_by_digest_8_8;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_APPENDED_SALT
7956 | OPTI_TYPE_USES_BITS_64
7957 | OPTI_TYPE_RAW_HASH;
7958 dgst_pos0 = 14;
7959 dgst_pos1 = 15;
7960 dgst_pos2 = 6;
7961 dgst_pos3 = 7;
7962 break;
7963
7964 case 1711: hash_type = HASH_TYPE_SHA512;
7965 salt_type = SALT_TYPE_EMBEDDED;
7966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7967 opts_type = OPTS_TYPE_PT_GENERATE_BE
7968 | OPTS_TYPE_ST_ADD80
7969 | OPTS_TYPE_ST_ADDBITS15;
7970 kern_type = KERN_TYPE_SHA512_PWSLT;
7971 dgst_size = DGST_SIZE_8_8;
7972 parse_func = sha512b64s_parse_hash;
7973 sort_by_digest = sort_by_digest_8_8;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_PRECOMPUTE_INIT
7976 | OPTI_TYPE_PRECOMPUTE_MERKLE
7977 | OPTI_TYPE_EARLY_SKIP
7978 | OPTI_TYPE_NOT_ITERATED
7979 | OPTI_TYPE_APPENDED_SALT
7980 | OPTI_TYPE_USES_BITS_64
7981 | OPTI_TYPE_RAW_HASH;
7982 dgst_pos0 = 14;
7983 dgst_pos1 = 15;
7984 dgst_pos2 = 6;
7985 dgst_pos3 = 7;
7986 break;
7987
7988 case 1720: hash_type = HASH_TYPE_SHA512;
7989 salt_type = SALT_TYPE_INTERN;
7990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7991 opts_type = OPTS_TYPE_PT_GENERATE_BE
7992 | OPTS_TYPE_PT_ADD80
7993 | OPTS_TYPE_PT_ADDBITS15;
7994 kern_type = KERN_TYPE_SHA512_SLTPW;
7995 dgst_size = DGST_SIZE_8_8;
7996 parse_func = sha512s_parse_hash;
7997 sort_by_digest = sort_by_digest_8_8;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_PREPENDED_SALT
8004 | OPTI_TYPE_USES_BITS_64
8005 | OPTI_TYPE_RAW_HASH;
8006 dgst_pos0 = 14;
8007 dgst_pos1 = 15;
8008 dgst_pos2 = 6;
8009 dgst_pos3 = 7;
8010 break;
8011
8012 case 1722: hash_type = HASH_TYPE_SHA512;
8013 salt_type = SALT_TYPE_EMBEDDED;
8014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8015 opts_type = OPTS_TYPE_PT_GENERATE_BE
8016 | OPTS_TYPE_PT_ADD80
8017 | OPTS_TYPE_PT_ADDBITS15
8018 | OPTS_TYPE_ST_HEX;
8019 kern_type = KERN_TYPE_SHA512_SLTPW;
8020 dgst_size = DGST_SIZE_8_8;
8021 parse_func = osx512_parse_hash;
8022 sort_by_digest = sort_by_digest_8_8;
8023 opti_type = OPTI_TYPE_ZERO_BYTE
8024 | OPTI_TYPE_PRECOMPUTE_INIT
8025 | OPTI_TYPE_PRECOMPUTE_MERKLE
8026 | OPTI_TYPE_EARLY_SKIP
8027 | OPTI_TYPE_NOT_ITERATED
8028 | OPTI_TYPE_PREPENDED_SALT
8029 | OPTI_TYPE_USES_BITS_64
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 14;
8032 dgst_pos1 = 15;
8033 dgst_pos2 = 6;
8034 dgst_pos3 = 7;
8035 break;
8036
8037 case 1730: hash_type = HASH_TYPE_SHA512;
8038 salt_type = SALT_TYPE_INTERN;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_UNICODE
8042 | OPTS_TYPE_ST_ADD80
8043 | OPTS_TYPE_ST_ADDBITS15;
8044 kern_type = KERN_TYPE_SHA512_PWSLTU;
8045 dgst_size = DGST_SIZE_8_8;
8046 parse_func = sha512s_parse_hash;
8047 sort_by_digest = sort_by_digest_8_8;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_APPENDED_SALT
8054 | OPTI_TYPE_USES_BITS_64
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 14;
8057 dgst_pos1 = 15;
8058 dgst_pos2 = 6;
8059 dgst_pos3 = 7;
8060 break;
8061
8062 case 1731: hash_type = HASH_TYPE_SHA512;
8063 salt_type = SALT_TYPE_EMBEDDED;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_PT_UNICODE
8067 | OPTS_TYPE_ST_ADD80
8068 | OPTS_TYPE_ST_ADDBITS15
8069 | OPTS_TYPE_ST_HEX;
8070 kern_type = KERN_TYPE_SHA512_PWSLTU;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = mssql2012_parse_hash;
8073 sort_by_digest = sort_by_digest_8_8;
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_PRECOMPUTE_INIT
8076 | OPTI_TYPE_PRECOMPUTE_MERKLE
8077 | OPTI_TYPE_EARLY_SKIP
8078 | OPTI_TYPE_NOT_ITERATED
8079 | OPTI_TYPE_APPENDED_SALT
8080 | OPTI_TYPE_USES_BITS_64
8081 | OPTI_TYPE_RAW_HASH;
8082 dgst_pos0 = 14;
8083 dgst_pos1 = 15;
8084 dgst_pos2 = 6;
8085 dgst_pos3 = 7;
8086 break;
8087
8088 case 1740: hash_type = HASH_TYPE_SHA512;
8089 salt_type = SALT_TYPE_INTERN;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_PT_ADD80
8093 | OPTS_TYPE_PT_ADDBITS15
8094 | OPTS_TYPE_PT_UNICODE;
8095 kern_type = KERN_TYPE_SHA512_SLTPWU;
8096 dgst_size = DGST_SIZE_8_8;
8097 parse_func = sha512s_parse_hash;
8098 sort_by_digest = sort_by_digest_8_8;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_PRECOMPUTE_INIT
8101 | OPTI_TYPE_PRECOMPUTE_MERKLE
8102 | OPTI_TYPE_EARLY_SKIP
8103 | OPTI_TYPE_NOT_ITERATED
8104 | OPTI_TYPE_PREPENDED_SALT
8105 | OPTI_TYPE_USES_BITS_64
8106 | OPTI_TYPE_RAW_HASH;
8107 dgst_pos0 = 14;
8108 dgst_pos1 = 15;
8109 dgst_pos2 = 6;
8110 dgst_pos3 = 7;
8111 break;
8112
8113 case 1750: hash_type = HASH_TYPE_SHA512;
8114 salt_type = SALT_TYPE_INTERN;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_ST_ADD80;
8118 kern_type = KERN_TYPE_HMACSHA512_PW;
8119 dgst_size = DGST_SIZE_8_8;
8120 parse_func = hmacsha512_parse_hash;
8121 sort_by_digest = sort_by_digest_8_8;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_USES_BITS_64
8124 | OPTI_TYPE_NOT_ITERATED;
8125 dgst_pos0 = 14;
8126 dgst_pos1 = 15;
8127 dgst_pos2 = 6;
8128 dgst_pos3 = 7;
8129 break;
8130
8131 case 1760: hash_type = HASH_TYPE_SHA512;
8132 salt_type = SALT_TYPE_INTERN;
8133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_BE
8135 | OPTS_TYPE_PT_ADD80
8136 | OPTS_TYPE_PT_ADDBITS15;
8137 kern_type = KERN_TYPE_HMACSHA512_SLT;
8138 dgst_size = DGST_SIZE_8_8;
8139 parse_func = hmacsha512_parse_hash;
8140 sort_by_digest = sort_by_digest_8_8;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_USES_BITS_64
8143 | OPTI_TYPE_NOT_ITERATED;
8144 dgst_pos0 = 14;
8145 dgst_pos1 = 15;
8146 dgst_pos2 = 6;
8147 dgst_pos3 = 7;
8148 break;
8149
8150 case 1800: hash_type = HASH_TYPE_SHA512;
8151 salt_type = SALT_TYPE_EMBEDDED;
8152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8153 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8154 kern_type = KERN_TYPE_SHA512CRYPT;
8155 dgst_size = DGST_SIZE_8_8;
8156 parse_func = sha512crypt_parse_hash;
8157 sort_by_digest = sort_by_digest_8_8;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_USES_BITS_64;
8160 dgst_pos0 = 0;
8161 dgst_pos1 = 1;
8162 dgst_pos2 = 2;
8163 dgst_pos3 = 3;
8164 break;
8165
8166 case 2100: hash_type = HASH_TYPE_DCC2;
8167 salt_type = SALT_TYPE_EMBEDDED;
8168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8170 | OPTS_TYPE_ST_LOWER
8171 | OPTS_TYPE_ST_UNICODE;
8172 kern_type = KERN_TYPE_DCC2;
8173 dgst_size = DGST_SIZE_4_4;
8174 parse_func = dcc2_parse_hash;
8175 sort_by_digest = sort_by_digest_4_4;
8176 opti_type = OPTI_TYPE_ZERO_BYTE
8177 | OPTI_TYPE_SLOW_HASH_SIMD;
8178 dgst_pos0 = 0;
8179 dgst_pos1 = 1;
8180 dgst_pos2 = 2;
8181 dgst_pos3 = 3;
8182 break;
8183
8184 case 2400: hash_type = HASH_TYPE_MD5;
8185 salt_type = SALT_TYPE_NONE;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8188 kern_type = KERN_TYPE_MD5PIX;
8189 dgst_size = DGST_SIZE_4_4;
8190 parse_func = md5pix_parse_hash;
8191 sort_by_digest = sort_by_digest_4_4;
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_PRECOMPUTE_INIT
8194 | OPTI_TYPE_PRECOMPUTE_MERKLE
8195 | OPTI_TYPE_EARLY_SKIP
8196 | OPTI_TYPE_NOT_ITERATED
8197 | OPTI_TYPE_NOT_SALTED;
8198 dgst_pos0 = 0;
8199 dgst_pos1 = 3;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 1;
8202 break;
8203
8204 case 2410: hash_type = HASH_TYPE_MD5;
8205 salt_type = SALT_TYPE_INTERN;
8206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8208 kern_type = KERN_TYPE_MD5ASA;
8209 dgst_size = DGST_SIZE_4_4;
8210 parse_func = md5asa_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_EARLY_SKIP
8216 | OPTI_TYPE_NOT_ITERATED;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 3;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 1;
8221 break;
8222
8223 case 2500: hash_type = HASH_TYPE_WPA;
8224 salt_type = SALT_TYPE_EMBEDDED;
8225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8227 kern_type = KERN_TYPE_WPA;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = wpa_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_SLOW_HASH_SIMD;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 1;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 3;
8237 break;
8238
8239 case 2600: hash_type = HASH_TYPE_MD5;
8240 salt_type = SALT_TYPE_VIRTUAL;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_PT_ADD80
8244 | OPTS_TYPE_PT_ADDBITS14
8245 | OPTS_TYPE_ST_ADD80;
8246 kern_type = KERN_TYPE_MD55_PWSLT1;
8247 dgst_size = DGST_SIZE_4_4;
8248 parse_func = md5md5_parse_hash;
8249 sort_by_digest = sort_by_digest_4_4;
8250 opti_type = OPTI_TYPE_ZERO_BYTE
8251 | OPTI_TYPE_PRECOMPUTE_INIT
8252 | OPTI_TYPE_PRECOMPUTE_MERKLE
8253 | OPTI_TYPE_EARLY_SKIP;
8254 dgst_pos0 = 0;
8255 dgst_pos1 = 3;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 1;
8258 break;
8259
8260 case 2611: hash_type = HASH_TYPE_MD5;
8261 salt_type = SALT_TYPE_INTERN;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE
8264 | OPTS_TYPE_PT_ADD80
8265 | OPTS_TYPE_PT_ADDBITS14
8266 | OPTS_TYPE_ST_ADD80;
8267 kern_type = KERN_TYPE_MD55_PWSLT1;
8268 dgst_size = DGST_SIZE_4_4;
8269 parse_func = vb3_parse_hash;
8270 sort_by_digest = sort_by_digest_4_4;
8271 opti_type = OPTI_TYPE_ZERO_BYTE
8272 | OPTI_TYPE_PRECOMPUTE_INIT
8273 | OPTI_TYPE_PRECOMPUTE_MERKLE
8274 | OPTI_TYPE_EARLY_SKIP;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 3;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 1;
8279 break;
8280
8281 case 2612: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_PT_ADD80
8286 | OPTS_TYPE_PT_ADDBITS14
8287 | OPTS_TYPE_ST_ADD80
8288 | OPTS_TYPE_ST_HEX;
8289 kern_type = KERN_TYPE_MD55_PWSLT1;
8290 dgst_size = DGST_SIZE_4_4;
8291 parse_func = phps_parse_hash;
8292 sort_by_digest = sort_by_digest_4_4;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP;
8297 dgst_pos0 = 0;
8298 dgst_pos1 = 3;
8299 dgst_pos2 = 2;
8300 dgst_pos3 = 1;
8301 break;
8302
8303 case 2711: hash_type = HASH_TYPE_MD5;
8304 salt_type = SALT_TYPE_INTERN;
8305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8306 opts_type = OPTS_TYPE_PT_GENERATE_LE
8307 | OPTS_TYPE_PT_ADD80
8308 | OPTS_TYPE_PT_ADDBITS14
8309 | OPTS_TYPE_ST_ADD80;
8310 kern_type = KERN_TYPE_MD55_PWSLT2;
8311 dgst_size = DGST_SIZE_4_4;
8312 parse_func = vb30_parse_hash;
8313 sort_by_digest = sort_by_digest_4_4;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_PRECOMPUTE_INIT
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 2811: hash_type = HASH_TYPE_MD5;
8324 salt_type = SALT_TYPE_INTERN;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_ADD80
8328 | OPTS_TYPE_PT_ADDBITS14;
8329 kern_type = KERN_TYPE_MD55_SLTPW;
8330 dgst_size = DGST_SIZE_4_4;
8331 parse_func = ipb2_parse_hash;
8332 sort_by_digest = sort_by_digest_4_4;
8333 opti_type = OPTI_TYPE_ZERO_BYTE
8334 | OPTI_TYPE_PRECOMPUTE_INIT
8335 | OPTI_TYPE_EARLY_SKIP;
8336 dgst_pos0 = 0;
8337 dgst_pos1 = 3;
8338 dgst_pos2 = 2;
8339 dgst_pos3 = 1;
8340 break;
8341
8342 case 3000: hash_type = HASH_TYPE_LM;
8343 salt_type = SALT_TYPE_NONE;
8344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8345 opts_type = OPTS_TYPE_PT_GENERATE_LE
8346 | OPTS_TYPE_PT_UPPER
8347 | OPTS_TYPE_PT_BITSLICE;
8348 kern_type = KERN_TYPE_LM;
8349 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8350 parse_func = lm_parse_hash;
8351 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8354 dgst_pos0 = 0;
8355 dgst_pos1 = 1;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 3;
8358 break;
8359
8360 case 3100: hash_type = HASH_TYPE_ORACLEH;
8361 salt_type = SALT_TYPE_INTERN;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_LE
8364 | OPTS_TYPE_PT_UPPER
8365 | OPTS_TYPE_ST_UPPER;
8366 kern_type = KERN_TYPE_ORACLEH;
8367 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8368 parse_func = oracleh_parse_hash;
8369 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8370 opti_type = OPTI_TYPE_ZERO_BYTE;
8371 dgst_pos0 = 0;
8372 dgst_pos1 = 1;
8373 dgst_pos2 = 2;
8374 dgst_pos3 = 3;
8375 break;
8376
8377 case 3200: hash_type = HASH_TYPE_BCRYPT;
8378 salt_type = SALT_TYPE_EMBEDDED;
8379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE
8381 | OPTS_TYPE_ST_GENERATE_LE;
8382 kern_type = KERN_TYPE_BCRYPT;
8383 dgst_size = DGST_SIZE_4_6;
8384 parse_func = bcrypt_parse_hash;
8385 sort_by_digest = sort_by_digest_4_6;
8386 opti_type = OPTI_TYPE_ZERO_BYTE;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 1;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 3;
8391 break;
8392
8393 case 3710: hash_type = HASH_TYPE_MD5;
8394 salt_type = SALT_TYPE_INTERN;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE
8397 | OPTS_TYPE_PT_ADD80
8398 | OPTS_TYPE_PT_ADDBITS14;
8399 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8400 dgst_size = DGST_SIZE_4_4;
8401 parse_func = md5s_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4;
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_INIT
8405 | OPTI_TYPE_PRECOMPUTE_MERKLE
8406 | OPTI_TYPE_EARLY_SKIP;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 3;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 1;
8411 break;
8412
8413 case 3711: hash_type = HASH_TYPE_MD5;
8414 salt_type = SALT_TYPE_EMBEDDED;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE
8417 | OPTS_TYPE_PT_ADD80
8418 | OPTS_TYPE_PT_ADDBITS14;
8419 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = mediawiki_b_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 3800: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_INTERN;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_ST_ADDBITS14;
8438 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8439 dgst_size = DGST_SIZE_4_4;
8440 parse_func = md5s_parse_hash;
8441 sort_by_digest = sort_by_digest_4_4;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_PRECOMPUTE_INIT
8444 | OPTI_TYPE_PRECOMPUTE_MERKLE
8445 | OPTI_TYPE_EARLY_SKIP
8446 | OPTI_TYPE_NOT_ITERATED
8447 | OPTI_TYPE_RAW_HASH;
8448 dgst_pos0 = 0;
8449 dgst_pos1 = 3;
8450 dgst_pos2 = 2;
8451 dgst_pos3 = 1;
8452 break;
8453
8454 case 4300: hash_type = HASH_TYPE_MD5;
8455 salt_type = SALT_TYPE_VIRTUAL;
8456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8457 opts_type = OPTS_TYPE_PT_GENERATE_LE
8458 | OPTS_TYPE_PT_ADD80
8459 | OPTS_TYPE_PT_ADDBITS14
8460 | OPTS_TYPE_ST_ADD80;
8461 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8462 dgst_size = DGST_SIZE_4_4;
8463 parse_func = md5md5_parse_hash;
8464 sort_by_digest = sort_by_digest_4_4;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP;
8469 dgst_pos0 = 0;
8470 dgst_pos1 = 3;
8471 dgst_pos2 = 2;
8472 dgst_pos3 = 1;
8473 break;
8474
8475
8476 case 4400: hash_type = HASH_TYPE_MD5;
8477 salt_type = SALT_TYPE_NONE;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_BE
8480 | OPTS_TYPE_PT_ADD80
8481 | OPTS_TYPE_PT_ADDBITS15;
8482 kern_type = KERN_TYPE_MD5_SHA1;
8483 dgst_size = DGST_SIZE_4_4;
8484 parse_func = md5_parse_hash;
8485 sort_by_digest = sort_by_digest_4_4;
8486 opti_type = OPTI_TYPE_ZERO_BYTE
8487 | OPTI_TYPE_PRECOMPUTE_INIT
8488 | OPTI_TYPE_PRECOMPUTE_MERKLE
8489 | OPTI_TYPE_EARLY_SKIP
8490 | OPTI_TYPE_NOT_ITERATED
8491 | OPTI_TYPE_NOT_SALTED
8492 | OPTI_TYPE_RAW_HASH;
8493 dgst_pos0 = 0;
8494 dgst_pos1 = 3;
8495 dgst_pos2 = 2;
8496 dgst_pos3 = 1;
8497 break;
8498
8499 case 4500: hash_type = HASH_TYPE_SHA1;
8500 salt_type = SALT_TYPE_NONE;
8501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8502 opts_type = OPTS_TYPE_PT_GENERATE_BE
8503 | OPTS_TYPE_PT_ADD80
8504 | OPTS_TYPE_PT_ADDBITS15;
8505 kern_type = KERN_TYPE_SHA11;
8506 dgst_size = DGST_SIZE_4_5;
8507 parse_func = sha1_parse_hash;
8508 sort_by_digest = sort_by_digest_4_5;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_PRECOMPUTE_INIT
8511 | OPTI_TYPE_PRECOMPUTE_MERKLE
8512 | OPTI_TYPE_EARLY_SKIP
8513 | OPTI_TYPE_NOT_SALTED;
8514 dgst_pos0 = 3;
8515 dgst_pos1 = 4;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 1;
8518 break;
8519
8520 case 4700: hash_type = HASH_TYPE_SHA1;
8521 salt_type = SALT_TYPE_NONE;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_LE
8524 | OPTS_TYPE_PT_ADD80
8525 | OPTS_TYPE_PT_ADDBITS14;
8526 kern_type = KERN_TYPE_SHA1_MD5;
8527 dgst_size = DGST_SIZE_4_5;
8528 parse_func = sha1_parse_hash;
8529 sort_by_digest = sort_by_digest_4_5;
8530 opti_type = OPTI_TYPE_ZERO_BYTE
8531 | OPTI_TYPE_PRECOMPUTE_INIT
8532 | OPTI_TYPE_PRECOMPUTE_MERKLE
8533 | OPTI_TYPE_EARLY_SKIP
8534 | OPTI_TYPE_NOT_ITERATED
8535 | OPTI_TYPE_NOT_SALTED
8536 | OPTI_TYPE_RAW_HASH;
8537 dgst_pos0 = 3;
8538 dgst_pos1 = 4;
8539 dgst_pos2 = 2;
8540 dgst_pos3 = 1;
8541 break;
8542
8543 case 4800: hash_type = HASH_TYPE_MD5;
8544 salt_type = SALT_TYPE_EMBEDDED;
8545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8546 opts_type = OPTS_TYPE_PT_GENERATE_LE
8547 | OPTS_TYPE_PT_ADDBITS14;
8548 kern_type = KERN_TYPE_MD5_CHAP;
8549 dgst_size = DGST_SIZE_4_4;
8550 parse_func = chap_parse_hash;
8551 sort_by_digest = sort_by_digest_4_4;
8552 opti_type = OPTI_TYPE_ZERO_BYTE
8553 | OPTI_TYPE_PRECOMPUTE_INIT
8554 | OPTI_TYPE_PRECOMPUTE_MERKLE
8555 | OPTI_TYPE_MEET_IN_MIDDLE
8556 | OPTI_TYPE_EARLY_SKIP
8557 | OPTI_TYPE_NOT_ITERATED
8558 | OPTI_TYPE_RAW_HASH;
8559 dgst_pos0 = 0;
8560 dgst_pos1 = 3;
8561 dgst_pos2 = 2;
8562 dgst_pos3 = 1;
8563 break;
8564
8565 case 4900: hash_type = HASH_TYPE_SHA1;
8566 salt_type = SALT_TYPE_INTERN;
8567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8568 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8569 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8570 dgst_size = DGST_SIZE_4_5;
8571 parse_func = sha1s_parse_hash;
8572 sort_by_digest = sort_by_digest_4_5;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP;
8577 dgst_pos0 = 3;
8578 dgst_pos1 = 4;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 1;
8581 break;
8582
8583 case 5000: hash_type = HASH_TYPE_KECCAK;
8584 salt_type = SALT_TYPE_EMBEDDED;
8585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE
8587 | OPTS_TYPE_PT_ADD01;
8588 kern_type = KERN_TYPE_KECCAK;
8589 dgst_size = DGST_SIZE_8_25;
8590 parse_func = keccak_parse_hash;
8591 sort_by_digest = sort_by_digest_8_25;
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_USES_BITS_64
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 2;
8596 dgst_pos1 = 3;
8597 dgst_pos2 = 4;
8598 dgst_pos3 = 5;
8599 break;
8600
8601 case 5100: hash_type = HASH_TYPE_MD5H;
8602 salt_type = SALT_TYPE_NONE;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE
8605 | OPTS_TYPE_PT_ADD80
8606 | OPTS_TYPE_PT_ADDBITS14;
8607 kern_type = KERN_TYPE_MD5H;
8608 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8609 parse_func = md5half_parse_hash;
8610 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_RAW_HASH;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 1;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 3;
8617 break;
8618
8619 case 5200: hash_type = HASH_TYPE_SHA256;
8620 salt_type = SALT_TYPE_EMBEDDED;
8621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8623 kern_type = KERN_TYPE_PSAFE3;
8624 dgst_size = DGST_SIZE_4_8;
8625 parse_func = psafe3_parse_hash;
8626 sort_by_digest = sort_by_digest_4_8;
8627 opti_type = OPTI_TYPE_ZERO_BYTE;
8628 dgst_pos0 = 0;
8629 dgst_pos1 = 1;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 3;
8632 break;
8633
8634 case 5300: hash_type = HASH_TYPE_MD5;
8635 salt_type = SALT_TYPE_EMBEDDED;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE
8638 | OPTS_TYPE_ST_ADD80;
8639 kern_type = KERN_TYPE_IKEPSK_MD5;
8640 dgst_size = DGST_SIZE_4_4;
8641 parse_func = ikepsk_md5_parse_hash;
8642 sort_by_digest = sort_by_digest_4_4;
8643 opti_type = OPTI_TYPE_ZERO_BYTE;
8644 dgst_pos0 = 0;
8645 dgst_pos1 = 3;
8646 dgst_pos2 = 2;
8647 dgst_pos3 = 1;
8648 break;
8649
8650 case 5400: hash_type = HASH_TYPE_SHA1;
8651 salt_type = SALT_TYPE_EMBEDDED;
8652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_BE
8654 | OPTS_TYPE_ST_ADD80;
8655 kern_type = KERN_TYPE_IKEPSK_SHA1;
8656 dgst_size = DGST_SIZE_4_5;
8657 parse_func = ikepsk_sha1_parse_hash;
8658 sort_by_digest = sort_by_digest_4_5;
8659 opti_type = OPTI_TYPE_ZERO_BYTE;
8660 dgst_pos0 = 3;
8661 dgst_pos1 = 4;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 1;
8664 break;
8665
8666 case 5500: hash_type = HASH_TYPE_NETNTLM;
8667 salt_type = SALT_TYPE_EMBEDDED;
8668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_LE
8670 | OPTS_TYPE_PT_ADD80
8671 | OPTS_TYPE_PT_ADDBITS14
8672 | OPTS_TYPE_PT_UNICODE
8673 | OPTS_TYPE_ST_HEX;
8674 kern_type = KERN_TYPE_NETNTLMv1;
8675 dgst_size = DGST_SIZE_4_4;
8676 parse_func = netntlmv1_parse_hash;
8677 sort_by_digest = sort_by_digest_4_4;
8678 opti_type = OPTI_TYPE_ZERO_BYTE
8679 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8680 dgst_pos0 = 0;
8681 dgst_pos1 = 1;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 3;
8684 break;
8685
8686 case 5600: hash_type = HASH_TYPE_MD5;
8687 salt_type = SALT_TYPE_EMBEDDED;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE
8690 | OPTS_TYPE_PT_ADD80
8691 | OPTS_TYPE_PT_ADDBITS14
8692 | OPTS_TYPE_PT_UNICODE;
8693 kern_type = KERN_TYPE_NETNTLMv2;
8694 dgst_size = DGST_SIZE_4_4;
8695 parse_func = netntlmv2_parse_hash;
8696 sort_by_digest = sort_by_digest_4_4;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 3;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5700: hash_type = HASH_TYPE_SHA256;
8705 salt_type = SALT_TYPE_NONE;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_BE
8708 | OPTS_TYPE_PT_ADD80
8709 | OPTS_TYPE_PT_ADDBITS15;
8710 kern_type = KERN_TYPE_SHA256;
8711 dgst_size = DGST_SIZE_4_8;
8712 parse_func = cisco4_parse_hash;
8713 sort_by_digest = sort_by_digest_4_8;
8714 opti_type = OPTI_TYPE_ZERO_BYTE
8715 | OPTI_TYPE_PRECOMPUTE_INIT
8716 | OPTI_TYPE_PRECOMPUTE_MERKLE
8717 | OPTI_TYPE_EARLY_SKIP
8718 | OPTI_TYPE_NOT_ITERATED
8719 | OPTI_TYPE_NOT_SALTED
8720 | OPTI_TYPE_RAW_HASH;
8721 dgst_pos0 = 3;
8722 dgst_pos1 = 7;
8723 dgst_pos2 = 2;
8724 dgst_pos3 = 6;
8725 break;
8726
8727 case 5800: hash_type = HASH_TYPE_SHA1;
8728 salt_type = SALT_TYPE_INTERN;
8729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8730 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8731 | OPTS_TYPE_ST_ADD80;
8732 kern_type = KERN_TYPE_ANDROIDPIN;
8733 dgst_size = DGST_SIZE_4_5;
8734 parse_func = androidpin_parse_hash;
8735 sort_by_digest = sort_by_digest_4_5;
8736 opti_type = OPTI_TYPE_ZERO_BYTE;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 1;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 3;
8741 break;
8742
8743 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE
8747 | OPTS_TYPE_PT_ADD80;
8748 kern_type = KERN_TYPE_RIPEMD160;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = ripemd160_parse_hash;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8760 salt_type = SALT_TYPE_NONE;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_BE
8763 | OPTS_TYPE_PT_ADD80;
8764 kern_type = KERN_TYPE_WHIRLPOOL;
8765 dgst_size = DGST_SIZE_4_16;
8766 parse_func = whirlpool_parse_hash;
8767 sort_by_digest = sort_by_digest_4_16;
8768 opti_type = OPTI_TYPE_ZERO_BYTE;
8769 dgst_pos0 = 0;
8770 dgst_pos1 = 1;
8771 dgst_pos2 = 2;
8772 dgst_pos3 = 3;
8773 break;
8774
8775 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8776 salt_type = SALT_TYPE_EMBEDDED;
8777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8778 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8779 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8780 dgst_size = DGST_SIZE_4_5;
8781 parse_func = truecrypt_parse_hash_2k;
8782 sort_by_digest = sort_by_digest_4_5;
8783 opti_type = OPTI_TYPE_ZERO_BYTE;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8791 salt_type = SALT_TYPE_EMBEDDED;
8792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8794 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8795 dgst_size = DGST_SIZE_4_5;
8796 parse_func = truecrypt_parse_hash_2k;
8797 sort_by_digest = sort_by_digest_4_5;
8798 opti_type = OPTI_TYPE_ZERO_BYTE;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8809 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8810 dgst_size = DGST_SIZE_4_5;
8811 parse_func = truecrypt_parse_hash_2k;
8812 sort_by_digest = sort_by_digest_4_5;
8813 opti_type = OPTI_TYPE_ZERO_BYTE;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 6221: hash_type = HASH_TYPE_SHA512;
8821 salt_type = SALT_TYPE_EMBEDDED;
8822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8824 kern_type = KERN_TYPE_TCSHA512_XTS512;
8825 dgst_size = DGST_SIZE_8_8;
8826 parse_func = truecrypt_parse_hash_1k;
8827 sort_by_digest = sort_by_digest_8_8;
8828 opti_type = OPTI_TYPE_ZERO_BYTE
8829 | OPTI_TYPE_USES_BITS_64;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 6222: hash_type = HASH_TYPE_SHA512;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8840 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8841 dgst_size = DGST_SIZE_8_8;
8842 parse_func = truecrypt_parse_hash_1k;
8843 sort_by_digest = sort_by_digest_8_8;
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_USES_BITS_64;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 6223: hash_type = HASH_TYPE_SHA512;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8856 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8857 dgst_size = DGST_SIZE_8_8;
8858 parse_func = truecrypt_parse_hash_1k;
8859 sort_by_digest = sort_by_digest_8_8;
8860 opti_type = OPTI_TYPE_ZERO_BYTE
8861 | OPTI_TYPE_USES_BITS_64;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8872 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8873 dgst_size = DGST_SIZE_4_8;
8874 parse_func = truecrypt_parse_hash_1k;
8875 sort_by_digest = sort_by_digest_4_8;
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8887 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8888 dgst_size = DGST_SIZE_4_8;
8889 parse_func = truecrypt_parse_hash_1k;
8890 sort_by_digest = sort_by_digest_4_8;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8899 salt_type = SALT_TYPE_EMBEDDED;
8900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8902 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8903 dgst_size = DGST_SIZE_4_8;
8904 parse_func = truecrypt_parse_hash_1k;
8905 sort_by_digest = sort_by_digest_4_8;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8917 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8918 dgst_size = DGST_SIZE_4_5;
8919 parse_func = truecrypt_parse_hash_1k;
8920 sort_by_digest = sort_by_digest_4_5;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8929 salt_type = SALT_TYPE_EMBEDDED;
8930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8932 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8933 dgst_size = DGST_SIZE_4_5;
8934 parse_func = truecrypt_parse_hash_1k;
8935 sort_by_digest = sort_by_digest_4_5;
8936 opti_type = OPTI_TYPE_ZERO_BYTE;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 1;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 3;
8941 break;
8942
8943 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8947 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8948 dgst_size = DGST_SIZE_4_5;
8949 parse_func = truecrypt_parse_hash_1k;
8950 sort_by_digest = sort_by_digest_4_5;
8951 opti_type = OPTI_TYPE_ZERO_BYTE;
8952 dgst_pos0 = 0;
8953 dgst_pos1 = 1;
8954 dgst_pos2 = 2;
8955 dgst_pos3 = 3;
8956 break;
8957
8958 case 6300: hash_type = HASH_TYPE_MD5;
8959 salt_type = SALT_TYPE_EMBEDDED;
8960 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8961 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8962 kern_type = KERN_TYPE_MD5AIX;
8963 dgst_size = DGST_SIZE_4_4;
8964 parse_func = md5aix_parse_hash;
8965 sort_by_digest = sort_by_digest_4_4;
8966 opti_type = OPTI_TYPE_ZERO_BYTE;
8967 dgst_pos0 = 0;
8968 dgst_pos1 = 1;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 3;
8971 break;
8972
8973 case 6400: hash_type = HASH_TYPE_SHA256;
8974 salt_type = SALT_TYPE_EMBEDDED;
8975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8976 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8977 kern_type = KERN_TYPE_SHA256AIX;
8978 dgst_size = DGST_SIZE_4_8;
8979 parse_func = sha256aix_parse_hash;
8980 sort_by_digest = sort_by_digest_4_8;
8981 opti_type = OPTI_TYPE_ZERO_BYTE;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 6500: hash_type = HASH_TYPE_SHA512;
8989 salt_type = SALT_TYPE_EMBEDDED;
8990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8992 kern_type = KERN_TYPE_SHA512AIX;
8993 dgst_size = DGST_SIZE_8_8;
8994 parse_func = sha512aix_parse_hash;
8995 sort_by_digest = sort_by_digest_8_8;
8996 opti_type = OPTI_TYPE_ZERO_BYTE
8997 | OPTI_TYPE_USES_BITS_64;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 6600: hash_type = HASH_TYPE_AES;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9008 kern_type = KERN_TYPE_AGILEKEY;
9009 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9010 parse_func = agilekey_parse_hash;
9011 sort_by_digest = sort_by_digest_4_5;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6700: hash_type = HASH_TYPE_SHA1;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9023 kern_type = KERN_TYPE_SHA1AIX;
9024 dgst_size = DGST_SIZE_4_5;
9025 parse_func = sha1aix_parse_hash;
9026 sort_by_digest = sort_by_digest_4_5;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 6800: hash_type = HASH_TYPE_AES;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_LASTPASS;
9039 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9040 parse_func = lastpass_parse_hash;
9041 sort_by_digest = sort_by_digest_4_8;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 6900: hash_type = HASH_TYPE_GOST;
9050 salt_type = SALT_TYPE_NONE;
9051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9053 kern_type = KERN_TYPE_GOST;
9054 dgst_size = DGST_SIZE_4_8;
9055 parse_func = gost_parse_hash;
9056 sort_by_digest = sort_by_digest_4_8;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 7100: hash_type = HASH_TYPE_SHA512;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9068 kern_type = KERN_TYPE_PBKDF2_SHA512;
9069 dgst_size = DGST_SIZE_8_16;
9070 parse_func = sha512osx_parse_hash;
9071 sort_by_digest = sort_by_digest_8_16;
9072 opti_type = OPTI_TYPE_ZERO_BYTE
9073 | OPTI_TYPE_USES_BITS_64
9074 | OPTI_TYPE_SLOW_HASH_SIMD;
9075 dgst_pos0 = 0;
9076 dgst_pos1 = 1;
9077 dgst_pos2 = 2;
9078 dgst_pos3 = 3;
9079 break;
9080
9081 case 7200: hash_type = HASH_TYPE_SHA512;
9082 salt_type = SALT_TYPE_EMBEDDED;
9083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9084 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9085 kern_type = KERN_TYPE_PBKDF2_SHA512;
9086 dgst_size = DGST_SIZE_8_16;
9087 parse_func = sha512grub_parse_hash;
9088 sort_by_digest = sort_by_digest_8_16;
9089 opti_type = OPTI_TYPE_ZERO_BYTE
9090 | OPTI_TYPE_USES_BITS_64
9091 | OPTI_TYPE_SLOW_HASH_SIMD;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 1;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 3;
9096 break;
9097
9098 case 7300: hash_type = HASH_TYPE_SHA1;
9099 salt_type = SALT_TYPE_EMBEDDED;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_BE
9102 | OPTS_TYPE_ST_ADD80
9103 | OPTS_TYPE_ST_ADDBITS15;
9104 kern_type = KERN_TYPE_RAKP;
9105 dgst_size = DGST_SIZE_4_5;
9106 parse_func = rakp_parse_hash;
9107 sort_by_digest = sort_by_digest_4_5;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_NOT_ITERATED;
9110 dgst_pos0 = 3;
9111 dgst_pos1 = 4;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 1;
9114 break;
9115
9116 case 7400: hash_type = HASH_TYPE_SHA256;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9120 kern_type = KERN_TYPE_SHA256CRYPT;
9121 dgst_size = DGST_SIZE_4_8;
9122 parse_func = sha256crypt_parse_hash;
9123 sort_by_digest = sort_by_digest_4_8;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 7500: hash_type = HASH_TYPE_KRB5PA;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9135 kern_type = KERN_TYPE_KRB5PA;
9136 dgst_size = DGST_SIZE_4_4;
9137 parse_func = krb5pa_parse_hash;
9138 sort_by_digest = sort_by_digest_4_4;
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_NOT_ITERATED;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 7600: hash_type = HASH_TYPE_SHA1;
9148 salt_type = SALT_TYPE_INTERN;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_BE
9151 | OPTS_TYPE_PT_ADD80
9152 | OPTS_TYPE_PT_ADDBITS15;
9153 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9154 dgst_size = DGST_SIZE_4_5;
9155 parse_func = redmine_parse_hash;
9156 sort_by_digest = sort_by_digest_4_5;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_PRECOMPUTE_INIT
9159 | OPTI_TYPE_EARLY_SKIP
9160 | OPTI_TYPE_NOT_ITERATED
9161 | OPTI_TYPE_PREPENDED_SALT;
9162 dgst_pos0 = 3;
9163 dgst_pos1 = 4;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 1;
9166 break;
9167
9168 case 7700: hash_type = HASH_TYPE_SAPB;
9169 salt_type = SALT_TYPE_EMBEDDED;
9170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_LE
9172 | OPTS_TYPE_PT_UPPER
9173 | OPTS_TYPE_ST_UPPER;
9174 kern_type = KERN_TYPE_SAPB;
9175 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9176 parse_func = sapb_parse_hash;
9177 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_NOT_ITERATED;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 7800: hash_type = HASH_TYPE_SAPG;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_BE
9191 | OPTS_TYPE_ST_ADD80
9192 | OPTS_TYPE_ST_UPPER;
9193 kern_type = KERN_TYPE_SAPG;
9194 dgst_size = DGST_SIZE_4_5;
9195 parse_func = sapg_parse_hash;
9196 sort_by_digest = sort_by_digest_4_5;
9197 opti_type = OPTI_TYPE_ZERO_BYTE
9198 | OPTI_TYPE_PRECOMPUTE_INIT
9199 | OPTI_TYPE_NOT_ITERATED;
9200 dgst_pos0 = 3;
9201 dgst_pos1 = 4;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 1;
9204 break;
9205
9206 case 7900: hash_type = HASH_TYPE_SHA512;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9210 kern_type = KERN_TYPE_DRUPAL7;
9211 dgst_size = DGST_SIZE_8_8;
9212 parse_func = drupal7_parse_hash;
9213 sort_by_digest = sort_by_digest_8_8;
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_USES_BITS_64;
9216 dgst_pos0 = 0;
9217 dgst_pos1 = 1;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 3;
9220 break;
9221
9222 case 8000: hash_type = HASH_TYPE_SHA256;
9223 salt_type = SALT_TYPE_EMBEDDED;
9224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_BE
9226 | OPTS_TYPE_PT_UNICODE
9227 | OPTS_TYPE_ST_ADD80
9228 | OPTS_TYPE_ST_HEX;
9229 kern_type = KERN_TYPE_SYBASEASE;
9230 dgst_size = DGST_SIZE_4_8;
9231 parse_func = sybasease_parse_hash;
9232 sort_by_digest = sort_by_digest_4_8;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_EARLY_SKIP
9236 | OPTI_TYPE_NOT_ITERATED
9237 | OPTI_TYPE_RAW_HASH;
9238 dgst_pos0 = 3;
9239 dgst_pos1 = 7;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 6;
9242 break;
9243
9244 case 8100: hash_type = HASH_TYPE_SHA1;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9248 kern_type = KERN_TYPE_NETSCALER;
9249 dgst_size = DGST_SIZE_4_5;
9250 parse_func = netscaler_parse_hash;
9251 sort_by_digest = sort_by_digest_4_5;
9252 opti_type = OPTI_TYPE_ZERO_BYTE
9253 | OPTI_TYPE_PRECOMPUTE_INIT
9254 | OPTI_TYPE_PRECOMPUTE_MERKLE
9255 | OPTI_TYPE_EARLY_SKIP
9256 | OPTI_TYPE_NOT_ITERATED
9257 | OPTI_TYPE_PREPENDED_SALT
9258 | OPTI_TYPE_RAW_HASH;
9259 dgst_pos0 = 3;
9260 dgst_pos1 = 4;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 1;
9263 break;
9264
9265 case 8200: hash_type = HASH_TYPE_SHA256;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9269 kern_type = KERN_TYPE_CLOUDKEY;
9270 dgst_size = DGST_SIZE_4_8;
9271 parse_func = cloudkey_parse_hash;
9272 sort_by_digest = sort_by_digest_4_8;
9273 opti_type = OPTI_TYPE_ZERO_BYTE;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 8300: hash_type = HASH_TYPE_SHA1;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE
9284 | OPTS_TYPE_ST_HEX
9285 | OPTS_TYPE_ST_ADD80;
9286 kern_type = KERN_TYPE_NSEC3;
9287 dgst_size = DGST_SIZE_4_5;
9288 parse_func = nsec3_parse_hash;
9289 sort_by_digest = sort_by_digest_4_5;
9290 opti_type = OPTI_TYPE_ZERO_BYTE;
9291 dgst_pos0 = 3;
9292 dgst_pos1 = 4;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 1;
9295 break;
9296
9297 case 8400: hash_type = HASH_TYPE_SHA1;
9298 salt_type = SALT_TYPE_INTERN;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_BE
9301 | OPTS_TYPE_PT_ADD80
9302 | OPTS_TYPE_PT_ADDBITS15;
9303 kern_type = KERN_TYPE_WBB3;
9304 dgst_size = DGST_SIZE_4_5;
9305 parse_func = wbb3_parse_hash;
9306 sort_by_digest = sort_by_digest_4_5;
9307 opti_type = OPTI_TYPE_ZERO_BYTE
9308 | OPTI_TYPE_PRECOMPUTE_INIT
9309 | OPTI_TYPE_NOT_ITERATED;
9310 dgst_pos0 = 3;
9311 dgst_pos1 = 4;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 1;
9314 break;
9315
9316 case 8500: hash_type = HASH_TYPE_DESRACF;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_LE
9320 | OPTS_TYPE_ST_UPPER;
9321 kern_type = KERN_TYPE_RACF;
9322 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9323 parse_func = racf_parse_hash;
9324 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9325 opti_type = OPTI_TYPE_ZERO_BYTE
9326 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 8600: hash_type = HASH_TYPE_LOTUS5;
9334 salt_type = SALT_TYPE_NONE;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9337 kern_type = KERN_TYPE_LOTUS5;
9338 dgst_size = DGST_SIZE_4_4;
9339 parse_func = lotus5_parse_hash;
9340 sort_by_digest = sort_by_digest_4_4;
9341 opti_type = OPTI_TYPE_EARLY_SKIP
9342 | OPTI_TYPE_NOT_ITERATED
9343 | OPTI_TYPE_NOT_SALTED
9344 | OPTI_TYPE_RAW_HASH;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 8700: hash_type = HASH_TYPE_LOTUS6;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9355 kern_type = KERN_TYPE_LOTUS6;
9356 dgst_size = DGST_SIZE_4_4;
9357 parse_func = lotus6_parse_hash;
9358 sort_by_digest = sort_by_digest_4_4;
9359 opti_type = OPTI_TYPE_EARLY_SKIP
9360 | OPTI_TYPE_NOT_ITERATED
9361 | OPTI_TYPE_RAW_HASH;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9372 kern_type = KERN_TYPE_ANDROIDFDE;
9373 dgst_size = DGST_SIZE_4_4;
9374 parse_func = androidfde_parse_hash;
9375 sort_by_digest = sort_by_digest_4_4;
9376 opti_type = OPTI_TYPE_ZERO_BYTE;
9377 dgst_pos0 = 0;
9378 dgst_pos1 = 1;
9379 dgst_pos2 = 2;
9380 dgst_pos3 = 3;
9381 break;
9382
9383 case 8900: hash_type = HASH_TYPE_SCRYPT;
9384 salt_type = SALT_TYPE_EMBEDDED;
9385 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9386 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9387 kern_type = KERN_TYPE_SCRYPT;
9388 dgst_size = DGST_SIZE_4_8;
9389 parse_func = scrypt_parse_hash;
9390 sort_by_digest = sort_by_digest_4_8;
9391 opti_type = OPTI_TYPE_ZERO_BYTE;
9392 dgst_pos0 = 0;
9393 dgst_pos1 = 1;
9394 dgst_pos2 = 2;
9395 dgst_pos3 = 3;
9396 break;
9397
9398 case 9000: hash_type = HASH_TYPE_SHA1;
9399 salt_type = SALT_TYPE_EMBEDDED;
9400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9401 opts_type = OPTS_TYPE_PT_GENERATE_LE
9402 | OPTS_TYPE_ST_GENERATE_LE;
9403 kern_type = KERN_TYPE_PSAFE2;
9404 dgst_size = DGST_SIZE_4_5;
9405 parse_func = psafe2_parse_hash;
9406 sort_by_digest = sort_by_digest_4_5;
9407 opti_type = OPTI_TYPE_ZERO_BYTE;
9408 dgst_pos0 = 0;
9409 dgst_pos1 = 1;
9410 dgst_pos2 = 2;
9411 dgst_pos3 = 3;
9412 break;
9413
9414 case 9100: hash_type = HASH_TYPE_LOTUS8;
9415 salt_type = SALT_TYPE_EMBEDDED;
9416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9417 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9418 kern_type = KERN_TYPE_LOTUS8;
9419 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9420 parse_func = lotus8_parse_hash;
9421 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9422 opti_type = OPTI_TYPE_ZERO_BYTE;
9423 dgst_pos0 = 0;
9424 dgst_pos1 = 1;
9425 dgst_pos2 = 2;
9426 dgst_pos3 = 3;
9427 break;
9428
9429 case 9200: hash_type = HASH_TYPE_SHA256;
9430 salt_type = SALT_TYPE_EMBEDDED;
9431 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9432 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9433 kern_type = KERN_TYPE_PBKDF2_SHA256;
9434 dgst_size = DGST_SIZE_4_32;
9435 parse_func = cisco8_parse_hash;
9436 sort_by_digest = sort_by_digest_4_32;
9437 opti_type = OPTI_TYPE_ZERO_BYTE
9438 | OPTI_TYPE_SLOW_HASH_SIMD;
9439 dgst_pos0 = 0;
9440 dgst_pos1 = 1;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 3;
9443 break;
9444
9445 case 9300: hash_type = HASH_TYPE_SCRYPT;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9449 kern_type = KERN_TYPE_SCRYPT;
9450 dgst_size = DGST_SIZE_4_8;
9451 parse_func = cisco9_parse_hash;
9452 sort_by_digest = sort_by_digest_4_8;
9453 opti_type = OPTI_TYPE_ZERO_BYTE;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 1;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 3;
9458 break;
9459
9460 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9464 kern_type = KERN_TYPE_OFFICE2007;
9465 dgst_size = DGST_SIZE_4_4;
9466 parse_func = office2007_parse_hash;
9467 sort_by_digest = sort_by_digest_4_4;
9468 opti_type = OPTI_TYPE_ZERO_BYTE;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_OFFICE2010;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = office2010_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9494 kern_type = KERN_TYPE_OFFICE2013;
9495 dgst_size = DGST_SIZE_4_4;
9496 parse_func = office2013_parse_hash;
9497 sort_by_digest = sort_by_digest_4_4;
9498 opti_type = OPTI_TYPE_ZERO_BYTE;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE
9509 | OPTS_TYPE_PT_ADD80
9510 | OPTS_TYPE_PT_UNICODE;
9511 kern_type = KERN_TYPE_OLDOFFICE01;
9512 dgst_size = DGST_SIZE_4_4;
9513 parse_func = oldoffice01_parse_hash;
9514 sort_by_digest = sort_by_digest_4_4;
9515 opti_type = OPTI_TYPE_ZERO_BYTE
9516 | OPTI_TYPE_PRECOMPUTE_INIT
9517 | OPTI_TYPE_NOT_ITERATED;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE
9528 | OPTS_TYPE_PT_ADD80;
9529 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = oldoffice01cm1_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE
9534 | OPTI_TYPE_PRECOMPUTE_INIT
9535 | OPTI_TYPE_NOT_ITERATED;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE
9546 | OPTS_TYPE_PT_ADD80
9547 | OPTS_TYPE_PT_UNICODE
9548 | OPTS_TYPE_PT_NEVERCRACK;
9549 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = oldoffice01cm2_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE
9554 | OPTI_TYPE_PRECOMPUTE_INIT
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_BE
9566 | OPTS_TYPE_PT_ADD80
9567 | OPTS_TYPE_PT_UNICODE;
9568 kern_type = KERN_TYPE_OLDOFFICE34;
9569 dgst_size = DGST_SIZE_4_4;
9570 parse_func = oldoffice34_parse_hash;
9571 sort_by_digest = sort_by_digest_4_4;
9572 opti_type = OPTI_TYPE_ZERO_BYTE
9573 | OPTI_TYPE_PRECOMPUTE_INIT
9574 | OPTI_TYPE_NOT_ITERATED;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 1;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 3;
9579 break;
9580
9581 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9585 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9586 dgst_size = DGST_SIZE_4_4;
9587 parse_func = oldoffice34cm1_parse_hash;
9588 sort_by_digest = sort_by_digest_4_4;
9589 opti_type = OPTI_TYPE_ZERO_BYTE
9590 | OPTI_TYPE_PRECOMPUTE_INIT
9591 | OPTI_TYPE_NOT_ITERATED;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_BE
9602 | OPTS_TYPE_PT_ADD80
9603 | OPTS_TYPE_PT_UNICODE
9604 | OPTS_TYPE_PT_NEVERCRACK;
9605 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = oldoffice34cm2_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE
9610 | OPTI_TYPE_PRECOMPUTE_INIT
9611 | OPTI_TYPE_NOT_ITERATED;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 9900: hash_type = HASH_TYPE_MD5;
9619 salt_type = SALT_TYPE_NONE;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_RADMIN2;
9623 dgst_size = DGST_SIZE_4_4;
9624 parse_func = radmin2_parse_hash;
9625 sort_by_digest = sort_by_digest_4_4;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_PRECOMPUTE_INIT
9628 | OPTI_TYPE_EARLY_SKIP
9629 | OPTI_TYPE_NOT_ITERATED
9630 | OPTI_TYPE_NOT_SALTED;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 3;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 1;
9635 break;
9636
9637 case 10000: hash_type = HASH_TYPE_SHA256;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9641 kern_type = KERN_TYPE_PBKDF2_SHA256;
9642 dgst_size = DGST_SIZE_4_32;
9643 parse_func = djangopbkdf2_parse_hash;
9644 sort_by_digest = sort_by_digest_4_32;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_SLOW_HASH_SIMD;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 10100: hash_type = HASH_TYPE_SIPHASH;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9657 kern_type = KERN_TYPE_SIPHASH;
9658 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9659 parse_func = siphash_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_NOT_ITERATED
9663 | OPTI_TYPE_RAW_HASH;
9664 dgst_pos0 = 0;
9665 dgst_pos1 = 1;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 3;
9668 break;
9669
9670 case 10200: hash_type = HASH_TYPE_MD5;
9671 salt_type = SALT_TYPE_EMBEDDED;
9672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE
9674 | OPTS_TYPE_ST_ADD80
9675 | OPTS_TYPE_ST_ADDBITS14;
9676 kern_type = KERN_TYPE_HMACMD5_PW;
9677 dgst_size = DGST_SIZE_4_4;
9678 parse_func = crammd5_parse_hash;
9679 sort_by_digest = sort_by_digest_4_4;
9680 opti_type = OPTI_TYPE_ZERO_BYTE
9681 | OPTI_TYPE_NOT_ITERATED;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 3;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 1;
9686 break;
9687
9688 case 10300: hash_type = HASH_TYPE_SHA1;
9689 salt_type = SALT_TYPE_EMBEDDED;
9690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9692 kern_type = KERN_TYPE_SAPH_SHA1;
9693 dgst_size = DGST_SIZE_4_5;
9694 parse_func = saph_sha1_parse_hash;
9695 sort_by_digest = sort_by_digest_4_5;
9696 opti_type = OPTI_TYPE_ZERO_BYTE;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 10400: hash_type = HASH_TYPE_PDFU16;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9707 kern_type = KERN_TYPE_PDF11;
9708 dgst_size = DGST_SIZE_4_4;
9709 parse_func = pdf11_parse_hash;
9710 sort_by_digest = sort_by_digest_4_4;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_NOT_ITERATED;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 10410: hash_type = HASH_TYPE_PDFU16;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_PDF11CM1;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = pdf11cm1_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 1;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 3;
9733 break;
9734
9735 case 10420: hash_type = HASH_TYPE_PDFU16;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9739 kern_type = KERN_TYPE_PDF11CM2;
9740 dgst_size = DGST_SIZE_4_4;
9741 parse_func = pdf11cm2_parse_hash;
9742 sort_by_digest = sort_by_digest_4_4;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 10500: hash_type = HASH_TYPE_PDFU16;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9755 kern_type = KERN_TYPE_PDF14;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = pdf14_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_NOT_ITERATED;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 10600: hash_type = HASH_TYPE_SHA256;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_BE
9771 | OPTS_TYPE_ST_ADD80
9772 | OPTS_TYPE_ST_ADDBITS15
9773 | OPTS_TYPE_HASH_COPY;
9774 kern_type = KERN_TYPE_SHA256_PWSLT;
9775 dgst_size = DGST_SIZE_4_8;
9776 parse_func = pdf17l3_parse_hash;
9777 sort_by_digest = sort_by_digest_4_8;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_PRECOMPUTE_INIT
9780 | OPTI_TYPE_PRECOMPUTE_MERKLE
9781 | OPTI_TYPE_EARLY_SKIP
9782 | OPTI_TYPE_NOT_ITERATED
9783 | OPTI_TYPE_APPENDED_SALT
9784 | OPTI_TYPE_RAW_HASH;
9785 dgst_pos0 = 3;
9786 dgst_pos1 = 7;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 6;
9789 break;
9790
9791 case 10700: hash_type = HASH_TYPE_PDFU32;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE
9795 | OPTS_TYPE_HASH_COPY;
9796 kern_type = KERN_TYPE_PDF17L8;
9797 dgst_size = DGST_SIZE_4_8;
9798 parse_func = pdf17l8_parse_hash;
9799 sort_by_digest = sort_by_digest_4_8;
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_NOT_ITERATED;
9802 dgst_pos0 = 0;
9803 dgst_pos1 = 1;
9804 dgst_pos2 = 2;
9805 dgst_pos3 = 3;
9806 break;
9807
9808 case 10800: hash_type = HASH_TYPE_SHA384;
9809 salt_type = SALT_TYPE_NONE;
9810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9811 opts_type = OPTS_TYPE_PT_GENERATE_BE
9812 | OPTS_TYPE_PT_ADD80
9813 | OPTS_TYPE_PT_ADDBITS15;
9814 kern_type = KERN_TYPE_SHA384;
9815 dgst_size = DGST_SIZE_8_8;
9816 parse_func = sha384_parse_hash;
9817 sort_by_digest = sort_by_digest_8_8;
9818 opti_type = OPTI_TYPE_ZERO_BYTE
9819 | OPTI_TYPE_PRECOMPUTE_INIT
9820 | OPTI_TYPE_PRECOMPUTE_MERKLE
9821 | OPTI_TYPE_EARLY_SKIP
9822 | OPTI_TYPE_NOT_ITERATED
9823 | OPTI_TYPE_NOT_SALTED
9824 | OPTI_TYPE_USES_BITS_64
9825 | OPTI_TYPE_RAW_HASH;
9826 dgst_pos0 = 6;
9827 dgst_pos1 = 7;
9828 dgst_pos2 = 4;
9829 dgst_pos3 = 5;
9830 break;
9831
9832 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9833 salt_type = SALT_TYPE_EMBEDDED;
9834 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9835 opts_type = OPTS_TYPE_PT_GENERATE_LE
9836 | OPTS_TYPE_ST_BASE64
9837 | OPTS_TYPE_HASH_COPY;
9838 kern_type = KERN_TYPE_PBKDF2_SHA256;
9839 dgst_size = DGST_SIZE_4_32;
9840 parse_func = pbkdf2_sha256_parse_hash;
9841 sort_by_digest = sort_by_digest_4_32;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_SLOW_HASH_SIMD;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 11000: hash_type = HASH_TYPE_MD5;
9851 salt_type = SALT_TYPE_INTERN;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE
9854 | OPTS_TYPE_PT_ADD80;
9855 kern_type = KERN_TYPE_PRESTASHOP;
9856 dgst_size = DGST_SIZE_4_4;
9857 parse_func = prestashop_parse_hash;
9858 sort_by_digest = sort_by_digest_4_4;
9859 opti_type = OPTI_TYPE_ZERO_BYTE
9860 | OPTI_TYPE_PRECOMPUTE_INIT
9861 | OPTI_TYPE_NOT_ITERATED
9862 | OPTI_TYPE_PREPENDED_SALT;
9863 dgst_pos0 = 0;
9864 dgst_pos1 = 3;
9865 dgst_pos2 = 2;
9866 dgst_pos3 = 1;
9867 break;
9868
9869 case 11100: hash_type = HASH_TYPE_MD5;
9870 salt_type = SALT_TYPE_EMBEDDED;
9871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9872 opts_type = OPTS_TYPE_PT_GENERATE_LE
9873 | OPTS_TYPE_ST_ADD80;
9874 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9875 dgst_size = DGST_SIZE_4_4;
9876 parse_func = postgresql_auth_parse_hash;
9877 sort_by_digest = sort_by_digest_4_4;
9878 opti_type = OPTI_TYPE_ZERO_BYTE
9879 | OPTI_TYPE_PRECOMPUTE_INIT
9880 | OPTI_TYPE_PRECOMPUTE_MERKLE
9881 | OPTI_TYPE_EARLY_SKIP;
9882 dgst_pos0 = 0;
9883 dgst_pos1 = 3;
9884 dgst_pos2 = 2;
9885 dgst_pos3 = 1;
9886 break;
9887
9888 case 11200: hash_type = HASH_TYPE_SHA1;
9889 salt_type = SALT_TYPE_EMBEDDED;
9890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9891 opts_type = OPTS_TYPE_PT_GENERATE_BE
9892 | OPTS_TYPE_PT_ADD80
9893 | OPTS_TYPE_ST_HEX;
9894 kern_type = KERN_TYPE_MYSQL_AUTH;
9895 dgst_size = DGST_SIZE_4_5;
9896 parse_func = mysql_auth_parse_hash;
9897 sort_by_digest = sort_by_digest_4_5;
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_EARLY_SKIP;
9900 dgst_pos0 = 3;
9901 dgst_pos1 = 4;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 1;
9904 break;
9905
9906 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_LE
9910 | OPTS_TYPE_ST_HEX
9911 | OPTS_TYPE_ST_ADD80;
9912 kern_type = KERN_TYPE_BITCOIN_WALLET;
9913 dgst_size = DGST_SIZE_4_4;
9914 parse_func = bitcoin_wallet_parse_hash;
9915 sort_by_digest = sort_by_digest_4_4;
9916 opti_type = OPTI_TYPE_ZERO_BYTE;
9917 dgst_pos0 = 0;
9918 dgst_pos1 = 1;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 3;
9921 break;
9922
9923 case 11400: hash_type = HASH_TYPE_MD5;
9924 salt_type = SALT_TYPE_EMBEDDED;
9925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE
9927 | OPTS_TYPE_PT_ADD80
9928 | OPTS_TYPE_HASH_COPY;
9929 kern_type = KERN_TYPE_SIP_AUTH;
9930 dgst_size = DGST_SIZE_4_4;
9931 parse_func = sip_auth_parse_hash;
9932 sort_by_digest = sort_by_digest_4_4;
9933 opti_type = OPTI_TYPE_ZERO_BYTE;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 3;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 1;
9938 break;
9939
9940 case 11500: hash_type = HASH_TYPE_CRC32;
9941 salt_type = SALT_TYPE_INTERN;
9942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE
9944 | OPTS_TYPE_ST_GENERATE_LE
9945 | OPTS_TYPE_ST_HEX;
9946 kern_type = KERN_TYPE_CRC32;
9947 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9948 parse_func = crc32_parse_hash;
9949 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9950 opti_type = OPTI_TYPE_ZERO_BYTE;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 1;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 3;
9955 break;
9956
9957 case 11600: hash_type = HASH_TYPE_AES;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE
9961 | OPTS_TYPE_PT_NEVERCRACK;
9962 kern_type = KERN_TYPE_SEVEN_ZIP;
9963 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9964 parse_func = seven_zip_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9974 salt_type = SALT_TYPE_NONE;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_PT_ADD01;
9978 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9979 dgst_size = DGST_SIZE_4_8;
9980 parse_func = gost2012sbog_256_parse_hash;
9981 sort_by_digest = sort_by_digest_4_8;
9982 opti_type = OPTI_TYPE_ZERO_BYTE;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9990 salt_type = SALT_TYPE_NONE;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_LE
9993 | OPTS_TYPE_PT_ADD01;
9994 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9995 dgst_size = DGST_SIZE_4_16;
9996 parse_func = gost2012sbog_512_parse_hash;
9997 sort_by_digest = sort_by_digest_4_16;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_ST_BASE64
10010 | OPTS_TYPE_HASH_COPY;
10011 kern_type = KERN_TYPE_PBKDF2_MD5;
10012 dgst_size = DGST_SIZE_4_32;
10013 parse_func = pbkdf2_md5_parse_hash;
10014 sort_by_digest = sort_by_digest_4_32;
10015 opti_type = OPTI_TYPE_ZERO_BYTE
10016 | OPTI_TYPE_SLOW_HASH_SIMD;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10024 salt_type = SALT_TYPE_EMBEDDED;
10025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE
10027 | OPTS_TYPE_ST_BASE64
10028 | OPTS_TYPE_HASH_COPY;
10029 kern_type = KERN_TYPE_PBKDF2_SHA1;
10030 dgst_size = DGST_SIZE_4_32;
10031 parse_func = pbkdf2_sha1_parse_hash;
10032 sort_by_digest = sort_by_digest_4_32;
10033 opti_type = OPTI_TYPE_ZERO_BYTE
10034 | OPTI_TYPE_SLOW_HASH_SIMD;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE
10045 | OPTS_TYPE_ST_BASE64
10046 | OPTS_TYPE_HASH_COPY;
10047 kern_type = KERN_TYPE_PBKDF2_SHA512;
10048 dgst_size = DGST_SIZE_8_16;
10049 parse_func = pbkdf2_sha512_parse_hash;
10050 sort_by_digest = sort_by_digest_8_16;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_USES_BITS_64
10053 | OPTI_TYPE_SLOW_HASH_SIMD;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 1;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 3;
10058 break;
10059
10060 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10064 kern_type = KERN_TYPE_ECRYPTFS;
10065 dgst_size = DGST_SIZE_8_8;
10066 parse_func = ecryptfs_parse_hash;
10067 sort_by_digest = sort_by_digest_8_8;
10068 opti_type = OPTI_TYPE_ZERO_BYTE
10069 | OPTI_TYPE_USES_BITS_64;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 12300: hash_type = HASH_TYPE_ORACLET;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10080 kern_type = KERN_TYPE_ORACLET;
10081 dgst_size = DGST_SIZE_8_16;
10082 parse_func = oraclet_parse_hash;
10083 sort_by_digest = sort_by_digest_8_16;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_USES_BITS_64;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10096 kern_type = KERN_TYPE_BSDICRYPT;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = bsdicrypt_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE
10101 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 1;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 3;
10106 break;
10107
10108 case 12500: hash_type = HASH_TYPE_RAR3HP;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10112 kern_type = KERN_TYPE_RAR3;
10113 dgst_size = DGST_SIZE_4_4;
10114 parse_func = rar3hp_parse_hash;
10115 sort_by_digest = sort_by_digest_4_4;
10116 opti_type = OPTI_TYPE_ZERO_BYTE;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 12600: hash_type = HASH_TYPE_SHA256;
10124 salt_type = SALT_TYPE_INTERN;
10125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_BE
10127 | OPTS_TYPE_PT_ADD80;
10128 kern_type = KERN_TYPE_CF10;
10129 dgst_size = DGST_SIZE_4_8;
10130 parse_func = cf10_parse_hash;
10131 sort_by_digest = sort_by_digest_4_8;
10132 opti_type = OPTI_TYPE_ZERO_BYTE
10133 | OPTI_TYPE_PRECOMPUTE_INIT
10134 | OPTI_TYPE_EARLY_SKIP
10135 | OPTI_TYPE_NOT_ITERATED;
10136 dgst_pos0 = 3;
10137 dgst_pos1 = 7;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 6;
10140 break;
10141
10142 case 12700: hash_type = HASH_TYPE_AES;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_HASH_COPY;
10147 kern_type = KERN_TYPE_MYWALLET;
10148 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10149 parse_func = mywallet_parse_hash;
10150 sort_by_digest = sort_by_digest_4_5;
10151 opti_type = OPTI_TYPE_ZERO_BYTE;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10162 kern_type = KERN_TYPE_MS_DRSR;
10163 dgst_size = DGST_SIZE_4_8;
10164 parse_func = ms_drsr_parse_hash;
10165 sort_by_digest = sort_by_digest_4_8;
10166 opti_type = OPTI_TYPE_ZERO_BYTE;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 1;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 3;
10171 break;
10172
10173 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10174 salt_type = SALT_TYPE_EMBEDDED;
10175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10177 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10178 dgst_size = DGST_SIZE_4_8;
10179 parse_func = androidfde_samsung_parse_hash;
10180 sort_by_digest = sort_by_digest_4_8;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_RAR5;
10193 dgst_size = DGST_SIZE_4_4;
10194 parse_func = rar5_parse_hash;
10195 sort_by_digest = sort_by_digest_4_4;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_KRB5TGS;
10208 dgst_size = DGST_SIZE_4_4;
10209 parse_func = krb5tgs_parse_hash;
10210 sort_by_digest = sort_by_digest_4_4;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_NOT_ITERATED;
10213 dgst_pos0 = 0;
10214 dgst_pos1 = 1;
10215 dgst_pos2 = 2;
10216 dgst_pos3 = 3;
10217 break;
10218
10219 case 13200: hash_type = HASH_TYPE_AES;
10220 salt_type = SALT_TYPE_EMBEDDED;
10221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10222 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10223 kern_type = KERN_TYPE_AXCRYPT;
10224 dgst_size = DGST_SIZE_4_4;
10225 parse_func = axcrypt_parse_hash;
10226 sort_by_digest = sort_by_digest_4_4;
10227 opti_type = OPTI_TYPE_ZERO_BYTE;
10228 dgst_pos0 = 0;
10229 dgst_pos1 = 1;
10230 dgst_pos2 = 2;
10231 dgst_pos3 = 3;
10232 break;
10233
10234 case 13300: hash_type = HASH_TYPE_SHA1;
10235 salt_type = SALT_TYPE_NONE;
10236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10237 opts_type = OPTS_TYPE_PT_GENERATE_BE
10238 | OPTS_TYPE_PT_ADD80
10239 | OPTS_TYPE_PT_ADDBITS15;
10240 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10241 dgst_size = DGST_SIZE_4_5;
10242 parse_func = sha1axcrypt_parse_hash;
10243 sort_by_digest = sort_by_digest_4_5;
10244 opti_type = OPTI_TYPE_ZERO_BYTE
10245 | OPTI_TYPE_PRECOMPUTE_INIT
10246 | OPTI_TYPE_EARLY_SKIP
10247 | OPTI_TYPE_NOT_ITERATED
10248 | OPTI_TYPE_NOT_SALTED;
10249 dgst_pos0 = 0;
10250 dgst_pos1 = 4;
10251 dgst_pos2 = 3;
10252 dgst_pos3 = 2;
10253 break;
10254
10255 case 13400: hash_type = HASH_TYPE_AES;
10256 salt_type = SALT_TYPE_EMBEDDED;
10257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10259 kern_type = KERN_TYPE_KEEPASS;
10260 dgst_size = DGST_SIZE_4_4;
10261 parse_func = keepass_parse_hash;
10262 sort_by_digest = sort_by_digest_4_4;
10263 opti_type = OPTI_TYPE_ZERO_BYTE;
10264 dgst_pos0 = 0;
10265 dgst_pos1 = 1;
10266 dgst_pos2 = 2;
10267 dgst_pos3 = 3;
10268 break;
10269
10270 case 13500: hash_type = HASH_TYPE_SHA1;
10271 salt_type = SALT_TYPE_EMBEDDED;
10272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10273 opts_type = OPTS_TYPE_PT_GENERATE_BE
10274 | OPTS_TYPE_PT_UNICODE
10275 | OPTS_TYPE_PT_ADD80;
10276 kern_type = KERN_TYPE_PSTOKEN;
10277 dgst_size = DGST_SIZE_4_5;
10278 parse_func = pstoken_parse_hash;
10279 sort_by_digest = sort_by_digest_4_5;
10280 opti_type = OPTI_TYPE_ZERO_BYTE
10281 | OPTI_TYPE_PRECOMPUTE_INIT
10282 | OPTI_TYPE_EARLY_SKIP
10283 | OPTI_TYPE_NOT_ITERATED
10284 | OPTI_TYPE_PREPENDED_SALT
10285 | OPTI_TYPE_RAW_HASH;
10286 dgst_pos0 = 3;
10287 dgst_pos1 = 4;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 1;
10290 break;
10291
10292 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10293 salt_type = SALT_TYPE_EMBEDDED;
10294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10296 kern_type = KERN_TYPE_ZIP2;
10297 dgst_size = DGST_SIZE_4_4;
10298 parse_func = zip2_parse_hash;
10299 sort_by_digest = sort_by_digest_4_4;
10300 opti_type = OPTI_TYPE_ZERO_BYTE;
10301 dgst_pos0 = 0;
10302 dgst_pos1 = 1;
10303 dgst_pos2 = 2;
10304 dgst_pos3 = 3;
10305 break;
10306
10307 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10308 salt_type = SALT_TYPE_EMBEDDED;
10309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10310 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10311 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10312 dgst_size = DGST_SIZE_4_5;
10313 parse_func = veracrypt_parse_hash_655331;
10314 sort_by_digest = sort_by_digest_4_5;
10315 opti_type = OPTI_TYPE_ZERO_BYTE;
10316 dgst_pos0 = 0;
10317 dgst_pos1 = 1;
10318 dgst_pos2 = 2;
10319 dgst_pos3 = 3;
10320 break;
10321
10322 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10323 salt_type = SALT_TYPE_EMBEDDED;
10324 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10325 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10326 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10327 dgst_size = DGST_SIZE_4_5;
10328 parse_func = veracrypt_parse_hash_655331;
10329 sort_by_digest = sort_by_digest_4_5;
10330 opti_type = OPTI_TYPE_ZERO_BYTE;
10331 dgst_pos0 = 0;
10332 dgst_pos1 = 1;
10333 dgst_pos2 = 2;
10334 dgst_pos3 = 3;
10335 break;
10336
10337 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10338 salt_type = SALT_TYPE_EMBEDDED;
10339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10340 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10341 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10342 dgst_size = DGST_SIZE_4_5;
10343 parse_func = veracrypt_parse_hash_655331;
10344 sort_by_digest = sort_by_digest_4_5;
10345 opti_type = OPTI_TYPE_ZERO_BYTE;
10346 dgst_pos0 = 0;
10347 dgst_pos1 = 1;
10348 dgst_pos2 = 2;
10349 dgst_pos3 = 3;
10350 break;
10351
10352 case 13721: hash_type = HASH_TYPE_SHA512;
10353 salt_type = SALT_TYPE_EMBEDDED;
10354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10355 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10356 kern_type = KERN_TYPE_TCSHA512_XTS512;
10357 dgst_size = DGST_SIZE_8_8;
10358 parse_func = veracrypt_parse_hash_500000;
10359 sort_by_digest = sort_by_digest_8_8;
10360 opti_type = OPTI_TYPE_ZERO_BYTE
10361 | OPTI_TYPE_USES_BITS_64;
10362 dgst_pos0 = 0;
10363 dgst_pos1 = 1;
10364 dgst_pos2 = 2;
10365 dgst_pos3 = 3;
10366 break;
10367
10368 case 13722: hash_type = HASH_TYPE_SHA512;
10369 salt_type = SALT_TYPE_EMBEDDED;
10370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10371 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10372 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10373 dgst_size = DGST_SIZE_8_8;
10374 parse_func = veracrypt_parse_hash_500000;
10375 sort_by_digest = sort_by_digest_8_8;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_USES_BITS_64;
10378 dgst_pos0 = 0;
10379 dgst_pos1 = 1;
10380 dgst_pos2 = 2;
10381 dgst_pos3 = 3;
10382 break;
10383
10384 case 13723: hash_type = HASH_TYPE_SHA512;
10385 salt_type = SALT_TYPE_EMBEDDED;
10386 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10387 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10388 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10389 dgst_size = DGST_SIZE_8_8;
10390 parse_func = veracrypt_parse_hash_500000;
10391 sort_by_digest = sort_by_digest_8_8;
10392 opti_type = OPTI_TYPE_ZERO_BYTE
10393 | OPTI_TYPE_USES_BITS_64;
10394 dgst_pos0 = 0;
10395 dgst_pos1 = 1;
10396 dgst_pos2 = 2;
10397 dgst_pos3 = 3;
10398 break;
10399
10400 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10401 salt_type = SALT_TYPE_EMBEDDED;
10402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10404 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10405 dgst_size = DGST_SIZE_4_8;
10406 parse_func = veracrypt_parse_hash_500000;
10407 sort_by_digest = sort_by_digest_4_8;
10408 opti_type = OPTI_TYPE_ZERO_BYTE;
10409 dgst_pos0 = 0;
10410 dgst_pos1 = 1;
10411 dgst_pos2 = 2;
10412 dgst_pos3 = 3;
10413 break;
10414
10415 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10416 salt_type = SALT_TYPE_EMBEDDED;
10417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10419 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10420 dgst_size = DGST_SIZE_4_8;
10421 parse_func = veracrypt_parse_hash_500000;
10422 sort_by_digest = sort_by_digest_4_8;
10423 opti_type = OPTI_TYPE_ZERO_BYTE;
10424 dgst_pos0 = 0;
10425 dgst_pos1 = 1;
10426 dgst_pos2 = 2;
10427 dgst_pos3 = 3;
10428 break;
10429
10430 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10431 salt_type = SALT_TYPE_EMBEDDED;
10432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10433 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10434 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10435 dgst_size = DGST_SIZE_4_8;
10436 parse_func = veracrypt_parse_hash_500000;
10437 sort_by_digest = sort_by_digest_4_8;
10438 opti_type = OPTI_TYPE_ZERO_BYTE;
10439 dgst_pos0 = 0;
10440 dgst_pos1 = 1;
10441 dgst_pos2 = 2;
10442 dgst_pos3 = 3;
10443 break;
10444
10445 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10446 salt_type = SALT_TYPE_EMBEDDED;
10447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10448 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10449 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10450 dgst_size = DGST_SIZE_4_5;
10451 parse_func = veracrypt_parse_hash_327661;
10452 sort_by_digest = sort_by_digest_4_5;
10453 opti_type = OPTI_TYPE_ZERO_BYTE;
10454 dgst_pos0 = 0;
10455 dgst_pos1 = 1;
10456 dgst_pos2 = 2;
10457 dgst_pos3 = 3;
10458 break;
10459
10460 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10461 salt_type = SALT_TYPE_EMBEDDED;
10462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10463 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10464 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10465 dgst_size = DGST_SIZE_4_5;
10466 parse_func = veracrypt_parse_hash_327661;
10467 sort_by_digest = sort_by_digest_4_5;
10468 opti_type = OPTI_TYPE_ZERO_BYTE;
10469 dgst_pos0 = 0;
10470 dgst_pos1 = 1;
10471 dgst_pos2 = 2;
10472 dgst_pos3 = 3;
10473 break;
10474
10475 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10476 salt_type = SALT_TYPE_EMBEDDED;
10477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10479 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10480 dgst_size = DGST_SIZE_4_5;
10481 parse_func = veracrypt_parse_hash_327661;
10482 sort_by_digest = sort_by_digest_4_5;
10483 opti_type = OPTI_TYPE_ZERO_BYTE;
10484 dgst_pos0 = 0;
10485 dgst_pos1 = 1;
10486 dgst_pos2 = 2;
10487 dgst_pos3 = 3;
10488 break;
10489
10490 case 13751: hash_type = HASH_TYPE_SHA256;
10491 salt_type = SALT_TYPE_EMBEDDED;
10492 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10493 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10494 kern_type = KERN_TYPE_VCSHA256_XTS512;
10495 dgst_size = DGST_SIZE_4_8;
10496 parse_func = veracrypt_parse_hash_500000;
10497 sort_by_digest = sort_by_digest_4_8;
10498 opti_type = OPTI_TYPE_ZERO_BYTE;
10499 dgst_pos0 = 0;
10500 dgst_pos1 = 1;
10501 dgst_pos2 = 2;
10502 dgst_pos3 = 3;
10503 break;
10504
10505 case 13752: hash_type = HASH_TYPE_SHA256;
10506 salt_type = SALT_TYPE_EMBEDDED;
10507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10508 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10509 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10510 dgst_size = DGST_SIZE_4_8;
10511 parse_func = veracrypt_parse_hash_500000;
10512 sort_by_digest = sort_by_digest_4_8;
10513 opti_type = OPTI_TYPE_ZERO_BYTE;
10514 dgst_pos0 = 0;
10515 dgst_pos1 = 1;
10516 dgst_pos2 = 2;
10517 dgst_pos3 = 3;
10518 break;
10519
10520 case 13753: hash_type = HASH_TYPE_SHA256;
10521 salt_type = SALT_TYPE_EMBEDDED;
10522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10523 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10524 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10525 dgst_size = DGST_SIZE_4_8;
10526 parse_func = veracrypt_parse_hash_500000;
10527 sort_by_digest = sort_by_digest_4_8;
10528 opti_type = OPTI_TYPE_ZERO_BYTE;
10529 dgst_pos0 = 0;
10530 dgst_pos1 = 1;
10531 dgst_pos2 = 2;
10532 dgst_pos3 = 3;
10533 break;
10534
10535 case 13761: hash_type = HASH_TYPE_SHA256;
10536 salt_type = SALT_TYPE_EMBEDDED;
10537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10538 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10539 kern_type = KERN_TYPE_VCSHA256_XTS512;
10540 dgst_size = DGST_SIZE_4_8;
10541 parse_func = veracrypt_parse_hash_200000;
10542 sort_by_digest = sort_by_digest_4_8;
10543 opti_type = OPTI_TYPE_ZERO_BYTE;
10544 dgst_pos0 = 0;
10545 dgst_pos1 = 1;
10546 dgst_pos2 = 2;
10547 dgst_pos3 = 3;
10548 break;
10549
10550 case 13762: hash_type = HASH_TYPE_SHA256;
10551 salt_type = SALT_TYPE_EMBEDDED;
10552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10553 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10554 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10555 dgst_size = DGST_SIZE_4_8;
10556 parse_func = veracrypt_parse_hash_200000;
10557 sort_by_digest = sort_by_digest_4_8;
10558 opti_type = OPTI_TYPE_ZERO_BYTE;
10559 dgst_pos0 = 0;
10560 dgst_pos1 = 1;
10561 dgst_pos2 = 2;
10562 dgst_pos3 = 3;
10563 break;
10564
10565 case 13763: hash_type = HASH_TYPE_SHA256;
10566 salt_type = SALT_TYPE_EMBEDDED;
10567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10568 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10569 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10570 dgst_size = DGST_SIZE_4_8;
10571 parse_func = veracrypt_parse_hash_200000;
10572 sort_by_digest = sort_by_digest_4_8;
10573 opti_type = OPTI_TYPE_ZERO_BYTE;
10574 dgst_pos0 = 0;
10575 dgst_pos1 = 1;
10576 dgst_pos2 = 2;
10577 dgst_pos3 = 3;
10578 break;
10579
10580
10581 default: usage_mini_print (PROGNAME); return (-1);
10582 }
10583
10584 /**
10585 * parser
10586 */
10587
10588 data.parse_func = parse_func;
10589
10590 /**
10591 * misc stuff
10592 */
10593
10594 if (hex_salt)
10595 {
10596 if (salt_type == SALT_TYPE_INTERN)
10597 {
10598 opts_type |= OPTS_TYPE_ST_HEX;
10599 }
10600 else
10601 {
10602 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10603
10604 return (-1);
10605 }
10606 }
10607
10608 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10609 | (salt_type == SALT_TYPE_EXTERN)
10610 | (salt_type == SALT_TYPE_EMBEDDED)
10611 | (salt_type == SALT_TYPE_VIRTUAL));
10612
10613 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10614
10615 data.hash_type = hash_type;
10616 data.attack_mode = attack_mode;
10617 data.attack_kern = attack_kern;
10618 data.attack_exec = attack_exec;
10619 data.kern_type = kern_type;
10620 data.opts_type = opts_type;
10621 data.dgst_size = dgst_size;
10622 data.salt_type = salt_type;
10623 data.isSalted = isSalted;
10624 data.sort_by_digest = sort_by_digest;
10625 data.dgst_pos0 = dgst_pos0;
10626 data.dgst_pos1 = dgst_pos1;
10627 data.dgst_pos2 = dgst_pos2;
10628 data.dgst_pos3 = dgst_pos3;
10629
10630 esalt_size = 0;
10631
10632 switch (hash_mode)
10633 {
10634 case 2500: esalt_size = sizeof (wpa_t); break;
10635 case 5300: esalt_size = sizeof (ikepsk_t); break;
10636 case 5400: esalt_size = sizeof (ikepsk_t); break;
10637 case 5500: esalt_size = sizeof (netntlm_t); break;
10638 case 5600: esalt_size = sizeof (netntlm_t); break;
10639 case 6211: esalt_size = sizeof (tc_t); break;
10640 case 6212: esalt_size = sizeof (tc_t); break;
10641 case 6213: esalt_size = sizeof (tc_t); break;
10642 case 6221: esalt_size = sizeof (tc_t); break;
10643 case 6222: esalt_size = sizeof (tc_t); break;
10644 case 6223: esalt_size = sizeof (tc_t); break;
10645 case 6231: esalt_size = sizeof (tc_t); break;
10646 case 6232: esalt_size = sizeof (tc_t); break;
10647 case 6233: esalt_size = sizeof (tc_t); break;
10648 case 6241: esalt_size = sizeof (tc_t); break;
10649 case 6242: esalt_size = sizeof (tc_t); break;
10650 case 6243: esalt_size = sizeof (tc_t); break;
10651 case 6600: esalt_size = sizeof (agilekey_t); break;
10652 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10653 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10654 case 7300: esalt_size = sizeof (rakp_t); break;
10655 case 7500: esalt_size = sizeof (krb5pa_t); break;
10656 case 8200: esalt_size = sizeof (cloudkey_t); break;
10657 case 8800: esalt_size = sizeof (androidfde_t); break;
10658 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10659 case 9400: esalt_size = sizeof (office2007_t); break;
10660 case 9500: esalt_size = sizeof (office2010_t); break;
10661 case 9600: esalt_size = sizeof (office2013_t); break;
10662 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10663 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10664 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10665 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10666 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10667 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10668 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10669 case 10200: esalt_size = sizeof (cram_md5_t); break;
10670 case 10400: esalt_size = sizeof (pdf_t); break;
10671 case 10410: esalt_size = sizeof (pdf_t); break;
10672 case 10420: esalt_size = sizeof (pdf_t); break;
10673 case 10500: esalt_size = sizeof (pdf_t); break;
10674 case 10600: esalt_size = sizeof (pdf_t); break;
10675 case 10700: esalt_size = sizeof (pdf_t); break;
10676 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10677 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10678 case 11400: esalt_size = sizeof (sip_t); break;
10679 case 11600: esalt_size = sizeof (seven_zip_t); break;
10680 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10681 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10682 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10683 case 13000: esalt_size = sizeof (rar5_t); break;
10684 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10685 case 13400: esalt_size = sizeof (keepass_t); break;
10686 case 13500: esalt_size = sizeof (pstoken_t); break;
10687 case 13600: esalt_size = sizeof (zip2_t); break;
10688 case 13711: esalt_size = sizeof (tc_t); break;
10689 case 13712: esalt_size = sizeof (tc_t); break;
10690 case 13713: esalt_size = sizeof (tc_t); break;
10691 case 13721: esalt_size = sizeof (tc_t); break;
10692 case 13722: esalt_size = sizeof (tc_t); break;
10693 case 13723: esalt_size = sizeof (tc_t); break;
10694 case 13731: esalt_size = sizeof (tc_t); break;
10695 case 13732: esalt_size = sizeof (tc_t); break;
10696 case 13733: esalt_size = sizeof (tc_t); break;
10697 case 13741: esalt_size = sizeof (tc_t); break;
10698 case 13742: esalt_size = sizeof (tc_t); break;
10699 case 13743: esalt_size = sizeof (tc_t); break;
10700 case 13751: esalt_size = sizeof (tc_t); break;
10701 case 13752: esalt_size = sizeof (tc_t); break;
10702 case 13753: esalt_size = sizeof (tc_t); break;
10703 case 13761: esalt_size = sizeof (tc_t); break;
10704 case 13762: esalt_size = sizeof (tc_t); break;
10705 case 13763: esalt_size = sizeof (tc_t); break;
10706 }
10707
10708 data.esalt_size = esalt_size;
10709
10710 /**
10711 * choose dictionary parser
10712 */
10713
10714 if (hash_type == HASH_TYPE_LM)
10715 {
10716 get_next_word_func = get_next_word_lm;
10717 }
10718 else if (opts_type & OPTS_TYPE_PT_UPPER)
10719 {
10720 get_next_word_func = get_next_word_uc;
10721 }
10722 else
10723 {
10724 get_next_word_func = get_next_word_std;
10725 }
10726
10727 /**
10728 * dictstat
10729 */
10730
10731 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10732
10733 #ifdef _POSIX
10734 size_t dictstat_nmemb = 0;
10735 #endif
10736
10737 #ifdef _WIN
10738 uint dictstat_nmemb = 0;
10739 #endif
10740
10741 char dictstat[256] = { 0 };
10742
10743 FILE *dictstat_fp = NULL;
10744
10745 if (keyspace == 0)
10746 {
10747 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10748
10749 dictstat_fp = fopen (dictstat, "rb");
10750
10751 if (dictstat_fp)
10752 {
10753 #ifdef _POSIX
10754 struct stat tmpstat;
10755
10756 fstat (fileno (dictstat_fp), &tmpstat);
10757 #endif
10758
10759 #ifdef _WIN
10760 struct stat64 tmpstat;
10761
10762 _fstat64 (fileno (dictstat_fp), &tmpstat);
10763 #endif
10764
10765 if (tmpstat.st_mtime < COMPTIME)
10766 {
10767 /* with v0.15 the format changed so we have to ensure user is using a good version
10768 since there is no version-header in the dictstat file */
10769
10770 fclose (dictstat_fp);
10771
10772 unlink (dictstat);
10773 }
10774 else
10775 {
10776 while (!feof (dictstat_fp))
10777 {
10778 dictstat_t d;
10779
10780 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10781
10782 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10783
10784 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10785 {
10786 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10787
10788 return -1;
10789 }
10790 }
10791
10792 fclose (dictstat_fp);
10793 }
10794 }
10795 }
10796
10797 /**
10798 * potfile
10799 */
10800
10801 char potfile[256] = { 0 };
10802
10803 if (potfile_path == NULL)
10804 {
10805 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10806 }
10807 else
10808 {
10809 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10810 }
10811
10812 data.pot_fp = NULL;
10813
10814 FILE *out_fp = NULL;
10815 FILE *pot_fp = NULL;
10816
10817 if (show == 1 || left == 1)
10818 {
10819 pot_fp = fopen (potfile, "rb");
10820
10821 if (pot_fp == NULL)
10822 {
10823 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10824
10825 return (-1);
10826 }
10827
10828 if (outfile != NULL)
10829 {
10830 if ((out_fp = fopen (outfile, "ab")) == NULL)
10831 {
10832 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10833
10834 fclose (pot_fp);
10835
10836 return (-1);
10837 }
10838 }
10839 else
10840 {
10841 out_fp = stdout;
10842 }
10843 }
10844 else
10845 {
10846 if (potfile_disable == 0)
10847 {
10848 pot_fp = fopen (potfile, "ab");
10849
10850 if (pot_fp == NULL)
10851 {
10852 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10853
10854 return (-1);
10855 }
10856
10857 data.pot_fp = pot_fp;
10858 }
10859 }
10860
10861 pot_t *pot = NULL;
10862
10863 uint pot_cnt = 0;
10864 uint pot_avail = 0;
10865
10866 if (show == 1 || left == 1)
10867 {
10868 SUPPRESS_OUTPUT = 1;
10869
10870 pot_avail = count_lines (pot_fp);
10871
10872 rewind (pot_fp);
10873
10874 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10875
10876 uint pot_hashes_avail = 0;
10877
10878 uint line_num = 0;
10879
10880 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10881
10882 while (!feof (pot_fp))
10883 {
10884 line_num++;
10885
10886 int line_len = fgetl (pot_fp, line_buf);
10887
10888 if (line_len == 0) continue;
10889
10890 char *plain_buf = line_buf + line_len;
10891
10892 pot_t *pot_ptr = &pot[pot_cnt];
10893
10894 hash_t *hashes_buf = &pot_ptr->hash;
10895
10896 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10897 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10898
10899 if (pot_cnt == pot_hashes_avail)
10900 {
10901 uint pos = 0;
10902
10903 for (pos = 0; pos < INCR_POT; pos++)
10904 {
10905 if ((pot_cnt + pos) >= pot_avail) break;
10906
10907 pot_t *tmp_pot = &pot[pot_cnt + pos];
10908
10909 hash_t *tmp_hash = &tmp_pot->hash;
10910
10911 tmp_hash->digest = mymalloc (dgst_size);
10912
10913 if (isSalted)
10914 {
10915 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10916 }
10917
10918 if (esalt_size)
10919 {
10920 tmp_hash->esalt = mymalloc (esalt_size);
10921 }
10922
10923 pot_hashes_avail++;
10924 }
10925 }
10926
10927 int plain_len = 0;
10928
10929 int parser_status;
10930
10931 int iter = MAX_CUT_TRIES;
10932
10933 do
10934 {
10935 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10936 {
10937 if (line_buf[i] == ':')
10938 {
10939 line_len--;
10940
10941 break;
10942 }
10943 }
10944
10945 if (data.hash_mode != 2500)
10946 {
10947 parser_status = parse_func (line_buf, line_len, hashes_buf);
10948 }
10949 else
10950 {
10951 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10952
10953 if (line_len > max_salt_size)
10954 {
10955 parser_status = PARSER_GLOBAL_LENGTH;
10956 }
10957 else
10958 {
10959 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10960
10961 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10962
10963 hashes_buf->salt->salt_len = line_len;
10964
10965 parser_status = PARSER_OK;
10966 }
10967 }
10968
10969 // if NOT parsed without error, we add the ":" to the plain
10970
10971 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10972 {
10973 plain_len++;
10974 plain_buf--;
10975 }
10976
10977 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10978
10979 if (parser_status < PARSER_GLOBAL_ZERO)
10980 {
10981 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10982
10983 continue;
10984 }
10985
10986 if (plain_len >= 255) continue;
10987
10988 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10989
10990 pot_ptr->plain_len = plain_len;
10991
10992 pot_cnt++;
10993 }
10994
10995 myfree (line_buf);
10996
10997 fclose (pot_fp);
10998
10999 SUPPRESS_OUTPUT = 0;
11000
11001 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11002 }
11003
11004 /**
11005 * word len
11006 */
11007
11008 uint pw_min = PW_MIN;
11009 uint pw_max = PW_MAX;
11010
11011 switch (hash_mode)
11012 {
11013 case 125: if (pw_max > 32) pw_max = 32;
11014 break;
11015 case 400: if (pw_max > 40) pw_max = 40;
11016 break;
11017 case 500: if (pw_max > 16) pw_max = 16;
11018 break;
11019 case 1500: if (pw_max > 8) pw_max = 8;
11020 break;
11021 case 1600: if (pw_max > 16) pw_max = 16;
11022 break;
11023 case 1800: if (pw_max > 16) pw_max = 16;
11024 break;
11025 case 2100: if (pw_max > 16) pw_max = 16;
11026 break;
11027 case 2500: if (pw_min < 8) pw_min = 8;
11028 break;
11029 case 3000: if (pw_max > 7) pw_max = 7;
11030 break;
11031 case 5200: if (pw_max > 24) pw_max = 24;
11032 break;
11033 case 5800: if (pw_max > 16) pw_max = 16;
11034 break;
11035 case 6300: if (pw_max > 16) pw_max = 16;
11036 break;
11037 case 7400: if (pw_max > 16) pw_max = 16;
11038 break;
11039 case 7900: if (pw_max > 48) pw_max = 48;
11040 break;
11041 case 8500: if (pw_max > 8) pw_max = 8;
11042 break;
11043 case 8600: if (pw_max > 16) pw_max = 16;
11044 break;
11045 case 9710: pw_min = 5;
11046 pw_max = 5;
11047 break;
11048 case 9810: pw_min = 5;
11049 pw_max = 5;
11050 break;
11051 case 10410: pw_min = 5;
11052 pw_max = 5;
11053 break;
11054 case 10300: if (pw_max < 3) pw_min = 3;
11055 if (pw_max > 40) pw_max = 40;
11056 break;
11057 case 10500: if (pw_max < 3) pw_min = 3;
11058 if (pw_max > 40) pw_max = 40;
11059 break;
11060 case 10700: if (pw_max > 16) pw_max = 16;
11061 break;
11062 case 11300: if (pw_max > 40) pw_max = 40;
11063 break;
11064 case 11600: if (pw_max > 32) pw_max = 32;
11065 break;
11066 case 12500: if (pw_max > 20) pw_max = 20;
11067 break;
11068 case 12800: if (pw_max > 24) pw_max = 24;
11069 break;
11070 }
11071
11072 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11073 {
11074 switch (attack_kern)
11075 {
11076 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11077 break;
11078 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11079 break;
11080 }
11081 }
11082
11083 /**
11084 * charsets : keep them together for more easy maintainnce
11085 */
11086
11087 cs_t mp_sys[6] = { { { 0 }, 0 } };
11088 cs_t mp_usr[4] = { { { 0 }, 0 } };
11089
11090 mp_setup_sys (mp_sys);
11091
11092 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11093 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11094 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11095 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11096
11097 /**
11098 * load hashes, part I: find input mode, count hashes
11099 */
11100
11101 uint hashlist_mode = 0;
11102 uint hashlist_format = HLFMT_HASHCAT;
11103
11104 uint hashes_avail = 0;
11105
11106 if (benchmark == 0)
11107 {
11108 struct stat f;
11109
11110 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11111
11112 if ((hash_mode == 2500) ||
11113 (hash_mode == 5200) ||
11114 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11115 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11116 (hash_mode == 9000))
11117 {
11118 hashlist_mode = HL_MODE_ARG;
11119
11120 char *hashfile = myargv[optind];
11121
11122 data.hashfile = hashfile;
11123
11124 logfile_top_var_string ("target", hashfile);
11125 }
11126
11127 if (hashlist_mode == HL_MODE_ARG)
11128 {
11129 if (hash_mode == 2500)
11130 {
11131 struct stat st;
11132
11133 if (stat (data.hashfile, &st) == -1)
11134 {
11135 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11136
11137 return (-1);
11138 }
11139
11140 hashes_avail = st.st_size / sizeof (hccap_t);
11141 }
11142 else
11143 {
11144 hashes_avail = 1;
11145 }
11146 }
11147 else if (hashlist_mode == HL_MODE_FILE)
11148 {
11149 char *hashfile = myargv[optind];
11150
11151 data.hashfile = hashfile;
11152
11153 logfile_top_var_string ("target", hashfile);
11154
11155 FILE *fp = NULL;
11156
11157 if ((fp = fopen (hashfile, "rb")) == NULL)
11158 {
11159 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11160
11161 return (-1);
11162 }
11163
11164 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11165
11166 hashes_avail = count_lines (fp);
11167
11168 rewind (fp);
11169
11170 if (hashes_avail == 0)
11171 {
11172 log_error ("ERROR: hashfile is empty or corrupt");
11173
11174 fclose (fp);
11175
11176 return (-1);
11177 }
11178
11179 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11180
11181 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11182 {
11183 log_error ("ERROR: remove not supported in native hashfile-format mode");
11184
11185 fclose (fp);
11186
11187 return (-1);
11188 }
11189
11190 fclose (fp);
11191 }
11192 }
11193 else
11194 {
11195 hashlist_mode = HL_MODE_ARG;
11196
11197 hashes_avail = 1;
11198 }
11199
11200 if (hash_mode == 3000) hashes_avail *= 2;
11201
11202 data.hashlist_mode = hashlist_mode;
11203 data.hashlist_format = hashlist_format;
11204
11205 logfile_top_uint (hashlist_mode);
11206 logfile_top_uint (hashlist_format);
11207
11208 /**
11209 * load hashes, part II: allocate required memory, set pointers
11210 */
11211
11212 hash_t *hashes_buf = NULL;
11213 void *digests_buf = NULL;
11214 salt_t *salts_buf = NULL;
11215 void *esalts_buf = NULL;
11216
11217 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11218
11219 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11220
11221 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11222 {
11223 u32 hash_pos;
11224
11225 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11226 {
11227 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11228
11229 hashes_buf[hash_pos].hash_info = hash_info;
11230
11231 if (username && (remove || show || left))
11232 {
11233 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11234 }
11235
11236 if (benchmark)
11237 {
11238 hash_info->orighash = (char *) mymalloc (256);
11239 }
11240 }
11241 }
11242
11243 if (isSalted)
11244 {
11245 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11246
11247 if (esalt_size)
11248 {
11249 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11250 }
11251 }
11252 else
11253 {
11254 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11255 }
11256
11257 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11258 {
11259 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11260
11261 if (isSalted)
11262 {
11263 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11264
11265 if (esalt_size)
11266 {
11267 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11268 }
11269 }
11270 else
11271 {
11272 hashes_buf[hash_pos].salt = &salts_buf[0];
11273 }
11274 }
11275
11276 /**
11277 * load hashes, part III: parse hashes or generate them if benchmark
11278 */
11279
11280 uint hashes_cnt = 0;
11281
11282 if (benchmark == 0)
11283 {
11284 if (keyspace == 1)
11285 {
11286 // useless to read hash file for keyspace, cheat a little bit w/ optind
11287 }
11288 else if (hashes_avail == 0)
11289 {
11290 }
11291 else if (hashlist_mode == HL_MODE_ARG)
11292 {
11293 char *input_buf = myargv[optind];
11294
11295 uint input_len = strlen (input_buf);
11296
11297 logfile_top_var_string ("target", input_buf);
11298
11299 char *hash_buf = NULL;
11300 int hash_len = 0;
11301
11302 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11303
11304 bool hash_fmt_error = 0;
11305
11306 if (hash_len < 1) hash_fmt_error = 1;
11307 if (hash_buf == NULL) hash_fmt_error = 1;
11308
11309 if (hash_fmt_error)
11310 {
11311 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11312 }
11313 else
11314 {
11315 if (opts_type & OPTS_TYPE_HASH_COPY)
11316 {
11317 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11318
11319 hash_info_tmp->orighash = mystrdup (hash_buf);
11320 }
11321
11322 if (isSalted)
11323 {
11324 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11325 }
11326
11327 int parser_status = PARSER_OK;
11328
11329 if (hash_mode == 2500)
11330 {
11331 if (hash_len == 0)
11332 {
11333 log_error ("ERROR: hccap file not specified");
11334
11335 return (-1);
11336 }
11337
11338 hashlist_mode = HL_MODE_FILE;
11339
11340 data.hashlist_mode = hashlist_mode;
11341
11342 FILE *fp = fopen (hash_buf, "rb");
11343
11344 if (fp == NULL)
11345 {
11346 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11347
11348 return (-1);
11349 }
11350
11351 if (hashes_avail < 1)
11352 {
11353 log_error ("ERROR: hccap file is empty or corrupt");
11354
11355 fclose (fp);
11356
11357 return (-1);
11358 }
11359
11360 uint hccap_size = sizeof (hccap_t);
11361
11362 char *in = (char *) mymalloc (hccap_size);
11363
11364 while (!feof (fp))
11365 {
11366 int n = fread (in, hccap_size, 1, fp);
11367
11368 if (n != 1)
11369 {
11370 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11371
11372 break;
11373 }
11374
11375 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11376
11377 if (parser_status != PARSER_OK)
11378 {
11379 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11380
11381 continue;
11382 }
11383
11384 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11385
11386 if ((show == 1) || (left == 1))
11387 {
11388 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11389
11390 char *salt_ptr = (char *) tmp_salt->salt_buf;
11391
11392 int cur_pos = tmp_salt->salt_len;
11393 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11394
11395 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11396
11397 // do the appending task
11398
11399 snprintf (salt_ptr + cur_pos,
11400 rem_len,
11401 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11402 wpa->orig_mac1[0],
11403 wpa->orig_mac1[1],
11404 wpa->orig_mac1[2],
11405 wpa->orig_mac1[3],
11406 wpa->orig_mac1[4],
11407 wpa->orig_mac1[5],
11408 wpa->orig_mac2[0],
11409 wpa->orig_mac2[1],
11410 wpa->orig_mac2[2],
11411 wpa->orig_mac2[3],
11412 wpa->orig_mac2[4],
11413 wpa->orig_mac2[5]);
11414
11415 // memset () the remaining part of the salt
11416
11417 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11418 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11419
11420 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11421
11422 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11423 }
11424
11425 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);
11426 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);
11427
11428 hashes_cnt++;
11429 }
11430
11431 fclose (fp);
11432
11433 myfree (in);
11434 }
11435 else if (hash_mode == 3000)
11436 {
11437 if (hash_len == 32)
11438 {
11439 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11440
11441 hash_t *lm_hash_left = NULL;
11442
11443 if (parser_status == PARSER_OK)
11444 {
11445 lm_hash_left = &hashes_buf[hashes_cnt];
11446
11447 hashes_cnt++;
11448 }
11449 else
11450 {
11451 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11452 }
11453
11454 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11455
11456 hash_t *lm_hash_right = NULL;
11457
11458 if (parser_status == PARSER_OK)
11459 {
11460 lm_hash_right = &hashes_buf[hashes_cnt];
11461
11462 hashes_cnt++;
11463 }
11464 else
11465 {
11466 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11467 }
11468
11469 // show / left
11470
11471 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11472 {
11473 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);
11474 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);
11475 }
11476 }
11477 else
11478 {
11479 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11480
11481 if (parser_status == PARSER_OK)
11482 {
11483 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11484 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11485 }
11486
11487 if (parser_status == PARSER_OK)
11488 {
11489 hashes_cnt++;
11490 }
11491 else
11492 {
11493 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11494 }
11495 }
11496 }
11497 else
11498 {
11499 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11500
11501 if (parser_status == PARSER_OK)
11502 {
11503 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11504 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11505 }
11506
11507 if (parser_status == PARSER_OK)
11508 {
11509 hashes_cnt++;
11510 }
11511 else
11512 {
11513 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11514 }
11515 }
11516 }
11517 }
11518 else if (hashlist_mode == HL_MODE_FILE)
11519 {
11520 char *hashfile = data.hashfile;
11521
11522 FILE *fp;
11523
11524 if ((fp = fopen (hashfile, "rb")) == NULL)
11525 {
11526 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11527
11528 return (-1);
11529 }
11530
11531 uint line_num = 0;
11532
11533 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11534
11535 while (!feof (fp))
11536 {
11537 line_num++;
11538
11539 int line_len = fgetl (fp, line_buf);
11540
11541 if (line_len == 0) continue;
11542
11543 char *hash_buf = NULL;
11544 int hash_len = 0;
11545
11546 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11547
11548 bool hash_fmt_error = 0;
11549
11550 if (hash_len < 1) hash_fmt_error = 1;
11551 if (hash_buf == NULL) hash_fmt_error = 1;
11552
11553 if (hash_fmt_error)
11554 {
11555 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11556
11557 continue;
11558 }
11559
11560 if (username)
11561 {
11562 char *user_buf = NULL;
11563 int user_len = 0;
11564
11565 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11566
11567 if (remove || show)
11568 {
11569 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11570
11571 *user = (user_t *) mymalloc (sizeof (user_t));
11572
11573 user_t *user_ptr = *user;
11574
11575 if (user_buf != NULL)
11576 {
11577 user_ptr->user_name = mystrdup (user_buf);
11578 }
11579 else
11580 {
11581 user_ptr->user_name = mystrdup ("");
11582 }
11583
11584 user_ptr->user_len = user_len;
11585 }
11586 }
11587
11588 if (opts_type & OPTS_TYPE_HASH_COPY)
11589 {
11590 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11591
11592 hash_info_tmp->orighash = mystrdup (hash_buf);
11593 }
11594
11595 if (isSalted)
11596 {
11597 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11598 }
11599
11600 if (hash_mode == 3000)
11601 {
11602 if (hash_len == 32)
11603 {
11604 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11605
11606 if (parser_status < PARSER_GLOBAL_ZERO)
11607 {
11608 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11609
11610 continue;
11611 }
11612
11613 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11614
11615 hashes_cnt++;
11616
11617 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11618
11619 if (parser_status < PARSER_GLOBAL_ZERO)
11620 {
11621 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11622
11623 continue;
11624 }
11625
11626 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11627
11628 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);
11629
11630 hashes_cnt++;
11631
11632 // show / left
11633
11634 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);
11635 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);
11636 }
11637 else
11638 {
11639 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11640
11641 if (parser_status < PARSER_GLOBAL_ZERO)
11642 {
11643 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11644
11645 continue;
11646 }
11647
11648 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);
11649
11650 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11651 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11652
11653 hashes_cnt++;
11654 }
11655 }
11656 else
11657 {
11658 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11659
11660 if (parser_status < PARSER_GLOBAL_ZERO)
11661 {
11662 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11663
11664 continue;
11665 }
11666
11667 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);
11668
11669 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11670 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11671
11672 hashes_cnt++;
11673 }
11674 }
11675
11676 myfree (line_buf);
11677
11678 fclose (fp);
11679
11680 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11681
11682 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11683 }
11684 }
11685 else
11686 {
11687 if (isSalted)
11688 {
11689 hashes_buf[0].salt->salt_len = 8;
11690
11691 // special salt handling
11692
11693 switch (hash_mode)
11694 {
11695 case 1500: hashes_buf[0].salt->salt_len = 2;
11696 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11697 break;
11698 case 1731: hashes_buf[0].salt->salt_len = 4;
11699 break;
11700 case 2410: hashes_buf[0].salt->salt_len = 4;
11701 break;
11702 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11703 break;
11704 case 3100: hashes_buf[0].salt->salt_len = 1;
11705 break;
11706 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11707 break;
11708 case 5800: hashes_buf[0].salt->salt_len = 16;
11709 break;
11710 case 6800: hashes_buf[0].salt->salt_len = 32;
11711 break;
11712 case 8400: hashes_buf[0].salt->salt_len = 40;
11713 break;
11714 case 8800: hashes_buf[0].salt->salt_len = 16;
11715 break;
11716 case 8900: hashes_buf[0].salt->salt_len = 16;
11717 hashes_buf[0].salt->scrypt_N = 1024;
11718 hashes_buf[0].salt->scrypt_r = 1;
11719 hashes_buf[0].salt->scrypt_p = 1;
11720 break;
11721 case 9100: hashes_buf[0].salt->salt_len = 16;
11722 break;
11723 case 9300: hashes_buf[0].salt->salt_len = 14;
11724 hashes_buf[0].salt->scrypt_N = 16384;
11725 hashes_buf[0].salt->scrypt_r = 1;
11726 hashes_buf[0].salt->scrypt_p = 1;
11727 break;
11728 case 9400: hashes_buf[0].salt->salt_len = 16;
11729 break;
11730 case 9500: hashes_buf[0].salt->salt_len = 16;
11731 break;
11732 case 9600: hashes_buf[0].salt->salt_len = 16;
11733 break;
11734 case 9700: hashes_buf[0].salt->salt_len = 16;
11735 break;
11736 case 9710: hashes_buf[0].salt->salt_len = 16;
11737 break;
11738 case 9720: hashes_buf[0].salt->salt_len = 16;
11739 break;
11740 case 9800: hashes_buf[0].salt->salt_len = 16;
11741 break;
11742 case 9810: hashes_buf[0].salt->salt_len = 16;
11743 break;
11744 case 9820: hashes_buf[0].salt->salt_len = 16;
11745 break;
11746 case 10300: hashes_buf[0].salt->salt_len = 12;
11747 break;
11748 case 11500: hashes_buf[0].salt->salt_len = 4;
11749 break;
11750 case 11600: hashes_buf[0].salt->salt_len = 4;
11751 break;
11752 case 12400: hashes_buf[0].salt->salt_len = 4;
11753 break;
11754 case 12500: hashes_buf[0].salt->salt_len = 8;
11755 break;
11756 case 12600: hashes_buf[0].salt->salt_len = 64;
11757 break;
11758 }
11759
11760 // special esalt handling
11761
11762 switch (hash_mode)
11763 {
11764 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11765 break;
11766 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11767 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11768 break;
11769 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11770 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11771 break;
11772 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11773 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11774 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11775 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11776 break;
11777 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11778 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11779 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11780 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11781 break;
11782 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11783 break;
11784 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11785 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11786 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11787 break;
11788 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11789 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11790 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11791 break;
11792 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11793 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11794 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11795 break;
11796 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11797 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11798 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11799 break;
11800 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11801 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11802 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11803 break;
11804 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11805 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11806 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11807 break;
11808 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11809 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11810 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11811 break;
11812 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11813 break;
11814 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11815 break;
11816 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11817 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11818 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11819 break;
11820 }
11821 }
11822
11823 // set hashfile
11824
11825 switch (hash_mode)
11826 {
11827 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11828 break;
11829 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11830 break;
11831 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11832 break;
11833 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11834 break;
11835 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11836 break;
11837 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11838 break;
11839 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11840 break;
11841 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11842 break;
11843 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11844 break;
11845 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11846 break;
11847 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11848 break;
11849 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11850 break;
11851 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11852 break;
11853 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11854 break;
11855 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11856 break;
11857 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11858 break;
11859 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11860 break;
11861 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11862 break;
11863 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11864 break;
11865 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11866 break;
11867 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11868 break;
11869 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11870 break;
11871 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11872 break;
11873 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11874 break;
11875 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11876 break;
11877 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11878 break;
11879 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11880 break;
11881 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11882 break;
11883 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11884 break;
11885 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11886 break;
11887 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11888 break;
11889 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11898 break;
11899 }
11900
11901 // set default iterations
11902
11903 switch (hash_mode)
11904 {
11905 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11906 break;
11907 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11908 break;
11909 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11910 break;
11911 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11912 break;
11913 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11914 break;
11915 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11916 break;
11917 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11918 break;
11919 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11920 break;
11921 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11922 break;
11923 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11924 break;
11925 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11926 break;
11927 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11928 break;
11929 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11930 break;
11931 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11932 break;
11933 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11934 break;
11935 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11936 break;
11937 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11938 break;
11939 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11940 break;
11941 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11942 break;
11943 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11944 break;
11945 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11946 break;
11947 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11948 break;
11949 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11950 break;
11951 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11952 break;
11953 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11954 break;
11955 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11956 break;
11957 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11958 break;
11959 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11960 break;
11961 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11962 break;
11963 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11964 break;
11965 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11966 break;
11967 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11968 break;
11969 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11970 break;
11971 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11972 break;
11973 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11974 break;
11975 case 8900: hashes_buf[0].salt->salt_iter = 1;
11976 break;
11977 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11978 break;
11979 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11980 break;
11981 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11982 break;
11983 case 9300: hashes_buf[0].salt->salt_iter = 1;
11984 break;
11985 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11986 break;
11987 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11988 break;
11989 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11990 break;
11991 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11992 break;
11993 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11994 break;
11995 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11996 break;
11997 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11998 break;
11999 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12000 break;
12001 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12002 break;
12003 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12004 break;
12005 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12006 break;
12007 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12008 break;
12009 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12010 break;
12011 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12012 break;
12013 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12014 break;
12015 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12016 break;
12017 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12018 break;
12019 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12020 break;
12021 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12022 break;
12023 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12024 break;
12025 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12026 break;
12027 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12028 break;
12029 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12030 break;
12031 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12032 break;
12033 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12034 break;
12035 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12036 break;
12037 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12038 break;
12039 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12040 break;
12041 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12042 break;
12043 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12044 break;
12045 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12046 break;
12047 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12048 break;
12049 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12050 break;
12051 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12052 break;
12053 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12054 break;
12055 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12056 break;
12057 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12058 break;
12059 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12060 break;
12061 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12062 break;
12063 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12064 break;
12065 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12066 break;
12067 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12068 break;
12069 }
12070
12071 hashes_cnt = 1;
12072 }
12073
12074 if (show == 1 || left == 1)
12075 {
12076 for (uint i = 0; i < pot_cnt; i++)
12077 {
12078 pot_t *pot_ptr = &pot[i];
12079
12080 hash_t *hashes_buf = &pot_ptr->hash;
12081
12082 local_free (hashes_buf->digest);
12083
12084 if (isSalted)
12085 {
12086 local_free (hashes_buf->salt);
12087 }
12088 }
12089
12090 local_free (pot);
12091
12092 if (data.quiet == 0) log_info_nn ("");
12093
12094 return (0);
12095 }
12096
12097 if (keyspace == 0)
12098 {
12099 if (hashes_cnt == 0)
12100 {
12101 log_error ("ERROR: No hashes loaded");
12102
12103 return (-1);
12104 }
12105 }
12106
12107 /**
12108 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12109 */
12110
12111 if (data.outfile != NULL)
12112 {
12113 if (data.hashfile != NULL)
12114 {
12115 #ifdef _POSIX
12116 struct stat tmpstat_outfile;
12117 struct stat tmpstat_hashfile;
12118 #endif
12119
12120 #ifdef _WIN
12121 struct stat64 tmpstat_outfile;
12122 struct stat64 tmpstat_hashfile;
12123 #endif
12124
12125 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12126
12127 if (tmp_outfile_fp)
12128 {
12129 #ifdef _POSIX
12130 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12131 #endif
12132
12133 #ifdef _WIN
12134 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12135 #endif
12136
12137 fclose (tmp_outfile_fp);
12138 }
12139
12140 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12141
12142 if (tmp_hashfile_fp)
12143 {
12144 #ifdef _POSIX
12145 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12146 #endif
12147
12148 #ifdef _WIN
12149 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12150 #endif
12151
12152 fclose (tmp_hashfile_fp);
12153 }
12154
12155 if (tmp_outfile_fp && tmp_outfile_fp)
12156 {
12157 tmpstat_outfile.st_mode = 0;
12158 tmpstat_outfile.st_nlink = 0;
12159 tmpstat_outfile.st_uid = 0;
12160 tmpstat_outfile.st_gid = 0;
12161 tmpstat_outfile.st_rdev = 0;
12162 tmpstat_outfile.st_atime = 0;
12163
12164 tmpstat_hashfile.st_mode = 0;
12165 tmpstat_hashfile.st_nlink = 0;
12166 tmpstat_hashfile.st_uid = 0;
12167 tmpstat_hashfile.st_gid = 0;
12168 tmpstat_hashfile.st_rdev = 0;
12169 tmpstat_hashfile.st_atime = 0;
12170
12171 #ifdef _POSIX
12172 tmpstat_outfile.st_blksize = 0;
12173 tmpstat_outfile.st_blocks = 0;
12174
12175 tmpstat_hashfile.st_blksize = 0;
12176 tmpstat_hashfile.st_blocks = 0;
12177 #endif
12178
12179 #ifdef _POSIX
12180 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12181 {
12182 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12183
12184 return (-1);
12185 }
12186 #endif
12187
12188 #ifdef _WIN
12189 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12190 {
12191 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12192
12193 return (-1);
12194 }
12195 #endif
12196 }
12197 }
12198 }
12199
12200 /**
12201 * Remove duplicates
12202 */
12203
12204 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12205
12206 if (isSalted)
12207 {
12208 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12209 }
12210 else
12211 {
12212 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12213 }
12214
12215 uint hashes_cnt_orig = hashes_cnt;
12216
12217 hashes_cnt = 1;
12218
12219 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12220 {
12221 if (isSalted)
12222 {
12223 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12224 {
12225 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12226 }
12227 }
12228 else
12229 {
12230 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12231 }
12232
12233 if (hashes_pos > hashes_cnt)
12234 {
12235 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12236 }
12237
12238 hashes_cnt++;
12239 }
12240
12241 /**
12242 * Potfile removes
12243 */
12244
12245 uint potfile_remove_cracks = 0;
12246
12247 if (potfile_disable == 0)
12248 {
12249 hash_t hash_buf;
12250
12251 hash_buf.digest = mymalloc (dgst_size);
12252 hash_buf.salt = NULL;
12253 hash_buf.esalt = NULL;
12254 hash_buf.hash_info = NULL;
12255 hash_buf.cracked = 0;
12256
12257 if (isSalted)
12258 {
12259 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12260 }
12261
12262 if (esalt_size)
12263 {
12264 hash_buf.esalt = mymalloc (esalt_size);
12265 }
12266
12267 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12268
12269 // no solution for these special hash types (for instane because they use hashfile in output etc)
12270 if ((hash_mode != 5200) &&
12271 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12272 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12273 (hash_mode != 9000))
12274 {
12275 FILE *fp = fopen (potfile, "rb");
12276
12277 if (fp != NULL)
12278 {
12279 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12280
12281 // to be safe work with a copy (because of line_len loop, i etc)
12282 // moved up here because it's easier to handle continue case
12283 // it's just 64kb
12284
12285 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12286
12287 while (!feof (fp))
12288 {
12289 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12290
12291 if (ptr == NULL) break;
12292
12293 int line_len = strlen (line_buf);
12294
12295 if (line_len == 0) continue;
12296
12297 int iter = MAX_CUT_TRIES;
12298
12299 for (int i = line_len - 1; i && iter; i--, line_len--)
12300 {
12301 if (line_buf[i] != ':') continue;
12302
12303 if (isSalted)
12304 {
12305 memset (hash_buf.salt, 0, sizeof (salt_t));
12306 }
12307
12308 hash_t *found = NULL;
12309
12310 if (hash_mode == 6800)
12311 {
12312 if (i < 64) // 64 = 16 * uint in salt_buf[]
12313 {
12314 // manipulate salt_buf
12315 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12316
12317 hash_buf.salt->salt_len = i;
12318
12319 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12320 }
12321 }
12322 else if (hash_mode == 2500)
12323 {
12324 if (i < 64) // 64 = 16 * uint in salt_buf[]
12325 {
12326 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12327 // manipulate salt_buf
12328
12329 memcpy (line_buf_cpy, line_buf, i);
12330
12331 char *mac2_pos = strrchr (line_buf_cpy, ':');
12332
12333 if (mac2_pos == NULL) continue;
12334
12335 mac2_pos[0] = 0;
12336 mac2_pos++;
12337
12338 if (strlen (mac2_pos) != 12) continue;
12339
12340 char *mac1_pos = strrchr (line_buf_cpy, ':');
12341
12342 if (mac1_pos == NULL) continue;
12343
12344 mac1_pos[0] = 0;
12345 mac1_pos++;
12346
12347 if (strlen (mac1_pos) != 12) continue;
12348
12349 uint essid_length = mac1_pos - line_buf_cpy - 1;
12350
12351 // here we need the ESSID
12352 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12353
12354 hash_buf.salt->salt_len = essid_length;
12355
12356 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12357
12358 if (found)
12359 {
12360 wpa_t *wpa = (wpa_t *) found->esalt;
12361
12362 // compare hex string(s) vs binary MAC address(es)
12363
12364 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12365 {
12366 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12367 {
12368 found = NULL;
12369
12370 break;
12371 }
12372 }
12373
12374 // early skip ;)
12375 if (!found) continue;
12376
12377 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12378 {
12379 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12380 {
12381 found = NULL;
12382
12383 break;
12384 }
12385 }
12386 }
12387 }
12388 }
12389 else
12390 {
12391 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12392
12393 if (parser_status == PARSER_OK)
12394 {
12395 if (isSalted)
12396 {
12397 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12398 }
12399 else
12400 {
12401 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12402 }
12403 }
12404 }
12405
12406 if (found == NULL) continue;
12407
12408 if (!found->cracked) potfile_remove_cracks++;
12409
12410 found->cracked = 1;
12411
12412 if (found) break;
12413
12414 iter--;
12415 }
12416 }
12417
12418 myfree (line_buf_cpy);
12419
12420 myfree (line_buf);
12421
12422 fclose (fp);
12423 }
12424 }
12425
12426 if (esalt_size)
12427 {
12428 local_free (hash_buf.esalt);
12429 }
12430
12431 if (isSalted)
12432 {
12433 local_free (hash_buf.salt);
12434 }
12435
12436 local_free (hash_buf.digest);
12437 }
12438
12439 /**
12440 * Now generate all the buffers required for later
12441 */
12442
12443 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12444
12445 salt_t *salts_buf_new = NULL;
12446 void *esalts_buf_new = NULL;
12447
12448 if (isSalted)
12449 {
12450 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12451
12452 if (esalt_size)
12453 {
12454 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12455 }
12456 }
12457 else
12458 {
12459 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12460 }
12461
12462 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12463
12464 uint digests_cnt = hashes_cnt;
12465 uint digests_done = 0;
12466
12467 size_t size_digests = digests_cnt * dgst_size;
12468 size_t size_shown = digests_cnt * sizeof (uint);
12469
12470 uint *digests_shown = (uint *) mymalloc (size_shown);
12471 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12472
12473 uint salts_cnt = 0;
12474 uint salts_done = 0;
12475
12476 hashinfo_t **hash_info = NULL;
12477
12478 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12479 {
12480 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12481
12482 if (username && (remove || show))
12483 {
12484 uint user_pos;
12485
12486 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12487 {
12488 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12489
12490 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12491 }
12492 }
12493 }
12494
12495 uint *salts_shown = (uint *) mymalloc (size_shown);
12496
12497 salt_t *salt_buf;
12498
12499 {
12500 // copied from inner loop
12501
12502 salt_buf = &salts_buf_new[salts_cnt];
12503
12504 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12505
12506 if (esalt_size)
12507 {
12508 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12509 }
12510
12511 salt_buf->digests_cnt = 0;
12512 salt_buf->digests_done = 0;
12513 salt_buf->digests_offset = 0;
12514
12515 salts_cnt++;
12516 }
12517
12518 if (hashes_buf[0].cracked == 1)
12519 {
12520 digests_shown[0] = 1;
12521
12522 digests_done++;
12523
12524 salt_buf->digests_done++;
12525 }
12526
12527 salt_buf->digests_cnt++;
12528
12529 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12530
12531 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12532 {
12533 hash_info[0] = hashes_buf[0].hash_info;
12534 }
12535
12536 // copy from inner loop
12537
12538 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12539 {
12540 if (isSalted)
12541 {
12542 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12543 {
12544 salt_buf = &salts_buf_new[salts_cnt];
12545
12546 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12547
12548 if (esalt_size)
12549 {
12550 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12551 }
12552
12553 salt_buf->digests_cnt = 0;
12554 salt_buf->digests_done = 0;
12555 salt_buf->digests_offset = hashes_pos;
12556
12557 salts_cnt++;
12558 }
12559 }
12560
12561 if (hashes_buf[hashes_pos].cracked == 1)
12562 {
12563 digests_shown[hashes_pos] = 1;
12564
12565 digests_done++;
12566
12567 salt_buf->digests_done++;
12568 }
12569
12570 salt_buf->digests_cnt++;
12571
12572 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12573
12574 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12575 {
12576 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12577 }
12578 }
12579
12580 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12581 {
12582 salt_t *salt_buf = &salts_buf_new[salt_pos];
12583
12584 if (salt_buf->digests_done == salt_buf->digests_cnt)
12585 {
12586 salts_shown[salt_pos] = 1;
12587
12588 salts_done++;
12589 }
12590
12591 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12592 }
12593
12594 local_free (digests_buf);
12595 local_free (salts_buf);
12596 local_free (esalts_buf);
12597
12598 digests_buf = digests_buf_new;
12599 salts_buf = salts_buf_new;
12600 esalts_buf = esalts_buf_new;
12601
12602 local_free (hashes_buf);
12603
12604 /**
12605 * special modification not set from parser
12606 */
12607
12608 switch (hash_mode)
12609 {
12610 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12611 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12612 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12613 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12614 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12615 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12616 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12617 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12618 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12619 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12620 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12621 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12622 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12623 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12624 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12625 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12626 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12627 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12628 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12629 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12630 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12631 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12632 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12633 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12634 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12635 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12636 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12637 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12638 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12639 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12640 }
12641
12642 if (truecrypt_keyfiles)
12643 {
12644 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12645
12646 char *keyfiles = strdup (truecrypt_keyfiles);
12647
12648 char *keyfile = strtok (keyfiles, ",");
12649
12650 do
12651 {
12652 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12653
12654 } while ((keyfile = strtok (NULL, ",")) != NULL);
12655
12656 free (keyfiles);
12657 }
12658
12659 if (veracrypt_keyfiles)
12660 {
12661 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12662
12663 char *keyfiles = strdup (veracrypt_keyfiles);
12664
12665 char *keyfile = strtok (keyfiles, ",");
12666
12667 do
12668 {
12669 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12670
12671 } while ((keyfile = strtok (NULL, ",")) != NULL);
12672
12673 free (keyfiles);
12674 }
12675
12676 data.digests_cnt = digests_cnt;
12677 data.digests_done = digests_done;
12678 data.digests_buf = digests_buf;
12679 data.digests_shown = digests_shown;
12680 data.digests_shown_tmp = digests_shown_tmp;
12681
12682 data.salts_cnt = salts_cnt;
12683 data.salts_done = salts_done;
12684 data.salts_buf = salts_buf;
12685 data.salts_shown = salts_shown;
12686
12687 data.esalts_buf = esalts_buf;
12688 data.hash_info = hash_info;
12689
12690 /**
12691 * Automatic Optimizers
12692 */
12693
12694 if (salts_cnt == 1)
12695 opti_type |= OPTI_TYPE_SINGLE_SALT;
12696
12697 if (digests_cnt == 1)
12698 opti_type |= OPTI_TYPE_SINGLE_HASH;
12699
12700 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12701 opti_type |= OPTI_TYPE_NOT_ITERATED;
12702
12703 if (attack_mode == ATTACK_MODE_BF)
12704 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12705
12706 data.opti_type = opti_type;
12707
12708 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12709 {
12710 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12711 {
12712 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12713 {
12714 if (opts_type & OPTS_TYPE_ST_ADD80)
12715 {
12716 opts_type &= ~OPTS_TYPE_ST_ADD80;
12717 opts_type |= OPTS_TYPE_PT_ADD80;
12718 }
12719
12720 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12721 {
12722 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12723 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12724 }
12725
12726 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12727 {
12728 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12729 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12730 }
12731 }
12732 }
12733 }
12734
12735 /**
12736 * Some algorithm, like descrypt, can benefit from JIT compilation
12737 */
12738
12739 int force_jit_compilation = -1;
12740
12741 if (hash_mode == 8900)
12742 {
12743 force_jit_compilation = 8900;
12744 }
12745 else if (hash_mode == 9300)
12746 {
12747 force_jit_compilation = 8900;
12748 }
12749 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12750 {
12751 force_jit_compilation = 1500;
12752 }
12753
12754 /**
12755 * generate bitmap tables
12756 */
12757
12758 const uint bitmap_shift1 = 5;
12759 const uint bitmap_shift2 = 13;
12760
12761 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12762
12763 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12764 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12765 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12766 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12767 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12768 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12769 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12770 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12771
12772 uint bitmap_bits;
12773 uint bitmap_nums;
12774 uint bitmap_mask;
12775 uint bitmap_size;
12776
12777 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12778 {
12779 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12780
12781 bitmap_nums = 1 << bitmap_bits;
12782
12783 bitmap_mask = bitmap_nums - 1;
12784
12785 bitmap_size = bitmap_nums * sizeof (uint);
12786
12787 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12788
12789 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;
12790 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;
12791
12792 break;
12793 }
12794
12795 bitmap_nums = 1 << bitmap_bits;
12796
12797 bitmap_mask = bitmap_nums - 1;
12798
12799 bitmap_size = bitmap_nums * sizeof (uint);
12800
12801 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);
12802 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);
12803
12804 /**
12805 * prepare quick rule
12806 */
12807
12808 data.rule_buf_l = rule_buf_l;
12809 data.rule_buf_r = rule_buf_r;
12810
12811 int rule_len_l = (int) strlen (rule_buf_l);
12812 int rule_len_r = (int) strlen (rule_buf_r);
12813
12814 data.rule_len_l = rule_len_l;
12815 data.rule_len_r = rule_len_r;
12816
12817 /**
12818 * load rules
12819 */
12820
12821 uint *all_kernel_rules_cnt = NULL;
12822
12823 kernel_rule_t **all_kernel_rules_buf = NULL;
12824
12825 if (rp_files_cnt)
12826 {
12827 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12828
12829 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12830 }
12831
12832 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12833
12834 int rule_len = 0;
12835
12836 for (uint i = 0; i < rp_files_cnt; i++)
12837 {
12838 uint kernel_rules_avail = 0;
12839
12840 uint kernel_rules_cnt = 0;
12841
12842 kernel_rule_t *kernel_rules_buf = NULL;
12843
12844 char *rp_file = rp_files[i];
12845
12846 char in[BLOCK_SIZE] = { 0 };
12847 char out[BLOCK_SIZE] = { 0 };
12848
12849 FILE *fp = NULL;
12850
12851 uint rule_line = 0;
12852
12853 if ((fp = fopen (rp_file, "rb")) == NULL)
12854 {
12855 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12856
12857 return (-1);
12858 }
12859
12860 while (!feof (fp))
12861 {
12862 memset (rule_buf, 0, HCBUFSIZ);
12863
12864 rule_len = fgetl (fp, rule_buf);
12865
12866 rule_line++;
12867
12868 if (rule_len == 0) continue;
12869
12870 if (rule_buf[0] == '#') continue;
12871
12872 if (kernel_rules_avail == kernel_rules_cnt)
12873 {
12874 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12875
12876 kernel_rules_avail += INCR_RULES;
12877 }
12878
12879 memset (in, 0, BLOCK_SIZE);
12880 memset (out, 0, BLOCK_SIZE);
12881
12882 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12883
12884 if (result == -1)
12885 {
12886 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12887
12888 continue;
12889 }
12890
12891 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12892 {
12893 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12894
12895 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12896
12897 continue;
12898 }
12899
12900 /* its so slow
12901 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12902 {
12903 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12904
12905 continue;
12906 }
12907 */
12908
12909 kernel_rules_cnt++;
12910 }
12911
12912 fclose (fp);
12913
12914 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12915
12916 all_kernel_rules_buf[i] = kernel_rules_buf;
12917 }
12918
12919 /**
12920 * merge rules or automatic rule generator
12921 */
12922
12923 uint kernel_rules_cnt = 0;
12924
12925 kernel_rule_t *kernel_rules_buf = NULL;
12926
12927 if (attack_mode == ATTACK_MODE_STRAIGHT)
12928 {
12929 if (rp_files_cnt)
12930 {
12931 kernel_rules_cnt = 1;
12932
12933 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12934
12935 repeats[0] = kernel_rules_cnt;
12936
12937 for (uint i = 0; i < rp_files_cnt; i++)
12938 {
12939 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12940
12941 repeats[i + 1] = kernel_rules_cnt;
12942 }
12943
12944 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12945
12946 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12947
12948 for (uint i = 0; i < kernel_rules_cnt; i++)
12949 {
12950 uint out_pos = 0;
12951
12952 kernel_rule_t *out = &kernel_rules_buf[i];
12953
12954 for (uint j = 0; j < rp_files_cnt; j++)
12955 {
12956 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12957 uint in_pos;
12958
12959 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12960
12961 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12962 {
12963 if (out_pos == RULES_MAX - 1)
12964 {
12965 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12966
12967 break;
12968 }
12969
12970 out->cmds[out_pos] = in->cmds[in_pos];
12971 }
12972 }
12973 }
12974
12975 local_free (repeats);
12976 }
12977 else if (rp_gen)
12978 {
12979 uint kernel_rules_avail = 0;
12980
12981 while (kernel_rules_cnt < rp_gen)
12982 {
12983 if (kernel_rules_avail == kernel_rules_cnt)
12984 {
12985 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12986
12987 kernel_rules_avail += INCR_RULES;
12988 }
12989
12990 memset (rule_buf, 0, HCBUFSIZ);
12991
12992 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12993
12994 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12995
12996 kernel_rules_cnt++;
12997 }
12998 }
12999 }
13000
13001 myfree (rule_buf);
13002
13003 /**
13004 * generate NOP rules
13005 */
13006
13007 if (kernel_rules_cnt == 0)
13008 {
13009 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13010
13011 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13012
13013 kernel_rules_cnt++;
13014 }
13015
13016 data.kernel_rules_cnt = kernel_rules_cnt;
13017 data.kernel_rules_buf = kernel_rules_buf;
13018
13019 /**
13020 * OpenCL platforms: detect
13021 */
13022
13023 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13024 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13025
13026 cl_uint platforms_cnt = 0;
13027 cl_uint platform_devices_cnt = 0;
13028
13029 if (keyspace == 0)
13030 {
13031 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13032
13033 if (platforms_cnt == 0)
13034 {
13035 log_info ("");
13036 log_info ("ATTENTION! No OpenCL compatible platform found");
13037 log_info ("");
13038 log_info ("You're probably missing the OpenCL runtime installation");
13039 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13040 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13041 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13042 log_info ("");
13043
13044 return (-1);
13045 }
13046
13047 if (opencl_platforms_filter != (uint) -1)
13048 {
13049 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13050
13051 if (opencl_platforms_filter > platform_cnt_mask)
13052 {
13053 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13054
13055 return (-1);
13056 }
13057 }
13058 }
13059
13060 /**
13061 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13062 */
13063
13064 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13065 {
13066 cl_platform_id platform = platforms[platform_id];
13067
13068 char platform_vendor[INFOSZ] = { 0 };
13069
13070 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13071
13072 #ifdef HAVE_HWMON
13073 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13074 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13075 {
13076 // make sure that we do not directly control the fan for NVidia
13077
13078 gpu_temp_retain = 0;
13079
13080 data.gpu_temp_retain = gpu_temp_retain;
13081 }
13082 #endif // HAVE_NVML || HAVE_NVAPI
13083 #endif
13084 }
13085
13086 /**
13087 * OpenCL device types:
13088 * 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.
13089 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13090 */
13091
13092 if (opencl_device_types == NULL)
13093 {
13094 cl_device_type device_types_all = 0;
13095
13096 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13097 {
13098 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13099
13100 cl_platform_id platform = platforms[platform_id];
13101
13102 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13103
13104 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13105 {
13106 cl_device_id device = platform_devices[platform_devices_id];
13107
13108 cl_device_type device_type;
13109
13110 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13111
13112 device_types_all |= device_type;
13113 }
13114 }
13115
13116 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13117 {
13118 device_types_filter |= CL_DEVICE_TYPE_CPU;
13119 }
13120 }
13121
13122 /**
13123 * OpenCL devices: simply push all devices from all platforms into the same device array
13124 */
13125
13126 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13127
13128 data.devices_param = devices_param;
13129
13130 uint devices_cnt = 0;
13131
13132 uint devices_active = 0;
13133
13134 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13135 {
13136 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13137
13138 cl_platform_id platform = platforms[platform_id];
13139
13140 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13141
13142 char platform_vendor[INFOSZ] = { 0 };
13143
13144 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13145
13146 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13147 // this causes trouble with vendor id based macros
13148 // we'll assign generic to those without special optimization available
13149
13150 cl_uint vendor_id = 0;
13151
13152 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13153 {
13154 vendor_id = VENDOR_ID_AMD;
13155 }
13156 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13157 {
13158 vendor_id = VENDOR_ID_APPLE;
13159 }
13160 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13161 {
13162 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13163 }
13164 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13165 {
13166 vendor_id = VENDOR_ID_INTEL_SDK;
13167 }
13168 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13169 {
13170 vendor_id = VENDOR_ID_MESA;
13171 }
13172 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13173 {
13174 vendor_id = VENDOR_ID_NV;
13175 }
13176 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13177 {
13178 vendor_id = VENDOR_ID_POCL;
13179 }
13180 else
13181 {
13182 vendor_id = VENDOR_ID_GENERIC;
13183 }
13184
13185 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13186 {
13187 size_t param_value_size = 0;
13188
13189 const uint device_id = devices_cnt;
13190
13191 hc_device_param_t *device_param = &data.devices_param[device_id];
13192
13193 device_param->vendor_id = vendor_id;
13194
13195 device_param->device = platform_devices[platform_devices_id];
13196
13197 device_param->device_id = device_id;
13198
13199 device_param->platform_devices_id = platform_devices_id;
13200
13201 // device_type
13202
13203 cl_device_type device_type;
13204
13205 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13206
13207 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13208
13209 device_param->device_type = device_type;
13210
13211 // device_name
13212
13213 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13214
13215 char *device_name = (char *) mymalloc (param_value_size);
13216
13217 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13218
13219 device_param->device_name = device_name;
13220
13221 // tuning db
13222
13223 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13224
13225 // device_version
13226
13227 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13228
13229 char *device_version = (char *) mymalloc (param_value_size);
13230
13231 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13232
13233 device_param->device_version = device_version;
13234
13235 // device_opencl_version
13236
13237 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13238
13239 char *device_opencl_version = (char *) mymalloc (param_value_size);
13240
13241 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13242
13243 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13244
13245 myfree (device_opencl_version);
13246
13247 // vector_width
13248
13249 cl_uint vector_width;
13250
13251 if (opencl_vector_width_chgd == 0)
13252 {
13253 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13254 {
13255 if (opti_type & OPTI_TYPE_USES_BITS_64)
13256 {
13257 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13258 }
13259 else
13260 {
13261 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13262 }
13263 }
13264 else
13265 {
13266 vector_width = (cl_uint) tuningdb_entry->vector_width;
13267 }
13268 }
13269 else
13270 {
13271 vector_width = opencl_vector_width;
13272 }
13273
13274 if (vector_width > 16) vector_width = 16;
13275
13276 device_param->vector_width = vector_width;
13277
13278 // max_compute_units
13279
13280 cl_uint device_processors;
13281
13282 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13283
13284 device_param->device_processors = device_processors;
13285
13286 // device_maxmem_alloc
13287 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13288
13289 cl_ulong device_maxmem_alloc;
13290
13291 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13292
13293 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13294
13295 // device_global_mem
13296
13297 cl_ulong device_global_mem;
13298
13299 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13300
13301 device_param->device_global_mem = device_global_mem;
13302
13303 // max_work_group_size
13304
13305 size_t device_maxworkgroup_size;
13306
13307 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13308
13309 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13310
13311 // max_clock_frequency
13312
13313 cl_uint device_maxclock_frequency;
13314
13315 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13316
13317 device_param->device_maxclock_frequency = device_maxclock_frequency;
13318
13319 // device_endian_little
13320
13321 cl_bool device_endian_little;
13322
13323 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13324
13325 if (device_endian_little == CL_FALSE)
13326 {
13327 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13328
13329 device_param->skipped = 1;
13330 }
13331
13332 // device_available
13333
13334 cl_bool device_available;
13335
13336 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13337
13338 if (device_available == CL_FALSE)
13339 {
13340 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13341
13342 device_param->skipped = 1;
13343 }
13344
13345 // device_compiler_available
13346
13347 cl_bool device_compiler_available;
13348
13349 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13350
13351 if (device_compiler_available == CL_FALSE)
13352 {
13353 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13354
13355 device_param->skipped = 1;
13356 }
13357
13358 // device_execution_capabilities
13359
13360 cl_device_exec_capabilities device_execution_capabilities;
13361
13362 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13363
13364 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13365 {
13366 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13367
13368 device_param->skipped = 1;
13369 }
13370
13371 // device_extensions
13372
13373 size_t device_extensions_size;
13374
13375 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13376
13377 char *device_extensions = mymalloc (device_extensions_size + 1);
13378
13379 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13380
13381 if (strstr (device_extensions, "base_atomics") == 0)
13382 {
13383 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13384
13385 device_param->skipped = 1;
13386 }
13387
13388 if (strstr (device_extensions, "byte_addressable_store") == 0)
13389 {
13390 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13391
13392 device_param->skipped = 1;
13393 }
13394
13395 myfree (device_extensions);
13396
13397 // device_local_mem_size
13398
13399 cl_ulong device_local_mem_size;
13400
13401 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13402
13403 if (device_local_mem_size < 32768)
13404 {
13405 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13406
13407 device_param->skipped = 1;
13408 }
13409
13410
13411 // skipped
13412
13413 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13414 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13415
13416 // driver_version
13417
13418 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13419
13420 char *driver_version = (char *) mymalloc (param_value_size);
13421
13422 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13423
13424 device_param->driver_version = driver_version;
13425
13426 // device_name_chksum
13427
13428 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13429
13430 #if __x86_64__
13431 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);
13432 #else
13433 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);
13434 #endif
13435
13436 uint device_name_digest[4] = { 0 };
13437
13438 md5_64 ((uint *) device_name_chksum, device_name_digest);
13439
13440 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13441
13442 device_param->device_name_chksum = device_name_chksum;
13443
13444 // device_processor_cores
13445
13446 if (device_type & CL_DEVICE_TYPE_CPU)
13447 {
13448 cl_uint device_processor_cores = 1;
13449
13450 device_param->device_processor_cores = device_processor_cores;
13451 }
13452
13453 if (device_type & CL_DEVICE_TYPE_GPU)
13454 {
13455 if (vendor_id == VENDOR_ID_AMD)
13456 {
13457 cl_uint device_processor_cores = 0;
13458
13459 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13460
13461 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13462
13463 device_param->device_processor_cores = device_processor_cores;
13464 }
13465 else if (vendor_id == VENDOR_ID_NV)
13466 {
13467 cl_uint kernel_exec_timeout = 0;
13468
13469 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13470
13471 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13472
13473 device_param->kernel_exec_timeout = kernel_exec_timeout;
13474
13475 cl_uint device_processor_cores = 0;
13476
13477 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13478
13479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13480
13481 device_param->device_processor_cores = device_processor_cores;
13482
13483 cl_uint sm_minor = 0;
13484 cl_uint sm_major = 0;
13485
13486 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13487 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13488
13489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13490 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13491
13492 device_param->sm_minor = sm_minor;
13493 device_param->sm_major = sm_major;
13494 }
13495 else
13496 {
13497 cl_uint device_processor_cores = 1;
13498
13499 device_param->device_processor_cores = device_processor_cores;
13500 }
13501 }
13502
13503 // display results
13504
13505 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13506 {
13507 if (status_automat == 0)
13508 {
13509 if (device_param->skipped == 0)
13510 {
13511 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13512 device_id + 1,
13513 device_name,
13514 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13515 (unsigned int) (device_global_mem / 1024 / 1024),
13516 (unsigned int) (device_maxclock_frequency),
13517 (unsigned int) device_processors);
13518 }
13519 else
13520 {
13521 log_info ("Device #%u: %s, skipped",
13522 device_id + 1,
13523 device_name);
13524 }
13525 }
13526 }
13527
13528 // common driver check
13529
13530 if (device_param->skipped == 0)
13531 {
13532 if (device_type & CL_DEVICE_TYPE_GPU)
13533 {
13534 if (vendor_id == VENDOR_ID_AMD)
13535 {
13536 int catalyst_check = (force == 1) ? 0 : 1;
13537
13538 int catalyst_warn = 0;
13539
13540 int catalyst_broken = 0;
13541
13542 if (catalyst_check == 1)
13543 {
13544 catalyst_warn = 1;
13545
13546 // v14.9 and higher
13547 if (atoi (device_param->driver_version) >= 1573)
13548 {
13549 catalyst_warn = 0;
13550 }
13551
13552 catalyst_check = 0;
13553 }
13554
13555 if (catalyst_broken == 1)
13556 {
13557 log_info ("");
13558 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13559 log_info ("It will pass over cracked hashes and does not report them as cracked");
13560 log_info ("You are STRONGLY encouraged not to use it");
13561 log_info ("You can use --force to override this but do not post error reports if you do so");
13562 log_info ("");
13563
13564 return (-1);
13565 }
13566
13567 if (catalyst_warn == 1)
13568 {
13569 log_info ("");
13570 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13571 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13572 log_info ("See hashcat's homepage for official supported catalyst drivers");
13573 #ifdef _WIN
13574 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13575 #endif
13576 log_info ("You can use --force to override this but do not post error reports if you do so");
13577 log_info ("");
13578
13579 return (-1);
13580 }
13581 }
13582 else if (vendor_id == VENDOR_ID_NV)
13583 {
13584 if (device_param->kernel_exec_timeout != 0)
13585 {
13586 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);
13587 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13588 }
13589 }
13590 }
13591
13592 if (device_type & CL_DEVICE_TYPE_CPU)
13593 {
13594 if (vendor_id == VENDOR_ID_AMD)
13595 {
13596 if (force == 0)
13597 {
13598 log_info ("");
13599 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13600 log_info ("You are STRONGLY encouraged not to use it");
13601 log_info ("You can use --force to override this but do not post error reports if you do so");
13602 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13603 log_info ("");
13604
13605 return (-1);
13606 }
13607 }
13608 }
13609
13610 /**
13611 * kernel accel and loops tuning db adjustment
13612 */
13613
13614 device_param->kernel_accel_min = 1;
13615 device_param->kernel_accel_max = 1024;
13616
13617 device_param->kernel_loops_min = 1;
13618 device_param->kernel_loops_max = 1024;
13619
13620 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13621
13622 if (tuningdb_entry)
13623 {
13624 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13625 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13626
13627 if (_kernel_accel)
13628 {
13629 device_param->kernel_accel_min = _kernel_accel;
13630 device_param->kernel_accel_max = _kernel_accel;
13631 }
13632
13633 if (_kernel_loops)
13634 {
13635 if (workload_profile == 1)
13636 {
13637 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13638 }
13639 else if (workload_profile == 2)
13640 {
13641 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13642 }
13643
13644 device_param->kernel_loops_min = _kernel_loops;
13645 device_param->kernel_loops_max = _kernel_loops;
13646 }
13647 }
13648
13649 // commandline parameters overwrite tuningdb entries
13650
13651 if (kernel_accel)
13652 {
13653 device_param->kernel_accel_min = kernel_accel;
13654 device_param->kernel_accel_max = kernel_accel;
13655 }
13656
13657 if (kernel_loops)
13658 {
13659 device_param->kernel_loops_min = kernel_loops;
13660 device_param->kernel_loops_max = kernel_loops;
13661 }
13662
13663 /**
13664 * activate device
13665 */
13666
13667 devices_active++;
13668 }
13669
13670 // next please
13671
13672 devices_cnt++;
13673 }
13674 }
13675
13676 if (keyspace == 0 && devices_active == 0)
13677 {
13678 log_error ("ERROR: No devices found/left");
13679
13680 return (-1);
13681 }
13682
13683 // 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)
13684
13685 if (devices_filter != (uint) -1)
13686 {
13687 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13688
13689 if (devices_filter > devices_cnt_mask)
13690 {
13691 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13692
13693 return (-1);
13694 }
13695 }
13696
13697 data.devices_cnt = devices_cnt;
13698
13699 data.devices_active = devices_active;
13700
13701 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13702 {
13703 if (status_automat == 0)
13704 {
13705 log_info ("");
13706 }
13707 }
13708
13709 /**
13710 * HM devices: init
13711 */
13712
13713 #ifdef HAVE_HWMON
13714 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13715 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13716 #endif
13717
13718 #ifdef HAVE_ADL
13719 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13720 #endif
13721
13722 if (gpu_temp_disable == 0)
13723 {
13724 #if defined(WIN) && defined(HAVE_NVAPI)
13725 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13726
13727 if (nvapi_init (nvapi) == 0)
13728 data.hm_nv = nvapi;
13729
13730 if (data.hm_nv)
13731 {
13732 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13733 {
13734 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13735
13736 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13737
13738 int tmp_out = 0;
13739
13740 for (int i = 0; i < tmp_in; i++)
13741 {
13742 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13743 }
13744
13745 for (int i = 0; i < tmp_out; i++)
13746 {
13747 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13748
13749 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13750
13751 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;
13752 }
13753 }
13754 }
13755 #endif // WIN && HAVE_NVAPI
13756
13757 #if defined(LINUX) && defined(HAVE_NVML)
13758 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13759
13760 if (nvml_init (nvml) == 0)
13761 data.hm_nv = nvml;
13762
13763 if (data.hm_nv)
13764 {
13765 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13766 {
13767 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13768
13769 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13770
13771 int tmp_out = 0;
13772
13773 for (int i = 0; i < tmp_in; i++)
13774 {
13775 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13776 }
13777
13778 for (int i = 0; i < tmp_out; i++)
13779 {
13780 unsigned int speed;
13781
13782 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;
13783 }
13784 }
13785 }
13786 #endif // LINUX && HAVE_NVML
13787
13788 data.hm_amd = NULL;
13789
13790 #ifdef HAVE_ADL
13791 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13792
13793 if (adl_init (adl) == 0)
13794 data.hm_amd = adl;
13795
13796 if (data.hm_amd)
13797 {
13798 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13799 {
13800 // total number of adapters
13801
13802 int hm_adapters_num;
13803
13804 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13805
13806 // adapter info
13807
13808 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13809
13810 if (lpAdapterInfo == NULL) return (-1);
13811
13812 // get a list (of ids of) valid/usable adapters
13813
13814 int num_adl_adapters = 0;
13815
13816 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13817
13818 if (num_adl_adapters > 0)
13819 {
13820 hc_thread_mutex_lock (mux_adl);
13821
13822 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13823
13824 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13825
13826 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13827 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13828
13829 hc_thread_mutex_unlock (mux_adl);
13830 }
13831
13832 myfree (valid_adl_device_list);
13833 myfree (lpAdapterInfo);
13834 }
13835 }
13836 #endif // HAVE_ADL
13837
13838 if (data.hm_amd == NULL && data.hm_nv == NULL)
13839 {
13840 gpu_temp_disable = 1;
13841 }
13842 }
13843
13844 /**
13845 * OpenCL devices: allocate buffer for device specific information
13846 */
13847
13848 #ifdef HAVE_HWMON
13849 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13850
13851 #ifdef HAVE_ADL
13852 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13853
13854 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13855 #endif // ADL
13856 #endif
13857
13858 /**
13859 * enable custom signal handler(s)
13860 */
13861
13862 if (benchmark == 0)
13863 {
13864 hc_signal (sigHandler_default);
13865 }
13866 else
13867 {
13868 hc_signal (sigHandler_benchmark);
13869 }
13870
13871 /**
13872 * User-defined GPU temp handling
13873 */
13874
13875 #ifdef HAVE_HWMON
13876 if (gpu_temp_disable == 1)
13877 {
13878 gpu_temp_abort = 0;
13879 gpu_temp_retain = 0;
13880 }
13881
13882 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13883 {
13884 if (gpu_temp_abort < gpu_temp_retain)
13885 {
13886 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13887
13888 return (-1);
13889 }
13890 }
13891
13892 data.gpu_temp_disable = gpu_temp_disable;
13893 data.gpu_temp_abort = gpu_temp_abort;
13894 data.gpu_temp_retain = gpu_temp_retain;
13895 #endif
13896
13897 /**
13898 * inform the user
13899 */
13900
13901 if (data.quiet == 0)
13902 {
13903 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13904
13905 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);
13906
13907 if (attack_mode == ATTACK_MODE_STRAIGHT)
13908 {
13909 log_info ("Rules: %u", kernel_rules_cnt);
13910 }
13911
13912 if (opti_type)
13913 {
13914 log_info ("Applicable Optimizers:");
13915
13916 for (uint i = 0; i < 32; i++)
13917 {
13918 const uint opti_bit = 1u << i;
13919
13920 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13921 }
13922 }
13923
13924 /**
13925 * Watchdog and Temperature balance
13926 */
13927
13928 #ifdef HAVE_HWMON
13929 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13930 {
13931 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13932 }
13933
13934 if (gpu_temp_abort == 0)
13935 {
13936 log_info ("Watchdog: Temperature abort trigger disabled");
13937 }
13938 else
13939 {
13940 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13941 }
13942
13943 if (gpu_temp_retain == 0)
13944 {
13945 log_info ("Watchdog: Temperature retain trigger disabled");
13946 }
13947 else
13948 {
13949 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13950 }
13951
13952 if (data.quiet == 0) log_info ("");
13953 #endif
13954 }
13955
13956 /**
13957 * HM devices: copy
13958 */
13959
13960 if (gpu_temp_disable == 0)
13961 {
13962 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13963 {
13964 hc_device_param_t *device_param = &data.devices_param[device_id];
13965
13966 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13967
13968 if (device_param->skipped) continue;
13969
13970 const uint platform_devices_id = device_param->platform_devices_id;
13971
13972 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13973 if (device_param->vendor_id == VENDOR_ID_NV)
13974 {
13975 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13976 }
13977 #endif
13978
13979 #ifdef HAVE_ADL
13980 if (device_param->vendor_id == VENDOR_ID_AMD)
13981 {
13982 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13983 }
13984 #endif
13985 }
13986 }
13987
13988 /*
13989 * Temporary fix:
13990 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13991 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13992 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13993 * Driver / ADL bug?
13994 */
13995
13996 #ifdef HAVE_ADL
13997 if (powertune_enable == 1)
13998 {
13999 hc_thread_mutex_lock (mux_adl);
14000
14001 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14002 {
14003 hc_device_param_t *device_param = &data.devices_param[device_id];
14004
14005 if (device_param->skipped) continue;
14006
14007 if (data.hm_device[device_id].od_version == 6)
14008 {
14009 // set powertune value only
14010
14011 int powertune_supported = 0;
14012
14013 int ADL_rc = 0;
14014
14015 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14016 {
14017 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14018
14019 return (-1);
14020 }
14021
14022 if (powertune_supported != 0)
14023 {
14024 // powertune set
14025 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14026
14027 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14028 {
14029 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14030
14031 return (-1);
14032 }
14033
14034 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14035 {
14036 log_error ("ERROR: Failed to set new ADL PowerControl values");
14037
14038 return (-1);
14039 }
14040 }
14041 }
14042 }
14043
14044 hc_thread_mutex_unlock (mux_adl);
14045 }
14046 #endif // HAVE_ADK
14047 #endif // HAVE_HWMON
14048
14049 #ifdef DEBUG
14050 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14051 #endif
14052
14053 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14054
14055 uint kernel_power_all = 0;
14056
14057 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14058 {
14059 /**
14060 * host buffer
14061 */
14062
14063 hc_device_param_t *device_param = &data.devices_param[device_id];
14064
14065 if (device_param->skipped) continue;
14066
14067 /**
14068 * device properties
14069 */
14070
14071 const char *device_name_chksum = device_param->device_name_chksum;
14072 const u32 device_processors = device_param->device_processors;
14073 const u32 device_processor_cores = device_param->device_processor_cores;
14074
14075 /**
14076 * create context for each device
14077 */
14078
14079 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14080
14081 /**
14082 * create command-queue
14083 */
14084
14085 // not supported with NV
14086 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14087
14088 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14089
14090 /**
14091 * kernel threads: some algorithms need a fixed kernel-threads count
14092 * because of shared memory usage or bitslice
14093 * there needs to be some upper limit, otherwise there's too much overhead
14094 */
14095
14096 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14097
14098 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14099 {
14100 kernel_threads = KERNEL_THREADS_MAX_CPU;
14101 }
14102
14103 if (hash_mode == 1500) kernel_threads = 64; // DES
14104 if (hash_mode == 3000) kernel_threads = 64; // DES
14105 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14106 if (hash_mode == 7500) kernel_threads = 64; // RC4
14107 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14108 if (hash_mode == 9700) kernel_threads = 64; // RC4
14109 if (hash_mode == 9710) kernel_threads = 64; // RC4
14110 if (hash_mode == 9800) kernel_threads = 64; // RC4
14111 if (hash_mode == 9810) kernel_threads = 64; // RC4
14112 if (hash_mode == 10400) kernel_threads = 64; // RC4
14113 if (hash_mode == 10410) kernel_threads = 64; // RC4
14114 if (hash_mode == 10500) kernel_threads = 64; // RC4
14115 if (hash_mode == 13100) kernel_threads = 64; // RC4
14116
14117 /**
14118 * create input buffers on device : calculate size of fixed memory buffers
14119 */
14120
14121 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14122 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14123
14124 device_param->size_root_css = size_root_css;
14125 device_param->size_markov_css = size_markov_css;
14126
14127 size_t size_results = sizeof (uint);
14128
14129 device_param->size_results = size_results;
14130
14131 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14132 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14133
14134 size_t size_plains = digests_cnt * sizeof (plain_t);
14135 size_t size_salts = salts_cnt * sizeof (salt_t);
14136 size_t size_esalts = salts_cnt * esalt_size;
14137
14138 device_param->size_plains = size_plains;
14139 device_param->size_digests = size_digests;
14140 device_param->size_shown = size_shown;
14141 device_param->size_salts = size_salts;
14142
14143 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14144 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14145 size_t size_tm = 32 * sizeof (bs_word_t);
14146
14147 // scryptV stuff
14148
14149 size_t size_scryptV = 1;
14150
14151 if ((hash_mode == 8900) || (hash_mode == 9300))
14152 {
14153 uint tmto_start = 0;
14154 uint tmto_stop = 10;
14155
14156 if (scrypt_tmto)
14157 {
14158 tmto_start = scrypt_tmto;
14159 }
14160 else
14161 {
14162 // in case the user did not specify the tmto manually
14163 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14164 // but set the lower end only in case the user has a device with too less memory
14165
14166 if (hash_mode == 8900)
14167 {
14168 if (device_param->vendor_id == VENDOR_ID_AMD)
14169 {
14170 tmto_start = 1;
14171 }
14172 else if (device_param->vendor_id == VENDOR_ID_NV)
14173 {
14174 tmto_start = 2;
14175 }
14176 }
14177 else if (hash_mode == 9300)
14178 {
14179 if (device_param->vendor_id == VENDOR_ID_AMD)
14180 {
14181 tmto_start = 2;
14182 }
14183 else if (device_param->vendor_id == VENDOR_ID_NV)
14184 {
14185 tmto_start = 2;
14186 }
14187 }
14188 }
14189
14190 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14191 {
14192 // TODO: in theory the following calculation needs to be done per salt, not global
14193 // we assume all hashes have the same scrypt settings
14194
14195 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14196
14197 size_scryptV /= 1 << tmto;
14198
14199 size_scryptV *= device_processors * device_processor_cores;
14200
14201 if (size_scryptV > device_param->device_maxmem_alloc)
14202 {
14203 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14204
14205 continue;
14206 }
14207
14208 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14209 {
14210 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14211 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14212 }
14213
14214 break;
14215 }
14216
14217 if (data.salts_buf[0].scrypt_phy == 0)
14218 {
14219 log_error ("ERROR: can't allocate enough device memory");
14220
14221 return -1;
14222 }
14223
14224 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14225 }
14226
14227 /**
14228 * some algorithms need a fixed kernel-loops count
14229 */
14230
14231 if (hash_mode == 1500)
14232 {
14233 const u32 kernel_loops_fixed = 1024;
14234
14235 device_param->kernel_loops_min = kernel_loops_fixed;
14236 device_param->kernel_loops_max = kernel_loops_fixed;
14237 }
14238
14239 if (hash_mode == 3000)
14240 {
14241 const u32 kernel_loops_fixed = 1024;
14242
14243 device_param->kernel_loops_min = kernel_loops_fixed;
14244 device_param->kernel_loops_max = kernel_loops_fixed;
14245 }
14246
14247 if (hash_mode == 8900)
14248 {
14249 const u32 kernel_loops_fixed = 1;
14250
14251 device_param->kernel_loops_min = kernel_loops_fixed;
14252 device_param->kernel_loops_max = kernel_loops_fixed;
14253 }
14254
14255 if (hash_mode == 9300)
14256 {
14257 const u32 kernel_loops_fixed = 1;
14258
14259 device_param->kernel_loops_min = kernel_loops_fixed;
14260 device_param->kernel_loops_max = kernel_loops_fixed;
14261 }
14262
14263 if (hash_mode == 12500)
14264 {
14265 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14266
14267 device_param->kernel_loops_min = kernel_loops_fixed;
14268 device_param->kernel_loops_max = kernel_loops_fixed;
14269 }
14270
14271 /**
14272 * some algorithms have a maximum kernel-loops count
14273 */
14274
14275 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14276 {
14277 u32 innerloop_cnt = 0;
14278
14279 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14280 {
14281 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14282 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14283 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14284 }
14285 else
14286 {
14287 innerloop_cnt = data.salts_buf[0].salt_iter;
14288 }
14289
14290 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14291 (innerloop_cnt <= device_param->kernel_loops_max))
14292 {
14293 device_param->kernel_loops_max = innerloop_cnt;
14294 }
14295 }
14296
14297 /**
14298 * some algorithms need a special kernel-accel
14299 */
14300
14301 if (hash_mode == 8900)
14302 {
14303 device_param->kernel_accel_min = 1;
14304 device_param->kernel_accel_max = 64;
14305 }
14306
14307 if (hash_mode == 9300)
14308 {
14309 device_param->kernel_accel_min = 1;
14310 device_param->kernel_accel_max = 64;
14311 }
14312
14313 u32 kernel_accel_min = device_param->kernel_accel_min;
14314 u32 kernel_accel_max = device_param->kernel_accel_max;
14315
14316 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14317
14318 size_t size_pws = 4;
14319 size_t size_tmps = 4;
14320 size_t size_hooks = 4;
14321
14322 while (kernel_accel_max >= kernel_accel_min)
14323 {
14324 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14325
14326 // size_pws
14327
14328 size_pws = kernel_power_max * sizeof (pw_t);
14329
14330 // size_tmps
14331
14332 switch (hash_mode)
14333 {
14334 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14335 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14336 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14337 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14338 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14339 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14340 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14341 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14342 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14343 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14344 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14345 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14346 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14347 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14348 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14349 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14350 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14351 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14352 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14353 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14354 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14355 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14356 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14357 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14358 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14359 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14360 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14361 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14362 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14363 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14364 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14365 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14366 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14367 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14368 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14369 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14370 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14371 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14372 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14373 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14374 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14375 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14376 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14377 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14378 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14379 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14380 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14381 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14382 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14383 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14384 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14385 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14386 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14387 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14388 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14389 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14390 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14391 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14392 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14393 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14394 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14395 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14396 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14397 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14398 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14399 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14400 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14401 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14402 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14403 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14404 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14405 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14406 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14407 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14408 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14409 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14410 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14411 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14412 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14413 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14414 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14415 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14416 };
14417
14418 // size_hooks
14419
14420 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14421 {
14422 // none yet
14423 }
14424
14425 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14426 // if not, decrease amplifier and try again
14427
14428 int skip = 0;
14429
14430 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14431 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14432 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14433
14434 if (( bitmap_size
14435 + bitmap_size
14436 + bitmap_size
14437 + bitmap_size
14438 + bitmap_size
14439 + bitmap_size
14440 + bitmap_size
14441 + bitmap_size
14442 + size_bfs
14443 + size_combs
14444 + size_digests
14445 + size_esalts
14446 + size_hooks
14447 + size_markov_css
14448 + size_plains
14449 + size_pws
14450 + size_pws // not a bug
14451 + size_results
14452 + size_root_css
14453 + size_rules
14454 + size_rules_c
14455 + size_salts
14456 + size_scryptV
14457 + size_shown
14458 + size_tm
14459 + size_tmps) > device_param->device_global_mem) skip = 1;
14460
14461 if (skip == 1)
14462 {
14463 kernel_accel_max--;
14464
14465 continue;
14466 }
14467
14468 break;
14469 }
14470
14471 /*
14472 if (kernel_accel_max == 0)
14473 {
14474 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14475
14476 return -1;
14477 }
14478 */
14479
14480 device_param->kernel_accel_min = kernel_accel_min;
14481 device_param->kernel_accel_max = kernel_accel_max;
14482
14483 /*
14484 if (kernel_accel_max < kernel_accel)
14485 {
14486 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14487
14488 device_param->kernel_accel = kernel_accel_max;
14489 }
14490 */
14491
14492 device_param->size_bfs = size_bfs;
14493 device_param->size_combs = size_combs;
14494 device_param->size_rules = size_rules;
14495 device_param->size_rules_c = size_rules_c;
14496 device_param->size_pws = size_pws;
14497 device_param->size_tmps = size_tmps;
14498 device_param->size_hooks = size_hooks;
14499
14500 // do not confuse kernel_accel_max with kernel_accel here
14501
14502 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14503
14504 device_param->kernel_threads = kernel_threads;
14505 device_param->kernel_power_user = kernel_power;
14506
14507 kernel_power_all += kernel_power;
14508
14509 /**
14510 * default building options
14511 */
14512
14513 char build_opts[1024] = { 0 };
14514
14515 // we don't have sm_* on vendors not NV but it doesn't matter
14516
14517 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);
14518
14519 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14520 {
14521 // we do vectorizing much better than the auto-vectorizer
14522
14523 char build_opts_new[1024] = { 0 };
14524
14525 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14526
14527 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14528 }
14529
14530 #ifdef DEBUG
14531 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14532 #endif
14533
14534 /**
14535 * main kernel
14536 */
14537
14538 {
14539 /**
14540 * kernel source filename
14541 */
14542
14543 char source_file[256] = { 0 };
14544
14545 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14546
14547 struct stat sst;
14548
14549 if (stat (source_file, &sst) == -1)
14550 {
14551 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14552
14553 return -1;
14554 }
14555
14556 /**
14557 * kernel cached filename
14558 */
14559
14560 char cached_file[256] = { 0 };
14561
14562 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14563
14564 int cached = 1;
14565
14566 struct stat cst;
14567
14568 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14569 {
14570 cached = 0;
14571 }
14572
14573 /**
14574 * kernel compile or load
14575 */
14576
14577 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14578
14579 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14580
14581 if (force_jit_compilation == -1)
14582 {
14583 if (cached == 0)
14584 {
14585 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14586
14587 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14588
14589 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14590
14591 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14592
14593 #ifdef DEBUG
14594 size_t build_log_size = 0;
14595
14596 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14597
14598 if (build_log_size > 1)
14599 {
14600 char *build_log = (char *) malloc (build_log_size + 1);
14601
14602 memset (build_log, 0, build_log_size + 1);
14603
14604 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14605
14606 puts (build_log);
14607
14608 free (build_log);
14609 }
14610 #endif
14611
14612 if (rc != 0)
14613 {
14614 device_param->skipped = true;
14615
14616 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14617
14618 continue;
14619 }
14620
14621 size_t binary_size;
14622
14623 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14624
14625 u8 *binary = (u8 *) mymalloc (binary_size);
14626
14627 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14628
14629 writeProgramBin (cached_file, binary, binary_size);
14630
14631 local_free (binary);
14632 }
14633 else
14634 {
14635 #ifdef DEBUG
14636 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14637 #endif
14638
14639 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14640
14641 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14642
14643 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14644 }
14645 }
14646 else
14647 {
14648 #ifdef DEBUG
14649 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14650 #endif
14651
14652 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14653
14654 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14655
14656 char build_opts_update[1024] = { 0 };
14657
14658 if (force_jit_compilation == 1500)
14659 {
14660 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14661 }
14662 else if (force_jit_compilation == 8900)
14663 {
14664 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);
14665 }
14666 else
14667 {
14668 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14669 }
14670
14671 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14672
14673 #ifdef DEBUG
14674 size_t build_log_size = 0;
14675
14676 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14677
14678 if (build_log_size > 1)
14679 {
14680 char *build_log = (char *) malloc (build_log_size + 1);
14681
14682 memset (build_log, 0, build_log_size + 1);
14683
14684 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14685
14686 puts (build_log);
14687
14688 free (build_log);
14689 }
14690 #endif
14691
14692 if (rc != 0)
14693 {
14694 device_param->skipped = true;
14695
14696 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14697 }
14698 }
14699
14700 local_free (kernel_lengths);
14701 local_free (kernel_sources[0]);
14702 local_free (kernel_sources);
14703 }
14704
14705 /**
14706 * word generator kernel
14707 */
14708
14709 if (attack_mode != ATTACK_MODE_STRAIGHT)
14710 {
14711 /**
14712 * kernel mp source filename
14713 */
14714
14715 char source_file[256] = { 0 };
14716
14717 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14718
14719 struct stat sst;
14720
14721 if (stat (source_file, &sst) == -1)
14722 {
14723 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14724
14725 return -1;
14726 }
14727
14728 /**
14729 * kernel mp cached filename
14730 */
14731
14732 char cached_file[256] = { 0 };
14733
14734 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14735
14736 int cached = 1;
14737
14738 struct stat cst;
14739
14740 if (stat (cached_file, &cst) == -1)
14741 {
14742 cached = 0;
14743 }
14744
14745 /**
14746 * kernel compile or load
14747 */
14748
14749 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14750
14751 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14752
14753 if (cached == 0)
14754 {
14755 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14756 if (quiet == 0) log_info ("");
14757
14758 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14759
14760 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14761
14762 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14763
14764 if (rc != 0)
14765 {
14766 device_param->skipped = true;
14767
14768 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14769
14770 continue;
14771 }
14772
14773 size_t binary_size;
14774
14775 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14776
14777 u8 *binary = (u8 *) mymalloc (binary_size);
14778
14779 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14780
14781 writeProgramBin (cached_file, binary, binary_size);
14782
14783 local_free (binary);
14784 }
14785 else
14786 {
14787 #ifdef DEBUG
14788 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14789 #endif
14790
14791 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14792
14793 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14794
14795 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14796 }
14797
14798 local_free (kernel_lengths);
14799 local_free (kernel_sources[0]);
14800 local_free (kernel_sources);
14801 }
14802
14803 /**
14804 * amplifier kernel
14805 */
14806
14807 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14808 {
14809
14810 }
14811 else
14812 {
14813 /**
14814 * kernel amp source filename
14815 */
14816
14817 char source_file[256] = { 0 };
14818
14819 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14820
14821 struct stat sst;
14822
14823 if (stat (source_file, &sst) == -1)
14824 {
14825 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14826
14827 return -1;
14828 }
14829
14830 /**
14831 * kernel amp cached filename
14832 */
14833
14834 char cached_file[256] = { 0 };
14835
14836 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14837
14838 int cached = 1;
14839
14840 struct stat cst;
14841
14842 if (stat (cached_file, &cst) == -1)
14843 {
14844 cached = 0;
14845 }
14846
14847 /**
14848 * kernel compile or load
14849 */
14850
14851 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14852
14853 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14854
14855 if (cached == 0)
14856 {
14857 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14858 if (quiet == 0) log_info ("");
14859
14860 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14861
14862 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14863
14864 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14865
14866 if (rc != 0)
14867 {
14868 device_param->skipped = true;
14869
14870 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14871
14872 continue;
14873 }
14874
14875 size_t binary_size;
14876
14877 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14878
14879 u8 *binary = (u8 *) mymalloc (binary_size);
14880
14881 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14882
14883 writeProgramBin (cached_file, binary, binary_size);
14884
14885 local_free (binary);
14886 }
14887 else
14888 {
14889 #ifdef DEBUG
14890 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14891 #endif
14892
14893 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14894
14895 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14896
14897 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14898 }
14899
14900 local_free (kernel_lengths);
14901 local_free (kernel_sources[0]);
14902 local_free (kernel_sources);
14903 }
14904
14905 // some algorithm collide too fast, make that impossible
14906
14907 if (benchmark == 1)
14908 {
14909 ((uint *) digests_buf)[0] = -1;
14910 ((uint *) digests_buf)[1] = -1;
14911 ((uint *) digests_buf)[2] = -1;
14912 ((uint *) digests_buf)[3] = -1;
14913 }
14914
14915 /**
14916 * global buffers
14917 */
14918
14919 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14920 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14921 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14922 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14923 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14924 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14925 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14926 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14927 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14928 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14929 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14930 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14931 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14932 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14933 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14934 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14935 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14936 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14937
14938 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);
14939 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);
14940 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);
14941 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);
14942 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);
14943 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);
14944 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);
14945 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);
14946 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14947 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14948 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14949
14950 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14951 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14952 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14953 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14954 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14955 run_kernel_bzero (device_param, device_param->d_result, size_results);
14956
14957 /**
14958 * special buffers
14959 */
14960
14961 if (attack_kern == ATTACK_KERN_STRAIGHT)
14962 {
14963 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14964 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14965
14966 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14967
14968 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14969 }
14970 else if (attack_kern == ATTACK_KERN_COMBI)
14971 {
14972 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14973 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14974 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14975 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14976
14977 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14978 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14979 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14980 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14981 }
14982 else if (attack_kern == ATTACK_KERN_BF)
14983 {
14984 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14985 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14986 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14987 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14988 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14989
14990 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14991 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14992 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14993 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14994 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14995 }
14996
14997 if (size_esalts)
14998 {
14999 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15000
15001 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15002 }
15003
15004 /**
15005 * main host data
15006 */
15007
15008 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15009
15010 device_param->pws_buf = pws_buf;
15011
15012 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15013
15014 device_param->combs_buf = combs_buf;
15015
15016 void *hooks_buf = mymalloc (size_hooks);
15017
15018 device_param->hooks_buf = hooks_buf;
15019
15020 /**
15021 * kernel args
15022 */
15023
15024 device_param->kernel_params_buf32[21] = bitmap_mask;
15025 device_param->kernel_params_buf32[22] = bitmap_shift1;
15026 device_param->kernel_params_buf32[23] = bitmap_shift2;
15027 device_param->kernel_params_buf32[24] = 0; // salt_pos
15028 device_param->kernel_params_buf32[25] = 0; // loop_pos
15029 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15030 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15031 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15032 device_param->kernel_params_buf32[29] = 0; // digests_offset
15033 device_param->kernel_params_buf32[30] = 0; // combs_mode
15034 device_param->kernel_params_buf32[31] = 0; // gid_max
15035
15036 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15037 ? &device_param->d_pws_buf
15038 : &device_param->d_pws_amp_buf;
15039 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15040 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15041 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15042 device_param->kernel_params[ 4] = &device_param->d_tmps;
15043 device_param->kernel_params[ 5] = &device_param->d_hooks;
15044 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15045 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15046 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15047 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15048 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15049 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15050 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15051 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15052 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15053 device_param->kernel_params[15] = &device_param->d_digests_buf;
15054 device_param->kernel_params[16] = &device_param->d_digests_shown;
15055 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15056 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15057 device_param->kernel_params[19] = &device_param->d_result;
15058 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15059 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15060 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15061 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15062 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15063 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15064 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15065 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15066 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15067 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15068 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15069 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15070
15071 device_param->kernel_params_mp_buf64[3] = 0;
15072 device_param->kernel_params_mp_buf32[4] = 0;
15073 device_param->kernel_params_mp_buf32[5] = 0;
15074 device_param->kernel_params_mp_buf32[6] = 0;
15075 device_param->kernel_params_mp_buf32[7] = 0;
15076 device_param->kernel_params_mp_buf32[8] = 0;
15077
15078 device_param->kernel_params_mp[0] = NULL;
15079 device_param->kernel_params_mp[1] = NULL;
15080 device_param->kernel_params_mp[2] = NULL;
15081 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15082 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15083 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15084 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15085 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15086 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15087
15088 device_param->kernel_params_mp_l_buf64[3] = 0;
15089 device_param->kernel_params_mp_l_buf32[4] = 0;
15090 device_param->kernel_params_mp_l_buf32[5] = 0;
15091 device_param->kernel_params_mp_l_buf32[6] = 0;
15092 device_param->kernel_params_mp_l_buf32[7] = 0;
15093 device_param->kernel_params_mp_l_buf32[8] = 0;
15094 device_param->kernel_params_mp_l_buf32[9] = 0;
15095
15096 device_param->kernel_params_mp_l[0] = NULL;
15097 device_param->kernel_params_mp_l[1] = NULL;
15098 device_param->kernel_params_mp_l[2] = NULL;
15099 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15100 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15101 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15102 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15103 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15104 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15105 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15106
15107 device_param->kernel_params_mp_r_buf64[3] = 0;
15108 device_param->kernel_params_mp_r_buf32[4] = 0;
15109 device_param->kernel_params_mp_r_buf32[5] = 0;
15110 device_param->kernel_params_mp_r_buf32[6] = 0;
15111 device_param->kernel_params_mp_r_buf32[7] = 0;
15112 device_param->kernel_params_mp_r_buf32[8] = 0;
15113
15114 device_param->kernel_params_mp_r[0] = NULL;
15115 device_param->kernel_params_mp_r[1] = NULL;
15116 device_param->kernel_params_mp_r[2] = NULL;
15117 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15118 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15119 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15120 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15121 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15122 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15123
15124 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15125 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15126
15127 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15128 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15129 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15130 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15131 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15132 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15133 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15134
15135 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15136 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15137
15138 /**
15139 * kernel name
15140 */
15141
15142 size_t kernel_wgs_tmp;
15143
15144 char kernel_name[64] = { 0 };
15145
15146 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15147 {
15148 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15149 {
15150 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15151
15152 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15153
15154 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15155
15156 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15157
15158 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15159
15160 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15161 }
15162 else
15163 {
15164 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15165
15166 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15167
15168 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15169
15170 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15171
15172 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15173
15174 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15175 }
15176
15177 if (data.attack_mode == ATTACK_MODE_BF)
15178 {
15179 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15180 {
15181 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15182
15183 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15184
15185 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);
15186 }
15187 }
15188 }
15189 else
15190 {
15191 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15192
15193 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15194
15195 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15196
15197 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15198
15199 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15200
15201 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15202
15203 if (opts_type & OPTS_TYPE_HOOK12)
15204 {
15205 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15206
15207 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15208
15209 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);
15210 }
15211
15212 if (opts_type & OPTS_TYPE_HOOK23)
15213 {
15214 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15215
15216 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15217
15218 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);
15219 }
15220 }
15221
15222 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);
15223 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);
15224 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);
15225
15226 for (uint i = 0; i <= 20; i++)
15227 {
15228 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15229 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15230 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15231
15232 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15233 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15234 }
15235
15236 for (uint i = 21; i <= 31; i++)
15237 {
15238 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15239 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15240 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15241
15242 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15243 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15244 }
15245
15246 if (attack_mode == ATTACK_MODE_BF)
15247 {
15248 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15249 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15250
15251 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);
15252 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);
15253
15254 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15255 {
15256 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15257 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15258 }
15259 }
15260 else if (attack_mode == ATTACK_MODE_HYBRID1)
15261 {
15262 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15263
15264 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);
15265 }
15266 else if (attack_mode == ATTACK_MODE_HYBRID2)
15267 {
15268 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15269
15270 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);
15271 }
15272
15273 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15274 {
15275 // nothing to do
15276 }
15277 else
15278 {
15279 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15280
15281 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);
15282 }
15283
15284 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15285 {
15286 // nothing to do
15287 }
15288 else
15289 {
15290 for (uint i = 0; i < 5; i++)
15291 {
15292 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15293 }
15294
15295 for (uint i = 5; i < 7; i++)
15296 {
15297 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15298 }
15299 }
15300
15301 // maybe this has been updated by clGetKernelWorkGroupInfo()
15302 // value can only be decreased, so we don't need to reallocate buffers
15303
15304 device_param->kernel_threads = kernel_threads;
15305
15306 /**
15307 * Store initial fanspeed if gpu_temp_retain is enabled
15308 */
15309
15310 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15311 int gpu_temp_retain_set = 0;
15312
15313 if (gpu_temp_disable == 0)
15314 {
15315 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15316 {
15317 hc_thread_mutex_lock (mux_adl);
15318
15319 if (data.hm_device[device_id].fan_supported == 1)
15320 {
15321 if (gpu_temp_retain_chgd == 0)
15322 {
15323 uint cur_temp = 0;
15324 uint default_temp = 0;
15325
15326 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);
15327
15328 if (ADL_rc == ADL_OK)
15329 {
15330 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15331
15332 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15333
15334 // special case with multi gpu setups: always use minimum retain
15335
15336 if (gpu_temp_retain_set == 0)
15337 {
15338 gpu_temp_retain = gpu_temp_retain_target;
15339 gpu_temp_retain_set = 1;
15340 }
15341 else
15342 {
15343 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15344 }
15345
15346 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15347 }
15348 }
15349
15350 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15351
15352 temp_retain_fanspeed_value[device_id] = fan_speed;
15353
15354 if (fan_speed == -1)
15355 {
15356 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15357
15358 temp_retain_fanspeed_value[device_id] = 0;
15359 }
15360 }
15361
15362 hc_thread_mutex_unlock (mux_adl);
15363 }
15364 }
15365
15366 /**
15367 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15368 */
15369
15370 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15371 {
15372 hc_thread_mutex_lock (mux_adl);
15373
15374 if (data.hm_device[device_id].od_version == 6)
15375 {
15376 int ADL_rc;
15377
15378 // check powertune capabilities first, if not available then skip device
15379
15380 int powertune_supported = 0;
15381
15382 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15383 {
15384 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15385
15386 return (-1);
15387 }
15388
15389 if (powertune_supported != 0)
15390 {
15391 // powercontrol settings
15392
15393 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15394
15395 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15396 {
15397 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15398 }
15399
15400 if (ADL_rc != ADL_OK)
15401 {
15402 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15403
15404 return (-1);
15405 }
15406
15407 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15408 {
15409 log_error ("ERROR: Failed to set new ADL PowerControl values");
15410
15411 return (-1);
15412 }
15413
15414 // clocks
15415
15416 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15417
15418 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15419
15420 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)
15421 {
15422 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15423
15424 return (-1);
15425 }
15426
15427 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15428
15429 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15430
15431 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15432 {
15433 log_error ("ERROR: Failed to get ADL device capabilities");
15434
15435 return (-1);
15436 }
15437
15438 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15439 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15440
15441 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15442 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15443
15444 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15445 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15446
15447 // warning if profile has too low max values
15448
15449 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15450 {
15451 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15452 }
15453
15454 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15455 {
15456 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15457 }
15458
15459 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15460
15461 performance_state->iNumberOfPerformanceLevels = 2;
15462
15463 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15464 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15465 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15466 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15467
15468 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)
15469 {
15470 log_info ("ERROR: Failed to set ADL performance state");
15471
15472 return (-1);
15473 }
15474
15475 local_free (performance_state);
15476 }
15477 }
15478
15479 hc_thread_mutex_unlock (mux_adl);
15480 }
15481 #endif // HAVE_HWMON && HAVE_ADL
15482 }
15483
15484 data.kernel_power_all = kernel_power_all;
15485
15486 if (data.quiet == 0) log_info_nn ("");
15487
15488 /**
15489 * In benchmark-mode, inform user which algorithm is checked
15490 */
15491
15492 if (benchmark == 1)
15493 {
15494 if (status_automat == 0)
15495 {
15496 quiet = 0;
15497
15498 data.quiet = quiet;
15499
15500 char *hash_type = strhashtype (data.hash_mode); // not a bug
15501
15502 log_info ("Hashtype: %s", hash_type);
15503 log_info ("");
15504 }
15505 }
15506
15507 /**
15508 * keep track of the progress
15509 */
15510
15511 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15512 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15513 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15514
15515 /**
15516 * open filehandles
15517 */
15518
15519 #if _WIN
15520 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15521 {
15522 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15523
15524 return (-1);
15525 }
15526
15527 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15528 {
15529 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15530
15531 return (-1);
15532 }
15533
15534 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15535 {
15536 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15537
15538 return (-1);
15539 }
15540 #endif
15541
15542 /**
15543 * dictionary pad
15544 */
15545
15546 segment_size *= (1024 * 1024);
15547
15548 data.segment_size = segment_size;
15549
15550 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15551
15552 wl_data->buf = (char *) mymalloc (segment_size);
15553 wl_data->avail = segment_size;
15554 wl_data->incr = segment_size;
15555 wl_data->cnt = 0;
15556 wl_data->pos = 0;
15557
15558 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15559
15560 data.wordlist_mode = wordlist_mode;
15561
15562 cs_t *css_buf = NULL;
15563 uint css_cnt = 0;
15564 uint dictcnt = 0;
15565 uint maskcnt = 1;
15566 char **masks = NULL;
15567 char **dictfiles = NULL;
15568
15569 uint mask_from_file = 0;
15570
15571 if (attack_mode == ATTACK_MODE_STRAIGHT)
15572 {
15573 if (wordlist_mode == WL_MODE_FILE)
15574 {
15575 int wls_left = myargc - (optind + 1);
15576
15577 for (int i = 0; i < wls_left; i++)
15578 {
15579 char *l0_filename = myargv[optind + 1 + i];
15580
15581 struct stat l0_stat;
15582
15583 if (stat (l0_filename, &l0_stat) == -1)
15584 {
15585 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15586
15587 return (-1);
15588 }
15589
15590 uint is_dir = S_ISDIR (l0_stat.st_mode);
15591
15592 if (is_dir == 0)
15593 {
15594 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15595
15596 dictcnt++;
15597
15598 dictfiles[dictcnt - 1] = l0_filename;
15599 }
15600 else
15601 {
15602 // do not allow --keyspace w/ a directory
15603
15604 if (keyspace == 1)
15605 {
15606 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15607
15608 return (-1);
15609 }
15610
15611 char **dictionary_files = NULL;
15612
15613 dictionary_files = scan_directory (l0_filename);
15614
15615 if (dictionary_files != NULL)
15616 {
15617 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15618
15619 for (int d = 0; dictionary_files[d] != NULL; d++)
15620 {
15621 char *l1_filename = dictionary_files[d];
15622
15623 struct stat l1_stat;
15624
15625 if (stat (l1_filename, &l1_stat) == -1)
15626 {
15627 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15628
15629 return (-1);
15630 }
15631
15632 if (S_ISREG (l1_stat.st_mode))
15633 {
15634 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15635
15636 dictcnt++;
15637
15638 dictfiles[dictcnt - 1] = strdup (l1_filename);
15639 }
15640 }
15641 }
15642
15643 local_free (dictionary_files);
15644 }
15645 }
15646
15647 if (dictcnt < 1)
15648 {
15649 log_error ("ERROR: No usable dictionary file found.");
15650
15651 return (-1);
15652 }
15653 }
15654 else if (wordlist_mode == WL_MODE_STDIN)
15655 {
15656 dictcnt = 1;
15657 }
15658 }
15659 else if (attack_mode == ATTACK_MODE_COMBI)
15660 {
15661 // display
15662
15663 char *dictfile1 = myargv[optind + 1 + 0];
15664 char *dictfile2 = myargv[optind + 1 + 1];
15665
15666 // find the bigger dictionary and use as base
15667
15668 FILE *fp1 = NULL;
15669 FILE *fp2 = NULL;
15670
15671 struct stat tmp_stat;
15672
15673 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15674 {
15675 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15676
15677 return (-1);
15678 }
15679
15680 if (stat (dictfile1, &tmp_stat) == -1)
15681 {
15682 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15683
15684 fclose (fp1);
15685
15686 return (-1);
15687 }
15688
15689 if (S_ISDIR (tmp_stat.st_mode))
15690 {
15691 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15692
15693 fclose (fp1);
15694
15695 return (-1);
15696 }
15697
15698 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15699 {
15700 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15701
15702 fclose (fp1);
15703
15704 return (-1);
15705 }
15706
15707 if (stat (dictfile2, &tmp_stat) == -1)
15708 {
15709 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15710
15711 fclose (fp1);
15712 fclose (fp2);
15713
15714 return (-1);
15715 }
15716
15717 if (S_ISDIR (tmp_stat.st_mode))
15718 {
15719 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15720
15721 fclose (fp1);
15722 fclose (fp2);
15723
15724 return (-1);
15725 }
15726
15727 data.combs_cnt = 1;
15728
15729 data.quiet = 1;
15730
15731 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15732
15733 data.quiet = quiet;
15734
15735 if (words1_cnt == 0)
15736 {
15737 log_error ("ERROR: %s: empty file", dictfile1);
15738
15739 fclose (fp1);
15740 fclose (fp2);
15741
15742 return (-1);
15743 }
15744
15745 data.combs_cnt = 1;
15746
15747 data.quiet = 1;
15748
15749 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15750
15751 data.quiet = quiet;
15752
15753 if (words2_cnt == 0)
15754 {
15755 log_error ("ERROR: %s: empty file", dictfile2);
15756
15757 fclose (fp1);
15758 fclose (fp2);
15759
15760 return (-1);
15761 }
15762
15763 fclose (fp1);
15764 fclose (fp2);
15765
15766 data.dictfile = dictfile1;
15767 data.dictfile2 = dictfile2;
15768
15769 if (words1_cnt >= words2_cnt)
15770 {
15771 data.combs_cnt = words2_cnt;
15772 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15773
15774 dictfiles = &data.dictfile;
15775
15776 dictcnt = 1;
15777 }
15778 else
15779 {
15780 data.combs_cnt = words1_cnt;
15781 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15782
15783 dictfiles = &data.dictfile2;
15784
15785 dictcnt = 1;
15786
15787 // we also have to switch wordlist related rules!
15788
15789 char *tmpc = data.rule_buf_l;
15790
15791 data.rule_buf_l = data.rule_buf_r;
15792 data.rule_buf_r = tmpc;
15793
15794 int tmpi = data.rule_len_l;
15795
15796 data.rule_len_l = data.rule_len_r;
15797 data.rule_len_r = tmpi;
15798 }
15799 }
15800 else if (attack_mode == ATTACK_MODE_BF)
15801 {
15802 char *mask = NULL;
15803
15804 maskcnt = 0;
15805
15806 if (benchmark == 0)
15807 {
15808 mask = myargv[optind + 1];
15809
15810 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15811
15812 if ((optind + 2) <= myargc)
15813 {
15814 struct stat file_stat;
15815
15816 if (stat (mask, &file_stat) == -1)
15817 {
15818 maskcnt = 1;
15819
15820 masks[maskcnt - 1] = mystrdup (mask);
15821 }
15822 else
15823 {
15824 int wls_left = myargc - (optind + 1);
15825
15826 uint masks_avail = INCR_MASKS;
15827
15828 for (int i = 0; i < wls_left; i++)
15829 {
15830 if (i != 0)
15831 {
15832 mask = myargv[optind + 1 + i];
15833
15834 if (stat (mask, &file_stat) == -1)
15835 {
15836 log_error ("ERROR: %s: %s", mask, strerror (errno));
15837
15838 return (-1);
15839 }
15840 }
15841
15842 uint is_file = S_ISREG (file_stat.st_mode);
15843
15844 if (is_file == 1)
15845 {
15846 FILE *mask_fp;
15847
15848 if ((mask_fp = fopen (mask, "r")) == NULL)
15849 {
15850 log_error ("ERROR: %s: %s", mask, strerror (errno));
15851
15852 return (-1);
15853 }
15854
15855 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15856
15857 while (!feof (mask_fp))
15858 {
15859 memset (line_buf, 0, HCBUFSIZ);
15860
15861 int line_len = fgetl (mask_fp, line_buf);
15862
15863 if (line_len == 0) continue;
15864
15865 if (line_buf[0] == '#') continue;
15866
15867 if (masks_avail == maskcnt)
15868 {
15869 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15870
15871 masks_avail += INCR_MASKS;
15872 }
15873
15874 masks[maskcnt] = mystrdup (line_buf);
15875
15876 maskcnt++;
15877 }
15878
15879 myfree (line_buf);
15880
15881 fclose (mask_fp);
15882 }
15883 else
15884 {
15885 log_error ("ERROR: %s: unsupported file-type", mask);
15886
15887 return (-1);
15888 }
15889 }
15890
15891 mask_from_file = 1;
15892 }
15893 }
15894 else
15895 {
15896 custom_charset_1 = (char *) "?l?d?u";
15897 custom_charset_2 = (char *) "?l?d";
15898 custom_charset_3 = (char *) "?l?d*!$@_";
15899
15900 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15901 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15902 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15903
15904 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15905
15906 wordlist_mode = WL_MODE_MASK;
15907
15908 data.wordlist_mode = wordlist_mode;
15909
15910 increment = 1;
15911
15912 maskcnt = 1;
15913 }
15914 }
15915 else
15916 {
15917 /**
15918 * generate full masks and charsets
15919 */
15920
15921 masks = (char **) mymalloc (sizeof (char *));
15922
15923 switch (hash_mode)
15924 {
15925 case 1731: pw_min = 5;
15926 pw_max = 5;
15927 mask = mystrdup ("?b?b?b?b?b");
15928 break;
15929 case 12500: pw_min = 5;
15930 pw_max = 5;
15931 mask = mystrdup ("?b?b?b?b?b");
15932 break;
15933 default: pw_min = 7;
15934 pw_max = 7;
15935 mask = mystrdup ("?b?b?b?b?b?b?b");
15936 break;
15937 }
15938
15939 maskcnt = 1;
15940
15941 masks[maskcnt - 1] = mystrdup (mask);
15942
15943 wordlist_mode = WL_MODE_MASK;
15944
15945 data.wordlist_mode = wordlist_mode;
15946
15947 increment = 1;
15948 }
15949
15950 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15951
15952 if (increment)
15953 {
15954 if (increment_min > pw_min) pw_min = increment_min;
15955
15956 if (increment_max < pw_max) pw_max = increment_max;
15957 }
15958 }
15959 else if (attack_mode == ATTACK_MODE_HYBRID1)
15960 {
15961 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15962
15963 // display
15964
15965 char *mask = myargv[myargc - 1];
15966
15967 maskcnt = 0;
15968
15969 masks = (char **) mymalloc (1 * sizeof (char *));
15970
15971 // mod
15972
15973 struct stat file_stat;
15974
15975 if (stat (mask, &file_stat) == -1)
15976 {
15977 maskcnt = 1;
15978
15979 masks[maskcnt - 1] = mystrdup (mask);
15980 }
15981 else
15982 {
15983 uint is_file = S_ISREG (file_stat.st_mode);
15984
15985 if (is_file == 1)
15986 {
15987 FILE *mask_fp;
15988
15989 if ((mask_fp = fopen (mask, "r")) == NULL)
15990 {
15991 log_error ("ERROR: %s: %s", mask, strerror (errno));
15992
15993 return (-1);
15994 }
15995
15996 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15997
15998 uint masks_avail = 1;
15999
16000 while (!feof (mask_fp))
16001 {
16002 memset (line_buf, 0, HCBUFSIZ);
16003
16004 int line_len = fgetl (mask_fp, line_buf);
16005
16006 if (line_len == 0) continue;
16007
16008 if (line_buf[0] == '#') continue;
16009
16010 if (masks_avail == maskcnt)
16011 {
16012 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16013
16014 masks_avail += INCR_MASKS;
16015 }
16016
16017 masks[maskcnt] = mystrdup (line_buf);
16018
16019 maskcnt++;
16020 }
16021
16022 myfree (line_buf);
16023
16024 fclose (mask_fp);
16025
16026 mask_from_file = 1;
16027 }
16028 else
16029 {
16030 maskcnt = 1;
16031
16032 masks[maskcnt - 1] = mystrdup (mask);
16033 }
16034 }
16035
16036 // base
16037
16038 int wls_left = myargc - (optind + 2);
16039
16040 for (int i = 0; i < wls_left; i++)
16041 {
16042 char *filename = myargv[optind + 1 + i];
16043
16044 struct stat file_stat;
16045
16046 if (stat (filename, &file_stat) == -1)
16047 {
16048 log_error ("ERROR: %s: %s", filename, strerror (errno));
16049
16050 return (-1);
16051 }
16052
16053 uint is_dir = S_ISDIR (file_stat.st_mode);
16054
16055 if (is_dir == 0)
16056 {
16057 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16058
16059 dictcnt++;
16060
16061 dictfiles[dictcnt - 1] = filename;
16062 }
16063 else
16064 {
16065 // do not allow --keyspace w/ a directory
16066
16067 if (keyspace == 1)
16068 {
16069 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16070
16071 return (-1);
16072 }
16073
16074 char **dictionary_files = NULL;
16075
16076 dictionary_files = scan_directory (filename);
16077
16078 if (dictionary_files != NULL)
16079 {
16080 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16081
16082 for (int d = 0; dictionary_files[d] != NULL; d++)
16083 {
16084 char *l1_filename = dictionary_files[d];
16085
16086 struct stat l1_stat;
16087
16088 if (stat (l1_filename, &l1_stat) == -1)
16089 {
16090 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16091
16092 return (-1);
16093 }
16094
16095 if (S_ISREG (l1_stat.st_mode))
16096 {
16097 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16098
16099 dictcnt++;
16100
16101 dictfiles[dictcnt - 1] = strdup (l1_filename);
16102 }
16103 }
16104 }
16105
16106 local_free (dictionary_files);
16107 }
16108 }
16109
16110 if (dictcnt < 1)
16111 {
16112 log_error ("ERROR: No usable dictionary file found.");
16113
16114 return (-1);
16115 }
16116
16117 if (increment)
16118 {
16119 maskcnt = 0;
16120
16121 uint mask_min = increment_min; // we can't reject smaller masks here
16122 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16123
16124 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16125 {
16126 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16127
16128 if (cur_mask == NULL) break;
16129
16130 masks[maskcnt] = cur_mask;
16131
16132 maskcnt++;
16133
16134 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16135 }
16136 }
16137 }
16138 else if (attack_mode == ATTACK_MODE_HYBRID2)
16139 {
16140 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16141
16142 // display
16143
16144 char *mask = myargv[optind + 1 + 0];
16145
16146 maskcnt = 0;
16147
16148 masks = (char **) mymalloc (1 * sizeof (char *));
16149
16150 // mod
16151
16152 struct stat file_stat;
16153
16154 if (stat (mask, &file_stat) == -1)
16155 {
16156 maskcnt = 1;
16157
16158 masks[maskcnt - 1] = mystrdup (mask);
16159 }
16160 else
16161 {
16162 uint is_file = S_ISREG (file_stat.st_mode);
16163
16164 if (is_file == 1)
16165 {
16166 FILE *mask_fp;
16167
16168 if ((mask_fp = fopen (mask, "r")) == NULL)
16169 {
16170 log_error ("ERROR: %s: %s", mask, strerror (errno));
16171
16172 return (-1);
16173 }
16174
16175 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16176
16177 uint masks_avail = 1;
16178
16179 while (!feof (mask_fp))
16180 {
16181 memset (line_buf, 0, HCBUFSIZ);
16182
16183 int line_len = fgetl (mask_fp, line_buf);
16184
16185 if (line_len == 0) continue;
16186
16187 if (line_buf[0] == '#') continue;
16188
16189 if (masks_avail == maskcnt)
16190 {
16191 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16192
16193 masks_avail += INCR_MASKS;
16194 }
16195
16196 masks[maskcnt] = mystrdup (line_buf);
16197
16198 maskcnt++;
16199 }
16200
16201 myfree (line_buf);
16202
16203 fclose (mask_fp);
16204
16205 mask_from_file = 1;
16206 }
16207 else
16208 {
16209 maskcnt = 1;
16210
16211 masks[maskcnt - 1] = mystrdup (mask);
16212 }
16213 }
16214
16215 // base
16216
16217 int wls_left = myargc - (optind + 2);
16218
16219 for (int i = 0; i < wls_left; i++)
16220 {
16221 char *filename = myargv[optind + 2 + i];
16222
16223 struct stat file_stat;
16224
16225 if (stat (filename, &file_stat) == -1)
16226 {
16227 log_error ("ERROR: %s: %s", filename, strerror (errno));
16228
16229 return (-1);
16230 }
16231
16232 uint is_dir = S_ISDIR (file_stat.st_mode);
16233
16234 if (is_dir == 0)
16235 {
16236 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16237
16238 dictcnt++;
16239
16240 dictfiles[dictcnt - 1] = filename;
16241 }
16242 else
16243 {
16244 // do not allow --keyspace w/ a directory
16245
16246 if (keyspace == 1)
16247 {
16248 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16249
16250 return (-1);
16251 }
16252
16253 char **dictionary_files = NULL;
16254
16255 dictionary_files = scan_directory (filename);
16256
16257 if (dictionary_files != NULL)
16258 {
16259 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16260
16261 for (int d = 0; dictionary_files[d] != NULL; d++)
16262 {
16263 char *l1_filename = dictionary_files[d];
16264
16265 struct stat l1_stat;
16266
16267 if (stat (l1_filename, &l1_stat) == -1)
16268 {
16269 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16270
16271 return (-1);
16272 }
16273
16274 if (S_ISREG (l1_stat.st_mode))
16275 {
16276 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16277
16278 dictcnt++;
16279
16280 dictfiles[dictcnt - 1] = strdup (l1_filename);
16281 }
16282 }
16283 }
16284
16285 local_free (dictionary_files);
16286 }
16287 }
16288
16289 if (dictcnt < 1)
16290 {
16291 log_error ("ERROR: No usable dictionary file found.");
16292
16293 return (-1);
16294 }
16295
16296 if (increment)
16297 {
16298 maskcnt = 0;
16299
16300 uint mask_min = increment_min; // we can't reject smaller masks here
16301 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16302
16303 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16304 {
16305 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16306
16307 if (cur_mask == NULL) break;
16308
16309 masks[maskcnt] = cur_mask;
16310
16311 maskcnt++;
16312
16313 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16314 }
16315 }
16316 }
16317
16318 data.pw_min = pw_min;
16319 data.pw_max = pw_max;
16320
16321 /**
16322 * weak hash check
16323 */
16324
16325 if (weak_hash_threshold >= salts_cnt)
16326 {
16327 hc_device_param_t *device_param = NULL;
16328
16329 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16330 {
16331 device_param = &data.devices_param[device_id];
16332
16333 if (device_param->skipped) continue;
16334
16335 break;
16336 }
16337
16338 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16339
16340 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16341 {
16342 weak_hash_check (device_param, salt_pos);
16343 }
16344
16345 // Display hack, guarantee that there is at least one \r before real start
16346
16347 //if (data.quiet == 0) log_info ("");
16348 }
16349
16350 /**
16351 * status and monitor threads
16352 */
16353
16354 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16355
16356 hc_thread_t i_thread = 0;
16357
16358 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16359 {
16360 hc_thread_create (i_thread, thread_keypress, &benchmark);
16361 }
16362
16363 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16364
16365 uint ni_threads_cnt = 0;
16366
16367 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16368
16369 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16370
16371 ni_threads_cnt++;
16372
16373 /**
16374 * Outfile remove
16375 */
16376
16377 if (keyspace == 0)
16378 {
16379 if (outfile_check_timer != 0)
16380 {
16381 if (data.outfile_check_directory != NULL)
16382 {
16383 if ((hash_mode != 5200) &&
16384 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16385 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16386 (hash_mode != 9000))
16387 {
16388 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16389
16390 ni_threads_cnt++;
16391 }
16392 else
16393 {
16394 outfile_check_timer = 0;
16395 }
16396 }
16397 else
16398 {
16399 outfile_check_timer = 0;
16400 }
16401 }
16402 }
16403
16404 /**
16405 * Inform the user if we got some hashes remove because of the pot file remove feature
16406 */
16407
16408 if (data.quiet == 0)
16409 {
16410 if (potfile_remove_cracks > 0)
16411 {
16412 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16413 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16414 }
16415 }
16416
16417 data.outfile_check_timer = outfile_check_timer;
16418
16419 /**
16420 * main loop
16421 */
16422
16423 char **induction_dictionaries = NULL;
16424
16425 int induction_dictionaries_cnt = 0;
16426
16427 hcstat_table_t *root_table_buf = NULL;
16428 hcstat_table_t *markov_table_buf = NULL;
16429
16430 uint initial_restore_done = 0;
16431
16432 data.maskcnt = maskcnt;
16433
16434 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16435 {
16436 if (data.devices_status == STATUS_CRACKED) break;
16437
16438 data.devices_status = STATUS_INIT;
16439
16440 if (maskpos > rd->maskpos)
16441 {
16442 rd->dictpos = 0;
16443 }
16444
16445 rd->maskpos = maskpos;
16446 data.maskpos = maskpos;
16447
16448 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16449 {
16450 char *mask = masks[maskpos];
16451
16452 if (mask_from_file == 1)
16453 {
16454 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16455
16456 char *str_ptr;
16457 uint str_pos;
16458
16459 uint mask_offset = 0;
16460
16461 uint separator_cnt;
16462
16463 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16464 {
16465 str_ptr = strstr (mask + mask_offset, ",");
16466
16467 if (str_ptr == NULL) break;
16468
16469 str_pos = str_ptr - mask;
16470
16471 // escaped separator, i.e. "\,"
16472
16473 if (str_pos > 0)
16474 {
16475 if (mask[str_pos - 1] == '\\')
16476 {
16477 separator_cnt --;
16478
16479 mask_offset = str_pos + 1;
16480
16481 continue;
16482 }
16483 }
16484
16485 // reset the offset
16486
16487 mask_offset = 0;
16488
16489 mask[str_pos] = '\0';
16490
16491 switch (separator_cnt)
16492 {
16493 case 0:
16494 mp_reset_usr (mp_usr, 0);
16495
16496 custom_charset_1 = mask;
16497 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16498 break;
16499
16500 case 1:
16501 mp_reset_usr (mp_usr, 1);
16502
16503 custom_charset_2 = mask;
16504 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16505 break;
16506
16507 case 2:
16508 mp_reset_usr (mp_usr, 2);
16509
16510 custom_charset_3 = mask;
16511 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16512 break;
16513
16514 case 3:
16515 mp_reset_usr (mp_usr, 3);
16516
16517 custom_charset_4 = mask;
16518 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16519 break;
16520 }
16521
16522 mask = mask + str_pos + 1;
16523 }
16524 }
16525
16526 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16527 {
16528 if (maskpos > 0)
16529 {
16530 local_free (css_buf);
16531 local_free (data.root_css_buf);
16532 local_free (data.markov_css_buf);
16533
16534 local_free (masks[maskpos - 1]);
16535 }
16536
16537 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16538
16539 data.mask = mask;
16540 data.css_cnt = css_cnt;
16541 data.css_buf = css_buf;
16542
16543 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16544
16545 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16546
16547 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16548 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16549
16550 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16551
16552 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16553
16554 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16555 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16556
16557 data.root_css_buf = root_css_buf;
16558 data.markov_css_buf = markov_css_buf;
16559
16560 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16561
16562 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16563
16564 local_free (root_table_buf);
16565 local_free (markov_table_buf);
16566
16567 // args
16568
16569 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16570 {
16571 hc_device_param_t *device_param = &data.devices_param[device_id];
16572
16573 if (device_param->skipped) continue;
16574
16575 device_param->kernel_params_mp[0] = &device_param->d_combs;
16576 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16577 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16578
16579 device_param->kernel_params_mp_buf64[3] = 0;
16580 device_param->kernel_params_mp_buf32[4] = css_cnt;
16581 device_param->kernel_params_mp_buf32[5] = 0;
16582 device_param->kernel_params_mp_buf32[6] = 0;
16583 device_param->kernel_params_mp_buf32[7] = 0;
16584
16585 if (attack_mode == ATTACK_MODE_HYBRID1)
16586 {
16587 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16588 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16589 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16590 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16591 }
16592 else if (attack_mode == ATTACK_MODE_HYBRID2)
16593 {
16594 device_param->kernel_params_mp_buf32[5] = 0;
16595 device_param->kernel_params_mp_buf32[6] = 0;
16596 device_param->kernel_params_mp_buf32[7] = 0;
16597 }
16598
16599 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]);
16600 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]);
16601 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]);
16602
16603 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);
16604 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);
16605 }
16606 }
16607 else if (attack_mode == ATTACK_MODE_BF)
16608 {
16609 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16610
16611 if (increment)
16612 {
16613 for (uint i = 0; i < dictcnt; i++)
16614 {
16615 local_free (dictfiles[i]);
16616 }
16617
16618 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16619 {
16620 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16621
16622 if (l1_filename == NULL) break;
16623
16624 dictcnt++;
16625
16626 dictfiles[dictcnt - 1] = l1_filename;
16627 }
16628 }
16629 else
16630 {
16631 dictcnt++;
16632
16633 dictfiles[dictcnt - 1] = mask;
16634 }
16635
16636 if (dictcnt == 0)
16637 {
16638 log_error ("ERROR: Mask is too small");
16639
16640 return (-1);
16641 }
16642 }
16643 }
16644
16645 free (induction_dictionaries);
16646
16647 // induction_dictionaries_cnt = 0; // implied
16648
16649 if (attack_mode != ATTACK_MODE_BF)
16650 {
16651 if (keyspace == 0)
16652 {
16653 induction_dictionaries = scan_directory (induction_directory);
16654
16655 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16656 }
16657 }
16658
16659 if (induction_dictionaries_cnt)
16660 {
16661 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16662 }
16663
16664 /**
16665 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16666 */
16667 if (keyspace == 1)
16668 {
16669 if ((maskcnt > 1) || (dictcnt > 1))
16670 {
16671 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16672
16673 return (-1);
16674 }
16675 }
16676
16677 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16678 {
16679 char *subid = logfile_generate_subid ();
16680
16681 data.subid = subid;
16682
16683 logfile_sub_msg ("START");
16684
16685 data.devices_status = STATUS_INIT;
16686
16687 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16688 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16689 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16690
16691 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16692
16693 data.cpt_pos = 0;
16694
16695 data.cpt_start = time (NULL);
16696
16697 data.cpt_total = 0;
16698
16699 if (data.restore == 0)
16700 {
16701 rd->words_cur = skip;
16702
16703 skip = 0;
16704
16705 data.skip = 0;
16706 }
16707
16708 data.ms_paused = 0;
16709
16710 data.words_cur = rd->words_cur;
16711
16712 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16713 {
16714 hc_device_param_t *device_param = &data.devices_param[device_id];
16715
16716 if (device_param->skipped) continue;
16717
16718 device_param->speed_pos = 0;
16719
16720 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16721 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16722
16723 device_param->exec_pos = 0;
16724
16725 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16726
16727 device_param->kernel_power = device_param->kernel_power_user;
16728
16729 device_param->outerloop_pos = 0;
16730 device_param->outerloop_left = 0;
16731 device_param->innerloop_pos = 0;
16732 device_param->innerloop_left = 0;
16733
16734 // some more resets:
16735
16736 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16737
16738 device_param->pws_cnt = 0;
16739
16740 device_param->words_off = 0;
16741 device_param->words_done = 0;
16742 }
16743
16744 data.kernel_power_div = 0;
16745
16746 // figure out some workload
16747
16748 if (attack_mode == ATTACK_MODE_STRAIGHT)
16749 {
16750 if (data.wordlist_mode == WL_MODE_FILE)
16751 {
16752 char *dictfile = NULL;
16753
16754 if (induction_dictionaries_cnt)
16755 {
16756 dictfile = induction_dictionaries[0];
16757 }
16758 else
16759 {
16760 dictfile = dictfiles[dictpos];
16761 }
16762
16763 data.dictfile = dictfile;
16764
16765 logfile_sub_string (dictfile);
16766
16767 for (uint i = 0; i < rp_files_cnt; i++)
16768 {
16769 logfile_sub_var_string ("rulefile", rp_files[i]);
16770 }
16771
16772 FILE *fd2 = fopen (dictfile, "rb");
16773
16774 if (fd2 == NULL)
16775 {
16776 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16777
16778 return (-1);
16779 }
16780
16781 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16782
16783 fclose (fd2);
16784
16785 if (data.words_cnt == 0)
16786 {
16787 if (data.devices_status == STATUS_CRACKED) break;
16788 if (data.devices_status == STATUS_ABORTED) break;
16789
16790 dictpos++;
16791
16792 continue;
16793 }
16794 }
16795 }
16796 else if (attack_mode == ATTACK_MODE_COMBI)
16797 {
16798 char *dictfile = data.dictfile;
16799 char *dictfile2 = data.dictfile2;
16800
16801 logfile_sub_string (dictfile);
16802 logfile_sub_string (dictfile2);
16803
16804 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16805 {
16806 FILE *fd2 = fopen (dictfile, "rb");
16807
16808 if (fd2 == NULL)
16809 {
16810 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16811
16812 return (-1);
16813 }
16814
16815 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16816
16817 fclose (fd2);
16818 }
16819 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16820 {
16821 FILE *fd2 = fopen (dictfile2, "rb");
16822
16823 if (fd2 == NULL)
16824 {
16825 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16826
16827 return (-1);
16828 }
16829
16830 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16831
16832 fclose (fd2);
16833 }
16834
16835 if (data.words_cnt == 0)
16836 {
16837 if (data.devices_status == STATUS_CRACKED) break;
16838 if (data.devices_status == STATUS_ABORTED) break;
16839
16840 dictpos++;
16841
16842 continue;
16843 }
16844 }
16845 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16846 {
16847 char *dictfile = NULL;
16848
16849 if (induction_dictionaries_cnt)
16850 {
16851 dictfile = induction_dictionaries[0];
16852 }
16853 else
16854 {
16855 dictfile = dictfiles[dictpos];
16856 }
16857
16858 data.dictfile = dictfile;
16859
16860 char *mask = data.mask;
16861
16862 logfile_sub_string (dictfile);
16863 logfile_sub_string (mask);
16864
16865 FILE *fd2 = fopen (dictfile, "rb");
16866
16867 if (fd2 == NULL)
16868 {
16869 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16870
16871 return (-1);
16872 }
16873
16874 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16875
16876 fclose (fd2);
16877
16878 if (data.words_cnt == 0)
16879 {
16880 if (data.devices_status == STATUS_CRACKED) break;
16881 if (data.devices_status == STATUS_ABORTED) break;
16882
16883 dictpos++;
16884
16885 continue;
16886 }
16887 }
16888 else if (attack_mode == ATTACK_MODE_BF)
16889 {
16890 local_free (css_buf);
16891 local_free (data.root_css_buf);
16892 local_free (data.markov_css_buf);
16893
16894 char *mask = dictfiles[dictpos];
16895
16896 logfile_sub_string (mask);
16897
16898 // base
16899
16900 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16901
16902 if (opts_type & OPTS_TYPE_PT_UNICODE)
16903 {
16904 uint css_cnt_unicode = css_cnt * 2;
16905
16906 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16907
16908 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16909 {
16910 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16911
16912 css_buf_unicode[j + 1].cs_buf[0] = 0;
16913 css_buf_unicode[j + 1].cs_len = 1;
16914 }
16915
16916 free (css_buf);
16917
16918 css_buf = css_buf_unicode;
16919 css_cnt = css_cnt_unicode;
16920 }
16921
16922 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16923
16924 uint mask_min = pw_min;
16925 uint mask_max = pw_max;
16926
16927 if (opts_type & OPTS_TYPE_PT_UNICODE)
16928 {
16929 mask_min *= 2;
16930 mask_max *= 2;
16931 }
16932
16933 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16934 {
16935 if (css_cnt < mask_min)
16936 {
16937 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16938 }
16939
16940 if (css_cnt > mask_max)
16941 {
16942 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16943 }
16944
16945 // skip to next mask
16946
16947 dictpos++;
16948
16949 rd->dictpos = dictpos;
16950
16951 logfile_sub_msg ("STOP");
16952
16953 continue;
16954 }
16955
16956 uint save_css_cnt = css_cnt;
16957
16958 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16959 {
16960 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16961 {
16962 uint salt_len = (uint) data.salts_buf[0].salt_len;
16963 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16964
16965 uint css_cnt_salt = css_cnt + salt_len;
16966
16967 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16968
16969 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16970
16971 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16972 {
16973 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16974 css_buf_salt[j].cs_len = 1;
16975 }
16976
16977 free (css_buf);
16978
16979 css_buf = css_buf_salt;
16980 css_cnt = css_cnt_salt;
16981 }
16982 }
16983
16984 data.mask = mask;
16985 data.css_cnt = css_cnt;
16986 data.css_buf = css_buf;
16987
16988 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16989
16990 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16991
16992 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16993
16994 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16995 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16996
16997 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16998
16999 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17000
17001 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17002 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17003
17004 data.root_css_buf = root_css_buf;
17005 data.markov_css_buf = markov_css_buf;
17006
17007 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17008
17009 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17010
17011 local_free (root_table_buf);
17012 local_free (markov_table_buf);
17013
17014 // copy + args
17015
17016 uint css_cnt_l = css_cnt;
17017 uint css_cnt_r;
17018
17019 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17020 {
17021 if (save_css_cnt < 6)
17022 {
17023 css_cnt_r = 1;
17024 }
17025 else if (save_css_cnt == 6)
17026 {
17027 css_cnt_r = 2;
17028 }
17029 else
17030 {
17031 if (opts_type & OPTS_TYPE_PT_UNICODE)
17032 {
17033 if (save_css_cnt == 8 || save_css_cnt == 10)
17034 {
17035 css_cnt_r = 2;
17036 }
17037 else
17038 {
17039 css_cnt_r = 4;
17040 }
17041 }
17042 else
17043 {
17044 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17045 {
17046 css_cnt_r = 3;
17047 }
17048 else
17049 {
17050 css_cnt_r = 4;
17051 }
17052 }
17053 }
17054 }
17055 else
17056 {
17057 css_cnt_r = 1;
17058
17059 /* unfinished code?
17060 int sum = css_buf[css_cnt_r - 1].cs_len;
17061
17062 for (uint i = 1; i < 4 && i < css_cnt; i++)
17063 {
17064 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17065
17066 css_cnt_r++;
17067
17068 sum *= css_buf[css_cnt_r - 1].cs_len;
17069 }
17070 */
17071 }
17072
17073 css_cnt_l -= css_cnt_r;
17074
17075 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17076
17077 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17078 {
17079 hc_device_param_t *device_param = &data.devices_param[device_id];
17080
17081 if (device_param->skipped) continue;
17082
17083 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17084 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17085 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17086
17087 device_param->kernel_params_mp_l_buf64[3] = 0;
17088 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17089 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17090 device_param->kernel_params_mp_l_buf32[6] = 0;
17091 device_param->kernel_params_mp_l_buf32[7] = 0;
17092 device_param->kernel_params_mp_l_buf32[8] = 0;
17093
17094 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17095 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17096 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17097 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17098
17099 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17100 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17101 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17102
17103 device_param->kernel_params_mp_r_buf64[3] = 0;
17104 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17105 device_param->kernel_params_mp_r_buf32[5] = 0;
17106 device_param->kernel_params_mp_r_buf32[6] = 0;
17107 device_param->kernel_params_mp_r_buf32[7] = 0;
17108
17109 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]);
17110 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]);
17111 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]);
17112
17113 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]);
17114 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]);
17115 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]);
17116
17117 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);
17118 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);
17119 }
17120 }
17121
17122 u64 words_base = data.words_cnt;
17123
17124 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17125 {
17126 if (data.kernel_rules_cnt)
17127 {
17128 words_base /= data.kernel_rules_cnt;
17129 }
17130 }
17131 else if (data.attack_kern == ATTACK_KERN_COMBI)
17132 {
17133 if (data.combs_cnt)
17134 {
17135 words_base /= data.combs_cnt;
17136 }
17137 }
17138 else if (data.attack_kern == ATTACK_KERN_BF)
17139 {
17140 if (data.bfs_cnt)
17141 {
17142 words_base /= data.bfs_cnt;
17143 }
17144 }
17145
17146 data.words_base = words_base;
17147
17148 if (keyspace == 1)
17149 {
17150 log_info ("%llu", (unsigned long long int) words_base);
17151
17152 return (0);
17153 }
17154
17155 if (data.words_cur > data.words_base)
17156 {
17157 log_error ("ERROR: restore value greater keyspace");
17158
17159 return (-1);
17160 }
17161
17162 if (data.words_cur)
17163 {
17164 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17165 {
17166 for (uint i = 0; i < data.salts_cnt; i++)
17167 {
17168 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17169 }
17170 }
17171 else if (data.attack_kern == ATTACK_KERN_COMBI)
17172 {
17173 for (uint i = 0; i < data.salts_cnt; i++)
17174 {
17175 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17176 }
17177 }
17178 else if (data.attack_kern == ATTACK_KERN_BF)
17179 {
17180 for (uint i = 0; i < data.salts_cnt; i++)
17181 {
17182 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17183 }
17184 }
17185 }
17186
17187 /*
17188 * Inform user about possible slow speeds
17189 */
17190
17191 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17192 {
17193 if (data.words_base < kernel_power_all)
17194 {
17195 if (quiet == 0)
17196 {
17197 log_info ("ATTENTION!");
17198 log_info (" The wordlist or mask you are using is too small.");
17199 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17200 log_info (" The cracking speed will drop.");
17201 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17202 log_info ("");
17203 }
17204 }
17205 }
17206
17207 /*
17208 * Update loopback file
17209 */
17210
17211 if (loopback == 1)
17212 {
17213 time_t now;
17214
17215 time (&now);
17216
17217 uint random_num = get_random_num (0, 9999);
17218
17219 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17220
17221 data.loopback_file = loopback_file;
17222 }
17223
17224 /*
17225 * Update dictionary statistic
17226 */
17227
17228 if (keyspace == 0)
17229 {
17230 dictstat_fp = fopen (dictstat, "wb");
17231
17232 if (dictstat_fp)
17233 {
17234 lock_file (dictstat_fp);
17235
17236 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17237
17238 fclose (dictstat_fp);
17239 }
17240 }
17241
17242 data.devices_status = STATUS_RUNNING;
17243
17244 if (initial_restore_done == 0)
17245 {
17246 if (data.restore_disable == 0) cycle_restore ();
17247
17248 initial_restore_done = 1;
17249 }
17250
17251 hc_timer_set (&data.timer_running);
17252
17253 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17254 {
17255 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17256 {
17257 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17258 if (quiet == 0) fflush (stdout);
17259 }
17260 }
17261 else if (wordlist_mode == WL_MODE_STDIN)
17262 {
17263 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17264 if (data.quiet == 0) log_info ("");
17265 }
17266
17267 time_t runtime_start;
17268
17269 time (&runtime_start);
17270
17271 data.runtime_start = runtime_start;
17272
17273 /**
17274 * create cracker threads
17275 */
17276
17277 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17278
17279 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17280 {
17281 hc_device_param_t *device_param = &devices_param[device_id];
17282
17283 if (wordlist_mode == WL_MODE_STDIN)
17284 {
17285 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17286 }
17287 else
17288 {
17289 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17290 }
17291 }
17292
17293 // wait for crack threads to exit
17294
17295 hc_thread_wait (data.devices_cnt, c_threads);
17296
17297 local_free (c_threads);
17298
17299 data.restore = 0;
17300
17301 // finalize task
17302
17303 logfile_sub_var_uint ("status-after-work", data.devices_status);
17304
17305 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17306
17307 if (data.devices_status == STATUS_CRACKED) break;
17308 if (data.devices_status == STATUS_ABORTED) break;
17309
17310 if (data.devices_status == STATUS_BYPASS)
17311 {
17312 data.devices_status = STATUS_RUNNING;
17313 }
17314
17315 if (induction_dictionaries_cnt)
17316 {
17317 unlink (induction_dictionaries[0]);
17318 }
17319
17320 free (induction_dictionaries);
17321
17322 if (attack_mode != ATTACK_MODE_BF)
17323 {
17324 induction_dictionaries = scan_directory (induction_directory);
17325
17326 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17327 }
17328
17329 if (benchmark == 0)
17330 {
17331 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17332 {
17333 if (quiet == 0) clear_prompt ();
17334
17335 if (quiet == 0) log_info ("");
17336
17337 if (status == 1)
17338 {
17339 status_display ();
17340 }
17341 else
17342 {
17343 if (quiet == 0) status_display ();
17344 }
17345
17346 if (quiet == 0) log_info ("");
17347 }
17348 }
17349
17350 if (attack_mode == ATTACK_MODE_BF)
17351 {
17352 dictpos++;
17353
17354 rd->dictpos = dictpos;
17355 }
17356 else
17357 {
17358 if (induction_dictionaries_cnt)
17359 {
17360 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17361 }
17362 else
17363 {
17364 dictpos++;
17365
17366 rd->dictpos = dictpos;
17367 }
17368 }
17369
17370 time_t runtime_stop;
17371
17372 time (&runtime_stop);
17373
17374 data.runtime_stop = runtime_stop;
17375
17376 logfile_sub_uint (runtime_start);
17377 logfile_sub_uint (runtime_stop);
17378
17379 logfile_sub_msg ("STOP");
17380
17381 global_free (subid);
17382 }
17383
17384 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17385
17386 if (data.devices_status == STATUS_CRACKED) break;
17387 if (data.devices_status == STATUS_ABORTED) break;
17388 if (data.devices_status == STATUS_QUIT) break;
17389
17390 if (data.devices_status == STATUS_BYPASS)
17391 {
17392 data.devices_status = STATUS_RUNNING;
17393 }
17394 }
17395
17396 // 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
17397
17398 if (attack_mode == ATTACK_MODE_STRAIGHT)
17399 {
17400 if (data.wordlist_mode == WL_MODE_FILE)
17401 {
17402 if (data.dictfile == NULL)
17403 {
17404 if (dictfiles != NULL)
17405 {
17406 data.dictfile = dictfiles[0];
17407
17408 hc_timer_set (&data.timer_running);
17409 }
17410 }
17411 }
17412 }
17413 // NOTE: combi is okay because it is already set beforehand
17414 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17415 {
17416 if (data.dictfile == NULL)
17417 {
17418 if (dictfiles != NULL)
17419 {
17420 hc_timer_set (&data.timer_running);
17421
17422 data.dictfile = dictfiles[0];
17423 }
17424 }
17425 }
17426 else if (attack_mode == ATTACK_MODE_BF)
17427 {
17428 if (data.mask == NULL)
17429 {
17430 hc_timer_set (&data.timer_running);
17431
17432 data.mask = masks[0];
17433 }
17434 }
17435
17436 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17437 {
17438 data.devices_status = STATUS_EXHAUSTED;
17439 }
17440
17441 // if cracked / aborted remove last induction dictionary
17442
17443 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17444 {
17445 struct stat induct_stat;
17446
17447 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17448 {
17449 unlink (induction_dictionaries[file_pos]);
17450 }
17451 }
17452
17453 // wait for non-interactive threads
17454
17455 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17456 {
17457 hc_thread_wait (1, &ni_threads[thread_idx]);
17458 }
17459
17460 local_free (ni_threads);
17461
17462 // wait for interactive threads
17463
17464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17465 {
17466 hc_thread_wait (1, &i_thread);
17467 }
17468
17469 // we dont need restore file anymore
17470 if (data.restore_disable == 0)
17471 {
17472 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17473 {
17474 unlink (eff_restore_file);
17475 unlink (new_restore_file);
17476 }
17477 else
17478 {
17479 cycle_restore ();
17480 }
17481 }
17482
17483 // finally save left hashes
17484
17485 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17486 {
17487 save_hash ();
17488 }
17489
17490 /**
17491 * Clean up
17492 */
17493
17494 if (benchmark == 1)
17495 {
17496 status_benchmark ();
17497
17498 if (status_automat == 0)
17499 {
17500 log_info ("");
17501 }
17502 }
17503 else
17504 {
17505 if (quiet == 0) clear_prompt ();
17506
17507 if (quiet == 0) log_info ("");
17508
17509 if (status == 1)
17510 {
17511 status_display ();
17512 }
17513 else
17514 {
17515 if (quiet == 0) status_display ();
17516 }
17517
17518 if (quiet == 0) log_info ("");
17519 }
17520
17521 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17522 {
17523 hc_device_param_t *device_param = &data.devices_param[device_id];
17524
17525 if (device_param->skipped) continue;
17526
17527 local_free (device_param->combs_buf);
17528
17529 local_free (device_param->hooks_buf);
17530
17531 local_free (device_param->device_name);
17532
17533 local_free (device_param->device_name_chksum);
17534
17535 local_free (device_param->device_version);
17536
17537 local_free (device_param->driver_version);
17538
17539 if (device_param->pws_buf) myfree (device_param->pws_buf);
17540 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17541 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17542 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17543 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17544 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17545 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17546 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17547 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17548 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17549 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17550 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17551 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17552 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17553 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17554 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17555 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17556 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17557 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17558 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17559 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17560 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17561 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17562 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17563 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17564 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17565 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17566 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17567 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17568
17569 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17570 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17571 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17572 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17573 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17574 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17575 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17576 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17577 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17578 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17579
17580 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17581 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17582 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17583
17584 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17585 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17586 }
17587
17588 // reset default fan speed
17589
17590 #ifdef HAVE_HWMON
17591 if (gpu_temp_disable == 0)
17592 {
17593 #ifdef HAVE_ADL
17594 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17595 {
17596 hc_thread_mutex_lock (mux_adl);
17597
17598 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17599 {
17600 hc_device_param_t *device_param = &data.devices_param[device_id];
17601
17602 if (device_param->skipped) continue;
17603
17604 if (data.hm_device[device_id].fan_supported == 1)
17605 {
17606 int fanspeed = temp_retain_fanspeed_value[device_id];
17607
17608 if (fanspeed == -1) continue;
17609
17610 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17611
17612 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17613 }
17614 }
17615
17616 hc_thread_mutex_unlock (mux_adl);
17617 }
17618 #endif // HAVE_ADL
17619 }
17620
17621 #ifdef HAVE_ADL
17622 // reset power tuning
17623
17624 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17625 {
17626 hc_thread_mutex_lock (mux_adl);
17627
17628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17629 {
17630 hc_device_param_t *device_param = &data.devices_param[device_id];
17631
17632 if (device_param->skipped) continue;
17633
17634 if (data.hm_device[device_id].od_version == 6)
17635 {
17636 // check powertune capabilities first, if not available then skip device
17637
17638 int powertune_supported = 0;
17639
17640 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17641 {
17642 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17643
17644 return (-1);
17645 }
17646
17647 if (powertune_supported != 0)
17648 {
17649 // powercontrol settings
17650
17651 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)
17652 {
17653 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17654
17655 return (-1);
17656 }
17657
17658 // clocks
17659
17660 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17661
17662 performance_state->iNumberOfPerformanceLevels = 2;
17663
17664 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17665 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17666 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17667 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17668
17669 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)
17670 {
17671 log_info ("ERROR: Failed to restore ADL performance state");
17672
17673 return (-1);
17674 }
17675
17676 local_free (performance_state);
17677 }
17678 }
17679 }
17680
17681 hc_thread_mutex_unlock (mux_adl);
17682 }
17683 #endif // HAVE_ADL
17684
17685 if (gpu_temp_disable == 0)
17686 {
17687 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17688 if (data.hm_nv)
17689 {
17690 #if defined(LINUX) && defined(HAVE_NVML)
17691
17692 hm_NVML_nvmlShutdown (data.hm_nv);
17693
17694 nvml_close (data.hm_nv);
17695
17696 #elif defined(WIN) && (HAVE_NVAPI)
17697
17698 hm_NvAPI_Unload (data.hm_nv);
17699
17700 nvapi_close (data.hm_nv);
17701
17702 #endif
17703
17704 data.hm_nv = NULL;
17705 }
17706 #endif
17707
17708 #ifdef HAVE_ADL
17709 if (data.hm_amd)
17710 {
17711 hm_ADL_Main_Control_Destroy (data.hm_amd);
17712
17713 adl_close (data.hm_amd);
17714 data.hm_amd = NULL;
17715 }
17716 #endif
17717 }
17718 #endif // HAVE_HWMON
17719
17720 // free memory
17721
17722 local_free (masks);
17723
17724 local_free (dictstat_base);
17725
17726 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17727 {
17728 pot_t *pot_ptr = &pot[pot_pos];
17729
17730 hash_t *hash = &pot_ptr->hash;
17731
17732 local_free (hash->digest);
17733
17734 if (isSalted)
17735 {
17736 local_free (hash->salt);
17737 }
17738 }
17739
17740 local_free (pot);
17741
17742 local_free (all_kernel_rules_cnt);
17743 local_free (all_kernel_rules_buf);
17744
17745 local_free (wl_data->buf);
17746 local_free (wl_data);
17747
17748 local_free (bitmap_s1_a);
17749 local_free (bitmap_s1_b);
17750 local_free (bitmap_s1_c);
17751 local_free (bitmap_s1_d);
17752 local_free (bitmap_s2_a);
17753 local_free (bitmap_s2_b);
17754 local_free (bitmap_s2_c);
17755 local_free (bitmap_s2_d);
17756
17757 #ifdef HAVE_HWMON
17758 local_free (temp_retain_fanspeed_value);
17759 #ifdef HAVE_ADL
17760 local_free (od_clock_mem_status);
17761 local_free (od_power_control_status);
17762 #endif // ADL
17763 #endif
17764
17765 global_free (devices_param);
17766
17767 global_free (kernel_rules_buf);
17768
17769 global_free (root_css_buf);
17770 global_free (markov_css_buf);
17771
17772 global_free (digests_buf);
17773 global_free (digests_shown);
17774 global_free (digests_shown_tmp);
17775
17776 global_free (salts_buf);
17777 global_free (salts_shown);
17778
17779 global_free (esalts_buf);
17780
17781 global_free (words_progress_done);
17782 global_free (words_progress_rejected);
17783 global_free (words_progress_restored);
17784
17785 if (pot_fp) fclose (pot_fp);
17786
17787 if (data.devices_status == STATUS_QUIT) break;
17788 }
17789
17790 // destroy others mutex
17791
17792 hc_thread_mutex_delete (mux_dispatcher);
17793 hc_thread_mutex_delete (mux_counter);
17794 hc_thread_mutex_delete (mux_display);
17795 hc_thread_mutex_delete (mux_adl);
17796
17797 // free memory
17798
17799 local_free (eff_restore_file);
17800 local_free (new_restore_file);
17801
17802 local_free (rd);
17803
17804 // tuning db
17805
17806 tuning_db_destroy (tuning_db);
17807
17808 // loopback
17809
17810 local_free (loopback_file);
17811
17812 if (loopback == 1) unlink (loopback_file);
17813
17814 // induction directory
17815
17816 if (induction_dir == NULL)
17817 {
17818 if (attack_mode != ATTACK_MODE_BF)
17819 {
17820 if (rmdir (induction_directory) == -1)
17821 {
17822 if (errno == ENOENT)
17823 {
17824 // good, we can ignore
17825 }
17826 else if (errno == ENOTEMPTY)
17827 {
17828 // good, we can ignore
17829 }
17830 else
17831 {
17832 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17833
17834 return (-1);
17835 }
17836 }
17837
17838 local_free (induction_directory);
17839 }
17840 }
17841
17842 // outfile-check directory
17843
17844 if (outfile_check_dir == NULL)
17845 {
17846 if (rmdir (outfile_check_directory) == -1)
17847 {
17848 if (errno == ENOENT)
17849 {
17850 // good, we can ignore
17851 }
17852 else if (errno == ENOTEMPTY)
17853 {
17854 // good, we can ignore
17855 }
17856 else
17857 {
17858 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17859
17860 return (-1);
17861 }
17862 }
17863
17864 local_free (outfile_check_directory);
17865 }
17866
17867 time_t proc_stop;
17868
17869 time (&proc_stop);
17870
17871 logfile_top_uint (proc_start);
17872 logfile_top_uint (proc_stop);
17873
17874 logfile_top_msg ("STOP");
17875
17876 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17877 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17878
17879 if (data.ocl) ocl_close (data.ocl);
17880
17881 if (data.devices_status == STATUS_ABORTED) return 2;
17882 if (data.devices_status == STATUS_QUIT) return 2;
17883 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17884 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17885 if (data.devices_status == STATUS_CRACKED) return 0;
17886
17887 return -1;
17888 }
Hashcat additions to support pwdhash