projects / hashcat.git / blob
? search:


2b81e0b4c7b19c8db0cd67da003949e47d37a9f7
[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 (outdated option, use -w)",
427 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size (outdated option, use -w)",
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 // in this case the user specified a fixed -u and -n on the commandline
2869 // no way to tune anything
2870 // but we need to run a few caching rounds
2871
2872 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2873 {
2874 try_run (device_param, kernel_accel, kernel_loops);
2875 try_run (device_param, kernel_accel, kernel_loops);
2876 try_run (device_param, kernel_accel, kernel_loops);
2877 try_run (device_param, kernel_accel, kernel_loops);
2878
2879 return;
2880 }
2881
2882 // from here it's clear we are allowed to autotune
2883 // so let's init some fake words
2884
2885 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2886
2887 for (u32 i = 0; i < kernel_power_max; i++)
2888 {
2889 device_param->pws_buf[i].i[0] = i;
2890 device_param->pws_buf[i].i[1] = 0x01234567;
2891 device_param->pws_buf[i].pw_len = 7;
2892 }
2893
2894 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);
2895
2896 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2897 {
2898 run_kernel_amp (device_param, kernel_power_max);
2899 }
2900
2901 #define VERIFIER_CNT 1
2902
2903 // first find out highest kernel-loops that stays below target_ms
2904
2905 if (kernel_loops_min < kernel_loops_max)
2906 {
2907 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2908 {
2909 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2910
2911 for (int i = 0; i < VERIFIER_CNT; i++)
2912 {
2913 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2914
2915 exec_ms = MIN (exec_ms, exec_ms_v);
2916 }
2917
2918 if (exec_ms < target_ms) break;
2919 }
2920 }
2921
2922 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2923
2924 #define STEPS_CNT 10
2925
2926 if (kernel_accel_min < kernel_accel_max)
2927 {
2928 for (int i = 0; i < STEPS_CNT; i++)
2929 {
2930 const u32 kernel_accel_try = 1 << i;
2931
2932 if (kernel_accel_try < kernel_accel_min) continue;
2933 if (kernel_accel_try > kernel_accel_max) break;
2934
2935 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2936
2937 for (int i = 0; i < VERIFIER_CNT; i++)
2938 {
2939 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2940
2941 exec_ms = MIN (exec_ms, exec_ms_v);
2942 }
2943
2944 if (exec_ms > target_ms) break;
2945
2946 kernel_accel = kernel_accel_try;
2947 }
2948 }
2949
2950 // at this point we want to know the actual runtime for the following reason:
2951 // we need a reference for the balancing loop following up, and this
2952 // the balancing loop can have an effect that the creates a new opportunity, for example:
2953 // if the target is 95 ms and the current runtime is 48ms the above loop
2954 // stopped the execution because the previous exec_ms was > 95ms
2955 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2956 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2957
2958 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2959
2960 for (int i = 0; i < VERIFIER_CNT; i++)
2961 {
2962 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2963
2964 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2965 }
2966
2967 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2968 {
2969 for (u32 f = 2; f < 1024; f++)
2970 {
2971 const u32 kernel_accel_try = kernel_accel * f;
2972 const u32 kernel_loops_try = kernel_loops / f;
2973
2974 if (kernel_accel_try > kernel_accel_max) break;
2975 if (kernel_loops_try < kernel_loops_min) break;
2976
2977 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2978
2979 for (int i = 0; i < VERIFIER_CNT; i++)
2980 {
2981 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2982
2983 exec_ms = MIN (exec_ms, exec_ms_v);
2984 }
2985
2986 if (exec_ms < exec_ms_pre_final)
2987 {
2988 exec_ms_pre_final = exec_ms;
2989
2990 kernel_accel = kernel_accel_try;
2991 kernel_loops = kernel_loops_try;
2992 }
2993 }
2994 }
2995
2996 const double exec_left = target_ms / exec_ms_pre_final;
2997
2998 const double accel_left = kernel_accel_max / kernel_accel;
2999
3000 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3001
3002 if (exec_accel_min >= 2)
3003 {
3004 // this is safe to not overflow kernel_accel_max because of accel_left
3005
3006 kernel_accel *= exec_accel_min;
3007 }
3008
3009 // reset them fake words
3010
3011 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3012
3013 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);
3014 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);
3015
3016 // reset timer
3017
3018 device_param->exec_pos = 0;
3019
3020 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3021
3022 // store
3023
3024 device_param->kernel_accel = kernel_accel;
3025 device_param->kernel_loops = kernel_loops;
3026
3027 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3028
3029 device_param->kernel_power = kernel_power;
3030
3031 #ifdef DEBUG
3032
3033 if (data.quiet == 0)
3034 {
3035 clear_prompt ();
3036
3037 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3038 "Device #%u: autotuned kernel-loops to %u\n",
3039 device_param->device_id + 1, kernel_accel,
3040 device_param->device_id + 1, kernel_loops);
3041
3042 fprintf (stdout, "%s", PROMPT);
3043
3044 fflush (stdout);
3045 }
3046
3047 #endif
3048 }
3049
3050 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3051 {
3052 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3053
3054 // init speed timer
3055
3056 uint speed_pos = device_param->speed_pos;
3057
3058 #ifdef _POSIX
3059 if (device_param->timer_speed.tv_sec == 0)
3060 {
3061 hc_timer_set (&device_param->timer_speed);
3062 }
3063 #endif
3064
3065 #ifdef _WIN
3066 if (device_param->timer_speed.QuadPart == 0)
3067 {
3068 hc_timer_set (&device_param->timer_speed);
3069 }
3070 #endif
3071
3072 // find higest password length, this is for optimization stuff
3073
3074 uint highest_pw_len = 0;
3075
3076 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3077 {
3078 }
3079 else if (data.attack_kern == ATTACK_KERN_COMBI)
3080 {
3081 }
3082 else if (data.attack_kern == ATTACK_KERN_BF)
3083 {
3084 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3085 + device_param->kernel_params_mp_l_buf32[5];
3086 }
3087
3088 // iteration type
3089
3090 uint innerloop_step = 0;
3091 uint innerloop_cnt = 0;
3092
3093 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3094 else innerloop_step = 1;
3095
3096 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3097 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3098 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3099
3100 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3101
3102 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3103 {
3104 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3105
3106 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3107
3108 if (data.devices_status == STATUS_CRACKED) break;
3109 if (data.devices_status == STATUS_ABORTED) break;
3110 if (data.devices_status == STATUS_QUIT) break;
3111 if (data.devices_status == STATUS_BYPASS) break;
3112
3113 salt_t *salt_buf = &data.salts_buf[salt_pos];
3114
3115 device_param->kernel_params_buf32[24] = salt_pos;
3116 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3117 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3118
3119 FILE *combs_fp = device_param->combs_fp;
3120
3121 if (data.attack_mode == ATTACK_MODE_COMBI)
3122 {
3123 rewind (combs_fp);
3124 }
3125
3126 // innerloops
3127
3128 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3129 {
3130 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3131
3132 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3133
3134 if (data.devices_status == STATUS_CRACKED) break;
3135 if (data.devices_status == STATUS_ABORTED) break;
3136 if (data.devices_status == STATUS_QUIT) break;
3137 if (data.devices_status == STATUS_BYPASS) break;
3138
3139 uint innerloop_left = innerloop_cnt - innerloop_pos;
3140
3141 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3142
3143 device_param->innerloop_pos = innerloop_pos;
3144 device_param->innerloop_left = innerloop_left;
3145
3146 device_param->kernel_params_buf32[27] = innerloop_left;
3147
3148 // i think we can get rid of this
3149 if (innerloop_left == 0)
3150 {
3151 puts ("bug, how should this happen????\n");
3152
3153 continue;
3154 }
3155
3156 if (data.salts_shown[salt_pos] == 1)
3157 {
3158 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3159
3160 continue;
3161 }
3162
3163 // initialize amplifiers
3164
3165 if (data.attack_mode == ATTACK_MODE_COMBI)
3166 {
3167 uint i = 0;
3168
3169 while (i < innerloop_left)
3170 {
3171 if (feof (combs_fp)) break;
3172
3173 int line_len = fgetl (combs_fp, line_buf);
3174
3175 if (line_len >= PW_MAX1) continue;
3176
3177 line_len = convert_from_hex (line_buf, line_len);
3178
3179 char *line_buf_new = line_buf;
3180
3181 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3182 {
3183 char rule_buf_out[BLOCK_SIZE] = { 0 };
3184
3185 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3186
3187 if (rule_len_out < 0)
3188 {
3189 data.words_progress_rejected[salt_pos] += pws_cnt;
3190
3191 continue;
3192 }
3193
3194 line_len = rule_len_out;
3195
3196 line_buf_new = rule_buf_out;
3197 }
3198
3199 line_len = MIN (line_len, PW_DICTMAX);
3200
3201 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3202
3203 memcpy (ptr, line_buf_new, line_len);
3204
3205 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3206
3207 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3208 {
3209 uppercase (ptr, line_len);
3210 }
3211
3212 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3213 {
3214 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3215 {
3216 ptr[line_len] = 0x80;
3217 }
3218
3219 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3220 {
3221 ptr[line_len] = 0x01;
3222 }
3223 }
3224
3225 device_param->combs_buf[i].pw_len = line_len;
3226
3227 i++;
3228 }
3229
3230 for (uint j = i; j < innerloop_left; j++)
3231 {
3232 device_param->combs_buf[j].i[0] = 0;
3233 device_param->combs_buf[j].i[1] = 0;
3234 device_param->combs_buf[j].i[2] = 0;
3235 device_param->combs_buf[j].i[3] = 0;
3236 device_param->combs_buf[j].i[4] = 0;
3237 device_param->combs_buf[j].i[5] = 0;
3238 device_param->combs_buf[j].i[6] = 0;
3239 device_param->combs_buf[j].i[7] = 0;
3240
3241 device_param->combs_buf[j].pw_len = 0;
3242 }
3243
3244 innerloop_left = i;
3245 }
3246 else if (data.attack_mode == ATTACK_MODE_BF)
3247 {
3248 u64 off = innerloop_pos;
3249
3250 device_param->kernel_params_mp_r_buf64[3] = off;
3251
3252 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3255 {
3256 u64 off = innerloop_pos;
3257
3258 device_param->kernel_params_mp_buf64[3] = off;
3259
3260 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3261 }
3262 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3263 {
3264 u64 off = innerloop_pos;
3265
3266 device_param->kernel_params_mp_buf64[3] = off;
3267
3268 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3269 }
3270
3271 // copy amplifiers
3272
3273 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3274 {
3275 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);
3276 }
3277 else if (data.attack_mode == ATTACK_MODE_COMBI)
3278 {
3279 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);
3280 }
3281 else if (data.attack_mode == ATTACK_MODE_BF)
3282 {
3283 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);
3284 }
3285 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3286 {
3287 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);
3288 }
3289 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3290 {
3291 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);
3292 }
3293
3294 if (data.benchmark == 1)
3295 {
3296 hc_timer_set (&device_param->timer_speed);
3297 }
3298
3299 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3300
3301 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3302
3303 if (data.devices_status == STATUS_CRACKED) break;
3304 if (data.devices_status == STATUS_ABORTED) break;
3305 if (data.devices_status == STATUS_QUIT) break;
3306
3307 /**
3308 * result
3309 */
3310
3311 hc_thread_mutex_lock (mux_display);
3312
3313 check_cracked (device_param, salt_pos);
3314
3315 hc_thread_mutex_unlock (mux_display);
3316
3317 /**
3318 * progress
3319 */
3320
3321 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3322
3323 hc_thread_mutex_lock (mux_counter);
3324
3325 data.words_progress_done[salt_pos] += perf_sum_all;
3326
3327 hc_thread_mutex_unlock (mux_counter);
3328
3329 /**
3330 * speed
3331 */
3332
3333 double speed_ms;
3334
3335 hc_timer_get (device_param->timer_speed, speed_ms);
3336
3337 hc_timer_set (&device_param->timer_speed);
3338
3339 hc_thread_mutex_lock (mux_display);
3340
3341 // current speed
3342
3343 device_param->speed_cnt[speed_pos] = perf_sum_all;
3344
3345 device_param->speed_ms[speed_pos] = speed_ms;
3346
3347 hc_thread_mutex_unlock (mux_display);
3348
3349 speed_pos++;
3350
3351 if (speed_pos == SPEED_CACHE)
3352 {
3353 speed_pos = 0;
3354 }
3355
3356 /**
3357 * benchmark
3358 */
3359
3360 if (data.benchmark == 1) break;
3361 }
3362 }
3363
3364 device_param->speed_pos = speed_pos;
3365
3366 myfree (line_buf);
3367 }
3368
3369 static void load_segment (wl_data_t *wl_data, FILE *fd)
3370 {
3371 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3372
3373 wl_data->pos = 0;
3374
3375 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3376
3377 wl_data->buf[wl_data->cnt] = 0;
3378
3379 if (wl_data->cnt == 0) return;
3380
3381 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3382
3383 while (!feof (fd))
3384 {
3385 if (wl_data->cnt == wl_data->avail)
3386 {
3387 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3388
3389 wl_data->avail += wl_data->incr;
3390 }
3391
3392 const int c = fgetc (fd);
3393
3394 if (c == EOF) break;
3395
3396 wl_data->buf[wl_data->cnt] = (char) c;
3397
3398 wl_data->cnt++;
3399
3400 if (c == '\n') break;
3401 }
3402
3403 // ensure stream ends with a newline
3404
3405 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3406 {
3407 wl_data->cnt++;
3408
3409 wl_data->buf[wl_data->cnt - 1] = '\n';
3410 }
3411
3412 return;
3413 }
3414
3415 static void get_next_word_lm (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 (i == 7)
3424 {
3425 *off = i;
3426 *len = i;
3427
3428 return;
3429 }
3430
3431 if (*ptr != '\n') continue;
3432
3433 *off = i + 1;
3434
3435 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3436
3437 *len = i;
3438
3439 return;
3440 }
3441
3442 *off = sz;
3443 *len = sz;
3444 }
3445
3446 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3447 {
3448 char *ptr = buf;
3449
3450 for (u32 i = 0; i < sz; i++, ptr++)
3451 {
3452 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3453
3454 if (*ptr != '\n') continue;
3455
3456 *off = i + 1;
3457
3458 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3459
3460 *len = i;
3461
3462 return;
3463 }
3464
3465 *off = sz;
3466 *len = sz;
3467 }
3468
3469 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3470 {
3471 char *ptr = buf;
3472
3473 for (u32 i = 0; i < sz; i++, ptr++)
3474 {
3475 if (*ptr != '\n') continue;
3476
3477 *off = i + 1;
3478
3479 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3480
3481 *len = i;
3482
3483 return;
3484 }
3485
3486 *off = sz;
3487 *len = sz;
3488 }
3489
3490 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3491 {
3492 while (wl_data->pos < wl_data->cnt)
3493 {
3494 uint off;
3495 uint len;
3496
3497 char *ptr = wl_data->buf + wl_data->pos;
3498
3499 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3500
3501 wl_data->pos += off;
3502
3503 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3504 {
3505 char rule_buf_out[BLOCK_SIZE] = { 0 };
3506
3507 int rule_len_out = -1;
3508
3509 if (len < BLOCK_SIZE)
3510 {
3511 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3512 }
3513
3514 if (rule_len_out < 0)
3515 {
3516 continue;
3517 }
3518
3519 if (rule_len_out > PW_MAX)
3520 {
3521 continue;
3522 }
3523 }
3524 else
3525 {
3526 if (len > PW_MAX)
3527 {
3528 continue;
3529 }
3530 }
3531
3532 *out_buf = ptr;
3533 *out_len = len;
3534
3535 return;
3536 }
3537
3538 if (feof (fd))
3539 {
3540 fprintf (stderr, "BUG feof()!!\n");
3541
3542 return;
3543 }
3544
3545 load_segment (wl_data, fd);
3546
3547 get_next_word (wl_data, fd, out_buf, out_len);
3548 }
3549
3550 #ifdef _POSIX
3551 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3552 #endif
3553
3554 #ifdef _WIN
3555 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3556 #endif
3557 {
3558 hc_signal (NULL);
3559
3560 dictstat_t d;
3561
3562 d.cnt = 0;
3563
3564 #ifdef _POSIX
3565 fstat (fileno (fd), &d.stat);
3566 #endif
3567
3568 #ifdef _WIN
3569 _fstat64 (fileno (fd), &d.stat);
3570 #endif
3571
3572 d.stat.st_mode = 0;
3573 d.stat.st_nlink = 0;
3574 d.stat.st_uid = 0;
3575 d.stat.st_gid = 0;
3576 d.stat.st_rdev = 0;
3577 d.stat.st_atime = 0;
3578
3579 #ifdef _POSIX
3580 d.stat.st_blksize = 0;
3581 d.stat.st_blocks = 0;
3582 #endif
3583
3584 if (d.stat.st_size == 0) return 0;
3585
3586 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3587
3588 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3589 {
3590 if (d_cache)
3591 {
3592 u64 cnt = d_cache->cnt;
3593
3594 u64 keyspace = cnt;
3595
3596 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3597 {
3598 keyspace *= data.kernel_rules_cnt;
3599 }
3600 else if (data.attack_kern == ATTACK_KERN_COMBI)
3601 {
3602 keyspace *= data.combs_cnt;
3603 }
3604
3605 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);
3606 if (data.quiet == 0) log_info ("");
3607
3608 hc_signal (sigHandler_default);
3609
3610 return (keyspace);
3611 }
3612 }
3613
3614 time_t now = 0;
3615 time_t prev = 0;
3616
3617 u64 comp = 0;
3618 u64 cnt = 0;
3619 u64 cnt2 = 0;
3620
3621 while (!feof (fd))
3622 {
3623 load_segment (wl_data, fd);
3624
3625 comp += wl_data->cnt;
3626
3627 u32 i = 0;
3628
3629 while (i < wl_data->cnt)
3630 {
3631 u32 len;
3632 u32 off;
3633
3634 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3635
3636 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3637 {
3638 char rule_buf_out[BLOCK_SIZE] = { 0 };
3639
3640 int rule_len_out = -1;
3641
3642 if (len < BLOCK_SIZE)
3643 {
3644 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3645 }
3646
3647 if (rule_len_out < 0)
3648 {
3649 len = PW_MAX1;
3650 }
3651 else
3652 {
3653 len = rule_len_out;
3654 }
3655 }
3656
3657 if (len < PW_MAX1)
3658 {
3659 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3660 {
3661 cnt += data.kernel_rules_cnt;
3662 }
3663 else if (data.attack_kern == ATTACK_KERN_COMBI)
3664 {
3665 cnt += data.combs_cnt;
3666 }
3667
3668 d.cnt++;
3669 }
3670
3671 i += off;
3672
3673 cnt2++;
3674 }
3675
3676 time (&now);
3677
3678 if ((now - prev) == 0) continue;
3679
3680 float percent = (float) comp / (float) d.stat.st_size;
3681
3682 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);
3683
3684 time (&prev);
3685 }
3686
3687 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);
3688 if (data.quiet == 0) log_info ("");
3689
3690 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3691
3692 hc_signal (sigHandler_default);
3693
3694 return (cnt);
3695 }
3696
3697 static void *thread_monitor (void *p)
3698 {
3699 uint runtime_check = 0;
3700 uint remove_check = 0;
3701 uint status_check = 0;
3702 uint restore_check = 0;
3703
3704 uint restore_left = data.restore_timer;
3705 uint remove_left = data.remove_timer;
3706 uint status_left = data.status_timer;
3707
3708 #ifdef HAVE_HWMON
3709 uint hwmon_check = 0;
3710
3711 // these variables are mainly used for fan control (AMD only)
3712
3713 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3714
3715 // temperature controller "loopback" values
3716
3717 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3718 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3719
3720 #ifdef HAVE_ADL
3721 int temp_threshold = 1; // degrees celcius
3722
3723 int fan_speed_min = 15; // in percentage
3724 int fan_speed_max = 100;
3725 #endif // HAVE_ADL
3726
3727 time_t last_temp_check_time;
3728 #endif // HAVE_HWMON
3729
3730 uint sleep_time = 1;
3731
3732 if (data.runtime)
3733 {
3734 runtime_check = 1;
3735 }
3736
3737 if (data.restore_timer)
3738 {
3739 restore_check = 1;
3740 }
3741
3742 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3743 {
3744 remove_check = 1;
3745 }
3746
3747 if (data.status == 1)
3748 {
3749 status_check = 1;
3750 }
3751
3752 #ifdef HAVE_HWMON
3753 if (data.gpu_temp_disable == 0)
3754 {
3755 time (&last_temp_check_time);
3756
3757 hwmon_check = 1;
3758 }
3759 #endif
3760
3761 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3762 {
3763 #ifdef HAVE_HWMON
3764 if (hwmon_check == 0)
3765 #endif
3766 return (p);
3767 }
3768
3769 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3770 {
3771 hc_sleep (sleep_time);
3772
3773 if (data.devices_status != STATUS_RUNNING) continue;
3774
3775 #ifdef HAVE_HWMON
3776 if (hwmon_check == 1)
3777 {
3778 hc_thread_mutex_lock (mux_adl);
3779
3780 time_t temp_check_time;
3781
3782 time (&temp_check_time);
3783
3784 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3785
3786 if (Ta == 0) Ta = 1;
3787
3788 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3789 {
3790 hc_device_param_t *device_param = &data.devices_param[device_id];
3791
3792 if (device_param->skipped) continue;
3793
3794 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3795
3796 const int temperature = hm_get_temperature_with_device_id (device_id);
3797
3798 if (temperature > (int) data.gpu_temp_abort)
3799 {
3800 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3801
3802 if (data.devices_status != STATUS_QUIT) myabort ();
3803
3804 break;
3805 }
3806
3807 #ifdef HAVE_ADL
3808 const int gpu_temp_retain = data.gpu_temp_retain;
3809
3810 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3811 {
3812 if (data.hm_device[device_id].fan_supported == 1)
3813 {
3814 int temp_cur = temperature;
3815
3816 int temp_diff_new = gpu_temp_retain - temp_cur;
3817
3818 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3819
3820 // calculate Ta value (time difference in seconds between the last check and this check)
3821
3822 last_temp_check_time = temp_check_time;
3823
3824 float Kp = 1.8;
3825 float Ki = 0.005;
3826 float Kd = 6;
3827
3828 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3829
3830 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);
3831
3832 if (abs (fan_diff_required) >= temp_threshold)
3833 {
3834 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3835
3836 int fan_speed_level = fan_speed_cur;
3837
3838 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3839
3840 int fan_speed_new = fan_speed_level - fan_diff_required;
3841
3842 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3843 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3844
3845 if (fan_speed_new != fan_speed_cur)
3846 {
3847 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3848 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3849
3850 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3851 {
3852 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3853
3854 fan_speed_chgd[device_id] = 1;
3855 }
3856
3857 temp_diff_old[device_id] = temp_diff_new;
3858 }
3859 }
3860 }
3861 }
3862 #endif // HAVE_ADL
3863 }
3864
3865 hc_thread_mutex_unlock (mux_adl);
3866 }
3867 #endif // HAVE_HWMON
3868
3869 if (restore_check == 1)
3870 {
3871 restore_left--;
3872
3873 if (restore_left == 0)
3874 {
3875 if (data.restore_disable == 0) cycle_restore ();
3876
3877 restore_left = data.restore_timer;
3878 }
3879 }
3880
3881 if ((runtime_check == 1) && (data.runtime_start > 0))
3882 {
3883 time_t runtime_cur;
3884
3885 time (&runtime_cur);
3886
3887 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3888
3889 if (runtime_left <= 0)
3890 {
3891 if (data.benchmark == 0)
3892 {
3893 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3894 }
3895
3896 if (data.devices_status != STATUS_QUIT) myabort ();
3897 }
3898 }
3899
3900 if (remove_check == 1)
3901 {
3902 remove_left--;
3903
3904 if (remove_left == 0)
3905 {
3906 if (data.digests_saved != data.digests_done)
3907 {
3908 data.digests_saved = data.digests_done;
3909
3910 save_hash ();
3911 }
3912
3913 remove_left = data.remove_timer;
3914 }
3915 }
3916
3917 if (status_check == 1)
3918 {
3919 status_left--;
3920
3921 if (status_left == 0)
3922 {
3923 hc_thread_mutex_lock (mux_display);
3924
3925 if (data.quiet == 0) clear_prompt ();
3926
3927 if (data.quiet == 0) log_info ("");
3928
3929 status_display ();
3930
3931 if (data.quiet == 0) log_info ("");
3932
3933 hc_thread_mutex_unlock (mux_display);
3934
3935 status_left = data.status_timer;
3936 }
3937 }
3938 }
3939
3940 #ifdef HAVE_HWMON
3941 myfree (fan_speed_chgd);
3942
3943 myfree (temp_diff_old);
3944 myfree (temp_diff_sum);
3945 #endif
3946
3947 p = NULL;
3948
3949 return (p);
3950 }
3951
3952 static void *thread_outfile_remove (void *p)
3953 {
3954 // some hash-dependent constants
3955 char *outfile_dir = data.outfile_check_directory;
3956 uint dgst_size = data.dgst_size;
3957 uint isSalted = data.isSalted;
3958 uint esalt_size = data.esalt_size;
3959 uint hash_mode = data.hash_mode;
3960
3961 uint outfile_check_timer = data.outfile_check_timer;
3962
3963 char separator = data.separator;
3964
3965 // some hash-dependent functions
3966 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3967 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3968
3969 // buffers
3970 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3971
3972 hash_buf.digest = mymalloc (dgst_size);
3973
3974 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3975
3976 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3977
3978 uint digest_buf[64] = { 0 };
3979
3980 outfile_data_t *out_info = NULL;
3981
3982 char **out_files = NULL;
3983
3984 time_t folder_mtime = 0;
3985
3986 int out_cnt = 0;
3987
3988 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3989
3990 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3991 {
3992 hc_sleep (1);
3993
3994 if (data.devices_status != STATUS_RUNNING) continue;
3995
3996 check_left--;
3997
3998 if (check_left == 0)
3999 {
4000 struct stat outfile_check_stat;
4001
4002 if (stat (outfile_dir, &outfile_check_stat) == 0)
4003 {
4004 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4005
4006 if (is_dir == 1)
4007 {
4008 if (outfile_check_stat.st_mtime > folder_mtime)
4009 {
4010 char **out_files_new = scan_directory (outfile_dir);
4011
4012 int out_cnt_new = count_dictionaries (out_files_new);
4013
4014 outfile_data_t *out_info_new = NULL;
4015
4016 if (out_cnt_new > 0)
4017 {
4018 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4019
4020 for (int i = 0; i < out_cnt_new; i++)
4021 {
4022 out_info_new[i].file_name = out_files_new[i];
4023
4024 // check if there are files that we have seen/checked before (and not changed)
4025
4026 for (int j = 0; j < out_cnt; j++)
4027 {
4028 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4029 {
4030 struct stat outfile_stat;
4031
4032 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4033 {
4034 if (outfile_stat.st_ctime == out_info[j].ctime)
4035 {
4036 out_info_new[i].ctime = out_info[j].ctime;
4037 out_info_new[i].seek = out_info[j].seek;
4038 }
4039 }
4040 }
4041 }
4042 }
4043 }
4044
4045 local_free (out_info);
4046 local_free (out_files);
4047
4048 out_files = out_files_new;
4049 out_cnt = out_cnt_new;
4050 out_info = out_info_new;
4051
4052 folder_mtime = outfile_check_stat.st_mtime;
4053 }
4054
4055 for (int j = 0; j < out_cnt; j++)
4056 {
4057 FILE *fp = fopen (out_info[j].file_name, "rb");
4058
4059 if (fp != NULL)
4060 {
4061 //hc_thread_mutex_lock (mux_display);
4062
4063 #ifdef _POSIX
4064 struct stat outfile_stat;
4065
4066 fstat (fileno (fp), &outfile_stat);
4067 #endif
4068
4069 #ifdef _WIN
4070 struct stat64 outfile_stat;
4071
4072 _fstat64 (fileno (fp), &outfile_stat);
4073 #endif
4074
4075 if (outfile_stat.st_ctime > out_info[j].ctime)
4076 {
4077 out_info[j].ctime = outfile_stat.st_ctime;
4078 out_info[j].seek = 0;
4079 }
4080
4081 fseek (fp, out_info[j].seek, SEEK_SET);
4082
4083 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4084
4085 while (!feof (fp))
4086 {
4087 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4088
4089 if (ptr == NULL) break;
4090
4091 int line_len = strlen (line_buf);
4092
4093 if (line_len <= 0) continue;
4094
4095 int iter = MAX_CUT_TRIES;
4096
4097 for (uint i = line_len - 1; i && iter; i--, line_len--)
4098 {
4099 if (line_buf[i] != separator) continue;
4100
4101 int parser_status = PARSER_OK;
4102
4103 if ((hash_mode != 2500) && (hash_mode != 6800))
4104 {
4105 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4106 }
4107
4108 uint found = 0;
4109
4110 if (parser_status == PARSER_OK)
4111 {
4112 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4113 {
4114 if (data.salts_shown[salt_pos] == 1) continue;
4115
4116 salt_t *salt_buf = &data.salts_buf[salt_pos];
4117
4118 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4119 {
4120 uint idx = salt_buf->digests_offset + digest_pos;
4121
4122 if (data.digests_shown[idx] == 1) continue;
4123
4124 uint cracked = 0;
4125
4126 if (hash_mode == 6800)
4127 {
4128 if (i == salt_buf->salt_len)
4129 {
4130 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4131 }
4132 }
4133 else if (hash_mode == 2500)
4134 {
4135 // BSSID : MAC1 : MAC2 (:plain)
4136 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4137 {
4138 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4139
4140 if (!cracked) continue;
4141
4142 // now compare MAC1 and MAC2 too, since we have this additional info
4143 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4144 char *mac2_pos = mac1_pos + 12 + 1;
4145
4146 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4147 wpa_t *wpa = &wpas[salt_pos];
4148
4149 // compare hex string(s) vs binary MAC address(es)
4150
4151 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4152 {
4153 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4154 {
4155 cracked = 0;
4156
4157 break;
4158 }
4159 }
4160
4161 // early skip ;)
4162 if (!cracked) continue;
4163
4164 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4165 {
4166 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4167 {
4168 cracked = 0;
4169
4170 break;
4171 }
4172 }
4173 }
4174 }
4175 else
4176 {
4177 char *digests_buf_ptr = (char *) data.digests_buf;
4178
4179 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4180
4181 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4182 }
4183
4184 if (cracked == 1)
4185 {
4186 found = 1;
4187
4188 data.digests_shown[idx] = 1;
4189
4190 data.digests_done++;
4191
4192 salt_buf->digests_done++;
4193
4194 if (salt_buf->digests_done == salt_buf->digests_cnt)
4195 {
4196 data.salts_shown[salt_pos] = 1;
4197
4198 data.salts_done++;
4199
4200 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4201 }
4202 }
4203 }
4204
4205 if (data.devices_status == STATUS_CRACKED) break;
4206 }
4207 }
4208
4209 if (found) break;
4210
4211 if (data.devices_status == STATUS_CRACKED) break;
4212
4213 iter--;
4214 }
4215
4216 if (data.devices_status == STATUS_CRACKED) break;
4217 }
4218
4219 myfree (line_buf);
4220
4221 out_info[j].seek = ftell (fp);
4222
4223 //hc_thread_mutex_unlock (mux_display);
4224
4225 fclose (fp);
4226 }
4227 }
4228 }
4229 }
4230
4231 check_left = outfile_check_timer;
4232 }
4233 }
4234
4235 if (esalt_size) local_free (hash_buf.esalt);
4236
4237 if (isSalted) local_free (hash_buf.salt);
4238
4239 local_free (hash_buf.digest);
4240
4241 local_free (out_info);
4242
4243 local_free (out_files);
4244
4245 p = NULL;
4246
4247 return (p);
4248 }
4249
4250 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4251 {
4252 if (device_param->pws_cnt < device_param->kernel_power)
4253 {
4254 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4255
4256 u8 *ptr = (u8 *) pw->i;
4257
4258 memcpy (ptr, pw_buf, pw_len);
4259
4260 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4261
4262 pw->pw_len = pw_len;
4263
4264 device_param->pws_cnt++;
4265 }
4266 else
4267 {
4268 fprintf (stderr, "BUG pw_add()!!\n");
4269
4270 return;
4271 }
4272 }
4273
4274 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4275 {
4276 hc_thread_mutex_lock (mux_dispatcher);
4277
4278 const u64 words_cur = data.words_cur;
4279 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4280
4281 device_param->words_off = words_cur;
4282
4283 const u64 words_left = words_base - words_cur;
4284
4285 if (allow_div)
4286 {
4287 if (data.kernel_power_all > words_left)
4288 {
4289 if (data.kernel_power_div == 0)
4290 {
4291 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4292 }
4293 }
4294
4295 if (data.kernel_power_div)
4296 {
4297 if (device_param->kernel_power == device_param->kernel_power_user)
4298 {
4299 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4300
4301 if (kernel_power_new < device_param->kernel_power)
4302 {
4303 device_param->kernel_power = kernel_power_new;
4304 }
4305 }
4306 }
4307 }
4308
4309 const uint kernel_power = device_param->kernel_power;
4310
4311 uint work = MIN (words_left, kernel_power);
4312
4313 work = MIN (work, max);
4314
4315 data.words_cur += work;
4316
4317 hc_thread_mutex_unlock (mux_dispatcher);
4318
4319 return work;
4320 }
4321
4322 static void *thread_calc_stdin (void *p)
4323 {
4324 hc_device_param_t *device_param = (hc_device_param_t *) p;
4325
4326 if (device_param->skipped) return NULL;
4327
4328 autotune (device_param);
4329
4330 char *buf = (char *) mymalloc (HCBUFSIZ);
4331
4332 const uint attack_kern = data.attack_kern;
4333
4334 const uint kernel_power = device_param->kernel_power;
4335
4336 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4337 {
4338 hc_thread_mutex_lock (mux_dispatcher);
4339
4340 if (feof (stdin) != 0)
4341 {
4342 hc_thread_mutex_unlock (mux_dispatcher);
4343
4344 break;
4345 }
4346
4347 uint words_cur = 0;
4348
4349 while (words_cur < kernel_power)
4350 {
4351 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4352
4353 if (line_buf == NULL) break;
4354
4355 uint line_len = in_superchop (line_buf);
4356
4357 line_len = convert_from_hex (line_buf, line_len);
4358
4359 // post-process rule engine
4360
4361 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4362 {
4363 char rule_buf_out[BLOCK_SIZE] = { 0 };
4364
4365 int rule_len_out = -1;
4366
4367 if (line_len < BLOCK_SIZE)
4368 {
4369 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4370 }
4371
4372 if (rule_len_out < 0) continue;
4373
4374 line_buf = rule_buf_out;
4375 line_len = rule_len_out;
4376 }
4377
4378 if (line_len > PW_MAX)
4379 {
4380 continue;
4381 }
4382
4383 if (attack_kern == ATTACK_KERN_STRAIGHT)
4384 {
4385 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4386 {
4387 hc_thread_mutex_lock (mux_counter);
4388
4389 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4390 {
4391 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4392 }
4393
4394 hc_thread_mutex_unlock (mux_counter);
4395
4396 continue;
4397 }
4398 }
4399 else if (attack_kern == ATTACK_KERN_COMBI)
4400 {
4401 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4402 // since we still need to combine the plains
4403
4404 if (line_len > data.pw_max)
4405 {
4406 hc_thread_mutex_lock (mux_counter);
4407
4408 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4409 {
4410 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4411 }
4412
4413 hc_thread_mutex_unlock (mux_counter);
4414
4415 continue;
4416 }
4417 }
4418
4419 pw_add (device_param, (u8 *) line_buf, line_len);
4420
4421 words_cur++;
4422
4423 if (data.devices_status == STATUS_CRACKED) break;
4424 if (data.devices_status == STATUS_ABORTED) break;
4425 if (data.devices_status == STATUS_QUIT) break;
4426 if (data.devices_status == STATUS_BYPASS) break;
4427 }
4428
4429 hc_thread_mutex_unlock (mux_dispatcher);
4430
4431 if (data.devices_status == STATUS_CRACKED) break;
4432 if (data.devices_status == STATUS_ABORTED) break;
4433 if (data.devices_status == STATUS_QUIT) break;
4434 if (data.devices_status == STATUS_BYPASS) break;
4435
4436 // flush
4437
4438 const uint pws_cnt = device_param->pws_cnt;
4439
4440 if (pws_cnt)
4441 {
4442 run_copy (device_param, pws_cnt);
4443
4444 run_cracker (device_param, pws_cnt);
4445
4446 device_param->pws_cnt = 0;
4447
4448 /*
4449 still required?
4450 if (attack_kern == ATTACK_KERN_STRAIGHT)
4451 {
4452 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4453 }
4454 else if (attack_kern == ATTACK_KERN_COMBI)
4455 {
4456 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4457 }
4458 */
4459 }
4460 }
4461
4462 device_param->kernel_accel = 0;
4463 device_param->kernel_loops = 0;
4464
4465 myfree (buf);
4466
4467 return NULL;
4468 }
4469
4470 static void *thread_calc (void *p)
4471 {
4472 hc_device_param_t *device_param = (hc_device_param_t *) p;
4473
4474 if (device_param->skipped) return NULL;
4475
4476 autotune (device_param);
4477
4478 const uint attack_mode = data.attack_mode;
4479 const uint attack_kern = data.attack_kern;
4480
4481 if (attack_mode == ATTACK_MODE_BF)
4482 {
4483 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4484 {
4485 const uint work = get_work (device_param, -1, true);
4486
4487 if (work == 0) break;
4488
4489 const u64 words_off = device_param->words_off;
4490 const u64 words_fin = words_off + work;
4491
4492 const uint pws_cnt = work;
4493
4494 device_param->pws_cnt = pws_cnt;
4495
4496 if (pws_cnt)
4497 {
4498 run_copy (device_param, pws_cnt);
4499
4500 run_cracker (device_param, pws_cnt);
4501
4502 device_param->pws_cnt = 0;
4503
4504 /*
4505 still required?
4506 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4507 */
4508 }
4509
4510 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4511
4512 if (data.devices_status == STATUS_CRACKED) break;
4513 if (data.devices_status == STATUS_ABORTED) break;
4514 if (data.devices_status == STATUS_QUIT) break;
4515 if (data.devices_status == STATUS_BYPASS) break;
4516
4517 if (data.benchmark == 1) break;
4518
4519 device_param->words_done = words_fin;
4520 }
4521 }
4522 else
4523 {
4524 const uint segment_size = data.segment_size;
4525
4526 char *dictfile = data.dictfile;
4527
4528 if (attack_mode == ATTACK_MODE_COMBI)
4529 {
4530 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4531 {
4532 dictfile = data.dictfile2;
4533 }
4534 }
4535
4536 FILE *fd = fopen (dictfile, "rb");
4537
4538 if (fd == NULL)
4539 {
4540 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4541
4542 return NULL;
4543 }
4544
4545 if (attack_mode == ATTACK_MODE_COMBI)
4546 {
4547 const uint combs_mode = data.combs_mode;
4548
4549 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4550 {
4551 const char *dictfilec = data.dictfile2;
4552
4553 FILE *combs_fp = fopen (dictfilec, "rb");
4554
4555 if (combs_fp == NULL)
4556 {
4557 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4558
4559 fclose (fd);
4560
4561 return NULL;
4562 }
4563
4564 device_param->combs_fp = combs_fp;
4565 }
4566 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4567 {
4568 const char *dictfilec = data.dictfile;
4569
4570 FILE *combs_fp = fopen (dictfilec, "rb");
4571
4572 if (combs_fp == NULL)
4573 {
4574 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4575
4576 fclose (fd);
4577
4578 return NULL;
4579 }
4580
4581 device_param->combs_fp = combs_fp;
4582 }
4583 }
4584
4585 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4586
4587 wl_data->buf = (char *) mymalloc (segment_size);
4588 wl_data->avail = segment_size;
4589 wl_data->incr = segment_size;
4590 wl_data->cnt = 0;
4591 wl_data->pos = 0;
4592
4593 u64 words_cur = 0;
4594
4595 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4596 {
4597 u64 words_off = 0;
4598 u64 words_fin = 0;
4599
4600 bool allow_div = true;
4601
4602 u64 max = -1;
4603
4604 while (max)
4605 {
4606 const uint work = get_work (device_param, max, allow_div);
4607
4608 allow_div = false;
4609
4610 if (work == 0) break;
4611
4612 words_off = device_param->words_off;
4613 words_fin = words_off + work;
4614
4615 char *line_buf;
4616 uint line_len;
4617
4618 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4619
4620 max = 0;
4621
4622 for ( ; words_cur < words_fin; words_cur++)
4623 {
4624 get_next_word (wl_data, fd, &line_buf, &line_len);
4625
4626 line_len = convert_from_hex (line_buf, line_len);
4627
4628 // post-process rule engine
4629
4630 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4631 {
4632 char rule_buf_out[BLOCK_SIZE] = { 0 };
4633
4634 int rule_len_out = -1;
4635
4636 if (line_len < BLOCK_SIZE)
4637 {
4638 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4639 }
4640
4641 if (rule_len_out < 0) continue;
4642
4643 line_buf = rule_buf_out;
4644 line_len = rule_len_out;
4645 }
4646
4647 if (attack_kern == ATTACK_KERN_STRAIGHT)
4648 {
4649 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4650 {
4651 max++;
4652
4653 hc_thread_mutex_lock (mux_counter);
4654
4655 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4656 {
4657 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4658 }
4659
4660 hc_thread_mutex_unlock (mux_counter);
4661
4662 continue;
4663 }
4664 }
4665 else if (attack_kern == ATTACK_KERN_COMBI)
4666 {
4667 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4668 // since we still need to combine the plains
4669
4670 if (line_len > data.pw_max)
4671 {
4672 max++;
4673
4674 hc_thread_mutex_lock (mux_counter);
4675
4676 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4677 {
4678 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4679 }
4680
4681 hc_thread_mutex_unlock (mux_counter);
4682
4683 continue;
4684 }
4685 }
4686
4687 pw_add (device_param, (u8 *) line_buf, line_len);
4688
4689 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4690
4691 if (data.devices_status == STATUS_CRACKED) break;
4692 if (data.devices_status == STATUS_ABORTED) break;
4693 if (data.devices_status == STATUS_QUIT) break;
4694 if (data.devices_status == STATUS_BYPASS) break;
4695 }
4696
4697 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4698
4699 if (data.devices_status == STATUS_CRACKED) break;
4700 if (data.devices_status == STATUS_ABORTED) break;
4701 if (data.devices_status == STATUS_QUIT) break;
4702 if (data.devices_status == STATUS_BYPASS) break;
4703 }
4704
4705 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4706
4707 if (data.devices_status == STATUS_CRACKED) break;
4708 if (data.devices_status == STATUS_ABORTED) break;
4709 if (data.devices_status == STATUS_QUIT) break;
4710 if (data.devices_status == STATUS_BYPASS) break;
4711
4712 //
4713 // flush
4714 //
4715
4716 const uint pws_cnt = device_param->pws_cnt;
4717
4718 if (pws_cnt)
4719 {
4720 run_copy (device_param, pws_cnt);
4721
4722 run_cracker (device_param, pws_cnt);
4723
4724 device_param->pws_cnt = 0;
4725
4726 /*
4727 still required?
4728 if (attack_kern == ATTACK_KERN_STRAIGHT)
4729 {
4730 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4731 }
4732 else if (attack_kern == ATTACK_KERN_COMBI)
4733 {
4734 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4735 }
4736 */
4737 }
4738
4739 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4740
4741 if (data.devices_status == STATUS_CRACKED) break;
4742 if (data.devices_status == STATUS_ABORTED) break;
4743 if (data.devices_status == STATUS_QUIT) break;
4744 if (data.devices_status == STATUS_BYPASS) break;
4745
4746 if (words_fin == 0) break;
4747
4748 device_param->words_done = words_fin;
4749 }
4750
4751 if (attack_mode == ATTACK_MODE_COMBI)
4752 {
4753 fclose (device_param->combs_fp);
4754 }
4755
4756 free (wl_data->buf);
4757 free (wl_data);
4758
4759 fclose (fd);
4760 }
4761
4762 device_param->kernel_accel = 0;
4763 device_param->kernel_loops = 0;
4764
4765 return NULL;
4766 }
4767
4768 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4769 {
4770 if (!device_param)
4771 {
4772 log_error ("ERROR: %s : Invalid argument", __func__);
4773
4774 exit (-1);
4775 }
4776
4777 salt_t *salt_buf = &data.salts_buf[salt_pos];
4778
4779 device_param->kernel_params_buf32[24] = salt_pos;
4780 device_param->kernel_params_buf32[27] = 1;
4781 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4782 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4783 device_param->kernel_params_buf32[30] = 0;
4784 device_param->kernel_params_buf32[31] = 1;
4785
4786 char *dictfile_old = data.dictfile;
4787
4788 const char *weak_hash_check = "weak-hash-check";
4789
4790 data.dictfile = (char *) weak_hash_check;
4791
4792 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4793
4794 data.kernel_rules_buf[0].cmds[0] = 0;
4795
4796 /**
4797 * run the kernel
4798 */
4799
4800 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4801 {
4802 run_kernel (KERN_RUN_1, device_param, 1, false);
4803 }
4804 else
4805 {
4806 run_kernel (KERN_RUN_1, device_param, 1, false);
4807
4808 uint loop_step = 16;
4809
4810 const uint iter = salt_buf->salt_iter;
4811
4812 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4813 {
4814 uint loop_left = iter - loop_pos;
4815
4816 loop_left = MIN (loop_left, loop_step);
4817
4818 device_param->kernel_params_buf32[25] = loop_pos;
4819 device_param->kernel_params_buf32[26] = loop_left;
4820
4821 run_kernel (KERN_RUN_2, device_param, 1, false);
4822 }
4823
4824 run_kernel (KERN_RUN_3, device_param, 1, false);
4825 }
4826
4827 /**
4828 * result
4829 */
4830
4831 check_cracked (device_param, salt_pos);
4832
4833 /**
4834 * cleanup
4835 */
4836
4837 device_param->kernel_params_buf32[24] = 0;
4838 device_param->kernel_params_buf32[25] = 0;
4839 device_param->kernel_params_buf32[26] = 0;
4840 device_param->kernel_params_buf32[27] = 0;
4841 device_param->kernel_params_buf32[28] = 0;
4842 device_param->kernel_params_buf32[29] = 0;
4843 device_param->kernel_params_buf32[30] = 0;
4844 device_param->kernel_params_buf32[31] = 0;
4845
4846 data.dictfile = dictfile_old;
4847
4848 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4849 }
4850
4851 // hlfmt hashcat
4852
4853 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4854 {
4855 if (data.username == 0)
4856 {
4857 *hashbuf_pos = line_buf;
4858 *hashbuf_len = line_len;
4859 }
4860 else
4861 {
4862 char *pos = line_buf;
4863 int len = line_len;
4864
4865 for (int i = 0; i < line_len; i++, pos++, len--)
4866 {
4867 if (line_buf[i] == data.separator)
4868 {
4869 pos++;
4870
4871 len--;
4872
4873 break;
4874 }
4875 }
4876
4877 *hashbuf_pos = pos;
4878 *hashbuf_len = len;
4879 }
4880 }
4881
4882 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4883 {
4884 char *pos = NULL;
4885 int len = 0;
4886
4887 int sep_cnt = 0;
4888
4889 for (int i = 0; i < line_len; i++)
4890 {
4891 if (line_buf[i] == data.separator)
4892 {
4893 sep_cnt++;
4894
4895 continue;
4896 }
4897
4898 if (sep_cnt == 0)
4899 {
4900 if (pos == NULL) pos = line_buf + i;
4901
4902 len++;
4903 }
4904 }
4905
4906 *userbuf_pos = pos;
4907 *userbuf_len = len;
4908 }
4909
4910 // hlfmt pwdump
4911
4912 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4913 {
4914 int sep_cnt = 0;
4915
4916 int sep2_len = 0;
4917 int sep3_len = 0;
4918
4919 for (int i = 0; i < line_len; i++)
4920 {
4921 if (line_buf[i] == ':')
4922 {
4923 sep_cnt++;
4924
4925 continue;
4926 }
4927
4928 if (sep_cnt == 2) sep2_len++;
4929 if (sep_cnt == 3) sep3_len++;
4930 }
4931
4932 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4933
4934 return 0;
4935 }
4936
4937 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4938 {
4939 char *pos = NULL;
4940 int len = 0;
4941
4942 int sep_cnt = 0;
4943
4944 for (int i = 0; i < line_len; i++)
4945 {
4946 if (line_buf[i] == ':')
4947 {
4948 sep_cnt++;
4949
4950 continue;
4951 }
4952
4953 if (data.hash_mode == 1000)
4954 {
4955 if (sep_cnt == 3)
4956 {
4957 if (pos == NULL) pos = line_buf + i;
4958
4959 len++;
4960 }
4961 }
4962 else if (data.hash_mode == 3000)
4963 {
4964 if (sep_cnt == 2)
4965 {
4966 if (pos == NULL) pos = line_buf + i;
4967
4968 len++;
4969 }
4970 }
4971 }
4972
4973 *hashbuf_pos = pos;
4974 *hashbuf_len = len;
4975 }
4976
4977 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4978 {
4979 char *pos = NULL;
4980 int len = 0;
4981
4982 int sep_cnt = 0;
4983
4984 for (int i = 0; i < line_len; i++)
4985 {
4986 if (line_buf[i] == ':')
4987 {
4988 sep_cnt++;
4989
4990 continue;
4991 }
4992
4993 if (sep_cnt == 0)
4994 {
4995 if (pos == NULL) pos = line_buf + i;
4996
4997 len++;
4998 }
4999 }
5000
5001 *userbuf_pos = pos;
5002 *userbuf_len = len;
5003 }
5004
5005 // hlfmt passwd
5006
5007 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5008 {
5009 int sep_cnt = 0;
5010
5011 char sep5_first = 0;
5012 char sep6_first = 0;
5013
5014 for (int i = 0; i < line_len; i++)
5015 {
5016 if (line_buf[i] == ':')
5017 {
5018 sep_cnt++;
5019
5020 continue;
5021 }
5022
5023 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5024 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5025 }
5026
5027 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5028
5029 return 0;
5030 }
5031
5032 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5033 {
5034 char *pos = NULL;
5035 int len = 0;
5036
5037 int sep_cnt = 0;
5038
5039 for (int i = 0; i < line_len; i++)
5040 {
5041 if (line_buf[i] == ':')
5042 {
5043 sep_cnt++;
5044
5045 continue;
5046 }
5047
5048 if (sep_cnt == 1)
5049 {
5050 if (pos == NULL) pos = line_buf + i;
5051
5052 len++;
5053 }
5054 }
5055
5056 *hashbuf_pos = pos;
5057 *hashbuf_len = len;
5058 }
5059
5060 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5061 {
5062 char *pos = NULL;
5063 int len = 0;
5064
5065 int sep_cnt = 0;
5066
5067 for (int i = 0; i < line_len; i++)
5068 {
5069 if (line_buf[i] == ':')
5070 {
5071 sep_cnt++;
5072
5073 continue;
5074 }
5075
5076 if (sep_cnt == 0)
5077 {
5078 if (pos == NULL) pos = line_buf + i;
5079
5080 len++;
5081 }
5082 }
5083
5084 *userbuf_pos = pos;
5085 *userbuf_len = len;
5086 }
5087
5088 // hlfmt shadow
5089
5090 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5091 {
5092 int sep_cnt = 0;
5093
5094 for (int i = 0; i < line_len; i++)
5095 {
5096 if (line_buf[i] == ':') sep_cnt++;
5097 }
5098
5099 if (sep_cnt == 8) return 1;
5100
5101 return 0;
5102 }
5103
5104 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5105 {
5106 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5107 }
5108
5109 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5110 {
5111 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5112 }
5113
5114 // hlfmt main
5115
5116 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5117 {
5118 switch (hashfile_format)
5119 {
5120 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5121 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5122 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5123 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5124 }
5125 }
5126
5127 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5128 {
5129 switch (hashfile_format)
5130 {
5131 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5132 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5133 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5134 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5135 }
5136 }
5137
5138 char *strhlfmt (const uint hashfile_format)
5139 {
5140 switch (hashfile_format)
5141 {
5142 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5143 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5144 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5145 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5146 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5147 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5148 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5149 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5150 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5151 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5152 }
5153
5154 return ((char *) "Unknown");
5155 }
5156
5157 static uint hlfmt_detect (FILE *fp, uint max_check)
5158 {
5159 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5160
5161 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5162 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5163
5164 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5165
5166 uint num_check = 0;
5167
5168 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5169
5170 while (!feof (fp))
5171 {
5172 int line_len = fgetl (fp, line_buf);
5173
5174 if (line_len == 0) continue;
5175
5176 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5177 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5178 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5179
5180 if (num_check == max_check) break;
5181
5182 num_check++;
5183 }
5184
5185 myfree (line_buf);
5186
5187 uint hashlist_format = HLFMT_HASHCAT;
5188
5189 for (int i = 1; i < HLFMTS_CNT; i++)
5190 {
5191 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5192
5193 hashlist_format = i;
5194 }
5195
5196 free (formats_cnt);
5197
5198 return hashlist_format;
5199 }
5200
5201 /**
5202 * some further helper function
5203 */
5204
5205 // wrapper around mymalloc for ADL
5206
5207 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5208 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5209 {
5210 return mymalloc (iSize);
5211 }
5212 #endif
5213
5214 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)
5215 {
5216 u64 collisions = 0;
5217
5218 const uint dgst_pos0 = data.dgst_pos0;
5219 const uint dgst_pos1 = data.dgst_pos1;
5220 const uint dgst_pos2 = data.dgst_pos2;
5221 const uint dgst_pos3 = data.dgst_pos3;
5222
5223 memset (bitmap_a, 0, bitmap_size);
5224 memset (bitmap_b, 0, bitmap_size);
5225 memset (bitmap_c, 0, bitmap_size);
5226 memset (bitmap_d, 0, bitmap_size);
5227
5228 for (uint i = 0; i < digests_cnt; i++)
5229 {
5230 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5231
5232 uint *digest_ptr = (uint *) digests_buf_ptr;
5233
5234 digests_buf_ptr += dgst_size;
5235
5236 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5237 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5238 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5239 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5240
5241 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5242 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5243 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5244 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5245
5246 if (bitmap_a[idx0] & val0) collisions++;
5247 if (bitmap_b[idx1] & val1) collisions++;
5248 if (bitmap_c[idx2] & val2) collisions++;
5249 if (bitmap_d[idx3] & val3) collisions++;
5250
5251 bitmap_a[idx0] |= val0;
5252 bitmap_b[idx1] |= val1;
5253 bitmap_c[idx2] |= val2;
5254 bitmap_d[idx3] |= val3;
5255
5256 if (collisions >= collisions_max) return 0x7fffffff;
5257 }
5258
5259 return collisions;
5260 }
5261
5262 /**
5263 * main
5264 */
5265
5266 int main (int argc, char **argv)
5267 {
5268 /**
5269 * To help users a bit
5270 */
5271
5272 char *compute = getenv ("COMPUTE");
5273
5274 if (compute)
5275 {
5276 static char display[100];
5277
5278 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5279
5280 putenv (display);
5281 }
5282 else
5283 {
5284 if (getenv ("DISPLAY") == NULL)
5285 putenv ((char *) "DISPLAY=:0");
5286 }
5287
5288 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5289 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5290
5291 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5292 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5293
5294 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5295 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5296
5297 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5298 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5299
5300 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5301 putenv ((char *) "POCL_KERNEL_CACHE=0");
5302
5303 umask (077);
5304
5305 /**
5306 * Real init
5307 */
5308
5309 memset (&data, 0, sizeof (hc_global_data_t));
5310
5311 time_t proc_start;
5312
5313 time (&proc_start);
5314
5315 data.proc_start = proc_start;
5316
5317 int myargc = argc;
5318 char **myargv = argv;
5319
5320 hc_thread_mutex_init (mux_dispatcher);
5321 hc_thread_mutex_init (mux_counter);
5322 hc_thread_mutex_init (mux_display);
5323 hc_thread_mutex_init (mux_adl);
5324
5325 /**
5326 * commandline parameters
5327 */
5328
5329 uint usage = USAGE;
5330 uint version = VERSION;
5331 uint quiet = QUIET;
5332 uint benchmark = BENCHMARK;
5333 uint show = SHOW;
5334 uint left = LEFT;
5335 uint username = USERNAME;
5336 uint remove = REMOVE;
5337 uint remove_timer = REMOVE_TIMER;
5338 u64 skip = SKIP;
5339 u64 limit = LIMIT;
5340 uint keyspace = KEYSPACE;
5341 uint potfile_disable = POTFILE_DISABLE;
5342 char *potfile_path = NULL;
5343 uint debug_mode = DEBUG_MODE;
5344 char *debug_file = NULL;
5345 char *induction_dir = NULL;
5346 char *outfile_check_dir = NULL;
5347 uint force = FORCE;
5348 uint runtime = RUNTIME;
5349 uint hash_mode = HASH_MODE;
5350 uint attack_mode = ATTACK_MODE;
5351 uint markov_disable = MARKOV_DISABLE;
5352 uint markov_classic = MARKOV_CLASSIC;
5353 uint markov_threshold = MARKOV_THRESHOLD;
5354 char *markov_hcstat = NULL;
5355 char *outfile = NULL;
5356 uint outfile_format = OUTFILE_FORMAT;
5357 uint outfile_autohex = OUTFILE_AUTOHEX;
5358 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5359 uint restore = RESTORE;
5360 uint restore_timer = RESTORE_TIMER;
5361 uint restore_disable = RESTORE_DISABLE;
5362 uint status = STATUS;
5363 uint status_timer = STATUS_TIMER;
5364 uint status_automat = STATUS_AUTOMAT;
5365 uint loopback = LOOPBACK;
5366 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5367 char *session = NULL;
5368 uint hex_charset = HEX_CHARSET;
5369 uint hex_salt = HEX_SALT;
5370 uint hex_wordlist = HEX_WORDLIST;
5371 uint rp_gen = RP_GEN;
5372 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5373 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5374 uint rp_gen_seed = RP_GEN_SEED;
5375 char *rule_buf_l = (char *) RULE_BUF_L;
5376 char *rule_buf_r = (char *) RULE_BUF_R;
5377 uint increment = INCREMENT;
5378 uint increment_min = INCREMENT_MIN;
5379 uint increment_max = INCREMENT_MAX;
5380 char *cpu_affinity = NULL;
5381 OCL_PTR *ocl = NULL;
5382 char *opencl_devices = NULL;
5383 char *opencl_platforms = NULL;
5384 char *opencl_device_types = NULL;
5385 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5386 char *truecrypt_keyfiles = NULL;
5387 char *veracrypt_keyfiles = NULL;
5388 uint veracrypt_pim = 0;
5389 uint workload_profile = WORKLOAD_PROFILE;
5390 uint kernel_accel = KERNEL_ACCEL;
5391 uint kernel_loops = KERNEL_LOOPS;
5392 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5393 #ifdef HAVE_HWMON
5394 uint gpu_temp_abort = GPU_TEMP_ABORT;
5395 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5396 #ifdef HAVE_ADL
5397 uint powertune_enable = POWERTUNE_ENABLE;
5398 #endif
5399 #endif
5400 uint logfile_disable = LOGFILE_DISABLE;
5401 uint segment_size = SEGMENT_SIZE;
5402 uint scrypt_tmto = SCRYPT_TMTO;
5403 char separator = SEPARATOR;
5404 uint bitmap_min = BITMAP_MIN;
5405 uint bitmap_max = BITMAP_MAX;
5406 char *custom_charset_1 = NULL;
5407 char *custom_charset_2 = NULL;
5408 char *custom_charset_3 = NULL;
5409 char *custom_charset_4 = NULL;
5410
5411 #define IDX_HELP 'h'
5412 #define IDX_VERSION 'V'
5413 #define IDX_VERSION_LOWER 'v'
5414 #define IDX_QUIET 0xff02
5415 #define IDX_SHOW 0xff03
5416 #define IDX_LEFT 0xff04
5417 #define IDX_REMOVE 0xff05
5418 #define IDX_REMOVE_TIMER 0xff37
5419 #define IDX_SKIP 's'
5420 #define IDX_LIMIT 'l'
5421 #define IDX_KEYSPACE 0xff35
5422 #define IDX_POTFILE_DISABLE 0xff06
5423 #define IDX_POTFILE_PATH 0xffe0
5424 #define IDX_DEBUG_MODE 0xff43
5425 #define IDX_DEBUG_FILE 0xff44
5426 #define IDX_INDUCTION_DIR 0xff46
5427 #define IDX_OUTFILE_CHECK_DIR 0xff47
5428 #define IDX_USERNAME 0xff07
5429 #define IDX_FORCE 0xff08
5430 #define IDX_RUNTIME 0xff09
5431 #define IDX_BENCHMARK 'b'
5432 #define IDX_HASH_MODE 'm'
5433 #define IDX_ATTACK_MODE 'a'
5434 #define IDX_RP_FILE 'r'
5435 #define IDX_RP_GEN 'g'
5436 #define IDX_RP_GEN_FUNC_MIN 0xff10
5437 #define IDX_RP_GEN_FUNC_MAX 0xff11
5438 #define IDX_RP_GEN_SEED 0xff34
5439 #define IDX_RULE_BUF_L 'j'
5440 #define IDX_RULE_BUF_R 'k'
5441 #define IDX_INCREMENT 'i'
5442 #define IDX_INCREMENT_MIN 0xff12
5443 #define IDX_INCREMENT_MAX 0xff13
5444 #define IDX_OUTFILE 'o'
5445 #define IDX_OUTFILE_FORMAT 0xff14
5446 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5447 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5448 #define IDX_RESTORE 0xff15
5449 #define IDX_RESTORE_DISABLE 0xff27
5450 #define IDX_STATUS 0xff17
5451 #define IDX_STATUS_TIMER 0xff18
5452 #define IDX_STATUS_AUTOMAT 0xff50
5453 #define IDX_LOOPBACK 0xff38
5454 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5455 #define IDX_SESSION 0xff19
5456 #define IDX_HEX_CHARSET 0xff20
5457 #define IDX_HEX_SALT 0xff21
5458 #define IDX_HEX_WORDLIST 0xff40
5459 #define IDX_MARKOV_DISABLE 0xff22
5460 #define IDX_MARKOV_CLASSIC 0xff23
5461 #define IDX_MARKOV_THRESHOLD 't'
5462 #define IDX_MARKOV_HCSTAT 0xff24
5463 #define IDX_CPU_AFFINITY 0xff25
5464 #define IDX_OPENCL_DEVICES 'd'
5465 #define IDX_OPENCL_PLATFORMS 0xff72
5466 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5467 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5468 #define IDX_WORKLOAD_PROFILE 'w'
5469 #define IDX_KERNEL_ACCEL 'n'
5470 #define IDX_KERNEL_LOOPS 'u'
5471 #define IDX_GPU_TEMP_DISABLE 0xff29
5472 #define IDX_GPU_TEMP_ABORT 0xff30
5473 #define IDX_GPU_TEMP_RETAIN 0xff31
5474 #define IDX_POWERTUNE_ENABLE 0xff41
5475 #define IDX_LOGFILE_DISABLE 0xff51
5476 #define IDX_TRUECRYPT_KEYFILES 0xff52
5477 #define IDX_VERACRYPT_KEYFILES 0xff53
5478 #define IDX_VERACRYPT_PIM 0xff54
5479 #define IDX_SCRYPT_TMTO 0xff61
5480 #define IDX_SEGMENT_SIZE 'c'
5481 #define IDX_SEPARATOR 'p'
5482 #define IDX_BITMAP_MIN 0xff70
5483 #define IDX_BITMAP_MAX 0xff71
5484 #define IDX_CUSTOM_CHARSET_1 '1'
5485 #define IDX_CUSTOM_CHARSET_2 '2'
5486 #define IDX_CUSTOM_CHARSET_3 '3'
5487 #define IDX_CUSTOM_CHARSET_4 '4'
5488
5489 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5490
5491 struct option long_options[] =
5492 {
5493 {"help", no_argument, 0, IDX_HELP},
5494 {"version", no_argument, 0, IDX_VERSION},
5495 {"quiet", no_argument, 0, IDX_QUIET},
5496 {"show", no_argument, 0, IDX_SHOW},
5497 {"left", no_argument, 0, IDX_LEFT},
5498 {"username", no_argument, 0, IDX_USERNAME},
5499 {"remove", no_argument, 0, IDX_REMOVE},
5500 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5501 {"skip", required_argument, 0, IDX_SKIP},
5502 {"limit", required_argument, 0, IDX_LIMIT},
5503 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5504 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5505 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5506 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5507 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5508 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5509 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5510 {"force", no_argument, 0, IDX_FORCE},
5511 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5512 {"restore", no_argument, 0, IDX_RESTORE},
5513 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5514 {"status", no_argument, 0, IDX_STATUS},
5515 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5516 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5517 {"loopback", no_argument, 0, IDX_LOOPBACK},
5518 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5519 {"session", required_argument, 0, IDX_SESSION},
5520 {"runtime", required_argument, 0, IDX_RUNTIME},
5521 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5522 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5523 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5524 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5525 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5526 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5527 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5528 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5529 {"rules-file", required_argument, 0, IDX_RP_FILE},
5530 {"outfile", required_argument, 0, IDX_OUTFILE},
5531 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5532 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5533 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5534 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5535 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5536 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5537 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5538 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5539 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5540 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5541 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5542 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5543 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5544 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5545 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5546 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5547 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5548 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5549 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5550 #ifdef HAVE_HWMON
5551 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5552 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5553 #ifdef HAVE_ADL
5554 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5555 #endif
5556 #endif // HAVE_HWMON
5557 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5558 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5559 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5560 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5561 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5562 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5563 {"seperator", required_argument, 0, IDX_SEPARATOR},
5564 {"separator", required_argument, 0, IDX_SEPARATOR},
5565 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5566 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5567 {"increment", no_argument, 0, IDX_INCREMENT},
5568 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5569 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5570 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5571 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5572 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5573 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5574 {0, 0, 0, 0}
5575 };
5576
5577 uint rp_files_cnt = 0;
5578
5579 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5580
5581 int option_index = 0;
5582 int c = -1;
5583
5584 optind = 1;
5585 optopt = 0;
5586
5587 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5588 {
5589 switch (c)
5590 {
5591 case IDX_HELP: usage = 1; break;
5592 case IDX_VERSION:
5593 case IDX_VERSION_LOWER: version = 1; break;
5594 case IDX_RESTORE: restore = 1; break;
5595 case IDX_SESSION: session = optarg; break;
5596 case IDX_SHOW: show = 1; break;
5597 case IDX_LEFT: left = 1; break;
5598 case '?': return (-1);
5599 }
5600 }
5601
5602 if (optopt != 0)
5603 {
5604 log_error ("ERROR: Invalid argument specified");
5605
5606 return (-1);
5607 }
5608
5609 /**
5610 * exit functions
5611 */
5612
5613 if (version)
5614 {
5615 log_info ("%s", VERSION_TAG);
5616
5617 return (0);
5618 }
5619
5620 if (usage)
5621 {
5622 usage_big_print (PROGNAME);
5623
5624 return (0);
5625 }
5626
5627 /**
5628 * session needs to be set, always!
5629 */
5630
5631 if (session == NULL) session = (char *) PROGNAME;
5632
5633 /**
5634 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5635 */
5636
5637 char *exec_path = get_exec_path ();
5638
5639 #ifdef LINUX
5640
5641 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5642 char *resolved_exec_path = realpath (exec_path, NULL);
5643
5644 char *install_dir = get_install_dir (resolved_exec_path);
5645 char *profile_dir = NULL;
5646 char *session_dir = NULL;
5647 char *shared_dir = NULL;
5648
5649 if (strcmp (install_dir, resolved_install_folder) == 0)
5650 {
5651 struct passwd *pw = getpwuid (getuid ());
5652
5653 const char *homedir = pw->pw_dir;
5654
5655 profile_dir = get_profile_dir (homedir);
5656 session_dir = get_session_dir (profile_dir);
5657 shared_dir = strdup (SHARED_FOLDER);
5658
5659 mkdir (profile_dir, 0700);
5660 mkdir (session_dir, 0700);
5661 }
5662 else
5663 {
5664 profile_dir = install_dir;
5665 session_dir = install_dir;
5666 shared_dir = install_dir;
5667 }
5668
5669 myfree (resolved_install_folder);
5670 myfree (resolved_exec_path);
5671
5672 #else
5673
5674 char *install_dir = get_install_dir (exec_path);
5675 char *profile_dir = install_dir;
5676 char *session_dir = install_dir;
5677 char *shared_dir = install_dir;
5678
5679 #endif
5680
5681 data.install_dir = install_dir;
5682 data.profile_dir = profile_dir;
5683 data.session_dir = session_dir;
5684 data.shared_dir = shared_dir;
5685
5686 myfree (exec_path);
5687
5688 /**
5689 * kernel cache, we need to make sure folder exist
5690 */
5691
5692 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5693
5694 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5695
5696 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5697
5698 mkdir (kernels_folder, 0700);
5699
5700 myfree (kernels_folder);
5701
5702 /**
5703 * session
5704 */
5705
5706 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5707
5708 data.session = session;
5709
5710 char *eff_restore_file = (char *) mymalloc (session_size);
5711 char *new_restore_file = (char *) mymalloc (session_size);
5712
5713 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5714 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5715
5716 data.eff_restore_file = eff_restore_file;
5717 data.new_restore_file = new_restore_file;
5718
5719 if (((show == 1) || (left == 1)) && (restore == 1))
5720 {
5721 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5722 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5723
5724 return (-1);
5725 }
5726
5727 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5728 if ((show == 1) || (left == 1))
5729 {
5730 restore_disable = 1;
5731
5732 restore = 0;
5733 }
5734
5735 data.restore_disable = restore_disable;
5736
5737 restore_data_t *rd = init_restore (argc, argv);
5738
5739 data.rd = rd;
5740
5741 /**
5742 * restore file
5743 */
5744
5745 if (restore == 1)
5746 {
5747 read_restore (eff_restore_file, rd);
5748
5749 if (rd->version_bin < RESTORE_MIN)
5750 {
5751 log_error ("ERROR: Incompatible restore-file version");
5752
5753 return (-1);
5754 }
5755
5756 myargc = rd->argc;
5757 myargv = rd->argv;
5758
5759 #ifdef _POSIX
5760 rd->pid = getpid ();
5761 #elif _WIN
5762 rd->pid = GetCurrentProcessId ();
5763 #endif
5764 }
5765
5766 uint hash_mode_chgd = 0;
5767 uint runtime_chgd = 0;
5768 uint kernel_loops_chgd = 0;
5769 uint kernel_accel_chgd = 0;
5770 uint attack_mode_chgd = 0;
5771 uint outfile_format_chgd = 0;
5772 uint rp_gen_seed_chgd = 0;
5773 uint remove_timer_chgd = 0;
5774 uint increment_min_chgd = 0;
5775 uint increment_max_chgd = 0;
5776 uint workload_profile_chgd = 0;
5777 uint opencl_vector_width_chgd = 0;
5778
5779 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5780 uint gpu_temp_retain_chgd = 0;
5781 uint gpu_temp_abort_chgd = 0;
5782 #endif
5783
5784 optind = 1;
5785 optopt = 0;
5786 option_index = 0;
5787
5788 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5789 {
5790 switch (c)
5791 {
5792 //case IDX_HELP: usage = 1; break;
5793 //case IDX_VERSION: version = 1; break;
5794 //case IDX_RESTORE: restore = 1; break;
5795 case IDX_QUIET: quiet = 1; break;
5796 //case IDX_SHOW: show = 1; break;
5797 case IDX_SHOW: break;
5798 //case IDX_LEFT: left = 1; break;
5799 case IDX_LEFT: break;
5800 case IDX_USERNAME: username = 1; break;
5801 case IDX_REMOVE: remove = 1; break;
5802 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5803 remove_timer_chgd = 1; break;
5804 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5805 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5806 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5807 case IDX_DEBUG_FILE: debug_file = optarg; break;
5808 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5809 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5810 case IDX_FORCE: force = 1; break;
5811 case IDX_SKIP: skip = atoll (optarg); break;
5812 case IDX_LIMIT: limit = atoll (optarg); break;
5813 case IDX_KEYSPACE: keyspace = 1; break;
5814 case IDX_BENCHMARK: benchmark = 1; break;
5815 case IDX_RESTORE: break;
5816 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5817 case IDX_STATUS: status = 1; break;
5818 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5819 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5820 case IDX_LOOPBACK: loopback = 1; break;
5821 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5822 //case IDX_SESSION: session = optarg; break;
5823 case IDX_SESSION: break;
5824 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5825 hash_mode_chgd = 1; break;
5826 case IDX_RUNTIME: runtime = atoi (optarg);
5827 runtime_chgd = 1; break;
5828 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5829 attack_mode_chgd = 1; break;
5830 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5831 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5832 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5833 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5834 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5835 rp_gen_seed_chgd = 1; break;
5836 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5837 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5838 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5839 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5840 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5841 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5842 case IDX_OUTFILE: outfile = optarg; break;
5843 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5844 outfile_format_chgd = 1; break;
5845 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5846 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5847 case IDX_HEX_CHARSET: hex_charset = 1; break;
5848 case IDX_HEX_SALT: hex_salt = 1; break;
5849 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5850 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5851 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5852 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5853 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5854 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5855 opencl_vector_width_chgd = 1; break;
5856 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5857 workload_profile_chgd = 1; break;
5858 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5859 kernel_accel_chgd = 1; break;
5860 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5861 kernel_loops_chgd = 1; break;
5862 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5863 #ifdef HAVE_HWMON
5864 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5865 #ifdef HAVE_ADL
5866 gpu_temp_abort_chgd = 1;
5867 #endif
5868 break;
5869 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5870 #ifdef HAVE_ADL
5871 gpu_temp_retain_chgd = 1;
5872 #endif
5873 break;
5874 #ifdef HAVE_ADL
5875 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5876 #endif
5877 #endif // HAVE_HWMON
5878 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5879 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5880 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5881 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5882 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5883 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5884 case IDX_SEPARATOR: separator = optarg[0]; break;
5885 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5886 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5887 case IDX_INCREMENT: increment = 1; break;
5888 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5889 increment_min_chgd = 1; break;
5890 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5891 increment_max_chgd = 1; break;
5892 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5893 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5894 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5895 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5896
5897 default:
5898 log_error ("ERROR: Invalid argument specified");
5899 return (-1);
5900 }
5901 }
5902
5903 if (optopt != 0)
5904 {
5905 log_error ("ERROR: Invalid argument specified");
5906
5907 return (-1);
5908 }
5909
5910 /**
5911 * Inform user things getting started,
5912 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5913 * - we do not need to check algorithm_pos
5914 */
5915
5916 if (quiet == 0)
5917 {
5918 if (benchmark == 1)
5919 {
5920 if (status_automat == 0)
5921 {
5922 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5923 log_info ("");
5924 }
5925 else
5926 {
5927 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5928 }
5929 }
5930 else if (restore == 1)
5931 {
5932 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5933 log_info ("");
5934 }
5935 else
5936 {
5937 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5938 log_info ("");
5939 }
5940 }
5941
5942 /**
5943 * sanity check
5944 */
5945
5946 if (attack_mode > 7)
5947 {
5948 log_error ("ERROR: Invalid attack-mode specified");
5949
5950 return (-1);
5951 }
5952
5953 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5954 {
5955 log_error ("ERROR: Invalid runtime specified");
5956
5957 return (-1);
5958 }
5959
5960 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5961 {
5962 log_error ("ERROR: Invalid hash-type specified");
5963
5964 return (-1);
5965 }
5966
5967 // renamed hash modes
5968
5969 if (hash_mode_chgd)
5970 {
5971 int n = -1;
5972
5973 switch (hash_mode)
5974 {
5975 case 123: n = 124;
5976 break;
5977 }
5978
5979 if (n >= 0)
5980 {
5981 log_error ("Old -m specified, use -m %d instead", n);
5982
5983 return (-1);
5984 }
5985 }
5986
5987 if (username == 1)
5988 {
5989 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5990 {
5991 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5992
5993 return (-1);
5994 }
5995 }
5996
5997 if (outfile_format > 16)
5998 {
5999 log_error ("ERROR: Invalid outfile-format specified");
6000
6001 return (-1);
6002 }
6003
6004 if (left == 1)
6005 {
6006 if (outfile_format_chgd == 1)
6007 {
6008 if (outfile_format > 1)
6009 {
6010 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6011
6012 return (-1);
6013 }
6014 }
6015 else
6016 {
6017 outfile_format = OUTFILE_FMT_HASH;
6018 }
6019 }
6020
6021 if (show == 1)
6022 {
6023 if (outfile_format_chgd == 1)
6024 {
6025 if ((outfile_format > 7) && (outfile_format < 16))
6026 {
6027 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6028
6029 return (-1);
6030 }
6031 }
6032 }
6033
6034 if (increment_min < INCREMENT_MIN)
6035 {
6036 log_error ("ERROR: Invalid increment-min specified");
6037
6038 return (-1);
6039 }
6040
6041 if (increment_max > INCREMENT_MAX)
6042 {
6043 log_error ("ERROR: Invalid increment-max specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_min > increment_max)
6049 {
6050 log_error ("ERROR: Invalid increment-min specified");
6051
6052 return (-1);
6053 }
6054
6055 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6056 {
6057 log_error ("ERROR: increment is not allowed in attack-mode 0");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 0) && (increment_min_chgd == 1))
6063 {
6064 log_error ("ERROR: increment-min is only supported together with increment switch");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_max_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-max is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if (rp_files_cnt && rp_gen)
6077 {
6078 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt || rp_gen)
6084 {
6085 if (attack_mode != ATTACK_MODE_STRAIGHT)
6086 {
6087 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6088
6089 return (-1);
6090 }
6091 }
6092
6093 if (rp_gen_func_min > rp_gen_func_max)
6094 {
6095 log_error ("ERROR: Invalid rp-gen-func-min specified");
6096
6097 return (-1);
6098 }
6099
6100 if (kernel_accel_chgd == 1)
6101 {
6102 if (force == 0)
6103 {
6104 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6105 log_info ("Please consider using the option -w instead");
6106 log_info ("You can use --force to override this but do not post error reports if you do so");
6107 log_info ("");
6108
6109 return (-1);
6110 }
6111
6112 if (kernel_accel < 1)
6113 {
6114 log_error ("ERROR: Invalid kernel-accel specified");
6115
6116 return (-1);
6117 }
6118
6119 if (kernel_accel > 1024)
6120 {
6121 log_error ("ERROR: Invalid kernel-accel specified");
6122
6123 return (-1);
6124 }
6125 }
6126
6127 if (kernel_loops_chgd == 1)
6128 {
6129 if (force == 0)
6130 {
6131 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6132 log_info ("Please consider using the option -w instead");
6133 log_info ("You can use --force to override this but do not post error reports if you do so");
6134 log_info ("");
6135
6136 return (-1);
6137 }
6138
6139 if (kernel_loops < 1)
6140 {
6141 log_error ("ERROR: Invalid kernel-loops specified");
6142
6143 return (-1);
6144 }
6145
6146 if (kernel_loops > 1024)
6147 {
6148 log_error ("ERROR: Invalid kernel-loops specified");
6149
6150 return (-1);
6151 }
6152 }
6153
6154 if ((workload_profile < 1) || (workload_profile > 3))
6155 {
6156 log_error ("ERROR: workload-profile %i not available", workload_profile);
6157
6158 return (-1);
6159 }
6160
6161 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6162 {
6163 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6164
6165 return (-1);
6166 }
6167
6168 if (show == 1 || left == 1)
6169 {
6170 attack_mode = ATTACK_MODE_NONE;
6171
6172 if (remove == 1)
6173 {
6174 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6175
6176 return (-1);
6177 }
6178
6179 if (potfile_disable == 1)
6180 {
6181 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6182
6183 return (-1);
6184 }
6185 }
6186
6187 uint attack_kern = ATTACK_KERN_NONE;
6188
6189 switch (attack_mode)
6190 {
6191 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6192 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6193 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6194 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6195 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6196 }
6197
6198 if (benchmark == 0)
6199 {
6200 if (keyspace == 1)
6201 {
6202 int num_additional_params = 1;
6203
6204 if (attack_kern == ATTACK_KERN_COMBI)
6205 {
6206 num_additional_params = 2;
6207 }
6208
6209 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6210
6211 if (keyspace_wordlist_specified == 0) optind--;
6212 }
6213
6214 if (attack_kern == ATTACK_KERN_NONE)
6215 {
6216 if ((optind + 1) != myargc)
6217 {
6218 usage_mini_print (myargv[0]);
6219
6220 return (-1);
6221 }
6222 }
6223 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6224 {
6225 if ((optind + 1) > myargc)
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else if (attack_kern == ATTACK_KERN_COMBI)
6233 {
6234 if ((optind + 3) != myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else if (attack_kern == ATTACK_KERN_BF)
6242 {
6243 if ((optind + 1) > myargc)
6244 {
6245 usage_mini_print (myargv[0]);
6246
6247 return (-1);
6248 }
6249 }
6250 else
6251 {
6252 usage_mini_print (myargv[0]);
6253
6254 return (-1);
6255 }
6256 }
6257 else
6258 {
6259 if (myargv[optind] != 0)
6260 {
6261 log_error ("ERROR: Invalid argument for benchmark mode specified");
6262
6263 return (-1);
6264 }
6265
6266 if (attack_mode_chgd == 1)
6267 {
6268 if (attack_mode != ATTACK_MODE_BF)
6269 {
6270 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6271
6272 return (-1);
6273 }
6274 }
6275 }
6276
6277 if (skip != 0 && limit != 0)
6278 {
6279 limit += skip;
6280 }
6281
6282 if (keyspace == 1)
6283 {
6284 if (show == 1)
6285 {
6286 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6287
6288 return (-1);
6289 }
6290 else if (left == 1)
6291 {
6292 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6293
6294 return (-1);
6295 }
6296
6297 potfile_disable = 1;
6298
6299 restore_disable = 1;
6300
6301 restore = 0;
6302
6303 weak_hash_threshold = 0;
6304
6305 quiet = 1;
6306 }
6307
6308 if (remove_timer_chgd == 1)
6309 {
6310 if (remove == 0)
6311 {
6312 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6313
6314 return (-1);
6315 }
6316
6317 if (remove_timer < 1)
6318 {
6319 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6320
6321 return (-1);
6322 }
6323 }
6324
6325 if (loopback == 1)
6326 {
6327 if (attack_mode == ATTACK_MODE_STRAIGHT)
6328 {
6329 if ((rp_files_cnt == 0) && (rp_gen == 0))
6330 {
6331 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6332
6333 return (-1);
6334 }
6335 }
6336 else
6337 {
6338 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6339
6340 return (-1);
6341 }
6342 }
6343
6344 if (debug_mode > 0)
6345 {
6346 if (attack_mode != ATTACK_MODE_STRAIGHT)
6347 {
6348 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6349
6350 return (-1);
6351 }
6352
6353 if ((rp_files_cnt == 0) && (rp_gen == 0))
6354 {
6355 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6356
6357 return (-1);
6358 }
6359 }
6360
6361 if (debug_mode > 4)
6362 {
6363 log_error ("ERROR: Invalid debug-mode specified");
6364
6365 return (-1);
6366 }
6367
6368 if (debug_file != NULL)
6369 {
6370 if (debug_mode < 1)
6371 {
6372 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6373
6374 return (-1);
6375 }
6376 }
6377
6378 if (induction_dir != NULL)
6379 {
6380 if (attack_mode == ATTACK_MODE_BF)
6381 {
6382 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6383
6384 return (-1);
6385 }
6386 }
6387
6388 if (attack_mode != ATTACK_MODE_STRAIGHT)
6389 {
6390 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6391 {
6392 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6393
6394 return (-1);
6395 }
6396
6397 weak_hash_threshold = 0;
6398 }
6399
6400 /**
6401 * induction directory
6402 */
6403
6404 char *induction_directory = NULL;
6405
6406 if (attack_mode != ATTACK_MODE_BF)
6407 {
6408 if (induction_dir == NULL)
6409 {
6410 induction_directory = (char *) mymalloc (session_size);
6411
6412 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6413
6414 // create induction folder if it does not already exist
6415
6416 if (keyspace == 0)
6417 {
6418 if (rmdir (induction_directory) == -1)
6419 {
6420 if (errno == ENOENT)
6421 {
6422 // good, we can ignore
6423 }
6424 else if (errno == ENOTEMPTY)
6425 {
6426 char *induction_directory_mv = (char *) mymalloc (session_size);
6427
6428 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6429
6430 if (rename (induction_directory, induction_directory_mv) != 0)
6431 {
6432 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6433
6434 return (-1);
6435 }
6436 }
6437 else
6438 {
6439 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6440
6441 return (-1);
6442 }
6443 }
6444
6445 if (mkdir (induction_directory, 0700) == -1)
6446 {
6447 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6448
6449 return (-1);
6450 }
6451 }
6452 }
6453 else
6454 {
6455 induction_directory = induction_dir;
6456 }
6457 }
6458
6459 data.induction_directory = induction_directory;
6460
6461 /**
6462 * loopback
6463 */
6464
6465 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6466
6467 char *loopback_file = (char *) mymalloc (loopback_size);
6468
6469 /**
6470 * tuning db
6471 */
6472
6473 char tuning_db_file[256] = { 0 };
6474
6475 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6476
6477 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6478
6479 /**
6480 * outfile-check directory
6481 */
6482
6483 char *outfile_check_directory = NULL;
6484
6485 if (outfile_check_dir == NULL)
6486 {
6487 outfile_check_directory = (char *) mymalloc (session_size);
6488
6489 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6490 }
6491 else
6492 {
6493 outfile_check_directory = outfile_check_dir;
6494 }
6495
6496 data.outfile_check_directory = outfile_check_directory;
6497
6498 if (keyspace == 0)
6499 {
6500 struct stat outfile_check_stat;
6501
6502 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6503 {
6504 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6505
6506 if (is_dir == 0)
6507 {
6508 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6509
6510 return (-1);
6511 }
6512 }
6513 else if (outfile_check_dir == NULL)
6514 {
6515 if (mkdir (outfile_check_directory, 0700) == -1)
6516 {
6517 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6518
6519 return (-1);
6520 }
6521 }
6522 }
6523
6524 /**
6525 * special other stuff
6526 */
6527
6528 if (hash_mode == 9710)
6529 {
6530 outfile_format = 5;
6531 outfile_format_chgd = 1;
6532 }
6533
6534 if (hash_mode == 9810)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 if (hash_mode == 10410)
6541 {
6542 outfile_format = 5;
6543 outfile_format_chgd = 1;
6544 }
6545
6546 /**
6547 * store stuff
6548 */
6549
6550 data.hash_mode = hash_mode;
6551 data.restore = restore;
6552 data.restore_timer = restore_timer;
6553 data.restore_disable = restore_disable;
6554 data.status = status;
6555 data.status_timer = status_timer;
6556 data.status_automat = status_automat;
6557 data.loopback = loopback;
6558 data.runtime = runtime;
6559 data.remove = remove;
6560 data.remove_timer = remove_timer;
6561 data.debug_mode = debug_mode;
6562 data.debug_file = debug_file;
6563 data.username = username;
6564 data.quiet = quiet;
6565 data.outfile = outfile;
6566 data.outfile_format = outfile_format;
6567 data.outfile_autohex = outfile_autohex;
6568 data.hex_charset = hex_charset;
6569 data.hex_salt = hex_salt;
6570 data.hex_wordlist = hex_wordlist;
6571 data.separator = separator;
6572 data.rp_files = rp_files;
6573 data.rp_files_cnt = rp_files_cnt;
6574 data.rp_gen = rp_gen;
6575 data.rp_gen_seed = rp_gen_seed;
6576 data.force = force;
6577 data.benchmark = benchmark;
6578 data.skip = skip;
6579 data.limit = limit;
6580 #ifdef HAVE_HWMON
6581 #ifdef HAVE_ADL
6582 data.powertune_enable = powertune_enable;
6583 #endif
6584 #endif
6585 data.logfile_disable = logfile_disable;
6586 data.truecrypt_keyfiles = truecrypt_keyfiles;
6587 data.veracrypt_keyfiles = veracrypt_keyfiles;
6588 data.veracrypt_pim = veracrypt_pim;
6589 data.scrypt_tmto = scrypt_tmto;
6590 data.workload_profile = workload_profile;
6591
6592 /**
6593 * cpu affinity
6594 */
6595
6596 if (cpu_affinity)
6597 {
6598 set_cpu_affinity (cpu_affinity);
6599 }
6600
6601 if (rp_gen_seed_chgd == 0)
6602 {
6603 srand (proc_start);
6604 }
6605 else
6606 {
6607 srand (rp_gen_seed);
6608 }
6609
6610 /**
6611 * logfile init
6612 */
6613
6614 if (logfile_disable == 0)
6615 {
6616 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6617
6618 char *logfile = (char *) mymalloc (logfile_size);
6619
6620 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6621
6622 data.logfile = logfile;
6623
6624 char *topid = logfile_generate_topid ();
6625
6626 data.topid = topid;
6627 }
6628
6629 // logfile_append() checks for logfile_disable internally to make it easier from here
6630
6631 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6632 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6633 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6634 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6635 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6636 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6637 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6638 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6639 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6640 #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));
6641
6642 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6643 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6644 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6645 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6646 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6647 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6648 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6649 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6650
6651 logfile_top_msg ("START");
6652
6653 logfile_top_uint (attack_mode);
6654 logfile_top_uint (attack_kern);
6655 logfile_top_uint (benchmark);
6656 logfile_top_uint (bitmap_min);
6657 logfile_top_uint (bitmap_max);
6658 logfile_top_uint (debug_mode);
6659 logfile_top_uint (force);
6660 logfile_top_uint (kernel_accel);
6661 logfile_top_uint (kernel_loops);
6662 logfile_top_uint (gpu_temp_disable);
6663 #ifdef HAVE_HWMON
6664 logfile_top_uint (gpu_temp_abort);
6665 logfile_top_uint (gpu_temp_retain);
6666 #endif
6667 logfile_top_uint (hash_mode);
6668 logfile_top_uint (hex_charset);
6669 logfile_top_uint (hex_salt);
6670 logfile_top_uint (hex_wordlist);
6671 logfile_top_uint (increment);
6672 logfile_top_uint (increment_max);
6673 logfile_top_uint (increment_min);
6674 logfile_top_uint (keyspace);
6675 logfile_top_uint (left);
6676 logfile_top_uint (logfile_disable);
6677 logfile_top_uint (loopback);
6678 logfile_top_uint (markov_classic);
6679 logfile_top_uint (markov_disable);
6680 logfile_top_uint (markov_threshold);
6681 logfile_top_uint (outfile_autohex);
6682 logfile_top_uint (outfile_check_timer);
6683 logfile_top_uint (outfile_format);
6684 logfile_top_uint (potfile_disable);
6685 logfile_top_string (potfile_path);
6686 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6687 logfile_top_uint (powertune_enable);
6688 #endif
6689 logfile_top_uint (scrypt_tmto);
6690 logfile_top_uint (quiet);
6691 logfile_top_uint (remove);
6692 logfile_top_uint (remove_timer);
6693 logfile_top_uint (restore);
6694 logfile_top_uint (restore_disable);
6695 logfile_top_uint (restore_timer);
6696 logfile_top_uint (rp_gen);
6697 logfile_top_uint (rp_gen_func_max);
6698 logfile_top_uint (rp_gen_func_min);
6699 logfile_top_uint (rp_gen_seed);
6700 logfile_top_uint (runtime);
6701 logfile_top_uint (segment_size);
6702 logfile_top_uint (show);
6703 logfile_top_uint (status);
6704 logfile_top_uint (status_automat);
6705 logfile_top_uint (status_timer);
6706 logfile_top_uint (usage);
6707 logfile_top_uint (username);
6708 logfile_top_uint (version);
6709 logfile_top_uint (weak_hash_threshold);
6710 logfile_top_uint (workload_profile);
6711 logfile_top_uint64 (limit);
6712 logfile_top_uint64 (skip);
6713 logfile_top_char (separator);
6714 logfile_top_string (cpu_affinity);
6715 logfile_top_string (custom_charset_1);
6716 logfile_top_string (custom_charset_2);
6717 logfile_top_string (custom_charset_3);
6718 logfile_top_string (custom_charset_4);
6719 logfile_top_string (debug_file);
6720 logfile_top_string (opencl_devices);
6721 logfile_top_string (opencl_platforms);
6722 logfile_top_string (opencl_device_types);
6723 logfile_top_uint (opencl_vector_width);
6724 logfile_top_string (induction_dir);
6725 logfile_top_string (markov_hcstat);
6726 logfile_top_string (outfile);
6727 logfile_top_string (outfile_check_dir);
6728 logfile_top_string (rule_buf_l);
6729 logfile_top_string (rule_buf_r);
6730 logfile_top_string (session);
6731 logfile_top_string (truecrypt_keyfiles);
6732 logfile_top_string (veracrypt_keyfiles);
6733 logfile_top_uint (veracrypt_pim);
6734
6735 /**
6736 * Init OpenCL library loader
6737 */
6738
6739 if (keyspace == 0)
6740 {
6741 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6742
6743 ocl_init (ocl);
6744
6745 data.ocl = ocl;
6746 }
6747
6748 /**
6749 * OpenCL platform selection
6750 */
6751
6752 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6753
6754 /**
6755 * OpenCL device selection
6756 */
6757
6758 u32 devices_filter = setup_devices_filter (opencl_devices);
6759
6760 /**
6761 * OpenCL device type selection
6762 */
6763
6764 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6765
6766 /**
6767 * benchmark
6768 */
6769
6770 if (benchmark == 1)
6771 {
6772 /**
6773 * disable useless stuff for benchmark
6774 */
6775
6776 status_timer = 0;
6777 restore_timer = 0;
6778 restore_disable = 1;
6779 potfile_disable = 1;
6780 weak_hash_threshold = 0;
6781 gpu_temp_disable = 1;
6782
6783 data.status_timer = status_timer;
6784 data.restore_timer = restore_timer;
6785 data.restore_disable = restore_disable;
6786
6787 /**
6788 * force attack mode to be bruteforce
6789 */
6790
6791 attack_mode = ATTACK_MODE_BF;
6792 attack_kern = ATTACK_KERN_BF;
6793
6794 if (workload_profile_chgd == 0)
6795 {
6796 workload_profile = 3;
6797
6798 data.workload_profile = workload_profile;
6799 }
6800 }
6801
6802 /**
6803 * config
6804 */
6805
6806 uint hash_type = 0;
6807 uint salt_type = 0;
6808 uint attack_exec = 0;
6809 uint opts_type = 0;
6810 uint kern_type = 0;
6811 uint dgst_size = 0;
6812 uint esalt_size = 0;
6813 uint opti_type = 0;
6814 uint dgst_pos0 = -1;
6815 uint dgst_pos1 = -1;
6816 uint dgst_pos2 = -1;
6817 uint dgst_pos3 = -1;
6818
6819 int (*parse_func) (char *, uint, hash_t *);
6820 int (*sort_by_digest) (const void *, const void *);
6821
6822 uint algorithm_pos = 0;
6823 uint algorithm_max = 1;
6824
6825 uint *algorithms = default_benchmark_algorithms;
6826
6827 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6828
6829 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6830 {
6831 /*
6832 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6833 * the following algos are skipped entirely
6834 */
6835
6836 if (algorithm_pos > 0)
6837 {
6838 local_free (rd);
6839
6840 rd = init_restore (argc, argv);
6841
6842 data.rd = rd;
6843 }
6844
6845 /**
6846 * update hash_mode in case of multihash benchmark
6847 */
6848
6849 if (benchmark == 1)
6850 {
6851 if (hash_mode_chgd == 0)
6852 {
6853 hash_mode = algorithms[algorithm_pos];
6854
6855 data.hash_mode = hash_mode;
6856 }
6857
6858 quiet = 1;
6859
6860 data.quiet = quiet;
6861 }
6862
6863 switch (hash_mode)
6864 {
6865 case 0: hash_type = HASH_TYPE_MD5;
6866 salt_type = SALT_TYPE_NONE;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_LE
6869 | OPTS_TYPE_PT_ADD80
6870 | OPTS_TYPE_PT_ADDBITS14;
6871 kern_type = KERN_TYPE_MD5;
6872 dgst_size = DGST_SIZE_4_4;
6873 parse_func = md5_parse_hash;
6874 sort_by_digest = sort_by_digest_4_4;
6875 opti_type = OPTI_TYPE_ZERO_BYTE
6876 | OPTI_TYPE_PRECOMPUTE_INIT
6877 | OPTI_TYPE_PRECOMPUTE_MERKLE
6878 | OPTI_TYPE_MEET_IN_MIDDLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_NOT_SALTED
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 0;
6884 dgst_pos1 = 3;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 10: hash_type = HASH_TYPE_MD5;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_LE
6893 | OPTS_TYPE_ST_ADD80
6894 | OPTS_TYPE_ST_ADDBITS14;
6895 kern_type = KERN_TYPE_MD5_PWSLT;
6896 dgst_size = DGST_SIZE_4_4;
6897 parse_func = md5s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_4;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_MEET_IN_MIDDLE
6903 | OPTI_TYPE_EARLY_SKIP
6904 | OPTI_TYPE_NOT_ITERATED
6905 | OPTI_TYPE_APPENDED_SALT
6906 | OPTI_TYPE_RAW_HASH;
6907 dgst_pos0 = 0;
6908 dgst_pos1 = 3;
6909 dgst_pos2 = 2;
6910 dgst_pos3 = 1;
6911 break;
6912
6913 case 11: hash_type = HASH_TYPE_MD5;
6914 salt_type = SALT_TYPE_INTERN;
6915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6916 opts_type = OPTS_TYPE_PT_GENERATE_LE
6917 | OPTS_TYPE_ST_ADD80
6918 | OPTS_TYPE_ST_ADDBITS14;
6919 kern_type = KERN_TYPE_MD5_PWSLT;
6920 dgst_size = DGST_SIZE_4_4;
6921 parse_func = joomla_parse_hash;
6922 sort_by_digest = sort_by_digest_4_4;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_MEET_IN_MIDDLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_APPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 0;
6932 dgst_pos1 = 3;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 12: hash_type = HASH_TYPE_MD5;
6938 salt_type = SALT_TYPE_INTERN;
6939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6940 opts_type = OPTS_TYPE_PT_GENERATE_LE
6941 | OPTS_TYPE_ST_ADD80
6942 | OPTS_TYPE_ST_ADDBITS14;
6943 kern_type = KERN_TYPE_MD5_PWSLT;
6944 dgst_size = DGST_SIZE_4_4;
6945 parse_func = postgresql_parse_hash;
6946 sort_by_digest = sort_by_digest_4_4;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_MEET_IN_MIDDLE
6951 | OPTI_TYPE_EARLY_SKIP
6952 | OPTI_TYPE_NOT_ITERATED
6953 | OPTI_TYPE_APPENDED_SALT
6954 | OPTI_TYPE_RAW_HASH;
6955 dgst_pos0 = 0;
6956 dgst_pos1 = 3;
6957 dgst_pos2 = 2;
6958 dgst_pos3 = 1;
6959 break;
6960
6961 case 20: hash_type = HASH_TYPE_MD5;
6962 salt_type = SALT_TYPE_INTERN;
6963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6964 opts_type = OPTS_TYPE_PT_GENERATE_LE
6965 | OPTS_TYPE_PT_ADD80
6966 | OPTS_TYPE_PT_ADDBITS14;
6967 kern_type = KERN_TYPE_MD5_SLTPW;
6968 dgst_size = DGST_SIZE_4_4;
6969 parse_func = md5s_parse_hash;
6970 sort_by_digest = sort_by_digest_4_4;
6971 opti_type = OPTI_TYPE_ZERO_BYTE
6972 | OPTI_TYPE_PRECOMPUTE_INIT
6973 | OPTI_TYPE_PRECOMPUTE_MERKLE
6974 | OPTI_TYPE_EARLY_SKIP
6975 | OPTI_TYPE_NOT_ITERATED
6976 | OPTI_TYPE_PREPENDED_SALT
6977 | OPTI_TYPE_RAW_HASH;
6978 dgst_pos0 = 0;
6979 dgst_pos1 = 3;
6980 dgst_pos2 = 2;
6981 dgst_pos3 = 1;
6982 break;
6983
6984 case 21: hash_type = HASH_TYPE_MD5;
6985 salt_type = SALT_TYPE_INTERN;
6986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6987 opts_type = OPTS_TYPE_PT_GENERATE_LE
6988 | OPTS_TYPE_PT_ADD80
6989 | OPTS_TYPE_PT_ADDBITS14;
6990 kern_type = KERN_TYPE_MD5_SLTPW;
6991 dgst_size = DGST_SIZE_4_4;
6992 parse_func = osc_parse_hash;
6993 sort_by_digest = sort_by_digest_4_4;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_EARLY_SKIP
6998 | OPTI_TYPE_NOT_ITERATED
6999 | OPTI_TYPE_PREPENDED_SALT
7000 | OPTI_TYPE_RAW_HASH;
7001 dgst_pos0 = 0;
7002 dgst_pos1 = 3;
7003 dgst_pos2 = 2;
7004 dgst_pos3 = 1;
7005 break;
7006
7007 case 22: hash_type = HASH_TYPE_MD5;
7008 salt_type = SALT_TYPE_EMBEDDED;
7009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7010 opts_type = OPTS_TYPE_PT_GENERATE_LE
7011 | OPTS_TYPE_PT_ADD80
7012 | OPTS_TYPE_PT_ADDBITS14;
7013 kern_type = KERN_TYPE_MD5_SLTPW;
7014 dgst_size = DGST_SIZE_4_4;
7015 parse_func = netscreen_parse_hash;
7016 sort_by_digest = sort_by_digest_4_4;
7017 opti_type = OPTI_TYPE_ZERO_BYTE
7018 | OPTI_TYPE_PRECOMPUTE_INIT
7019 | OPTI_TYPE_PRECOMPUTE_MERKLE
7020 | OPTI_TYPE_EARLY_SKIP
7021 | OPTI_TYPE_NOT_ITERATED
7022 | OPTI_TYPE_PREPENDED_SALT
7023 | OPTI_TYPE_RAW_HASH;
7024 dgst_pos0 = 0;
7025 dgst_pos1 = 3;
7026 dgst_pos2 = 2;
7027 dgst_pos3 = 1;
7028 break;
7029
7030 case 23: hash_type = HASH_TYPE_MD5;
7031 salt_type = SALT_TYPE_EMBEDDED;
7032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7033 opts_type = OPTS_TYPE_PT_GENERATE_LE
7034 | OPTS_TYPE_PT_ADD80
7035 | OPTS_TYPE_PT_ADDBITS14;
7036 kern_type = KERN_TYPE_MD5_SLTPW;
7037 dgst_size = DGST_SIZE_4_4;
7038 parse_func = skype_parse_hash;
7039 sort_by_digest = sort_by_digest_4_4;
7040 opti_type = OPTI_TYPE_ZERO_BYTE
7041 | OPTI_TYPE_PRECOMPUTE_INIT
7042 | OPTI_TYPE_PRECOMPUTE_MERKLE
7043 | OPTI_TYPE_EARLY_SKIP
7044 | OPTI_TYPE_NOT_ITERATED
7045 | OPTI_TYPE_PREPENDED_SALT
7046 | OPTI_TYPE_RAW_HASH;
7047 dgst_pos0 = 0;
7048 dgst_pos1 = 3;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 30: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_INTERN;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_PT_UNICODE
7058 | OPTS_TYPE_ST_ADD80
7059 | OPTS_TYPE_ST_ADDBITS14;
7060 kern_type = KERN_TYPE_MD5_PWUSLT;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = md5s_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_MEET_IN_MIDDLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_APPENDED_SALT
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 0;
7073 dgst_pos1 = 3;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 40: hash_type = HASH_TYPE_MD5;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_LE
7082 | OPTS_TYPE_PT_ADD80
7083 | OPTS_TYPE_PT_ADDBITS14
7084 | OPTS_TYPE_PT_UNICODE;
7085 kern_type = KERN_TYPE_MD5_SLTPWU;
7086 dgst_size = DGST_SIZE_4_4;
7087 parse_func = md5s_parse_hash;
7088 sort_by_digest = sort_by_digest_4_4;
7089 opti_type = OPTI_TYPE_ZERO_BYTE
7090 | OPTI_TYPE_PRECOMPUTE_INIT
7091 | OPTI_TYPE_PRECOMPUTE_MERKLE
7092 | OPTI_TYPE_EARLY_SKIP
7093 | OPTI_TYPE_NOT_ITERATED
7094 | OPTI_TYPE_PREPENDED_SALT
7095 | OPTI_TYPE_RAW_HASH;
7096 dgst_pos0 = 0;
7097 dgst_pos1 = 3;
7098 dgst_pos2 = 2;
7099 dgst_pos3 = 1;
7100 break;
7101
7102 case 50: hash_type = HASH_TYPE_MD5;
7103 salt_type = SALT_TYPE_INTERN;
7104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7105 opts_type = OPTS_TYPE_PT_GENERATE_LE
7106 | OPTS_TYPE_ST_ADD80
7107 | OPTS_TYPE_ST_ADDBITS14;
7108 kern_type = KERN_TYPE_HMACMD5_PW;
7109 dgst_size = DGST_SIZE_4_4;
7110 parse_func = hmacmd5_parse_hash;
7111 sort_by_digest = sort_by_digest_4_4;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_NOT_ITERATED;
7114 dgst_pos0 = 0;
7115 dgst_pos1 = 3;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 60: hash_type = HASH_TYPE_MD5;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_LE
7124 | OPTS_TYPE_PT_ADD80
7125 | OPTS_TYPE_PT_ADDBITS14;
7126 kern_type = KERN_TYPE_HMACMD5_SLT;
7127 dgst_size = DGST_SIZE_4_4;
7128 parse_func = hmacmd5_parse_hash;
7129 sort_by_digest = sort_by_digest_4_4;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_NOT_ITERATED;
7132 dgst_pos0 = 0;
7133 dgst_pos1 = 3;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 100: hash_type = HASH_TYPE_SHA1;
7139 salt_type = SALT_TYPE_NONE;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_BE
7142 | OPTS_TYPE_PT_ADD80
7143 | OPTS_TYPE_PT_ADDBITS15;
7144 kern_type = KERN_TYPE_SHA1;
7145 dgst_size = DGST_SIZE_4_5;
7146 parse_func = sha1_parse_hash;
7147 sort_by_digest = sort_by_digest_4_5;
7148 opti_type = OPTI_TYPE_ZERO_BYTE
7149 | OPTI_TYPE_PRECOMPUTE_INIT
7150 | OPTI_TYPE_PRECOMPUTE_MERKLE
7151 | OPTI_TYPE_EARLY_SKIP
7152 | OPTI_TYPE_NOT_ITERATED
7153 | OPTI_TYPE_NOT_SALTED
7154 | OPTI_TYPE_RAW_HASH;
7155 dgst_pos0 = 3;
7156 dgst_pos1 = 4;
7157 dgst_pos2 = 2;
7158 dgst_pos3 = 1;
7159 break;
7160
7161 case 101: hash_type = HASH_TYPE_SHA1;
7162 salt_type = SALT_TYPE_NONE;
7163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7164 opts_type = OPTS_TYPE_PT_GENERATE_BE
7165 | OPTS_TYPE_PT_ADD80
7166 | OPTS_TYPE_PT_ADDBITS15;
7167 kern_type = KERN_TYPE_SHA1;
7168 dgst_size = DGST_SIZE_4_5;
7169 parse_func = sha1b64_parse_hash;
7170 sort_by_digest = sort_by_digest_4_5;
7171 opti_type = OPTI_TYPE_ZERO_BYTE
7172 | OPTI_TYPE_PRECOMPUTE_INIT
7173 | OPTI_TYPE_PRECOMPUTE_MERKLE
7174 | OPTI_TYPE_EARLY_SKIP
7175 | OPTI_TYPE_NOT_ITERATED
7176 | OPTI_TYPE_NOT_SALTED
7177 | OPTI_TYPE_RAW_HASH;
7178 dgst_pos0 = 3;
7179 dgst_pos1 = 4;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 1;
7182 break;
7183
7184 case 110: hash_type = HASH_TYPE_SHA1;
7185 salt_type = SALT_TYPE_INTERN;
7186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_ST_ADD80
7189 | OPTS_TYPE_ST_ADDBITS15;
7190 kern_type = KERN_TYPE_SHA1_PWSLT;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = sha1s_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_APPENDED_SALT
7200 | OPTI_TYPE_RAW_HASH;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 1;
7205 break;
7206
7207 case 111: hash_type = HASH_TYPE_SHA1;
7208 salt_type = SALT_TYPE_EMBEDDED;
7209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7210 opts_type = OPTS_TYPE_PT_GENERATE_BE
7211 | OPTS_TYPE_ST_ADD80
7212 | OPTS_TYPE_ST_ADDBITS15;
7213 kern_type = KERN_TYPE_SHA1_PWSLT;
7214 dgst_size = DGST_SIZE_4_5;
7215 parse_func = sha1b64s_parse_hash;
7216 sort_by_digest = sort_by_digest_4_5;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_APPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 4;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 112: hash_type = HASH_TYPE_SHA1;
7231 salt_type = SALT_TYPE_INTERN;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_ST_ADD80
7235 | OPTS_TYPE_ST_ADDBITS15
7236 | OPTS_TYPE_ST_HEX;
7237 kern_type = KERN_TYPE_SHA1_PWSLT;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = oracles_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 120: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15;
7260 kern_type = KERN_TYPE_SHA1_SLTPW;
7261 dgst_size = DGST_SIZE_4_5;
7262 parse_func = sha1s_parse_hash;
7263 sort_by_digest = sort_by_digest_4_5;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_PREPENDED_SALT
7270 | OPTI_TYPE_RAW_HASH;
7271 dgst_pos0 = 3;
7272 dgst_pos1 = 4;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 1;
7275 break;
7276
7277 case 121: hash_type = HASH_TYPE_SHA1;
7278 salt_type = SALT_TYPE_INTERN;
7279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7280 opts_type = OPTS_TYPE_PT_GENERATE_BE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS15
7283 | OPTS_TYPE_ST_LOWER;
7284 kern_type = KERN_TYPE_SHA1_SLTPW;
7285 dgst_size = DGST_SIZE_4_5;
7286 parse_func = smf_parse_hash;
7287 sort_by_digest = sort_by_digest_4_5;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_PREPENDED_SALT
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 4;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 122: hash_type = HASH_TYPE_SHA1;
7302 salt_type = SALT_TYPE_EMBEDDED;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS15
7307 | OPTS_TYPE_ST_HEX;
7308 kern_type = KERN_TYPE_SHA1_SLTPW;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = osx1_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_PRECOMPUTE_MERKLE
7315 | OPTI_TYPE_EARLY_SKIP
7316 | OPTI_TYPE_NOT_ITERATED
7317 | OPTI_TYPE_PREPENDED_SALT
7318 | OPTI_TYPE_RAW_HASH;
7319 dgst_pos0 = 3;
7320 dgst_pos1 = 4;
7321 dgst_pos2 = 2;
7322 dgst_pos3 = 1;
7323 break;
7324
7325 case 124: hash_type = HASH_TYPE_SHA1;
7326 salt_type = SALT_TYPE_EMBEDDED;
7327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7328 opts_type = OPTS_TYPE_PT_GENERATE_BE
7329 | OPTS_TYPE_PT_ADD80
7330 | OPTS_TYPE_PT_ADDBITS15;
7331 kern_type = KERN_TYPE_SHA1_SLTPW;
7332 dgst_size = DGST_SIZE_4_5;
7333 parse_func = djangosha1_parse_hash;
7334 sort_by_digest = sort_by_digest_4_5;
7335 opti_type = OPTI_TYPE_ZERO_BYTE
7336 | OPTI_TYPE_PRECOMPUTE_INIT
7337 | OPTI_TYPE_PRECOMPUTE_MERKLE
7338 | OPTI_TYPE_EARLY_SKIP
7339 | OPTI_TYPE_NOT_ITERATED
7340 | OPTI_TYPE_PREPENDED_SALT
7341 | OPTI_TYPE_RAW_HASH;
7342 dgst_pos0 = 3;
7343 dgst_pos1 = 4;
7344 dgst_pos2 = 2;
7345 dgst_pos3 = 1;
7346 break;
7347
7348 case 125: hash_type = HASH_TYPE_SHA1;
7349 salt_type = SALT_TYPE_EMBEDDED;
7350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7351 opts_type = OPTS_TYPE_PT_GENERATE_BE
7352 | OPTS_TYPE_PT_ADD80
7353 | OPTS_TYPE_PT_ADDBITS15
7354 | OPTS_TYPE_ST_HEX;
7355 kern_type = KERN_TYPE_SHA1_SLTPW;
7356 dgst_size = DGST_SIZE_4_5;
7357 parse_func = arubaos_parse_hash;
7358 sort_by_digest = sort_by_digest_4_5;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_PREPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 4;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 1;
7370 break;
7371
7372 case 130: hash_type = HASH_TYPE_SHA1;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_PT_UNICODE
7377 | OPTS_TYPE_ST_ADD80
7378 | OPTS_TYPE_ST_ADDBITS15;
7379 kern_type = KERN_TYPE_SHA1_PWUSLT;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = sha1s_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 131: 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_PT_UPPER
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWUSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = mssql2000_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 132: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_EMBEDDED;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_UNICODE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWUSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = mssql2005_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 133: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_EMBEDDED;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_UNICODE
7452 | OPTS_TYPE_ST_ADD80
7453 | OPTS_TYPE_ST_ADDBITS15;
7454 kern_type = KERN_TYPE_SHA1_PWUSLT;
7455 dgst_size = DGST_SIZE_4_5;
7456 parse_func = peoplesoft_parse_hash;
7457 sort_by_digest = sort_by_digest_4_5;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_APPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 140: hash_type = HASH_TYPE_SHA1;
7472 salt_type = SALT_TYPE_INTERN;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS15
7477 | OPTS_TYPE_PT_UNICODE;
7478 kern_type = KERN_TYPE_SHA1_SLTPWU;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = sha1s_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 141: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_EMBEDDED;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15
7501 | OPTS_TYPE_PT_UNICODE
7502 | OPTS_TYPE_ST_BASE64;
7503 kern_type = KERN_TYPE_SHA1_SLTPWU;
7504 dgst_size = DGST_SIZE_4_5;
7505 parse_func = episerver_parse_hash;
7506 sort_by_digest = sort_by_digest_4_5;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_PRECOMPUTE_INIT
7509 | OPTI_TYPE_PRECOMPUTE_MERKLE
7510 | OPTI_TYPE_EARLY_SKIP
7511 | OPTI_TYPE_NOT_ITERATED
7512 | OPTI_TYPE_PREPENDED_SALT
7513 | OPTI_TYPE_RAW_HASH;
7514 dgst_pos0 = 3;
7515 dgst_pos1 = 4;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 150: hash_type = HASH_TYPE_SHA1;
7521 salt_type = SALT_TYPE_INTERN;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_BE
7524 | OPTS_TYPE_ST_ADD80
7525 | OPTS_TYPE_ST_ADDBITS15;
7526 kern_type = KERN_TYPE_HMACSHA1_PW;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = hmacsha1_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_NOT_ITERATED;
7532 dgst_pos0 = 3;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 160: hash_type = HASH_TYPE_SHA1;
7539 salt_type = SALT_TYPE_INTERN;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_BE
7542 | OPTS_TYPE_PT_ADD80
7543 | OPTS_TYPE_PT_ADDBITS15;
7544 kern_type = KERN_TYPE_HMACSHA1_SLT;
7545 dgst_size = DGST_SIZE_4_5;
7546 parse_func = hmacsha1_parse_hash;
7547 sort_by_digest = sort_by_digest_4_5;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_NOT_ITERATED;
7550 dgst_pos0 = 3;
7551 dgst_pos1 = 4;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 190: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_NONE;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7563 dgst_size = DGST_SIZE_4_5;
7564 parse_func = sha1linkedin_parse_hash;
7565 sort_by_digest = sort_by_digest_4_5;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_PRECOMPUTE_INIT
7568 | OPTI_TYPE_EARLY_SKIP
7569 | OPTI_TYPE_NOT_ITERATED
7570 | OPTI_TYPE_NOT_SALTED;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 4;
7573 dgst_pos2 = 3;
7574 dgst_pos3 = 2;
7575 break;
7576
7577 case 200: hash_type = HASH_TYPE_MYSQL;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = 0;
7581 kern_type = KERN_TYPE_MYSQL;
7582 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7583 parse_func = mysql323_parse_hash;
7584 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7585 opti_type = OPTI_TYPE_ZERO_BYTE;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 1;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 3;
7590 break;
7591
7592 case 300: hash_type = HASH_TYPE_SHA1;
7593 salt_type = SALT_TYPE_NONE;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_BE
7596 | OPTS_TYPE_PT_ADD80
7597 | OPTS_TYPE_PT_ADDBITS15;
7598 kern_type = KERN_TYPE_MYSQL41;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = sha1_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_NOT_SALTED;
7608 dgst_pos0 = 3;
7609 dgst_pos1 = 4;
7610 dgst_pos2 = 2;
7611 dgst_pos3 = 1;
7612 break;
7613
7614 case 400: hash_type = HASH_TYPE_MD5;
7615 salt_type = SALT_TYPE_EMBEDDED;
7616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7617 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7618 kern_type = KERN_TYPE_PHPASS;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = phpass_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_SLOW_HASH_SIMD;
7624 dgst_pos0 = 0;
7625 dgst_pos1 = 1;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 3;
7628 break;
7629
7630 case 500: hash_type = HASH_TYPE_MD5;
7631 salt_type = SALT_TYPE_EMBEDDED;
7632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7634 kern_type = KERN_TYPE_MD5CRYPT;
7635 dgst_size = DGST_SIZE_4_4;
7636 parse_func = md5crypt_parse_hash;
7637 sort_by_digest = sort_by_digest_4_4;
7638 opti_type = OPTI_TYPE_ZERO_BYTE;
7639 dgst_pos0 = 0;
7640 dgst_pos1 = 1;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 3;
7643 break;
7644
7645 case 501: hash_type = HASH_TYPE_MD5;
7646 salt_type = SALT_TYPE_EMBEDDED;
7647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_LE
7649 | OPTS_TYPE_HASH_COPY;
7650 kern_type = KERN_TYPE_MD5CRYPT;
7651 dgst_size = DGST_SIZE_4_4;
7652 parse_func = juniper_parse_hash;
7653 sort_by_digest = sort_by_digest_4_4;
7654 opti_type = OPTI_TYPE_ZERO_BYTE;
7655 dgst_pos0 = 0;
7656 dgst_pos1 = 1;
7657 dgst_pos2 = 2;
7658 dgst_pos3 = 3;
7659 break;
7660
7661 case 900: hash_type = HASH_TYPE_MD4;
7662 salt_type = SALT_TYPE_NONE;
7663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7664 opts_type = OPTS_TYPE_PT_GENERATE_LE
7665 | OPTS_TYPE_PT_ADD80
7666 | OPTS_TYPE_PT_ADDBITS14;
7667 kern_type = KERN_TYPE_MD4;
7668 dgst_size = DGST_SIZE_4_4;
7669 parse_func = md4_parse_hash;
7670 sort_by_digest = sort_by_digest_4_4;
7671 opti_type = OPTI_TYPE_ZERO_BYTE
7672 | OPTI_TYPE_PRECOMPUTE_INIT
7673 | OPTI_TYPE_PRECOMPUTE_MERKLE
7674 | OPTI_TYPE_MEET_IN_MIDDLE
7675 | OPTI_TYPE_EARLY_SKIP
7676 | OPTI_TYPE_NOT_ITERATED
7677 | OPTI_TYPE_NOT_SALTED
7678 | OPTI_TYPE_RAW_HASH;
7679 dgst_pos0 = 0;
7680 dgst_pos1 = 3;
7681 dgst_pos2 = 2;
7682 dgst_pos3 = 1;
7683 break;
7684
7685 case 1000: hash_type = HASH_TYPE_MD4;
7686 salt_type = SALT_TYPE_NONE;
7687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7688 opts_type = OPTS_TYPE_PT_GENERATE_LE
7689 | OPTS_TYPE_PT_ADD80
7690 | OPTS_TYPE_PT_ADDBITS14
7691 | OPTS_TYPE_PT_UNICODE;
7692 kern_type = KERN_TYPE_MD4_PWU;
7693 dgst_size = DGST_SIZE_4_4;
7694 parse_func = md4_parse_hash;
7695 sort_by_digest = sort_by_digest_4_4;
7696 opti_type = OPTI_TYPE_ZERO_BYTE
7697 | OPTI_TYPE_PRECOMPUTE_INIT
7698 | OPTI_TYPE_PRECOMPUTE_MERKLE
7699 | OPTI_TYPE_MEET_IN_MIDDLE
7700 | OPTI_TYPE_EARLY_SKIP
7701 | OPTI_TYPE_NOT_ITERATED
7702 | OPTI_TYPE_NOT_SALTED
7703 | OPTI_TYPE_RAW_HASH;
7704 dgst_pos0 = 0;
7705 dgst_pos1 = 3;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 1;
7708 break;
7709
7710 case 1100: hash_type = HASH_TYPE_MD4;
7711 salt_type = SALT_TYPE_INTERN;
7712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7713 opts_type = OPTS_TYPE_PT_GENERATE_LE
7714 | OPTS_TYPE_PT_ADD80
7715 | OPTS_TYPE_PT_ADDBITS14
7716 | OPTS_TYPE_PT_UNICODE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_UNICODE
7719 | OPTS_TYPE_ST_LOWER;
7720 kern_type = KERN_TYPE_MD44_PWUSLT;
7721 dgst_size = DGST_SIZE_4_4;
7722 parse_func = dcc_parse_hash;
7723 sort_by_digest = sort_by_digest_4_4;
7724 opti_type = OPTI_TYPE_ZERO_BYTE
7725 | OPTI_TYPE_PRECOMPUTE_INIT
7726 | OPTI_TYPE_PRECOMPUTE_MERKLE
7727 | OPTI_TYPE_EARLY_SKIP
7728 | OPTI_TYPE_NOT_ITERATED;
7729 dgst_pos0 = 0;
7730 dgst_pos1 = 3;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 1;
7733 break;
7734
7735 case 1400: hash_type = HASH_TYPE_SHA256;
7736 salt_type = SALT_TYPE_NONE;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_BE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS15;
7741 kern_type = KERN_TYPE_SHA256;
7742 dgst_size = DGST_SIZE_4_8;
7743 parse_func = sha256_parse_hash;
7744 sort_by_digest = sort_by_digest_4_8;
7745 opti_type = OPTI_TYPE_ZERO_BYTE
7746 | OPTI_TYPE_PRECOMPUTE_INIT
7747 | OPTI_TYPE_PRECOMPUTE_MERKLE
7748 | OPTI_TYPE_EARLY_SKIP
7749 | OPTI_TYPE_NOT_ITERATED
7750 | OPTI_TYPE_NOT_SALTED
7751 | OPTI_TYPE_RAW_HASH;
7752 dgst_pos0 = 3;
7753 dgst_pos1 = 7;
7754 dgst_pos2 = 2;
7755 dgst_pos3 = 6;
7756 break;
7757
7758 case 1410: hash_type = HASH_TYPE_SHA256;
7759 salt_type = SALT_TYPE_INTERN;
7760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7761 opts_type = OPTS_TYPE_PT_GENERATE_BE
7762 | OPTS_TYPE_ST_ADD80
7763 | OPTS_TYPE_ST_ADDBITS15;
7764 kern_type = KERN_TYPE_SHA256_PWSLT;
7765 dgst_size = DGST_SIZE_4_8;
7766 parse_func = sha256s_parse_hash;
7767 sort_by_digest = sort_by_digest_4_8;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED
7773 | OPTI_TYPE_APPENDED_SALT
7774 | OPTI_TYPE_RAW_HASH;
7775 dgst_pos0 = 3;
7776 dgst_pos1 = 7;
7777 dgst_pos2 = 2;
7778 dgst_pos3 = 6;
7779 break;
7780
7781 case 1420: hash_type = HASH_TYPE_SHA256;
7782 salt_type = SALT_TYPE_INTERN;
7783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_BE
7785 | OPTS_TYPE_PT_ADD80
7786 | OPTS_TYPE_PT_ADDBITS15;
7787 kern_type = KERN_TYPE_SHA256_SLTPW;
7788 dgst_size = DGST_SIZE_4_8;
7789 parse_func = sha256s_parse_hash;
7790 sort_by_digest = sort_by_digest_4_8;
7791 opti_type = OPTI_TYPE_ZERO_BYTE
7792 | OPTI_TYPE_PRECOMPUTE_INIT
7793 | OPTI_TYPE_PRECOMPUTE_MERKLE
7794 | OPTI_TYPE_EARLY_SKIP
7795 | OPTI_TYPE_NOT_ITERATED
7796 | OPTI_TYPE_PREPENDED_SALT
7797 | OPTI_TYPE_RAW_HASH;
7798 dgst_pos0 = 3;
7799 dgst_pos1 = 7;
7800 dgst_pos2 = 2;
7801 dgst_pos3 = 6;
7802 break;
7803
7804 case 1421: hash_type = HASH_TYPE_SHA256;
7805 salt_type = SALT_TYPE_EMBEDDED;
7806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_BE
7808 | OPTS_TYPE_PT_ADD80
7809 | OPTS_TYPE_PT_ADDBITS15;
7810 kern_type = KERN_TYPE_SHA256_SLTPW;
7811 dgst_size = DGST_SIZE_4_8;
7812 parse_func = hmailserver_parse_hash;
7813 sort_by_digest = sort_by_digest_4_8;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_EARLY_SKIP
7818 | OPTI_TYPE_NOT_ITERATED
7819 | OPTI_TYPE_PREPENDED_SALT
7820 | OPTI_TYPE_RAW_HASH;
7821 dgst_pos0 = 3;
7822 dgst_pos1 = 7;
7823 dgst_pos2 = 2;
7824 dgst_pos3 = 6;
7825 break;
7826
7827 case 1430: hash_type = HASH_TYPE_SHA256;
7828 salt_type = SALT_TYPE_INTERN;
7829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7830 opts_type = OPTS_TYPE_PT_GENERATE_BE
7831 | OPTS_TYPE_PT_UNICODE
7832 | OPTS_TYPE_ST_ADD80
7833 | OPTS_TYPE_ST_ADDBITS15;
7834 kern_type = KERN_TYPE_SHA256_PWUSLT;
7835 dgst_size = DGST_SIZE_4_8;
7836 parse_func = sha256s_parse_hash;
7837 sort_by_digest = sort_by_digest_4_8;
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_INIT
7840 | OPTI_TYPE_PRECOMPUTE_MERKLE
7841 | OPTI_TYPE_EARLY_SKIP
7842 | OPTI_TYPE_NOT_ITERATED
7843 | OPTI_TYPE_APPENDED_SALT
7844 | OPTI_TYPE_RAW_HASH;
7845 dgst_pos0 = 3;
7846 dgst_pos1 = 7;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 6;
7849 break;
7850
7851 case 1440: hash_type = HASH_TYPE_SHA256;
7852 salt_type = SALT_TYPE_INTERN;
7853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_BE
7855 | OPTS_TYPE_PT_ADD80
7856 | OPTS_TYPE_PT_ADDBITS15
7857 | OPTS_TYPE_PT_UNICODE;
7858 kern_type = KERN_TYPE_SHA256_SLTPWU;
7859 dgst_size = DGST_SIZE_4_8;
7860 parse_func = sha256s_parse_hash;
7861 sort_by_digest = sort_by_digest_4_8;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_PREPENDED_SALT
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 7;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 6;
7873 break;
7874
7875 case 1441: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_EMBEDDED;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15
7881 | OPTS_TYPE_PT_UNICODE
7882 | OPTS_TYPE_ST_BASE64;
7883 kern_type = KERN_TYPE_SHA256_SLTPWU;
7884 dgst_size = DGST_SIZE_4_8;
7885 parse_func = episerver4_parse_hash;
7886 sort_by_digest = sort_by_digest_4_8;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_PRECOMPUTE_INIT
7889 | OPTI_TYPE_PRECOMPUTE_MERKLE
7890 | OPTI_TYPE_EARLY_SKIP
7891 | OPTI_TYPE_NOT_ITERATED
7892 | OPTI_TYPE_PREPENDED_SALT
7893 | OPTI_TYPE_RAW_HASH;
7894 dgst_pos0 = 3;
7895 dgst_pos1 = 7;
7896 dgst_pos2 = 2;
7897 dgst_pos3 = 6;
7898 break;
7899
7900 case 1450: hash_type = HASH_TYPE_SHA256;
7901 salt_type = SALT_TYPE_INTERN;
7902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7903 opts_type = OPTS_TYPE_PT_GENERATE_BE
7904 | OPTS_TYPE_ST_ADD80;
7905 kern_type = KERN_TYPE_HMACSHA256_PW;
7906 dgst_size = DGST_SIZE_4_8;
7907 parse_func = hmacsha256_parse_hash;
7908 sort_by_digest = sort_by_digest_4_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_NOT_ITERATED;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 7;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 6;
7915 break;
7916
7917 case 1460: hash_type = HASH_TYPE_SHA256;
7918 salt_type = SALT_TYPE_INTERN;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS15;
7923 kern_type = KERN_TYPE_HMACSHA256_SLT;
7924 dgst_size = DGST_SIZE_4_8;
7925 parse_func = hmacsha256_parse_hash;
7926 sort_by_digest = sort_by_digest_4_8;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_NOT_ITERATED;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 7;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 6;
7933 break;
7934
7935 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7936 salt_type = SALT_TYPE_EMBEDDED;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_LE
7939 | OPTS_TYPE_PT_BITSLICE;
7940 kern_type = KERN_TYPE_DESCRYPT;
7941 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7942 parse_func = descrypt_parse_hash;
7943 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7944 opti_type = OPTI_TYPE_ZERO_BYTE
7945 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7946 dgst_pos0 = 0;
7947 dgst_pos1 = 1;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 3;
7950 break;
7951
7952 case 1600: hash_type = HASH_TYPE_MD5;
7953 salt_type = SALT_TYPE_EMBEDDED;
7954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7956 kern_type = KERN_TYPE_APR1CRYPT;
7957 dgst_size = DGST_SIZE_4_4;
7958 parse_func = md5apr1_parse_hash;
7959 sort_by_digest = sort_by_digest_4_4;
7960 opti_type = OPTI_TYPE_ZERO_BYTE;
7961 dgst_pos0 = 0;
7962 dgst_pos1 = 1;
7963 dgst_pos2 = 2;
7964 dgst_pos3 = 3;
7965 break;
7966
7967 case 1700: hash_type = HASH_TYPE_SHA512;
7968 salt_type = SALT_TYPE_NONE;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_PT_ADD80
7972 | OPTS_TYPE_PT_ADDBITS15;
7973 kern_type = KERN_TYPE_SHA512;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = sha512_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_NOT_SALTED
7983 | OPTI_TYPE_USES_BITS_64
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 14;
7986 dgst_pos1 = 15;
7987 dgst_pos2 = 6;
7988 dgst_pos3 = 7;
7989 break;
7990
7991 case 1710: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_INTERN;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_ST_ADD80
7996 | OPTS_TYPE_ST_ADDBITS15;
7997 kern_type = KERN_TYPE_SHA512_PWSLT;
7998 dgst_size = DGST_SIZE_8_8;
7999 parse_func = sha512s_parse_hash;
8000 sort_by_digest = sort_by_digest_8_8;
8001 opti_type = OPTI_TYPE_ZERO_BYTE
8002 | OPTI_TYPE_PRECOMPUTE_INIT
8003 | OPTI_TYPE_PRECOMPUTE_MERKLE
8004 | OPTI_TYPE_EARLY_SKIP
8005 | OPTI_TYPE_NOT_ITERATED
8006 | OPTI_TYPE_APPENDED_SALT
8007 | OPTI_TYPE_USES_BITS_64
8008 | OPTI_TYPE_RAW_HASH;
8009 dgst_pos0 = 14;
8010 dgst_pos1 = 15;
8011 dgst_pos2 = 6;
8012 dgst_pos3 = 7;
8013 break;
8014
8015 case 1711: hash_type = HASH_TYPE_SHA512;
8016 salt_type = SALT_TYPE_EMBEDDED;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_BE
8019 | OPTS_TYPE_ST_ADD80
8020 | OPTS_TYPE_ST_ADDBITS15;
8021 kern_type = KERN_TYPE_SHA512_PWSLT;
8022 dgst_size = DGST_SIZE_8_8;
8023 parse_func = sha512b64s_parse_hash;
8024 sort_by_digest = sort_by_digest_8_8;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP
8029 | OPTI_TYPE_NOT_ITERATED
8030 | OPTI_TYPE_APPENDED_SALT
8031 | OPTI_TYPE_USES_BITS_64
8032 | OPTI_TYPE_RAW_HASH;
8033 dgst_pos0 = 14;
8034 dgst_pos1 = 15;
8035 dgst_pos2 = 6;
8036 dgst_pos3 = 7;
8037 break;
8038
8039 case 1720: hash_type = HASH_TYPE_SHA512;
8040 salt_type = SALT_TYPE_INTERN;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = OPTS_TYPE_PT_GENERATE_BE
8043 | OPTS_TYPE_PT_ADD80
8044 | OPTS_TYPE_PT_ADDBITS15;
8045 kern_type = KERN_TYPE_SHA512_SLTPW;
8046 dgst_size = DGST_SIZE_8_8;
8047 parse_func = sha512s_parse_hash;
8048 sort_by_digest = sort_by_digest_8_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_PRECOMPUTE_INIT
8051 | OPTI_TYPE_PRECOMPUTE_MERKLE
8052 | OPTI_TYPE_EARLY_SKIP
8053 | OPTI_TYPE_NOT_ITERATED
8054 | OPTI_TYPE_PREPENDED_SALT
8055 | OPTI_TYPE_USES_BITS_64
8056 | OPTI_TYPE_RAW_HASH;
8057 dgst_pos0 = 14;
8058 dgst_pos1 = 15;
8059 dgst_pos2 = 6;
8060 dgst_pos3 = 7;
8061 break;
8062
8063 case 1722: hash_type = HASH_TYPE_SHA512;
8064 salt_type = SALT_TYPE_EMBEDDED;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_ADD80
8068 | OPTS_TYPE_PT_ADDBITS15
8069 | OPTS_TYPE_ST_HEX;
8070 kern_type = KERN_TYPE_SHA512_SLTPW;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = osx512_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_PREPENDED_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 1730: 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_UNICODE
8093 | OPTS_TYPE_ST_ADD80
8094 | OPTS_TYPE_ST_ADDBITS15;
8095 kern_type = KERN_TYPE_SHA512_PWSLTU;
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_APPENDED_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 1731: hash_type = HASH_TYPE_SHA512;
8114 salt_type = SALT_TYPE_EMBEDDED;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_PT_UNICODE
8118 | OPTS_TYPE_ST_ADD80
8119 | OPTS_TYPE_ST_ADDBITS15
8120 | OPTS_TYPE_ST_HEX;
8121 kern_type = KERN_TYPE_SHA512_PWSLTU;
8122 dgst_size = DGST_SIZE_8_8;
8123 parse_func = mssql2012_parse_hash;
8124 sort_by_digest = sort_by_digest_8_8;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_PRECOMPUTE_INIT
8127 | OPTI_TYPE_PRECOMPUTE_MERKLE
8128 | OPTI_TYPE_EARLY_SKIP
8129 | OPTI_TYPE_NOT_ITERATED
8130 | OPTI_TYPE_APPENDED_SALT
8131 | OPTI_TYPE_USES_BITS_64
8132 | OPTI_TYPE_RAW_HASH;
8133 dgst_pos0 = 14;
8134 dgst_pos1 = 15;
8135 dgst_pos2 = 6;
8136 dgst_pos3 = 7;
8137 break;
8138
8139 case 1740: hash_type = HASH_TYPE_SHA512;
8140 salt_type = SALT_TYPE_INTERN;
8141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8142 opts_type = OPTS_TYPE_PT_GENERATE_BE
8143 | OPTS_TYPE_PT_ADD80
8144 | OPTS_TYPE_PT_ADDBITS15
8145 | OPTS_TYPE_PT_UNICODE;
8146 kern_type = KERN_TYPE_SHA512_SLTPWU;
8147 dgst_size = DGST_SIZE_8_8;
8148 parse_func = sha512s_parse_hash;
8149 sort_by_digest = sort_by_digest_8_8;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_PREPENDED_SALT
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_RAW_HASH;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1750: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_ST_ADD80;
8169 kern_type = KERN_TYPE_HMACSHA512_PW;
8170 dgst_size = DGST_SIZE_8_8;
8171 parse_func = hmacsha512_parse_hash;
8172 sort_by_digest = sort_by_digest_8_8;
8173 opti_type = OPTI_TYPE_ZERO_BYTE
8174 | OPTI_TYPE_USES_BITS_64
8175 | OPTI_TYPE_NOT_ITERATED;
8176 dgst_pos0 = 14;
8177 dgst_pos1 = 15;
8178 dgst_pos2 = 6;
8179 dgst_pos3 = 7;
8180 break;
8181
8182 case 1760: hash_type = HASH_TYPE_SHA512;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_BE
8186 | OPTS_TYPE_PT_ADD80
8187 | OPTS_TYPE_PT_ADDBITS15;
8188 kern_type = KERN_TYPE_HMACSHA512_SLT;
8189 dgst_size = DGST_SIZE_8_8;
8190 parse_func = hmacsha512_parse_hash;
8191 sort_by_digest = sort_by_digest_8_8;
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_USES_BITS_64
8194 | OPTI_TYPE_NOT_ITERATED;
8195 dgst_pos0 = 14;
8196 dgst_pos1 = 15;
8197 dgst_pos2 = 6;
8198 dgst_pos3 = 7;
8199 break;
8200
8201 case 1800: hash_type = HASH_TYPE_SHA512;
8202 salt_type = SALT_TYPE_EMBEDDED;
8203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8205 kern_type = KERN_TYPE_SHA512CRYPT;
8206 dgst_size = DGST_SIZE_8_8;
8207 parse_func = sha512crypt_parse_hash;
8208 sort_by_digest = sort_by_digest_8_8;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_USES_BITS_64;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 1;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 3;
8215 break;
8216
8217 case 2100: hash_type = HASH_TYPE_DCC2;
8218 salt_type = SALT_TYPE_EMBEDDED;
8219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8221 | OPTS_TYPE_ST_LOWER
8222 | OPTS_TYPE_ST_UNICODE;
8223 kern_type = KERN_TYPE_DCC2;
8224 dgst_size = DGST_SIZE_4_4;
8225 parse_func = dcc2_parse_hash;
8226 sort_by_digest = sort_by_digest_4_4;
8227 opti_type = OPTI_TYPE_ZERO_BYTE
8228 | OPTI_TYPE_SLOW_HASH_SIMD;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 1;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 3;
8233 break;
8234
8235 case 2400: hash_type = HASH_TYPE_MD5;
8236 salt_type = SALT_TYPE_NONE;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8239 kern_type = KERN_TYPE_MD5PIX;
8240 dgst_size = DGST_SIZE_4_4;
8241 parse_func = md5pix_parse_hash;
8242 sort_by_digest = sort_by_digest_4_4;
8243 opti_type = OPTI_TYPE_ZERO_BYTE
8244 | OPTI_TYPE_PRECOMPUTE_INIT
8245 | OPTI_TYPE_PRECOMPUTE_MERKLE
8246 | OPTI_TYPE_EARLY_SKIP
8247 | OPTI_TYPE_NOT_ITERATED
8248 | OPTI_TYPE_NOT_SALTED;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 3;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 1;
8253 break;
8254
8255 case 2410: hash_type = HASH_TYPE_MD5;
8256 salt_type = SALT_TYPE_INTERN;
8257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8259 kern_type = KERN_TYPE_MD5ASA;
8260 dgst_size = DGST_SIZE_4_4;
8261 parse_func = md5asa_parse_hash;
8262 sort_by_digest = sort_by_digest_4_4;
8263 opti_type = OPTI_TYPE_ZERO_BYTE
8264 | OPTI_TYPE_PRECOMPUTE_INIT
8265 | OPTI_TYPE_PRECOMPUTE_MERKLE
8266 | OPTI_TYPE_EARLY_SKIP
8267 | OPTI_TYPE_NOT_ITERATED;
8268 dgst_pos0 = 0;
8269 dgst_pos1 = 3;
8270 dgst_pos2 = 2;
8271 dgst_pos3 = 1;
8272 break;
8273
8274 case 2500: hash_type = HASH_TYPE_WPA;
8275 salt_type = SALT_TYPE_EMBEDDED;
8276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8278 kern_type = KERN_TYPE_WPA;
8279 dgst_size = DGST_SIZE_4_4;
8280 parse_func = wpa_parse_hash;
8281 sort_by_digest = sort_by_digest_4_4;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_SLOW_HASH_SIMD;
8284 dgst_pos0 = 0;
8285 dgst_pos1 = 1;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 3;
8288 break;
8289
8290 case 2600: hash_type = HASH_TYPE_MD5;
8291 salt_type = SALT_TYPE_VIRTUAL;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_LE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS14
8296 | OPTS_TYPE_ST_ADD80;
8297 kern_type = KERN_TYPE_MD55_PWSLT1;
8298 dgst_size = DGST_SIZE_4_4;
8299 parse_func = md5md5_parse_hash;
8300 sort_by_digest = sort_by_digest_4_4;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2611: hash_type = HASH_TYPE_MD5;
8312 salt_type = SALT_TYPE_INTERN;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS14
8317 | OPTS_TYPE_ST_ADD80;
8318 kern_type = KERN_TYPE_MD55_PWSLT1;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = vb3_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE
8323 | OPTI_TYPE_PRECOMPUTE_INIT
8324 | OPTI_TYPE_PRECOMPUTE_MERKLE
8325 | OPTI_TYPE_EARLY_SKIP;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 2612: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14
8338 | OPTS_TYPE_ST_ADD80
8339 | OPTS_TYPE_ST_HEX;
8340 kern_type = KERN_TYPE_MD55_PWSLT1;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = phps_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_PRECOMPUTE_MERKLE
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 2711: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_INTERN;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_ADD80
8359 | OPTS_TYPE_PT_ADDBITS14
8360 | OPTS_TYPE_ST_ADD80;
8361 kern_type = KERN_TYPE_MD55_PWSLT2;
8362 dgst_size = DGST_SIZE_4_4;
8363 parse_func = vb30_parse_hash;
8364 sort_by_digest = sort_by_digest_4_4;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_PRECOMPUTE_INIT
8367 | OPTI_TYPE_EARLY_SKIP;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 3;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 2811: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADD80
8379 | OPTS_TYPE_PT_ADDBITS14;
8380 kern_type = KERN_TYPE_MD55_SLTPW;
8381 dgst_size = DGST_SIZE_4_4;
8382 parse_func = ipb2_parse_hash;
8383 sort_by_digest = sort_by_digest_4_4;
8384 opti_type = OPTI_TYPE_ZERO_BYTE
8385 | OPTI_TYPE_PRECOMPUTE_INIT
8386 | OPTI_TYPE_EARLY_SKIP;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 3000: hash_type = HASH_TYPE_LM;
8394 salt_type = SALT_TYPE_NONE;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE
8397 | OPTS_TYPE_PT_UPPER
8398 | OPTS_TYPE_PT_BITSLICE;
8399 kern_type = KERN_TYPE_LM;
8400 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8401 parse_func = lm_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 1;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 3;
8409 break;
8410
8411 case 3100: hash_type = HASH_TYPE_ORACLEH;
8412 salt_type = SALT_TYPE_INTERN;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_UPPER
8416 | OPTS_TYPE_ST_UPPER;
8417 kern_type = KERN_TYPE_ORACLEH;
8418 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8419 parse_func = oracleh_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8421 opti_type = OPTI_TYPE_ZERO_BYTE;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 3200: hash_type = HASH_TYPE_BCRYPT;
8429 salt_type = SALT_TYPE_EMBEDDED;
8430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_ST_GENERATE_LE;
8433 kern_type = KERN_TYPE_BCRYPT;
8434 dgst_size = DGST_SIZE_4_6;
8435 parse_func = bcrypt_parse_hash;
8436 sort_by_digest = sort_by_digest_4_6;
8437 opti_type = OPTI_TYPE_ZERO_BYTE;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 1;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 3;
8442 break;
8443
8444 case 3710: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_INTERN;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = md5s_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 3711: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14;
8470 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = mediawiki_b_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 3800: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_ST_ADDBITS14;
8489 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = md5s_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_RAW_HASH;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 4300: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_VIRTUAL;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS14
8511 | OPTS_TYPE_ST_ADD80;
8512 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8513 dgst_size = DGST_SIZE_4_4;
8514 parse_func = md5md5_parse_hash;
8515 sort_by_digest = sort_by_digest_4_4;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 3;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 1;
8524 break;
8525
8526
8527 case 4400: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_NONE;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS15;
8533 kern_type = KERN_TYPE_MD5_SHA1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = md5_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_NOT_SALTED
8543 | OPTI_TYPE_RAW_HASH;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 4500: hash_type = HASH_TYPE_SHA1;
8551 salt_type = SALT_TYPE_NONE;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_BE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS15;
8556 kern_type = KERN_TYPE_SHA11;
8557 dgst_size = DGST_SIZE_4_5;
8558 parse_func = sha1_parse_hash;
8559 sort_by_digest = sort_by_digest_4_5;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_PRECOMPUTE_MERKLE
8563 | OPTI_TYPE_EARLY_SKIP
8564 | OPTI_TYPE_NOT_SALTED;
8565 dgst_pos0 = 3;
8566 dgst_pos1 = 4;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 4700: hash_type = HASH_TYPE_SHA1;
8572 salt_type = SALT_TYPE_NONE;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE
8575 | OPTS_TYPE_PT_ADD80
8576 | OPTS_TYPE_PT_ADDBITS14;
8577 kern_type = KERN_TYPE_SHA1_MD5;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = sha1_parse_hash;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP
8585 | OPTI_TYPE_NOT_ITERATED
8586 | OPTI_TYPE_NOT_SALTED
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 4800: hash_type = HASH_TYPE_MD5;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADDBITS14;
8599 kern_type = KERN_TYPE_MD5_CHAP;
8600 dgst_size = DGST_SIZE_4_4;
8601 parse_func = chap_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_MEET_IN_MIDDLE
8607 | OPTI_TYPE_EARLY_SKIP
8608 | OPTI_TYPE_NOT_ITERATED
8609 | OPTI_TYPE_RAW_HASH;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 3;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 1;
8614 break;
8615
8616 case 4900: hash_type = HASH_TYPE_SHA1;
8617 salt_type = SALT_TYPE_INTERN;
8618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8620 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8621 dgst_size = DGST_SIZE_4_5;
8622 parse_func = sha1s_parse_hash;
8623 sort_by_digest = sort_by_digest_4_5;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_EARLY_SKIP;
8628 dgst_pos0 = 3;
8629 dgst_pos1 = 4;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 5000: hash_type = HASH_TYPE_KECCAK;
8635 salt_type = SALT_TYPE_EMBEDDED;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE
8638 | OPTS_TYPE_PT_ADD01;
8639 kern_type = KERN_TYPE_KECCAK;
8640 dgst_size = DGST_SIZE_8_25;
8641 parse_func = keccak_parse_hash;
8642 sort_by_digest = sort_by_digest_8_25;
8643 opti_type = OPTI_TYPE_ZERO_BYTE
8644 | OPTI_TYPE_USES_BITS_64
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 2;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 4;
8649 dgst_pos3 = 5;
8650 break;
8651
8652 case 5100: hash_type = HASH_TYPE_MD5H;
8653 salt_type = SALT_TYPE_NONE;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD80
8657 | OPTS_TYPE_PT_ADDBITS14;
8658 kern_type = KERN_TYPE_MD5H;
8659 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8660 parse_func = md5half_parse_hash;
8661 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8662 opti_type = OPTI_TYPE_ZERO_BYTE
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 1;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 3;
8668 break;
8669
8670 case 5200: hash_type = HASH_TYPE_SHA256;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8674 kern_type = KERN_TYPE_PSAFE3;
8675 dgst_size = DGST_SIZE_4_8;
8676 parse_func = psafe3_parse_hash;
8677 sort_by_digest = sort_by_digest_4_8;
8678 opti_type = OPTI_TYPE_ZERO_BYTE;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 1;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 3;
8683 break;
8684
8685 case 5300: hash_type = HASH_TYPE_MD5;
8686 salt_type = SALT_TYPE_EMBEDDED;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE
8689 | OPTS_TYPE_ST_ADD80;
8690 kern_type = KERN_TYPE_IKEPSK_MD5;
8691 dgst_size = DGST_SIZE_4_4;
8692 parse_func = ikepsk_md5_parse_hash;
8693 sort_by_digest = sort_by_digest_4_4;
8694 opti_type = OPTI_TYPE_ZERO_BYTE;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 5400: hash_type = HASH_TYPE_SHA1;
8702 salt_type = SALT_TYPE_EMBEDDED;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_ST_ADD80;
8706 kern_type = KERN_TYPE_IKEPSK_SHA1;
8707 dgst_size = DGST_SIZE_4_5;
8708 parse_func = ikepsk_sha1_parse_hash;
8709 sort_by_digest = sort_by_digest_4_5;
8710 opti_type = OPTI_TYPE_ZERO_BYTE;
8711 dgst_pos0 = 3;
8712 dgst_pos1 = 4;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 1;
8715 break;
8716
8717 case 5500: hash_type = HASH_TYPE_NETNTLM;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE
8721 | OPTS_TYPE_PT_ADD80
8722 | OPTS_TYPE_PT_ADDBITS14
8723 | OPTS_TYPE_PT_UNICODE
8724 | OPTS_TYPE_ST_HEX;
8725 kern_type = KERN_TYPE_NETNTLMv1;
8726 dgst_size = DGST_SIZE_4_4;
8727 parse_func = netntlmv1_parse_hash;
8728 sort_by_digest = sort_by_digest_4_4;
8729 opti_type = OPTI_TYPE_ZERO_BYTE
8730 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 5600: hash_type = HASH_TYPE_MD5;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE
8741 | OPTS_TYPE_PT_ADD80
8742 | OPTS_TYPE_PT_ADDBITS14
8743 | OPTS_TYPE_PT_UNICODE;
8744 kern_type = KERN_TYPE_NETNTLMv2;
8745 dgst_size = DGST_SIZE_4_4;
8746 parse_func = netntlmv2_parse_hash;
8747 sort_by_digest = sort_by_digest_4_4;
8748 opti_type = OPTI_TYPE_ZERO_BYTE;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 3;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 5700: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_NONE;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_BE
8759 | OPTS_TYPE_PT_ADD80
8760 | OPTS_TYPE_PT_ADDBITS15;
8761 kern_type = KERN_TYPE_SHA256;
8762 dgst_size = DGST_SIZE_4_8;
8763 parse_func = cisco4_parse_hash;
8764 sort_by_digest = sort_by_digest_4_8;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_PRECOMPUTE_INIT
8767 | OPTI_TYPE_PRECOMPUTE_MERKLE
8768 | OPTI_TYPE_EARLY_SKIP
8769 | OPTI_TYPE_NOT_ITERATED
8770 | OPTI_TYPE_NOT_SALTED
8771 | OPTI_TYPE_RAW_HASH;
8772 dgst_pos0 = 3;
8773 dgst_pos1 = 7;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 6;
8776 break;
8777
8778 case 5800: hash_type = HASH_TYPE_SHA1;
8779 salt_type = SALT_TYPE_INTERN;
8780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8782 | OPTS_TYPE_ST_ADD80;
8783 kern_type = KERN_TYPE_ANDROIDPIN;
8784 dgst_size = DGST_SIZE_4_5;
8785 parse_func = androidpin_parse_hash;
8786 sort_by_digest = sort_by_digest_4_5;
8787 opti_type = OPTI_TYPE_ZERO_BYTE;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 1;
8790 dgst_pos2 = 2;
8791 dgst_pos3 = 3;
8792 break;
8793
8794 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8795 salt_type = SALT_TYPE_NONE;
8796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_LE
8798 | OPTS_TYPE_PT_ADD80;
8799 kern_type = KERN_TYPE_RIPEMD160;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = ripemd160_parse_hash;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8811 salt_type = SALT_TYPE_NONE;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_BE
8814 | OPTS_TYPE_PT_ADD80;
8815 kern_type = KERN_TYPE_WHIRLPOOL;
8816 dgst_size = DGST_SIZE_4_16;
8817 parse_func = whirlpool_parse_hash;
8818 sort_by_digest = sort_by_digest_4_16;
8819 opti_type = OPTI_TYPE_ZERO_BYTE;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8830 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8831 dgst_size = DGST_SIZE_4_5;
8832 parse_func = truecrypt_parse_hash_2k;
8833 sort_by_digest = sort_by_digest_4_5;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8845 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8846 dgst_size = DGST_SIZE_4_5;
8847 parse_func = truecrypt_parse_hash_2k;
8848 sort_by_digest = sort_by_digest_4_5;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8860 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8861 dgst_size = DGST_SIZE_4_5;
8862 parse_func = truecrypt_parse_hash_2k;
8863 sort_by_digest = sort_by_digest_4_5;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 6221: hash_type = HASH_TYPE_SHA512;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8875 kern_type = KERN_TYPE_TCSHA512_XTS512;
8876 dgst_size = DGST_SIZE_8_8;
8877 parse_func = truecrypt_parse_hash_1k;
8878 sort_by_digest = sort_by_digest_8_8;
8879 opti_type = OPTI_TYPE_ZERO_BYTE
8880 | OPTI_TYPE_USES_BITS_64;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 1;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 3;
8885 break;
8886
8887 case 6222: hash_type = HASH_TYPE_SHA512;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8891 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8892 dgst_size = DGST_SIZE_8_8;
8893 parse_func = truecrypt_parse_hash_1k;
8894 sort_by_digest = sort_by_digest_8_8;
8895 opti_type = OPTI_TYPE_ZERO_BYTE
8896 | OPTI_TYPE_USES_BITS_64;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6223: hash_type = HASH_TYPE_SHA512;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8908 dgst_size = DGST_SIZE_8_8;
8909 parse_func = truecrypt_parse_hash_1k;
8910 sort_by_digest = sort_by_digest_8_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_USES_BITS_64;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 1;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 3;
8917 break;
8918
8919 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8923 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8924 dgst_size = DGST_SIZE_4_8;
8925 parse_func = truecrypt_parse_hash_1k;
8926 sort_by_digest = sort_by_digest_4_8;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8935 salt_type = SALT_TYPE_EMBEDDED;
8936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8938 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8939 dgst_size = DGST_SIZE_4_8;
8940 parse_func = truecrypt_parse_hash_1k;
8941 sort_by_digest = sort_by_digest_4_8;
8942 opti_type = OPTI_TYPE_ZERO_BYTE;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8954 dgst_size = DGST_SIZE_4_8;
8955 parse_func = truecrypt_parse_hash_1k;
8956 sort_by_digest = sort_by_digest_4_8;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8968 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = truecrypt_parse_hash_1k;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8984 dgst_size = DGST_SIZE_4_5;
8985 parse_func = truecrypt_parse_hash_1k;
8986 sort_by_digest = sort_by_digest_4_5;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_1k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6300: hash_type = HASH_TYPE_MD5;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_MD5AIX;
9014 dgst_size = DGST_SIZE_4_4;
9015 parse_func = md5aix_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6400: hash_type = HASH_TYPE_SHA256;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9028 kern_type = KERN_TYPE_SHA256AIX;
9029 dgst_size = DGST_SIZE_4_8;
9030 parse_func = sha256aix_parse_hash;
9031 sort_by_digest = sort_by_digest_4_8;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6500: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_SHA512AIX;
9044 dgst_size = DGST_SIZE_8_8;
9045 parse_func = sha512aix_parse_hash;
9046 sort_by_digest = sort_by_digest_8_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 6600: hash_type = HASH_TYPE_AES;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9059 kern_type = KERN_TYPE_AGILEKEY;
9060 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9061 parse_func = agilekey_parse_hash;
9062 sort_by_digest = sort_by_digest_4_5;
9063 opti_type = OPTI_TYPE_ZERO_BYTE;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 1;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 3;
9068 break;
9069
9070 case 6700: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9074 kern_type = KERN_TYPE_SHA1AIX;
9075 dgst_size = DGST_SIZE_4_5;
9076 parse_func = sha1aix_parse_hash;
9077 sort_by_digest = sort_by_digest_4_5;
9078 opti_type = OPTI_TYPE_ZERO_BYTE;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 6800: hash_type = HASH_TYPE_AES;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9089 kern_type = KERN_TYPE_LASTPASS;
9090 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9091 parse_func = lastpass_parse_hash;
9092 sort_by_digest = sort_by_digest_4_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE;
9094 dgst_pos0 = 0;
9095 dgst_pos1 = 1;
9096 dgst_pos2 = 2;
9097 dgst_pos3 = 3;
9098 break;
9099
9100 case 6900: hash_type = HASH_TYPE_GOST;
9101 salt_type = SALT_TYPE_NONE;
9102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9104 kern_type = KERN_TYPE_GOST;
9105 dgst_size = DGST_SIZE_4_8;
9106 parse_func = gost_parse_hash;
9107 sort_by_digest = sort_by_digest_4_8;
9108 opti_type = OPTI_TYPE_ZERO_BYTE;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 7100: hash_type = HASH_TYPE_SHA512;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9119 kern_type = KERN_TYPE_PBKDF2_SHA512;
9120 dgst_size = DGST_SIZE_8_16;
9121 parse_func = sha512osx_parse_hash;
9122 sort_by_digest = sort_by_digest_8_16;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_USES_BITS_64
9125 | OPTI_TYPE_SLOW_HASH_SIMD;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 7200: hash_type = HASH_TYPE_SHA512;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9136 kern_type = KERN_TYPE_PBKDF2_SHA512;
9137 dgst_size = DGST_SIZE_8_16;
9138 parse_func = sha512grub_parse_hash;
9139 sort_by_digest = sort_by_digest_8_16;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_USES_BITS_64
9142 | OPTI_TYPE_SLOW_HASH_SIMD;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 7300: hash_type = HASH_TYPE_SHA1;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_BE
9153 | OPTS_TYPE_ST_ADD80
9154 | OPTS_TYPE_ST_ADDBITS15;
9155 kern_type = KERN_TYPE_RAKP;
9156 dgst_size = DGST_SIZE_4_5;
9157 parse_func = rakp_parse_hash;
9158 sort_by_digest = sort_by_digest_4_5;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_NOT_ITERATED;
9161 dgst_pos0 = 3;
9162 dgst_pos1 = 4;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 1;
9165 break;
9166
9167 case 7400: hash_type = HASH_TYPE_SHA256;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9171 kern_type = KERN_TYPE_SHA256CRYPT;
9172 dgst_size = DGST_SIZE_4_8;
9173 parse_func = sha256crypt_parse_hash;
9174 sort_by_digest = sort_by_digest_4_8;
9175 opti_type = OPTI_TYPE_ZERO_BYTE;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 7500: hash_type = HASH_TYPE_KRB5PA;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9186 kern_type = KERN_TYPE_KRB5PA;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = krb5pa_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_NOT_ITERATED;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 1;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 3;
9196 break;
9197
9198 case 7600: hash_type = HASH_TYPE_SHA1;
9199 salt_type = SALT_TYPE_INTERN;
9200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_BE
9202 | OPTS_TYPE_PT_ADD80
9203 | OPTS_TYPE_PT_ADDBITS15;
9204 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9205 dgst_size = DGST_SIZE_4_5;
9206 parse_func = redmine_parse_hash;
9207 sort_by_digest = sort_by_digest_4_5;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_PRECOMPUTE_INIT
9210 | OPTI_TYPE_EARLY_SKIP
9211 | OPTI_TYPE_NOT_ITERATED
9212 | OPTI_TYPE_PREPENDED_SALT;
9213 dgst_pos0 = 3;
9214 dgst_pos1 = 4;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 1;
9217 break;
9218
9219 case 7700: hash_type = HASH_TYPE_SAPB;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_LE
9223 | OPTS_TYPE_PT_UPPER
9224 | OPTS_TYPE_ST_UPPER;
9225 kern_type = KERN_TYPE_SAPB;
9226 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9227 parse_func = sapb_parse_hash;
9228 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_PRECOMPUTE_INIT
9231 | OPTI_TYPE_NOT_ITERATED;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 1;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 3;
9236 break;
9237
9238 case 7800: hash_type = HASH_TYPE_SAPG;
9239 salt_type = SALT_TYPE_EMBEDDED;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_BE
9242 | OPTS_TYPE_ST_ADD80
9243 | OPTS_TYPE_ST_UPPER;
9244 kern_type = KERN_TYPE_SAPG;
9245 dgst_size = DGST_SIZE_4_5;
9246 parse_func = sapg_parse_hash;
9247 sort_by_digest = sort_by_digest_4_5;
9248 opti_type = OPTI_TYPE_ZERO_BYTE
9249 | OPTI_TYPE_PRECOMPUTE_INIT
9250 | OPTI_TYPE_NOT_ITERATED;
9251 dgst_pos0 = 3;
9252 dgst_pos1 = 4;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 1;
9255 break;
9256
9257 case 7900: hash_type = HASH_TYPE_SHA512;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9261 kern_type = KERN_TYPE_DRUPAL7;
9262 dgst_size = DGST_SIZE_8_8;
9263 parse_func = drupal7_parse_hash;
9264 sort_by_digest = sort_by_digest_8_8;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_USES_BITS_64;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 8000: hash_type = HASH_TYPE_SHA256;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_BE
9277 | OPTS_TYPE_PT_UNICODE
9278 | OPTS_TYPE_ST_ADD80
9279 | OPTS_TYPE_ST_HEX;
9280 kern_type = KERN_TYPE_SYBASEASE;
9281 dgst_size = DGST_SIZE_4_8;
9282 parse_func = sybasease_parse_hash;
9283 sort_by_digest = sort_by_digest_4_8;
9284 opti_type = OPTI_TYPE_ZERO_BYTE
9285 | OPTI_TYPE_PRECOMPUTE_INIT
9286 | OPTI_TYPE_EARLY_SKIP
9287 | OPTI_TYPE_NOT_ITERATED
9288 | OPTI_TYPE_RAW_HASH;
9289 dgst_pos0 = 3;
9290 dgst_pos1 = 7;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 6;
9293 break;
9294
9295 case 8100: hash_type = HASH_TYPE_SHA1;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9299 kern_type = KERN_TYPE_NETSCALER;
9300 dgst_size = DGST_SIZE_4_5;
9301 parse_func = netscaler_parse_hash;
9302 sort_by_digest = sort_by_digest_4_5;
9303 opti_type = OPTI_TYPE_ZERO_BYTE
9304 | OPTI_TYPE_PRECOMPUTE_INIT
9305 | OPTI_TYPE_PRECOMPUTE_MERKLE
9306 | OPTI_TYPE_EARLY_SKIP
9307 | OPTI_TYPE_NOT_ITERATED
9308 | OPTI_TYPE_PREPENDED_SALT
9309 | OPTI_TYPE_RAW_HASH;
9310 dgst_pos0 = 3;
9311 dgst_pos1 = 4;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 1;
9314 break;
9315
9316 case 8200: hash_type = HASH_TYPE_SHA256;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9320 kern_type = KERN_TYPE_CLOUDKEY;
9321 dgst_size = DGST_SIZE_4_8;
9322 parse_func = cloudkey_parse_hash;
9323 sort_by_digest = sort_by_digest_4_8;
9324 opti_type = OPTI_TYPE_ZERO_BYTE;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 8300: hash_type = HASH_TYPE_SHA1;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_BE
9335 | OPTS_TYPE_ST_HEX
9336 | OPTS_TYPE_ST_ADD80;
9337 kern_type = KERN_TYPE_NSEC3;
9338 dgst_size = DGST_SIZE_4_5;
9339 parse_func = nsec3_parse_hash;
9340 sort_by_digest = sort_by_digest_4_5;
9341 opti_type = OPTI_TYPE_ZERO_BYTE;
9342 dgst_pos0 = 3;
9343 dgst_pos1 = 4;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 1;
9346 break;
9347
9348 case 8400: hash_type = HASH_TYPE_SHA1;
9349 salt_type = SALT_TYPE_INTERN;
9350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_BE
9352 | OPTS_TYPE_PT_ADD80
9353 | OPTS_TYPE_PT_ADDBITS15;
9354 kern_type = KERN_TYPE_WBB3;
9355 dgst_size = DGST_SIZE_4_5;
9356 parse_func = wbb3_parse_hash;
9357 sort_by_digest = sort_by_digest_4_5;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_PRECOMPUTE_INIT
9360 | OPTI_TYPE_NOT_ITERATED;
9361 dgst_pos0 = 3;
9362 dgst_pos1 = 4;
9363 dgst_pos2 = 2;
9364 dgst_pos3 = 1;
9365 break;
9366
9367 case 8500: hash_type = HASH_TYPE_DESRACF;
9368 salt_type = SALT_TYPE_EMBEDDED;
9369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9370 opts_type = OPTS_TYPE_PT_GENERATE_LE
9371 | OPTS_TYPE_ST_UPPER;
9372 kern_type = KERN_TYPE_RACF;
9373 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9374 parse_func = racf_parse_hash;
9375 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 8600: hash_type = HASH_TYPE_LOTUS5;
9385 salt_type = SALT_TYPE_NONE;
9386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9388 kern_type = KERN_TYPE_LOTUS5;
9389 dgst_size = DGST_SIZE_4_4;
9390 parse_func = lotus5_parse_hash;
9391 sort_by_digest = sort_by_digest_4_4;
9392 opti_type = OPTI_TYPE_EARLY_SKIP
9393 | OPTI_TYPE_NOT_ITERATED
9394 | OPTI_TYPE_NOT_SALTED
9395 | OPTI_TYPE_RAW_HASH;
9396 dgst_pos0 = 0;
9397 dgst_pos1 = 1;
9398 dgst_pos2 = 2;
9399 dgst_pos3 = 3;
9400 break;
9401
9402 case 8700: hash_type = HASH_TYPE_LOTUS6;
9403 salt_type = SALT_TYPE_EMBEDDED;
9404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9406 kern_type = KERN_TYPE_LOTUS6;
9407 dgst_size = DGST_SIZE_4_4;
9408 parse_func = lotus6_parse_hash;
9409 sort_by_digest = sort_by_digest_4_4;
9410 opti_type = OPTI_TYPE_EARLY_SKIP
9411 | OPTI_TYPE_NOT_ITERATED
9412 | OPTI_TYPE_RAW_HASH;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_ANDROIDFDE;
9424 dgst_size = DGST_SIZE_4_4;
9425 parse_func = androidfde_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 8900: hash_type = HASH_TYPE_SCRYPT;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_SCRYPT;
9439 dgst_size = DGST_SIZE_4_8;
9440 parse_func = scrypt_parse_hash;
9441 sort_by_digest = sort_by_digest_4_8;
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9000: hash_type = HASH_TYPE_SHA1;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE
9453 | OPTS_TYPE_ST_GENERATE_LE;
9454 kern_type = KERN_TYPE_PSAFE2;
9455 dgst_size = DGST_SIZE_4_5;
9456 parse_func = psafe2_parse_hash;
9457 sort_by_digest = sort_by_digest_4_5;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9100: hash_type = HASH_TYPE_LOTUS8;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_LOTUS8;
9470 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9471 parse_func = lotus8_parse_hash;
9472 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9200: hash_type = HASH_TYPE_SHA256;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9484 kern_type = KERN_TYPE_PBKDF2_SHA256;
9485 dgst_size = DGST_SIZE_4_32;
9486 parse_func = cisco8_parse_hash;
9487 sort_by_digest = sort_by_digest_4_32;
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_SLOW_HASH_SIMD;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 9300: hash_type = HASH_TYPE_SCRYPT;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9500 kern_type = KERN_TYPE_SCRYPT;
9501 dgst_size = DGST_SIZE_4_8;
9502 parse_func = cisco9_parse_hash;
9503 sort_by_digest = sort_by_digest_4_8;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_OFFICE2007;
9516 dgst_size = DGST_SIZE_4_4;
9517 parse_func = office2007_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4;
9519 opti_type = OPTI_TYPE_ZERO_BYTE;
9520 dgst_pos0 = 0;
9521 dgst_pos1 = 1;
9522 dgst_pos2 = 2;
9523 dgst_pos3 = 3;
9524 break;
9525
9526 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9527 salt_type = SALT_TYPE_EMBEDDED;
9528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9530 kern_type = KERN_TYPE_OFFICE2010;
9531 dgst_size = DGST_SIZE_4_4;
9532 parse_func = office2010_parse_hash;
9533 sort_by_digest = sort_by_digest_4_4;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_OFFICE2013;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = office2013_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE
9560 | OPTS_TYPE_PT_ADD80
9561 | OPTS_TYPE_PT_UNICODE;
9562 kern_type = KERN_TYPE_OLDOFFICE01;
9563 dgst_size = DGST_SIZE_4_4;
9564 parse_func = oldoffice01_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_PRECOMPUTE_INIT
9568 | OPTI_TYPE_NOT_ITERATED;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE
9579 | OPTS_TYPE_PT_ADD80;
9580 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = oldoffice01cm1_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE
9585 | OPTI_TYPE_PRECOMPUTE_INIT
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_PT_ADD80
9598 | OPTS_TYPE_PT_UNICODE
9599 | OPTS_TYPE_PT_NEVERCRACK;
9600 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = oldoffice01cm2_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4;
9604 opti_type = OPTI_TYPE_ZERO_BYTE
9605 | OPTI_TYPE_PRECOMPUTE_INIT
9606 | OPTI_TYPE_NOT_ITERATED;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_BE
9617 | OPTS_TYPE_PT_ADD80
9618 | OPTS_TYPE_PT_UNICODE;
9619 kern_type = KERN_TYPE_OLDOFFICE34;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = oldoffice34_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE
9624 | OPTI_TYPE_PRECOMPUTE_INIT
9625 | OPTI_TYPE_NOT_ITERATED;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9637 dgst_size = DGST_SIZE_4_4;
9638 parse_func = oldoffice34cm1_parse_hash;
9639 sort_by_digest = sort_by_digest_4_4;
9640 opti_type = OPTI_TYPE_ZERO_BYTE
9641 | OPTI_TYPE_PRECOMPUTE_INIT
9642 | OPTI_TYPE_NOT_ITERATED;
9643 dgst_pos0 = 0;
9644 dgst_pos1 = 1;
9645 dgst_pos2 = 2;
9646 dgst_pos3 = 3;
9647 break;
9648
9649 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9650 salt_type = SALT_TYPE_EMBEDDED;
9651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9652 opts_type = OPTS_TYPE_PT_GENERATE_BE
9653 | OPTS_TYPE_PT_ADD80
9654 | OPTS_TYPE_PT_UNICODE
9655 | OPTS_TYPE_PT_NEVERCRACK;
9656 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9657 dgst_size = DGST_SIZE_4_4;
9658 parse_func = oldoffice34cm2_parse_hash;
9659 sort_by_digest = sort_by_digest_4_4;
9660 opti_type = OPTI_TYPE_ZERO_BYTE
9661 | OPTI_TYPE_PRECOMPUTE_INIT
9662 | OPTI_TYPE_NOT_ITERATED;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 9900: hash_type = HASH_TYPE_MD5;
9670 salt_type = SALT_TYPE_NONE;
9671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_RADMIN2;
9674 dgst_size = DGST_SIZE_4_4;
9675 parse_func = radmin2_parse_hash;
9676 sort_by_digest = sort_by_digest_4_4;
9677 opti_type = OPTI_TYPE_ZERO_BYTE
9678 | OPTI_TYPE_PRECOMPUTE_INIT
9679 | OPTI_TYPE_EARLY_SKIP
9680 | OPTI_TYPE_NOT_ITERATED
9681 | OPTI_TYPE_NOT_SALTED;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 3;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 1;
9686 break;
9687
9688 case 10000: hash_type = HASH_TYPE_SHA256;
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_PBKDF2_SHA256;
9693 dgst_size = DGST_SIZE_4_32;
9694 parse_func = djangopbkdf2_parse_hash;
9695 sort_by_digest = sort_by_digest_4_32;
9696 opti_type = OPTI_TYPE_ZERO_BYTE
9697 | OPTI_TYPE_SLOW_HASH_SIMD;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 10100: hash_type = HASH_TYPE_SIPHASH;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9708 kern_type = KERN_TYPE_SIPHASH;
9709 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9710 parse_func = siphash_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9712 opti_type = OPTI_TYPE_ZERO_BYTE
9713 | OPTI_TYPE_NOT_ITERATED
9714 | OPTI_TYPE_RAW_HASH;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 1;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 3;
9719 break;
9720
9721 case 10200: hash_type = HASH_TYPE_MD5;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE
9725 | OPTS_TYPE_ST_ADD80
9726 | OPTS_TYPE_ST_ADDBITS14;
9727 kern_type = KERN_TYPE_HMACMD5_PW;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = crammd5_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 3;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 1;
9737 break;
9738
9739 case 10300: hash_type = HASH_TYPE_SHA1;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9743 kern_type = KERN_TYPE_SAPH_SHA1;
9744 dgst_size = DGST_SIZE_4_5;
9745 parse_func = saph_sha1_parse_hash;
9746 sort_by_digest = sort_by_digest_4_5;
9747 opti_type = OPTI_TYPE_ZERO_BYTE;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 10400: hash_type = HASH_TYPE_PDFU16;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_PDF11;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = pdf11_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 10410: hash_type = HASH_TYPE_PDFU16;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9774 kern_type = KERN_TYPE_PDF11CM1;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = pdf11cm1_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 10420: hash_type = HASH_TYPE_PDFU16;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_PDF11CM2;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = pdf11cm2_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_NOT_ITERATED;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 10500: hash_type = HASH_TYPE_PDFU16;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9806 kern_type = KERN_TYPE_PDF14;
9807 dgst_size = DGST_SIZE_4_4;
9808 parse_func = pdf14_parse_hash;
9809 sort_by_digest = sort_by_digest_4_4;
9810 opti_type = OPTI_TYPE_ZERO_BYTE
9811 | OPTI_TYPE_NOT_ITERATED;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 10600: hash_type = HASH_TYPE_SHA256;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_BE
9822 | OPTS_TYPE_ST_ADD80
9823 | OPTS_TYPE_ST_ADDBITS15
9824 | OPTS_TYPE_HASH_COPY;
9825 kern_type = KERN_TYPE_SHA256_PWSLT;
9826 dgst_size = DGST_SIZE_4_8;
9827 parse_func = pdf17l3_parse_hash;
9828 sort_by_digest = sort_by_digest_4_8;
9829 opti_type = OPTI_TYPE_ZERO_BYTE
9830 | OPTI_TYPE_PRECOMPUTE_INIT
9831 | OPTI_TYPE_PRECOMPUTE_MERKLE
9832 | OPTI_TYPE_EARLY_SKIP
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_APPENDED_SALT
9835 | OPTI_TYPE_RAW_HASH;
9836 dgst_pos0 = 3;
9837 dgst_pos1 = 7;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 6;
9840 break;
9841
9842 case 10700: hash_type = HASH_TYPE_PDFU32;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE
9846 | OPTS_TYPE_HASH_COPY;
9847 kern_type = KERN_TYPE_PDF17L8;
9848 dgst_size = DGST_SIZE_4_8;
9849 parse_func = pdf17l8_parse_hash;
9850 sort_by_digest = sort_by_digest_4_8;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_NOT_ITERATED;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 1;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 3;
9857 break;
9858
9859 case 10800: hash_type = HASH_TYPE_SHA384;
9860 salt_type = SALT_TYPE_NONE;
9861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_BE
9863 | OPTS_TYPE_PT_ADD80
9864 | OPTS_TYPE_PT_ADDBITS15;
9865 kern_type = KERN_TYPE_SHA384;
9866 dgst_size = DGST_SIZE_8_8;
9867 parse_func = sha384_parse_hash;
9868 sort_by_digest = sort_by_digest_8_8;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_PRECOMPUTE_INIT
9871 | OPTI_TYPE_PRECOMPUTE_MERKLE
9872 | OPTI_TYPE_EARLY_SKIP
9873 | OPTI_TYPE_NOT_ITERATED
9874 | OPTI_TYPE_NOT_SALTED
9875 | OPTI_TYPE_USES_BITS_64
9876 | OPTI_TYPE_RAW_HASH;
9877 dgst_pos0 = 6;
9878 dgst_pos1 = 7;
9879 dgst_pos2 = 4;
9880 dgst_pos3 = 5;
9881 break;
9882
9883 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_ST_BASE64
9888 | OPTS_TYPE_HASH_COPY;
9889 kern_type = KERN_TYPE_PBKDF2_SHA256;
9890 dgst_size = DGST_SIZE_4_32;
9891 parse_func = pbkdf2_sha256_parse_hash;
9892 sort_by_digest = sort_by_digest_4_32;
9893 opti_type = OPTI_TYPE_ZERO_BYTE
9894 | OPTI_TYPE_SLOW_HASH_SIMD;
9895 dgst_pos0 = 0;
9896 dgst_pos1 = 1;
9897 dgst_pos2 = 2;
9898 dgst_pos3 = 3;
9899 break;
9900
9901 case 11000: hash_type = HASH_TYPE_MD5;
9902 salt_type = SALT_TYPE_INTERN;
9903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_PT_ADD80;
9906 kern_type = KERN_TYPE_PRESTASHOP;
9907 dgst_size = DGST_SIZE_4_4;
9908 parse_func = prestashop_parse_hash;
9909 sort_by_digest = sort_by_digest_4_4;
9910 opti_type = OPTI_TYPE_ZERO_BYTE
9911 | OPTI_TYPE_PRECOMPUTE_INIT
9912 | OPTI_TYPE_NOT_ITERATED
9913 | OPTI_TYPE_PREPENDED_SALT;
9914 dgst_pos0 = 0;
9915 dgst_pos1 = 3;
9916 dgst_pos2 = 2;
9917 dgst_pos3 = 1;
9918 break;
9919
9920 case 11100: hash_type = HASH_TYPE_MD5;
9921 salt_type = SALT_TYPE_EMBEDDED;
9922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9923 opts_type = OPTS_TYPE_PT_GENERATE_LE
9924 | OPTS_TYPE_ST_ADD80;
9925 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9926 dgst_size = DGST_SIZE_4_4;
9927 parse_func = postgresql_auth_parse_hash;
9928 sort_by_digest = sort_by_digest_4_4;
9929 opti_type = OPTI_TYPE_ZERO_BYTE
9930 | OPTI_TYPE_PRECOMPUTE_INIT
9931 | OPTI_TYPE_PRECOMPUTE_MERKLE
9932 | OPTI_TYPE_EARLY_SKIP;
9933 dgst_pos0 = 0;
9934 dgst_pos1 = 3;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 1;
9937 break;
9938
9939 case 11200: hash_type = HASH_TYPE_SHA1;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_BE
9943 | OPTS_TYPE_PT_ADD80
9944 | OPTS_TYPE_ST_HEX;
9945 kern_type = KERN_TYPE_MYSQL_AUTH;
9946 dgst_size = DGST_SIZE_4_5;
9947 parse_func = mysql_auth_parse_hash;
9948 sort_by_digest = sort_by_digest_4_5;
9949 opti_type = OPTI_TYPE_ZERO_BYTE
9950 | OPTI_TYPE_EARLY_SKIP;
9951 dgst_pos0 = 3;
9952 dgst_pos1 = 4;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE
9961 | OPTS_TYPE_ST_HEX
9962 | OPTS_TYPE_ST_ADD80;
9963 kern_type = KERN_TYPE_BITCOIN_WALLET;
9964 dgst_size = DGST_SIZE_4_4;
9965 parse_func = bitcoin_wallet_parse_hash;
9966 sort_by_digest = sort_by_digest_4_4;
9967 opti_type = OPTI_TYPE_ZERO_BYTE;
9968 dgst_pos0 = 0;
9969 dgst_pos1 = 1;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 3;
9972 break;
9973
9974 case 11400: hash_type = HASH_TYPE_MD5;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE
9978 | OPTS_TYPE_PT_ADD80
9979 | OPTS_TYPE_HASH_COPY;
9980 kern_type = KERN_TYPE_SIP_AUTH;
9981 dgst_size = DGST_SIZE_4_4;
9982 parse_func = sip_auth_parse_hash;
9983 sort_by_digest = sort_by_digest_4_4;
9984 opti_type = OPTI_TYPE_ZERO_BYTE;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 3;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 1;
9989 break;
9990
9991 case 11500: hash_type = HASH_TYPE_CRC32;
9992 salt_type = SALT_TYPE_INTERN;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_LE
9995 | OPTS_TYPE_ST_GENERATE_LE
9996 | OPTS_TYPE_ST_HEX;
9997 kern_type = KERN_TYPE_CRC32;
9998 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9999 parse_func = crc32_parse_hash;
10000 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10001 opti_type = OPTI_TYPE_ZERO_BYTE;
10002 dgst_pos0 = 0;
10003 dgst_pos1 = 1;
10004 dgst_pos2 = 2;
10005 dgst_pos3 = 3;
10006 break;
10007
10008 case 11600: hash_type = HASH_TYPE_AES;
10009 salt_type = SALT_TYPE_EMBEDDED;
10010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10011 opts_type = OPTS_TYPE_PT_GENERATE_LE
10012 | OPTS_TYPE_PT_NEVERCRACK;
10013 kern_type = KERN_TYPE_SEVEN_ZIP;
10014 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10015 parse_func = seven_zip_parse_hash;
10016 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10017 opti_type = OPTI_TYPE_ZERO_BYTE;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10025 salt_type = SALT_TYPE_NONE;
10026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE
10028 | OPTS_TYPE_PT_ADD01;
10029 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10030 dgst_size = DGST_SIZE_4_8;
10031 parse_func = gost2012sbog_256_parse_hash;
10032 sort_by_digest = sort_by_digest_4_8;
10033 opti_type = OPTI_TYPE_ZERO_BYTE;
10034 dgst_pos0 = 0;
10035 dgst_pos1 = 1;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 3;
10038 break;
10039
10040 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10041 salt_type = SALT_TYPE_NONE;
10042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE
10044 | OPTS_TYPE_PT_ADD01;
10045 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10046 dgst_size = DGST_SIZE_4_16;
10047 parse_func = gost2012sbog_512_parse_hash;
10048 sort_by_digest = sort_by_digest_4_16;
10049 opti_type = OPTI_TYPE_ZERO_BYTE;
10050 dgst_pos0 = 0;
10051 dgst_pos1 = 1;
10052 dgst_pos2 = 2;
10053 dgst_pos3 = 3;
10054 break;
10055
10056 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE
10060 | OPTS_TYPE_ST_BASE64
10061 | OPTS_TYPE_HASH_COPY;
10062 kern_type = KERN_TYPE_PBKDF2_MD5;
10063 dgst_size = DGST_SIZE_4_32;
10064 parse_func = pbkdf2_md5_parse_hash;
10065 sort_by_digest = sort_by_digest_4_32;
10066 opti_type = OPTI_TYPE_ZERO_BYTE
10067 | OPTI_TYPE_SLOW_HASH_SIMD;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_ST_BASE64
10079 | OPTS_TYPE_HASH_COPY;
10080 kern_type = KERN_TYPE_PBKDF2_SHA1;
10081 dgst_size = DGST_SIZE_4_32;
10082 parse_func = pbkdf2_sha1_parse_hash;
10083 sort_by_digest = sort_by_digest_4_32;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_SLOW_HASH_SIMD;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE
10096 | OPTS_TYPE_ST_BASE64
10097 | OPTS_TYPE_HASH_COPY;
10098 kern_type = KERN_TYPE_PBKDF2_SHA512;
10099 dgst_size = DGST_SIZE_8_16;
10100 parse_func = pbkdf2_sha512_parse_hash;
10101 sort_by_digest = sort_by_digest_8_16;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_USES_BITS_64
10104 | OPTI_TYPE_SLOW_HASH_SIMD;
10105 dgst_pos0 = 0;
10106 dgst_pos1 = 1;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 3;
10109 break;
10110
10111 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10112 salt_type = SALT_TYPE_EMBEDDED;
10113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10115 kern_type = KERN_TYPE_ECRYPTFS;
10116 dgst_size = DGST_SIZE_8_8;
10117 parse_func = ecryptfs_parse_hash;
10118 sort_by_digest = sort_by_digest_8_8;
10119 opti_type = OPTI_TYPE_ZERO_BYTE
10120 | OPTI_TYPE_USES_BITS_64;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 12300: hash_type = HASH_TYPE_ORACLET;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10131 kern_type = KERN_TYPE_ORACLET;
10132 dgst_size = DGST_SIZE_8_16;
10133 parse_func = oraclet_parse_hash;
10134 sort_by_digest = sort_by_digest_8_16;
10135 opti_type = OPTI_TYPE_ZERO_BYTE
10136 | OPTI_TYPE_USES_BITS_64;
10137 dgst_pos0 = 0;
10138 dgst_pos1 = 1;
10139 dgst_pos2 = 2;
10140 dgst_pos3 = 3;
10141 break;
10142
10143 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10144 salt_type = SALT_TYPE_EMBEDDED;
10145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10146 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10147 kern_type = KERN_TYPE_BSDICRYPT;
10148 dgst_size = DGST_SIZE_4_4;
10149 parse_func = bsdicrypt_parse_hash;
10150 sort_by_digest = sort_by_digest_4_4;
10151 opti_type = OPTI_TYPE_ZERO_BYTE
10152 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 12500: hash_type = HASH_TYPE_RAR3HP;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10163 kern_type = KERN_TYPE_RAR3;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = rar3hp_parse_hash;
10166 sort_by_digest = sort_by_digest_4_4;
10167 opti_type = OPTI_TYPE_ZERO_BYTE;
10168 dgst_pos0 = 0;
10169 dgst_pos1 = 1;
10170 dgst_pos2 = 2;
10171 dgst_pos3 = 3;
10172 break;
10173
10174 case 12600: hash_type = HASH_TYPE_SHA256;
10175 salt_type = SALT_TYPE_INTERN;
10176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10177 opts_type = OPTS_TYPE_PT_GENERATE_BE
10178 | OPTS_TYPE_PT_ADD80;
10179 kern_type = KERN_TYPE_CF10;
10180 dgst_size = DGST_SIZE_4_8;
10181 parse_func = cf10_parse_hash;
10182 sort_by_digest = sort_by_digest_4_8;
10183 opti_type = OPTI_TYPE_ZERO_BYTE
10184 | OPTI_TYPE_PRECOMPUTE_INIT
10185 | OPTI_TYPE_EARLY_SKIP
10186 | OPTI_TYPE_NOT_ITERATED;
10187 dgst_pos0 = 3;
10188 dgst_pos1 = 7;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 6;
10191 break;
10192
10193 case 12700: hash_type = HASH_TYPE_AES;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE
10197 | OPTS_TYPE_HASH_COPY;
10198 kern_type = KERN_TYPE_MYWALLET;
10199 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10200 parse_func = mywallet_parse_hash;
10201 sort_by_digest = sort_by_digest_4_5;
10202 opti_type = OPTI_TYPE_ZERO_BYTE;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10210 salt_type = SALT_TYPE_EMBEDDED;
10211 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10213 kern_type = KERN_TYPE_MS_DRSR;
10214 dgst_size = DGST_SIZE_4_8;
10215 parse_func = ms_drsr_parse_hash;
10216 sort_by_digest = sort_by_digest_4_8;
10217 opti_type = OPTI_TYPE_ZERO_BYTE;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10228 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10229 dgst_size = DGST_SIZE_4_8;
10230 parse_func = androidfde_samsung_parse_hash;
10231 sort_by_digest = sort_by_digest_4_8;
10232 opti_type = OPTI_TYPE_ZERO_BYTE;
10233 dgst_pos0 = 0;
10234 dgst_pos1 = 1;
10235 dgst_pos2 = 2;
10236 dgst_pos3 = 3;
10237 break;
10238
10239 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10240 salt_type = SALT_TYPE_EMBEDDED;
10241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10242 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10243 kern_type = KERN_TYPE_RAR5;
10244 dgst_size = DGST_SIZE_4_4;
10245 parse_func = rar5_parse_hash;
10246 sort_by_digest = sort_by_digest_4_4;
10247 opti_type = OPTI_TYPE_ZERO_BYTE;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10255 salt_type = SALT_TYPE_EMBEDDED;
10256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10258 kern_type = KERN_TYPE_KRB5TGS;
10259 dgst_size = DGST_SIZE_4_4;
10260 parse_func = krb5tgs_parse_hash;
10261 sort_by_digest = sort_by_digest_4_4;
10262 opti_type = OPTI_TYPE_ZERO_BYTE
10263 | OPTI_TYPE_NOT_ITERATED;
10264 dgst_pos0 = 0;
10265 dgst_pos1 = 1;
10266 dgst_pos2 = 2;
10267 dgst_pos3 = 3;
10268 break;
10269
10270 case 13200: hash_type = HASH_TYPE_AES;
10271 salt_type = SALT_TYPE_EMBEDDED;
10272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10274 kern_type = KERN_TYPE_AXCRYPT;
10275 dgst_size = DGST_SIZE_4_4;
10276 parse_func = axcrypt_parse_hash;
10277 sort_by_digest = sort_by_digest_4_4;
10278 opti_type = OPTI_TYPE_ZERO_BYTE;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 13300: hash_type = HASH_TYPE_SHA1;
10286 salt_type = SALT_TYPE_NONE;
10287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_BE
10289 | OPTS_TYPE_PT_ADD80
10290 | OPTS_TYPE_PT_ADDBITS15;
10291 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10292 dgst_size = DGST_SIZE_4_5;
10293 parse_func = sha1axcrypt_parse_hash;
10294 sort_by_digest = sort_by_digest_4_5;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_PRECOMPUTE_INIT
10297 | OPTI_TYPE_EARLY_SKIP
10298 | OPTI_TYPE_NOT_ITERATED
10299 | OPTI_TYPE_NOT_SALTED;
10300 dgst_pos0 = 0;
10301 dgst_pos1 = 4;
10302 dgst_pos2 = 3;
10303 dgst_pos3 = 2;
10304 break;
10305
10306 case 13400: hash_type = HASH_TYPE_AES;
10307 salt_type = SALT_TYPE_EMBEDDED;
10308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10309 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10310 kern_type = KERN_TYPE_KEEPASS;
10311 dgst_size = DGST_SIZE_4_4;
10312 parse_func = keepass_parse_hash;
10313 sort_by_digest = sort_by_digest_4_4;
10314 opti_type = OPTI_TYPE_ZERO_BYTE;
10315 dgst_pos0 = 0;
10316 dgst_pos1 = 1;
10317 dgst_pos2 = 2;
10318 dgst_pos3 = 3;
10319 break;
10320
10321 case 13500: hash_type = HASH_TYPE_SHA1;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_BE
10325 | OPTS_TYPE_PT_UNICODE
10326 | OPTS_TYPE_PT_ADD80;
10327 kern_type = KERN_TYPE_PSTOKEN;
10328 dgst_size = DGST_SIZE_4_5;
10329 parse_func = pstoken_parse_hash;
10330 sort_by_digest = sort_by_digest_4_5;
10331 opti_type = OPTI_TYPE_ZERO_BYTE
10332 | OPTI_TYPE_PRECOMPUTE_INIT
10333 | OPTI_TYPE_EARLY_SKIP
10334 | OPTI_TYPE_NOT_ITERATED
10335 | OPTI_TYPE_PREPENDED_SALT
10336 | OPTI_TYPE_RAW_HASH;
10337 dgst_pos0 = 3;
10338 dgst_pos1 = 4;
10339 dgst_pos2 = 2;
10340 dgst_pos3 = 1;
10341 break;
10342
10343 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10344 salt_type = SALT_TYPE_EMBEDDED;
10345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10347 kern_type = KERN_TYPE_ZIP2;
10348 dgst_size = DGST_SIZE_4_4;
10349 parse_func = zip2_parse_hash;
10350 sort_by_digest = sort_by_digest_4_4;
10351 opti_type = OPTI_TYPE_ZERO_BYTE;
10352 dgst_pos0 = 0;
10353 dgst_pos1 = 1;
10354 dgst_pos2 = 2;
10355 dgst_pos3 = 3;
10356 break;
10357
10358 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10359 salt_type = SALT_TYPE_EMBEDDED;
10360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10362 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10363 dgst_size = DGST_SIZE_4_5;
10364 parse_func = veracrypt_parse_hash_655331;
10365 sort_by_digest = sort_by_digest_4_5;
10366 opti_type = OPTI_TYPE_ZERO_BYTE;
10367 dgst_pos0 = 0;
10368 dgst_pos1 = 1;
10369 dgst_pos2 = 2;
10370 dgst_pos3 = 3;
10371 break;
10372
10373 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10374 salt_type = SALT_TYPE_EMBEDDED;
10375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10377 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10378 dgst_size = DGST_SIZE_4_5;
10379 parse_func = veracrypt_parse_hash_655331;
10380 sort_by_digest = sort_by_digest_4_5;
10381 opti_type = OPTI_TYPE_ZERO_BYTE;
10382 dgst_pos0 = 0;
10383 dgst_pos1 = 1;
10384 dgst_pos2 = 2;
10385 dgst_pos3 = 3;
10386 break;
10387
10388 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10389 salt_type = SALT_TYPE_EMBEDDED;
10390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10392 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10393 dgst_size = DGST_SIZE_4_5;
10394 parse_func = veracrypt_parse_hash_655331;
10395 sort_by_digest = sort_by_digest_4_5;
10396 opti_type = OPTI_TYPE_ZERO_BYTE;
10397 dgst_pos0 = 0;
10398 dgst_pos1 = 1;
10399 dgst_pos2 = 2;
10400 dgst_pos3 = 3;
10401 break;
10402
10403 case 13721: hash_type = HASH_TYPE_SHA512;
10404 salt_type = SALT_TYPE_EMBEDDED;
10405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10406 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10407 kern_type = KERN_TYPE_TCSHA512_XTS512;
10408 dgst_size = DGST_SIZE_8_8;
10409 parse_func = veracrypt_parse_hash_500000;
10410 sort_by_digest = sort_by_digest_8_8;
10411 opti_type = OPTI_TYPE_ZERO_BYTE
10412 | OPTI_TYPE_USES_BITS_64;
10413 dgst_pos0 = 0;
10414 dgst_pos1 = 1;
10415 dgst_pos2 = 2;
10416 dgst_pos3 = 3;
10417 break;
10418
10419 case 13722: hash_type = HASH_TYPE_SHA512;
10420 salt_type = SALT_TYPE_EMBEDDED;
10421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10422 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10423 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10424 dgst_size = DGST_SIZE_8_8;
10425 parse_func = veracrypt_parse_hash_500000;
10426 sort_by_digest = sort_by_digest_8_8;
10427 opti_type = OPTI_TYPE_ZERO_BYTE
10428 | OPTI_TYPE_USES_BITS_64;
10429 dgst_pos0 = 0;
10430 dgst_pos1 = 1;
10431 dgst_pos2 = 2;
10432 dgst_pos3 = 3;
10433 break;
10434
10435 case 13723: hash_type = HASH_TYPE_SHA512;
10436 salt_type = SALT_TYPE_EMBEDDED;
10437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10438 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10439 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10440 dgst_size = DGST_SIZE_8_8;
10441 parse_func = veracrypt_parse_hash_500000;
10442 sort_by_digest = sort_by_digest_8_8;
10443 opti_type = OPTI_TYPE_ZERO_BYTE
10444 | OPTI_TYPE_USES_BITS_64;
10445 dgst_pos0 = 0;
10446 dgst_pos1 = 1;
10447 dgst_pos2 = 2;
10448 dgst_pos3 = 3;
10449 break;
10450
10451 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10452 salt_type = SALT_TYPE_EMBEDDED;
10453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10454 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10455 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10456 dgst_size = DGST_SIZE_4_8;
10457 parse_func = veracrypt_parse_hash_500000;
10458 sort_by_digest = sort_by_digest_4_8;
10459 opti_type = OPTI_TYPE_ZERO_BYTE;
10460 dgst_pos0 = 0;
10461 dgst_pos1 = 1;
10462 dgst_pos2 = 2;
10463 dgst_pos3 = 3;
10464 break;
10465
10466 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10467 salt_type = SALT_TYPE_EMBEDDED;
10468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10470 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10471 dgst_size = DGST_SIZE_4_8;
10472 parse_func = veracrypt_parse_hash_500000;
10473 sort_by_digest = sort_by_digest_4_8;
10474 opti_type = OPTI_TYPE_ZERO_BYTE;
10475 dgst_pos0 = 0;
10476 dgst_pos1 = 1;
10477 dgst_pos2 = 2;
10478 dgst_pos3 = 3;
10479 break;
10480
10481 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10482 salt_type = SALT_TYPE_EMBEDDED;
10483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10484 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10485 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10486 dgst_size = DGST_SIZE_4_8;
10487 parse_func = veracrypt_parse_hash_500000;
10488 sort_by_digest = sort_by_digest_4_8;
10489 opti_type = OPTI_TYPE_ZERO_BYTE;
10490 dgst_pos0 = 0;
10491 dgst_pos1 = 1;
10492 dgst_pos2 = 2;
10493 dgst_pos3 = 3;
10494 break;
10495
10496 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10497 salt_type = SALT_TYPE_EMBEDDED;
10498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10500 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10501 dgst_size = DGST_SIZE_4_5;
10502 parse_func = veracrypt_parse_hash_327661;
10503 sort_by_digest = sort_by_digest_4_5;
10504 opti_type = OPTI_TYPE_ZERO_BYTE;
10505 dgst_pos0 = 0;
10506 dgst_pos1 = 1;
10507 dgst_pos2 = 2;
10508 dgst_pos3 = 3;
10509 break;
10510
10511 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10512 salt_type = SALT_TYPE_EMBEDDED;
10513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10515 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10516 dgst_size = DGST_SIZE_4_5;
10517 parse_func = veracrypt_parse_hash_327661;
10518 sort_by_digest = sort_by_digest_4_5;
10519 opti_type = OPTI_TYPE_ZERO_BYTE;
10520 dgst_pos0 = 0;
10521 dgst_pos1 = 1;
10522 dgst_pos2 = 2;
10523 dgst_pos3 = 3;
10524 break;
10525
10526 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10527 salt_type = SALT_TYPE_EMBEDDED;
10528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10530 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10531 dgst_size = DGST_SIZE_4_5;
10532 parse_func = veracrypt_parse_hash_327661;
10533 sort_by_digest = sort_by_digest_4_5;
10534 opti_type = OPTI_TYPE_ZERO_BYTE;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 13751: hash_type = HASH_TYPE_SHA256;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10545 kern_type = KERN_TYPE_VCSHA256_XTS512;
10546 dgst_size = DGST_SIZE_4_8;
10547 parse_func = veracrypt_parse_hash_500000;
10548 sort_by_digest = sort_by_digest_4_8;
10549 opti_type = OPTI_TYPE_ZERO_BYTE;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 13752: hash_type = HASH_TYPE_SHA256;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10560 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10561 dgst_size = DGST_SIZE_4_8;
10562 parse_func = veracrypt_parse_hash_500000;
10563 sort_by_digest = sort_by_digest_4_8;
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 13753: hash_type = HASH_TYPE_SHA256;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10575 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10576 dgst_size = DGST_SIZE_4_8;
10577 parse_func = veracrypt_parse_hash_500000;
10578 sort_by_digest = sort_by_digest_4_8;
10579 opti_type = OPTI_TYPE_ZERO_BYTE;
10580 dgst_pos0 = 0;
10581 dgst_pos1 = 1;
10582 dgst_pos2 = 2;
10583 dgst_pos3 = 3;
10584 break;
10585
10586 case 13761: hash_type = HASH_TYPE_SHA256;
10587 salt_type = SALT_TYPE_EMBEDDED;
10588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10589 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10590 kern_type = KERN_TYPE_VCSHA256_XTS512;
10591 dgst_size = DGST_SIZE_4_8;
10592 parse_func = veracrypt_parse_hash_200000;
10593 sort_by_digest = sort_by_digest_4_8;
10594 opti_type = OPTI_TYPE_ZERO_BYTE;
10595 dgst_pos0 = 0;
10596 dgst_pos1 = 1;
10597 dgst_pos2 = 2;
10598 dgst_pos3 = 3;
10599 break;
10600
10601 case 13762: hash_type = HASH_TYPE_SHA256;
10602 salt_type = SALT_TYPE_EMBEDDED;
10603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10604 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10605 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10606 dgst_size = DGST_SIZE_4_8;
10607 parse_func = veracrypt_parse_hash_200000;
10608 sort_by_digest = sort_by_digest_4_8;
10609 opti_type = OPTI_TYPE_ZERO_BYTE;
10610 dgst_pos0 = 0;
10611 dgst_pos1 = 1;
10612 dgst_pos2 = 2;
10613 dgst_pos3 = 3;
10614 break;
10615
10616 case 13763: hash_type = HASH_TYPE_SHA256;
10617 salt_type = SALT_TYPE_EMBEDDED;
10618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10620 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10621 dgst_size = DGST_SIZE_4_8;
10622 parse_func = veracrypt_parse_hash_200000;
10623 sort_by_digest = sort_by_digest_4_8;
10624 opti_type = OPTI_TYPE_ZERO_BYTE;
10625 dgst_pos0 = 0;
10626 dgst_pos1 = 1;
10627 dgst_pos2 = 2;
10628 dgst_pos3 = 3;
10629 break;
10630
10631
10632 default: usage_mini_print (PROGNAME); return (-1);
10633 }
10634
10635 /**
10636 * parser
10637 */
10638
10639 data.parse_func = parse_func;
10640
10641 /**
10642 * misc stuff
10643 */
10644
10645 if (hex_salt)
10646 {
10647 if (salt_type == SALT_TYPE_INTERN)
10648 {
10649 opts_type |= OPTS_TYPE_ST_HEX;
10650 }
10651 else
10652 {
10653 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10654
10655 return (-1);
10656 }
10657 }
10658
10659 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10660 | (salt_type == SALT_TYPE_EXTERN)
10661 | (salt_type == SALT_TYPE_EMBEDDED)
10662 | (salt_type == SALT_TYPE_VIRTUAL));
10663
10664 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10665
10666 data.hash_type = hash_type;
10667 data.attack_mode = attack_mode;
10668 data.attack_kern = attack_kern;
10669 data.attack_exec = attack_exec;
10670 data.kern_type = kern_type;
10671 data.opts_type = opts_type;
10672 data.dgst_size = dgst_size;
10673 data.salt_type = salt_type;
10674 data.isSalted = isSalted;
10675 data.sort_by_digest = sort_by_digest;
10676 data.dgst_pos0 = dgst_pos0;
10677 data.dgst_pos1 = dgst_pos1;
10678 data.dgst_pos2 = dgst_pos2;
10679 data.dgst_pos3 = dgst_pos3;
10680
10681 esalt_size = 0;
10682
10683 switch (hash_mode)
10684 {
10685 case 2500: esalt_size = sizeof (wpa_t); break;
10686 case 5300: esalt_size = sizeof (ikepsk_t); break;
10687 case 5400: esalt_size = sizeof (ikepsk_t); break;
10688 case 5500: esalt_size = sizeof (netntlm_t); break;
10689 case 5600: esalt_size = sizeof (netntlm_t); break;
10690 case 6211: esalt_size = sizeof (tc_t); break;
10691 case 6212: esalt_size = sizeof (tc_t); break;
10692 case 6213: esalt_size = sizeof (tc_t); break;
10693 case 6221: esalt_size = sizeof (tc_t); break;
10694 case 6222: esalt_size = sizeof (tc_t); break;
10695 case 6223: esalt_size = sizeof (tc_t); break;
10696 case 6231: esalt_size = sizeof (tc_t); break;
10697 case 6232: esalt_size = sizeof (tc_t); break;
10698 case 6233: esalt_size = sizeof (tc_t); break;
10699 case 6241: esalt_size = sizeof (tc_t); break;
10700 case 6242: esalt_size = sizeof (tc_t); break;
10701 case 6243: esalt_size = sizeof (tc_t); break;
10702 case 6600: esalt_size = sizeof (agilekey_t); break;
10703 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10704 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10705 case 7300: esalt_size = sizeof (rakp_t); break;
10706 case 7500: esalt_size = sizeof (krb5pa_t); break;
10707 case 8200: esalt_size = sizeof (cloudkey_t); break;
10708 case 8800: esalt_size = sizeof (androidfde_t); break;
10709 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10710 case 9400: esalt_size = sizeof (office2007_t); break;
10711 case 9500: esalt_size = sizeof (office2010_t); break;
10712 case 9600: esalt_size = sizeof (office2013_t); break;
10713 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10714 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10715 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10716 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10717 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10718 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10719 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10720 case 10200: esalt_size = sizeof (cram_md5_t); break;
10721 case 10400: esalt_size = sizeof (pdf_t); break;
10722 case 10410: esalt_size = sizeof (pdf_t); break;
10723 case 10420: esalt_size = sizeof (pdf_t); break;
10724 case 10500: esalt_size = sizeof (pdf_t); break;
10725 case 10600: esalt_size = sizeof (pdf_t); break;
10726 case 10700: esalt_size = sizeof (pdf_t); break;
10727 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10728 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10729 case 11400: esalt_size = sizeof (sip_t); break;
10730 case 11600: esalt_size = sizeof (seven_zip_t); break;
10731 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10732 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10733 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10734 case 13000: esalt_size = sizeof (rar5_t); break;
10735 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10736 case 13400: esalt_size = sizeof (keepass_t); break;
10737 case 13500: esalt_size = sizeof (pstoken_t); break;
10738 case 13600: esalt_size = sizeof (zip2_t); break;
10739 case 13711: esalt_size = sizeof (tc_t); break;
10740 case 13712: esalt_size = sizeof (tc_t); break;
10741 case 13713: esalt_size = sizeof (tc_t); break;
10742 case 13721: esalt_size = sizeof (tc_t); break;
10743 case 13722: esalt_size = sizeof (tc_t); break;
10744 case 13723: esalt_size = sizeof (tc_t); break;
10745 case 13731: esalt_size = sizeof (tc_t); break;
10746 case 13732: esalt_size = sizeof (tc_t); break;
10747 case 13733: esalt_size = sizeof (tc_t); break;
10748 case 13741: esalt_size = sizeof (tc_t); break;
10749 case 13742: esalt_size = sizeof (tc_t); break;
10750 case 13743: esalt_size = sizeof (tc_t); break;
10751 case 13751: esalt_size = sizeof (tc_t); break;
10752 case 13752: esalt_size = sizeof (tc_t); break;
10753 case 13753: esalt_size = sizeof (tc_t); break;
10754 case 13761: esalt_size = sizeof (tc_t); break;
10755 case 13762: esalt_size = sizeof (tc_t); break;
10756 case 13763: esalt_size = sizeof (tc_t); break;
10757 }
10758
10759 data.esalt_size = esalt_size;
10760
10761 /**
10762 * choose dictionary parser
10763 */
10764
10765 if (hash_type == HASH_TYPE_LM)
10766 {
10767 get_next_word_func = get_next_word_lm;
10768 }
10769 else if (opts_type & OPTS_TYPE_PT_UPPER)
10770 {
10771 get_next_word_func = get_next_word_uc;
10772 }
10773 else
10774 {
10775 get_next_word_func = get_next_word_std;
10776 }
10777
10778 /**
10779 * dictstat
10780 */
10781
10782 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10783
10784 #ifdef _POSIX
10785 size_t dictstat_nmemb = 0;
10786 #endif
10787
10788 #ifdef _WIN
10789 uint dictstat_nmemb = 0;
10790 #endif
10791
10792 char dictstat[256] = { 0 };
10793
10794 FILE *dictstat_fp = NULL;
10795
10796 if (keyspace == 0)
10797 {
10798 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10799
10800 dictstat_fp = fopen (dictstat, "rb");
10801
10802 if (dictstat_fp)
10803 {
10804 #ifdef _POSIX
10805 struct stat tmpstat;
10806
10807 fstat (fileno (dictstat_fp), &tmpstat);
10808 #endif
10809
10810 #ifdef _WIN
10811 struct stat64 tmpstat;
10812
10813 _fstat64 (fileno (dictstat_fp), &tmpstat);
10814 #endif
10815
10816 if (tmpstat.st_mtime < COMPTIME)
10817 {
10818 /* with v0.15 the format changed so we have to ensure user is using a good version
10819 since there is no version-header in the dictstat file */
10820
10821 fclose (dictstat_fp);
10822
10823 unlink (dictstat);
10824 }
10825 else
10826 {
10827 while (!feof (dictstat_fp))
10828 {
10829 dictstat_t d;
10830
10831 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10832
10833 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10834
10835 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10836 {
10837 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10838
10839 return -1;
10840 }
10841 }
10842
10843 fclose (dictstat_fp);
10844 }
10845 }
10846 }
10847
10848 /**
10849 * potfile
10850 */
10851
10852 char potfile[256] = { 0 };
10853
10854 if (potfile_path == NULL)
10855 {
10856 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10857 }
10858 else
10859 {
10860 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10861 }
10862
10863 data.pot_fp = NULL;
10864
10865 FILE *out_fp = NULL;
10866 FILE *pot_fp = NULL;
10867
10868 if (show == 1 || left == 1)
10869 {
10870 pot_fp = fopen (potfile, "rb");
10871
10872 if (pot_fp == NULL)
10873 {
10874 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10875
10876 return (-1);
10877 }
10878
10879 if (outfile != NULL)
10880 {
10881 if ((out_fp = fopen (outfile, "ab")) == NULL)
10882 {
10883 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10884
10885 fclose (pot_fp);
10886
10887 return (-1);
10888 }
10889 }
10890 else
10891 {
10892 out_fp = stdout;
10893 }
10894 }
10895 else
10896 {
10897 if (potfile_disable == 0)
10898 {
10899 pot_fp = fopen (potfile, "ab");
10900
10901 if (pot_fp == NULL)
10902 {
10903 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10904
10905 return (-1);
10906 }
10907
10908 data.pot_fp = pot_fp;
10909 }
10910 }
10911
10912 pot_t *pot = NULL;
10913
10914 uint pot_cnt = 0;
10915 uint pot_avail = 0;
10916
10917 if (show == 1 || left == 1)
10918 {
10919 SUPPRESS_OUTPUT = 1;
10920
10921 pot_avail = count_lines (pot_fp);
10922
10923 rewind (pot_fp);
10924
10925 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10926
10927 uint pot_hashes_avail = 0;
10928
10929 uint line_num = 0;
10930
10931 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10932
10933 while (!feof (pot_fp))
10934 {
10935 line_num++;
10936
10937 int line_len = fgetl (pot_fp, line_buf);
10938
10939 if (line_len == 0) continue;
10940
10941 char *plain_buf = line_buf + line_len;
10942
10943 pot_t *pot_ptr = &pot[pot_cnt];
10944
10945 hash_t *hashes_buf = &pot_ptr->hash;
10946
10947 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10948 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10949
10950 if (pot_cnt == pot_hashes_avail)
10951 {
10952 uint pos = 0;
10953
10954 for (pos = 0; pos < INCR_POT; pos++)
10955 {
10956 if ((pot_cnt + pos) >= pot_avail) break;
10957
10958 pot_t *tmp_pot = &pot[pot_cnt + pos];
10959
10960 hash_t *tmp_hash = &tmp_pot->hash;
10961
10962 tmp_hash->digest = mymalloc (dgst_size);
10963
10964 if (isSalted)
10965 {
10966 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10967 }
10968
10969 if (esalt_size)
10970 {
10971 tmp_hash->esalt = mymalloc (esalt_size);
10972 }
10973
10974 pot_hashes_avail++;
10975 }
10976 }
10977
10978 int plain_len = 0;
10979
10980 int parser_status;
10981
10982 int iter = MAX_CUT_TRIES;
10983
10984 do
10985 {
10986 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10987 {
10988 if (line_buf[i] == ':')
10989 {
10990 line_len--;
10991
10992 break;
10993 }
10994 }
10995
10996 if (data.hash_mode != 2500)
10997 {
10998 parser_status = parse_func (line_buf, line_len, hashes_buf);
10999 }
11000 else
11001 {
11002 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11003
11004 if (line_len > max_salt_size)
11005 {
11006 parser_status = PARSER_GLOBAL_LENGTH;
11007 }
11008 else
11009 {
11010 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11011
11012 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11013
11014 hashes_buf->salt->salt_len = line_len;
11015
11016 parser_status = PARSER_OK;
11017 }
11018 }
11019
11020 // if NOT parsed without error, we add the ":" to the plain
11021
11022 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11023 {
11024 plain_len++;
11025 plain_buf--;
11026 }
11027
11028 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11029
11030 if (parser_status < PARSER_GLOBAL_ZERO)
11031 {
11032 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11033
11034 continue;
11035 }
11036
11037 if (plain_len >= 255) continue;
11038
11039 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11040
11041 pot_ptr->plain_len = plain_len;
11042
11043 pot_cnt++;
11044 }
11045
11046 myfree (line_buf);
11047
11048 fclose (pot_fp);
11049
11050 SUPPRESS_OUTPUT = 0;
11051
11052 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11053 }
11054
11055 /**
11056 * word len
11057 */
11058
11059 uint pw_min = PW_MIN;
11060 uint pw_max = PW_MAX;
11061
11062 switch (hash_mode)
11063 {
11064 case 125: if (pw_max > 32) pw_max = 32;
11065 break;
11066 case 400: if (pw_max > 40) pw_max = 40;
11067 break;
11068 case 500: if (pw_max > 16) pw_max = 16;
11069 break;
11070 case 1500: if (pw_max > 8) pw_max = 8;
11071 break;
11072 case 1600: if (pw_max > 16) pw_max = 16;
11073 break;
11074 case 1800: if (pw_max > 16) pw_max = 16;
11075 break;
11076 case 2100: if (pw_max > 16) pw_max = 16;
11077 break;
11078 case 2500: if (pw_min < 8) pw_min = 8;
11079 break;
11080 case 3000: if (pw_max > 7) pw_max = 7;
11081 break;
11082 case 5200: if (pw_max > 24) pw_max = 24;
11083 break;
11084 case 5800: if (pw_max > 16) pw_max = 16;
11085 break;
11086 case 6300: if (pw_max > 16) pw_max = 16;
11087 break;
11088 case 7400: if (pw_max > 16) pw_max = 16;
11089 break;
11090 case 7900: if (pw_max > 48) pw_max = 48;
11091 break;
11092 case 8500: if (pw_max > 8) pw_max = 8;
11093 break;
11094 case 8600: if (pw_max > 16) pw_max = 16;
11095 break;
11096 case 9710: pw_min = 5;
11097 pw_max = 5;
11098 break;
11099 case 9810: pw_min = 5;
11100 pw_max = 5;
11101 break;
11102 case 10410: pw_min = 5;
11103 pw_max = 5;
11104 break;
11105 case 10300: if (pw_max < 3) pw_min = 3;
11106 if (pw_max > 40) pw_max = 40;
11107 break;
11108 case 10500: if (pw_max < 3) pw_min = 3;
11109 if (pw_max > 40) pw_max = 40;
11110 break;
11111 case 10700: if (pw_max > 16) pw_max = 16;
11112 break;
11113 case 11300: if (pw_max > 40) pw_max = 40;
11114 break;
11115 case 11600: if (pw_max > 32) pw_max = 32;
11116 break;
11117 case 12500: if (pw_max > 20) pw_max = 20;
11118 break;
11119 case 12800: if (pw_max > 24) pw_max = 24;
11120 break;
11121 }
11122
11123 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11124 {
11125 switch (attack_kern)
11126 {
11127 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11128 break;
11129 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11130 break;
11131 }
11132 }
11133
11134 /**
11135 * charsets : keep them together for more easy maintainnce
11136 */
11137
11138 cs_t mp_sys[6] = { { { 0 }, 0 } };
11139 cs_t mp_usr[4] = { { { 0 }, 0 } };
11140
11141 mp_setup_sys (mp_sys);
11142
11143 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11144 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11145 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11146 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11147
11148 /**
11149 * load hashes, part I: find input mode, count hashes
11150 */
11151
11152 uint hashlist_mode = 0;
11153 uint hashlist_format = HLFMT_HASHCAT;
11154
11155 uint hashes_avail = 0;
11156
11157 if (benchmark == 0)
11158 {
11159 struct stat f;
11160
11161 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11162
11163 if ((hash_mode == 2500) ||
11164 (hash_mode == 5200) ||
11165 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11166 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11167 (hash_mode == 9000))
11168 {
11169 hashlist_mode = HL_MODE_ARG;
11170
11171 char *hashfile = myargv[optind];
11172
11173 data.hashfile = hashfile;
11174
11175 logfile_top_var_string ("target", hashfile);
11176 }
11177
11178 if (hashlist_mode == HL_MODE_ARG)
11179 {
11180 if (hash_mode == 2500)
11181 {
11182 struct stat st;
11183
11184 if (stat (data.hashfile, &st) == -1)
11185 {
11186 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11187
11188 return (-1);
11189 }
11190
11191 hashes_avail = st.st_size / sizeof (hccap_t);
11192 }
11193 else
11194 {
11195 hashes_avail = 1;
11196 }
11197 }
11198 else if (hashlist_mode == HL_MODE_FILE)
11199 {
11200 char *hashfile = myargv[optind];
11201
11202 data.hashfile = hashfile;
11203
11204 logfile_top_var_string ("target", hashfile);
11205
11206 FILE *fp = NULL;
11207
11208 if ((fp = fopen (hashfile, "rb")) == NULL)
11209 {
11210 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11211
11212 return (-1);
11213 }
11214
11215 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11216
11217 hashes_avail = count_lines (fp);
11218
11219 rewind (fp);
11220
11221 if (hashes_avail == 0)
11222 {
11223 log_error ("ERROR: hashfile is empty or corrupt");
11224
11225 fclose (fp);
11226
11227 return (-1);
11228 }
11229
11230 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11231
11232 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11233 {
11234 log_error ("ERROR: remove not supported in native hashfile-format mode");
11235
11236 fclose (fp);
11237
11238 return (-1);
11239 }
11240
11241 fclose (fp);
11242 }
11243 }
11244 else
11245 {
11246 hashlist_mode = HL_MODE_ARG;
11247
11248 hashes_avail = 1;
11249 }
11250
11251 if (hash_mode == 3000) hashes_avail *= 2;
11252
11253 data.hashlist_mode = hashlist_mode;
11254 data.hashlist_format = hashlist_format;
11255
11256 logfile_top_uint (hashlist_mode);
11257 logfile_top_uint (hashlist_format);
11258
11259 /**
11260 * load hashes, part II: allocate required memory, set pointers
11261 */
11262
11263 hash_t *hashes_buf = NULL;
11264 void *digests_buf = NULL;
11265 salt_t *salts_buf = NULL;
11266 void *esalts_buf = NULL;
11267
11268 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11269
11270 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11271
11272 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11273 {
11274 u32 hash_pos;
11275
11276 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11277 {
11278 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11279
11280 hashes_buf[hash_pos].hash_info = hash_info;
11281
11282 if (username && (remove || show || left))
11283 {
11284 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11285 }
11286
11287 if (benchmark)
11288 {
11289 hash_info->orighash = (char *) mymalloc (256);
11290 }
11291 }
11292 }
11293
11294 if (isSalted)
11295 {
11296 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11297
11298 if (esalt_size)
11299 {
11300 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11301 }
11302 }
11303 else
11304 {
11305 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11306 }
11307
11308 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11309 {
11310 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11311
11312 if (isSalted)
11313 {
11314 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11315
11316 if (esalt_size)
11317 {
11318 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11319 }
11320 }
11321 else
11322 {
11323 hashes_buf[hash_pos].salt = &salts_buf[0];
11324 }
11325 }
11326
11327 /**
11328 * load hashes, part III: parse hashes or generate them if benchmark
11329 */
11330
11331 uint hashes_cnt = 0;
11332
11333 if (benchmark == 0)
11334 {
11335 if (keyspace == 1)
11336 {
11337 // useless to read hash file for keyspace, cheat a little bit w/ optind
11338 }
11339 else if (hashes_avail == 0)
11340 {
11341 }
11342 else if (hashlist_mode == HL_MODE_ARG)
11343 {
11344 char *input_buf = myargv[optind];
11345
11346 uint input_len = strlen (input_buf);
11347
11348 logfile_top_var_string ("target", input_buf);
11349
11350 char *hash_buf = NULL;
11351 int hash_len = 0;
11352
11353 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11354
11355 bool hash_fmt_error = 0;
11356
11357 if (hash_len < 1) hash_fmt_error = 1;
11358 if (hash_buf == NULL) hash_fmt_error = 1;
11359
11360 if (hash_fmt_error)
11361 {
11362 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11363 }
11364 else
11365 {
11366 if (opts_type & OPTS_TYPE_HASH_COPY)
11367 {
11368 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11369
11370 hash_info_tmp->orighash = mystrdup (hash_buf);
11371 }
11372
11373 if (isSalted)
11374 {
11375 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11376 }
11377
11378 int parser_status = PARSER_OK;
11379
11380 if (hash_mode == 2500)
11381 {
11382 if (hash_len == 0)
11383 {
11384 log_error ("ERROR: hccap file not specified");
11385
11386 return (-1);
11387 }
11388
11389 hashlist_mode = HL_MODE_FILE;
11390
11391 data.hashlist_mode = hashlist_mode;
11392
11393 FILE *fp = fopen (hash_buf, "rb");
11394
11395 if (fp == NULL)
11396 {
11397 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11398
11399 return (-1);
11400 }
11401
11402 if (hashes_avail < 1)
11403 {
11404 log_error ("ERROR: hccap file is empty or corrupt");
11405
11406 fclose (fp);
11407
11408 return (-1);
11409 }
11410
11411 uint hccap_size = sizeof (hccap_t);
11412
11413 char *in = (char *) mymalloc (hccap_size);
11414
11415 while (!feof (fp))
11416 {
11417 int n = fread (in, hccap_size, 1, fp);
11418
11419 if (n != 1)
11420 {
11421 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11422
11423 break;
11424 }
11425
11426 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11427
11428 if (parser_status != PARSER_OK)
11429 {
11430 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11431
11432 continue;
11433 }
11434
11435 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11436
11437 if ((show == 1) || (left == 1))
11438 {
11439 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11440
11441 char *salt_ptr = (char *) tmp_salt->salt_buf;
11442
11443 int cur_pos = tmp_salt->salt_len;
11444 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11445
11446 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11447
11448 // do the appending task
11449
11450 snprintf (salt_ptr + cur_pos,
11451 rem_len,
11452 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11453 wpa->orig_mac1[0],
11454 wpa->orig_mac1[1],
11455 wpa->orig_mac1[2],
11456 wpa->orig_mac1[3],
11457 wpa->orig_mac1[4],
11458 wpa->orig_mac1[5],
11459 wpa->orig_mac2[0],
11460 wpa->orig_mac2[1],
11461 wpa->orig_mac2[2],
11462 wpa->orig_mac2[3],
11463 wpa->orig_mac2[4],
11464 wpa->orig_mac2[5]);
11465
11466 // memset () the remaining part of the salt
11467
11468 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11469 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11470
11471 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11472
11473 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11474 }
11475
11476 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);
11477 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);
11478
11479 hashes_cnt++;
11480 }
11481
11482 fclose (fp);
11483
11484 myfree (in);
11485 }
11486 else if (hash_mode == 3000)
11487 {
11488 if (hash_len == 32)
11489 {
11490 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11491
11492 hash_t *lm_hash_left = NULL;
11493
11494 if (parser_status == PARSER_OK)
11495 {
11496 lm_hash_left = &hashes_buf[hashes_cnt];
11497
11498 hashes_cnt++;
11499 }
11500 else
11501 {
11502 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11503 }
11504
11505 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11506
11507 hash_t *lm_hash_right = NULL;
11508
11509 if (parser_status == PARSER_OK)
11510 {
11511 lm_hash_right = &hashes_buf[hashes_cnt];
11512
11513 hashes_cnt++;
11514 }
11515 else
11516 {
11517 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11518 }
11519
11520 // show / left
11521
11522 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11523 {
11524 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);
11525 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);
11526 }
11527 }
11528 else
11529 {
11530 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11531
11532 if (parser_status == PARSER_OK)
11533 {
11534 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11535 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11536 }
11537
11538 if (parser_status == PARSER_OK)
11539 {
11540 hashes_cnt++;
11541 }
11542 else
11543 {
11544 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11545 }
11546 }
11547 }
11548 else
11549 {
11550 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11551
11552 if (parser_status == PARSER_OK)
11553 {
11554 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11555 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11556 }
11557
11558 if (parser_status == PARSER_OK)
11559 {
11560 hashes_cnt++;
11561 }
11562 else
11563 {
11564 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11565 }
11566 }
11567 }
11568 }
11569 else if (hashlist_mode == HL_MODE_FILE)
11570 {
11571 char *hashfile = data.hashfile;
11572
11573 FILE *fp;
11574
11575 if ((fp = fopen (hashfile, "rb")) == NULL)
11576 {
11577 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11578
11579 return (-1);
11580 }
11581
11582 uint line_num = 0;
11583
11584 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11585
11586 while (!feof (fp))
11587 {
11588 line_num++;
11589
11590 int line_len = fgetl (fp, line_buf);
11591
11592 if (line_len == 0) continue;
11593
11594 char *hash_buf = NULL;
11595 int hash_len = 0;
11596
11597 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11598
11599 bool hash_fmt_error = 0;
11600
11601 if (hash_len < 1) hash_fmt_error = 1;
11602 if (hash_buf == NULL) hash_fmt_error = 1;
11603
11604 if (hash_fmt_error)
11605 {
11606 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11607
11608 continue;
11609 }
11610
11611 if (username)
11612 {
11613 char *user_buf = NULL;
11614 int user_len = 0;
11615
11616 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11617
11618 if (remove || show)
11619 {
11620 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11621
11622 *user = (user_t *) mymalloc (sizeof (user_t));
11623
11624 user_t *user_ptr = *user;
11625
11626 if (user_buf != NULL)
11627 {
11628 user_ptr->user_name = mystrdup (user_buf);
11629 }
11630 else
11631 {
11632 user_ptr->user_name = mystrdup ("");
11633 }
11634
11635 user_ptr->user_len = user_len;
11636 }
11637 }
11638
11639 if (opts_type & OPTS_TYPE_HASH_COPY)
11640 {
11641 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11642
11643 hash_info_tmp->orighash = mystrdup (hash_buf);
11644 }
11645
11646 if (isSalted)
11647 {
11648 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11649 }
11650
11651 if (hash_mode == 3000)
11652 {
11653 if (hash_len == 32)
11654 {
11655 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11656
11657 if (parser_status < PARSER_GLOBAL_ZERO)
11658 {
11659 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11660
11661 continue;
11662 }
11663
11664 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11665
11666 hashes_cnt++;
11667
11668 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11669
11670 if (parser_status < PARSER_GLOBAL_ZERO)
11671 {
11672 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11673
11674 continue;
11675 }
11676
11677 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11678
11679 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);
11680
11681 hashes_cnt++;
11682
11683 // show / left
11684
11685 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);
11686 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);
11687 }
11688 else
11689 {
11690 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11691
11692 if (parser_status < PARSER_GLOBAL_ZERO)
11693 {
11694 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11695
11696 continue;
11697 }
11698
11699 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);
11700
11701 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11702 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11703
11704 hashes_cnt++;
11705 }
11706 }
11707 else
11708 {
11709 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11710
11711 if (parser_status < PARSER_GLOBAL_ZERO)
11712 {
11713 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11714
11715 continue;
11716 }
11717
11718 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);
11719
11720 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11721 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11722
11723 hashes_cnt++;
11724 }
11725 }
11726
11727 myfree (line_buf);
11728
11729 fclose (fp);
11730
11731 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11732
11733 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11734 }
11735 }
11736 else
11737 {
11738 if (isSalted)
11739 {
11740 hashes_buf[0].salt->salt_len = 8;
11741
11742 // special salt handling
11743
11744 switch (hash_mode)
11745 {
11746 case 1500: hashes_buf[0].salt->salt_len = 2;
11747 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11748 break;
11749 case 1731: hashes_buf[0].salt->salt_len = 4;
11750 break;
11751 case 2410: hashes_buf[0].salt->salt_len = 4;
11752 break;
11753 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11754 break;
11755 case 3100: hashes_buf[0].salt->salt_len = 1;
11756 break;
11757 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11758 break;
11759 case 5800: hashes_buf[0].salt->salt_len = 16;
11760 break;
11761 case 6800: hashes_buf[0].salt->salt_len = 32;
11762 break;
11763 case 8400: hashes_buf[0].salt->salt_len = 40;
11764 break;
11765 case 8800: hashes_buf[0].salt->salt_len = 16;
11766 break;
11767 case 8900: hashes_buf[0].salt->salt_len = 16;
11768 hashes_buf[0].salt->scrypt_N = 1024;
11769 hashes_buf[0].salt->scrypt_r = 1;
11770 hashes_buf[0].salt->scrypt_p = 1;
11771 break;
11772 case 9100: hashes_buf[0].salt->salt_len = 16;
11773 break;
11774 case 9300: hashes_buf[0].salt->salt_len = 14;
11775 hashes_buf[0].salt->scrypt_N = 16384;
11776 hashes_buf[0].salt->scrypt_r = 1;
11777 hashes_buf[0].salt->scrypt_p = 1;
11778 break;
11779 case 9400: hashes_buf[0].salt->salt_len = 16;
11780 break;
11781 case 9500: hashes_buf[0].salt->salt_len = 16;
11782 break;
11783 case 9600: hashes_buf[0].salt->salt_len = 16;
11784 break;
11785 case 9700: hashes_buf[0].salt->salt_len = 16;
11786 break;
11787 case 9710: hashes_buf[0].salt->salt_len = 16;
11788 break;
11789 case 9720: hashes_buf[0].salt->salt_len = 16;
11790 break;
11791 case 9800: hashes_buf[0].salt->salt_len = 16;
11792 break;
11793 case 9810: hashes_buf[0].salt->salt_len = 16;
11794 break;
11795 case 9820: hashes_buf[0].salt->salt_len = 16;
11796 break;
11797 case 10300: hashes_buf[0].salt->salt_len = 12;
11798 break;
11799 case 11500: hashes_buf[0].salt->salt_len = 4;
11800 break;
11801 case 11600: hashes_buf[0].salt->salt_len = 4;
11802 break;
11803 case 12400: hashes_buf[0].salt->salt_len = 4;
11804 break;
11805 case 12500: hashes_buf[0].salt->salt_len = 8;
11806 break;
11807 case 12600: hashes_buf[0].salt->salt_len = 64;
11808 break;
11809 }
11810
11811 // special esalt handling
11812
11813 switch (hash_mode)
11814 {
11815 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11816 break;
11817 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11818 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11819 break;
11820 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11821 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11822 break;
11823 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11824 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11825 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11826 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11827 break;
11828 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11829 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11830 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11831 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11832 break;
11833 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11834 break;
11835 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11836 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11837 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11838 break;
11839 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11840 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11841 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11842 break;
11843 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11844 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11845 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11846 break;
11847 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11848 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11849 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11850 break;
11851 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11852 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11853 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11854 break;
11855 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11856 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11857 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11858 break;
11859 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11860 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11861 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11862 break;
11863 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11864 break;
11865 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11866 break;
11867 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11868 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11869 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11870 break;
11871 }
11872 }
11873
11874 // set hashfile
11875
11876 switch (hash_mode)
11877 {
11878 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11879 break;
11880 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11881 break;
11882 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11883 break;
11884 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11885 break;
11886 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11887 break;
11888 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11889 break;
11890 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11891 break;
11892 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11893 break;
11894 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11895 break;
11896 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11897 break;
11898 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11899 break;
11900 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11901 break;
11902 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11903 break;
11904 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11905 break;
11906 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11907 break;
11908 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11909 break;
11910 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11911 break;
11912 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11913 break;
11914 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11915 break;
11916 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11917 break;
11918 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11919 break;
11920 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11921 break;
11922 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11923 break;
11924 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11925 break;
11926 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11927 break;
11928 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11929 break;
11930 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11931 break;
11932 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11933 break;
11934 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11935 break;
11936 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11937 break;
11938 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11939 break;
11940 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11941 break;
11942 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11943 break;
11944 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11945 break;
11946 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11947 break;
11948 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11949 break;
11950 }
11951
11952 // set default iterations
11953
11954 switch (hash_mode)
11955 {
11956 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11957 break;
11958 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11959 break;
11960 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11961 break;
11962 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11963 break;
11964 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11965 break;
11966 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11967 break;
11968 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11969 break;
11970 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11971 break;
11972 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11973 break;
11974 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11975 break;
11976 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11977 break;
11978 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11979 break;
11980 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11981 break;
11982 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11983 break;
11984 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11985 break;
11986 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11987 break;
11988 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11989 break;
11990 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11991 break;
11992 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11993 break;
11994 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11995 break;
11996 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11997 break;
11998 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11999 break;
12000 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12001 break;
12002 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12003 break;
12004 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12005 break;
12006 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12007 break;
12008 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12009 break;
12010 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12011 break;
12012 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12013 break;
12014 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12015 break;
12016 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12017 break;
12018 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12019 break;
12020 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12021 break;
12022 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12023 break;
12024 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12025 break;
12026 case 8900: hashes_buf[0].salt->salt_iter = 1;
12027 break;
12028 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12029 break;
12030 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12031 break;
12032 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12033 break;
12034 case 9300: hashes_buf[0].salt->salt_iter = 1;
12035 break;
12036 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12037 break;
12038 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12039 break;
12040 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12041 break;
12042 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12043 break;
12044 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12045 break;
12046 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12047 break;
12048 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12049 break;
12050 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12051 break;
12052 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12053 break;
12054 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12055 break;
12056 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12057 break;
12058 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12059 break;
12060 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12061 break;
12062 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12063 break;
12064 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12065 break;
12066 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12067 break;
12068 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12069 break;
12070 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12071 break;
12072 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12073 break;
12074 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12075 break;
12076 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12077 break;
12078 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12079 break;
12080 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12081 break;
12082 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12083 break;
12084 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12085 break;
12086 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12087 break;
12088 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12089 break;
12090 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12091 break;
12092 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12093 break;
12094 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12095 break;
12096 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12097 break;
12098 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12099 break;
12100 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12101 break;
12102 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12103 break;
12104 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12105 break;
12106 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12107 break;
12108 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12109 break;
12110 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12111 break;
12112 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12113 break;
12114 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12115 break;
12116 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12117 break;
12118 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12119 break;
12120 }
12121
12122 hashes_cnt = 1;
12123 }
12124
12125 if (show == 1 || left == 1)
12126 {
12127 for (uint i = 0; i < pot_cnt; i++)
12128 {
12129 pot_t *pot_ptr = &pot[i];
12130
12131 hash_t *hashes_buf = &pot_ptr->hash;
12132
12133 local_free (hashes_buf->digest);
12134
12135 if (isSalted)
12136 {
12137 local_free (hashes_buf->salt);
12138 }
12139 }
12140
12141 local_free (pot);
12142
12143 if (data.quiet == 0) log_info_nn ("");
12144
12145 return (0);
12146 }
12147
12148 if (keyspace == 0)
12149 {
12150 if (hashes_cnt == 0)
12151 {
12152 log_error ("ERROR: No hashes loaded");
12153
12154 return (-1);
12155 }
12156 }
12157
12158 /**
12159 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12160 */
12161
12162 if (data.outfile != NULL)
12163 {
12164 if (data.hashfile != NULL)
12165 {
12166 #ifdef _POSIX
12167 struct stat tmpstat_outfile;
12168 struct stat tmpstat_hashfile;
12169 #endif
12170
12171 #ifdef _WIN
12172 struct stat64 tmpstat_outfile;
12173 struct stat64 tmpstat_hashfile;
12174 #endif
12175
12176 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12177
12178 if (tmp_outfile_fp)
12179 {
12180 #ifdef _POSIX
12181 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12182 #endif
12183
12184 #ifdef _WIN
12185 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12186 #endif
12187
12188 fclose (tmp_outfile_fp);
12189 }
12190
12191 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12192
12193 if (tmp_hashfile_fp)
12194 {
12195 #ifdef _POSIX
12196 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12197 #endif
12198
12199 #ifdef _WIN
12200 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12201 #endif
12202
12203 fclose (tmp_hashfile_fp);
12204 }
12205
12206 if (tmp_outfile_fp && tmp_outfile_fp)
12207 {
12208 tmpstat_outfile.st_mode = 0;
12209 tmpstat_outfile.st_nlink = 0;
12210 tmpstat_outfile.st_uid = 0;
12211 tmpstat_outfile.st_gid = 0;
12212 tmpstat_outfile.st_rdev = 0;
12213 tmpstat_outfile.st_atime = 0;
12214
12215 tmpstat_hashfile.st_mode = 0;
12216 tmpstat_hashfile.st_nlink = 0;
12217 tmpstat_hashfile.st_uid = 0;
12218 tmpstat_hashfile.st_gid = 0;
12219 tmpstat_hashfile.st_rdev = 0;
12220 tmpstat_hashfile.st_atime = 0;
12221
12222 #ifdef _POSIX
12223 tmpstat_outfile.st_blksize = 0;
12224 tmpstat_outfile.st_blocks = 0;
12225
12226 tmpstat_hashfile.st_blksize = 0;
12227 tmpstat_hashfile.st_blocks = 0;
12228 #endif
12229
12230 #ifdef _POSIX
12231 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12232 {
12233 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12234
12235 return (-1);
12236 }
12237 #endif
12238
12239 #ifdef _WIN
12240 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12241 {
12242 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12243
12244 return (-1);
12245 }
12246 #endif
12247 }
12248 }
12249 }
12250
12251 /**
12252 * Remove duplicates
12253 */
12254
12255 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12256
12257 if (isSalted)
12258 {
12259 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12260 }
12261 else
12262 {
12263 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12264 }
12265
12266 uint hashes_cnt_orig = hashes_cnt;
12267
12268 hashes_cnt = 1;
12269
12270 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12271 {
12272 if (isSalted)
12273 {
12274 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12275 {
12276 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12277 }
12278 }
12279 else
12280 {
12281 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12282 }
12283
12284 if (hashes_pos > hashes_cnt)
12285 {
12286 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12287 }
12288
12289 hashes_cnt++;
12290 }
12291
12292 /**
12293 * Potfile removes
12294 */
12295
12296 uint potfile_remove_cracks = 0;
12297
12298 if (potfile_disable == 0)
12299 {
12300 hash_t hash_buf;
12301
12302 hash_buf.digest = mymalloc (dgst_size);
12303 hash_buf.salt = NULL;
12304 hash_buf.esalt = NULL;
12305 hash_buf.hash_info = NULL;
12306 hash_buf.cracked = 0;
12307
12308 if (isSalted)
12309 {
12310 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12311 }
12312
12313 if (esalt_size)
12314 {
12315 hash_buf.esalt = mymalloc (esalt_size);
12316 }
12317
12318 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12319
12320 // no solution for these special hash types (for instane because they use hashfile in output etc)
12321 if ((hash_mode != 5200) &&
12322 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12323 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12324 (hash_mode != 9000))
12325 {
12326 FILE *fp = fopen (potfile, "rb");
12327
12328 if (fp != NULL)
12329 {
12330 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12331
12332 // to be safe work with a copy (because of line_len loop, i etc)
12333 // moved up here because it's easier to handle continue case
12334 // it's just 64kb
12335
12336 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12337
12338 while (!feof (fp))
12339 {
12340 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12341
12342 if (ptr == NULL) break;
12343
12344 int line_len = strlen (line_buf);
12345
12346 if (line_len == 0) continue;
12347
12348 int iter = MAX_CUT_TRIES;
12349
12350 for (int i = line_len - 1; i && iter; i--, line_len--)
12351 {
12352 if (line_buf[i] != ':') continue;
12353
12354 if (isSalted)
12355 {
12356 memset (hash_buf.salt, 0, sizeof (salt_t));
12357 }
12358
12359 hash_t *found = NULL;
12360
12361 if (hash_mode == 6800)
12362 {
12363 if (i < 64) // 64 = 16 * uint in salt_buf[]
12364 {
12365 // manipulate salt_buf
12366 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12367
12368 hash_buf.salt->salt_len = i;
12369
12370 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12371 }
12372 }
12373 else if (hash_mode == 2500)
12374 {
12375 if (i < 64) // 64 = 16 * uint in salt_buf[]
12376 {
12377 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12378 // manipulate salt_buf
12379
12380 memcpy (line_buf_cpy, line_buf, i);
12381
12382 char *mac2_pos = strrchr (line_buf_cpy, ':');
12383
12384 if (mac2_pos == NULL) continue;
12385
12386 mac2_pos[0] = 0;
12387 mac2_pos++;
12388
12389 if (strlen (mac2_pos) != 12) continue;
12390
12391 char *mac1_pos = strrchr (line_buf_cpy, ':');
12392
12393 if (mac1_pos == NULL) continue;
12394
12395 mac1_pos[0] = 0;
12396 mac1_pos++;
12397
12398 if (strlen (mac1_pos) != 12) continue;
12399
12400 uint essid_length = mac1_pos - line_buf_cpy - 1;
12401
12402 // here we need the ESSID
12403 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12404
12405 hash_buf.salt->salt_len = essid_length;
12406
12407 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12408
12409 if (found)
12410 {
12411 wpa_t *wpa = (wpa_t *) found->esalt;
12412
12413 // compare hex string(s) vs binary MAC address(es)
12414
12415 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12416 {
12417 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12418 {
12419 found = NULL;
12420
12421 break;
12422 }
12423 }
12424
12425 // early skip ;)
12426 if (!found) continue;
12427
12428 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12429 {
12430 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12431 {
12432 found = NULL;
12433
12434 break;
12435 }
12436 }
12437 }
12438 }
12439 }
12440 else
12441 {
12442 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12443
12444 if (parser_status == PARSER_OK)
12445 {
12446 if (isSalted)
12447 {
12448 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12449 }
12450 else
12451 {
12452 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12453 }
12454 }
12455 }
12456
12457 if (found == NULL) continue;
12458
12459 if (!found->cracked) potfile_remove_cracks++;
12460
12461 found->cracked = 1;
12462
12463 if (found) break;
12464
12465 iter--;
12466 }
12467 }
12468
12469 myfree (line_buf_cpy);
12470
12471 myfree (line_buf);
12472
12473 fclose (fp);
12474 }
12475 }
12476
12477 if (esalt_size)
12478 {
12479 local_free (hash_buf.esalt);
12480 }
12481
12482 if (isSalted)
12483 {
12484 local_free (hash_buf.salt);
12485 }
12486
12487 local_free (hash_buf.digest);
12488 }
12489
12490 /**
12491 * Now generate all the buffers required for later
12492 */
12493
12494 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12495
12496 salt_t *salts_buf_new = NULL;
12497 void *esalts_buf_new = NULL;
12498
12499 if (isSalted)
12500 {
12501 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12502
12503 if (esalt_size)
12504 {
12505 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12506 }
12507 }
12508 else
12509 {
12510 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12511 }
12512
12513 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12514
12515 uint digests_cnt = hashes_cnt;
12516 uint digests_done = 0;
12517
12518 size_t size_digests = digests_cnt * dgst_size;
12519 size_t size_shown = digests_cnt * sizeof (uint);
12520
12521 uint *digests_shown = (uint *) mymalloc (size_shown);
12522 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12523
12524 uint salts_cnt = 0;
12525 uint salts_done = 0;
12526
12527 hashinfo_t **hash_info = NULL;
12528
12529 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12530 {
12531 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12532
12533 if (username && (remove || show))
12534 {
12535 uint user_pos;
12536
12537 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12538 {
12539 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12540
12541 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12542 }
12543 }
12544 }
12545
12546 uint *salts_shown = (uint *) mymalloc (size_shown);
12547
12548 salt_t *salt_buf;
12549
12550 {
12551 // copied from inner loop
12552
12553 salt_buf = &salts_buf_new[salts_cnt];
12554
12555 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12556
12557 if (esalt_size)
12558 {
12559 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12560 }
12561
12562 salt_buf->digests_cnt = 0;
12563 salt_buf->digests_done = 0;
12564 salt_buf->digests_offset = 0;
12565
12566 salts_cnt++;
12567 }
12568
12569 if (hashes_buf[0].cracked == 1)
12570 {
12571 digests_shown[0] = 1;
12572
12573 digests_done++;
12574
12575 salt_buf->digests_done++;
12576 }
12577
12578 salt_buf->digests_cnt++;
12579
12580 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12581
12582 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12583 {
12584 hash_info[0] = hashes_buf[0].hash_info;
12585 }
12586
12587 // copy from inner loop
12588
12589 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12590 {
12591 if (isSalted)
12592 {
12593 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12594 {
12595 salt_buf = &salts_buf_new[salts_cnt];
12596
12597 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12598
12599 if (esalt_size)
12600 {
12601 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12602 }
12603
12604 salt_buf->digests_cnt = 0;
12605 salt_buf->digests_done = 0;
12606 salt_buf->digests_offset = hashes_pos;
12607
12608 salts_cnt++;
12609 }
12610 }
12611
12612 if (hashes_buf[hashes_pos].cracked == 1)
12613 {
12614 digests_shown[hashes_pos] = 1;
12615
12616 digests_done++;
12617
12618 salt_buf->digests_done++;
12619 }
12620
12621 salt_buf->digests_cnt++;
12622
12623 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12624
12625 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12626 {
12627 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12628 }
12629 }
12630
12631 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12632 {
12633 salt_t *salt_buf = &salts_buf_new[salt_pos];
12634
12635 if (salt_buf->digests_done == salt_buf->digests_cnt)
12636 {
12637 salts_shown[salt_pos] = 1;
12638
12639 salts_done++;
12640 }
12641
12642 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12643 }
12644
12645 local_free (digests_buf);
12646 local_free (salts_buf);
12647 local_free (esalts_buf);
12648
12649 digests_buf = digests_buf_new;
12650 salts_buf = salts_buf_new;
12651 esalts_buf = esalts_buf_new;
12652
12653 local_free (hashes_buf);
12654
12655 /**
12656 * special modification not set from parser
12657 */
12658
12659 switch (hash_mode)
12660 {
12661 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12662 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12663 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12664 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12665 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12666 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12667 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12668 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12669 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12670 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12671 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12672 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12673 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12674 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12675 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12676 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12677 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12678 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12679 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12680 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12681 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12682 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12683 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12684 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12685 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12686 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12687 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12688 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12689 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12690 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12691 }
12692
12693 if (truecrypt_keyfiles)
12694 {
12695 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12696
12697 char *keyfiles = strdup (truecrypt_keyfiles);
12698
12699 char *keyfile = strtok (keyfiles, ",");
12700
12701 do
12702 {
12703 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12704
12705 } while ((keyfile = strtok (NULL, ",")) != NULL);
12706
12707 free (keyfiles);
12708 }
12709
12710 if (veracrypt_keyfiles)
12711 {
12712 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12713
12714 char *keyfiles = strdup (veracrypt_keyfiles);
12715
12716 char *keyfile = strtok (keyfiles, ",");
12717
12718 do
12719 {
12720 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12721
12722 } while ((keyfile = strtok (NULL, ",")) != NULL);
12723
12724 free (keyfiles);
12725 }
12726
12727 data.digests_cnt = digests_cnt;
12728 data.digests_done = digests_done;
12729 data.digests_buf = digests_buf;
12730 data.digests_shown = digests_shown;
12731 data.digests_shown_tmp = digests_shown_tmp;
12732
12733 data.salts_cnt = salts_cnt;
12734 data.salts_done = salts_done;
12735 data.salts_buf = salts_buf;
12736 data.salts_shown = salts_shown;
12737
12738 data.esalts_buf = esalts_buf;
12739 data.hash_info = hash_info;
12740
12741 /**
12742 * Automatic Optimizers
12743 */
12744
12745 if (salts_cnt == 1)
12746 opti_type |= OPTI_TYPE_SINGLE_SALT;
12747
12748 if (digests_cnt == 1)
12749 opti_type |= OPTI_TYPE_SINGLE_HASH;
12750
12751 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12752 opti_type |= OPTI_TYPE_NOT_ITERATED;
12753
12754 if (attack_mode == ATTACK_MODE_BF)
12755 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12756
12757 data.opti_type = opti_type;
12758
12759 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12760 {
12761 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12762 {
12763 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12764 {
12765 if (opts_type & OPTS_TYPE_ST_ADD80)
12766 {
12767 opts_type &= ~OPTS_TYPE_ST_ADD80;
12768 opts_type |= OPTS_TYPE_PT_ADD80;
12769 }
12770
12771 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12772 {
12773 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12774 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12775 }
12776
12777 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12778 {
12779 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12780 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12781 }
12782 }
12783 }
12784 }
12785
12786 /**
12787 * Some algorithm, like descrypt, can benefit from JIT compilation
12788 */
12789
12790 int force_jit_compilation = -1;
12791
12792 if (hash_mode == 8900)
12793 {
12794 force_jit_compilation = 8900;
12795 }
12796 else if (hash_mode == 9300)
12797 {
12798 force_jit_compilation = 8900;
12799 }
12800 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12801 {
12802 force_jit_compilation = 1500;
12803 }
12804
12805 /**
12806 * generate bitmap tables
12807 */
12808
12809 const uint bitmap_shift1 = 5;
12810 const uint bitmap_shift2 = 13;
12811
12812 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12813
12814 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12815 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12816 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12817 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12818 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12819 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12820 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12821 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12822
12823 uint bitmap_bits;
12824 uint bitmap_nums;
12825 uint bitmap_mask;
12826 uint bitmap_size;
12827
12828 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12829 {
12830 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12831
12832 bitmap_nums = 1 << bitmap_bits;
12833
12834 bitmap_mask = bitmap_nums - 1;
12835
12836 bitmap_size = bitmap_nums * sizeof (uint);
12837
12838 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12839
12840 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;
12841 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;
12842
12843 break;
12844 }
12845
12846 bitmap_nums = 1 << bitmap_bits;
12847
12848 bitmap_mask = bitmap_nums - 1;
12849
12850 bitmap_size = bitmap_nums * sizeof (uint);
12851
12852 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);
12853 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);
12854
12855 /**
12856 * prepare quick rule
12857 */
12858
12859 data.rule_buf_l = rule_buf_l;
12860 data.rule_buf_r = rule_buf_r;
12861
12862 int rule_len_l = (int) strlen (rule_buf_l);
12863 int rule_len_r = (int) strlen (rule_buf_r);
12864
12865 data.rule_len_l = rule_len_l;
12866 data.rule_len_r = rule_len_r;
12867
12868 /**
12869 * load rules
12870 */
12871
12872 uint *all_kernel_rules_cnt = NULL;
12873
12874 kernel_rule_t **all_kernel_rules_buf = NULL;
12875
12876 if (rp_files_cnt)
12877 {
12878 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12879
12880 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12881 }
12882
12883 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12884
12885 int rule_len = 0;
12886
12887 for (uint i = 0; i < rp_files_cnt; i++)
12888 {
12889 uint kernel_rules_avail = 0;
12890
12891 uint kernel_rules_cnt = 0;
12892
12893 kernel_rule_t *kernel_rules_buf = NULL;
12894
12895 char *rp_file = rp_files[i];
12896
12897 char in[BLOCK_SIZE] = { 0 };
12898 char out[BLOCK_SIZE] = { 0 };
12899
12900 FILE *fp = NULL;
12901
12902 uint rule_line = 0;
12903
12904 if ((fp = fopen (rp_file, "rb")) == NULL)
12905 {
12906 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12907
12908 return (-1);
12909 }
12910
12911 while (!feof (fp))
12912 {
12913 memset (rule_buf, 0, HCBUFSIZ);
12914
12915 rule_len = fgetl (fp, rule_buf);
12916
12917 rule_line++;
12918
12919 if (rule_len == 0) continue;
12920
12921 if (rule_buf[0] == '#') continue;
12922
12923 if (kernel_rules_avail == kernel_rules_cnt)
12924 {
12925 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12926
12927 kernel_rules_avail += INCR_RULES;
12928 }
12929
12930 memset (in, 0, BLOCK_SIZE);
12931 memset (out, 0, BLOCK_SIZE);
12932
12933 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12934
12935 if (result == -1)
12936 {
12937 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12938
12939 continue;
12940 }
12941
12942 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12943 {
12944 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12945
12946 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12947
12948 continue;
12949 }
12950
12951 /* its so slow
12952 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12953 {
12954 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12955
12956 continue;
12957 }
12958 */
12959
12960 kernel_rules_cnt++;
12961 }
12962
12963 fclose (fp);
12964
12965 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12966
12967 all_kernel_rules_buf[i] = kernel_rules_buf;
12968 }
12969
12970 /**
12971 * merge rules or automatic rule generator
12972 */
12973
12974 uint kernel_rules_cnt = 0;
12975
12976 kernel_rule_t *kernel_rules_buf = NULL;
12977
12978 if (attack_mode == ATTACK_MODE_STRAIGHT)
12979 {
12980 if (rp_files_cnt)
12981 {
12982 kernel_rules_cnt = 1;
12983
12984 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12985
12986 repeats[0] = kernel_rules_cnt;
12987
12988 for (uint i = 0; i < rp_files_cnt; i++)
12989 {
12990 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12991
12992 repeats[i + 1] = kernel_rules_cnt;
12993 }
12994
12995 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12996
12997 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12998
12999 for (uint i = 0; i < kernel_rules_cnt; i++)
13000 {
13001 uint out_pos = 0;
13002
13003 kernel_rule_t *out = &kernel_rules_buf[i];
13004
13005 for (uint j = 0; j < rp_files_cnt; j++)
13006 {
13007 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13008 uint in_pos;
13009
13010 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13011
13012 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13013 {
13014 if (out_pos == RULES_MAX - 1)
13015 {
13016 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13017
13018 break;
13019 }
13020
13021 out->cmds[out_pos] = in->cmds[in_pos];
13022 }
13023 }
13024 }
13025
13026 local_free (repeats);
13027 }
13028 else if (rp_gen)
13029 {
13030 uint kernel_rules_avail = 0;
13031
13032 while (kernel_rules_cnt < rp_gen)
13033 {
13034 if (kernel_rules_avail == kernel_rules_cnt)
13035 {
13036 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13037
13038 kernel_rules_avail += INCR_RULES;
13039 }
13040
13041 memset (rule_buf, 0, HCBUFSIZ);
13042
13043 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13044
13045 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13046
13047 kernel_rules_cnt++;
13048 }
13049 }
13050 }
13051
13052 myfree (rule_buf);
13053
13054 /**
13055 * generate NOP rules
13056 */
13057
13058 if (kernel_rules_cnt == 0)
13059 {
13060 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13061
13062 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13063
13064 kernel_rules_cnt++;
13065 }
13066
13067 data.kernel_rules_cnt = kernel_rules_cnt;
13068 data.kernel_rules_buf = kernel_rules_buf;
13069
13070 /**
13071 * OpenCL platforms: detect
13072 */
13073
13074 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13075 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13076
13077 cl_uint platforms_cnt = 0;
13078 cl_uint platform_devices_cnt = 0;
13079
13080 if (keyspace == 0)
13081 {
13082 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13083
13084 if (platforms_cnt == 0)
13085 {
13086 log_info ("");
13087 log_info ("ATTENTION! No OpenCL compatible platform found");
13088 log_info ("");
13089 log_info ("You're probably missing the OpenCL runtime installation");
13090 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13091 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13092 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13093 log_info ("");
13094
13095 return (-1);
13096 }
13097
13098 if (opencl_platforms_filter != (uint) -1)
13099 {
13100 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13101
13102 if (opencl_platforms_filter > platform_cnt_mask)
13103 {
13104 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13105
13106 return (-1);
13107 }
13108 }
13109 }
13110
13111 /**
13112 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13113 */
13114
13115 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13116 {
13117 cl_platform_id platform = platforms[platform_id];
13118
13119 char platform_vendor[INFOSZ] = { 0 };
13120
13121 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13122
13123 #ifdef HAVE_HWMON
13124 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13125 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13126 {
13127 // make sure that we do not directly control the fan for NVidia
13128
13129 gpu_temp_retain = 0;
13130
13131 data.gpu_temp_retain = gpu_temp_retain;
13132 }
13133 #endif // HAVE_NVML || HAVE_NVAPI
13134 #endif
13135 }
13136
13137 /**
13138 * OpenCL device types:
13139 * 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.
13140 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13141 */
13142
13143 if (opencl_device_types == NULL)
13144 {
13145 cl_device_type device_types_all = 0;
13146
13147 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13148 {
13149 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13150
13151 cl_platform_id platform = platforms[platform_id];
13152
13153 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13154
13155 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13156 {
13157 cl_device_id device = platform_devices[platform_devices_id];
13158
13159 cl_device_type device_type;
13160
13161 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13162
13163 device_types_all |= device_type;
13164 }
13165 }
13166
13167 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13168 {
13169 device_types_filter |= CL_DEVICE_TYPE_CPU;
13170 }
13171 }
13172
13173 /**
13174 * OpenCL devices: simply push all devices from all platforms into the same device array
13175 */
13176
13177 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13178
13179 data.devices_param = devices_param;
13180
13181 uint devices_cnt = 0;
13182
13183 uint devices_active = 0;
13184
13185 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13186 {
13187 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13188
13189 cl_platform_id platform = platforms[platform_id];
13190
13191 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13192
13193 char platform_vendor[INFOSZ] = { 0 };
13194
13195 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13196
13197 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13198 // this causes trouble with vendor id based macros
13199 // we'll assign generic to those without special optimization available
13200
13201 cl_uint vendor_id = 0;
13202
13203 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13204 {
13205 vendor_id = VENDOR_ID_AMD;
13206 }
13207 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13208 {
13209 vendor_id = VENDOR_ID_APPLE;
13210 }
13211 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13212 {
13213 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13214 }
13215 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13216 {
13217 vendor_id = VENDOR_ID_INTEL_SDK;
13218 }
13219 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13220 {
13221 vendor_id = VENDOR_ID_MESA;
13222 }
13223 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13224 {
13225 vendor_id = VENDOR_ID_NV;
13226 }
13227 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13228 {
13229 vendor_id = VENDOR_ID_POCL;
13230 }
13231 else
13232 {
13233 vendor_id = VENDOR_ID_GENERIC;
13234 }
13235
13236 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13237 {
13238 size_t param_value_size = 0;
13239
13240 const uint device_id = devices_cnt;
13241
13242 hc_device_param_t *device_param = &data.devices_param[device_id];
13243
13244 device_param->vendor_id = vendor_id;
13245
13246 device_param->device = platform_devices[platform_devices_id];
13247
13248 device_param->device_id = device_id;
13249
13250 device_param->platform_devices_id = platform_devices_id;
13251
13252 // device_type
13253
13254 cl_device_type device_type;
13255
13256 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13257
13258 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13259
13260 device_param->device_type = device_type;
13261
13262 // device_name
13263
13264 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13265
13266 char *device_name = (char *) mymalloc (param_value_size);
13267
13268 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13269
13270 device_param->device_name = device_name;
13271
13272 // tuning db
13273
13274 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13275
13276 // device_version
13277
13278 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13279
13280 char *device_version = (char *) mymalloc (param_value_size);
13281
13282 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13283
13284 device_param->device_version = device_version;
13285
13286 // device_opencl_version
13287
13288 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13289
13290 char *device_opencl_version = (char *) mymalloc (param_value_size);
13291
13292 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13293
13294 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13295
13296 myfree (device_opencl_version);
13297
13298 // vector_width
13299
13300 cl_uint vector_width;
13301
13302 if (opencl_vector_width_chgd == 0)
13303 {
13304 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13305 {
13306 if (opti_type & OPTI_TYPE_USES_BITS_64)
13307 {
13308 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13309 }
13310 else
13311 {
13312 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13313 }
13314 }
13315 else
13316 {
13317 vector_width = (cl_uint) tuningdb_entry->vector_width;
13318 }
13319 }
13320 else
13321 {
13322 vector_width = opencl_vector_width;
13323 }
13324
13325 if (vector_width > 16) vector_width = 16;
13326
13327 device_param->vector_width = vector_width;
13328
13329 // max_compute_units
13330
13331 cl_uint device_processors;
13332
13333 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13334
13335 device_param->device_processors = device_processors;
13336
13337 // device_maxmem_alloc
13338 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13339
13340 cl_ulong device_maxmem_alloc;
13341
13342 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13343
13344 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13345
13346 // device_global_mem
13347
13348 cl_ulong device_global_mem;
13349
13350 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13351
13352 device_param->device_global_mem = device_global_mem;
13353
13354 // max_work_group_size
13355
13356 size_t device_maxworkgroup_size;
13357
13358 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13359
13360 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13361
13362 // max_clock_frequency
13363
13364 cl_uint device_maxclock_frequency;
13365
13366 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13367
13368 device_param->device_maxclock_frequency = device_maxclock_frequency;
13369
13370 // device_endian_little
13371
13372 cl_bool device_endian_little;
13373
13374 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13375
13376 if (device_endian_little == CL_FALSE)
13377 {
13378 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13379
13380 device_param->skipped = 1;
13381 }
13382
13383 // device_available
13384
13385 cl_bool device_available;
13386
13387 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13388
13389 if (device_available == CL_FALSE)
13390 {
13391 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13392
13393 device_param->skipped = 1;
13394 }
13395
13396 // device_compiler_available
13397
13398 cl_bool device_compiler_available;
13399
13400 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13401
13402 if (device_compiler_available == CL_FALSE)
13403 {
13404 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13405
13406 device_param->skipped = 1;
13407 }
13408
13409 // device_execution_capabilities
13410
13411 cl_device_exec_capabilities device_execution_capabilities;
13412
13413 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13414
13415 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13416 {
13417 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13418
13419 device_param->skipped = 1;
13420 }
13421
13422 // device_extensions
13423
13424 size_t device_extensions_size;
13425
13426 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13427
13428 char *device_extensions = mymalloc (device_extensions_size + 1);
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13431
13432 if (strstr (device_extensions, "base_atomics") == 0)
13433 {
13434 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13435
13436 device_param->skipped = 1;
13437 }
13438
13439 if (strstr (device_extensions, "byte_addressable_store") == 0)
13440 {
13441 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13442
13443 device_param->skipped = 1;
13444 }
13445
13446 myfree (device_extensions);
13447
13448 // device_local_mem_size
13449
13450 cl_ulong device_local_mem_size;
13451
13452 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13453
13454 if (device_local_mem_size < 32768)
13455 {
13456 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13457
13458 device_param->skipped = 1;
13459 }
13460
13461
13462 // skipped
13463
13464 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13465 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13466
13467 // driver_version
13468
13469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13470
13471 char *driver_version = (char *) mymalloc (param_value_size);
13472
13473 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13474
13475 device_param->driver_version = driver_version;
13476
13477 // device_name_chksum
13478
13479 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13480
13481 #if __x86_64__
13482 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);
13483 #else
13484 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);
13485 #endif
13486
13487 uint device_name_digest[4] = { 0 };
13488
13489 md5_64 ((uint *) device_name_chksum, device_name_digest);
13490
13491 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13492
13493 device_param->device_name_chksum = device_name_chksum;
13494
13495 // device_processor_cores
13496
13497 if (device_type & CL_DEVICE_TYPE_CPU)
13498 {
13499 cl_uint device_processor_cores = 1;
13500
13501 device_param->device_processor_cores = device_processor_cores;
13502 }
13503
13504 if (device_type & CL_DEVICE_TYPE_GPU)
13505 {
13506 if (vendor_id == VENDOR_ID_AMD)
13507 {
13508 cl_uint device_processor_cores = 0;
13509
13510 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13511
13512 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13513
13514 device_param->device_processor_cores = device_processor_cores;
13515 }
13516 else if (vendor_id == VENDOR_ID_NV)
13517 {
13518 cl_uint kernel_exec_timeout = 0;
13519
13520 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13521
13522 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13523
13524 device_param->kernel_exec_timeout = kernel_exec_timeout;
13525
13526 cl_uint device_processor_cores = 0;
13527
13528 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13529
13530 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13531
13532 device_param->device_processor_cores = device_processor_cores;
13533
13534 cl_uint sm_minor = 0;
13535 cl_uint sm_major = 0;
13536
13537 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13538 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13539
13540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13541 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13542
13543 device_param->sm_minor = sm_minor;
13544 device_param->sm_major = sm_major;
13545 }
13546 else
13547 {
13548 cl_uint device_processor_cores = 1;
13549
13550 device_param->device_processor_cores = device_processor_cores;
13551 }
13552 }
13553
13554 // display results
13555
13556 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13557 {
13558 if (status_automat == 0)
13559 {
13560 if (device_param->skipped == 0)
13561 {
13562 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13563 device_id + 1,
13564 device_name,
13565 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13566 (unsigned int) (device_global_mem / 1024 / 1024),
13567 (unsigned int) (device_maxclock_frequency),
13568 (unsigned int) device_processors);
13569 }
13570 else
13571 {
13572 log_info ("Device #%u: %s, skipped",
13573 device_id + 1,
13574 device_name);
13575 }
13576 }
13577 }
13578
13579 // common driver check
13580
13581 if (device_param->skipped == 0)
13582 {
13583 if (device_type & CL_DEVICE_TYPE_GPU)
13584 {
13585 if (vendor_id == VENDOR_ID_AMD)
13586 {
13587 int catalyst_check = (force == 1) ? 0 : 1;
13588
13589 int catalyst_warn = 0;
13590
13591 int catalyst_broken = 0;
13592
13593 if (catalyst_check == 1)
13594 {
13595 catalyst_warn = 1;
13596
13597 // v14.9 and higher
13598 if (atoi (device_param->driver_version) >= 1573)
13599 {
13600 catalyst_warn = 0;
13601 }
13602
13603 catalyst_check = 0;
13604 }
13605
13606 if (catalyst_broken == 1)
13607 {
13608 log_info ("");
13609 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13610 log_info ("It will pass over cracked hashes and does not report them as cracked");
13611 log_info ("You are STRONGLY encouraged not to use it");
13612 log_info ("You can use --force to override this but do not post error reports if you do so");
13613 log_info ("");
13614
13615 return (-1);
13616 }
13617
13618 if (catalyst_warn == 1)
13619 {
13620 log_info ("");
13621 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13622 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13623 log_info ("See hashcat's homepage for official supported catalyst drivers");
13624 #ifdef _WIN
13625 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13626 #endif
13627 log_info ("You can use --force to override this but do not post error reports if you do so");
13628 log_info ("");
13629
13630 return (-1);
13631 }
13632 }
13633 else if (vendor_id == VENDOR_ID_NV)
13634 {
13635 if (device_param->kernel_exec_timeout != 0)
13636 {
13637 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);
13638 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13639 }
13640 }
13641 }
13642
13643 if (device_type & CL_DEVICE_TYPE_CPU)
13644 {
13645 if (vendor_id == VENDOR_ID_AMD)
13646 {
13647 if (force == 0)
13648 {
13649 log_info ("");
13650 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13651 log_info ("You are STRONGLY encouraged not to use it");
13652 log_info ("You can use --force to override this but do not post error reports if you do so");
13653 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13654 log_info ("");
13655
13656 return (-1);
13657 }
13658 }
13659 }
13660
13661 /**
13662 * kernel accel and loops tuning db adjustment
13663 */
13664
13665 device_param->kernel_accel_min = 1;
13666 device_param->kernel_accel_max = 1024;
13667
13668 device_param->kernel_loops_min = 1;
13669 device_param->kernel_loops_max = 1024;
13670
13671 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13672
13673 if (tuningdb_entry)
13674 {
13675 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13676 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13677
13678 if (_kernel_accel)
13679 {
13680 device_param->kernel_accel_min = _kernel_accel;
13681 device_param->kernel_accel_max = _kernel_accel;
13682 }
13683
13684 if (_kernel_loops)
13685 {
13686 if (workload_profile == 1)
13687 {
13688 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13689 }
13690 else if (workload_profile == 2)
13691 {
13692 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13693 }
13694
13695 device_param->kernel_loops_min = _kernel_loops;
13696 device_param->kernel_loops_max = _kernel_loops;
13697 }
13698 }
13699
13700 // commandline parameters overwrite tuningdb entries
13701
13702 if (kernel_accel)
13703 {
13704 device_param->kernel_accel_min = kernel_accel;
13705 device_param->kernel_accel_max = kernel_accel;
13706 }
13707
13708 if (kernel_loops)
13709 {
13710 device_param->kernel_loops_min = kernel_loops;
13711 device_param->kernel_loops_max = kernel_loops;
13712 }
13713
13714 /**
13715 * activate device
13716 */
13717
13718 devices_active++;
13719 }
13720
13721 // next please
13722
13723 devices_cnt++;
13724 }
13725 }
13726
13727 if (keyspace == 0 && devices_active == 0)
13728 {
13729 log_error ("ERROR: No devices found/left");
13730
13731 return (-1);
13732 }
13733
13734 // 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)
13735
13736 if (devices_filter != (uint) -1)
13737 {
13738 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13739
13740 if (devices_filter > devices_cnt_mask)
13741 {
13742 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13743
13744 return (-1);
13745 }
13746 }
13747
13748 data.devices_cnt = devices_cnt;
13749
13750 data.devices_active = devices_active;
13751
13752 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13753 {
13754 if (status_automat == 0)
13755 {
13756 log_info ("");
13757 }
13758 }
13759
13760 /**
13761 * HM devices: init
13762 */
13763
13764 #ifdef HAVE_HWMON
13765 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13766 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13767 #endif
13768
13769 #ifdef HAVE_ADL
13770 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13771 #endif
13772
13773 if (gpu_temp_disable == 0)
13774 {
13775 #if defined(WIN) && defined(HAVE_NVAPI)
13776 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13777
13778 if (nvapi_init (nvapi) == 0)
13779 data.hm_nv = nvapi;
13780
13781 if (data.hm_nv)
13782 {
13783 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13784 {
13785 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13786
13787 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13788
13789 int tmp_out = 0;
13790
13791 for (int i = 0; i < tmp_in; i++)
13792 {
13793 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13794 }
13795
13796 for (int i = 0; i < tmp_out; i++)
13797 {
13798 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13799
13800 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13801
13802 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;
13803 }
13804 }
13805 }
13806 #endif // WIN && HAVE_NVAPI
13807
13808 #if defined(LINUX) && defined(HAVE_NVML)
13809 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13810
13811 if (nvml_init (nvml) == 0)
13812 data.hm_nv = nvml;
13813
13814 if (data.hm_nv)
13815 {
13816 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13817 {
13818 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13819
13820 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13821
13822 int tmp_out = 0;
13823
13824 for (int i = 0; i < tmp_in; i++)
13825 {
13826 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13827 }
13828
13829 for (int i = 0; i < tmp_out; i++)
13830 {
13831 unsigned int speed;
13832
13833 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;
13834 }
13835 }
13836 }
13837 #endif // LINUX && HAVE_NVML
13838
13839 data.hm_amd = NULL;
13840
13841 #ifdef HAVE_ADL
13842 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13843
13844 if (adl_init (adl) == 0)
13845 data.hm_amd = adl;
13846
13847 if (data.hm_amd)
13848 {
13849 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13850 {
13851 // total number of adapters
13852
13853 int hm_adapters_num;
13854
13855 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13856
13857 // adapter info
13858
13859 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13860
13861 if (lpAdapterInfo == NULL) return (-1);
13862
13863 // get a list (of ids of) valid/usable adapters
13864
13865 int num_adl_adapters = 0;
13866
13867 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13868
13869 if (num_adl_adapters > 0)
13870 {
13871 hc_thread_mutex_lock (mux_adl);
13872
13873 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13874
13875 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13876
13877 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13878 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13879
13880 hc_thread_mutex_unlock (mux_adl);
13881 }
13882
13883 myfree (valid_adl_device_list);
13884 myfree (lpAdapterInfo);
13885 }
13886 }
13887 #endif // HAVE_ADL
13888
13889 if (data.hm_amd == NULL && data.hm_nv == NULL)
13890 {
13891 gpu_temp_disable = 1;
13892 }
13893 }
13894
13895 /**
13896 * OpenCL devices: allocate buffer for device specific information
13897 */
13898
13899 #ifdef HAVE_HWMON
13900 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13901
13902 #ifdef HAVE_ADL
13903 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13904
13905 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13906 #endif // ADL
13907 #endif
13908
13909 /**
13910 * enable custom signal handler(s)
13911 */
13912
13913 if (benchmark == 0)
13914 {
13915 hc_signal (sigHandler_default);
13916 }
13917 else
13918 {
13919 hc_signal (sigHandler_benchmark);
13920 }
13921
13922 /**
13923 * User-defined GPU temp handling
13924 */
13925
13926 #ifdef HAVE_HWMON
13927 if (gpu_temp_disable == 1)
13928 {
13929 gpu_temp_abort = 0;
13930 gpu_temp_retain = 0;
13931 }
13932
13933 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13934 {
13935 if (gpu_temp_abort < gpu_temp_retain)
13936 {
13937 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13938
13939 return (-1);
13940 }
13941 }
13942
13943 data.gpu_temp_disable = gpu_temp_disable;
13944 data.gpu_temp_abort = gpu_temp_abort;
13945 data.gpu_temp_retain = gpu_temp_retain;
13946 #endif
13947
13948 /**
13949 * inform the user
13950 */
13951
13952 if (data.quiet == 0)
13953 {
13954 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13955
13956 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);
13957
13958 if (attack_mode == ATTACK_MODE_STRAIGHT)
13959 {
13960 log_info ("Rules: %u", kernel_rules_cnt);
13961 }
13962
13963 if (opti_type)
13964 {
13965 log_info ("Applicable Optimizers:");
13966
13967 for (uint i = 0; i < 32; i++)
13968 {
13969 const uint opti_bit = 1u << i;
13970
13971 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13972 }
13973 }
13974
13975 /**
13976 * Watchdog and Temperature balance
13977 */
13978
13979 #ifdef HAVE_HWMON
13980 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13981 {
13982 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13983 }
13984
13985 if (gpu_temp_abort == 0)
13986 {
13987 log_info ("Watchdog: Temperature abort trigger disabled");
13988 }
13989 else
13990 {
13991 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13992 }
13993
13994 if (gpu_temp_retain == 0)
13995 {
13996 log_info ("Watchdog: Temperature retain trigger disabled");
13997 }
13998 else
13999 {
14000 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14001 }
14002
14003 if (data.quiet == 0) log_info ("");
14004 #endif
14005 }
14006
14007 /**
14008 * HM devices: copy
14009 */
14010
14011 if (gpu_temp_disable == 0)
14012 {
14013 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14014 {
14015 hc_device_param_t *device_param = &data.devices_param[device_id];
14016
14017 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14018
14019 if (device_param->skipped) continue;
14020
14021 const uint platform_devices_id = device_param->platform_devices_id;
14022
14023 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14024 if (device_param->vendor_id == VENDOR_ID_NV)
14025 {
14026 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14027 }
14028 #endif
14029
14030 #ifdef HAVE_ADL
14031 if (device_param->vendor_id == VENDOR_ID_AMD)
14032 {
14033 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14034 }
14035 #endif
14036 }
14037 }
14038
14039 /*
14040 * Temporary fix:
14041 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14042 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14043 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14044 * Driver / ADL bug?
14045 */
14046
14047 #ifdef HAVE_ADL
14048 if (powertune_enable == 1)
14049 {
14050 hc_thread_mutex_lock (mux_adl);
14051
14052 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14053 {
14054 hc_device_param_t *device_param = &data.devices_param[device_id];
14055
14056 if (device_param->skipped) continue;
14057
14058 if (data.hm_device[device_id].od_version == 6)
14059 {
14060 // set powertune value only
14061
14062 int powertune_supported = 0;
14063
14064 int ADL_rc = 0;
14065
14066 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14067 {
14068 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14069
14070 return (-1);
14071 }
14072
14073 if (powertune_supported != 0)
14074 {
14075 // powertune set
14076 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14077
14078 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14079 {
14080 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14081
14082 return (-1);
14083 }
14084
14085 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14086 {
14087 log_error ("ERROR: Failed to set new ADL PowerControl values");
14088
14089 return (-1);
14090 }
14091 }
14092 }
14093 }
14094
14095 hc_thread_mutex_unlock (mux_adl);
14096 }
14097 #endif // HAVE_ADK
14098 #endif // HAVE_HWMON
14099
14100 #ifdef DEBUG
14101 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14102 #endif
14103
14104 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14105
14106 uint kernel_power_all = 0;
14107
14108 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14109 {
14110 /**
14111 * host buffer
14112 */
14113
14114 hc_device_param_t *device_param = &data.devices_param[device_id];
14115
14116 if (device_param->skipped) continue;
14117
14118 /**
14119 * device properties
14120 */
14121
14122 const char *device_name_chksum = device_param->device_name_chksum;
14123 const u32 device_processors = device_param->device_processors;
14124 const u32 device_processor_cores = device_param->device_processor_cores;
14125
14126 /**
14127 * create context for each device
14128 */
14129
14130 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14131
14132 /**
14133 * create command-queue
14134 */
14135
14136 // not supported with NV
14137 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14138
14139 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14140
14141 /**
14142 * kernel threads: some algorithms need a fixed kernel-threads count
14143 * because of shared memory usage or bitslice
14144 * there needs to be some upper limit, otherwise there's too much overhead
14145 */
14146
14147 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14148
14149 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14150 {
14151 kernel_threads = KERNEL_THREADS_MAX_CPU;
14152 }
14153
14154 if (hash_mode == 1500) kernel_threads = 64; // DES
14155 if (hash_mode == 3000) kernel_threads = 64; // DES
14156 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14157 if (hash_mode == 7500) kernel_threads = 64; // RC4
14158 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14159 if (hash_mode == 9700) kernel_threads = 64; // RC4
14160 if (hash_mode == 9710) kernel_threads = 64; // RC4
14161 if (hash_mode == 9800) kernel_threads = 64; // RC4
14162 if (hash_mode == 9810) kernel_threads = 64; // RC4
14163 if (hash_mode == 10400) kernel_threads = 64; // RC4
14164 if (hash_mode == 10410) kernel_threads = 64; // RC4
14165 if (hash_mode == 10500) kernel_threads = 64; // RC4
14166 if (hash_mode == 13100) kernel_threads = 64; // RC4
14167
14168 /**
14169 * create input buffers on device : calculate size of fixed memory buffers
14170 */
14171
14172 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14173 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14174
14175 device_param->size_root_css = size_root_css;
14176 device_param->size_markov_css = size_markov_css;
14177
14178 size_t size_results = sizeof (uint);
14179
14180 device_param->size_results = size_results;
14181
14182 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14183 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14184
14185 size_t size_plains = digests_cnt * sizeof (plain_t);
14186 size_t size_salts = salts_cnt * sizeof (salt_t);
14187 size_t size_esalts = salts_cnt * esalt_size;
14188
14189 device_param->size_plains = size_plains;
14190 device_param->size_digests = size_digests;
14191 device_param->size_shown = size_shown;
14192 device_param->size_salts = size_salts;
14193
14194 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14195 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14196 size_t size_tm = 32 * sizeof (bs_word_t);
14197
14198 // scryptV stuff
14199
14200 size_t size_scryptV = 1;
14201
14202 if ((hash_mode == 8900) || (hash_mode == 9300))
14203 {
14204 uint tmto_start = 0;
14205 uint tmto_stop = 10;
14206
14207 if (scrypt_tmto)
14208 {
14209 tmto_start = scrypt_tmto;
14210 }
14211 else
14212 {
14213 // in case the user did not specify the tmto manually
14214 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14215 // but set the lower end only in case the user has a device with too less memory
14216
14217 if (hash_mode == 8900)
14218 {
14219 if (device_param->vendor_id == VENDOR_ID_AMD)
14220 {
14221 tmto_start = 1;
14222 }
14223 else if (device_param->vendor_id == VENDOR_ID_NV)
14224 {
14225 tmto_start = 2;
14226 }
14227 }
14228 else if (hash_mode == 9300)
14229 {
14230 if (device_param->vendor_id == VENDOR_ID_AMD)
14231 {
14232 tmto_start = 2;
14233 }
14234 else if (device_param->vendor_id == VENDOR_ID_NV)
14235 {
14236 tmto_start = 2;
14237 }
14238 }
14239 }
14240
14241 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14242 {
14243 // TODO: in theory the following calculation needs to be done per salt, not global
14244 // we assume all hashes have the same scrypt settings
14245
14246 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14247
14248 size_scryptV /= 1 << tmto;
14249
14250 size_scryptV *= device_processors * device_processor_cores;
14251
14252 if (size_scryptV > device_param->device_maxmem_alloc)
14253 {
14254 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14255
14256 continue;
14257 }
14258
14259 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14260 {
14261 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14262 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14263 }
14264
14265 break;
14266 }
14267
14268 if (data.salts_buf[0].scrypt_phy == 0)
14269 {
14270 log_error ("ERROR: can't allocate enough device memory");
14271
14272 return -1;
14273 }
14274
14275 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14276 }
14277
14278 /**
14279 * some algorithms need a fixed kernel-loops count
14280 */
14281
14282 if (hash_mode == 1500)
14283 {
14284 const u32 kernel_loops_fixed = 1024;
14285
14286 device_param->kernel_loops_min = kernel_loops_fixed;
14287 device_param->kernel_loops_max = kernel_loops_fixed;
14288 }
14289
14290 if (hash_mode == 3000)
14291 {
14292 const u32 kernel_loops_fixed = 1024;
14293
14294 device_param->kernel_loops_min = kernel_loops_fixed;
14295 device_param->kernel_loops_max = kernel_loops_fixed;
14296 }
14297
14298 if (hash_mode == 8900)
14299 {
14300 const u32 kernel_loops_fixed = 1;
14301
14302 device_param->kernel_loops_min = kernel_loops_fixed;
14303 device_param->kernel_loops_max = kernel_loops_fixed;
14304 }
14305
14306 if (hash_mode == 9300)
14307 {
14308 const u32 kernel_loops_fixed = 1;
14309
14310 device_param->kernel_loops_min = kernel_loops_fixed;
14311 device_param->kernel_loops_max = kernel_loops_fixed;
14312 }
14313
14314 if (hash_mode == 12500)
14315 {
14316 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14317
14318 device_param->kernel_loops_min = kernel_loops_fixed;
14319 device_param->kernel_loops_max = kernel_loops_fixed;
14320 }
14321
14322 /**
14323 * some algorithms have a maximum kernel-loops count
14324 */
14325
14326 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14327 {
14328 u32 innerloop_cnt = 0;
14329
14330 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14331 {
14332 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14333 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14334 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14335 }
14336 else
14337 {
14338 innerloop_cnt = data.salts_buf[0].salt_iter;
14339 }
14340
14341 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14342 (innerloop_cnt <= device_param->kernel_loops_max))
14343 {
14344 device_param->kernel_loops_max = innerloop_cnt;
14345 }
14346 }
14347
14348 u32 kernel_accel_min = device_param->kernel_accel_min;
14349 u32 kernel_accel_max = device_param->kernel_accel_max;
14350
14351 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14352
14353 size_t size_pws = 4;
14354 size_t size_tmps = 4;
14355 size_t size_hooks = 4;
14356
14357 while (kernel_accel_max >= kernel_accel_min)
14358 {
14359 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14360
14361 // size_pws
14362
14363 size_pws = kernel_power_max * sizeof (pw_t);
14364
14365 // size_tmps
14366
14367 switch (hash_mode)
14368 {
14369 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14370 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14371 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14372 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14373 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14374 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14375 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14376 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14377 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14378 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14379 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14380 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14381 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14382 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14383 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14384 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14385 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14386 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14387 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14388 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14389 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14390 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14391 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14392 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14393 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14394 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14395 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14396 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14397 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14398 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14399 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14400 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14401 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14402 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14403 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14404 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14405 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14406 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14407 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14408 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14409 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14410 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14411 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14412 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14413 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14414 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14415 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14416 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14417 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14418 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14419 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14420 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14421 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14422 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14423 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14424 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14425 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14426 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14427 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14428 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14429 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14430 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14431 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14432 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14433 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14434 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14435 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14436 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14437 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14438 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14439 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14440 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14441 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14442 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14443 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14444 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14445 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14446 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14447 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14448 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 };
14452
14453 // size_hooks
14454
14455 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14456 {
14457 // none yet
14458 }
14459
14460 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14461 // if not, decrease amplifier and try again
14462
14463 int skip = 0;
14464
14465 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14466 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14467 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14468
14469 if (( bitmap_size
14470 + bitmap_size
14471 + bitmap_size
14472 + bitmap_size
14473 + bitmap_size
14474 + bitmap_size
14475 + bitmap_size
14476 + bitmap_size
14477 + size_bfs
14478 + size_combs
14479 + size_digests
14480 + size_esalts
14481 + size_hooks
14482 + size_markov_css
14483 + size_plains
14484 + size_pws
14485 + size_pws // not a bug
14486 + size_results
14487 + size_root_css
14488 + size_rules
14489 + size_rules_c
14490 + size_salts
14491 + size_scryptV
14492 + size_shown
14493 + size_tm
14494 + size_tmps) > device_param->device_global_mem) skip = 1;
14495
14496 if (skip == 1)
14497 {
14498 kernel_accel_max--;
14499
14500 continue;
14501 }
14502
14503 break;
14504 }
14505
14506 /*
14507 if (kernel_accel_max == 0)
14508 {
14509 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14510
14511 return -1;
14512 }
14513 */
14514
14515 device_param->kernel_accel_min = kernel_accel_min;
14516 device_param->kernel_accel_max = kernel_accel_max;
14517
14518 /*
14519 if (kernel_accel_max < kernel_accel)
14520 {
14521 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14522
14523 device_param->kernel_accel = kernel_accel_max;
14524 }
14525 */
14526
14527 device_param->size_bfs = size_bfs;
14528 device_param->size_combs = size_combs;
14529 device_param->size_rules = size_rules;
14530 device_param->size_rules_c = size_rules_c;
14531 device_param->size_pws = size_pws;
14532 device_param->size_tmps = size_tmps;
14533 device_param->size_hooks = size_hooks;
14534
14535 // do not confuse kernel_accel_max with kernel_accel here
14536
14537 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14538
14539 device_param->kernel_threads = kernel_threads;
14540 device_param->kernel_power_user = kernel_power;
14541
14542 kernel_power_all += kernel_power;
14543
14544 /**
14545 * default building options
14546 */
14547
14548 char build_opts[1024] = { 0 };
14549
14550 // we don't have sm_* on vendors not NV but it doesn't matter
14551
14552 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);
14553
14554 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14555 {
14556 // we do vectorizing much better than the auto-vectorizer
14557
14558 char build_opts_new[1024] = { 0 };
14559
14560 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14561
14562 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14563 }
14564
14565 #ifdef DEBUG
14566 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14567 #endif
14568
14569 /**
14570 * main kernel
14571 */
14572
14573 {
14574 /**
14575 * kernel source filename
14576 */
14577
14578 char source_file[256] = { 0 };
14579
14580 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14581
14582 struct stat sst;
14583
14584 if (stat (source_file, &sst) == -1)
14585 {
14586 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14587
14588 return -1;
14589 }
14590
14591 /**
14592 * kernel cached filename
14593 */
14594
14595 char cached_file[256] = { 0 };
14596
14597 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14598
14599 int cached = 1;
14600
14601 struct stat cst;
14602
14603 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14604 {
14605 cached = 0;
14606 }
14607
14608 /**
14609 * kernel compile or load
14610 */
14611
14612 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14613
14614 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14615
14616 if (force_jit_compilation == -1)
14617 {
14618 if (cached == 0)
14619 {
14620 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14621
14622 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14623
14624 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14625
14626 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14627
14628 #ifdef DEBUG
14629 size_t build_log_size = 0;
14630
14631 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14632
14633 if (build_log_size > 1)
14634 {
14635 char *build_log = (char *) malloc (build_log_size + 1);
14636
14637 memset (build_log, 0, build_log_size + 1);
14638
14639 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14640
14641 puts (build_log);
14642
14643 free (build_log);
14644 }
14645 #endif
14646
14647 if (rc != 0)
14648 {
14649 device_param->skipped = true;
14650
14651 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14652
14653 continue;
14654 }
14655
14656 size_t binary_size;
14657
14658 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14659
14660 u8 *binary = (u8 *) mymalloc (binary_size);
14661
14662 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14663
14664 writeProgramBin (cached_file, binary, binary_size);
14665
14666 local_free (binary);
14667 }
14668 else
14669 {
14670 #ifdef DEBUG
14671 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14672 #endif
14673
14674 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14675
14676 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14677
14678 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14679 }
14680 }
14681 else
14682 {
14683 #ifdef DEBUG
14684 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14685 #endif
14686
14687 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14688
14689 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14690
14691 char build_opts_update[1024] = { 0 };
14692
14693 if (force_jit_compilation == 1500)
14694 {
14695 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14696 }
14697 else if (force_jit_compilation == 8900)
14698 {
14699 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);
14700 }
14701 else
14702 {
14703 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14704 }
14705
14706 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14707
14708 #ifdef DEBUG
14709 size_t build_log_size = 0;
14710
14711 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14712
14713 if (build_log_size > 1)
14714 {
14715 char *build_log = (char *) malloc (build_log_size + 1);
14716
14717 memset (build_log, 0, build_log_size + 1);
14718
14719 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14720
14721 puts (build_log);
14722
14723 free (build_log);
14724 }
14725 #endif
14726
14727 if (rc != 0)
14728 {
14729 device_param->skipped = true;
14730
14731 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14732 }
14733 }
14734
14735 local_free (kernel_lengths);
14736 local_free (kernel_sources[0]);
14737 local_free (kernel_sources);
14738 }
14739
14740 /**
14741 * word generator kernel
14742 */
14743
14744 if (attack_mode != ATTACK_MODE_STRAIGHT)
14745 {
14746 /**
14747 * kernel mp source filename
14748 */
14749
14750 char source_file[256] = { 0 };
14751
14752 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14753
14754 struct stat sst;
14755
14756 if (stat (source_file, &sst) == -1)
14757 {
14758 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14759
14760 return -1;
14761 }
14762
14763 /**
14764 * kernel mp cached filename
14765 */
14766
14767 char cached_file[256] = { 0 };
14768
14769 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14770
14771 int cached = 1;
14772
14773 struct stat cst;
14774
14775 if (stat (cached_file, &cst) == -1)
14776 {
14777 cached = 0;
14778 }
14779
14780 /**
14781 * kernel compile or load
14782 */
14783
14784 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14785
14786 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14787
14788 if (cached == 0)
14789 {
14790 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14791 if (quiet == 0) log_info ("");
14792
14793 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14794
14795 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14796
14797 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14798
14799 if (rc != 0)
14800 {
14801 device_param->skipped = true;
14802
14803 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14804
14805 continue;
14806 }
14807
14808 size_t binary_size;
14809
14810 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14811
14812 u8 *binary = (u8 *) mymalloc (binary_size);
14813
14814 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14815
14816 writeProgramBin (cached_file, binary, binary_size);
14817
14818 local_free (binary);
14819 }
14820 else
14821 {
14822 #ifdef DEBUG
14823 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14824 #endif
14825
14826 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14827
14828 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14829
14830 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14831 }
14832
14833 local_free (kernel_lengths);
14834 local_free (kernel_sources[0]);
14835 local_free (kernel_sources);
14836 }
14837
14838 /**
14839 * amplifier kernel
14840 */
14841
14842 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14843 {
14844
14845 }
14846 else
14847 {
14848 /**
14849 * kernel amp source filename
14850 */
14851
14852 char source_file[256] = { 0 };
14853
14854 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14855
14856 struct stat sst;
14857
14858 if (stat (source_file, &sst) == -1)
14859 {
14860 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14861
14862 return -1;
14863 }
14864
14865 /**
14866 * kernel amp cached filename
14867 */
14868
14869 char cached_file[256] = { 0 };
14870
14871 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14872
14873 int cached = 1;
14874
14875 struct stat cst;
14876
14877 if (stat (cached_file, &cst) == -1)
14878 {
14879 cached = 0;
14880 }
14881
14882 /**
14883 * kernel compile or load
14884 */
14885
14886 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14887
14888 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14889
14890 if (cached == 0)
14891 {
14892 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14893 if (quiet == 0) log_info ("");
14894
14895 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14896
14897 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14898
14899 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14900
14901 if (rc != 0)
14902 {
14903 device_param->skipped = true;
14904
14905 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14906
14907 continue;
14908 }
14909
14910 size_t binary_size;
14911
14912 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14913
14914 u8 *binary = (u8 *) mymalloc (binary_size);
14915
14916 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14917
14918 writeProgramBin (cached_file, binary, binary_size);
14919
14920 local_free (binary);
14921 }
14922 else
14923 {
14924 #ifdef DEBUG
14925 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14926 #endif
14927
14928 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14929
14930 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14931
14932 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14933 }
14934
14935 local_free (kernel_lengths);
14936 local_free (kernel_sources[0]);
14937 local_free (kernel_sources);
14938 }
14939
14940 // some algorithm collide too fast, make that impossible
14941
14942 if (benchmark == 1)
14943 {
14944 ((uint *) digests_buf)[0] = -1;
14945 ((uint *) digests_buf)[1] = -1;
14946 ((uint *) digests_buf)[2] = -1;
14947 ((uint *) digests_buf)[3] = -1;
14948 }
14949
14950 /**
14951 * global buffers
14952 */
14953
14954 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14955 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14956 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14957 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14958 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14959 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14960 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14961 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14962 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14963 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14964 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14965 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14966 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14967 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14968 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14969 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14970 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14971 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14972
14973 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);
14974 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);
14975 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);
14976 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);
14977 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);
14978 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);
14979 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);
14980 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);
14981 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14982 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14983 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14984
14985 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14986 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14987 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14988 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14989 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14990 run_kernel_bzero (device_param, device_param->d_result, size_results);
14991
14992 /**
14993 * special buffers
14994 */
14995
14996 if (attack_kern == ATTACK_KERN_STRAIGHT)
14997 {
14998 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14999 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15000
15001 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15002
15003 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15004 }
15005 else if (attack_kern == ATTACK_KERN_COMBI)
15006 {
15007 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15008 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15009 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15010 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15011
15012 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15013 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15014 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15015 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15016 }
15017 else if (attack_kern == ATTACK_KERN_BF)
15018 {
15019 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15020 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15021 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15022 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15023 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15024
15025 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15026 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15027 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15028 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15029 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15030 }
15031
15032 if (size_esalts)
15033 {
15034 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15035
15036 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15037 }
15038
15039 /**
15040 * main host data
15041 */
15042
15043 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15044
15045 device_param->pws_buf = pws_buf;
15046
15047 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15048
15049 device_param->combs_buf = combs_buf;
15050
15051 void *hooks_buf = mymalloc (size_hooks);
15052
15053 device_param->hooks_buf = hooks_buf;
15054
15055 /**
15056 * kernel args
15057 */
15058
15059 device_param->kernel_params_buf32[21] = bitmap_mask;
15060 device_param->kernel_params_buf32[22] = bitmap_shift1;
15061 device_param->kernel_params_buf32[23] = bitmap_shift2;
15062 device_param->kernel_params_buf32[24] = 0; // salt_pos
15063 device_param->kernel_params_buf32[25] = 0; // loop_pos
15064 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15065 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15066 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15067 device_param->kernel_params_buf32[29] = 0; // digests_offset
15068 device_param->kernel_params_buf32[30] = 0; // combs_mode
15069 device_param->kernel_params_buf32[31] = 0; // gid_max
15070
15071 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15072 ? &device_param->d_pws_buf
15073 : &device_param->d_pws_amp_buf;
15074 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15075 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15076 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15077 device_param->kernel_params[ 4] = &device_param->d_tmps;
15078 device_param->kernel_params[ 5] = &device_param->d_hooks;
15079 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15080 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15081 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15082 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15083 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15084 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15085 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15086 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15087 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15088 device_param->kernel_params[15] = &device_param->d_digests_buf;
15089 device_param->kernel_params[16] = &device_param->d_digests_shown;
15090 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15091 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15092 device_param->kernel_params[19] = &device_param->d_result;
15093 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15094 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15095 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15096 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15097 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15098 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15099 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15100 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15101 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15102 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15103 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15104 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15105
15106 device_param->kernel_params_mp_buf64[3] = 0;
15107 device_param->kernel_params_mp_buf32[4] = 0;
15108 device_param->kernel_params_mp_buf32[5] = 0;
15109 device_param->kernel_params_mp_buf32[6] = 0;
15110 device_param->kernel_params_mp_buf32[7] = 0;
15111 device_param->kernel_params_mp_buf32[8] = 0;
15112
15113 device_param->kernel_params_mp[0] = NULL;
15114 device_param->kernel_params_mp[1] = NULL;
15115 device_param->kernel_params_mp[2] = NULL;
15116 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15117 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15118 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15119 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15120 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15121 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15122
15123 device_param->kernel_params_mp_l_buf64[3] = 0;
15124 device_param->kernel_params_mp_l_buf32[4] = 0;
15125 device_param->kernel_params_mp_l_buf32[5] = 0;
15126 device_param->kernel_params_mp_l_buf32[6] = 0;
15127 device_param->kernel_params_mp_l_buf32[7] = 0;
15128 device_param->kernel_params_mp_l_buf32[8] = 0;
15129 device_param->kernel_params_mp_l_buf32[9] = 0;
15130
15131 device_param->kernel_params_mp_l[0] = NULL;
15132 device_param->kernel_params_mp_l[1] = NULL;
15133 device_param->kernel_params_mp_l[2] = NULL;
15134 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15135 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15136 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15137 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15138 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15139 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15140 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15141
15142 device_param->kernel_params_mp_r_buf64[3] = 0;
15143 device_param->kernel_params_mp_r_buf32[4] = 0;
15144 device_param->kernel_params_mp_r_buf32[5] = 0;
15145 device_param->kernel_params_mp_r_buf32[6] = 0;
15146 device_param->kernel_params_mp_r_buf32[7] = 0;
15147 device_param->kernel_params_mp_r_buf32[8] = 0;
15148
15149 device_param->kernel_params_mp_r[0] = NULL;
15150 device_param->kernel_params_mp_r[1] = NULL;
15151 device_param->kernel_params_mp_r[2] = NULL;
15152 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15153 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15154 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15155 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15156 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15157 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15158
15159 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15160 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15161
15162 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15163 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15164 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15165 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15166 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15167 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15168 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15169
15170 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15171 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15172
15173 /**
15174 * kernel name
15175 */
15176
15177 size_t kernel_wgs_tmp;
15178
15179 char kernel_name[64] = { 0 };
15180
15181 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15182 {
15183 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15184 {
15185 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15186
15187 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15188
15189 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15190
15191 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15192
15193 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15194
15195 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15196 }
15197 else
15198 {
15199 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15200
15201 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15202
15203 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15204
15205 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15206
15207 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15208
15209 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15210 }
15211
15212 if (data.attack_mode == ATTACK_MODE_BF)
15213 {
15214 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15215 {
15216 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15217
15218 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15219
15220 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);
15221 }
15222 }
15223 }
15224 else
15225 {
15226 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15227
15228 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15229
15230 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15231
15232 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15233
15234 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15235
15236 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15237
15238 if (opts_type & OPTS_TYPE_HOOK12)
15239 {
15240 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15241
15242 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15243
15244 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);
15245 }
15246
15247 if (opts_type & OPTS_TYPE_HOOK23)
15248 {
15249 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15250
15251 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15252
15253 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);
15254 }
15255 }
15256
15257 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);
15258 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);
15259 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);
15260
15261 for (uint i = 0; i <= 20; i++)
15262 {
15263 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15264 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15265 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15266
15267 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15268 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15269 }
15270
15271 for (uint i = 21; i <= 31; i++)
15272 {
15273 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15274 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15275 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15276
15277 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15278 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15279 }
15280
15281 if (attack_mode == ATTACK_MODE_BF)
15282 {
15283 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15284 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15285
15286 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);
15287 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);
15288
15289 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15290 {
15291 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15292 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15293 }
15294 }
15295 else if (attack_mode == ATTACK_MODE_HYBRID1)
15296 {
15297 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15298
15299 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);
15300 }
15301 else if (attack_mode == ATTACK_MODE_HYBRID2)
15302 {
15303 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15304
15305 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);
15306 }
15307
15308 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15309 {
15310 // nothing to do
15311 }
15312 else
15313 {
15314 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15315
15316 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);
15317 }
15318
15319 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15320 {
15321 // nothing to do
15322 }
15323 else
15324 {
15325 for (uint i = 0; i < 5; i++)
15326 {
15327 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15328 }
15329
15330 for (uint i = 5; i < 7; i++)
15331 {
15332 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15333 }
15334 }
15335
15336 // maybe this has been updated by clGetKernelWorkGroupInfo()
15337 // value can only be decreased, so we don't need to reallocate buffers
15338
15339 device_param->kernel_threads = kernel_threads;
15340
15341 /**
15342 * Store initial fanspeed if gpu_temp_retain is enabled
15343 */
15344
15345 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15346 int gpu_temp_retain_set = 0;
15347
15348 if (gpu_temp_disable == 0)
15349 {
15350 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15351 {
15352 hc_thread_mutex_lock (mux_adl);
15353
15354 if (data.hm_device[device_id].fan_supported == 1)
15355 {
15356 if (gpu_temp_retain_chgd == 0)
15357 {
15358 uint cur_temp = 0;
15359 uint default_temp = 0;
15360
15361 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);
15362
15363 if (ADL_rc == ADL_OK)
15364 {
15365 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15366
15367 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15368
15369 // special case with multi gpu setups: always use minimum retain
15370
15371 if (gpu_temp_retain_set == 0)
15372 {
15373 gpu_temp_retain = gpu_temp_retain_target;
15374 gpu_temp_retain_set = 1;
15375 }
15376 else
15377 {
15378 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15379 }
15380
15381 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15382 }
15383 }
15384
15385 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15386
15387 temp_retain_fanspeed_value[device_id] = fan_speed;
15388
15389 if (fan_speed == -1)
15390 {
15391 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15392
15393 temp_retain_fanspeed_value[device_id] = 0;
15394 }
15395 }
15396
15397 hc_thread_mutex_unlock (mux_adl);
15398 }
15399 }
15400
15401 /**
15402 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15403 */
15404
15405 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15406 {
15407 hc_thread_mutex_lock (mux_adl);
15408
15409 if (data.hm_device[device_id].od_version == 6)
15410 {
15411 int ADL_rc;
15412
15413 // check powertune capabilities first, if not available then skip device
15414
15415 int powertune_supported = 0;
15416
15417 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15418 {
15419 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15420
15421 return (-1);
15422 }
15423
15424 if (powertune_supported != 0)
15425 {
15426 // powercontrol settings
15427
15428 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15429
15430 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15431 {
15432 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15433 }
15434
15435 if (ADL_rc != ADL_OK)
15436 {
15437 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15438
15439 return (-1);
15440 }
15441
15442 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15443 {
15444 log_error ("ERROR: Failed to set new ADL PowerControl values");
15445
15446 return (-1);
15447 }
15448
15449 // clocks
15450
15451 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15452
15453 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15454
15455 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)
15456 {
15457 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15458
15459 return (-1);
15460 }
15461
15462 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15463
15464 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15465
15466 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15467 {
15468 log_error ("ERROR: Failed to get ADL device capabilities");
15469
15470 return (-1);
15471 }
15472
15473 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15474 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15475
15476 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15477 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15478
15479 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15480 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15481
15482 // warning if profile has too low max values
15483
15484 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15485 {
15486 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15487 }
15488
15489 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15490 {
15491 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15492 }
15493
15494 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15495
15496 performance_state->iNumberOfPerformanceLevels = 2;
15497
15498 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15499 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15500 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15501 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15502
15503 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)
15504 {
15505 log_info ("ERROR: Failed to set ADL performance state");
15506
15507 return (-1);
15508 }
15509
15510 local_free (performance_state);
15511 }
15512 }
15513
15514 hc_thread_mutex_unlock (mux_adl);
15515 }
15516 #endif // HAVE_HWMON && HAVE_ADL
15517 }
15518
15519 data.kernel_power_all = kernel_power_all;
15520
15521 if (data.quiet == 0) log_info_nn ("");
15522
15523 /**
15524 * In benchmark-mode, inform user which algorithm is checked
15525 */
15526
15527 if (benchmark == 1)
15528 {
15529 if (status_automat == 0)
15530 {
15531 quiet = 0;
15532
15533 data.quiet = quiet;
15534
15535 char *hash_type = strhashtype (data.hash_mode); // not a bug
15536
15537 log_info ("Hashtype: %s", hash_type);
15538 log_info ("");
15539 }
15540 }
15541
15542 /**
15543 * keep track of the progress
15544 */
15545
15546 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15547 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15548 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15549
15550 /**
15551 * open filehandles
15552 */
15553
15554 #if _WIN
15555 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15556 {
15557 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15558
15559 return (-1);
15560 }
15561
15562 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15563 {
15564 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15565
15566 return (-1);
15567 }
15568
15569 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15570 {
15571 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15572
15573 return (-1);
15574 }
15575 #endif
15576
15577 /**
15578 * dictionary pad
15579 */
15580
15581 segment_size *= (1024 * 1024);
15582
15583 data.segment_size = segment_size;
15584
15585 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15586
15587 wl_data->buf = (char *) mymalloc (segment_size);
15588 wl_data->avail = segment_size;
15589 wl_data->incr = segment_size;
15590 wl_data->cnt = 0;
15591 wl_data->pos = 0;
15592
15593 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15594
15595 data.wordlist_mode = wordlist_mode;
15596
15597 cs_t *css_buf = NULL;
15598 uint css_cnt = 0;
15599 uint dictcnt = 0;
15600 uint maskcnt = 1;
15601 char **masks = NULL;
15602 char **dictfiles = NULL;
15603
15604 uint mask_from_file = 0;
15605
15606 if (attack_mode == ATTACK_MODE_STRAIGHT)
15607 {
15608 if (wordlist_mode == WL_MODE_FILE)
15609 {
15610 int wls_left = myargc - (optind + 1);
15611
15612 for (int i = 0; i < wls_left; i++)
15613 {
15614 char *l0_filename = myargv[optind + 1 + i];
15615
15616 struct stat l0_stat;
15617
15618 if (stat (l0_filename, &l0_stat) == -1)
15619 {
15620 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15621
15622 return (-1);
15623 }
15624
15625 uint is_dir = S_ISDIR (l0_stat.st_mode);
15626
15627 if (is_dir == 0)
15628 {
15629 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15630
15631 dictcnt++;
15632
15633 dictfiles[dictcnt - 1] = l0_filename;
15634 }
15635 else
15636 {
15637 // do not allow --keyspace w/ a directory
15638
15639 if (keyspace == 1)
15640 {
15641 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15642
15643 return (-1);
15644 }
15645
15646 char **dictionary_files = NULL;
15647
15648 dictionary_files = scan_directory (l0_filename);
15649
15650 if (dictionary_files != NULL)
15651 {
15652 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15653
15654 for (int d = 0; dictionary_files[d] != NULL; d++)
15655 {
15656 char *l1_filename = dictionary_files[d];
15657
15658 struct stat l1_stat;
15659
15660 if (stat (l1_filename, &l1_stat) == -1)
15661 {
15662 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15663
15664 return (-1);
15665 }
15666
15667 if (S_ISREG (l1_stat.st_mode))
15668 {
15669 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15670
15671 dictcnt++;
15672
15673 dictfiles[dictcnt - 1] = strdup (l1_filename);
15674 }
15675 }
15676 }
15677
15678 local_free (dictionary_files);
15679 }
15680 }
15681
15682 if (dictcnt < 1)
15683 {
15684 log_error ("ERROR: No usable dictionary file found.");
15685
15686 return (-1);
15687 }
15688 }
15689 else if (wordlist_mode == WL_MODE_STDIN)
15690 {
15691 dictcnt = 1;
15692 }
15693 }
15694 else if (attack_mode == ATTACK_MODE_COMBI)
15695 {
15696 // display
15697
15698 char *dictfile1 = myargv[optind + 1 + 0];
15699 char *dictfile2 = myargv[optind + 1 + 1];
15700
15701 // find the bigger dictionary and use as base
15702
15703 FILE *fp1 = NULL;
15704 FILE *fp2 = NULL;
15705
15706 struct stat tmp_stat;
15707
15708 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15709 {
15710 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15711
15712 return (-1);
15713 }
15714
15715 if (stat (dictfile1, &tmp_stat) == -1)
15716 {
15717 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15718
15719 fclose (fp1);
15720
15721 return (-1);
15722 }
15723
15724 if (S_ISDIR (tmp_stat.st_mode))
15725 {
15726 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15727
15728 fclose (fp1);
15729
15730 return (-1);
15731 }
15732
15733 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15734 {
15735 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15736
15737 fclose (fp1);
15738
15739 return (-1);
15740 }
15741
15742 if (stat (dictfile2, &tmp_stat) == -1)
15743 {
15744 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15745
15746 fclose (fp1);
15747 fclose (fp2);
15748
15749 return (-1);
15750 }
15751
15752 if (S_ISDIR (tmp_stat.st_mode))
15753 {
15754 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15755
15756 fclose (fp1);
15757 fclose (fp2);
15758
15759 return (-1);
15760 }
15761
15762 data.combs_cnt = 1;
15763
15764 data.quiet = 1;
15765
15766 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15767
15768 data.quiet = quiet;
15769
15770 if (words1_cnt == 0)
15771 {
15772 log_error ("ERROR: %s: empty file", dictfile1);
15773
15774 fclose (fp1);
15775 fclose (fp2);
15776
15777 return (-1);
15778 }
15779
15780 data.combs_cnt = 1;
15781
15782 data.quiet = 1;
15783
15784 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15785
15786 data.quiet = quiet;
15787
15788 if (words2_cnt == 0)
15789 {
15790 log_error ("ERROR: %s: empty file", dictfile2);
15791
15792 fclose (fp1);
15793 fclose (fp2);
15794
15795 return (-1);
15796 }
15797
15798 fclose (fp1);
15799 fclose (fp2);
15800
15801 data.dictfile = dictfile1;
15802 data.dictfile2 = dictfile2;
15803
15804 if (words1_cnt >= words2_cnt)
15805 {
15806 data.combs_cnt = words2_cnt;
15807 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15808
15809 dictfiles = &data.dictfile;
15810
15811 dictcnt = 1;
15812 }
15813 else
15814 {
15815 data.combs_cnt = words1_cnt;
15816 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15817
15818 dictfiles = &data.dictfile2;
15819
15820 dictcnt = 1;
15821
15822 // we also have to switch wordlist related rules!
15823
15824 char *tmpc = data.rule_buf_l;
15825
15826 data.rule_buf_l = data.rule_buf_r;
15827 data.rule_buf_r = tmpc;
15828
15829 int tmpi = data.rule_len_l;
15830
15831 data.rule_len_l = data.rule_len_r;
15832 data.rule_len_r = tmpi;
15833 }
15834 }
15835 else if (attack_mode == ATTACK_MODE_BF)
15836 {
15837 char *mask = NULL;
15838
15839 maskcnt = 0;
15840
15841 if (benchmark == 0)
15842 {
15843 mask = myargv[optind + 1];
15844
15845 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15846
15847 if ((optind + 2) <= myargc)
15848 {
15849 struct stat file_stat;
15850
15851 if (stat (mask, &file_stat) == -1)
15852 {
15853 maskcnt = 1;
15854
15855 masks[maskcnt - 1] = mystrdup (mask);
15856 }
15857 else
15858 {
15859 int wls_left = myargc - (optind + 1);
15860
15861 uint masks_avail = INCR_MASKS;
15862
15863 for (int i = 0; i < wls_left; i++)
15864 {
15865 if (i != 0)
15866 {
15867 mask = myargv[optind + 1 + i];
15868
15869 if (stat (mask, &file_stat) == -1)
15870 {
15871 log_error ("ERROR: %s: %s", mask, strerror (errno));
15872
15873 return (-1);
15874 }
15875 }
15876
15877 uint is_file = S_ISREG (file_stat.st_mode);
15878
15879 if (is_file == 1)
15880 {
15881 FILE *mask_fp;
15882
15883 if ((mask_fp = fopen (mask, "r")) == NULL)
15884 {
15885 log_error ("ERROR: %s: %s", mask, strerror (errno));
15886
15887 return (-1);
15888 }
15889
15890 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15891
15892 while (!feof (mask_fp))
15893 {
15894 memset (line_buf, 0, HCBUFSIZ);
15895
15896 int line_len = fgetl (mask_fp, line_buf);
15897
15898 if (line_len == 0) continue;
15899
15900 if (line_buf[0] == '#') continue;
15901
15902 if (masks_avail == maskcnt)
15903 {
15904 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15905
15906 masks_avail += INCR_MASKS;
15907 }
15908
15909 masks[maskcnt] = mystrdup (line_buf);
15910
15911 maskcnt++;
15912 }
15913
15914 myfree (line_buf);
15915
15916 fclose (mask_fp);
15917 }
15918 else
15919 {
15920 log_error ("ERROR: %s: unsupported file-type", mask);
15921
15922 return (-1);
15923 }
15924 }
15925
15926 mask_from_file = 1;
15927 }
15928 }
15929 else
15930 {
15931 custom_charset_1 = (char *) "?l?d?u";
15932 custom_charset_2 = (char *) "?l?d";
15933 custom_charset_3 = (char *) "?l?d*!$@_";
15934
15935 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15936 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15937 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15938
15939 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15940
15941 wordlist_mode = WL_MODE_MASK;
15942
15943 data.wordlist_mode = wordlist_mode;
15944
15945 increment = 1;
15946
15947 maskcnt = 1;
15948 }
15949 }
15950 else
15951 {
15952 /**
15953 * generate full masks and charsets
15954 */
15955
15956 masks = (char **) mymalloc (sizeof (char *));
15957
15958 switch (hash_mode)
15959 {
15960 case 1731: pw_min = 5;
15961 pw_max = 5;
15962 mask = mystrdup ("?b?b?b?b?b");
15963 break;
15964 case 12500: pw_min = 5;
15965 pw_max = 5;
15966 mask = mystrdup ("?b?b?b?b?b");
15967 break;
15968 default: pw_min = 7;
15969 pw_max = 7;
15970 mask = mystrdup ("?b?b?b?b?b?b?b");
15971 break;
15972 }
15973
15974 maskcnt = 1;
15975
15976 masks[maskcnt - 1] = mystrdup (mask);
15977
15978 wordlist_mode = WL_MODE_MASK;
15979
15980 data.wordlist_mode = wordlist_mode;
15981
15982 increment = 1;
15983 }
15984
15985 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15986
15987 if (increment)
15988 {
15989 if (increment_min > pw_min) pw_min = increment_min;
15990
15991 if (increment_max < pw_max) pw_max = increment_max;
15992 }
15993 }
15994 else if (attack_mode == ATTACK_MODE_HYBRID1)
15995 {
15996 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15997
15998 // display
15999
16000 char *mask = myargv[myargc - 1];
16001
16002 maskcnt = 0;
16003
16004 masks = (char **) mymalloc (1 * sizeof (char *));
16005
16006 // mod
16007
16008 struct stat file_stat;
16009
16010 if (stat (mask, &file_stat) == -1)
16011 {
16012 maskcnt = 1;
16013
16014 masks[maskcnt - 1] = mystrdup (mask);
16015 }
16016 else
16017 {
16018 uint is_file = S_ISREG (file_stat.st_mode);
16019
16020 if (is_file == 1)
16021 {
16022 FILE *mask_fp;
16023
16024 if ((mask_fp = fopen (mask, "r")) == NULL)
16025 {
16026 log_error ("ERROR: %s: %s", mask, strerror (errno));
16027
16028 return (-1);
16029 }
16030
16031 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16032
16033 uint masks_avail = 1;
16034
16035 while (!feof (mask_fp))
16036 {
16037 memset (line_buf, 0, HCBUFSIZ);
16038
16039 int line_len = fgetl (mask_fp, line_buf);
16040
16041 if (line_len == 0) continue;
16042
16043 if (line_buf[0] == '#') continue;
16044
16045 if (masks_avail == maskcnt)
16046 {
16047 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16048
16049 masks_avail += INCR_MASKS;
16050 }
16051
16052 masks[maskcnt] = mystrdup (line_buf);
16053
16054 maskcnt++;
16055 }
16056
16057 myfree (line_buf);
16058
16059 fclose (mask_fp);
16060
16061 mask_from_file = 1;
16062 }
16063 else
16064 {
16065 maskcnt = 1;
16066
16067 masks[maskcnt - 1] = mystrdup (mask);
16068 }
16069 }
16070
16071 // base
16072
16073 int wls_left = myargc - (optind + 2);
16074
16075 for (int i = 0; i < wls_left; i++)
16076 {
16077 char *filename = myargv[optind + 1 + i];
16078
16079 struct stat file_stat;
16080
16081 if (stat (filename, &file_stat) == -1)
16082 {
16083 log_error ("ERROR: %s: %s", filename, strerror (errno));
16084
16085 return (-1);
16086 }
16087
16088 uint is_dir = S_ISDIR (file_stat.st_mode);
16089
16090 if (is_dir == 0)
16091 {
16092 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16093
16094 dictcnt++;
16095
16096 dictfiles[dictcnt - 1] = filename;
16097 }
16098 else
16099 {
16100 // do not allow --keyspace w/ a directory
16101
16102 if (keyspace == 1)
16103 {
16104 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16105
16106 return (-1);
16107 }
16108
16109 char **dictionary_files = NULL;
16110
16111 dictionary_files = scan_directory (filename);
16112
16113 if (dictionary_files != NULL)
16114 {
16115 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16116
16117 for (int d = 0; dictionary_files[d] != NULL; d++)
16118 {
16119 char *l1_filename = dictionary_files[d];
16120
16121 struct stat l1_stat;
16122
16123 if (stat (l1_filename, &l1_stat) == -1)
16124 {
16125 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16126
16127 return (-1);
16128 }
16129
16130 if (S_ISREG (l1_stat.st_mode))
16131 {
16132 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16133
16134 dictcnt++;
16135
16136 dictfiles[dictcnt - 1] = strdup (l1_filename);
16137 }
16138 }
16139 }
16140
16141 local_free (dictionary_files);
16142 }
16143 }
16144
16145 if (dictcnt < 1)
16146 {
16147 log_error ("ERROR: No usable dictionary file found.");
16148
16149 return (-1);
16150 }
16151
16152 if (increment)
16153 {
16154 maskcnt = 0;
16155
16156 uint mask_min = increment_min; // we can't reject smaller masks here
16157 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16158
16159 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16160 {
16161 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16162
16163 if (cur_mask == NULL) break;
16164
16165 masks[maskcnt] = cur_mask;
16166
16167 maskcnt++;
16168
16169 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16170 }
16171 }
16172 }
16173 else if (attack_mode == ATTACK_MODE_HYBRID2)
16174 {
16175 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16176
16177 // display
16178
16179 char *mask = myargv[optind + 1 + 0];
16180
16181 maskcnt = 0;
16182
16183 masks = (char **) mymalloc (1 * sizeof (char *));
16184
16185 // mod
16186
16187 struct stat file_stat;
16188
16189 if (stat (mask, &file_stat) == -1)
16190 {
16191 maskcnt = 1;
16192
16193 masks[maskcnt - 1] = mystrdup (mask);
16194 }
16195 else
16196 {
16197 uint is_file = S_ISREG (file_stat.st_mode);
16198
16199 if (is_file == 1)
16200 {
16201 FILE *mask_fp;
16202
16203 if ((mask_fp = fopen (mask, "r")) == NULL)
16204 {
16205 log_error ("ERROR: %s: %s", mask, strerror (errno));
16206
16207 return (-1);
16208 }
16209
16210 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16211
16212 uint masks_avail = 1;
16213
16214 while (!feof (mask_fp))
16215 {
16216 memset (line_buf, 0, HCBUFSIZ);
16217
16218 int line_len = fgetl (mask_fp, line_buf);
16219
16220 if (line_len == 0) continue;
16221
16222 if (line_buf[0] == '#') continue;
16223
16224 if (masks_avail == maskcnt)
16225 {
16226 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16227
16228 masks_avail += INCR_MASKS;
16229 }
16230
16231 masks[maskcnt] = mystrdup (line_buf);
16232
16233 maskcnt++;
16234 }
16235
16236 myfree (line_buf);
16237
16238 fclose (mask_fp);
16239
16240 mask_from_file = 1;
16241 }
16242 else
16243 {
16244 maskcnt = 1;
16245
16246 masks[maskcnt - 1] = mystrdup (mask);
16247 }
16248 }
16249
16250 // base
16251
16252 int wls_left = myargc - (optind + 2);
16253
16254 for (int i = 0; i < wls_left; i++)
16255 {
16256 char *filename = myargv[optind + 2 + i];
16257
16258 struct stat file_stat;
16259
16260 if (stat (filename, &file_stat) == -1)
16261 {
16262 log_error ("ERROR: %s: %s", filename, strerror (errno));
16263
16264 return (-1);
16265 }
16266
16267 uint is_dir = S_ISDIR (file_stat.st_mode);
16268
16269 if (is_dir == 0)
16270 {
16271 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16272
16273 dictcnt++;
16274
16275 dictfiles[dictcnt - 1] = filename;
16276 }
16277 else
16278 {
16279 // do not allow --keyspace w/ a directory
16280
16281 if (keyspace == 1)
16282 {
16283 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16284
16285 return (-1);
16286 }
16287
16288 char **dictionary_files = NULL;
16289
16290 dictionary_files = scan_directory (filename);
16291
16292 if (dictionary_files != NULL)
16293 {
16294 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16295
16296 for (int d = 0; dictionary_files[d] != NULL; d++)
16297 {
16298 char *l1_filename = dictionary_files[d];
16299
16300 struct stat l1_stat;
16301
16302 if (stat (l1_filename, &l1_stat) == -1)
16303 {
16304 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16305
16306 return (-1);
16307 }
16308
16309 if (S_ISREG (l1_stat.st_mode))
16310 {
16311 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16312
16313 dictcnt++;
16314
16315 dictfiles[dictcnt - 1] = strdup (l1_filename);
16316 }
16317 }
16318 }
16319
16320 local_free (dictionary_files);
16321 }
16322 }
16323
16324 if (dictcnt < 1)
16325 {
16326 log_error ("ERROR: No usable dictionary file found.");
16327
16328 return (-1);
16329 }
16330
16331 if (increment)
16332 {
16333 maskcnt = 0;
16334
16335 uint mask_min = increment_min; // we can't reject smaller masks here
16336 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16337
16338 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16339 {
16340 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16341
16342 if (cur_mask == NULL) break;
16343
16344 masks[maskcnt] = cur_mask;
16345
16346 maskcnt++;
16347
16348 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16349 }
16350 }
16351 }
16352
16353 data.pw_min = pw_min;
16354 data.pw_max = pw_max;
16355
16356 /**
16357 * weak hash check
16358 */
16359
16360 if (weak_hash_threshold >= salts_cnt)
16361 {
16362 hc_device_param_t *device_param = NULL;
16363
16364 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16365 {
16366 device_param = &data.devices_param[device_id];
16367
16368 if (device_param->skipped) continue;
16369
16370 break;
16371 }
16372
16373 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16374
16375 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16376 {
16377 weak_hash_check (device_param, salt_pos);
16378 }
16379
16380 // Display hack, guarantee that there is at least one \r before real start
16381
16382 //if (data.quiet == 0) log_info ("");
16383 }
16384
16385 /**
16386 * status and monitor threads
16387 */
16388
16389 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16390
16391 hc_thread_t i_thread = 0;
16392
16393 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16394 {
16395 hc_thread_create (i_thread, thread_keypress, &benchmark);
16396 }
16397
16398 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16399
16400 uint ni_threads_cnt = 0;
16401
16402 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16403
16404 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16405
16406 ni_threads_cnt++;
16407
16408 /**
16409 * Outfile remove
16410 */
16411
16412 if (keyspace == 0)
16413 {
16414 if (outfile_check_timer != 0)
16415 {
16416 if (data.outfile_check_directory != NULL)
16417 {
16418 if ((hash_mode != 5200) &&
16419 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16420 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16421 (hash_mode != 9000))
16422 {
16423 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16424
16425 ni_threads_cnt++;
16426 }
16427 else
16428 {
16429 outfile_check_timer = 0;
16430 }
16431 }
16432 else
16433 {
16434 outfile_check_timer = 0;
16435 }
16436 }
16437 }
16438
16439 /**
16440 * Inform the user if we got some hashes remove because of the pot file remove feature
16441 */
16442
16443 if (data.quiet == 0)
16444 {
16445 if (potfile_remove_cracks > 0)
16446 {
16447 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16448 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16449 }
16450 }
16451
16452 data.outfile_check_timer = outfile_check_timer;
16453
16454 /**
16455 * main loop
16456 */
16457
16458 char **induction_dictionaries = NULL;
16459
16460 int induction_dictionaries_cnt = 0;
16461
16462 hcstat_table_t *root_table_buf = NULL;
16463 hcstat_table_t *markov_table_buf = NULL;
16464
16465 uint initial_restore_done = 0;
16466
16467 data.maskcnt = maskcnt;
16468
16469 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16470 {
16471 if (data.devices_status == STATUS_CRACKED) break;
16472
16473 data.devices_status = STATUS_INIT;
16474
16475 if (maskpos > rd->maskpos)
16476 {
16477 rd->dictpos = 0;
16478 }
16479
16480 rd->maskpos = maskpos;
16481 data.maskpos = maskpos;
16482
16483 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16484 {
16485 char *mask = masks[maskpos];
16486
16487 if (mask_from_file == 1)
16488 {
16489 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16490
16491 char *str_ptr;
16492 uint str_pos;
16493
16494 uint mask_offset = 0;
16495
16496 uint separator_cnt;
16497
16498 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16499 {
16500 str_ptr = strstr (mask + mask_offset, ",");
16501
16502 if (str_ptr == NULL) break;
16503
16504 str_pos = str_ptr - mask;
16505
16506 // escaped separator, i.e. "\,"
16507
16508 if (str_pos > 0)
16509 {
16510 if (mask[str_pos - 1] == '\\')
16511 {
16512 separator_cnt --;
16513
16514 mask_offset = str_pos + 1;
16515
16516 continue;
16517 }
16518 }
16519
16520 // reset the offset
16521
16522 mask_offset = 0;
16523
16524 mask[str_pos] = '\0';
16525
16526 switch (separator_cnt)
16527 {
16528 case 0:
16529 mp_reset_usr (mp_usr, 0);
16530
16531 custom_charset_1 = mask;
16532 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16533 break;
16534
16535 case 1:
16536 mp_reset_usr (mp_usr, 1);
16537
16538 custom_charset_2 = mask;
16539 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16540 break;
16541
16542 case 2:
16543 mp_reset_usr (mp_usr, 2);
16544
16545 custom_charset_3 = mask;
16546 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16547 break;
16548
16549 case 3:
16550 mp_reset_usr (mp_usr, 3);
16551
16552 custom_charset_4 = mask;
16553 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16554 break;
16555 }
16556
16557 mask = mask + str_pos + 1;
16558 }
16559 }
16560
16561 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16562 {
16563 if (maskpos > 0)
16564 {
16565 local_free (css_buf);
16566 local_free (data.root_css_buf);
16567 local_free (data.markov_css_buf);
16568
16569 local_free (masks[maskpos - 1]);
16570 }
16571
16572 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16573
16574 data.mask = mask;
16575 data.css_cnt = css_cnt;
16576 data.css_buf = css_buf;
16577
16578 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16579
16580 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16581
16582 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16583 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16584
16585 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16586
16587 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16588
16589 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16590 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16591
16592 data.root_css_buf = root_css_buf;
16593 data.markov_css_buf = markov_css_buf;
16594
16595 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16596
16597 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16598
16599 local_free (root_table_buf);
16600 local_free (markov_table_buf);
16601
16602 // args
16603
16604 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16605 {
16606 hc_device_param_t *device_param = &data.devices_param[device_id];
16607
16608 if (device_param->skipped) continue;
16609
16610 device_param->kernel_params_mp[0] = &device_param->d_combs;
16611 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16612 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16613
16614 device_param->kernel_params_mp_buf64[3] = 0;
16615 device_param->kernel_params_mp_buf32[4] = css_cnt;
16616 device_param->kernel_params_mp_buf32[5] = 0;
16617 device_param->kernel_params_mp_buf32[6] = 0;
16618 device_param->kernel_params_mp_buf32[7] = 0;
16619
16620 if (attack_mode == ATTACK_MODE_HYBRID1)
16621 {
16622 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16623 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16624 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16625 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16626 }
16627 else if (attack_mode == ATTACK_MODE_HYBRID2)
16628 {
16629 device_param->kernel_params_mp_buf32[5] = 0;
16630 device_param->kernel_params_mp_buf32[6] = 0;
16631 device_param->kernel_params_mp_buf32[7] = 0;
16632 }
16633
16634 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]);
16635 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]);
16636 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]);
16637
16638 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);
16639 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);
16640 }
16641 }
16642 else if (attack_mode == ATTACK_MODE_BF)
16643 {
16644 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16645
16646 if (increment)
16647 {
16648 for (uint i = 0; i < dictcnt; i++)
16649 {
16650 local_free (dictfiles[i]);
16651 }
16652
16653 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16654 {
16655 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16656
16657 if (l1_filename == NULL) break;
16658
16659 dictcnt++;
16660
16661 dictfiles[dictcnt - 1] = l1_filename;
16662 }
16663 }
16664 else
16665 {
16666 dictcnt++;
16667
16668 dictfiles[dictcnt - 1] = mask;
16669 }
16670
16671 if (dictcnt == 0)
16672 {
16673 log_error ("ERROR: Mask is too small");
16674
16675 return (-1);
16676 }
16677 }
16678 }
16679
16680 free (induction_dictionaries);
16681
16682 // induction_dictionaries_cnt = 0; // implied
16683
16684 if (attack_mode != ATTACK_MODE_BF)
16685 {
16686 if (keyspace == 0)
16687 {
16688 induction_dictionaries = scan_directory (induction_directory);
16689
16690 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16691 }
16692 }
16693
16694 if (induction_dictionaries_cnt)
16695 {
16696 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16697 }
16698
16699 /**
16700 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16701 */
16702 if (keyspace == 1)
16703 {
16704 if ((maskcnt > 1) || (dictcnt > 1))
16705 {
16706 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16707
16708 return (-1);
16709 }
16710 }
16711
16712 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16713 {
16714 char *subid = logfile_generate_subid ();
16715
16716 data.subid = subid;
16717
16718 logfile_sub_msg ("START");
16719
16720 data.devices_status = STATUS_INIT;
16721
16722 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16723 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16724 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16725
16726 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16727
16728 data.cpt_pos = 0;
16729
16730 data.cpt_start = time (NULL);
16731
16732 data.cpt_total = 0;
16733
16734 if (data.restore == 0)
16735 {
16736 rd->words_cur = skip;
16737
16738 skip = 0;
16739
16740 data.skip = 0;
16741 }
16742
16743 data.ms_paused = 0;
16744
16745 data.words_cur = rd->words_cur;
16746
16747 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16748 {
16749 hc_device_param_t *device_param = &data.devices_param[device_id];
16750
16751 if (device_param->skipped) continue;
16752
16753 device_param->speed_pos = 0;
16754
16755 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16756 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16757
16758 device_param->exec_pos = 0;
16759
16760 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16761
16762 device_param->kernel_power = device_param->kernel_power_user;
16763
16764 device_param->outerloop_pos = 0;
16765 device_param->outerloop_left = 0;
16766 device_param->innerloop_pos = 0;
16767 device_param->innerloop_left = 0;
16768
16769 // some more resets:
16770
16771 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16772
16773 device_param->pws_cnt = 0;
16774
16775 device_param->words_off = 0;
16776 device_param->words_done = 0;
16777 }
16778
16779 data.kernel_power_div = 0;
16780
16781 // figure out some workload
16782
16783 if (attack_mode == ATTACK_MODE_STRAIGHT)
16784 {
16785 if (data.wordlist_mode == WL_MODE_FILE)
16786 {
16787 char *dictfile = NULL;
16788
16789 if (induction_dictionaries_cnt)
16790 {
16791 dictfile = induction_dictionaries[0];
16792 }
16793 else
16794 {
16795 dictfile = dictfiles[dictpos];
16796 }
16797
16798 data.dictfile = dictfile;
16799
16800 logfile_sub_string (dictfile);
16801
16802 for (uint i = 0; i < rp_files_cnt; i++)
16803 {
16804 logfile_sub_var_string ("rulefile", rp_files[i]);
16805 }
16806
16807 FILE *fd2 = fopen (dictfile, "rb");
16808
16809 if (fd2 == NULL)
16810 {
16811 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16812
16813 return (-1);
16814 }
16815
16816 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16817
16818 fclose (fd2);
16819
16820 if (data.words_cnt == 0)
16821 {
16822 if (data.devices_status == STATUS_CRACKED) break;
16823 if (data.devices_status == STATUS_ABORTED) break;
16824
16825 dictpos++;
16826
16827 continue;
16828 }
16829 }
16830 }
16831 else if (attack_mode == ATTACK_MODE_COMBI)
16832 {
16833 char *dictfile = data.dictfile;
16834 char *dictfile2 = data.dictfile2;
16835
16836 logfile_sub_string (dictfile);
16837 logfile_sub_string (dictfile2);
16838
16839 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16840 {
16841 FILE *fd2 = fopen (dictfile, "rb");
16842
16843 if (fd2 == NULL)
16844 {
16845 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16846
16847 return (-1);
16848 }
16849
16850 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16851
16852 fclose (fd2);
16853 }
16854 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16855 {
16856 FILE *fd2 = fopen (dictfile2, "rb");
16857
16858 if (fd2 == NULL)
16859 {
16860 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16861
16862 return (-1);
16863 }
16864
16865 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16866
16867 fclose (fd2);
16868 }
16869
16870 if (data.words_cnt == 0)
16871 {
16872 if (data.devices_status == STATUS_CRACKED) break;
16873 if (data.devices_status == STATUS_ABORTED) break;
16874
16875 dictpos++;
16876
16877 continue;
16878 }
16879 }
16880 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16881 {
16882 char *dictfile = NULL;
16883
16884 if (induction_dictionaries_cnt)
16885 {
16886 dictfile = induction_dictionaries[0];
16887 }
16888 else
16889 {
16890 dictfile = dictfiles[dictpos];
16891 }
16892
16893 data.dictfile = dictfile;
16894
16895 char *mask = data.mask;
16896
16897 logfile_sub_string (dictfile);
16898 logfile_sub_string (mask);
16899
16900 FILE *fd2 = fopen (dictfile, "rb");
16901
16902 if (fd2 == NULL)
16903 {
16904 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16905
16906 return (-1);
16907 }
16908
16909 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16910
16911 fclose (fd2);
16912
16913 if (data.words_cnt == 0)
16914 {
16915 if (data.devices_status == STATUS_CRACKED) break;
16916 if (data.devices_status == STATUS_ABORTED) break;
16917
16918 dictpos++;
16919
16920 continue;
16921 }
16922 }
16923 else if (attack_mode == ATTACK_MODE_BF)
16924 {
16925 local_free (css_buf);
16926 local_free (data.root_css_buf);
16927 local_free (data.markov_css_buf);
16928
16929 char *mask = dictfiles[dictpos];
16930
16931 logfile_sub_string (mask);
16932
16933 // base
16934
16935 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16936
16937 if (opts_type & OPTS_TYPE_PT_UNICODE)
16938 {
16939 uint css_cnt_unicode = css_cnt * 2;
16940
16941 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16942
16943 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16944 {
16945 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16946
16947 css_buf_unicode[j + 1].cs_buf[0] = 0;
16948 css_buf_unicode[j + 1].cs_len = 1;
16949 }
16950
16951 free (css_buf);
16952
16953 css_buf = css_buf_unicode;
16954 css_cnt = css_cnt_unicode;
16955 }
16956
16957 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16958
16959 uint mask_min = pw_min;
16960 uint mask_max = pw_max;
16961
16962 if (opts_type & OPTS_TYPE_PT_UNICODE)
16963 {
16964 mask_min *= 2;
16965 mask_max *= 2;
16966 }
16967
16968 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16969 {
16970 if (css_cnt < mask_min)
16971 {
16972 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16973 }
16974
16975 if (css_cnt > mask_max)
16976 {
16977 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16978 }
16979
16980 // skip to next mask
16981
16982 dictpos++;
16983
16984 rd->dictpos = dictpos;
16985
16986 logfile_sub_msg ("STOP");
16987
16988 continue;
16989 }
16990
16991 uint save_css_cnt = css_cnt;
16992
16993 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16994 {
16995 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16996 {
16997 uint salt_len = (uint) data.salts_buf[0].salt_len;
16998 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16999
17000 uint css_cnt_salt = css_cnt + salt_len;
17001
17002 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17003
17004 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17005
17006 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17007 {
17008 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17009 css_buf_salt[j].cs_len = 1;
17010 }
17011
17012 free (css_buf);
17013
17014 css_buf = css_buf_salt;
17015 css_cnt = css_cnt_salt;
17016 }
17017 }
17018
17019 data.mask = mask;
17020 data.css_cnt = css_cnt;
17021 data.css_buf = css_buf;
17022
17023 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17024
17025 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17026
17027 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17028
17029 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17030 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17031
17032 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17033
17034 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17035
17036 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17037 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17038
17039 data.root_css_buf = root_css_buf;
17040 data.markov_css_buf = markov_css_buf;
17041
17042 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17043
17044 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17045
17046 local_free (root_table_buf);
17047 local_free (markov_table_buf);
17048
17049 // copy + args
17050
17051 uint css_cnt_l = css_cnt;
17052 uint css_cnt_r;
17053
17054 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17055 {
17056 if (save_css_cnt < 6)
17057 {
17058 css_cnt_r = 1;
17059 }
17060 else if (save_css_cnt == 6)
17061 {
17062 css_cnt_r = 2;
17063 }
17064 else
17065 {
17066 if (opts_type & OPTS_TYPE_PT_UNICODE)
17067 {
17068 if (save_css_cnt == 8 || save_css_cnt == 10)
17069 {
17070 css_cnt_r = 2;
17071 }
17072 else
17073 {
17074 css_cnt_r = 4;
17075 }
17076 }
17077 else
17078 {
17079 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17080 {
17081 css_cnt_r = 3;
17082 }
17083 else
17084 {
17085 css_cnt_r = 4;
17086 }
17087 }
17088 }
17089 }
17090 else
17091 {
17092 css_cnt_r = 1;
17093
17094 /* unfinished code?
17095 int sum = css_buf[css_cnt_r - 1].cs_len;
17096
17097 for (uint i = 1; i < 4 && i < css_cnt; i++)
17098 {
17099 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17100
17101 css_cnt_r++;
17102
17103 sum *= css_buf[css_cnt_r - 1].cs_len;
17104 }
17105 */
17106 }
17107
17108 css_cnt_l -= css_cnt_r;
17109
17110 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17111
17112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17113 {
17114 hc_device_param_t *device_param = &data.devices_param[device_id];
17115
17116 if (device_param->skipped) continue;
17117
17118 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17119 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17120 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17121
17122 device_param->kernel_params_mp_l_buf64[3] = 0;
17123 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17124 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17125 device_param->kernel_params_mp_l_buf32[6] = 0;
17126 device_param->kernel_params_mp_l_buf32[7] = 0;
17127 device_param->kernel_params_mp_l_buf32[8] = 0;
17128
17129 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17130 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17131 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17132 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17133
17134 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17135 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17136 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17137
17138 device_param->kernel_params_mp_r_buf64[3] = 0;
17139 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17140 device_param->kernel_params_mp_r_buf32[5] = 0;
17141 device_param->kernel_params_mp_r_buf32[6] = 0;
17142 device_param->kernel_params_mp_r_buf32[7] = 0;
17143
17144 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]);
17145 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]);
17146 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]);
17147
17148 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]);
17149 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]);
17150 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]);
17151
17152 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);
17153 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);
17154 }
17155 }
17156
17157 u64 words_base = data.words_cnt;
17158
17159 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17160 {
17161 if (data.kernel_rules_cnt)
17162 {
17163 words_base /= data.kernel_rules_cnt;
17164 }
17165 }
17166 else if (data.attack_kern == ATTACK_KERN_COMBI)
17167 {
17168 if (data.combs_cnt)
17169 {
17170 words_base /= data.combs_cnt;
17171 }
17172 }
17173 else if (data.attack_kern == ATTACK_KERN_BF)
17174 {
17175 if (data.bfs_cnt)
17176 {
17177 words_base /= data.bfs_cnt;
17178 }
17179 }
17180
17181 data.words_base = words_base;
17182
17183 if (keyspace == 1)
17184 {
17185 log_info ("%llu", (unsigned long long int) words_base);
17186
17187 return (0);
17188 }
17189
17190 if (data.words_cur > data.words_base)
17191 {
17192 log_error ("ERROR: restore value greater keyspace");
17193
17194 return (-1);
17195 }
17196
17197 if (data.words_cur)
17198 {
17199 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17200 {
17201 for (uint i = 0; i < data.salts_cnt; i++)
17202 {
17203 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17204 }
17205 }
17206 else if (data.attack_kern == ATTACK_KERN_COMBI)
17207 {
17208 for (uint i = 0; i < data.salts_cnt; i++)
17209 {
17210 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17211 }
17212 }
17213 else if (data.attack_kern == ATTACK_KERN_BF)
17214 {
17215 for (uint i = 0; i < data.salts_cnt; i++)
17216 {
17217 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17218 }
17219 }
17220 }
17221
17222 /*
17223 * Inform user about possible slow speeds
17224 */
17225
17226 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17227 {
17228 if (data.words_base < kernel_power_all)
17229 {
17230 if (quiet == 0)
17231 {
17232 log_info ("ATTENTION!");
17233 log_info (" The wordlist or mask you are using is too small.");
17234 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17235 log_info (" The cracking speed will drop.");
17236 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17237 log_info ("");
17238 }
17239 }
17240 }
17241
17242 /*
17243 * Update loopback file
17244 */
17245
17246 if (loopback == 1)
17247 {
17248 time_t now;
17249
17250 time (&now);
17251
17252 uint random_num = get_random_num (0, 9999);
17253
17254 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17255
17256 data.loopback_file = loopback_file;
17257 }
17258
17259 /*
17260 * Update dictionary statistic
17261 */
17262
17263 if (keyspace == 0)
17264 {
17265 dictstat_fp = fopen (dictstat, "wb");
17266
17267 if (dictstat_fp)
17268 {
17269 lock_file (dictstat_fp);
17270
17271 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17272
17273 fclose (dictstat_fp);
17274 }
17275 }
17276
17277 data.devices_status = STATUS_RUNNING;
17278
17279 if (initial_restore_done == 0)
17280 {
17281 if (data.restore_disable == 0) cycle_restore ();
17282
17283 initial_restore_done = 1;
17284 }
17285
17286 hc_timer_set (&data.timer_running);
17287
17288 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17289 {
17290 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17291 {
17292 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17293 if (quiet == 0) fflush (stdout);
17294 }
17295 }
17296 else if (wordlist_mode == WL_MODE_STDIN)
17297 {
17298 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17299 if (data.quiet == 0) log_info ("");
17300 }
17301
17302 time_t runtime_start;
17303
17304 time (&runtime_start);
17305
17306 data.runtime_start = runtime_start;
17307
17308 /**
17309 * create cracker threads
17310 */
17311
17312 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17313
17314 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17315 {
17316 hc_device_param_t *device_param = &devices_param[device_id];
17317
17318 if (wordlist_mode == WL_MODE_STDIN)
17319 {
17320 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17321 }
17322 else
17323 {
17324 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17325 }
17326 }
17327
17328 // wait for crack threads to exit
17329
17330 hc_thread_wait (data.devices_cnt, c_threads);
17331
17332 local_free (c_threads);
17333
17334 data.restore = 0;
17335
17336 // finalize task
17337
17338 logfile_sub_var_uint ("status-after-work", data.devices_status);
17339
17340 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17341
17342 if (data.devices_status == STATUS_CRACKED) break;
17343 if (data.devices_status == STATUS_ABORTED) break;
17344
17345 if (data.devices_status == STATUS_BYPASS)
17346 {
17347 data.devices_status = STATUS_RUNNING;
17348 }
17349
17350 if (induction_dictionaries_cnt)
17351 {
17352 unlink (induction_dictionaries[0]);
17353 }
17354
17355 free (induction_dictionaries);
17356
17357 if (attack_mode != ATTACK_MODE_BF)
17358 {
17359 induction_dictionaries = scan_directory (induction_directory);
17360
17361 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17362 }
17363
17364 if (benchmark == 0)
17365 {
17366 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17367 {
17368 if (quiet == 0) clear_prompt ();
17369
17370 if (quiet == 0) log_info ("");
17371
17372 if (status == 1)
17373 {
17374 status_display ();
17375 }
17376 else
17377 {
17378 if (quiet == 0) status_display ();
17379 }
17380
17381 if (quiet == 0) log_info ("");
17382 }
17383 }
17384
17385 if (attack_mode == ATTACK_MODE_BF)
17386 {
17387 dictpos++;
17388
17389 rd->dictpos = dictpos;
17390 }
17391 else
17392 {
17393 if (induction_dictionaries_cnt)
17394 {
17395 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17396 }
17397 else
17398 {
17399 dictpos++;
17400
17401 rd->dictpos = dictpos;
17402 }
17403 }
17404
17405 time_t runtime_stop;
17406
17407 time (&runtime_stop);
17408
17409 data.runtime_stop = runtime_stop;
17410
17411 logfile_sub_uint (runtime_start);
17412 logfile_sub_uint (runtime_stop);
17413
17414 logfile_sub_msg ("STOP");
17415
17416 global_free (subid);
17417 }
17418
17419 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17420
17421 if (data.devices_status == STATUS_CRACKED) break;
17422 if (data.devices_status == STATUS_ABORTED) break;
17423 if (data.devices_status == STATUS_QUIT) break;
17424
17425 if (data.devices_status == STATUS_BYPASS)
17426 {
17427 data.devices_status = STATUS_RUNNING;
17428 }
17429 }
17430
17431 // 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
17432
17433 if (attack_mode == ATTACK_MODE_STRAIGHT)
17434 {
17435 if (data.wordlist_mode == WL_MODE_FILE)
17436 {
17437 if (data.dictfile == NULL)
17438 {
17439 if (dictfiles != NULL)
17440 {
17441 data.dictfile = dictfiles[0];
17442
17443 hc_timer_set (&data.timer_running);
17444 }
17445 }
17446 }
17447 }
17448 // NOTE: combi is okay because it is already set beforehand
17449 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17450 {
17451 if (data.dictfile == NULL)
17452 {
17453 if (dictfiles != NULL)
17454 {
17455 hc_timer_set (&data.timer_running);
17456
17457 data.dictfile = dictfiles[0];
17458 }
17459 }
17460 }
17461 else if (attack_mode == ATTACK_MODE_BF)
17462 {
17463 if (data.mask == NULL)
17464 {
17465 hc_timer_set (&data.timer_running);
17466
17467 data.mask = masks[0];
17468 }
17469 }
17470
17471 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17472 {
17473 data.devices_status = STATUS_EXHAUSTED;
17474 }
17475
17476 // if cracked / aborted remove last induction dictionary
17477
17478 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17479 {
17480 struct stat induct_stat;
17481
17482 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17483 {
17484 unlink (induction_dictionaries[file_pos]);
17485 }
17486 }
17487
17488 // wait for non-interactive threads
17489
17490 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17491 {
17492 hc_thread_wait (1, &ni_threads[thread_idx]);
17493 }
17494
17495 local_free (ni_threads);
17496
17497 // wait for interactive threads
17498
17499 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17500 {
17501 hc_thread_wait (1, &i_thread);
17502 }
17503
17504 // we dont need restore file anymore
17505 if (data.restore_disable == 0)
17506 {
17507 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17508 {
17509 unlink (eff_restore_file);
17510 unlink (new_restore_file);
17511 }
17512 else
17513 {
17514 cycle_restore ();
17515 }
17516 }
17517
17518 // finally save left hashes
17519
17520 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17521 {
17522 save_hash ();
17523 }
17524
17525 /**
17526 * Clean up
17527 */
17528
17529 if (benchmark == 1)
17530 {
17531 status_benchmark ();
17532
17533 if (status_automat == 0)
17534 {
17535 log_info ("");
17536 }
17537 }
17538 else
17539 {
17540 if (quiet == 0) clear_prompt ();
17541
17542 if (quiet == 0) log_info ("");
17543
17544 if (status == 1)
17545 {
17546 status_display ();
17547 }
17548 else
17549 {
17550 if (quiet == 0) status_display ();
17551 }
17552
17553 if (quiet == 0) log_info ("");
17554 }
17555
17556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17557 {
17558 hc_device_param_t *device_param = &data.devices_param[device_id];
17559
17560 if (device_param->skipped) continue;
17561
17562 local_free (device_param->combs_buf);
17563
17564 local_free (device_param->hooks_buf);
17565
17566 local_free (device_param->device_name);
17567
17568 local_free (device_param->device_name_chksum);
17569
17570 local_free (device_param->device_version);
17571
17572 local_free (device_param->driver_version);
17573
17574 if (device_param->pws_buf) myfree (device_param->pws_buf);
17575 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17576 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17577 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17578 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17579 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17580 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17581 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17582 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17583 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17584 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17585 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17586 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17587 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17588 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17589 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17590 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17591 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17592 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17593 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17594 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17595 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17596 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17597 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17598 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17599 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17600 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17601 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17602 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17603
17604 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17605 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17606 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17607 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17608 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17609 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17610 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17611 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17612 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17613 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17614
17615 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17616 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17617 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17618
17619 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17620 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17621 }
17622
17623 // reset default fan speed
17624
17625 #ifdef HAVE_HWMON
17626 if (gpu_temp_disable == 0)
17627 {
17628 #ifdef HAVE_ADL
17629 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17630 {
17631 hc_thread_mutex_lock (mux_adl);
17632
17633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17634 {
17635 hc_device_param_t *device_param = &data.devices_param[device_id];
17636
17637 if (device_param->skipped) continue;
17638
17639 if (data.hm_device[device_id].fan_supported == 1)
17640 {
17641 int fanspeed = temp_retain_fanspeed_value[device_id];
17642
17643 if (fanspeed == -1) continue;
17644
17645 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17646
17647 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17648 }
17649 }
17650
17651 hc_thread_mutex_unlock (mux_adl);
17652 }
17653 #endif // HAVE_ADL
17654 }
17655
17656 #ifdef HAVE_ADL
17657 // reset power tuning
17658
17659 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17660 {
17661 hc_thread_mutex_lock (mux_adl);
17662
17663 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17664 {
17665 hc_device_param_t *device_param = &data.devices_param[device_id];
17666
17667 if (device_param->skipped) continue;
17668
17669 if (data.hm_device[device_id].od_version == 6)
17670 {
17671 // check powertune capabilities first, if not available then skip device
17672
17673 int powertune_supported = 0;
17674
17675 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17676 {
17677 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17678
17679 return (-1);
17680 }
17681
17682 if (powertune_supported != 0)
17683 {
17684 // powercontrol settings
17685
17686 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)
17687 {
17688 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17689
17690 return (-1);
17691 }
17692
17693 // clocks
17694
17695 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17696
17697 performance_state->iNumberOfPerformanceLevels = 2;
17698
17699 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17700 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17701 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17702 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17703
17704 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)
17705 {
17706 log_info ("ERROR: Failed to restore ADL performance state");
17707
17708 return (-1);
17709 }
17710
17711 local_free (performance_state);
17712 }
17713 }
17714 }
17715
17716 hc_thread_mutex_unlock (mux_adl);
17717 }
17718 #endif // HAVE_ADL
17719
17720 if (gpu_temp_disable == 0)
17721 {
17722 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17723 if (data.hm_nv)
17724 {
17725 #if defined(LINUX) && defined(HAVE_NVML)
17726
17727 hm_NVML_nvmlShutdown (data.hm_nv);
17728
17729 nvml_close (data.hm_nv);
17730
17731 #elif defined(WIN) && (HAVE_NVAPI)
17732
17733 hm_NvAPI_Unload (data.hm_nv);
17734
17735 nvapi_close (data.hm_nv);
17736
17737 #endif
17738
17739 data.hm_nv = NULL;
17740 }
17741 #endif
17742
17743 #ifdef HAVE_ADL
17744 if (data.hm_amd)
17745 {
17746 hm_ADL_Main_Control_Destroy (data.hm_amd);
17747
17748 adl_close (data.hm_amd);
17749 data.hm_amd = NULL;
17750 }
17751 #endif
17752 }
17753 #endif // HAVE_HWMON
17754
17755 // free memory
17756
17757 local_free (masks);
17758
17759 local_free (dictstat_base);
17760
17761 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17762 {
17763 pot_t *pot_ptr = &pot[pot_pos];
17764
17765 hash_t *hash = &pot_ptr->hash;
17766
17767 local_free (hash->digest);
17768
17769 if (isSalted)
17770 {
17771 local_free (hash->salt);
17772 }
17773 }
17774
17775 local_free (pot);
17776
17777 local_free (all_kernel_rules_cnt);
17778 local_free (all_kernel_rules_buf);
17779
17780 local_free (wl_data->buf);
17781 local_free (wl_data);
17782
17783 local_free (bitmap_s1_a);
17784 local_free (bitmap_s1_b);
17785 local_free (bitmap_s1_c);
17786 local_free (bitmap_s1_d);
17787 local_free (bitmap_s2_a);
17788 local_free (bitmap_s2_b);
17789 local_free (bitmap_s2_c);
17790 local_free (bitmap_s2_d);
17791
17792 #ifdef HAVE_HWMON
17793 local_free (temp_retain_fanspeed_value);
17794 #ifdef HAVE_ADL
17795 local_free (od_clock_mem_status);
17796 local_free (od_power_control_status);
17797 #endif // ADL
17798 #endif
17799
17800 global_free (devices_param);
17801
17802 global_free (kernel_rules_buf);
17803
17804 global_free (root_css_buf);
17805 global_free (markov_css_buf);
17806
17807 global_free (digests_buf);
17808 global_free (digests_shown);
17809 global_free (digests_shown_tmp);
17810
17811 global_free (salts_buf);
17812 global_free (salts_shown);
17813
17814 global_free (esalts_buf);
17815
17816 global_free (words_progress_done);
17817 global_free (words_progress_rejected);
17818 global_free (words_progress_restored);
17819
17820 if (pot_fp) fclose (pot_fp);
17821
17822 if (data.devices_status == STATUS_QUIT) break;
17823 }
17824
17825 // destroy others mutex
17826
17827 hc_thread_mutex_delete (mux_dispatcher);
17828 hc_thread_mutex_delete (mux_counter);
17829 hc_thread_mutex_delete (mux_display);
17830 hc_thread_mutex_delete (mux_adl);
17831
17832 // free memory
17833
17834 local_free (eff_restore_file);
17835 local_free (new_restore_file);
17836
17837 local_free (rd);
17838
17839 // tuning db
17840
17841 tuning_db_destroy (tuning_db);
17842
17843 // loopback
17844
17845 local_free (loopback_file);
17846
17847 if (loopback == 1) unlink (loopback_file);
17848
17849 // induction directory
17850
17851 if (induction_dir == NULL)
17852 {
17853 if (attack_mode != ATTACK_MODE_BF)
17854 {
17855 if (rmdir (induction_directory) == -1)
17856 {
17857 if (errno == ENOENT)
17858 {
17859 // good, we can ignore
17860 }
17861 else if (errno == ENOTEMPTY)
17862 {
17863 // good, we can ignore
17864 }
17865 else
17866 {
17867 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17868
17869 return (-1);
17870 }
17871 }
17872
17873 local_free (induction_directory);
17874 }
17875 }
17876
17877 // outfile-check directory
17878
17879 if (outfile_check_dir == NULL)
17880 {
17881 if (rmdir (outfile_check_directory) == -1)
17882 {
17883 if (errno == ENOENT)
17884 {
17885 // good, we can ignore
17886 }
17887 else if (errno == ENOTEMPTY)
17888 {
17889 // good, we can ignore
17890 }
17891 else
17892 {
17893 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17894
17895 return (-1);
17896 }
17897 }
17898
17899 local_free (outfile_check_directory);
17900 }
17901
17902 time_t proc_stop;
17903
17904 time (&proc_stop);
17905
17906 logfile_top_uint (proc_start);
17907 logfile_top_uint (proc_stop);
17908
17909 logfile_top_msg ("STOP");
17910
17911 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17912 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17913
17914 if (data.ocl) ocl_close (data.ocl);
17915
17916 if (data.devices_status == STATUS_ABORTED) return 2;
17917 if (data.devices_status == STATUS_QUIT) return 2;
17918 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17919 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17920 if (data.devices_status == STATUS_CRACKED) return 0;
17921
17922 return -1;
17923 }
Hashcat additions to support pwdhash