projects / hashcat.git / blob
? search:


8d222b44022db4657b75973f463f89f14fbf67be
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "=======",
353 "Options",
354 "=======",
355 "",
356 "* General:",
357 "",
358 " -m, --hash-type=NUM Hash-type, see references below",
359 " -a, --attack-mode=NUM Attack-mode, see references below",
360 " -V, --version Print version",
361 " -h, --help Print help",
362 " --quiet Suppress output",
363 "",
364 "* Misc:",
365 "",
366 " --hex-charset Assume charset is given in hex",
367 " --hex-salt Assume salt is given in hex",
368 " --hex-wordlist Assume words in wordlist is given in hex",
369 " --force Ignore warnings",
370 " --status Enable automatic update of the status-screen",
371 " --status-timer=NUM Seconds between status-screen update",
372 " --status-automat Display the status view in a machine readable format",
373 " --loopback Add new plains to induct directory",
374 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
375 "",
376 "* Markov:",
377 "",
378 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
379 " --markov-disable Disables markov-chains, emulates classic brute-force",
380 " --markov-classic Enables classic markov-chains, no per-position enhancement",
381 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
382 "",
383 "* Session:",
384 "",
385 " --runtime=NUM Abort session after NUM seconds of runtime",
386 " --session=STR Define specific session name",
387 " --restore Restore session from --session",
388 " --restore-disable Do not write restore file",
389 "",
390 "* Files:",
391 "",
392 " -o, --outfile=FILE Define outfile for recovered hash",
393 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
394 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
395 " --outfile-check-timer=NUM Seconds between outfile checks",
396 " -p, --separator=CHAR Separator char for hashlists and outfile",
397 " --show Show cracked passwords only",
398 " --left Show un-cracked passwords only",
399 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
400 " --remove Enable remove of hash once it is cracked",
401 " --remove-timer=NUM Update input hash file each NUM seconds",
402 " --potfile-disable Do not write potfile",
403 " --potfile-path Specific path to potfile",
404 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
405 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
406 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
407 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
408 " --logfile-disable Disable the logfile",
409 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
410 " --veracrypt-keyfiles=FILE Keyfiles used, separate with comma",
411 " --veracrypt-pim=NUM VeraCrypt personal iterations multiplier",
412 "",
413 "* Resources:",
414 "",
415 " -b, --benchmark Run benchmark",
416 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
417 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
418 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
419 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
420 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
421 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
422 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
423 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
424 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
425 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
426 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
427 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
428 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
429 #ifdef HAVE_HWMON
430 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
431 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
432 #ifdef HAVE_ADL
433 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
434 #endif
435 #endif
436 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
437 "",
438 "* Distributed:",
439 "",
440 " -s, --skip=NUM Skip number of words",
441 " -l, --limit=NUM Limit number of words",
442 " --keyspace Show keyspace base:mod values and quit",
443 "",
444 "* Rules:",
445 "",
446 " -j, --rule-left=RULE Single rule applied to each word from left dict",
447 " -k, --rule-right=RULE Single rule applied to each word from right dict",
448 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
449 " -g, --generate-rules=NUM Generate NUM random rules",
450 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
451 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
452 " --generate-rules-seed=NUM Force RNG seed to NUM",
453 "",
454 "* Custom charsets:",
455 "",
456 " -1, --custom-charset1=CS User-defined charsets",
457 " -2, --custom-charset2=CS Example:",
458 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
459 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
460 "",
461 "* Increment:",
462 "",
463 " -i, --increment Enable increment mode",
464 " --increment-min=NUM Start incrementing at NUM",
465 " --increment-max=NUM Stop incrementing at NUM",
466 "",
467 "==========",
468 "References",
469 "==========",
470 "",
471 "* Workload Profile:",
472 "",
473 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
474 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
475 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
476 "",
477 "* OpenCL device-types:",
478 "",
479 " 1 = CPU devices",
480 " 2 = GPU devices",
481 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
482 "",
483 "* Outfile Formats:",
484 "",
485 " 1 = hash[:salt]",
486 " 2 = plain",
487 " 3 = hash[:salt]:plain",
488 " 4 = hex_plain",
489 " 5 = hash[:salt]:hex_plain",
490 " 6 = plain:hex_plain",
491 " 7 = hash[:salt]:plain:hex_plain",
492 " 8 = crackpos",
493 " 9 = hash[:salt]:crackpos",
494 " 10 = plain:crackpos",
495 " 11 = hash[:salt]:plain:crackpos",
496 " 12 = hex_plain:crackpos",
497 " 13 = hash[:salt]:hex_plain:crackpos",
498 " 14 = plain:hex_plain:crackpos",
499 " 15 = hash[:salt]:plain:hex_plain:crackpos",
500 "",
501 "* Debug mode output formats (for hybrid mode only, by using rules):",
502 "",
503 " 1 = save finding rule",
504 " 2 = save original word",
505 " 3 = save original word and finding rule",
506 " 4 = save original word, finding rule and modified plain",
507 "",
508 "* Built-in charsets:",
509 "",
510 " ?l = abcdefghijklmnopqrstuvwxyz",
511 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
512 " ?d = 0123456789",
513 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
514 " ?a = ?l?u?d?s",
515 " ?b = 0x00 - 0xff",
516 "",
517 "* Attack modes:",
518 "",
519 " 0 = Straight",
520 " 1 = Combination",
521 " 3 = Brute-force",
522 " 6 = Hybrid dict + mask",
523 " 7 = Hybrid mask + dict",
524 "",
525 "* Hash types:",
526 "",
527 "[[ Roll-your-own: Raw Hashes ]]",
528 "",
529 " 900 = MD4",
530 " 0 = MD5",
531 " 5100 = Half MD5",
532 " 100 = SHA1",
533 " 10800 = SHA-384",
534 " 1400 = SHA-256",
535 " 1700 = SHA-512",
536 " 5000 = SHA-3(Keccak)",
537 " 10100 = SipHash",
538 " 6000 = RipeMD160",
539 " 6100 = Whirlpool",
540 " 6900 = GOST R 34.11-94",
541 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
542 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
543 "",
544 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
545 "",
546 " 10 = md5($pass.$salt)",
547 " 20 = md5($salt.$pass)",
548 " 30 = md5(unicode($pass).$salt)",
549 " 40 = md5($salt.unicode($pass))",
550 " 3800 = md5($salt.$pass.$salt)",
551 " 3710 = md5($salt.md5($pass))",
552 " 2600 = md5(md5($pass)",
553 " 4300 = md5(strtoupper(md5($pass)))",
554 " 4400 = md5(sha1($pass))",
555 " 110 = sha1($pass.$salt)",
556 " 120 = sha1($salt.$pass)",
557 " 130 = sha1(unicode($pass).$salt)",
558 " 140 = sha1($salt.unicode($pass))",
559 " 4500 = sha1(sha1($pass)",
560 " 4700 = sha1(md5($pass))",
561 " 4900 = sha1($salt.$pass.$salt)",
562 " 1410 = sha256($pass.$salt)",
563 " 1420 = sha256($salt.$pass)",
564 " 1430 = sha256(unicode($pass).$salt)",
565 " 1440 = sha256($salt.unicode($pass))",
566 " 1710 = sha512($pass.$salt)",
567 " 1720 = sha512($salt.$pass)",
568 " 1730 = sha512(unicode($pass).$salt)",
569 " 1740 = sha512($salt.unicode($pass))",
570 "",
571 "[[ Roll-your-own: Authenticated Hashes ]]",
572 "",
573 " 50 = HMAC-MD5 (key = $pass)",
574 " 60 = HMAC-MD5 (key = $salt)",
575 " 150 = HMAC-SHA1 (key = $pass)",
576 " 160 = HMAC-SHA1 (key = $salt)",
577 " 1450 = HMAC-SHA256 (key = $pass)",
578 " 1460 = HMAC-SHA256 (key = $salt)",
579 " 1750 = HMAC-SHA512 (key = $pass)",
580 " 1760 = HMAC-SHA512 (key = $salt)",
581 "",
582 "[[ Generic KDF ]]",
583 "",
584 " 400 = phpass",
585 " 8900 = scrypt",
586 " 11900 = PBKDF2-HMAC-MD5",
587 " 12000 = PBKDF2-HMAC-SHA1",
588 " 10900 = PBKDF2-HMAC-SHA256",
589 " 12100 = PBKDF2-HMAC-SHA512",
590 "",
591 "[[ Network protocols, Challenge-Response ]]",
592 "",
593 " 23 = Skype",
594 " 2500 = WPA/WPA2",
595 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
596 " 5300 = IKE-PSK MD5",
597 " 5400 = IKE-PSK SHA1",
598 " 5500 = NetNTLMv1",
599 " 5500 = NetNTLMv1 + ESS",
600 " 5600 = NetNTLMv2",
601 " 7300 = IPMI2 RAKP HMAC-SHA1",
602 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
603 " 8300 = DNSSEC (NSEC3)",
604 " 10200 = Cram MD5",
605 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
606 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
607 " 11400 = SIP digest authentication (MD5)",
608 " 13100 = Kerberos 5 TGS-REP etype 23",
609 "",
610 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
611 "",
612 " 121 = SMF (Simple Machines Forum)",
613 " 400 = phpBB3",
614 " 2611 = vBulletin < v3.8.5",
615 " 2711 = vBulletin > v3.8.5",
616 " 2811 = MyBB",
617 " 2811 = IPB (Invison Power Board)",
618 " 8400 = WBB3 (Woltlab Burning Board)",
619 " 11 = Joomla < 2.5.18",
620 " 400 = Joomla > 2.5.18",
621 " 400 = Wordpress",
622 " 2612 = PHPS",
623 " 7900 = Drupal7",
624 " 21 = osCommerce",
625 " 21 = xt:Commerce",
626 " 11000 = PrestaShop",
627 " 124 = Django (SHA-1)",
628 " 10000 = Django (PBKDF2-SHA256)",
629 " 3711 = Mediawiki B type",
630 " 7600 = Redmine",
631 "",
632 "[[ Database Server ]]",
633 "",
634 " 12 = PostgreSQL",
635 " 131 = MSSQL(2000)",
636 " 132 = MSSQL(2005)",
637 " 1731 = MSSQL(2012)",
638 " 1731 = MSSQL(2014)",
639 " 200 = MySQL323",
640 " 300 = MySQL4.1/MySQL5",
641 " 3100 = Oracle H: Type (Oracle 7+)",
642 " 112 = Oracle S: Type (Oracle 11+)",
643 " 12300 = Oracle T: Type (Oracle 12+)",
644 " 8000 = Sybase ASE",
645 "",
646 "[[ HTTP, SMTP, LDAP Server ]]",
647 "",
648 " 141 = EPiServer 6.x < v4",
649 " 1441 = EPiServer 6.x > v4",
650 " 1600 = Apache $apr1$",
651 " 12600 = ColdFusion 10+",
652 " 1421 = hMailServer",
653 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
654 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
655 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
656 "",
657 "[[ Checksums ]]",
658 "",
659 " 11500 = CRC32",
660 "",
661 "[[ Operating-Systems ]]",
662 "",
663 " 3000 = LM",
664 " 1000 = NTLM",
665 " 1100 = Domain Cached Credentials (DCC), MS Cache",
666 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
667 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
668 " 1500 = descrypt, DES(Unix), Traditional DES",
669 " 12400 = BSDiCrypt, Extended DES",
670 " 500 = md5crypt $1$, MD5(Unix)",
671 " 3200 = bcrypt $2*$, Blowfish(Unix)",
672 " 7400 = sha256crypt $5$, SHA256(Unix)",
673 " 1800 = sha512crypt $6$, SHA512(Unix)",
674 " 122 = OSX v10.4",
675 " 122 = OSX v10.5",
676 " 122 = OSX v10.6",
677 " 1722 = OSX v10.7",
678 " 7100 = OSX v10.8",
679 " 7100 = OSX v10.9",
680 " 7100 = OSX v10.10",
681 " 6300 = AIX {smd5}",
682 " 6700 = AIX {ssha1}",
683 " 6400 = AIX {ssha256}",
684 " 6500 = AIX {ssha512}",
685 " 2400 = Cisco-PIX",
686 " 2410 = Cisco-ASA",
687 " 500 = Cisco-IOS $1$",
688 " 5700 = Cisco-IOS $4$",
689 " 9200 = Cisco-IOS $8$",
690 " 9300 = Cisco-IOS $9$",
691 " 22 = Juniper Netscreen/SSG (ScreenOS)",
692 " 501 = Juniper IVE",
693 " 5800 = Android PIN",
694 " 8100 = Citrix Netscaler",
695 " 8500 = RACF",
696 " 7200 = GRUB 2",
697 " 9900 = Radmin2",
698 " 125 = ArubaOS",
699 "",
700 "[[ Enterprise Application Software (EAS) ]]",
701 "",
702 " 7700 = SAP CODVN B (BCODE)",
703 " 7800 = SAP CODVN F/G (PASSCODE)",
704 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
705 " 8600 = Lotus Notes/Domino 5",
706 " 8700 = Lotus Notes/Domino 6",
707 " 9100 = Lotus Notes/Domino 8",
708 " 133 = PeopleSoft",
709 " 13500 = PeopleSoft Token",
710 "",
711 "[[ Archives ]]",
712 "",
713 " 11600 = 7-Zip",
714 " 12500 = RAR3-hp",
715 " 13000 = RAR5",
716 " 13200 = AxCrypt",
717 " 13300 = AxCrypt in memory SHA1",
718 " 13600 = WinZip",
719 "",
720 "[[ Full-Disk encryptions (FDE) ]]",
721 "",
722 " 62XY = TrueCrypt",
723 " X = 1 = PBKDF2-HMAC-RipeMD160",
724 " X = 2 = PBKDF2-HMAC-SHA512",
725 " X = 3 = PBKDF2-HMAC-Whirlpool",
726 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
727 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
728 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
729 " Y = 3 = XTS 1536 bit (Ciphers: All)",
730 " 8800 = Android FDE < v4.3",
731 " 12900 = Android FDE (Samsung DEK)",
732 " 12200 = eCryptfs",
733 " 137XY = VeraCrypt",
734 " X = 1 = PBKDF2-HMAC-RipeMD160",
735 " X = 2 = PBKDF2-HMAC-SHA512",
736 " X = 3 = PBKDF2-HMAC-Whirlpool",
737 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
738 " X = 5 = PBKDF2-HMAC-SHA256",
739 " X = 6 = PBKDF2-HMAC-SHA256 + boot-mode",
740 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
741 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
742 " Y = 3 = XTS 1536 bit (Ciphers: All)",
743 "",
744 "[[ Documents ]]",
745 "",
746 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
747 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
748 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
749 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
750 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
751 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
752 " 9400 = MS Office 2007",
753 " 9500 = MS Office 2010",
754 " 9600 = MS Office 2013",
755 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
756 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
757 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
758 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
759 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
760 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
761 "",
762 "[[ Password Managers ]]",
763 "",
764 " 9000 = Password Safe v2",
765 " 5200 = Password Safe v3",
766 " 6800 = Lastpass",
767 " 6600 = 1Password, agilekeychain",
768 " 8200 = 1Password, cloudkeychain",
769 " 11300 = Bitcoin/Litecoin wallet.dat",
770 " 12700 = Blockchain, My Wallet",
771 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
772 "",
773 NULL
774 };
775
776 /**
777 * hashcat specific functions
778 */
779
780 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
781 {
782 int exec_pos = (int) device_param->exec_pos - last_num_entries;
783
784 if (exec_pos < 0) exec_pos += EXEC_CACHE;
785
786 double exec_ms_sum = 0;
787
788 int exec_ms_cnt = 0;
789
790 for (int i = 0; i < last_num_entries; i++)
791 {
792 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
793
794 if (exec_ms)
795 {
796 exec_ms_sum += exec_ms;
797
798 exec_ms_cnt++;
799 }
800 }
801
802 if (exec_ms_cnt == 0) return 0;
803
804 return exec_ms_sum / exec_ms_cnt;
805 }
806
807 void status_display_automat ()
808 {
809 FILE *out = stdout;
810
811 fprintf (out, "STATUS\t%u\t", data.devices_status);
812
813 /**
814 * speed new
815 */
816
817 fprintf (out, "SPEED\t");
818
819 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
820 {
821 hc_device_param_t *device_param = &data.devices_param[device_id];
822
823 if (device_param->skipped) continue;
824
825 u64 speed_cnt = 0;
826 double speed_ms = 0;
827
828 for (int i = 0; i < SPEED_CACHE; i++)
829 {
830 speed_cnt += device_param->speed_cnt[i];
831 speed_ms += device_param->speed_ms[i];
832 }
833
834 speed_cnt /= SPEED_CACHE;
835 speed_ms /= SPEED_CACHE;
836
837 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
838 }
839
840 /**
841 * exec time
842 */
843
844 fprintf (out, "EXEC_RUNTIME\t");
845
846 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
847 {
848 hc_device_param_t *device_param = &data.devices_param[device_id];
849
850 if (device_param->skipped) continue;
851
852 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
853
854 fprintf (out, "%f\t", exec_ms_avg);
855 }
856
857 /**
858 * words_cur
859 */
860
861 u64 words_cur = get_lowest_words_done ();
862
863 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
864
865 /**
866 * counter
867 */
868
869 u64 progress_total = data.words_cnt * data.salts_cnt;
870
871 u64 all_done = 0;
872 u64 all_rejected = 0;
873 u64 all_restored = 0;
874
875 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
876 {
877 all_done += data.words_progress_done[salt_pos];
878 all_rejected += data.words_progress_rejected[salt_pos];
879 all_restored += data.words_progress_restored[salt_pos];
880 }
881
882 u64 progress_cur = all_restored + all_done + all_rejected;
883 u64 progress_end = progress_total;
884
885 u64 progress_skip = 0;
886
887 if (data.skip)
888 {
889 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
890
891 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
892 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
893 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
894 }
895
896 if (data.limit)
897 {
898 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
899
900 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
901 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
902 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
903 }
904
905 u64 progress_cur_relative_skip = progress_cur - progress_skip;
906 u64 progress_end_relative_skip = progress_end - progress_skip;
907
908 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
909
910 /**
911 * cracks
912 */
913
914 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
915 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
916
917 /**
918 * temperature
919 */
920
921 #ifdef HAVE_HWMON
922 if (data.gpu_temp_disable == 0)
923 {
924 fprintf (out, "TEMP\t");
925
926 hc_thread_mutex_lock (mux_adl);
927
928 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
929 {
930 hc_device_param_t *device_param = &data.devices_param[device_id];
931
932 if (device_param->skipped) continue;
933
934 int temp = hm_get_temperature_with_device_id (device_id);
935
936 fprintf (out, "%d\t", temp);
937 }
938
939 hc_thread_mutex_unlock (mux_adl);
940 }
941 #endif // HAVE_HWMON
942
943 /**
944 * flush
945 */
946
947 #ifdef _WIN
948 fputc ('\r', out);
949 fputc ('\n', out);
950 #endif
951
952 #ifdef _POSIX
953 fputc ('\n', out);
954 #endif
955
956 fflush (out);
957 }
958
959 void status_display ()
960 {
961 if (data.devices_status == STATUS_INIT) return;
962 if (data.devices_status == STATUS_STARTING) return;
963 if (data.devices_status == STATUS_BYPASS) return;
964
965 if (data.status_automat == 1)
966 {
967 status_display_automat ();
968
969 return;
970 }
971
972 char tmp_buf[1000] = { 0 };
973
974 uint tmp_len = 0;
975
976 log_info ("Session.Name...: %s", data.session);
977
978 char *status_type = strstatus (data.devices_status);
979
980 uint hash_mode = data.hash_mode;
981
982 char *hash_type = strhashtype (hash_mode); // not a bug
983
984 log_info ("Status.........: %s", status_type);
985
986 /**
987 * show rules
988 */
989
990 if (data.rp_files_cnt)
991 {
992 uint i;
993
994 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
995 {
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
997 }
998
999 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
1000
1001 log_info ("Rules.Type.....: %s", tmp_buf);
1002
1003 tmp_len = 0;
1004 }
1005
1006 if (data.rp_gen)
1007 {
1008 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
1009
1010 if (data.rp_gen_seed)
1011 {
1012 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
1013 }
1014 }
1015
1016 /**
1017 * show input
1018 */
1019
1020 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1021 {
1022 if (data.wordlist_mode == WL_MODE_FILE)
1023 {
1024 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1025 }
1026 else if (data.wordlist_mode == WL_MODE_STDIN)
1027 {
1028 log_info ("Input.Mode.....: Pipe");
1029 }
1030 }
1031 else if (data.attack_mode == ATTACK_MODE_COMBI)
1032 {
1033 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1034 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_BF)
1037 {
1038 char *mask = data.mask;
1039
1040 if (mask != NULL)
1041 {
1042 uint mask_len = data.css_cnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1045
1046 if (mask_len > 0)
1047 {
1048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1049 {
1050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1051 {
1052 mask_len -= data.salts_buf[0].salt_len;
1053 }
1054 }
1055
1056 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1057
1058 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1059 }
1060
1061 if (data.maskcnt > 1)
1062 {
1063 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1064
1065 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1066 }
1067
1068 log_info ("Input.Mode.....: %s", tmp_buf);
1069 }
1070
1071 tmp_len = 0;
1072 }
1073 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1074 {
1075 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1076 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1077 }
1078 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1079 {
1080 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1081 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1082 }
1083
1084 if (data.digests_cnt == 1)
1085 {
1086 if (data.hash_mode == 2500)
1087 {
1088 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1089
1090 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1091 (char *) data.salts_buf[0].salt_buf,
1092 wpa->orig_mac1[0],
1093 wpa->orig_mac1[1],
1094 wpa->orig_mac1[2],
1095 wpa->orig_mac1[3],
1096 wpa->orig_mac1[4],
1097 wpa->orig_mac1[5],
1098 wpa->orig_mac2[0],
1099 wpa->orig_mac2[1],
1100 wpa->orig_mac2[2],
1101 wpa->orig_mac2[3],
1102 wpa->orig_mac2[4],
1103 wpa->orig_mac2[5]);
1104 }
1105 else if (data.hash_mode == 5200)
1106 {
1107 log_info ("Hash.Target....: File (%s)", data.hashfile);
1108 }
1109 else if (data.hash_mode == 9000)
1110 {
1111 log_info ("Hash.Target....: File (%s)", data.hashfile);
1112 }
1113 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1114 {
1115 log_info ("Hash.Target....: File (%s)", data.hashfile);
1116 }
1117 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 else
1122 {
1123 char out_buf[HCBUFSIZ] = { 0 };
1124
1125 ascii_digest (out_buf, 0, 0);
1126
1127 // limit length
1128 if (strlen (out_buf) > 40)
1129 {
1130 out_buf[41] = '.';
1131 out_buf[42] = '.';
1132 out_buf[43] = '.';
1133 out_buf[44] = 0;
1134 }
1135
1136 log_info ("Hash.Target....: %s", out_buf);
1137 }
1138 }
1139 else
1140 {
1141 if (data.hash_mode == 3000)
1142 {
1143 char out_buf1[32] = { 0 };
1144 char out_buf2[32] = { 0 };
1145
1146 ascii_digest (out_buf1, 0, 0);
1147 ascii_digest (out_buf2, 0, 1);
1148
1149 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1150 }
1151 else
1152 {
1153 log_info ("Hash.Target....: File (%s)", data.hashfile);
1154 }
1155 }
1156
1157 log_info ("Hash.Type......: %s", hash_type);
1158
1159 /**
1160 * speed new
1161 */
1162
1163 u64 speed_cnt[DEVICES_MAX] = { 0 };
1164 double speed_ms[DEVICES_MAX] = { 0 };
1165
1166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1167 {
1168 hc_device_param_t *device_param = &data.devices_param[device_id];
1169
1170 if (device_param->skipped) continue;
1171
1172 speed_cnt[device_id] = 0;
1173 speed_ms[device_id] = 0;
1174
1175 for (int i = 0; i < SPEED_CACHE; i++)
1176 {
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 double hashes_all_ms = 0;
1186
1187 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 double ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 double ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 double ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 u64 progress_total = data.words_cnt * data.salts_cnt;
1297
1298 u64 all_done = 0;
1299 u64 all_rejected = 0;
1300 u64 all_restored = 0;
1301
1302 u64 progress_noneed = 0;
1303
1304 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1305 {
1306 all_done += data.words_progress_done[salt_pos];
1307 all_rejected += data.words_progress_rejected[salt_pos];
1308 all_restored += data.words_progress_restored[salt_pos];
1309
1310 // Important for ETA only
1311
1312 if (data.salts_shown[salt_pos] == 1)
1313 {
1314 const u64 all = data.words_progress_done[salt_pos]
1315 + data.words_progress_rejected[salt_pos]
1316 + data.words_progress_restored[salt_pos];
1317
1318 const u64 left = data.words_cnt - all;
1319
1320 progress_noneed += left;
1321 }
1322 }
1323
1324 u64 progress_cur = all_restored + all_done + all_rejected;
1325 u64 progress_end = progress_total;
1326
1327 u64 progress_skip = 0;
1328
1329 if (data.skip)
1330 {
1331 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1336 }
1337
1338 if (data.limit)
1339 {
1340 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1341
1342 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1344 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1345 }
1346
1347 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1348 u64 progress_end_relative_skip = progress_end - progress_skip;
1349
1350 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1351 {
1352 if (data.devices_status != STATUS_CRACKED)
1353 {
1354 #ifdef WIN
1355 __time64_t sec_etc = 0;
1356 #else
1357 time_t sec_etc = 0;
1358 #endif
1359
1360 if (hashes_all_ms)
1361 {
1362 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1363
1364 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1365
1366 sec_etc = ms_left / 1000;
1367 }
1368
1369 if (sec_etc == 0)
1370 {
1371 //log_info ("Time.Estimated.: 0 secs");
1372 }
1373 else if ((u64) sec_etc > ETC_MAX)
1374 {
1375 log_info ("Time.Estimated.: > 10 Years");
1376 }
1377 else
1378 {
1379 char display_etc[32] = { 0 };
1380
1381 struct tm tm_etc;
1382
1383 struct tm *tmp = NULL;
1384
1385 #ifdef WIN
1386
1387 tmp = _gmtime64 (&sec_etc);
1388
1389 #else
1390
1391 tmp = gmtime (&sec_etc);
1392
1393 #endif
1394
1395 if (tmp != NULL)
1396 {
1397 memset (&tm_etc, 0, sizeof (tm_etc));
1398
1399 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1400
1401 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1402
1403 time_t now;
1404
1405 time (&now);
1406
1407 now += sec_etc;
1408
1409 char *etc = ctime (&now);
1410
1411 size_t etc_len = strlen (etc);
1412
1413 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1414 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1415
1416 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1417 }
1418 }
1419 }
1420 }
1421
1422 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1423 {
1424 hc_device_param_t *device_param = &data.devices_param[device_id];
1425
1426 if (device_param->skipped) continue;
1427
1428 char display_dev_cur[16] = { 0 };
1429
1430 strncpy (display_dev_cur, "0.00", 4);
1431
1432 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1433
1434 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1435 }
1436
1437 char display_all_cur[16] = { 0 };
1438
1439 strncpy (display_all_cur, "0.00", 4);
1440
1441 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1442
1443 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1444
1445 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1446 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1447
1448 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1449
1450 // crack-per-time
1451
1452 if (data.digests_cnt > 100)
1453 {
1454 time_t now = time (NULL);
1455
1456 int cpt_cur_min = 0;
1457 int cpt_cur_hour = 0;
1458 int cpt_cur_day = 0;
1459
1460 for (int i = 0; i < CPT_BUF; i++)
1461 {
1462 const uint cracked = data.cpt_buf[i].cracked;
1463 const time_t timestamp = data.cpt_buf[i].timestamp;
1464
1465 if ((timestamp + 60) > now)
1466 {
1467 cpt_cur_min += cracked;
1468 }
1469
1470 if ((timestamp + 3600) > now)
1471 {
1472 cpt_cur_hour += cracked;
1473 }
1474
1475 if ((timestamp + 86400) > now)
1476 {
1477 cpt_cur_day += cracked;
1478 }
1479 }
1480
1481 double ms_real = ms_running - ms_paused;
1482
1483 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1484 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1485 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1486
1487 if ((data.cpt_start + 86400) < now)
1488 {
1489 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1490 cpt_cur_min,
1491 cpt_cur_hour,
1492 cpt_cur_day,
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 else if ((data.cpt_start + 3600) < now)
1498 {
1499 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1500 cpt_cur_min,
1501 cpt_cur_hour,
1502 cpt_avg_min,
1503 cpt_avg_hour,
1504 cpt_avg_day);
1505 }
1506 else if ((data.cpt_start + 60) < now)
1507 {
1508 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1509 cpt_cur_min,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else
1515 {
1516 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_avg_min,
1518 cpt_avg_hour,
1519 cpt_avg_day);
1520 }
1521 }
1522
1523 // Restore point
1524
1525 u64 restore_point = get_lowest_words_done ();
1526
1527 u64 restore_total = data.words_base;
1528
1529 float percent_restore = 0;
1530
1531 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1532
1533 if (progress_end_relative_skip)
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1538 float percent_rejected = 0.0;
1539
1540 if (progress_cur)
1541 {
1542 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1543 }
1544
1545 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1546 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1547
1548 if (data.restore_disable == 0)
1549 {
1550 if (percent_finished != 1)
1551 {
1552 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1553 }
1554 }
1555 }
1556 }
1557 else
1558 {
1559 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1560 {
1561 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563
1564 if (data.restore_disable == 0)
1565 {
1566 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567 }
1568 }
1569 else
1570 {
1571 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1572 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1573
1574 // --restore not allowed if stdin is used -- really? why?
1575
1576 //if (data.restore_disable == 0)
1577 //{
1578 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1579 //}
1580 }
1581 }
1582
1583 #ifdef HAVE_HWMON
1584 if (data.gpu_temp_disable == 0)
1585 {
1586 hc_thread_mutex_lock (mux_adl);
1587
1588 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1589 {
1590 hc_device_param_t *device_param = &data.devices_param[device_id];
1591
1592 if (device_param->skipped) continue;
1593
1594 #define HM_STR_BUF_SIZE 255
1595
1596 if (data.hm_device[device_id].fan_supported == 1)
1597 {
1598 char utilization[HM_STR_BUF_SIZE] = { 0 };
1599 char temperature[HM_STR_BUF_SIZE] = { 0 };
1600 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1601
1602 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1603 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1604
1605 if (device_param->vendor_id == VENDOR_ID_AMD)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609 else if (device_param->vendor_id == VENDOR_ID_NV)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613
1614 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1615 }
1616 else
1617 {
1618 char utilization[HM_STR_BUF_SIZE] = { 0 };
1619 char temperature[HM_STR_BUF_SIZE] = { 0 };
1620
1621 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1622 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1623
1624 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1625 }
1626 }
1627
1628 hc_thread_mutex_unlock (mux_adl);
1629 }
1630 #endif // HAVE_HWMON
1631 }
1632
1633 static void status_benchmark_automat ()
1634 {
1635 u64 speed_cnt[DEVICES_MAX] = { 0 };
1636 double speed_ms[DEVICES_MAX] = { 0 };
1637
1638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1639 {
1640 hc_device_param_t *device_param = &data.devices_param[device_id];
1641
1642 if (device_param->skipped) continue;
1643
1644 speed_cnt[device_id] = device_param->speed_cnt[0];
1645 speed_ms[device_id] = device_param->speed_ms[0];
1646 }
1647
1648 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1649
1650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1651 {
1652 hc_device_param_t *device_param = &data.devices_param[device_id];
1653
1654 if (device_param->skipped) continue;
1655
1656 hashes_dev_ms[device_id] = 0;
1657
1658 if (speed_ms[device_id])
1659 {
1660 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1661 }
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1671 }
1672 }
1673
1674 static void status_benchmark ()
1675 {
1676 if (data.devices_status == STATUS_INIT) return;
1677 if (data.devices_status == STATUS_STARTING) return;
1678 if (data.devices_status == STATUS_BYPASS) return;
1679
1680 if (data.status_automat == 1)
1681 {
1682 status_benchmark_automat ();
1683
1684 return;
1685 }
1686
1687 u64 speed_cnt[DEVICES_MAX] = { 0 };
1688 double speed_ms[DEVICES_MAX] = { 0 };
1689
1690 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1691 {
1692 hc_device_param_t *device_param = &data.devices_param[device_id];
1693
1694 if (device_param->skipped) continue;
1695
1696 speed_cnt[device_id] = device_param->speed_cnt[0];
1697 speed_ms[device_id] = device_param->speed_ms[0];
1698 }
1699
1700 double hashes_all_ms = 0;
1701
1702 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 hashes_dev_ms[device_id] = 0;
1711
1712 if (speed_ms[device_id])
1713 {
1714 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1715
1716 hashes_all_ms += hashes_dev_ms[device_id];
1717 }
1718 }
1719
1720 /**
1721 * exec time
1722 */
1723
1724 double exec_all_ms[DEVICES_MAX] = { 0 };
1725
1726 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1727 {
1728 hc_device_param_t *device_param = &data.devices_param[device_id];
1729
1730 if (device_param->skipped) continue;
1731
1732 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1733
1734 exec_all_ms[device_id] = exec_ms_avg;
1735 }
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 char display_dev_cur[16] = { 0 };
1744
1745 strncpy (display_dev_cur, "0.00", 4);
1746
1747 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1748
1749 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1750 }
1751
1752 char display_all_cur[16] = { 0 };
1753
1754 strncpy (display_all_cur, "0.00", 4);
1755
1756 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1757
1758 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1759 }
1760
1761 /**
1762 * hashcat -only- functions
1763 */
1764
1765 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1766 {
1767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1768 {
1769 if (attack_kern == ATTACK_KERN_STRAIGHT)
1770 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1771 else if (attack_kern == ATTACK_KERN_COMBI)
1772 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1773 else if (attack_kern == ATTACK_KERN_BF)
1774 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1775 }
1776 else
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1778 }
1779
1780 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1781 {
1782 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1783 {
1784 if (attack_kern == ATTACK_KERN_STRAIGHT)
1785 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1786 else if (attack_kern == ATTACK_KERN_COMBI)
1787 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1788 else if (attack_kern == ATTACK_KERN_BF)
1789 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1790 }
1791 else
1792 {
1793 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1794 }
1795 }
1796
1797 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1798 {
1799 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1802 }
1803 else
1804 {
1805 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1806 }
1807 }
1808
1809 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1810 {
1811 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1812 {
1813 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1814 }
1815 else
1816 {
1817 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1818 }
1819 }
1820
1821 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1822 {
1823 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1824 }
1825
1826 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1827 {
1828 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1829 }
1830
1831 static uint convert_from_hex (char *line_buf, const uint line_len)
1832 {
1833 if (line_len & 1) return (line_len); // not in hex
1834
1835 if (data.hex_wordlist == 1)
1836 {
1837 uint i;
1838 uint j;
1839
1840 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1841 {
1842 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1843 }
1844
1845 memset (line_buf + i, 0, line_len - i);
1846
1847 return (i);
1848 }
1849 else if (line_len >= 6) // $HEX[] = 6
1850 {
1851 if (line_buf[0] != '$') return (line_len);
1852 if (line_buf[1] != 'H') return (line_len);
1853 if (line_buf[2] != 'E') return (line_len);
1854 if (line_buf[3] != 'X') return (line_len);
1855 if (line_buf[4] != '[') return (line_len);
1856 if (line_buf[line_len - 1] != ']') return (line_len);
1857
1858 uint i;
1859 uint j;
1860
1861 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1862 {
1863 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1864 }
1865
1866 memset (line_buf + i, 0, line_len - i);
1867
1868 return (i);
1869 }
1870
1871 return (line_len);
1872 }
1873
1874 static void clear_prompt ()
1875 {
1876 fputc ('\r', stdout);
1877
1878 for (size_t i = 0; i < strlen (PROMPT); i++)
1879 {
1880 fputc (' ', stdout);
1881 }
1882
1883 fputc ('\r', stdout);
1884
1885 fflush (stdout);
1886 }
1887
1888 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1889 {
1890 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1891 }
1892
1893 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
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 ascii_digest (out_buf, salt_pos, digest_pos);
1913
1914 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1915
1916 // plain
1917
1918 plain_t plain;
1919
1920 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1921
1922 uint gidvid = plain.gidvid;
1923 uint il_pos = plain.il_pos;
1924
1925 u64 crackpos = device_param->words_off;
1926
1927 uint plain_buf[16] = { 0 };
1928
1929 u8 *plain_ptr = (u8 *) plain_buf;
1930 unsigned int plain_len = 0;
1931
1932 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1933 {
1934 u64 gidd = gidvid;
1935 u64 gidm = 0;
1936
1937 pw_t pw;
1938
1939 gidd_to_pw_t (device_param, gidd, &pw);
1940
1941 for (int i = 0, j = gidm; i < 16; i++, j++)
1942 {
1943 plain_buf[i] = pw.i[j];
1944 }
1945
1946 plain_len = pw.pw_len;
1947
1948 const uint off = device_param->innerloop_pos + il_pos;
1949
1950 if (debug_mode > 0)
1951 {
1952 debug_rule_len = 0;
1953
1954 // save rule
1955 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1956 {
1957 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1958
1959 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1960 }
1961
1962 // save plain
1963 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1964 {
1965 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1966
1967 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1968
1969 debug_plain_len = plain_len;
1970 }
1971 }
1972
1973 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1974
1975 crackpos += gidvid;
1976 crackpos *= data.kernel_rules_cnt;
1977 crackpos += device_param->innerloop_pos + il_pos;
1978
1979 if (plain_len > data.pw_max) plain_len = data.pw_max;
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_COMBI)
1982 {
1983 u64 gidd = gidvid;
1984 u64 gidm = 0;
1985
1986 pw_t pw;
1987
1988 gidd_to_pw_t (device_param, gidd, &pw);
1989
1990 for (int i = 0, j = gidm; i < 16; i++, j++)
1991 {
1992 plain_buf[i] = pw.i[j];
1993 }
1994
1995 plain_len = pw.pw_len;
1996
1997 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1998 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1999
2000 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2001 {
2002 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2003 }
2004 else
2005 {
2006 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2007
2008 memcpy (plain_ptr, comb_buf, comb_len);
2009 }
2010
2011 plain_len += comb_len;
2012
2013 crackpos += gidvid;
2014 crackpos *= data.combs_cnt;
2015 crackpos += device_param->innerloop_pos + il_pos;
2016
2017 if (data.pw_max != PW_DICTMAX1)
2018 {
2019 if (plain_len > data.pw_max) plain_len = data.pw_max;
2020 }
2021 }
2022 else if (data.attack_mode == ATTACK_MODE_BF)
2023 {
2024 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2025 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2026
2027 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2028 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2029
2030 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2031 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2032
2033 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2034 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2035
2036 plain_len = data.css_cnt;
2037
2038 crackpos += gidvid;
2039 crackpos *= data.bfs_cnt;
2040 crackpos += device_param->innerloop_pos + il_pos;
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2064
2065 plain_len += start + stop;
2066
2067 crackpos += gidvid;
2068 crackpos *= data.combs_cnt;
2069 crackpos += device_param->innerloop_pos + il_pos;
2070
2071 if (data.pw_max != PW_DICTMAX1)
2072 {
2073 if (plain_len > data.pw_max) plain_len = data.pw_max;
2074 }
2075 }
2076 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2077 {
2078 u64 gidd = gidvid;
2079 u64 gidm = 0;
2080
2081 pw_t pw;
2082
2083 gidd_to_pw_t (device_param, gidd, &pw);
2084
2085 for (int i = 0, j = gidm; i < 16; i++, j++)
2086 {
2087 plain_buf[i] = pw.i[j];
2088 }
2089
2090 plain_len = pw.pw_len;
2091
2092 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2093
2094 uint start = 0;
2095 uint stop = device_param->kernel_params_mp_buf32[4];
2096
2097 memmove (plain_ptr + stop, plain_ptr, plain_len);
2098
2099 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2100
2101 plain_len += start + stop;
2102
2103 crackpos += gidvid;
2104 crackpos *= data.combs_cnt;
2105 crackpos += device_param->innerloop_pos + il_pos;
2106
2107 if (data.pw_max != PW_DICTMAX1)
2108 {
2109 if (plain_len > data.pw_max) plain_len = data.pw_max;
2110 }
2111 }
2112
2113 if (data.attack_mode == ATTACK_MODE_BF)
2114 {
2115 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2116 {
2117 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2118 {
2119 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2120 {
2121 plain_len = plain_len - data.salts_buf[0].salt_len;
2122 }
2123 }
2124
2125 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2126 {
2127 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2128 {
2129 plain_ptr[j] = plain_ptr[i];
2130 }
2131
2132 plain_len = plain_len / 2;
2133 }
2134 }
2135 }
2136
2137 // if enabled, update also the potfile
2138
2139 if (pot_fp)
2140 {
2141 lock_file (pot_fp);
2142
2143 fprintf (pot_fp, "%s:", out_buf);
2144
2145 format_plain (pot_fp, plain_ptr, plain_len, 1);
2146
2147 fputc ('\n', pot_fp);
2148
2149 fflush (pot_fp);
2150
2151 unlock_file (pot_fp);
2152 }
2153
2154 // outfile
2155
2156 FILE *out_fp = NULL;
2157
2158 if (outfile != NULL)
2159 {
2160 if ((out_fp = fopen (outfile, "ab")) == NULL)
2161 {
2162 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2163
2164 out_fp = stdout;
2165 }
2166 lock_file (out_fp);
2167 }
2168 else
2169 {
2170 out_fp = stdout;
2171
2172 if (quiet == 0) clear_prompt ();
2173 }
2174
2175 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2176
2177 if (outfile != NULL)
2178 {
2179 if (out_fp != stdout)
2180 {
2181 fclose (out_fp);
2182 }
2183 }
2184 else
2185 {
2186 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2187 {
2188 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2189 {
2190 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2191 if (quiet == 0) fflush (stdout);
2192 }
2193 }
2194 }
2195
2196 // loopback
2197
2198 if (loopback)
2199 {
2200 char *loopback_file = data.loopback_file;
2201
2202 FILE *fb_fp = NULL;
2203
2204 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2205 {
2206 lock_file (fb_fp);
2207
2208 format_plain (fb_fp, plain_ptr, plain_len, 1);
2209
2210 fputc ('\n', fb_fp);
2211
2212 fclose (fb_fp);
2213 }
2214 }
2215
2216 // (rule) debug mode
2217
2218 // the next check implies that:
2219 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2220 // - debug_mode > 0
2221
2222 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2223 {
2224 if (debug_rule_len < 0) debug_rule_len = 0;
2225
2226 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2227
2228 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2229
2230 if ((quiet == 0) && (debug_file == NULL))
2231 {
2232 fprintf (stdout, "%s", PROMPT);
2233
2234 fflush (stdout);
2235 }
2236 }
2237 }
2238
2239 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2240 {
2241 salt_t *salt_buf = &data.salts_buf[salt_pos];
2242
2243 int found = 0;
2244
2245 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2246
2247 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2248
2249 if (found == 1)
2250 {
2251 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2252
2253 log_info_nn ("");
2254
2255 hc_clEnqueueReadBuffer (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);
2256
2257 uint cpt_cracked = 0;
2258
2259 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2260 {
2261 uint idx = salt_buf->digests_offset + digest_pos;
2262
2263 if (data.digests_shown_tmp[idx] == 0) continue;
2264
2265 if (data.digests_shown[idx] == 1) continue;
2266
2267 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2268 {
2269 data.digests_shown[idx] = 1;
2270
2271 data.digests_done++;
2272
2273 cpt_cracked++;
2274
2275 salt_buf->digests_done++;
2276
2277 if (salt_buf->digests_done == salt_buf->digests_cnt)
2278 {
2279 data.salts_shown[salt_pos] = 1;
2280
2281 data.salts_done++;
2282 }
2283 }
2284
2285 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2286
2287 check_hash (device_param, salt_pos, digest_pos);
2288 }
2289
2290 if (cpt_cracked > 0)
2291 {
2292 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2293 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2294
2295 data.cpt_pos++;
2296
2297 data.cpt_total += cpt_cracked;
2298
2299 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2300 }
2301
2302 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2303 {
2304 // we need to reset cracked state on the device
2305 // otherwise host thinks again and again the hash was cracked
2306 // and returns invalid password each time
2307
2308 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2309
2310 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);
2311 }
2312
2313 memset (device_param->result, 0, device_param->size_results);
2314
2315 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2316 }
2317 }
2318
2319 static void save_hash ()
2320 {
2321 char *hashfile = data.hashfile;
2322
2323 char new_hashfile[256] = { 0 };
2324 char old_hashfile[256] = { 0 };
2325
2326 snprintf (new_hashfile, 255, "%s.new", hashfile);
2327 snprintf (old_hashfile, 255, "%s.old", hashfile);
2328
2329 unlink (new_hashfile);
2330
2331 char separator = data.separator;
2332
2333 FILE *fp = fopen (new_hashfile, "wb");
2334
2335 if (fp == NULL)
2336 {
2337 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2338
2339 exit (-1);
2340 }
2341
2342 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2343 {
2344 if (data.salts_shown[salt_pos] == 1) continue;
2345
2346 salt_t *salt_buf = &data.salts_buf[salt_pos];
2347
2348 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2349 {
2350 uint idx = salt_buf->digests_offset + digest_pos;
2351
2352 if (data.digests_shown[idx] == 1) continue;
2353
2354 if (data.hash_mode != 2500)
2355 {
2356 char out_buf[HCBUFSIZ] = { 0 };
2357
2358 if (data.username == 1)
2359 {
2360 user_t *user = data.hash_info[idx]->user;
2361
2362 uint i;
2363
2364 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2365
2366 fputc (separator, fp);
2367 }
2368
2369 ascii_digest (out_buf, salt_pos, digest_pos);
2370
2371 fputs (out_buf, fp);
2372
2373 log_out (fp, "");
2374 }
2375 else
2376 {
2377 hccap_t hccap;
2378
2379 to_hccap_t (&hccap, salt_pos, digest_pos);
2380
2381 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2382 }
2383 }
2384 }
2385
2386 fflush (fp);
2387
2388 fclose (fp);
2389
2390 unlink (old_hashfile);
2391
2392 if (rename (hashfile, old_hashfile) != 0)
2393 {
2394 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2395
2396 exit (-1);
2397 }
2398
2399 unlink (hashfile);
2400
2401 if (rename (new_hashfile, hashfile) != 0)
2402 {
2403 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2404
2405 exit (-1);
2406 }
2407
2408 unlink (old_hashfile);
2409 }
2410
2411 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2412 {
2413 // function called only in case kernel_power_all > words_left
2414
2415 float kernel_power_div = (float) (total_left) / kernel_power_all;
2416
2417 kernel_power_div += kernel_power_div / 100;
2418
2419 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2420
2421 while (kernel_power_new < total_left)
2422 {
2423 kernel_power_div += kernel_power_div / 100;
2424
2425 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2426 }
2427
2428 if (data.quiet == 0)
2429 {
2430 clear_prompt ();
2431
2432 //log_info ("");
2433
2434 log_info ("INFO: approaching final keyspace, workload adjusted");
2435 log_info ("");
2436
2437 fprintf (stdout, "%s", PROMPT);
2438
2439 fflush (stdout);
2440 }
2441
2442 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2443
2444 return kernel_power_div;
2445 }
2446
2447 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2448 {
2449 uint num_elements = num;
2450
2451 device_param->kernel_params_buf32[30] = data.combs_mode;
2452 device_param->kernel_params_buf32[31] = num;
2453
2454 uint kernel_threads = device_param->kernel_threads;
2455
2456 while (num_elements % kernel_threads) num_elements++;
2457
2458 cl_kernel kernel = NULL;
2459
2460 switch (kern_run)
2461 {
2462 case KERN_RUN_1: kernel = device_param->kernel1; break;
2463 case KERN_RUN_12: kernel = device_param->kernel12; break;
2464 case KERN_RUN_2: kernel = device_param->kernel2; break;
2465 case KERN_RUN_23: kernel = device_param->kernel23; break;
2466 case KERN_RUN_3: kernel = device_param->kernel3; break;
2467 }
2468
2469 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2470 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2471 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2472 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2473 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2474 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2475 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2476 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2477 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2478 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2479 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2480
2481 cl_event event;
2482
2483 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2484 {
2485 const size_t global_work_size[3] = { num_elements, 32, 1 };
2486 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2487
2488 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2489 }
2490 else
2491 {
2492 if (kern_run == KERN_RUN_2)
2493 {
2494 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2495 {
2496 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2497 }
2498 }
2499
2500 while (num_elements % kernel_threads) num_elements++;
2501
2502 const size_t global_work_size[3] = { num_elements, 1, 1 };
2503 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2504
2505 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2506 }
2507
2508 hc_clFlush (data.ocl, device_param->command_queue);
2509
2510 hc_clWaitForEvents (data.ocl, 1, &event);
2511
2512 if (event_update)
2513 {
2514 cl_ulong time_start;
2515 cl_ulong time_end;
2516
2517 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2518 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2519
2520 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2521
2522 uint exec_pos = device_param->exec_pos;
2523
2524 device_param->exec_ms[exec_pos] = exec_time;
2525
2526 exec_pos++;
2527
2528 if (exec_pos == EXEC_CACHE)
2529 {
2530 exec_pos = 0;
2531 }
2532
2533 device_param->exec_pos = exec_pos;
2534 }
2535
2536 hc_clReleaseEvent (data.ocl, event);
2537
2538 hc_clFinish (data.ocl, device_param->command_queue);
2539 }
2540
2541 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2542 {
2543 uint num_elements = num;
2544
2545 switch (kern_run)
2546 {
2547 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2548 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2549 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2550 }
2551
2552 // causes problems with special threads like in bcrypt
2553 // const uint kernel_threads = device_param->kernel_threads;
2554
2555 uint kernel_threads = device_param->kernel_threads;
2556
2557 while (num_elements % kernel_threads) num_elements++;
2558
2559 cl_kernel kernel = NULL;
2560
2561 switch (kern_run)
2562 {
2563 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2564 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2565 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2566 }
2567
2568 switch (kern_run)
2569 {
2570 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2571 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2572 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2573 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2574 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2575 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2576 break;
2577 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2578 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2579 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2580 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2581 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2582 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2583 break;
2584 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2585 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2586 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2587 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2588 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2589 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2590 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2591 break;
2592 }
2593
2594 const size_t global_work_size[3] = { num_elements, 1, 1 };
2595 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2596
2597 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2598
2599 hc_clFlush (data.ocl, device_param->command_queue);
2600
2601 hc_clFinish (data.ocl, device_param->command_queue);
2602 }
2603
2604 static void run_kernel_tm (hc_device_param_t *device_param)
2605 {
2606 const uint num_elements = 1024; // fixed
2607
2608 uint kernel_threads = 32;
2609
2610 cl_kernel kernel = device_param->kernel_tm;
2611
2612 const size_t global_work_size[3] = { num_elements, 1, 1 };
2613 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2614
2615 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2616
2617 hc_clFlush (data.ocl, device_param->command_queue);
2618
2619 hc_clFinish (data.ocl, device_param->command_queue);
2620 }
2621
2622 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2623 {
2624 uint num_elements = num;
2625
2626 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2627 device_param->kernel_params_amp_buf32[6] = num_elements;
2628
2629 // causes problems with special threads like in bcrypt
2630 // const uint kernel_threads = device_param->kernel_threads;
2631
2632 uint kernel_threads = device_param->kernel_threads;
2633
2634 while (num_elements % kernel_threads) num_elements++;
2635
2636 cl_kernel kernel = device_param->kernel_amp;
2637
2638 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2639 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2640
2641 const size_t global_work_size[3] = { num_elements, 1, 1 };
2642 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2643
2644 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2645
2646 hc_clFlush (data.ocl, device_param->command_queue);
2647
2648 hc_clFinish (data.ocl, device_param->command_queue);
2649 }
2650
2651 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2652 {
2653 int rc = -1;
2654
2655 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2656 {
2657 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2658
2659 const cl_uchar zero = 0;
2660
2661 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2662 }
2663
2664 if (rc != 0)
2665 {
2666 // NOTE: clEnqueueFillBuffer () always fails with -59
2667 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2668 // How's that possible, OpenCL 1.2 support is advertised??
2669 // We need to workaround...
2670
2671 #define FILLSZ 0x100000
2672
2673 char *tmp = (char *) mymalloc (FILLSZ);
2674
2675 for (size_t i = 0; i < size; i += FILLSZ)
2676 {
2677 const size_t left = size - i;
2678
2679 const size_t fillsz = MIN (FILLSZ, left);
2680
2681 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2682 }
2683
2684 myfree (tmp);
2685 }
2686 }
2687
2688 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)
2689 {
2690 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2691 {
2692 if (attack_mode == ATTACK_MODE_BF)
2693 {
2694 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2695 {
2696 const uint size_tm = 32 * sizeof (bs_word_t);
2697
2698 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2699
2700 run_kernel_tm (device_param);
2701
2702 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);
2703 }
2704 }
2705
2706 if (highest_pw_len < 16)
2707 {
2708 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2709 }
2710 else if (highest_pw_len < 32)
2711 {
2712 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2713 }
2714 else
2715 {
2716 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2717 }
2718 }
2719 else
2720 {
2721 run_kernel_amp (device_param, pws_cnt);
2722
2723 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2724
2725 if (opts_type & OPTS_TYPE_HOOK12)
2726 {
2727 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2728 }
2729
2730 uint iter = salt_buf->salt_iter;
2731
2732 uint loop_step = device_param->kernel_loops;
2733
2734 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2735 {
2736 uint loop_left = iter - loop_pos;
2737
2738 loop_left = MIN (loop_left, loop_step);
2739
2740 device_param->kernel_params_buf32[25] = loop_pos;
2741 device_param->kernel_params_buf32[26] = loop_left;
2742
2743 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2744
2745 if (data.devices_status == STATUS_CRACKED) break;
2746 if (data.devices_status == STATUS_ABORTED) break;
2747 if (data.devices_status == STATUS_QUIT) break;
2748
2749 /**
2750 * speed
2751 */
2752
2753 const float iter_part = (float) (loop_pos + loop_left) / iter;
2754
2755 const u64 perf_sum_all = pws_cnt * iter_part;
2756
2757 double speed_ms;
2758
2759 hc_timer_get (device_param->timer_speed, speed_ms);
2760
2761 const u32 speed_pos = device_param->speed_pos;
2762
2763 device_param->speed_cnt[speed_pos] = perf_sum_all;
2764
2765 device_param->speed_ms[speed_pos] = speed_ms;
2766
2767 if (data.benchmark == 1)
2768 {
2769 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2770 }
2771 }
2772
2773 if (opts_type & OPTS_TYPE_HOOK23)
2774 {
2775 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2776
2777 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);
2778
2779 // do something with data
2780
2781 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);
2782 }
2783
2784 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2785 }
2786 }
2787
2788 static int run_rule_engine (const int rule_len, const char *rule_buf)
2789 {
2790 if (rule_len == 0)
2791 {
2792 return 0;
2793 }
2794 else if (rule_len == 1)
2795 {
2796 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2797 }
2798
2799 return 1;
2800 }
2801
2802 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2803 {
2804 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2805 {
2806 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);
2807 }
2808 else if (data.attack_kern == ATTACK_KERN_COMBI)
2809 {
2810 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2811 {
2812 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x01;
2821 }
2822 }
2823 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2824 {
2825 for (u32 i = 0; i < pws_cnt; i++)
2826 {
2827 const u32 pw_len = device_param->pws_buf[i].pw_len;
2828
2829 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2830
2831 ptr[pw_len] = 0x80;
2832 }
2833 }
2834 }
2835
2836 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);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_BF)
2839 {
2840 const u64 off = device_param->words_off;
2841
2842 device_param->kernel_params_mp_l_buf64[3] = off;
2843
2844 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2845 }
2846 }
2847
2848 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2849 {
2850 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2851
2852 device_param->kernel_params_buf32[25] = 0;
2853 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2854 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2855
2856 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2857 {
2858 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2859 }
2860 else
2861 {
2862 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2863 }
2864
2865 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2866
2867 return exec_ms_prev;
2868 }
2869
2870 static void autotune (hc_device_param_t *device_param)
2871 {
2872 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2873
2874 const u32 kernel_accel_min = device_param->kernel_accel_min;
2875 const u32 kernel_accel_max = device_param->kernel_accel_max;
2876
2877 const u32 kernel_loops_min = device_param->kernel_loops_min;
2878 const u32 kernel_loops_max = device_param->kernel_loops_max;
2879
2880 u32 kernel_accel = kernel_accel_min;
2881 u32 kernel_loops = kernel_loops_min;
2882
2883 // 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 // begin actual testing
2902
2903 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2904
2905 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2906 {
2907 // we do this in case the user specified a fixed -u and -n on the commandline
2908 // so we have a cached kernel for benchmark
2909
2910 try_run (device_param, kernel_accel, kernel_loops);
2911 try_run (device_param, kernel_accel, kernel_loops);
2912 try_run (device_param, kernel_accel, kernel_loops);
2913 try_run (device_param, kernel_accel, kernel_loops);
2914 try_run (device_param, kernel_accel, kernel_loops);
2915 }
2916
2917 // first find out highest kernel-loops that stays below target_ms
2918
2919 #define STEPS_CNT 10
2920
2921 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2922 {
2923 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2924
2925 if (exec_ms < target_ms) break;
2926 }
2927
2928 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2929
2930 if (kernel_accel_min < kernel_accel_max)
2931 {
2932 for (int i = 0; i < STEPS_CNT; i++)
2933 {
2934 const u32 kernel_accel_try = 1 << i;
2935
2936 if (kernel_accel_try < kernel_accel_min) continue;
2937 if (kernel_accel_try > kernel_accel_max) break;
2938
2939 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2940
2941 if (exec_ms > target_ms) break;
2942
2943 exec_ms_final = exec_ms;
2944
2945 kernel_accel = kernel_accel_try;
2946 }
2947 }
2948
2949 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2950 // in such a case the above function would not create any change
2951 // we'll use the runtime to find out if we're allow to do last improvement
2952
2953 if (exec_ms_final > 0)
2954 {
2955 if ((exec_ms_final * 2) <= target_ms)
2956 {
2957 const double exec_left = target_ms / exec_ms_final;
2958
2959 const double accel_left = kernel_accel_max / kernel_accel;
2960
2961 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2962
2963 if (exec_accel_min >= 2)
2964 {
2965 kernel_accel *= exec_accel_min;
2966 }
2967 }
2968 }
2969
2970 // balancing the workload turns out to be very efficient
2971
2972 if (kernel_loops_min != kernel_loops_max)
2973 {
2974 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2975
2976 u32 sqrtv;
2977
2978 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2979 {
2980 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2981 }
2982
2983 const u32 kernel_accel_try = sqrtv;
2984 const u32 kernel_loops_try = sqrtv;
2985
2986 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2987 {
2988 kernel_accel = kernel_accel_try;
2989 kernel_loops = kernel_loops_try;
2990 }
2991 }
2992
2993 // reset fake words
2994
2995 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2996
2997 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);
2998 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);
2999
3000 // reset timer
3001
3002 device_param->exec_pos = 0;
3003
3004 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3005
3006 // store
3007
3008 device_param->kernel_accel = kernel_accel;
3009 device_param->kernel_loops = kernel_loops;
3010
3011 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3012
3013 device_param->kernel_power = kernel_power;
3014
3015 #ifdef DEBUG
3016
3017 if (data.quiet == 0)
3018 {
3019 clear_prompt ();
3020
3021 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3022 "Device #%u: autotuned kernel-loops to %u\n",
3023 device_param->device_id + 1, kernel_accel,
3024 device_param->device_id + 1, kernel_loops);
3025
3026 fprintf (stdout, "%s", PROMPT);
3027
3028 fflush (stdout);
3029 }
3030
3031 #endif
3032 }
3033
3034 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3035 {
3036 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3037
3038 // init speed timer
3039
3040 uint speed_pos = device_param->speed_pos;
3041
3042 #ifdef _POSIX
3043 if (device_param->timer_speed.tv_sec == 0)
3044 {
3045 hc_timer_set (&device_param->timer_speed);
3046 }
3047 #endif
3048
3049 #ifdef _WIN
3050 if (device_param->timer_speed.QuadPart == 0)
3051 {
3052 hc_timer_set (&device_param->timer_speed);
3053 }
3054 #endif
3055
3056 // find higest password length, this is for optimization stuff
3057
3058 uint highest_pw_len = 0;
3059
3060 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3061 {
3062 }
3063 else if (data.attack_kern == ATTACK_KERN_COMBI)
3064 {
3065 }
3066 else if (data.attack_kern == ATTACK_KERN_BF)
3067 {
3068 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3069 + device_param->kernel_params_mp_l_buf32[5];
3070 }
3071
3072 // iteration type
3073
3074 uint innerloop_step = 0;
3075 uint innerloop_cnt = 0;
3076
3077 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3078 else innerloop_step = 1;
3079
3080 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3081 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3082 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3083
3084 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3085
3086 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3087 {
3088 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3089
3090 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3091
3092 if (data.devices_status == STATUS_CRACKED) break;
3093 if (data.devices_status == STATUS_ABORTED) break;
3094 if (data.devices_status == STATUS_QUIT) break;
3095 if (data.devices_status == STATUS_BYPASS) break;
3096
3097 salt_t *salt_buf = &data.salts_buf[salt_pos];
3098
3099 device_param->kernel_params_buf32[24] = salt_pos;
3100 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3101 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3102
3103 FILE *combs_fp = device_param->combs_fp;
3104
3105 if (data.attack_mode == ATTACK_MODE_COMBI)
3106 {
3107 rewind (combs_fp);
3108 }
3109
3110 // innerloops
3111
3112 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3113 {
3114 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3115
3116 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3117
3118 if (data.devices_status == STATUS_CRACKED) break;
3119 if (data.devices_status == STATUS_ABORTED) break;
3120 if (data.devices_status == STATUS_QUIT) break;
3121 if (data.devices_status == STATUS_BYPASS) break;
3122
3123 uint innerloop_left = innerloop_cnt - innerloop_pos;
3124
3125 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3126
3127 device_param->innerloop_pos = innerloop_pos;
3128 device_param->innerloop_left = innerloop_left;
3129
3130 device_param->kernel_params_buf32[27] = innerloop_left;
3131
3132 // i think we can get rid of this
3133 if (innerloop_left == 0)
3134 {
3135 puts ("bug, how should this happen????\n");
3136
3137 continue;
3138 }
3139
3140 if (data.salts_shown[salt_pos] == 1)
3141 {
3142 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3143
3144 continue;
3145 }
3146
3147 // initialize amplifiers
3148
3149 if (data.attack_mode == ATTACK_MODE_COMBI)
3150 {
3151 uint i = 0;
3152
3153 while (i < innerloop_left)
3154 {
3155 if (feof (combs_fp)) break;
3156
3157 int line_len = fgetl (combs_fp, line_buf);
3158
3159 if (line_len >= PW_MAX1) continue;
3160
3161 line_len = convert_from_hex (line_buf, line_len);
3162
3163 char *line_buf_new = line_buf;
3164
3165 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3166 {
3167 char rule_buf_out[BLOCK_SIZE] = { 0 };
3168
3169 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3170
3171 if (rule_len_out < 0)
3172 {
3173 data.words_progress_rejected[salt_pos] += pws_cnt;
3174
3175 continue;
3176 }
3177
3178 line_len = rule_len_out;
3179
3180 line_buf_new = rule_buf_out;
3181 }
3182
3183 line_len = MIN (line_len, PW_DICTMAX);
3184
3185 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3186
3187 memcpy (ptr, line_buf_new, line_len);
3188
3189 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3190
3191 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3192 {
3193 uppercase (ptr, line_len);
3194 }
3195
3196 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3197 {
3198 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3199 {
3200 ptr[line_len] = 0x80;
3201 }
3202
3203 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3204 {
3205 ptr[line_len] = 0x01;
3206 }
3207 }
3208
3209 device_param->combs_buf[i].pw_len = line_len;
3210
3211 i++;
3212 }
3213
3214 for (uint j = i; j < innerloop_left; j++)
3215 {
3216 device_param->combs_buf[j].i[0] = 0;
3217 device_param->combs_buf[j].i[1] = 0;
3218 device_param->combs_buf[j].i[2] = 0;
3219 device_param->combs_buf[j].i[3] = 0;
3220 device_param->combs_buf[j].i[4] = 0;
3221 device_param->combs_buf[j].i[5] = 0;
3222 device_param->combs_buf[j].i[6] = 0;
3223 device_param->combs_buf[j].i[7] = 0;
3224
3225 device_param->combs_buf[j].pw_len = 0;
3226 }
3227
3228 innerloop_left = i;
3229 }
3230 else if (data.attack_mode == ATTACK_MODE_BF)
3231 {
3232 u64 off = innerloop_pos;
3233
3234 device_param->kernel_params_mp_r_buf64[3] = off;
3235
3236 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3237 }
3238 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3239 {
3240 u64 off = innerloop_pos;
3241
3242 device_param->kernel_params_mp_buf64[3] = off;
3243
3244 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3245 }
3246 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3247 {
3248 u64 off = innerloop_pos;
3249
3250 device_param->kernel_params_mp_buf64[3] = off;
3251
3252 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3253 }
3254
3255 // copy amplifiers
3256
3257 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3258 {
3259 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);
3260 }
3261 else if (data.attack_mode == ATTACK_MODE_COMBI)
3262 {
3263 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);
3264 }
3265 else if (data.attack_mode == ATTACK_MODE_BF)
3266 {
3267 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);
3268 }
3269 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3270 {
3271 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);
3272 }
3273 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3274 {
3275 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);
3276 }
3277
3278 if (data.benchmark == 1)
3279 {
3280 hc_timer_set (&device_param->timer_speed);
3281 }
3282
3283 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3284
3285 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3286
3287 if (data.devices_status == STATUS_CRACKED) break;
3288 if (data.devices_status == STATUS_ABORTED) break;
3289 if (data.devices_status == STATUS_QUIT) break;
3290
3291 /**
3292 * result
3293 */
3294
3295 hc_thread_mutex_lock (mux_display);
3296
3297 check_cracked (device_param, salt_pos);
3298
3299 hc_thread_mutex_unlock (mux_display);
3300
3301 /**
3302 * progress
3303 */
3304
3305 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3306
3307 hc_thread_mutex_lock (mux_counter);
3308
3309 data.words_progress_done[salt_pos] += perf_sum_all;
3310
3311 hc_thread_mutex_unlock (mux_counter);
3312
3313 /**
3314 * speed
3315 */
3316
3317 double speed_ms;
3318
3319 hc_timer_get (device_param->timer_speed, speed_ms);
3320
3321 hc_timer_set (&device_param->timer_speed);
3322
3323 hc_thread_mutex_lock (mux_display);
3324
3325 // current speed
3326
3327 device_param->speed_cnt[speed_pos] = perf_sum_all;
3328
3329 device_param->speed_ms[speed_pos] = speed_ms;
3330
3331 hc_thread_mutex_unlock (mux_display);
3332
3333 speed_pos++;
3334
3335 if (speed_pos == SPEED_CACHE)
3336 {
3337 speed_pos = 0;
3338 }
3339
3340 /**
3341 * benchmark
3342 */
3343
3344 if (data.benchmark == 1) break;
3345 }
3346 }
3347
3348 device_param->speed_pos = speed_pos;
3349
3350 myfree (line_buf);
3351 }
3352
3353 static void load_segment (wl_data_t *wl_data, FILE *fd)
3354 {
3355 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3356
3357 wl_data->pos = 0;
3358
3359 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3360
3361 wl_data->buf[wl_data->cnt] = 0;
3362
3363 if (wl_data->cnt == 0) return;
3364
3365 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3366
3367 while (!feof (fd))
3368 {
3369 if (wl_data->cnt == wl_data->avail)
3370 {
3371 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3372
3373 wl_data->avail += wl_data->incr;
3374 }
3375
3376 const int c = fgetc (fd);
3377
3378 if (c == EOF) break;
3379
3380 wl_data->buf[wl_data->cnt] = (char) c;
3381
3382 wl_data->cnt++;
3383
3384 if (c == '\n') break;
3385 }
3386
3387 // ensure stream ends with a newline
3388
3389 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3390 {
3391 wl_data->cnt++;
3392
3393 wl_data->buf[wl_data->cnt - 1] = '\n';
3394 }
3395
3396 return;
3397 }
3398
3399 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3400 {
3401 char *ptr = buf;
3402
3403 for (u32 i = 0; i < sz; i++, ptr++)
3404 {
3405 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3406
3407 if (i == 7)
3408 {
3409 *off = i;
3410 *len = i;
3411
3412 return;
3413 }
3414
3415 if (*ptr != '\n') continue;
3416
3417 *off = i + 1;
3418
3419 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3420
3421 *len = i;
3422
3423 return;
3424 }
3425
3426 *off = sz;
3427 *len = sz;
3428 }
3429
3430 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3431 {
3432 char *ptr = buf;
3433
3434 for (u32 i = 0; i < sz; i++, ptr++)
3435 {
3436 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3437
3438 if (*ptr != '\n') continue;
3439
3440 *off = i + 1;
3441
3442 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3443
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 *off = sz;
3450 *len = sz;
3451 }
3452
3453 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3454 {
3455 char *ptr = buf;
3456
3457 for (u32 i = 0; i < sz; i++, ptr++)
3458 {
3459 if (*ptr != '\n') continue;
3460
3461 *off = i + 1;
3462
3463 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3464
3465 *len = i;
3466
3467 return;
3468 }
3469
3470 *off = sz;
3471 *len = sz;
3472 }
3473
3474 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3475 {
3476 while (wl_data->pos < wl_data->cnt)
3477 {
3478 uint off;
3479 uint len;
3480
3481 char *ptr = wl_data->buf + wl_data->pos;
3482
3483 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3484
3485 wl_data->pos += off;
3486
3487 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3488 {
3489 char rule_buf_out[BLOCK_SIZE] = { 0 };
3490
3491 int rule_len_out = -1;
3492
3493 if (len < BLOCK_SIZE)
3494 {
3495 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3496 }
3497
3498 if (rule_len_out < 0)
3499 {
3500 continue;
3501 }
3502
3503 if (rule_len_out > PW_MAX)
3504 {
3505 continue;
3506 }
3507 }
3508 else
3509 {
3510 if (len > PW_MAX)
3511 {
3512 continue;
3513 }
3514 }
3515
3516 *out_buf = ptr;
3517 *out_len = len;
3518
3519 return;
3520 }
3521
3522 if (feof (fd))
3523 {
3524 fprintf (stderr, "BUG feof()!!\n");
3525
3526 return;
3527 }
3528
3529 load_segment (wl_data, fd);
3530
3531 get_next_word (wl_data, fd, out_buf, out_len);
3532 }
3533
3534 #ifdef _POSIX
3535 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3536 #endif
3537
3538 #ifdef _WIN
3539 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3540 #endif
3541 {
3542 hc_signal (NULL);
3543
3544 dictstat_t d;
3545
3546 d.cnt = 0;
3547
3548 #ifdef _POSIX
3549 fstat (fileno (fd), &d.stat);
3550 #endif
3551
3552 #ifdef _WIN
3553 _fstat64 (fileno (fd), &d.stat);
3554 #endif
3555
3556 d.stat.st_mode = 0;
3557 d.stat.st_nlink = 0;
3558 d.stat.st_uid = 0;
3559 d.stat.st_gid = 0;
3560 d.stat.st_rdev = 0;
3561 d.stat.st_atime = 0;
3562
3563 #ifdef _POSIX
3564 d.stat.st_blksize = 0;
3565 d.stat.st_blocks = 0;
3566 #endif
3567
3568 if (d.stat.st_size == 0) return 0;
3569
3570 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3571
3572 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3573 {
3574 if (d_cache)
3575 {
3576 u64 cnt = d_cache->cnt;
3577
3578 u64 keyspace = cnt;
3579
3580 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3581 {
3582 keyspace *= data.kernel_rules_cnt;
3583 }
3584 else if (data.attack_kern == ATTACK_KERN_COMBI)
3585 {
3586 keyspace *= data.combs_cnt;
3587 }
3588
3589 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);
3590 if (data.quiet == 0) log_info ("");
3591
3592 hc_signal (sigHandler_default);
3593
3594 return (keyspace);
3595 }
3596 }
3597
3598 time_t now = 0;
3599 time_t prev = 0;
3600
3601 u64 comp = 0;
3602 u64 cnt = 0;
3603 u64 cnt2 = 0;
3604
3605 while (!feof (fd))
3606 {
3607 load_segment (wl_data, fd);
3608
3609 comp += wl_data->cnt;
3610
3611 u32 i = 0;
3612
3613 while (i < wl_data->cnt)
3614 {
3615 u32 len;
3616 u32 off;
3617
3618 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3619
3620 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3621 {
3622 char rule_buf_out[BLOCK_SIZE] = { 0 };
3623
3624 int rule_len_out = -1;
3625
3626 if (len < BLOCK_SIZE)
3627 {
3628 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3629 }
3630
3631 if (rule_len_out < 0)
3632 {
3633 len = PW_MAX1;
3634 }
3635 else
3636 {
3637 len = rule_len_out;
3638 }
3639 }
3640
3641 if (len < PW_MAX1)
3642 {
3643 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3644 {
3645 cnt += data.kernel_rules_cnt;
3646 }
3647 else if (data.attack_kern == ATTACK_KERN_COMBI)
3648 {
3649 cnt += data.combs_cnt;
3650 }
3651
3652 d.cnt++;
3653 }
3654
3655 i += off;
3656
3657 cnt2++;
3658 }
3659
3660 time (&now);
3661
3662 if ((now - prev) == 0) continue;
3663
3664 float percent = (float) comp / (float) d.stat.st_size;
3665
3666 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);
3667
3668 time (&prev);
3669 }
3670
3671 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);
3672 if (data.quiet == 0) log_info ("");
3673
3674 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3675
3676 hc_signal (sigHandler_default);
3677
3678 return (cnt);
3679 }
3680
3681 static void *thread_monitor (void *p)
3682 {
3683 uint runtime_check = 0;
3684 uint remove_check = 0;
3685 uint status_check = 0;
3686 uint restore_check = 0;
3687
3688 uint restore_left = data.restore_timer;
3689 uint remove_left = data.remove_timer;
3690 uint status_left = data.status_timer;
3691
3692 #ifdef HAVE_HWMON
3693 uint hwmon_check = 0;
3694
3695 // these variables are mainly used for fan control (AMD only)
3696
3697 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3698
3699 // temperature controller "loopback" values
3700
3701 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3702 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3703
3704 #ifdef HAVE_ADL
3705 int temp_threshold = 1; // degrees celcius
3706
3707 int fan_speed_min = 15; // in percentage
3708 int fan_speed_max = 100;
3709 #endif // HAVE_ADL
3710
3711 time_t last_temp_check_time;
3712 #endif // HAVE_HWMON
3713
3714 uint sleep_time = 1;
3715
3716 if (data.runtime)
3717 {
3718 runtime_check = 1;
3719 }
3720
3721 if (data.restore_timer)
3722 {
3723 restore_check = 1;
3724 }
3725
3726 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3727 {
3728 remove_check = 1;
3729 }
3730
3731 if (data.status == 1)
3732 {
3733 status_check = 1;
3734 }
3735
3736 #ifdef HAVE_HWMON
3737 if (data.gpu_temp_disable == 0)
3738 {
3739 time (&last_temp_check_time);
3740
3741 hwmon_check = 1;
3742 }
3743 #endif
3744
3745 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3746 {
3747 #ifdef HAVE_HWMON
3748 if (hwmon_check == 0)
3749 #endif
3750 return (p);
3751 }
3752
3753 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3754 {
3755 hc_sleep (sleep_time);
3756
3757 if (data.devices_status != STATUS_RUNNING) continue;
3758
3759 #ifdef HAVE_HWMON
3760 if (hwmon_check == 1)
3761 {
3762 hc_thread_mutex_lock (mux_adl);
3763
3764 time_t temp_check_time;
3765
3766 time (&temp_check_time);
3767
3768 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3769
3770 if (Ta == 0) Ta = 1;
3771
3772 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3773 {
3774 hc_device_param_t *device_param = &data.devices_param[device_id];
3775
3776 if (device_param->skipped) continue;
3777
3778 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3779
3780 const int temperature = hm_get_temperature_with_device_id (device_id);
3781
3782 if (temperature > (int) data.gpu_temp_abort)
3783 {
3784 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3785
3786 if (data.devices_status != STATUS_QUIT) myabort ();
3787
3788 break;
3789 }
3790
3791 #ifdef HAVE_ADL
3792 const int gpu_temp_retain = data.gpu_temp_retain;
3793
3794 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3795 {
3796 if (data.hm_device[device_id].fan_supported == 1)
3797 {
3798 int temp_cur = temperature;
3799
3800 int temp_diff_new = gpu_temp_retain - temp_cur;
3801
3802 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3803
3804 // calculate Ta value (time difference in seconds between the last check and this check)
3805
3806 last_temp_check_time = temp_check_time;
3807
3808 float Kp = 1.8;
3809 float Ki = 0.005;
3810 float Kd = 6;
3811
3812 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3813
3814 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);
3815
3816 if (abs (fan_diff_required) >= temp_threshold)
3817 {
3818 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3819
3820 int fan_speed_level = fan_speed_cur;
3821
3822 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3823
3824 int fan_speed_new = fan_speed_level - fan_diff_required;
3825
3826 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3827 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3828
3829 if (fan_speed_new != fan_speed_cur)
3830 {
3831 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3832 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3833
3834 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3835 {
3836 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3837
3838 fan_speed_chgd[device_id] = 1;
3839 }
3840
3841 temp_diff_old[device_id] = temp_diff_new;
3842 }
3843 }
3844 }
3845 }
3846 #endif // HAVE_ADL
3847 }
3848
3849 hc_thread_mutex_unlock (mux_adl);
3850 }
3851 #endif // HAVE_HWMON
3852
3853 if (restore_check == 1)
3854 {
3855 restore_left--;
3856
3857 if (restore_left == 0)
3858 {
3859 if (data.restore_disable == 0) cycle_restore ();
3860
3861 restore_left = data.restore_timer;
3862 }
3863 }
3864
3865 if ((runtime_check == 1) && (data.runtime_start > 0))
3866 {
3867 time_t runtime_cur;
3868
3869 time (&runtime_cur);
3870
3871 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3872
3873 if (runtime_left <= 0)
3874 {
3875 if (data.benchmark == 0)
3876 {
3877 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3878 }
3879
3880 if (data.devices_status != STATUS_QUIT) myabort ();
3881 }
3882 }
3883
3884 if (remove_check == 1)
3885 {
3886 remove_left--;
3887
3888 if (remove_left == 0)
3889 {
3890 if (data.digests_saved != data.digests_done)
3891 {
3892 data.digests_saved = data.digests_done;
3893
3894 save_hash ();
3895 }
3896
3897 remove_left = data.remove_timer;
3898 }
3899 }
3900
3901 if (status_check == 1)
3902 {
3903 status_left--;
3904
3905 if (status_left == 0)
3906 {
3907 hc_thread_mutex_lock (mux_display);
3908
3909 if (data.quiet == 0) clear_prompt ();
3910
3911 if (data.quiet == 0) log_info ("");
3912
3913 status_display ();
3914
3915 if (data.quiet == 0) log_info ("");
3916
3917 hc_thread_mutex_unlock (mux_display);
3918
3919 status_left = data.status_timer;
3920 }
3921 }
3922 }
3923
3924 #ifdef HAVE_HWMON
3925 myfree (fan_speed_chgd);
3926
3927 myfree (temp_diff_old);
3928 myfree (temp_diff_sum);
3929 #endif
3930
3931 p = NULL;
3932
3933 return (p);
3934 }
3935
3936 static void *thread_outfile_remove (void *p)
3937 {
3938 // some hash-dependent constants
3939 char *outfile_dir = data.outfile_check_directory;
3940 uint dgst_size = data.dgst_size;
3941 uint isSalted = data.isSalted;
3942 uint esalt_size = data.esalt_size;
3943 uint hash_mode = data.hash_mode;
3944
3945 uint outfile_check_timer = data.outfile_check_timer;
3946
3947 char separator = data.separator;
3948
3949 // some hash-dependent functions
3950 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3951 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3952
3953 // buffers
3954 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3955
3956 hash_buf.digest = mymalloc (dgst_size);
3957
3958 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3959
3960 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3961
3962 uint digest_buf[64] = { 0 };
3963
3964 outfile_data_t *out_info = NULL;
3965
3966 char **out_files = NULL;
3967
3968 time_t folder_mtime = 0;
3969
3970 int out_cnt = 0;
3971
3972 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3973
3974 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3975 {
3976 hc_sleep (1);
3977
3978 if (data.devices_status != STATUS_RUNNING) continue;
3979
3980 check_left--;
3981
3982 if (check_left == 0)
3983 {
3984 struct stat outfile_check_stat;
3985
3986 if (stat (outfile_dir, &outfile_check_stat) == 0)
3987 {
3988 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3989
3990 if (is_dir == 1)
3991 {
3992 if (outfile_check_stat.st_mtime > folder_mtime)
3993 {
3994 char **out_files_new = scan_directory (outfile_dir);
3995
3996 int out_cnt_new = count_dictionaries (out_files_new);
3997
3998 outfile_data_t *out_info_new = NULL;
3999
4000 if (out_cnt_new > 0)
4001 {
4002 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4003
4004 for (int i = 0; i < out_cnt_new; i++)
4005 {
4006 out_info_new[i].file_name = out_files_new[i];
4007
4008 // check if there are files that we have seen/checked before (and not changed)
4009
4010 for (int j = 0; j < out_cnt; j++)
4011 {
4012 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4013 {
4014 struct stat outfile_stat;
4015
4016 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4017 {
4018 if (outfile_stat.st_ctime == out_info[j].ctime)
4019 {
4020 out_info_new[i].ctime = out_info[j].ctime;
4021 out_info_new[i].seek = out_info[j].seek;
4022 }
4023 }
4024 }
4025 }
4026 }
4027 }
4028
4029 local_free (out_info);
4030 local_free (out_files);
4031
4032 out_files = out_files_new;
4033 out_cnt = out_cnt_new;
4034 out_info = out_info_new;
4035
4036 folder_mtime = outfile_check_stat.st_mtime;
4037 }
4038
4039 for (int j = 0; j < out_cnt; j++)
4040 {
4041 FILE *fp = fopen (out_info[j].file_name, "rb");
4042
4043 if (fp != NULL)
4044 {
4045 //hc_thread_mutex_lock (mux_display);
4046
4047 #ifdef _POSIX
4048 struct stat outfile_stat;
4049
4050 fstat (fileno (fp), &outfile_stat);
4051 #endif
4052
4053 #ifdef _WIN
4054 struct stat64 outfile_stat;
4055
4056 _fstat64 (fileno (fp), &outfile_stat);
4057 #endif
4058
4059 if (outfile_stat.st_ctime > out_info[j].ctime)
4060 {
4061 out_info[j].ctime = outfile_stat.st_ctime;
4062 out_info[j].seek = 0;
4063 }
4064
4065 fseek (fp, out_info[j].seek, SEEK_SET);
4066
4067 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4068
4069 while (!feof (fp))
4070 {
4071 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4072
4073 if (ptr == NULL) break;
4074
4075 int line_len = strlen (line_buf);
4076
4077 if (line_len <= 0) continue;
4078
4079 int iter = MAX_CUT_TRIES;
4080
4081 for (uint i = line_len - 1; i && iter; i--, line_len--)
4082 {
4083 if (line_buf[i] != separator) continue;
4084
4085 int parser_status = PARSER_OK;
4086
4087 if ((hash_mode != 2500) && (hash_mode != 6800))
4088 {
4089 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4090 }
4091
4092 uint found = 0;
4093
4094 if (parser_status == PARSER_OK)
4095 {
4096 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4097 {
4098 if (data.salts_shown[salt_pos] == 1) continue;
4099
4100 salt_t *salt_buf = &data.salts_buf[salt_pos];
4101
4102 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4103 {
4104 uint idx = salt_buf->digests_offset + digest_pos;
4105
4106 if (data.digests_shown[idx] == 1) continue;
4107
4108 uint cracked = 0;
4109
4110 if (hash_mode == 6800)
4111 {
4112 if (i == salt_buf->salt_len)
4113 {
4114 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4115 }
4116 }
4117 else if (hash_mode == 2500)
4118 {
4119 // BSSID : MAC1 : MAC2 (:plain)
4120 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4121 {
4122 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4123
4124 if (!cracked) continue;
4125
4126 // now compare MAC1 and MAC2 too, since we have this additional info
4127 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4128 char *mac2_pos = mac1_pos + 12 + 1;
4129
4130 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4131 wpa_t *wpa = &wpas[salt_pos];
4132
4133 // compare hex string(s) vs binary MAC address(es)
4134
4135 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4136 {
4137 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4138 {
4139 cracked = 0;
4140
4141 break;
4142 }
4143 }
4144
4145 // early skip ;)
4146 if (!cracked) continue;
4147
4148 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4149 {
4150 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4151 {
4152 cracked = 0;
4153
4154 break;
4155 }
4156 }
4157 }
4158 }
4159 else
4160 {
4161 char *digests_buf_ptr = (char *) data.digests_buf;
4162
4163 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4164
4165 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4166 }
4167
4168 if (cracked == 1)
4169 {
4170 found = 1;
4171
4172 data.digests_shown[idx] = 1;
4173
4174 data.digests_done++;
4175
4176 salt_buf->digests_done++;
4177
4178 if (salt_buf->digests_done == salt_buf->digests_cnt)
4179 {
4180 data.salts_shown[salt_pos] = 1;
4181
4182 data.salts_done++;
4183
4184 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4185 }
4186 }
4187 }
4188
4189 if (data.devices_status == STATUS_CRACKED) break;
4190 }
4191 }
4192
4193 if (found) break;
4194
4195 if (data.devices_status == STATUS_CRACKED) break;
4196
4197 iter--;
4198 }
4199
4200 if (data.devices_status == STATUS_CRACKED) break;
4201 }
4202
4203 myfree (line_buf);
4204
4205 out_info[j].seek = ftell (fp);
4206
4207 //hc_thread_mutex_unlock (mux_display);
4208
4209 fclose (fp);
4210 }
4211 }
4212 }
4213 }
4214
4215 check_left = outfile_check_timer;
4216 }
4217 }
4218
4219 if (esalt_size) local_free (hash_buf.esalt);
4220
4221 if (isSalted) local_free (hash_buf.salt);
4222
4223 local_free (hash_buf.digest);
4224
4225 local_free (out_info);
4226
4227 local_free (out_files);
4228
4229 p = NULL;
4230
4231 return (p);
4232 }
4233
4234 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4235 {
4236 if (device_param->pws_cnt < device_param->kernel_power)
4237 {
4238 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4239
4240 u8 *ptr = (u8 *) pw->i;
4241
4242 memcpy (ptr, pw_buf, pw_len);
4243
4244 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4245
4246 pw->pw_len = pw_len;
4247
4248 device_param->pws_cnt++;
4249 }
4250 else
4251 {
4252 fprintf (stderr, "BUG pw_add()!!\n");
4253
4254 return;
4255 }
4256 }
4257
4258 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4259 {
4260 hc_thread_mutex_lock (mux_dispatcher);
4261
4262 const u64 words_cur = data.words_cur;
4263 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4264
4265 device_param->words_off = words_cur;
4266
4267 const u64 words_left = words_base - words_cur;
4268
4269 if (allow_div)
4270 {
4271 if (data.kernel_power_all > words_left)
4272 {
4273 if (data.kernel_power_div == 0)
4274 {
4275 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4276 }
4277 }
4278
4279 if (data.kernel_power_div)
4280 {
4281 if (device_param->kernel_power == device_param->kernel_power_user)
4282 {
4283 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4284
4285 if (kernel_power_new < device_param->kernel_power)
4286 {
4287 device_param->kernel_power = kernel_power_new;
4288 }
4289 }
4290 }
4291 }
4292
4293 const uint kernel_power = device_param->kernel_power;
4294
4295 uint work = MIN (words_left, kernel_power);
4296
4297 work = MIN (work, max);
4298
4299 data.words_cur += work;
4300
4301 hc_thread_mutex_unlock (mux_dispatcher);
4302
4303 return work;
4304 }
4305
4306 static void *thread_calc_stdin (void *p)
4307 {
4308 hc_device_param_t *device_param = (hc_device_param_t *) p;
4309
4310 if (device_param->skipped) return NULL;
4311
4312 autotune (device_param);
4313
4314 char *buf = (char *) mymalloc (HCBUFSIZ);
4315
4316 const uint attack_kern = data.attack_kern;
4317
4318 const uint kernel_power = device_param->kernel_power;
4319
4320 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4321 {
4322 hc_thread_mutex_lock (mux_dispatcher);
4323
4324 if (feof (stdin) != 0)
4325 {
4326 hc_thread_mutex_unlock (mux_dispatcher);
4327
4328 break;
4329 }
4330
4331 uint words_cur = 0;
4332
4333 while (words_cur < kernel_power)
4334 {
4335 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4336
4337 if (line_buf == NULL) break;
4338
4339 uint line_len = in_superchop (line_buf);
4340
4341 line_len = convert_from_hex (line_buf, line_len);
4342
4343 // post-process rule engine
4344
4345 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4346 {
4347 char rule_buf_out[BLOCK_SIZE] = { 0 };
4348
4349 int rule_len_out = -1;
4350
4351 if (line_len < BLOCK_SIZE)
4352 {
4353 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4354 }
4355
4356 if (rule_len_out < 0) continue;
4357
4358 line_buf = rule_buf_out;
4359 line_len = rule_len_out;
4360 }
4361
4362 if (line_len > PW_MAX)
4363 {
4364 continue;
4365 }
4366
4367 if (attack_kern == ATTACK_KERN_STRAIGHT)
4368 {
4369 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4370 {
4371 hc_thread_mutex_lock (mux_counter);
4372
4373 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4374 {
4375 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4376 }
4377
4378 hc_thread_mutex_unlock (mux_counter);
4379
4380 continue;
4381 }
4382 }
4383 else if (attack_kern == ATTACK_KERN_COMBI)
4384 {
4385 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4386 // since we still need to combine the plains
4387
4388 if (line_len > data.pw_max)
4389 {
4390 hc_thread_mutex_lock (mux_counter);
4391
4392 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4393 {
4394 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4395 }
4396
4397 hc_thread_mutex_unlock (mux_counter);
4398
4399 continue;
4400 }
4401 }
4402
4403 pw_add (device_param, (u8 *) line_buf, line_len);
4404
4405 words_cur++;
4406
4407 if (data.devices_status == STATUS_CRACKED) break;
4408 if (data.devices_status == STATUS_ABORTED) break;
4409 if (data.devices_status == STATUS_QUIT) break;
4410 if (data.devices_status == STATUS_BYPASS) break;
4411 }
4412
4413 hc_thread_mutex_unlock (mux_dispatcher);
4414
4415 if (data.devices_status == STATUS_CRACKED) break;
4416 if (data.devices_status == STATUS_ABORTED) break;
4417 if (data.devices_status == STATUS_QUIT) break;
4418 if (data.devices_status == STATUS_BYPASS) break;
4419
4420 // flush
4421
4422 const uint pws_cnt = device_param->pws_cnt;
4423
4424 if (pws_cnt)
4425 {
4426 run_copy (device_param, pws_cnt);
4427
4428 run_cracker (device_param, pws_cnt);
4429
4430 device_param->pws_cnt = 0;
4431
4432 /*
4433 still required?
4434 if (attack_kern == ATTACK_KERN_STRAIGHT)
4435 {
4436 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4437 }
4438 else if (attack_kern == ATTACK_KERN_COMBI)
4439 {
4440 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4441 }
4442 */
4443 }
4444 }
4445
4446 device_param->kernel_accel = 0;
4447 device_param->kernel_loops = 0;
4448
4449 myfree (buf);
4450
4451 return NULL;
4452 }
4453
4454 static void *thread_calc (void *p)
4455 {
4456 hc_device_param_t *device_param = (hc_device_param_t *) p;
4457
4458 if (device_param->skipped) return NULL;
4459
4460 autotune (device_param);
4461
4462 const uint attack_mode = data.attack_mode;
4463 const uint attack_kern = data.attack_kern;
4464
4465 if (attack_mode == ATTACK_MODE_BF)
4466 {
4467 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4468 {
4469 const uint work = get_work (device_param, -1, true);
4470
4471 if (work == 0) break;
4472
4473 const u64 words_off = device_param->words_off;
4474 const u64 words_fin = words_off + work;
4475
4476 const uint pws_cnt = work;
4477
4478 device_param->pws_cnt = pws_cnt;
4479
4480 if (pws_cnt)
4481 {
4482 run_copy (device_param, pws_cnt);
4483
4484 run_cracker (device_param, pws_cnt);
4485
4486 device_param->pws_cnt = 0;
4487
4488 /*
4489 still required?
4490 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4491 */
4492 }
4493
4494 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4495
4496 if (data.devices_status == STATUS_CRACKED) break;
4497 if (data.devices_status == STATUS_ABORTED) break;
4498 if (data.devices_status == STATUS_QUIT) break;
4499 if (data.devices_status == STATUS_BYPASS) break;
4500
4501 if (data.benchmark == 1) break;
4502
4503 device_param->words_done = words_fin;
4504 }
4505 }
4506 else
4507 {
4508 const uint segment_size = data.segment_size;
4509
4510 char *dictfile = data.dictfile;
4511
4512 if (attack_mode == ATTACK_MODE_COMBI)
4513 {
4514 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4515 {
4516 dictfile = data.dictfile2;
4517 }
4518 }
4519
4520 FILE *fd = fopen (dictfile, "rb");
4521
4522 if (fd == NULL)
4523 {
4524 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4525
4526 return NULL;
4527 }
4528
4529 if (attack_mode == ATTACK_MODE_COMBI)
4530 {
4531 const uint combs_mode = data.combs_mode;
4532
4533 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4534 {
4535 const char *dictfilec = data.dictfile2;
4536
4537 FILE *combs_fp = fopen (dictfilec, "rb");
4538
4539 if (combs_fp == NULL)
4540 {
4541 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4542
4543 fclose (fd);
4544
4545 return NULL;
4546 }
4547
4548 device_param->combs_fp = combs_fp;
4549 }
4550 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4551 {
4552 const char *dictfilec = data.dictfile;
4553
4554 FILE *combs_fp = fopen (dictfilec, "rb");
4555
4556 if (combs_fp == NULL)
4557 {
4558 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4559
4560 fclose (fd);
4561
4562 return NULL;
4563 }
4564
4565 device_param->combs_fp = combs_fp;
4566 }
4567 }
4568
4569 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4570
4571 wl_data->buf = (char *) mymalloc (segment_size);
4572 wl_data->avail = segment_size;
4573 wl_data->incr = segment_size;
4574 wl_data->cnt = 0;
4575 wl_data->pos = 0;
4576
4577 u64 words_cur = 0;
4578
4579 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4580 {
4581 u64 words_off = 0;
4582 u64 words_fin = 0;
4583
4584 bool allow_div = true;
4585
4586 u64 max = -1;
4587
4588 while (max)
4589 {
4590 const uint work = get_work (device_param, max, allow_div);
4591
4592 allow_div = false;
4593
4594 if (work == 0) break;
4595
4596 words_off = device_param->words_off;
4597 words_fin = words_off + work;
4598
4599 char *line_buf;
4600 uint line_len;
4601
4602 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4603
4604 max = 0;
4605
4606 for ( ; words_cur < words_fin; words_cur++)
4607 {
4608 get_next_word (wl_data, fd, &line_buf, &line_len);
4609
4610 line_len = convert_from_hex (line_buf, line_len);
4611
4612 // post-process rule engine
4613
4614 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4615 {
4616 char rule_buf_out[BLOCK_SIZE] = { 0 };
4617
4618 int rule_len_out = -1;
4619
4620 if (line_len < BLOCK_SIZE)
4621 {
4622 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4623 }
4624
4625 if (rule_len_out < 0) continue;
4626
4627 line_buf = rule_buf_out;
4628 line_len = rule_len_out;
4629 }
4630
4631 if (attack_kern == ATTACK_KERN_STRAIGHT)
4632 {
4633 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4634 {
4635 max++;
4636
4637 hc_thread_mutex_lock (mux_counter);
4638
4639 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4640 {
4641 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4642 }
4643
4644 hc_thread_mutex_unlock (mux_counter);
4645
4646 continue;
4647 }
4648 }
4649 else if (attack_kern == ATTACK_KERN_COMBI)
4650 {
4651 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4652 // since we still need to combine the plains
4653
4654 if (line_len > data.pw_max)
4655 {
4656 max++;
4657
4658 hc_thread_mutex_lock (mux_counter);
4659
4660 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4661 {
4662 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4663 }
4664
4665 hc_thread_mutex_unlock (mux_counter);
4666
4667 continue;
4668 }
4669 }
4670
4671 pw_add (device_param, (u8 *) line_buf, line_len);
4672
4673 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 if (data.devices_status == STATUS_ABORTED) break;
4677 if (data.devices_status == STATUS_QUIT) break;
4678 if (data.devices_status == STATUS_BYPASS) break;
4679 }
4680
4681 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4682
4683 if (data.devices_status == STATUS_CRACKED) break;
4684 if (data.devices_status == STATUS_ABORTED) break;
4685 if (data.devices_status == STATUS_QUIT) break;
4686 if (data.devices_status == STATUS_BYPASS) break;
4687 }
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 // flush
4698 //
4699
4700 const uint pws_cnt = device_param->pws_cnt;
4701
4702 if (pws_cnt)
4703 {
4704 run_copy (device_param, pws_cnt);
4705
4706 run_cracker (device_param, pws_cnt);
4707
4708 device_param->pws_cnt = 0;
4709
4710 /*
4711 still required?
4712 if (attack_kern == ATTACK_KERN_STRAIGHT)
4713 {
4714 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4715 }
4716 else if (attack_kern == ATTACK_KERN_COMBI)
4717 {
4718 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4719 }
4720 */
4721 }
4722
4723 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4724
4725 if (data.devices_status == STATUS_CRACKED) break;
4726 if (data.devices_status == STATUS_ABORTED) break;
4727 if (data.devices_status == STATUS_QUIT) break;
4728 if (data.devices_status == STATUS_BYPASS) break;
4729
4730 if (words_fin == 0) break;
4731
4732 device_param->words_done = words_fin;
4733 }
4734
4735 if (attack_mode == ATTACK_MODE_COMBI)
4736 {
4737 fclose (device_param->combs_fp);
4738 }
4739
4740 free (wl_data->buf);
4741 free (wl_data);
4742
4743 fclose (fd);
4744 }
4745
4746 device_param->kernel_accel = 0;
4747 device_param->kernel_loops = 0;
4748
4749 return NULL;
4750 }
4751
4752 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4753 {
4754 if (!device_param)
4755 {
4756 log_error ("ERROR: %s : Invalid argument", __func__);
4757
4758 exit (-1);
4759 }
4760
4761 salt_t *salt_buf = &data.salts_buf[salt_pos];
4762
4763 device_param->kernel_params_buf32[24] = salt_pos;
4764 device_param->kernel_params_buf32[27] = 1;
4765 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4766 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4767 device_param->kernel_params_buf32[30] = 0;
4768 device_param->kernel_params_buf32[31] = 1;
4769
4770 char *dictfile_old = data.dictfile;
4771
4772 const char *weak_hash_check = "weak-hash-check";
4773
4774 data.dictfile = (char *) weak_hash_check;
4775
4776 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4777
4778 data.kernel_rules_buf[0].cmds[0] = 0;
4779
4780 /**
4781 * run the kernel
4782 */
4783
4784 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4785 {
4786 run_kernel (KERN_RUN_1, device_param, 1, false);
4787 }
4788 else
4789 {
4790 run_kernel (KERN_RUN_1, device_param, 1, false);
4791
4792 uint loop_step = 16;
4793
4794 const uint iter = salt_buf->salt_iter;
4795
4796 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4797 {
4798 uint loop_left = iter - loop_pos;
4799
4800 loop_left = MIN (loop_left, loop_step);
4801
4802 device_param->kernel_params_buf32[25] = loop_pos;
4803 device_param->kernel_params_buf32[26] = loop_left;
4804
4805 run_kernel (KERN_RUN_2, device_param, 1, false);
4806 }
4807
4808 run_kernel (KERN_RUN_3, device_param, 1, false);
4809 }
4810
4811 /**
4812 * result
4813 */
4814
4815 check_cracked (device_param, salt_pos);
4816
4817 /**
4818 * cleanup
4819 */
4820
4821 device_param->kernel_params_buf32[24] = 0;
4822 device_param->kernel_params_buf32[25] = 0;
4823 device_param->kernel_params_buf32[26] = 0;
4824 device_param->kernel_params_buf32[27] = 0;
4825 device_param->kernel_params_buf32[28] = 0;
4826 device_param->kernel_params_buf32[29] = 0;
4827 device_param->kernel_params_buf32[30] = 0;
4828 device_param->kernel_params_buf32[31] = 0;
4829
4830 data.dictfile = dictfile_old;
4831
4832 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4833 }
4834
4835 // hlfmt hashcat
4836
4837 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4838 {
4839 if (data.username == 0)
4840 {
4841 *hashbuf_pos = line_buf;
4842 *hashbuf_len = line_len;
4843 }
4844 else
4845 {
4846 char *pos = line_buf;
4847 int len = line_len;
4848
4849 for (int i = 0; i < line_len; i++, pos++, len--)
4850 {
4851 if (line_buf[i] == data.separator)
4852 {
4853 pos++;
4854
4855 len--;
4856
4857 break;
4858 }
4859 }
4860
4861 *hashbuf_pos = pos;
4862 *hashbuf_len = len;
4863 }
4864 }
4865
4866 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4867 {
4868 char *pos = NULL;
4869 int len = 0;
4870
4871 int sep_cnt = 0;
4872
4873 for (int i = 0; i < line_len; i++)
4874 {
4875 if (line_buf[i] == data.separator)
4876 {
4877 sep_cnt++;
4878
4879 continue;
4880 }
4881
4882 if (sep_cnt == 0)
4883 {
4884 if (pos == NULL) pos = line_buf + i;
4885
4886 len++;
4887 }
4888 }
4889
4890 *userbuf_pos = pos;
4891 *userbuf_len = len;
4892 }
4893
4894 // hlfmt pwdump
4895
4896 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4897 {
4898 int sep_cnt = 0;
4899
4900 int sep2_len = 0;
4901 int sep3_len = 0;
4902
4903 for (int i = 0; i < line_len; i++)
4904 {
4905 if (line_buf[i] == ':')
4906 {
4907 sep_cnt++;
4908
4909 continue;
4910 }
4911
4912 if (sep_cnt == 2) sep2_len++;
4913 if (sep_cnt == 3) sep3_len++;
4914 }
4915
4916 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4917
4918 return 0;
4919 }
4920
4921 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4922 {
4923 char *pos = NULL;
4924 int len = 0;
4925
4926 int sep_cnt = 0;
4927
4928 for (int i = 0; i < line_len; i++)
4929 {
4930 if (line_buf[i] == ':')
4931 {
4932 sep_cnt++;
4933
4934 continue;
4935 }
4936
4937 if (data.hash_mode == 1000)
4938 {
4939 if (sep_cnt == 3)
4940 {
4941 if (pos == NULL) pos = line_buf + i;
4942
4943 len++;
4944 }
4945 }
4946 else if (data.hash_mode == 3000)
4947 {
4948 if (sep_cnt == 2)
4949 {
4950 if (pos == NULL) pos = line_buf + i;
4951
4952 len++;
4953 }
4954 }
4955 }
4956
4957 *hashbuf_pos = pos;
4958 *hashbuf_len = len;
4959 }
4960
4961 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4962 {
4963 char *pos = NULL;
4964 int len = 0;
4965
4966 int sep_cnt = 0;
4967
4968 for (int i = 0; i < line_len; i++)
4969 {
4970 if (line_buf[i] == ':')
4971 {
4972 sep_cnt++;
4973
4974 continue;
4975 }
4976
4977 if (sep_cnt == 0)
4978 {
4979 if (pos == NULL) pos = line_buf + i;
4980
4981 len++;
4982 }
4983 }
4984
4985 *userbuf_pos = pos;
4986 *userbuf_len = len;
4987 }
4988
4989 // hlfmt passwd
4990
4991 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4992 {
4993 int sep_cnt = 0;
4994
4995 char sep5_first = 0;
4996 char sep6_first = 0;
4997
4998 for (int i = 0; i < line_len; i++)
4999 {
5000 if (line_buf[i] == ':')
5001 {
5002 sep_cnt++;
5003
5004 continue;
5005 }
5006
5007 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5008 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5009 }
5010
5011 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5012
5013 return 0;
5014 }
5015
5016 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5017 {
5018 char *pos = NULL;
5019 int len = 0;
5020
5021 int sep_cnt = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 1)
5033 {
5034 if (pos == NULL) pos = line_buf + i;
5035
5036 len++;
5037 }
5038 }
5039
5040 *hashbuf_pos = pos;
5041 *hashbuf_len = len;
5042 }
5043
5044 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5045 {
5046 char *pos = NULL;
5047 int len = 0;
5048
5049 int sep_cnt = 0;
5050
5051 for (int i = 0; i < line_len; i++)
5052 {
5053 if (line_buf[i] == ':')
5054 {
5055 sep_cnt++;
5056
5057 continue;
5058 }
5059
5060 if (sep_cnt == 0)
5061 {
5062 if (pos == NULL) pos = line_buf + i;
5063
5064 len++;
5065 }
5066 }
5067
5068 *userbuf_pos = pos;
5069 *userbuf_len = len;
5070 }
5071
5072 // hlfmt shadow
5073
5074 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5075 {
5076 int sep_cnt = 0;
5077
5078 for (int i = 0; i < line_len; i++)
5079 {
5080 if (line_buf[i] == ':') sep_cnt++;
5081 }
5082
5083 if (sep_cnt == 8) return 1;
5084
5085 return 0;
5086 }
5087
5088 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5089 {
5090 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5091 }
5092
5093 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5094 {
5095 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5096 }
5097
5098 // hlfmt main
5099
5100 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5101 {
5102 switch (hashfile_format)
5103 {
5104 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5105 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5106 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5107 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5108 }
5109 }
5110
5111 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5112 {
5113 switch (hashfile_format)
5114 {
5115 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5116 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5117 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5118 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5119 }
5120 }
5121
5122 char *strhlfmt (const uint hashfile_format)
5123 {
5124 switch (hashfile_format)
5125 {
5126 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5127 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5128 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5129 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5130 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5131 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5132 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5133 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5134 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5135 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5136 }
5137
5138 return ((char *) "Unknown");
5139 }
5140
5141 static uint hlfmt_detect (FILE *fp, uint max_check)
5142 {
5143 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5144
5145 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5146 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5147
5148 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5149
5150 uint num_check = 0;
5151
5152 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5153
5154 while (!feof (fp))
5155 {
5156 int line_len = fgetl (fp, line_buf);
5157
5158 if (line_len == 0) continue;
5159
5160 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5161 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5162 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5163
5164 if (num_check == max_check) break;
5165
5166 num_check++;
5167 }
5168
5169 myfree (line_buf);
5170
5171 uint hashlist_format = HLFMT_HASHCAT;
5172
5173 for (int i = 1; i < HLFMTS_CNT; i++)
5174 {
5175 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5176
5177 hashlist_format = i;
5178 }
5179
5180 free (formats_cnt);
5181
5182 return hashlist_format;
5183 }
5184
5185 /**
5186 * some further helper function
5187 */
5188
5189 // wrapper around mymalloc for ADL
5190
5191 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5192 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5193 {
5194 return mymalloc (iSize);
5195 }
5196 #endif
5197
5198 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)
5199 {
5200 u64 collisions = 0;
5201
5202 const uint dgst_pos0 = data.dgst_pos0;
5203 const uint dgst_pos1 = data.dgst_pos1;
5204 const uint dgst_pos2 = data.dgst_pos2;
5205 const uint dgst_pos3 = data.dgst_pos3;
5206
5207 memset (bitmap_a, 0, bitmap_size);
5208 memset (bitmap_b, 0, bitmap_size);
5209 memset (bitmap_c, 0, bitmap_size);
5210 memset (bitmap_d, 0, bitmap_size);
5211
5212 for (uint i = 0; i < digests_cnt; i++)
5213 {
5214 uint *digest_ptr = (uint *) digests_buf_ptr;
5215
5216 digests_buf_ptr += dgst_size;
5217
5218 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5219 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5220 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5221 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5222
5223 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5224 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5225 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5226 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5227
5228 if (bitmap_a[idx0] & val0) collisions++;
5229 if (bitmap_b[idx1] & val1) collisions++;
5230 if (bitmap_c[idx2] & val2) collisions++;
5231 if (bitmap_d[idx3] & val3) collisions++;
5232
5233 bitmap_a[idx0] |= val0;
5234 bitmap_b[idx1] |= val1;
5235 bitmap_c[idx2] |= val2;
5236 bitmap_d[idx3] |= val3;
5237
5238 if (collisions >= collisions_max) return 0x7fffffff;
5239 }
5240
5241 return collisions;
5242 }
5243
5244 /**
5245 * main
5246 */
5247
5248 int main (int argc, char **argv)
5249 {
5250 /**
5251 * To help users a bit
5252 */
5253
5254 char *compute = getenv ("COMPUTE");
5255
5256 if (compute)
5257 {
5258 static char display[100];
5259
5260 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5261
5262 putenv (display);
5263 }
5264 else
5265 {
5266 if (getenv ("DISPLAY") == NULL)
5267 putenv ((char *) "DISPLAY=:0");
5268 }
5269
5270 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5271 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5272
5273 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5274 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5275
5276 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5277 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5278
5279 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5280 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5281
5282 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5283 putenv ((char *) "POCL_KERNEL_CACHE=0");
5284
5285 umask (077);
5286
5287 /**
5288 * Real init
5289 */
5290
5291 memset (&data, 0, sizeof (hc_global_data_t));
5292
5293 time_t proc_start;
5294
5295 time (&proc_start);
5296
5297 data.proc_start = proc_start;
5298
5299 int myargc = argc;
5300 char **myargv = argv;
5301
5302 hc_thread_mutex_init (mux_dispatcher);
5303 hc_thread_mutex_init (mux_counter);
5304 hc_thread_mutex_init (mux_display);
5305 hc_thread_mutex_init (mux_adl);
5306
5307 /**
5308 * commandline parameters
5309 */
5310
5311 uint usage = USAGE;
5312 uint version = VERSION;
5313 uint quiet = QUIET;
5314 uint benchmark = BENCHMARK;
5315 uint show = SHOW;
5316 uint left = LEFT;
5317 uint username = USERNAME;
5318 uint remove = REMOVE;
5319 uint remove_timer = REMOVE_TIMER;
5320 u64 skip = SKIP;
5321 u64 limit = LIMIT;
5322 uint keyspace = KEYSPACE;
5323 uint potfile_disable = POTFILE_DISABLE;
5324 char *potfile_path = NULL;
5325 uint debug_mode = DEBUG_MODE;
5326 char *debug_file = NULL;
5327 char *induction_dir = NULL;
5328 char *outfile_check_dir = NULL;
5329 uint force = FORCE;
5330 uint runtime = RUNTIME;
5331 uint hash_mode = HASH_MODE;
5332 uint attack_mode = ATTACK_MODE;
5333 uint markov_disable = MARKOV_DISABLE;
5334 uint markov_classic = MARKOV_CLASSIC;
5335 uint markov_threshold = MARKOV_THRESHOLD;
5336 char *markov_hcstat = NULL;
5337 char *outfile = NULL;
5338 uint outfile_format = OUTFILE_FORMAT;
5339 uint outfile_autohex = OUTFILE_AUTOHEX;
5340 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5341 uint restore = RESTORE;
5342 uint restore_timer = RESTORE_TIMER;
5343 uint restore_disable = RESTORE_DISABLE;
5344 uint status = STATUS;
5345 uint status_timer = STATUS_TIMER;
5346 uint status_automat = STATUS_AUTOMAT;
5347 uint loopback = LOOPBACK;
5348 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5349 char *session = NULL;
5350 uint hex_charset = HEX_CHARSET;
5351 uint hex_salt = HEX_SALT;
5352 uint hex_wordlist = HEX_WORDLIST;
5353 uint rp_gen = RP_GEN;
5354 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5355 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5356 uint rp_gen_seed = RP_GEN_SEED;
5357 char *rule_buf_l = (char *) RULE_BUF_L;
5358 char *rule_buf_r = (char *) RULE_BUF_R;
5359 uint increment = INCREMENT;
5360 uint increment_min = INCREMENT_MIN;
5361 uint increment_max = INCREMENT_MAX;
5362 char *cpu_affinity = NULL;
5363 OCL_PTR *ocl = NULL;
5364 char *opencl_devices = NULL;
5365 char *opencl_platforms = NULL;
5366 char *opencl_device_types = NULL;
5367 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5368 char *truecrypt_keyfiles = NULL;
5369 char *veracrypt_keyfiles = NULL;
5370 uint veracrypt_pim = 0;
5371 uint workload_profile = WORKLOAD_PROFILE;
5372 uint kernel_accel = KERNEL_ACCEL;
5373 uint kernel_loops = KERNEL_LOOPS;
5374 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5375 #ifdef HAVE_HWMON
5376 uint gpu_temp_abort = GPU_TEMP_ABORT;
5377 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5378 #ifdef HAVE_ADL
5379 uint powertune_enable = POWERTUNE_ENABLE;
5380 #endif
5381 #endif
5382 uint logfile_disable = LOGFILE_DISABLE;
5383 uint segment_size = SEGMENT_SIZE;
5384 uint scrypt_tmto = SCRYPT_TMTO;
5385 char separator = SEPARATOR;
5386 uint bitmap_min = BITMAP_MIN;
5387 uint bitmap_max = BITMAP_MAX;
5388 char *custom_charset_1 = NULL;
5389 char *custom_charset_2 = NULL;
5390 char *custom_charset_3 = NULL;
5391 char *custom_charset_4 = NULL;
5392
5393 #define IDX_HELP 'h'
5394 #define IDX_VERSION 'V'
5395 #define IDX_VERSION_LOWER 'v'
5396 #define IDX_QUIET 0xff02
5397 #define IDX_SHOW 0xff03
5398 #define IDX_LEFT 0xff04
5399 #define IDX_REMOVE 0xff05
5400 #define IDX_REMOVE_TIMER 0xff37
5401 #define IDX_SKIP 's'
5402 #define IDX_LIMIT 'l'
5403 #define IDX_KEYSPACE 0xff35
5404 #define IDX_POTFILE_DISABLE 0xff06
5405 #define IDX_POTFILE_PATH 0xffe0
5406 #define IDX_DEBUG_MODE 0xff43
5407 #define IDX_DEBUG_FILE 0xff44
5408 #define IDX_INDUCTION_DIR 0xff46
5409 #define IDX_OUTFILE_CHECK_DIR 0xff47
5410 #define IDX_USERNAME 0xff07
5411 #define IDX_FORCE 0xff08
5412 #define IDX_RUNTIME 0xff09
5413 #define IDX_BENCHMARK 'b'
5414 #define IDX_HASH_MODE 'm'
5415 #define IDX_ATTACK_MODE 'a'
5416 #define IDX_RP_FILE 'r'
5417 #define IDX_RP_GEN 'g'
5418 #define IDX_RP_GEN_FUNC_MIN 0xff10
5419 #define IDX_RP_GEN_FUNC_MAX 0xff11
5420 #define IDX_RP_GEN_SEED 0xff34
5421 #define IDX_RULE_BUF_L 'j'
5422 #define IDX_RULE_BUF_R 'k'
5423 #define IDX_INCREMENT 'i'
5424 #define IDX_INCREMENT_MIN 0xff12
5425 #define IDX_INCREMENT_MAX 0xff13
5426 #define IDX_OUTFILE 'o'
5427 #define IDX_OUTFILE_FORMAT 0xff14
5428 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5429 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5430 #define IDX_RESTORE 0xff15
5431 #define IDX_RESTORE_DISABLE 0xff27
5432 #define IDX_STATUS 0xff17
5433 #define IDX_STATUS_TIMER 0xff18
5434 #define IDX_STATUS_AUTOMAT 0xff50
5435 #define IDX_LOOPBACK 0xff38
5436 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5437 #define IDX_SESSION 0xff19
5438 #define IDX_HEX_CHARSET 0xff20
5439 #define IDX_HEX_SALT 0xff21
5440 #define IDX_HEX_WORDLIST 0xff40
5441 #define IDX_MARKOV_DISABLE 0xff22
5442 #define IDX_MARKOV_CLASSIC 0xff23
5443 #define IDX_MARKOV_THRESHOLD 't'
5444 #define IDX_MARKOV_HCSTAT 0xff24
5445 #define IDX_CPU_AFFINITY 0xff25
5446 #define IDX_OPENCL_DEVICES 'd'
5447 #define IDX_OPENCL_PLATFORMS 0xff72
5448 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5449 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5450 #define IDX_WORKLOAD_PROFILE 'w'
5451 #define IDX_KERNEL_ACCEL 'n'
5452 #define IDX_KERNEL_LOOPS 'u'
5453 #define IDX_GPU_TEMP_DISABLE 0xff29
5454 #define IDX_GPU_TEMP_ABORT 0xff30
5455 #define IDX_GPU_TEMP_RETAIN 0xff31
5456 #define IDX_POWERTUNE_ENABLE 0xff41
5457 #define IDX_LOGFILE_DISABLE 0xff51
5458 #define IDX_TRUECRYPT_KEYFILES 0xff52
5459 #define IDX_VERACRYPT_KEYFILES 0xff53
5460 #define IDX_VERACRYPT_PIM 0xff54
5461 #define IDX_SCRYPT_TMTO 0xff61
5462 #define IDX_SEGMENT_SIZE 'c'
5463 #define IDX_SEPARATOR 'p'
5464 #define IDX_BITMAP_MIN 0xff70
5465 #define IDX_BITMAP_MAX 0xff71
5466 #define IDX_CUSTOM_CHARSET_1 '1'
5467 #define IDX_CUSTOM_CHARSET_2 '2'
5468 #define IDX_CUSTOM_CHARSET_3 '3'
5469 #define IDX_CUSTOM_CHARSET_4 '4'
5470
5471 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5472
5473 struct option long_options[] =
5474 {
5475 {"help", no_argument, 0, IDX_HELP},
5476 {"version", no_argument, 0, IDX_VERSION},
5477 {"quiet", no_argument, 0, IDX_QUIET},
5478 {"show", no_argument, 0, IDX_SHOW},
5479 {"left", no_argument, 0, IDX_LEFT},
5480 {"username", no_argument, 0, IDX_USERNAME},
5481 {"remove", no_argument, 0, IDX_REMOVE},
5482 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5483 {"skip", required_argument, 0, IDX_SKIP},
5484 {"limit", required_argument, 0, IDX_LIMIT},
5485 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5486 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5487 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5488 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5489 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5490 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5491 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5492 {"force", no_argument, 0, IDX_FORCE},
5493 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5494 {"restore", no_argument, 0, IDX_RESTORE},
5495 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5496 {"status", no_argument, 0, IDX_STATUS},
5497 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5498 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5499 {"loopback", no_argument, 0, IDX_LOOPBACK},
5500 {"weak-hash-threshold",
5501 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5502 {"session", required_argument, 0, IDX_SESSION},
5503 {"runtime", required_argument, 0, IDX_RUNTIME},
5504 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5505 {"generate-rules-func-min",
5506 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5507 {"generate-rules-func-max",
5508 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5509 {"generate-rules-seed",
5510 required_argument, 0, IDX_RP_GEN_SEED},
5511 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5512 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5513 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5514 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5515 {"rules-file", required_argument, 0, IDX_RP_FILE},
5516 {"outfile", required_argument, 0, IDX_OUTFILE},
5517 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5518 {"outfile-autohex-disable",
5519 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5520 {"outfile-check-timer",
5521 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5522 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5523 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5524 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5525 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5526 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5527 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5528 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5529 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5530 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5531 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5532 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5533 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5534 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5535 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5536 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5537 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5538 #ifdef HAVE_HWMON
5539 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5540 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5541 #ifdef HAVE_ADL
5542 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5543 #endif
5544 #endif // HAVE_HWMON
5545 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5546 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5547 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5548 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5549 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5550 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5551 // deprecated
5552 {"seperator", required_argument, 0, IDX_SEPARATOR},
5553 {"separator", required_argument, 0, IDX_SEPARATOR},
5554 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5555 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5556 {"increment", no_argument, 0, IDX_INCREMENT},
5557 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5558 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5559 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5560 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5561 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5562 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5563
5564 {0, 0, 0, 0}
5565 };
5566
5567 uint rp_files_cnt = 0;
5568
5569 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5570
5571 int option_index = 0;
5572 int c = -1;
5573
5574 optind = 1;
5575 optopt = 0;
5576
5577 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5578 {
5579 switch (c)
5580 {
5581 case IDX_HELP: usage = 1; break;
5582 case IDX_VERSION:
5583 case IDX_VERSION_LOWER: version = 1; break;
5584 case IDX_RESTORE: restore = 1; break;
5585 case IDX_SESSION: session = optarg; break;
5586 case IDX_SHOW: show = 1; break;
5587 case IDX_LEFT: left = 1; break;
5588 case '?': return (-1);
5589 }
5590 }
5591
5592 if (optopt != 0)
5593 {
5594 log_error ("ERROR: Invalid argument specified");
5595
5596 return (-1);
5597 }
5598
5599 /**
5600 * exit functions
5601 */
5602
5603 if (version)
5604 {
5605 log_info ("%s", VERSION_TAG);
5606
5607 return (0);
5608 }
5609
5610 if (usage)
5611 {
5612 usage_big_print (PROGNAME);
5613
5614 return (0);
5615 }
5616
5617 /**
5618 * session needs to be set, always!
5619 */
5620
5621 if (session == NULL) session = (char *) PROGNAME;
5622
5623 /**
5624 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5625 */
5626
5627 char *exec_path = get_exec_path ();
5628
5629 #ifdef LINUX
5630
5631 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5632 char *resolved_exec_path = realpath (exec_path, NULL);
5633
5634 char *install_dir = get_install_dir (resolved_exec_path);
5635 char *profile_dir = NULL;
5636 char *session_dir = NULL;
5637 char *shared_dir = NULL;
5638
5639 if (strcmp (install_dir, resolved_install_folder) == 0)
5640 {
5641 struct passwd *pw = getpwuid (getuid ());
5642
5643 const char *homedir = pw->pw_dir;
5644
5645 profile_dir = get_profile_dir (homedir);
5646 session_dir = get_session_dir (profile_dir);
5647 shared_dir = strdup (SHARED_FOLDER);
5648
5649 mkdir (profile_dir, 0700);
5650 mkdir (session_dir, 0700);
5651 }
5652 else
5653 {
5654 profile_dir = install_dir;
5655 session_dir = install_dir;
5656 shared_dir = install_dir;
5657 }
5658
5659 myfree (resolved_install_folder);
5660 myfree (resolved_exec_path);
5661
5662 #else
5663
5664 char *install_dir = get_install_dir (exec_path);
5665 char *profile_dir = install_dir;
5666 char *session_dir = install_dir;
5667 char *shared_dir = install_dir;
5668
5669 #endif
5670
5671 data.install_dir = install_dir;
5672 data.profile_dir = profile_dir;
5673 data.session_dir = session_dir;
5674 data.shared_dir = shared_dir;
5675
5676 myfree (exec_path);
5677
5678 /**
5679 * kernel cache, we need to make sure folder exist
5680 */
5681
5682 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5683
5684 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5685
5686 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5687
5688 mkdir (kernels_folder, 0700);
5689
5690 myfree (kernels_folder);
5691
5692 /**
5693 * session
5694 */
5695
5696 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5697
5698 data.session = session;
5699
5700 char *eff_restore_file = (char *) mymalloc (session_size);
5701 char *new_restore_file = (char *) mymalloc (session_size);
5702
5703 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5704 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5705
5706 data.eff_restore_file = eff_restore_file;
5707 data.new_restore_file = new_restore_file;
5708
5709 if (((show == 1) || (left == 1)) && (restore == 1))
5710 {
5711 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5712 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5713
5714 return (-1);
5715 }
5716
5717 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5718 if ((show == 1) || (left == 1))
5719 {
5720 restore_disable = 1;
5721
5722 restore = 0;
5723 }
5724
5725 data.restore_disable = restore_disable;
5726
5727 restore_data_t *rd = init_restore (argc, argv);
5728
5729 data.rd = rd;
5730
5731 /**
5732 * restore file
5733 */
5734
5735 if (restore == 1)
5736 {
5737 read_restore (eff_restore_file, rd);
5738
5739 if (rd->version_bin < RESTORE_MIN)
5740 {
5741 log_error ("ERROR: Incompatible restore-file version");
5742
5743 return (-1);
5744 }
5745
5746 myargc = rd->argc;
5747 myargv = rd->argv;
5748
5749 #ifdef _POSIX
5750 rd->pid = getpid ();
5751 #elif _WIN
5752 rd->pid = GetCurrentProcessId ();
5753 #endif
5754 }
5755
5756 uint hash_mode_chgd = 0;
5757 uint runtime_chgd = 0;
5758 uint kernel_loops_chgd = 0;
5759 uint kernel_accel_chgd = 0;
5760 uint attack_mode_chgd = 0;
5761 uint outfile_format_chgd = 0;
5762 uint rp_gen_seed_chgd = 0;
5763 uint remove_timer_chgd = 0;
5764 uint increment_min_chgd = 0;
5765 uint increment_max_chgd = 0;
5766 uint workload_profile_chgd = 0;
5767 uint opencl_vector_width_chgd = 0;
5768
5769 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5770 uint gpu_temp_retain_chgd = 0;
5771 uint gpu_temp_abort_chgd = 0;
5772 #endif
5773
5774 optind = 1;
5775 optopt = 0;
5776 option_index = 0;
5777
5778 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5779 {
5780 switch (c)
5781 {
5782 //case IDX_HELP: usage = 1; break;
5783 //case IDX_VERSION: version = 1; break;
5784 //case IDX_RESTORE: restore = 1; break;
5785 case IDX_QUIET: quiet = 1; break;
5786 //case IDX_SHOW: show = 1; break;
5787 case IDX_SHOW: break;
5788 //case IDX_LEFT: left = 1; break;
5789 case IDX_LEFT: break;
5790 case IDX_USERNAME: username = 1; break;
5791 case IDX_REMOVE: remove = 1; break;
5792 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5793 remove_timer_chgd = 1; break;
5794 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5795 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5796 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5797 case IDX_DEBUG_FILE: debug_file = optarg; break;
5798 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5799 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5800 case IDX_FORCE: force = 1; break;
5801 case IDX_SKIP: skip = atoll (optarg); break;
5802 case IDX_LIMIT: limit = atoll (optarg); break;
5803 case IDX_KEYSPACE: keyspace = 1; break;
5804 case IDX_BENCHMARK: benchmark = 1; break;
5805 case IDX_RESTORE: break;
5806 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5807 case IDX_STATUS: status = 1; break;
5808 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5809 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5810 case IDX_LOOPBACK: loopback = 1; break;
5811 case IDX_WEAK_HASH_THRESHOLD:
5812 weak_hash_threshold = atoi (optarg); break;
5813 //case IDX_SESSION: session = optarg; break;
5814 case IDX_SESSION: break;
5815 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5816 hash_mode_chgd = 1; break;
5817 case IDX_RUNTIME: runtime = atoi (optarg);
5818 runtime_chgd = 1; break;
5819 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5820 attack_mode_chgd = 1; break;
5821 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5822 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5823 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5824 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5825 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5826 rp_gen_seed_chgd = 1; break;
5827 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5828 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5829 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5830 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5831 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5832 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5833 case IDX_OUTFILE: outfile = optarg; break;
5834 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5835 outfile_format_chgd = 1; break;
5836 case IDX_OUTFILE_AUTOHEX_DISABLE:
5837 outfile_autohex = 0; break;
5838 case IDX_OUTFILE_CHECK_TIMER:
5839 outfile_check_timer = atoi (optarg); break;
5840 case IDX_HEX_CHARSET: hex_charset = 1; break;
5841 case IDX_HEX_SALT: hex_salt = 1; break;
5842 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5843 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5844 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5845 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5846 case IDX_OPENCL_DEVICE_TYPES:
5847 opencl_device_types = optarg; break;
5848 case IDX_OPENCL_VECTOR_WIDTH:
5849 opencl_vector_width = atoi (optarg);
5850 opencl_vector_width_chgd = 1; break;
5851 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5852 workload_profile_chgd = 1; break;
5853 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5854 kernel_accel_chgd = 1; break;
5855 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5856 kernel_loops_chgd = 1; break;
5857 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5858 #ifdef HAVE_HWMON
5859 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5860 #ifdef HAVE_ADL
5861 gpu_temp_abort_chgd = 1;
5862 #endif
5863 break;
5864 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5865 #ifdef HAVE_ADL
5866 gpu_temp_retain_chgd = 1;
5867 #endif
5868 break;
5869 #ifdef HAVE_ADL
5870 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5871 #endif
5872 #endif // HAVE_HWMON
5873 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5874 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5875 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5876 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5877 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5878 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5879 case IDX_SEPARATOR: separator = optarg[0]; break;
5880 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5881 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5882 case IDX_INCREMENT: increment = 1; break;
5883 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5884 increment_min_chgd = 1; break;
5885 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5886 increment_max_chgd = 1; break;
5887 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5888 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5889 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5890 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5891
5892 default:
5893 log_error ("ERROR: Invalid argument specified");
5894 return (-1);
5895 }
5896 }
5897
5898 if (optopt != 0)
5899 {
5900 log_error ("ERROR: Invalid argument specified");
5901
5902 return (-1);
5903 }
5904
5905 /**
5906 * Inform user things getting started,
5907 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5908 * - we do not need to check algorithm_pos
5909 */
5910
5911 if (quiet == 0)
5912 {
5913 if (benchmark == 1)
5914 {
5915 if (status_automat == 0)
5916 {
5917 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5918 log_info ("");
5919 }
5920 else
5921 {
5922 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5923 }
5924 }
5925 else if (restore == 1)
5926 {
5927 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5928 log_info ("");
5929 }
5930 else
5931 {
5932 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5933 log_info ("");
5934 }
5935 }
5936
5937 /**
5938 * sanity check
5939 */
5940
5941 if (attack_mode > 7)
5942 {
5943 log_error ("ERROR: Invalid attack-mode specified");
5944
5945 return (-1);
5946 }
5947
5948 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5949 {
5950 log_error ("ERROR: Invalid runtime specified");
5951
5952 return (-1);
5953 }
5954
5955 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5956 {
5957 log_error ("ERROR: Invalid hash-type specified");
5958
5959 return (-1);
5960 }
5961
5962 // renamed hash modes
5963
5964 if (hash_mode_chgd)
5965 {
5966 int n = -1;
5967
5968 switch (hash_mode)
5969 {
5970 case 123: n = 124;
5971 break;
5972 }
5973
5974 if (n >= 0)
5975 {
5976 log_error ("Old -m specified, use -m %d instead", n);
5977
5978 return (-1);
5979 }
5980 }
5981
5982 if (username == 1)
5983 {
5984 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5985 {
5986 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5987
5988 return (-1);
5989 }
5990 }
5991
5992 if (outfile_format > 16)
5993 {
5994 log_error ("ERROR: Invalid outfile-format specified");
5995
5996 return (-1);
5997 }
5998
5999 if (left == 1)
6000 {
6001 if (outfile_format_chgd == 1)
6002 {
6003 if (outfile_format > 1)
6004 {
6005 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6006
6007 return (-1);
6008 }
6009 }
6010 else
6011 {
6012 outfile_format = OUTFILE_FMT_HASH;
6013 }
6014 }
6015
6016 if (show == 1)
6017 {
6018 if (outfile_format_chgd == 1)
6019 {
6020 if ((outfile_format > 7) && (outfile_format < 16))
6021 {
6022 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6023
6024 return (-1);
6025 }
6026 }
6027 }
6028
6029 if (increment_min < INCREMENT_MIN)
6030 {
6031 log_error ("ERROR: Invalid increment-min specified");
6032
6033 return (-1);
6034 }
6035
6036 if (increment_max > INCREMENT_MAX)
6037 {
6038 log_error ("ERROR: Invalid increment-max specified");
6039
6040 return (-1);
6041 }
6042
6043 if (increment_min > increment_max)
6044 {
6045 log_error ("ERROR: Invalid increment-min specified");
6046
6047 return (-1);
6048 }
6049
6050 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6051 {
6052 log_error ("ERROR: increment is not allowed in attack-mode 0");
6053
6054 return (-1);
6055 }
6056
6057 if ((increment == 0) && (increment_min_chgd == 1))
6058 {
6059 log_error ("ERROR: increment-min is only supported together with increment switch");
6060
6061 return (-1);
6062 }
6063
6064 if ((increment == 0) && (increment_max_chgd == 1))
6065 {
6066 log_error ("ERROR: increment-max is only supported together with increment switch");
6067
6068 return (-1);
6069 }
6070
6071 if (rp_files_cnt && rp_gen)
6072 {
6073 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6074
6075 return (-1);
6076 }
6077
6078 if (rp_files_cnt || rp_gen)
6079 {
6080 if (attack_mode != ATTACK_MODE_STRAIGHT)
6081 {
6082 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6083
6084 return (-1);
6085 }
6086 }
6087
6088 if (rp_gen_func_min > rp_gen_func_max)
6089 {
6090 log_error ("ERROR: Invalid rp-gen-func-min specified");
6091
6092 return (-1);
6093 }
6094
6095 if (kernel_accel_chgd == 1)
6096 {
6097 if (kernel_accel < 1)
6098 {
6099 log_error ("ERROR: Invalid kernel-accel specified");
6100
6101 return (-1);
6102 }
6103
6104 if (kernel_accel > 1024)
6105 {
6106 log_error ("ERROR: Invalid kernel-accel specified");
6107
6108 return (-1);
6109 }
6110 }
6111
6112 if (kernel_loops_chgd == 1)
6113 {
6114 if (kernel_loops < 1)
6115 {
6116 log_error ("ERROR: Invalid kernel-loops specified");
6117
6118 return (-1);
6119 }
6120
6121 if (kernel_loops > 1024)
6122 {
6123 log_error ("ERROR: Invalid kernel-loops specified");
6124
6125 return (-1);
6126 }
6127 }
6128
6129 if ((workload_profile < 1) || (workload_profile > 3))
6130 {
6131 log_error ("ERROR: workload-profile %i not available", workload_profile);
6132
6133 return (-1);
6134 }
6135
6136 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6137 {
6138 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6139
6140 return (-1);
6141 }
6142
6143 if (show == 1 || left == 1)
6144 {
6145 attack_mode = ATTACK_MODE_NONE;
6146
6147 if (remove == 1)
6148 {
6149 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6150
6151 return (-1);
6152 }
6153
6154 if (potfile_disable == 1)
6155 {
6156 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6157
6158 return (-1);
6159 }
6160 }
6161
6162 uint attack_kern = ATTACK_KERN_NONE;
6163
6164 switch (attack_mode)
6165 {
6166 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6167 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6168 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6169 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6170 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6171 }
6172
6173 if (benchmark == 0)
6174 {
6175 if (keyspace == 1)
6176 {
6177 int num_additional_params = 1;
6178
6179 if (attack_kern == ATTACK_KERN_COMBI)
6180 {
6181 num_additional_params = 2;
6182 }
6183
6184 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6185
6186 if (keyspace_wordlist_specified == 0) optind--;
6187 }
6188
6189 if (attack_kern == ATTACK_KERN_NONE)
6190 {
6191 if ((optind + 1) != myargc)
6192 {
6193 usage_mini_print (myargv[0]);
6194
6195 return (-1);
6196 }
6197 }
6198 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6199 {
6200 if ((optind + 1) > myargc)
6201 {
6202 usage_mini_print (myargv[0]);
6203
6204 return (-1);
6205 }
6206 }
6207 else if (attack_kern == ATTACK_KERN_COMBI)
6208 {
6209 if ((optind + 3) != myargc)
6210 {
6211 usage_mini_print (myargv[0]);
6212
6213 return (-1);
6214 }
6215 }
6216 else if (attack_kern == ATTACK_KERN_BF)
6217 {
6218 if ((optind + 1) > myargc)
6219 {
6220 usage_mini_print (myargv[0]);
6221
6222 return (-1);
6223 }
6224 }
6225 else
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else
6233 {
6234 if (myargv[optind] != 0)
6235 {
6236 log_error ("ERROR: Invalid argument for benchmark mode specified");
6237
6238 return (-1);
6239 }
6240
6241 if (attack_mode_chgd == 1)
6242 {
6243 if (attack_mode != ATTACK_MODE_BF)
6244 {
6245 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6246
6247 return (-1);
6248 }
6249 }
6250 }
6251
6252 if (skip != 0 && limit != 0)
6253 {
6254 limit += skip;
6255 }
6256
6257 if (keyspace == 1)
6258 {
6259 if (show == 1)
6260 {
6261 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6262
6263 return (-1);
6264 }
6265 else if (left == 1)
6266 {
6267 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6268
6269 return (-1);
6270 }
6271
6272 potfile_disable = 1;
6273
6274 restore_disable = 1;
6275
6276 restore = 0;
6277
6278 weak_hash_threshold = 0;
6279
6280 quiet = 1;
6281 }
6282
6283 if (remove_timer_chgd == 1)
6284 {
6285 if (remove == 0)
6286 {
6287 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6288
6289 return (-1);
6290 }
6291
6292 if (remove_timer < 1)
6293 {
6294 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6295
6296 return (-1);
6297 }
6298 }
6299
6300 if (loopback == 1)
6301 {
6302 if (attack_mode == ATTACK_MODE_STRAIGHT)
6303 {
6304 if ((rp_files_cnt == 0) && (rp_gen == 0))
6305 {
6306 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6307
6308 return (-1);
6309 }
6310 }
6311 else
6312 {
6313 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (debug_mode > 0)
6320 {
6321 if (attack_mode != ATTACK_MODE_STRAIGHT)
6322 {
6323 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6324
6325 return (-1);
6326 }
6327
6328 if ((rp_files_cnt == 0) && (rp_gen == 0))
6329 {
6330 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6331
6332 return (-1);
6333 }
6334 }
6335
6336 if (debug_mode > 4)
6337 {
6338 log_error ("ERROR: Invalid debug-mode specified");
6339
6340 return (-1);
6341 }
6342
6343 if (debug_file != NULL)
6344 {
6345 if (debug_mode < 1)
6346 {
6347 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 if (induction_dir != NULL)
6354 {
6355 if (attack_mode == ATTACK_MODE_BF)
6356 {
6357 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6358
6359 return (-1);
6360 }
6361 }
6362
6363 if (attack_mode != ATTACK_MODE_STRAIGHT)
6364 {
6365 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6366 {
6367 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6368
6369 return (-1);
6370 }
6371
6372 weak_hash_threshold = 0;
6373 }
6374
6375 /**
6376 * induction directory
6377 */
6378
6379 char *induction_directory = NULL;
6380
6381 if (attack_mode != ATTACK_MODE_BF)
6382 {
6383 if (induction_dir == NULL)
6384 {
6385 induction_directory = (char *) mymalloc (session_size);
6386
6387 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6388
6389 // create induction folder if it does not already exist
6390
6391 if (keyspace == 0)
6392 {
6393 if (rmdir (induction_directory) == -1)
6394 {
6395 if (errno == ENOENT)
6396 {
6397 // good, we can ignore
6398 }
6399 else if (errno == ENOTEMPTY)
6400 {
6401 char *induction_directory_mv = (char *) mymalloc (session_size);
6402
6403 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6404
6405 if (rename (induction_directory, induction_directory_mv) != 0)
6406 {
6407 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6408
6409 return (-1);
6410 }
6411 }
6412 else
6413 {
6414 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6415
6416 return (-1);
6417 }
6418 }
6419
6420 if (mkdir (induction_directory, 0700) == -1)
6421 {
6422 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6423
6424 return (-1);
6425 }
6426 }
6427 }
6428 else
6429 {
6430 induction_directory = induction_dir;
6431 }
6432 }
6433
6434 data.induction_directory = induction_directory;
6435
6436 /**
6437 * loopback
6438 */
6439
6440 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6441
6442 char *loopback_file = (char *) mymalloc (loopback_size);
6443
6444 /**
6445 * tuning db
6446 */
6447
6448 char tuning_db_file[256] = { 0 };
6449
6450 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6451
6452 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6453
6454 /**
6455 * outfile-check directory
6456 */
6457
6458 char *outfile_check_directory = NULL;
6459
6460 if (outfile_check_dir == NULL)
6461 {
6462 outfile_check_directory = (char *) mymalloc (session_size);
6463
6464 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6465 }
6466 else
6467 {
6468 outfile_check_directory = outfile_check_dir;
6469 }
6470
6471 data.outfile_check_directory = outfile_check_directory;
6472
6473 if (keyspace == 0)
6474 {
6475 struct stat outfile_check_stat;
6476
6477 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6478 {
6479 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6480
6481 if (is_dir == 0)
6482 {
6483 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6484
6485 return (-1);
6486 }
6487 }
6488 else if (outfile_check_dir == NULL)
6489 {
6490 if (mkdir (outfile_check_directory, 0700) == -1)
6491 {
6492 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6493
6494 return (-1);
6495 }
6496 }
6497 }
6498
6499 /**
6500 * special other stuff
6501 */
6502
6503 if (hash_mode == 9710)
6504 {
6505 outfile_format = 5;
6506 outfile_format_chgd = 1;
6507 }
6508
6509 if (hash_mode == 9810)
6510 {
6511 outfile_format = 5;
6512 outfile_format_chgd = 1;
6513 }
6514
6515 if (hash_mode == 10410)
6516 {
6517 outfile_format = 5;
6518 outfile_format_chgd = 1;
6519 }
6520
6521 /**
6522 * store stuff
6523 */
6524
6525 data.hash_mode = hash_mode;
6526 data.restore = restore;
6527 data.restore_timer = restore_timer;
6528 data.restore_disable = restore_disable;
6529 data.status = status;
6530 data.status_timer = status_timer;
6531 data.status_automat = status_automat;
6532 data.loopback = loopback;
6533 data.runtime = runtime;
6534 data.remove = remove;
6535 data.remove_timer = remove_timer;
6536 data.debug_mode = debug_mode;
6537 data.debug_file = debug_file;
6538 data.username = username;
6539 data.quiet = quiet;
6540 data.outfile = outfile;
6541 data.outfile_format = outfile_format;
6542 data.outfile_autohex = outfile_autohex;
6543 data.hex_charset = hex_charset;
6544 data.hex_salt = hex_salt;
6545 data.hex_wordlist = hex_wordlist;
6546 data.separator = separator;
6547 data.rp_files = rp_files;
6548 data.rp_files_cnt = rp_files_cnt;
6549 data.rp_gen = rp_gen;
6550 data.rp_gen_seed = rp_gen_seed;
6551 data.force = force;
6552 data.benchmark = benchmark;
6553 data.skip = skip;
6554 data.limit = limit;
6555 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6556 data.powertune_enable = powertune_enable;
6557 #endif
6558 data.logfile_disable = logfile_disable;
6559 data.truecrypt_keyfiles = truecrypt_keyfiles;
6560 data.veracrypt_keyfiles = veracrypt_keyfiles;
6561 data.veracrypt_pim = veracrypt_pim;
6562 data.scrypt_tmto = scrypt_tmto;
6563 data.workload_profile = workload_profile;
6564
6565 /**
6566 * cpu affinity
6567 */
6568
6569 if (cpu_affinity)
6570 {
6571 set_cpu_affinity (cpu_affinity);
6572 }
6573
6574 if (rp_gen_seed_chgd == 0)
6575 {
6576 srand (proc_start);
6577 }
6578 else
6579 {
6580 srand (rp_gen_seed);
6581 }
6582
6583 /**
6584 * logfile init
6585 */
6586
6587 if (logfile_disable == 0)
6588 {
6589 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6590
6591 char *logfile = (char *) mymalloc (logfile_size);
6592
6593 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6594
6595 data.logfile = logfile;
6596
6597 char *topid = logfile_generate_topid ();
6598
6599 data.topid = topid;
6600 }
6601
6602 // logfile_append() checks for logfile_disable internally to make it easier from here
6603
6604 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6605 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6606 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6607 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6608 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6609 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6610 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6611 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6612 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6613 #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));
6614
6615 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6616 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6617 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6618 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6619 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6620 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6621 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6622 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6623
6624 logfile_top_msg ("START");
6625
6626 logfile_top_uint (attack_mode);
6627 logfile_top_uint (attack_kern);
6628 logfile_top_uint (benchmark);
6629 logfile_top_uint (bitmap_min);
6630 logfile_top_uint (bitmap_max);
6631 logfile_top_uint (debug_mode);
6632 logfile_top_uint (force);
6633 logfile_top_uint (kernel_accel);
6634 logfile_top_uint (kernel_loops);
6635 logfile_top_uint (gpu_temp_disable);
6636 #ifdef HAVE_HWMON
6637 logfile_top_uint (gpu_temp_abort);
6638 logfile_top_uint (gpu_temp_retain);
6639 #endif
6640 logfile_top_uint (hash_mode);
6641 logfile_top_uint (hex_charset);
6642 logfile_top_uint (hex_salt);
6643 logfile_top_uint (hex_wordlist);
6644 logfile_top_uint (increment);
6645 logfile_top_uint (increment_max);
6646 logfile_top_uint (increment_min);
6647 logfile_top_uint (keyspace);
6648 logfile_top_uint (left);
6649 logfile_top_uint (logfile_disable);
6650 logfile_top_uint (loopback);
6651 logfile_top_uint (markov_classic);
6652 logfile_top_uint (markov_disable);
6653 logfile_top_uint (markov_threshold);
6654 logfile_top_uint (outfile_autohex);
6655 logfile_top_uint (outfile_check_timer);
6656 logfile_top_uint (outfile_format);
6657 logfile_top_uint (potfile_disable);
6658 logfile_top_string (potfile_path);
6659 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6660 logfile_top_uint (powertune_enable);
6661 #endif
6662 logfile_top_uint (scrypt_tmto);
6663 logfile_top_uint (quiet);
6664 logfile_top_uint (remove);
6665 logfile_top_uint (remove_timer);
6666 logfile_top_uint (restore);
6667 logfile_top_uint (restore_disable);
6668 logfile_top_uint (restore_timer);
6669 logfile_top_uint (rp_gen);
6670 logfile_top_uint (rp_gen_func_max);
6671 logfile_top_uint (rp_gen_func_min);
6672 logfile_top_uint (rp_gen_seed);
6673 logfile_top_uint (runtime);
6674 logfile_top_uint (segment_size);
6675 logfile_top_uint (show);
6676 logfile_top_uint (status);
6677 logfile_top_uint (status_automat);
6678 logfile_top_uint (status_timer);
6679 logfile_top_uint (usage);
6680 logfile_top_uint (username);
6681 logfile_top_uint (version);
6682 logfile_top_uint (weak_hash_threshold);
6683 logfile_top_uint (workload_profile);
6684 logfile_top_uint64 (limit);
6685 logfile_top_uint64 (skip);
6686 logfile_top_char (separator);
6687 logfile_top_string (cpu_affinity);
6688 logfile_top_string (custom_charset_1);
6689 logfile_top_string (custom_charset_2);
6690 logfile_top_string (custom_charset_3);
6691 logfile_top_string (custom_charset_4);
6692 logfile_top_string (debug_file);
6693 logfile_top_string (opencl_devices);
6694 logfile_top_string (opencl_platforms);
6695 logfile_top_string (opencl_device_types);
6696 logfile_top_uint (opencl_vector_width);
6697 logfile_top_string (induction_dir);
6698 logfile_top_string (markov_hcstat);
6699 logfile_top_string (outfile);
6700 logfile_top_string (outfile_check_dir);
6701 logfile_top_string (rule_buf_l);
6702 logfile_top_string (rule_buf_r);
6703 logfile_top_string (session);
6704 logfile_top_string (truecrypt_keyfiles);
6705 logfile_top_string (veracrypt_keyfiles);
6706 logfile_top_uint (veracrypt_pim);
6707
6708 /**
6709 * Init OpenCL library loader
6710 */
6711
6712 if (keyspace == 0)
6713 {
6714 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6715
6716 ocl_init (ocl);
6717
6718 data.ocl = ocl;
6719 }
6720
6721 /**
6722 * OpenCL platform selection
6723 */
6724
6725 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6726
6727 /**
6728 * OpenCL device selection
6729 */
6730
6731 u32 devices_filter = setup_devices_filter (opencl_devices);
6732
6733 /**
6734 * OpenCL device type selection
6735 */
6736
6737 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6738
6739 /**
6740 * benchmark
6741 */
6742
6743 if (benchmark == 1)
6744 {
6745 /**
6746 * disable useless stuff for benchmark
6747 */
6748
6749 status_timer = 0;
6750 restore_timer = 0;
6751 restore_disable = 1;
6752 potfile_disable = 1;
6753 weak_hash_threshold = 0;
6754 gpu_temp_disable = 1;
6755
6756 data.status_timer = status_timer;
6757 data.restore_timer = restore_timer;
6758 data.restore_disable = restore_disable;
6759
6760 /**
6761 * force attack mode to be bruteforce
6762 */
6763
6764 attack_mode = ATTACK_MODE_BF;
6765 attack_kern = ATTACK_KERN_BF;
6766
6767 if (workload_profile_chgd == 0)
6768 {
6769 workload_profile = 3;
6770
6771 data.workload_profile = workload_profile;
6772 }
6773 }
6774
6775 /**
6776 * config
6777 */
6778
6779 uint hash_type = 0;
6780 uint salt_type = 0;
6781 uint attack_exec = 0;
6782 uint opts_type = 0;
6783 uint kern_type = 0;
6784 uint dgst_size = 0;
6785 uint esalt_size = 0;
6786 uint opti_type = 0;
6787 uint dgst_pos0 = -1;
6788 uint dgst_pos1 = -1;
6789 uint dgst_pos2 = -1;
6790 uint dgst_pos3 = -1;
6791
6792 int (*parse_func) (char *, uint, hash_t *);
6793 int (*sort_by_digest) (const void *, const void *);
6794
6795 uint algorithm_pos = 0;
6796 uint algorithm_max = 1;
6797
6798 uint *algorithms = default_benchmark_algorithms;
6799
6800 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6801
6802 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6803 {
6804 /*
6805 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6806 * the following algos are skipped entirely
6807 */
6808
6809 if (algorithm_pos > 0)
6810 {
6811 local_free (rd);
6812
6813 rd = init_restore (argc, argv);
6814
6815 data.rd = rd;
6816 }
6817
6818 /**
6819 * update hash_mode in case of multihash benchmark
6820 */
6821
6822 if (benchmark == 1)
6823 {
6824 if (hash_mode_chgd == 0)
6825 {
6826 hash_mode = algorithms[algorithm_pos];
6827
6828 data.hash_mode = hash_mode;
6829 }
6830
6831 quiet = 1;
6832
6833 data.quiet = quiet;
6834 }
6835
6836 switch (hash_mode)
6837 {
6838 case 0: hash_type = HASH_TYPE_MD5;
6839 salt_type = SALT_TYPE_NONE;
6840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6841 opts_type = OPTS_TYPE_PT_GENERATE_LE
6842 | OPTS_TYPE_PT_ADD80
6843 | OPTS_TYPE_PT_ADDBITS14;
6844 kern_type = KERN_TYPE_MD5;
6845 dgst_size = DGST_SIZE_4_4;
6846 parse_func = md5_parse_hash;
6847 sort_by_digest = sort_by_digest_4_4;
6848 opti_type = OPTI_TYPE_ZERO_BYTE
6849 | OPTI_TYPE_PRECOMPUTE_INIT
6850 | OPTI_TYPE_PRECOMPUTE_MERKLE
6851 | OPTI_TYPE_MEET_IN_MIDDLE
6852 | OPTI_TYPE_EARLY_SKIP
6853 | OPTI_TYPE_NOT_ITERATED
6854 | OPTI_TYPE_NOT_SALTED
6855 | OPTI_TYPE_RAW_HASH;
6856 dgst_pos0 = 0;
6857 dgst_pos1 = 3;
6858 dgst_pos2 = 2;
6859 dgst_pos3 = 1;
6860 break;
6861
6862 case 10: hash_type = HASH_TYPE_MD5;
6863 salt_type = SALT_TYPE_INTERN;
6864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6865 opts_type = OPTS_TYPE_PT_GENERATE_LE
6866 | OPTS_TYPE_ST_ADD80
6867 | OPTS_TYPE_ST_ADDBITS14;
6868 kern_type = KERN_TYPE_MD5_PWSLT;
6869 dgst_size = DGST_SIZE_4_4;
6870 parse_func = md5s_parse_hash;
6871 sort_by_digest = sort_by_digest_4_4;
6872 opti_type = OPTI_TYPE_ZERO_BYTE
6873 | OPTI_TYPE_PRECOMPUTE_INIT
6874 | OPTI_TYPE_PRECOMPUTE_MERKLE
6875 | OPTI_TYPE_MEET_IN_MIDDLE
6876 | OPTI_TYPE_EARLY_SKIP
6877 | OPTI_TYPE_NOT_ITERATED
6878 | OPTI_TYPE_APPENDED_SALT
6879 | OPTI_TYPE_RAW_HASH;
6880 dgst_pos0 = 0;
6881 dgst_pos1 = 3;
6882 dgst_pos2 = 2;
6883 dgst_pos3 = 1;
6884 break;
6885
6886 case 11: hash_type = HASH_TYPE_MD5;
6887 salt_type = SALT_TYPE_INTERN;
6888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6889 opts_type = OPTS_TYPE_PT_GENERATE_LE
6890 | OPTS_TYPE_ST_ADD80
6891 | OPTS_TYPE_ST_ADDBITS14;
6892 kern_type = KERN_TYPE_MD5_PWSLT;
6893 dgst_size = DGST_SIZE_4_4;
6894 parse_func = joomla_parse_hash;
6895 sort_by_digest = sort_by_digest_4_4;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_MEET_IN_MIDDLE
6900 | OPTI_TYPE_EARLY_SKIP
6901 | OPTI_TYPE_NOT_ITERATED
6902 | OPTI_TYPE_APPENDED_SALT
6903 | OPTI_TYPE_RAW_HASH;
6904 dgst_pos0 = 0;
6905 dgst_pos1 = 3;
6906 dgst_pos2 = 2;
6907 dgst_pos3 = 1;
6908 break;
6909
6910 case 12: hash_type = HASH_TYPE_MD5;
6911 salt_type = SALT_TYPE_INTERN;
6912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6913 opts_type = OPTS_TYPE_PT_GENERATE_LE
6914 | OPTS_TYPE_ST_ADD80
6915 | OPTS_TYPE_ST_ADDBITS14;
6916 kern_type = KERN_TYPE_MD5_PWSLT;
6917 dgst_size = DGST_SIZE_4_4;
6918 parse_func = postgresql_parse_hash;
6919 sort_by_digest = sort_by_digest_4_4;
6920 opti_type = OPTI_TYPE_ZERO_BYTE
6921 | OPTI_TYPE_PRECOMPUTE_INIT
6922 | OPTI_TYPE_PRECOMPUTE_MERKLE
6923 | OPTI_TYPE_MEET_IN_MIDDLE
6924 | OPTI_TYPE_EARLY_SKIP
6925 | OPTI_TYPE_NOT_ITERATED
6926 | OPTI_TYPE_APPENDED_SALT
6927 | OPTI_TYPE_RAW_HASH;
6928 dgst_pos0 = 0;
6929 dgst_pos1 = 3;
6930 dgst_pos2 = 2;
6931 dgst_pos3 = 1;
6932 break;
6933
6934 case 20: hash_type = HASH_TYPE_MD5;
6935 salt_type = SALT_TYPE_INTERN;
6936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6937 opts_type = OPTS_TYPE_PT_GENERATE_LE
6938 | OPTS_TYPE_PT_ADD80
6939 | OPTS_TYPE_PT_ADDBITS14;
6940 kern_type = KERN_TYPE_MD5_SLTPW;
6941 dgst_size = DGST_SIZE_4_4;
6942 parse_func = md5s_parse_hash;
6943 sort_by_digest = sort_by_digest_4_4;
6944 opti_type = OPTI_TYPE_ZERO_BYTE
6945 | OPTI_TYPE_PRECOMPUTE_INIT
6946 | OPTI_TYPE_PRECOMPUTE_MERKLE
6947 | OPTI_TYPE_EARLY_SKIP
6948 | OPTI_TYPE_NOT_ITERATED
6949 | OPTI_TYPE_PREPENDED_SALT
6950 | OPTI_TYPE_RAW_HASH;
6951 dgst_pos0 = 0;
6952 dgst_pos1 = 3;
6953 dgst_pos2 = 2;
6954 dgst_pos3 = 1;
6955 break;
6956
6957 case 21: hash_type = HASH_TYPE_MD5;
6958 salt_type = SALT_TYPE_INTERN;
6959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6960 opts_type = OPTS_TYPE_PT_GENERATE_LE
6961 | OPTS_TYPE_PT_ADD80
6962 | OPTS_TYPE_PT_ADDBITS14;
6963 kern_type = KERN_TYPE_MD5_SLTPW;
6964 dgst_size = DGST_SIZE_4_4;
6965 parse_func = osc_parse_hash;
6966 sort_by_digest = sort_by_digest_4_4;
6967 opti_type = OPTI_TYPE_ZERO_BYTE
6968 | OPTI_TYPE_PRECOMPUTE_INIT
6969 | OPTI_TYPE_PRECOMPUTE_MERKLE
6970 | OPTI_TYPE_EARLY_SKIP
6971 | OPTI_TYPE_NOT_ITERATED
6972 | OPTI_TYPE_PREPENDED_SALT
6973 | OPTI_TYPE_RAW_HASH;
6974 dgst_pos0 = 0;
6975 dgst_pos1 = 3;
6976 dgst_pos2 = 2;
6977 dgst_pos3 = 1;
6978 break;
6979
6980 case 22: hash_type = HASH_TYPE_MD5;
6981 salt_type = SALT_TYPE_EMBEDDED;
6982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6983 opts_type = OPTS_TYPE_PT_GENERATE_LE
6984 | OPTS_TYPE_PT_ADD80
6985 | OPTS_TYPE_PT_ADDBITS14;
6986 kern_type = KERN_TYPE_MD5_SLTPW;
6987 dgst_size = DGST_SIZE_4_4;
6988 parse_func = netscreen_parse_hash;
6989 sort_by_digest = sort_by_digest_4_4;
6990 opti_type = OPTI_TYPE_ZERO_BYTE
6991 | OPTI_TYPE_PRECOMPUTE_INIT
6992 | OPTI_TYPE_PRECOMPUTE_MERKLE
6993 | OPTI_TYPE_EARLY_SKIP
6994 | OPTI_TYPE_NOT_ITERATED
6995 | OPTI_TYPE_PREPENDED_SALT
6996 | OPTI_TYPE_RAW_HASH;
6997 dgst_pos0 = 0;
6998 dgst_pos1 = 3;
6999 dgst_pos2 = 2;
7000 dgst_pos3 = 1;
7001 break;
7002
7003 case 23: hash_type = HASH_TYPE_MD5;
7004 salt_type = SALT_TYPE_EMBEDDED;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_LE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5_SLTPW;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = skype_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 0;
7021 dgst_pos1 = 3;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 30: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_INTERN;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_LE
7030 | OPTS_TYPE_PT_UNICODE
7031 | OPTS_TYPE_ST_ADD80
7032 | OPTS_TYPE_ST_ADDBITS14;
7033 kern_type = KERN_TYPE_MD5_PWUSLT;
7034 dgst_size = DGST_SIZE_4_4;
7035 parse_func = md5s_parse_hash;
7036 sort_by_digest = sort_by_digest_4_4;
7037 opti_type = OPTI_TYPE_ZERO_BYTE
7038 | OPTI_TYPE_PRECOMPUTE_INIT
7039 | OPTI_TYPE_PRECOMPUTE_MERKLE
7040 | OPTI_TYPE_MEET_IN_MIDDLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_APPENDED_SALT
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 0;
7046 dgst_pos1 = 3;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 40: hash_type = HASH_TYPE_MD5;
7052 salt_type = SALT_TYPE_INTERN;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_LE
7055 | OPTS_TYPE_PT_ADD80
7056 | OPTS_TYPE_PT_ADDBITS14
7057 | OPTS_TYPE_PT_UNICODE;
7058 kern_type = KERN_TYPE_MD5_SLTPWU;
7059 dgst_size = DGST_SIZE_4_4;
7060 parse_func = md5s_parse_hash;
7061 sort_by_digest = sort_by_digest_4_4;
7062 opti_type = OPTI_TYPE_ZERO_BYTE
7063 | OPTI_TYPE_PRECOMPUTE_INIT
7064 | OPTI_TYPE_PRECOMPUTE_MERKLE
7065 | OPTI_TYPE_EARLY_SKIP
7066 | OPTI_TYPE_NOT_ITERATED
7067 | OPTI_TYPE_PREPENDED_SALT
7068 | OPTI_TYPE_RAW_HASH;
7069 dgst_pos0 = 0;
7070 dgst_pos1 = 3;
7071 dgst_pos2 = 2;
7072 dgst_pos3 = 1;
7073 break;
7074
7075 case 50: hash_type = HASH_TYPE_MD5;
7076 salt_type = SALT_TYPE_INTERN;
7077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7078 opts_type = OPTS_TYPE_PT_GENERATE_LE
7079 | OPTS_TYPE_ST_ADD80
7080 | OPTS_TYPE_ST_ADDBITS14;
7081 kern_type = KERN_TYPE_HMACMD5_PW;
7082 dgst_size = DGST_SIZE_4_4;
7083 parse_func = hmacmd5_parse_hash;
7084 sort_by_digest = sort_by_digest_4_4;
7085 opti_type = OPTI_TYPE_ZERO_BYTE
7086 | OPTI_TYPE_NOT_ITERATED;
7087 dgst_pos0 = 0;
7088 dgst_pos1 = 3;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 60: hash_type = HASH_TYPE_MD5;
7094 salt_type = SALT_TYPE_INTERN;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_LE
7097 | OPTS_TYPE_PT_ADD80
7098 | OPTS_TYPE_PT_ADDBITS14;
7099 kern_type = KERN_TYPE_HMACMD5_SLT;
7100 dgst_size = DGST_SIZE_4_4;
7101 parse_func = hmacmd5_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_NOT_ITERATED;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 100: hash_type = HASH_TYPE_SHA1;
7112 salt_type = SALT_TYPE_NONE;
7113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7114 opts_type = OPTS_TYPE_PT_GENERATE_BE
7115 | OPTS_TYPE_PT_ADD80
7116 | OPTS_TYPE_PT_ADDBITS15;
7117 kern_type = KERN_TYPE_SHA1;
7118 dgst_size = DGST_SIZE_4_5;
7119 parse_func = sha1_parse_hash;
7120 sort_by_digest = sort_by_digest_4_5;
7121 opti_type = OPTI_TYPE_ZERO_BYTE
7122 | OPTI_TYPE_PRECOMPUTE_INIT
7123 | OPTI_TYPE_PRECOMPUTE_MERKLE
7124 | OPTI_TYPE_EARLY_SKIP
7125 | OPTI_TYPE_NOT_ITERATED
7126 | OPTI_TYPE_NOT_SALTED
7127 | OPTI_TYPE_RAW_HASH;
7128 dgst_pos0 = 3;
7129 dgst_pos1 = 4;
7130 dgst_pos2 = 2;
7131 dgst_pos3 = 1;
7132 break;
7133
7134 case 101: hash_type = HASH_TYPE_SHA1;
7135 salt_type = SALT_TYPE_NONE;
7136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7137 opts_type = OPTS_TYPE_PT_GENERATE_BE
7138 | OPTS_TYPE_PT_ADD80
7139 | OPTS_TYPE_PT_ADDBITS15;
7140 kern_type = KERN_TYPE_SHA1;
7141 dgst_size = DGST_SIZE_4_5;
7142 parse_func = sha1b64_parse_hash;
7143 sort_by_digest = sort_by_digest_4_5;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_NOT_SALTED
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 3;
7152 dgst_pos1 = 4;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 110: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_INTERN;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_ST_ADD80
7162 | OPTS_TYPE_ST_ADDBITS15;
7163 kern_type = KERN_TYPE_SHA1_PWSLT;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1s_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_APPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 3;
7175 dgst_pos1 = 4;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 111: hash_type = HASH_TYPE_SHA1;
7181 salt_type = SALT_TYPE_EMBEDDED;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_BE
7184 | OPTS_TYPE_ST_ADD80
7185 | OPTS_TYPE_ST_ADDBITS15;
7186 kern_type = KERN_TYPE_SHA1_PWSLT;
7187 dgst_size = DGST_SIZE_4_5;
7188 parse_func = sha1b64s_parse_hash;
7189 sort_by_digest = sort_by_digest_4_5;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_APPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 112: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_INTERN;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_ST_ADD80
7208 | OPTS_TYPE_ST_ADDBITS15
7209 | OPTS_TYPE_ST_HEX;
7210 kern_type = KERN_TYPE_SHA1_PWSLT;
7211 dgst_size = DGST_SIZE_4_5;
7212 parse_func = oracles_parse_hash;
7213 sort_by_digest = sort_by_digest_4_5;
7214 opti_type = OPTI_TYPE_ZERO_BYTE
7215 | OPTI_TYPE_PRECOMPUTE_INIT
7216 | OPTI_TYPE_PRECOMPUTE_MERKLE
7217 | OPTI_TYPE_EARLY_SKIP
7218 | OPTI_TYPE_NOT_ITERATED
7219 | OPTI_TYPE_APPENDED_SALT
7220 | OPTI_TYPE_RAW_HASH;
7221 dgst_pos0 = 3;
7222 dgst_pos1 = 4;
7223 dgst_pos2 = 2;
7224 dgst_pos3 = 1;
7225 break;
7226
7227 case 120: hash_type = HASH_TYPE_SHA1;
7228 salt_type = SALT_TYPE_INTERN;
7229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7230 opts_type = OPTS_TYPE_PT_GENERATE_BE
7231 | OPTS_TYPE_PT_ADD80
7232 | OPTS_TYPE_PT_ADDBITS15;
7233 kern_type = KERN_TYPE_SHA1_SLTPW;
7234 dgst_size = DGST_SIZE_4_5;
7235 parse_func = sha1s_parse_hash;
7236 sort_by_digest = sort_by_digest_4_5;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_EARLY_SKIP
7241 | OPTI_TYPE_NOT_ITERATED
7242 | OPTI_TYPE_PREPENDED_SALT
7243 | OPTI_TYPE_RAW_HASH;
7244 dgst_pos0 = 3;
7245 dgst_pos1 = 4;
7246 dgst_pos2 = 2;
7247 dgst_pos3 = 1;
7248 break;
7249
7250 case 121: hash_type = HASH_TYPE_SHA1;
7251 salt_type = SALT_TYPE_INTERN;
7252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7253 opts_type = OPTS_TYPE_PT_GENERATE_BE
7254 | OPTS_TYPE_PT_ADD80
7255 | OPTS_TYPE_PT_ADDBITS15
7256 | OPTS_TYPE_ST_LOWER;
7257 kern_type = KERN_TYPE_SHA1_SLTPW;
7258 dgst_size = DGST_SIZE_4_5;
7259 parse_func = smf_parse_hash;
7260 sort_by_digest = sort_by_digest_4_5;
7261 opti_type = OPTI_TYPE_ZERO_BYTE
7262 | OPTI_TYPE_PRECOMPUTE_INIT
7263 | OPTI_TYPE_PRECOMPUTE_MERKLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_PREPENDED_SALT
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 3;
7269 dgst_pos1 = 4;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 122: hash_type = HASH_TYPE_SHA1;
7275 salt_type = SALT_TYPE_EMBEDDED;
7276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_BE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS15
7280 | OPTS_TYPE_ST_HEX;
7281 kern_type = KERN_TYPE_SHA1_SLTPW;
7282 dgst_size = DGST_SIZE_4_5;
7283 parse_func = osx1_parse_hash;
7284 sort_by_digest = sort_by_digest_4_5;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_PRECOMPUTE_INIT
7287 | OPTI_TYPE_PRECOMPUTE_MERKLE
7288 | OPTI_TYPE_EARLY_SKIP
7289 | OPTI_TYPE_NOT_ITERATED
7290 | OPTI_TYPE_PREPENDED_SALT
7291 | OPTI_TYPE_RAW_HASH;
7292 dgst_pos0 = 3;
7293 dgst_pos1 = 4;
7294 dgst_pos2 = 2;
7295 dgst_pos3 = 1;
7296 break;
7297
7298 case 124: hash_type = HASH_TYPE_SHA1;
7299 salt_type = SALT_TYPE_EMBEDDED;
7300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7301 opts_type = OPTS_TYPE_PT_GENERATE_BE
7302 | OPTS_TYPE_PT_ADD80
7303 | OPTS_TYPE_PT_ADDBITS15;
7304 kern_type = KERN_TYPE_SHA1_SLTPW;
7305 dgst_size = DGST_SIZE_4_5;
7306 parse_func = djangosha1_parse_hash;
7307 sort_by_digest = sort_by_digest_4_5;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_PREPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 125: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_EMBEDDED;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_ADD80
7326 | OPTS_TYPE_PT_ADDBITS15
7327 | OPTS_TYPE_ST_HEX;
7328 kern_type = KERN_TYPE_SHA1_SLTPW;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = arubaos_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_PREPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 130: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_INTERN;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_UNICODE
7350 | OPTS_TYPE_ST_ADD80
7351 | OPTS_TYPE_ST_ADDBITS15;
7352 kern_type = KERN_TYPE_SHA1_PWUSLT;
7353 dgst_size = DGST_SIZE_4_5;
7354 parse_func = sha1s_parse_hash;
7355 sort_by_digest = sort_by_digest_4_5;
7356 opti_type = OPTI_TYPE_ZERO_BYTE
7357 | OPTI_TYPE_PRECOMPUTE_INIT
7358 | OPTI_TYPE_PRECOMPUTE_MERKLE
7359 | OPTI_TYPE_EARLY_SKIP
7360 | OPTI_TYPE_NOT_ITERATED
7361 | OPTI_TYPE_APPENDED_SALT
7362 | OPTI_TYPE_RAW_HASH;
7363 dgst_pos0 = 3;
7364 dgst_pos1 = 4;
7365 dgst_pos2 = 2;
7366 dgst_pos3 = 1;
7367 break;
7368
7369 case 131: hash_type = HASH_TYPE_SHA1;
7370 salt_type = SALT_TYPE_EMBEDDED;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = OPTS_TYPE_PT_GENERATE_BE
7373 | OPTS_TYPE_PT_UNICODE
7374 | OPTS_TYPE_PT_UPPER
7375 | OPTS_TYPE_ST_ADD80
7376 | OPTS_TYPE_ST_ADDBITS15
7377 | OPTS_TYPE_ST_HEX;
7378 kern_type = KERN_TYPE_SHA1_PWUSLT;
7379 dgst_size = DGST_SIZE_4_5;
7380 parse_func = mssql2000_parse_hash;
7381 sort_by_digest = sort_by_digest_4_5;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_APPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 3;
7390 dgst_pos1 = 4;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 1;
7393 break;
7394
7395 case 132: hash_type = HASH_TYPE_SHA1;
7396 salt_type = SALT_TYPE_EMBEDDED;
7397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7398 opts_type = OPTS_TYPE_PT_GENERATE_BE
7399 | OPTS_TYPE_PT_UNICODE
7400 | OPTS_TYPE_ST_ADD80
7401 | OPTS_TYPE_ST_ADDBITS15
7402 | OPTS_TYPE_ST_HEX;
7403 kern_type = KERN_TYPE_SHA1_PWUSLT;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = mssql2005_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_APPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 133: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_EMBEDDED;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_UNICODE
7425 | OPTS_TYPE_ST_ADD80
7426 | OPTS_TYPE_ST_ADDBITS15;
7427 kern_type = KERN_TYPE_SHA1_PWUSLT;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = peoplesoft_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_APPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 140: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_INTERN;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_PT_ADD80
7449 | OPTS_TYPE_PT_ADDBITS15
7450 | OPTS_TYPE_PT_UNICODE;
7451 kern_type = KERN_TYPE_SHA1_SLTPWU;
7452 dgst_size = DGST_SIZE_4_5;
7453 parse_func = sha1s_parse_hash;
7454 sort_by_digest = sort_by_digest_4_5;
7455 opti_type = OPTI_TYPE_ZERO_BYTE
7456 | OPTI_TYPE_PRECOMPUTE_INIT
7457 | OPTI_TYPE_PRECOMPUTE_MERKLE
7458 | OPTI_TYPE_EARLY_SKIP
7459 | OPTI_TYPE_NOT_ITERATED
7460 | OPTI_TYPE_PREPENDED_SALT
7461 | OPTI_TYPE_RAW_HASH;
7462 dgst_pos0 = 3;
7463 dgst_pos1 = 4;
7464 dgst_pos2 = 2;
7465 dgst_pos3 = 1;
7466 break;
7467
7468 case 141: hash_type = HASH_TYPE_SHA1;
7469 salt_type = SALT_TYPE_EMBEDDED;
7470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7471 opts_type = OPTS_TYPE_PT_GENERATE_BE
7472 | OPTS_TYPE_PT_ADD80
7473 | OPTS_TYPE_PT_ADDBITS15
7474 | OPTS_TYPE_PT_UNICODE
7475 | OPTS_TYPE_ST_BASE64;
7476 kern_type = KERN_TYPE_SHA1_SLTPWU;
7477 dgst_size = DGST_SIZE_4_5;
7478 parse_func = episerver_parse_hash;
7479 sort_by_digest = sort_by_digest_4_5;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_EARLY_SKIP
7484 | OPTI_TYPE_NOT_ITERATED
7485 | OPTI_TYPE_PREPENDED_SALT
7486 | OPTI_TYPE_RAW_HASH;
7487 dgst_pos0 = 3;
7488 dgst_pos1 = 4;
7489 dgst_pos2 = 2;
7490 dgst_pos3 = 1;
7491 break;
7492
7493 case 150: hash_type = HASH_TYPE_SHA1;
7494 salt_type = SALT_TYPE_INTERN;
7495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_BE
7497 | OPTS_TYPE_ST_ADD80
7498 | OPTS_TYPE_ST_ADDBITS15;
7499 kern_type = KERN_TYPE_HMACSHA1_PW;
7500 dgst_size = DGST_SIZE_4_5;
7501 parse_func = hmacsha1_parse_hash;
7502 sort_by_digest = sort_by_digest_4_5;
7503 opti_type = OPTI_TYPE_ZERO_BYTE
7504 | OPTI_TYPE_NOT_ITERATED;
7505 dgst_pos0 = 3;
7506 dgst_pos1 = 4;
7507 dgst_pos2 = 2;
7508 dgst_pos3 = 1;
7509 break;
7510
7511 case 160: hash_type = HASH_TYPE_SHA1;
7512 salt_type = SALT_TYPE_INTERN;
7513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7514 opts_type = OPTS_TYPE_PT_GENERATE_BE
7515 | OPTS_TYPE_PT_ADD80
7516 | OPTS_TYPE_PT_ADDBITS15;
7517 kern_type = KERN_TYPE_HMACSHA1_SLT;
7518 dgst_size = DGST_SIZE_4_5;
7519 parse_func = hmacsha1_parse_hash;
7520 sort_by_digest = sort_by_digest_4_5;
7521 opti_type = OPTI_TYPE_ZERO_BYTE
7522 | OPTI_TYPE_NOT_ITERATED;
7523 dgst_pos0 = 3;
7524 dgst_pos1 = 4;
7525 dgst_pos2 = 2;
7526 dgst_pos3 = 1;
7527 break;
7528
7529 case 190: hash_type = HASH_TYPE_SHA1;
7530 salt_type = SALT_TYPE_NONE;
7531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7532 opts_type = OPTS_TYPE_PT_GENERATE_BE
7533 | OPTS_TYPE_PT_ADD80
7534 | OPTS_TYPE_PT_ADDBITS15;
7535 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7536 dgst_size = DGST_SIZE_4_5;
7537 parse_func = sha1linkedin_parse_hash;
7538 sort_by_digest = sort_by_digest_4_5;
7539 opti_type = OPTI_TYPE_ZERO_BYTE
7540 | OPTI_TYPE_PRECOMPUTE_INIT
7541 | OPTI_TYPE_EARLY_SKIP
7542 | OPTI_TYPE_NOT_ITERATED
7543 | OPTI_TYPE_NOT_SALTED;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 4;
7546 dgst_pos2 = 3;
7547 dgst_pos3 = 2;
7548 break;
7549
7550 case 200: hash_type = HASH_TYPE_MYSQL;
7551 salt_type = SALT_TYPE_NONE;
7552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7553 opts_type = 0;
7554 kern_type = KERN_TYPE_MYSQL;
7555 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7556 parse_func = mysql323_parse_hash;
7557 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7558 opti_type = OPTI_TYPE_ZERO_BYTE;
7559 dgst_pos0 = 0;
7560 dgst_pos1 = 1;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 3;
7563 break;
7564
7565 case 300: hash_type = HASH_TYPE_SHA1;
7566 salt_type = SALT_TYPE_NONE;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_BE
7569 | OPTS_TYPE_PT_ADD80
7570 | OPTS_TYPE_PT_ADDBITS15;
7571 kern_type = KERN_TYPE_MYSQL41;
7572 dgst_size = DGST_SIZE_4_5;
7573 parse_func = sha1_parse_hash;
7574 sort_by_digest = sort_by_digest_4_5;
7575 opti_type = OPTI_TYPE_ZERO_BYTE
7576 | OPTI_TYPE_PRECOMPUTE_INIT
7577 | OPTI_TYPE_PRECOMPUTE_MERKLE
7578 | OPTI_TYPE_EARLY_SKIP
7579 | OPTI_TYPE_NOT_ITERATED
7580 | OPTI_TYPE_NOT_SALTED;
7581 dgst_pos0 = 3;
7582 dgst_pos1 = 4;
7583 dgst_pos2 = 2;
7584 dgst_pos3 = 1;
7585 break;
7586
7587 case 400: hash_type = HASH_TYPE_MD5;
7588 salt_type = SALT_TYPE_EMBEDDED;
7589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7591 kern_type = KERN_TYPE_PHPASS;
7592 dgst_size = DGST_SIZE_4_4;
7593 parse_func = phpass_parse_hash;
7594 sort_by_digest = sort_by_digest_4_4;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_SLOW_HASH_SIMD;
7597 dgst_pos0 = 0;
7598 dgst_pos1 = 1;
7599 dgst_pos2 = 2;
7600 dgst_pos3 = 3;
7601 break;
7602
7603 case 500: hash_type = HASH_TYPE_MD5;
7604 salt_type = SALT_TYPE_EMBEDDED;
7605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7607 kern_type = KERN_TYPE_MD5CRYPT;
7608 dgst_size = DGST_SIZE_4_4;
7609 parse_func = md5crypt_parse_hash;
7610 sort_by_digest = sort_by_digest_4_4;
7611 opti_type = OPTI_TYPE_ZERO_BYTE;
7612 dgst_pos0 = 0;
7613 dgst_pos1 = 1;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 3;
7616 break;
7617
7618 case 501: hash_type = HASH_TYPE_MD5;
7619 salt_type = SALT_TYPE_EMBEDDED;
7620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_LE
7622 | OPTS_TYPE_HASH_COPY;
7623 kern_type = KERN_TYPE_MD5CRYPT;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = juniper_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
7627 opti_type = OPTI_TYPE_ZERO_BYTE;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 1;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 3;
7632 break;
7633
7634 case 900: hash_type = HASH_TYPE_MD4;
7635 salt_type = SALT_TYPE_NONE;
7636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_PT_ADD80
7639 | OPTS_TYPE_PT_ADDBITS14;
7640 kern_type = KERN_TYPE_MD4;
7641 dgst_size = DGST_SIZE_4_4;
7642 parse_func = md4_parse_hash;
7643 sort_by_digest = sort_by_digest_4_4;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_MEET_IN_MIDDLE
7648 | OPTI_TYPE_EARLY_SKIP
7649 | OPTI_TYPE_NOT_ITERATED
7650 | OPTI_TYPE_NOT_SALTED
7651 | OPTI_TYPE_RAW_HASH;
7652 dgst_pos0 = 0;
7653 dgst_pos1 = 3;
7654 dgst_pos2 = 2;
7655 dgst_pos3 = 1;
7656 break;
7657
7658 case 1000: hash_type = HASH_TYPE_MD4;
7659 salt_type = SALT_TYPE_NONE;
7660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7661 opts_type = OPTS_TYPE_PT_GENERATE_LE
7662 | OPTS_TYPE_PT_ADD80
7663 | OPTS_TYPE_PT_ADDBITS14
7664 | OPTS_TYPE_PT_UNICODE;
7665 kern_type = KERN_TYPE_MD4_PWU;
7666 dgst_size = DGST_SIZE_4_4;
7667 parse_func = md4_parse_hash;
7668 sort_by_digest = sort_by_digest_4_4;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_PRECOMPUTE_INIT
7671 | OPTI_TYPE_PRECOMPUTE_MERKLE
7672 | OPTI_TYPE_MEET_IN_MIDDLE
7673 | OPTI_TYPE_EARLY_SKIP
7674 | OPTI_TYPE_NOT_ITERATED
7675 | OPTI_TYPE_NOT_SALTED
7676 | OPTI_TYPE_RAW_HASH;
7677 dgst_pos0 = 0;
7678 dgst_pos1 = 3;
7679 dgst_pos2 = 2;
7680 dgst_pos3 = 1;
7681 break;
7682
7683 case 1100: hash_type = HASH_TYPE_MD4;
7684 salt_type = SALT_TYPE_INTERN;
7685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7686 opts_type = OPTS_TYPE_PT_GENERATE_LE
7687 | OPTS_TYPE_PT_ADD80
7688 | OPTS_TYPE_PT_ADDBITS14
7689 | OPTS_TYPE_PT_UNICODE
7690 | OPTS_TYPE_ST_ADD80
7691 | OPTS_TYPE_ST_UNICODE
7692 | OPTS_TYPE_ST_LOWER;
7693 kern_type = KERN_TYPE_MD44_PWUSLT;
7694 dgst_size = DGST_SIZE_4_4;
7695 parse_func = dcc_parse_hash;
7696 sort_by_digest = sort_by_digest_4_4;
7697 opti_type = OPTI_TYPE_ZERO_BYTE
7698 | OPTI_TYPE_PRECOMPUTE_INIT
7699 | OPTI_TYPE_PRECOMPUTE_MERKLE
7700 | OPTI_TYPE_EARLY_SKIP
7701 | OPTI_TYPE_NOT_ITERATED;
7702 dgst_pos0 = 0;
7703 dgst_pos1 = 3;
7704 dgst_pos2 = 2;
7705 dgst_pos3 = 1;
7706 break;
7707
7708 case 1400: hash_type = HASH_TYPE_SHA256;
7709 salt_type = SALT_TYPE_NONE;
7710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7711 opts_type = OPTS_TYPE_PT_GENERATE_BE
7712 | OPTS_TYPE_PT_ADD80
7713 | OPTS_TYPE_PT_ADDBITS15;
7714 kern_type = KERN_TYPE_SHA256;
7715 dgst_size = DGST_SIZE_4_8;
7716 parse_func = sha256_parse_hash;
7717 sort_by_digest = sort_by_digest_4_8;
7718 opti_type = OPTI_TYPE_ZERO_BYTE
7719 | OPTI_TYPE_PRECOMPUTE_INIT
7720 | OPTI_TYPE_PRECOMPUTE_MERKLE
7721 | OPTI_TYPE_EARLY_SKIP
7722 | OPTI_TYPE_NOT_ITERATED
7723 | OPTI_TYPE_NOT_SALTED
7724 | OPTI_TYPE_RAW_HASH;
7725 dgst_pos0 = 3;
7726 dgst_pos1 = 7;
7727 dgst_pos2 = 2;
7728 dgst_pos3 = 6;
7729 break;
7730
7731 case 1410: hash_type = HASH_TYPE_SHA256;
7732 salt_type = SALT_TYPE_INTERN;
7733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7734 opts_type = OPTS_TYPE_PT_GENERATE_BE
7735 | OPTS_TYPE_ST_ADD80
7736 | OPTS_TYPE_ST_ADDBITS15;
7737 kern_type = KERN_TYPE_SHA256_PWSLT;
7738 dgst_size = DGST_SIZE_4_8;
7739 parse_func = sha256s_parse_hash;
7740 sort_by_digest = sort_by_digest_4_8;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_PRECOMPUTE_INIT
7743 | OPTI_TYPE_PRECOMPUTE_MERKLE
7744 | OPTI_TYPE_EARLY_SKIP
7745 | OPTI_TYPE_NOT_ITERATED
7746 | OPTI_TYPE_APPENDED_SALT
7747 | OPTI_TYPE_RAW_HASH;
7748 dgst_pos0 = 3;
7749 dgst_pos1 = 7;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 6;
7752 break;
7753
7754 case 1420: hash_type = HASH_TYPE_SHA256;
7755 salt_type = SALT_TYPE_INTERN;
7756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_BE
7758 | OPTS_TYPE_PT_ADD80
7759 | OPTS_TYPE_PT_ADDBITS15;
7760 kern_type = KERN_TYPE_SHA256_SLTPW;
7761 dgst_size = DGST_SIZE_4_8;
7762 parse_func = sha256s_parse_hash;
7763 sort_by_digest = sort_by_digest_4_8;
7764 opti_type = OPTI_TYPE_ZERO_BYTE
7765 | OPTI_TYPE_PRECOMPUTE_INIT
7766 | OPTI_TYPE_PRECOMPUTE_MERKLE
7767 | OPTI_TYPE_EARLY_SKIP
7768 | OPTI_TYPE_NOT_ITERATED
7769 | OPTI_TYPE_PREPENDED_SALT
7770 | OPTI_TYPE_RAW_HASH;
7771 dgst_pos0 = 3;
7772 dgst_pos1 = 7;
7773 dgst_pos2 = 2;
7774 dgst_pos3 = 6;
7775 break;
7776
7777 case 1421: hash_type = HASH_TYPE_SHA256;
7778 salt_type = SALT_TYPE_EMBEDDED;
7779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7780 opts_type = OPTS_TYPE_PT_GENERATE_BE
7781 | OPTS_TYPE_PT_ADD80
7782 | OPTS_TYPE_PT_ADDBITS15;
7783 kern_type = KERN_TYPE_SHA256_SLTPW;
7784 dgst_size = DGST_SIZE_4_8;
7785 parse_func = hmailserver_parse_hash;
7786 sort_by_digest = sort_by_digest_4_8;
7787 opti_type = OPTI_TYPE_ZERO_BYTE
7788 | OPTI_TYPE_PRECOMPUTE_INIT
7789 | OPTI_TYPE_PRECOMPUTE_MERKLE
7790 | OPTI_TYPE_EARLY_SKIP
7791 | OPTI_TYPE_NOT_ITERATED
7792 | OPTI_TYPE_PREPENDED_SALT
7793 | OPTI_TYPE_RAW_HASH;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 7;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 6;
7798 break;
7799
7800 case 1430: hash_type = HASH_TYPE_SHA256;
7801 salt_type = SALT_TYPE_INTERN;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_BE
7804 | OPTS_TYPE_PT_UNICODE
7805 | OPTS_TYPE_ST_ADD80
7806 | OPTS_TYPE_ST_ADDBITS15;
7807 kern_type = KERN_TYPE_SHA256_PWUSLT;
7808 dgst_size = DGST_SIZE_4_8;
7809 parse_func = sha256s_parse_hash;
7810 sort_by_digest = sort_by_digest_4_8;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_PRECOMPUTE_INIT
7813 | OPTI_TYPE_PRECOMPUTE_MERKLE
7814 | OPTI_TYPE_EARLY_SKIP
7815 | OPTI_TYPE_NOT_ITERATED
7816 | OPTI_TYPE_APPENDED_SALT
7817 | OPTI_TYPE_RAW_HASH;
7818 dgst_pos0 = 3;
7819 dgst_pos1 = 7;
7820 dgst_pos2 = 2;
7821 dgst_pos3 = 6;
7822 break;
7823
7824 case 1440: hash_type = HASH_TYPE_SHA256;
7825 salt_type = SALT_TYPE_INTERN;
7826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7827 opts_type = OPTS_TYPE_PT_GENERATE_BE
7828 | OPTS_TYPE_PT_ADD80
7829 | OPTS_TYPE_PT_ADDBITS15
7830 | OPTS_TYPE_PT_UNICODE;
7831 kern_type = KERN_TYPE_SHA256_SLTPWU;
7832 dgst_size = DGST_SIZE_4_8;
7833 parse_func = sha256s_parse_hash;
7834 sort_by_digest = sort_by_digest_4_8;
7835 opti_type = OPTI_TYPE_ZERO_BYTE
7836 | OPTI_TYPE_PRECOMPUTE_INIT
7837 | OPTI_TYPE_PRECOMPUTE_MERKLE
7838 | OPTI_TYPE_EARLY_SKIP
7839 | OPTI_TYPE_NOT_ITERATED
7840 | OPTI_TYPE_PREPENDED_SALT
7841 | OPTI_TYPE_RAW_HASH;
7842 dgst_pos0 = 3;
7843 dgst_pos1 = 7;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 6;
7846 break;
7847
7848 case 1441: hash_type = HASH_TYPE_SHA256;
7849 salt_type = SALT_TYPE_EMBEDDED;
7850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7851 opts_type = OPTS_TYPE_PT_GENERATE_BE
7852 | OPTS_TYPE_PT_ADD80
7853 | OPTS_TYPE_PT_ADDBITS15
7854 | OPTS_TYPE_PT_UNICODE
7855 | OPTS_TYPE_ST_BASE64;
7856 kern_type = KERN_TYPE_SHA256_SLTPWU;
7857 dgst_size = DGST_SIZE_4_8;
7858 parse_func = episerver4_parse_hash;
7859 sort_by_digest = sort_by_digest_4_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_PRECOMPUTE_INIT
7862 | OPTI_TYPE_PRECOMPUTE_MERKLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED
7865 | OPTI_TYPE_PREPENDED_SALT
7866 | OPTI_TYPE_RAW_HASH;
7867 dgst_pos0 = 3;
7868 dgst_pos1 = 7;
7869 dgst_pos2 = 2;
7870 dgst_pos3 = 6;
7871 break;
7872
7873 case 1450: hash_type = HASH_TYPE_SHA256;
7874 salt_type = SALT_TYPE_INTERN;
7875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_BE
7877 | OPTS_TYPE_ST_ADD80;
7878 kern_type = KERN_TYPE_HMACSHA256_PW;
7879 dgst_size = DGST_SIZE_4_8;
7880 parse_func = hmacsha256_parse_hash;
7881 sort_by_digest = sort_by_digest_4_8;
7882 opti_type = OPTI_TYPE_ZERO_BYTE
7883 | OPTI_TYPE_NOT_ITERATED;
7884 dgst_pos0 = 3;
7885 dgst_pos1 = 7;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 6;
7888 break;
7889
7890 case 1460: hash_type = HASH_TYPE_SHA256;
7891 salt_type = SALT_TYPE_INTERN;
7892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_BE
7894 | OPTS_TYPE_PT_ADD80
7895 | OPTS_TYPE_PT_ADDBITS15;
7896 kern_type = KERN_TYPE_HMACSHA256_SLT;
7897 dgst_size = DGST_SIZE_4_8;
7898 parse_func = hmacsha256_parse_hash;
7899 sort_by_digest = sort_by_digest_4_8;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_NOT_ITERATED;
7902 dgst_pos0 = 3;
7903 dgst_pos1 = 7;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 6;
7906 break;
7907
7908 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7909 salt_type = SALT_TYPE_EMBEDDED;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_BITSLICE;
7913 kern_type = KERN_TYPE_DESCRYPT;
7914 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7915 parse_func = descrypt_parse_hash;
7916 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7917 opti_type = OPTI_TYPE_ZERO_BYTE
7918 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7919 dgst_pos0 = 0;
7920 dgst_pos1 = 1;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 3;
7923 break;
7924
7925 case 1600: hash_type = HASH_TYPE_MD5;
7926 salt_type = SALT_TYPE_EMBEDDED;
7927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7929 kern_type = KERN_TYPE_APR1CRYPT;
7930 dgst_size = DGST_SIZE_4_4;
7931 parse_func = md5apr1_parse_hash;
7932 sort_by_digest = sort_by_digest_4_4;
7933 opti_type = OPTI_TYPE_ZERO_BYTE;
7934 dgst_pos0 = 0;
7935 dgst_pos1 = 1;
7936 dgst_pos2 = 2;
7937 dgst_pos3 = 3;
7938 break;
7939
7940 case 1700: hash_type = HASH_TYPE_SHA512;
7941 salt_type = SALT_TYPE_NONE;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_PT_ADD80
7945 | OPTS_TYPE_PT_ADDBITS15;
7946 kern_type = KERN_TYPE_SHA512;
7947 dgst_size = DGST_SIZE_8_8;
7948 parse_func = sha512_parse_hash;
7949 sort_by_digest = sort_by_digest_8_8;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_NOT_SALTED
7956 | OPTI_TYPE_USES_BITS_64
7957 | OPTI_TYPE_RAW_HASH;
7958 dgst_pos0 = 14;
7959 dgst_pos1 = 15;
7960 dgst_pos2 = 6;
7961 dgst_pos3 = 7;
7962 break;
7963
7964 case 1710: hash_type = HASH_TYPE_SHA512;
7965 salt_type = SALT_TYPE_INTERN;
7966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7967 opts_type = OPTS_TYPE_PT_GENERATE_BE
7968 | OPTS_TYPE_ST_ADD80
7969 | OPTS_TYPE_ST_ADDBITS15;
7970 kern_type = KERN_TYPE_SHA512_PWSLT;
7971 dgst_size = DGST_SIZE_8_8;
7972 parse_func = sha512s_parse_hash;
7973 sort_by_digest = sort_by_digest_8_8;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_PRECOMPUTE_INIT
7976 | OPTI_TYPE_PRECOMPUTE_MERKLE
7977 | OPTI_TYPE_EARLY_SKIP
7978 | OPTI_TYPE_NOT_ITERATED
7979 | OPTI_TYPE_APPENDED_SALT
7980 | OPTI_TYPE_USES_BITS_64
7981 | OPTI_TYPE_RAW_HASH;
7982 dgst_pos0 = 14;
7983 dgst_pos1 = 15;
7984 dgst_pos2 = 6;
7985 dgst_pos3 = 7;
7986 break;
7987
7988 case 1711: hash_type = HASH_TYPE_SHA512;
7989 salt_type = SALT_TYPE_EMBEDDED;
7990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7991 opts_type = OPTS_TYPE_PT_GENERATE_BE
7992 | OPTS_TYPE_ST_ADD80
7993 | OPTS_TYPE_ST_ADDBITS15;
7994 kern_type = KERN_TYPE_SHA512_PWSLT;
7995 dgst_size = DGST_SIZE_8_8;
7996 parse_func = sha512b64s_parse_hash;
7997 sort_by_digest = sort_by_digest_8_8;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_APPENDED_SALT
8004 | OPTI_TYPE_USES_BITS_64
8005 | OPTI_TYPE_RAW_HASH;
8006 dgst_pos0 = 14;
8007 dgst_pos1 = 15;
8008 dgst_pos2 = 6;
8009 dgst_pos3 = 7;
8010 break;
8011
8012 case 1720: hash_type = HASH_TYPE_SHA512;
8013 salt_type = SALT_TYPE_INTERN;
8014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8015 opts_type = OPTS_TYPE_PT_GENERATE_BE
8016 | OPTS_TYPE_PT_ADD80
8017 | OPTS_TYPE_PT_ADDBITS15;
8018 kern_type = KERN_TYPE_SHA512_SLTPW;
8019 dgst_size = DGST_SIZE_8_8;
8020 parse_func = sha512s_parse_hash;
8021 sort_by_digest = sort_by_digest_8_8;
8022 opti_type = OPTI_TYPE_ZERO_BYTE
8023 | OPTI_TYPE_PRECOMPUTE_INIT
8024 | OPTI_TYPE_PRECOMPUTE_MERKLE
8025 | OPTI_TYPE_EARLY_SKIP
8026 | OPTI_TYPE_NOT_ITERATED
8027 | OPTI_TYPE_PREPENDED_SALT
8028 | OPTI_TYPE_USES_BITS_64
8029 | OPTI_TYPE_RAW_HASH;
8030 dgst_pos0 = 14;
8031 dgst_pos1 = 15;
8032 dgst_pos2 = 6;
8033 dgst_pos3 = 7;
8034 break;
8035
8036 case 1722: hash_type = HASH_TYPE_SHA512;
8037 salt_type = SALT_TYPE_EMBEDDED;
8038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8039 opts_type = OPTS_TYPE_PT_GENERATE_BE
8040 | OPTS_TYPE_PT_ADD80
8041 | OPTS_TYPE_PT_ADDBITS15
8042 | OPTS_TYPE_ST_HEX;
8043 kern_type = KERN_TYPE_SHA512_SLTPW;
8044 dgst_size = DGST_SIZE_8_8;
8045 parse_func = osx512_parse_hash;
8046 sort_by_digest = sort_by_digest_8_8;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_PRECOMPUTE_INIT
8049 | OPTI_TYPE_PRECOMPUTE_MERKLE
8050 | OPTI_TYPE_EARLY_SKIP
8051 | OPTI_TYPE_NOT_ITERATED
8052 | OPTI_TYPE_PREPENDED_SALT
8053 | OPTI_TYPE_USES_BITS_64
8054 | OPTI_TYPE_RAW_HASH;
8055 dgst_pos0 = 14;
8056 dgst_pos1 = 15;
8057 dgst_pos2 = 6;
8058 dgst_pos3 = 7;
8059 break;
8060
8061 case 1730: hash_type = HASH_TYPE_SHA512;
8062 salt_type = SALT_TYPE_INTERN;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_BE
8065 | OPTS_TYPE_PT_UNICODE
8066 | OPTS_TYPE_ST_ADD80
8067 | OPTS_TYPE_ST_ADDBITS15;
8068 kern_type = KERN_TYPE_SHA512_PWSLTU;
8069 dgst_size = DGST_SIZE_8_8;
8070 parse_func = sha512s_parse_hash;
8071 sort_by_digest = sort_by_digest_8_8;
8072 opti_type = OPTI_TYPE_ZERO_BYTE
8073 | OPTI_TYPE_PRECOMPUTE_INIT
8074 | OPTI_TYPE_PRECOMPUTE_MERKLE
8075 | OPTI_TYPE_EARLY_SKIP
8076 | OPTI_TYPE_NOT_ITERATED
8077 | OPTI_TYPE_APPENDED_SALT
8078 | OPTI_TYPE_USES_BITS_64
8079 | OPTI_TYPE_RAW_HASH;
8080 dgst_pos0 = 14;
8081 dgst_pos1 = 15;
8082 dgst_pos2 = 6;
8083 dgst_pos3 = 7;
8084 break;
8085
8086 case 1731: hash_type = HASH_TYPE_SHA512;
8087 salt_type = SALT_TYPE_EMBEDDED;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_BE
8090 | OPTS_TYPE_PT_UNICODE
8091 | OPTS_TYPE_ST_ADD80
8092 | OPTS_TYPE_ST_ADDBITS15
8093 | OPTS_TYPE_ST_HEX;
8094 kern_type = KERN_TYPE_SHA512_PWSLTU;
8095 dgst_size = DGST_SIZE_8_8;
8096 parse_func = mssql2012_parse_hash;
8097 sort_by_digest = sort_by_digest_8_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_APPENDED_SALT
8104 | OPTI_TYPE_USES_BITS_64
8105 | OPTI_TYPE_RAW_HASH;
8106 dgst_pos0 = 14;
8107 dgst_pos1 = 15;
8108 dgst_pos2 = 6;
8109 dgst_pos3 = 7;
8110 break;
8111
8112 case 1740: hash_type = HASH_TYPE_SHA512;
8113 salt_type = SALT_TYPE_INTERN;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS15
8118 | OPTS_TYPE_PT_UNICODE;
8119 kern_type = KERN_TYPE_SHA512_SLTPWU;
8120 dgst_size = DGST_SIZE_8_8;
8121 parse_func = sha512s_parse_hash;
8122 sort_by_digest = sort_by_digest_8_8;
8123 opti_type = OPTI_TYPE_ZERO_BYTE
8124 | OPTI_TYPE_PRECOMPUTE_INIT
8125 | OPTI_TYPE_PRECOMPUTE_MERKLE
8126 | OPTI_TYPE_EARLY_SKIP
8127 | OPTI_TYPE_NOT_ITERATED
8128 | OPTI_TYPE_PREPENDED_SALT
8129 | OPTI_TYPE_USES_BITS_64
8130 | OPTI_TYPE_RAW_HASH;
8131 dgst_pos0 = 14;
8132 dgst_pos1 = 15;
8133 dgst_pos2 = 6;
8134 dgst_pos3 = 7;
8135 break;
8136
8137 case 1750: hash_type = HASH_TYPE_SHA512;
8138 salt_type = SALT_TYPE_INTERN;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_ST_ADD80;
8142 kern_type = KERN_TYPE_HMACSHA512_PW;
8143 dgst_size = DGST_SIZE_8_8;
8144 parse_func = hmacsha512_parse_hash;
8145 sort_by_digest = sort_by_digest_8_8;
8146 opti_type = OPTI_TYPE_ZERO_BYTE
8147 | OPTI_TYPE_USES_BITS_64
8148 | OPTI_TYPE_NOT_ITERATED;
8149 dgst_pos0 = 14;
8150 dgst_pos1 = 15;
8151 dgst_pos2 = 6;
8152 dgst_pos3 = 7;
8153 break;
8154
8155 case 1760: hash_type = HASH_TYPE_SHA512;
8156 salt_type = SALT_TYPE_INTERN;
8157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_BE
8159 | OPTS_TYPE_PT_ADD80
8160 | OPTS_TYPE_PT_ADDBITS15;
8161 kern_type = KERN_TYPE_HMACSHA512_SLT;
8162 dgst_size = DGST_SIZE_8_8;
8163 parse_func = hmacsha512_parse_hash;
8164 sort_by_digest = sort_by_digest_8_8;
8165 opti_type = OPTI_TYPE_ZERO_BYTE
8166 | OPTI_TYPE_USES_BITS_64
8167 | OPTI_TYPE_NOT_ITERATED;
8168 dgst_pos0 = 14;
8169 dgst_pos1 = 15;
8170 dgst_pos2 = 6;
8171 dgst_pos3 = 7;
8172 break;
8173
8174 case 1800: hash_type = HASH_TYPE_SHA512;
8175 salt_type = SALT_TYPE_EMBEDDED;
8176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8178 kern_type = KERN_TYPE_SHA512CRYPT;
8179 dgst_size = DGST_SIZE_8_8;
8180 parse_func = sha512crypt_parse_hash;
8181 sort_by_digest = sort_by_digest_8_8;
8182 opti_type = OPTI_TYPE_ZERO_BYTE
8183 | OPTI_TYPE_USES_BITS_64;
8184 dgst_pos0 = 0;
8185 dgst_pos1 = 1;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 3;
8188 break;
8189
8190 case 2100: hash_type = HASH_TYPE_DCC2;
8191 salt_type = SALT_TYPE_EMBEDDED;
8192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8194 | OPTS_TYPE_ST_LOWER
8195 | OPTS_TYPE_ST_UNICODE;
8196 kern_type = KERN_TYPE_DCC2;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = dcc2_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_SLOW_HASH_SIMD;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 2400: hash_type = HASH_TYPE_MD5;
8209 salt_type = SALT_TYPE_NONE;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8212 kern_type = KERN_TYPE_MD5PIX;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = md5pix_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_PRECOMPUTE_INIT
8218 | OPTI_TYPE_PRECOMPUTE_MERKLE
8219 | OPTI_TYPE_EARLY_SKIP
8220 | OPTI_TYPE_NOT_ITERATED
8221 | OPTI_TYPE_NOT_SALTED;
8222 dgst_pos0 = 0;
8223 dgst_pos1 = 3;
8224 dgst_pos2 = 2;
8225 dgst_pos3 = 1;
8226 break;
8227
8228 case 2410: hash_type = HASH_TYPE_MD5;
8229 salt_type = SALT_TYPE_INTERN;
8230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8232 kern_type = KERN_TYPE_MD5ASA;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = md5asa_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP
8240 | OPTI_TYPE_NOT_ITERATED;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 3;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 1;
8245 break;
8246
8247 case 2500: hash_type = HASH_TYPE_WPA;
8248 salt_type = SALT_TYPE_EMBEDDED;
8249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8251 kern_type = KERN_TYPE_WPA;
8252 dgst_size = DGST_SIZE_4_4;
8253 parse_func = wpa_parse_hash;
8254 sort_by_digest = sort_by_digest_4_4;
8255 opti_type = OPTI_TYPE_ZERO_BYTE
8256 | OPTI_TYPE_SLOW_HASH_SIMD;
8257 dgst_pos0 = 0;
8258 dgst_pos1 = 1;
8259 dgst_pos2 = 2;
8260 dgst_pos3 = 3;
8261 break;
8262
8263 case 2600: hash_type = HASH_TYPE_MD5;
8264 salt_type = SALT_TYPE_VIRTUAL;
8265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8266 opts_type = OPTS_TYPE_PT_GENERATE_LE
8267 | OPTS_TYPE_PT_ADD80
8268 | OPTS_TYPE_PT_ADDBITS14
8269 | OPTS_TYPE_ST_ADD80;
8270 kern_type = KERN_TYPE_MD55_PWSLT1;
8271 dgst_size = DGST_SIZE_4_4;
8272 parse_func = md5md5_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_EARLY_SKIP;
8278 dgst_pos0 = 0;
8279 dgst_pos1 = 3;
8280 dgst_pos2 = 2;
8281 dgst_pos3 = 1;
8282 break;
8283
8284 case 2611: hash_type = HASH_TYPE_MD5;
8285 salt_type = SALT_TYPE_INTERN;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_LE
8288 | OPTS_TYPE_PT_ADD80
8289 | OPTS_TYPE_PT_ADDBITS14
8290 | OPTS_TYPE_ST_ADD80;
8291 kern_type = KERN_TYPE_MD55_PWSLT1;
8292 dgst_size = DGST_SIZE_4_4;
8293 parse_func = vb3_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_EARLY_SKIP;
8299 dgst_pos0 = 0;
8300 dgst_pos1 = 3;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 1;
8303 break;
8304
8305 case 2612: hash_type = HASH_TYPE_MD5;
8306 salt_type = SALT_TYPE_EMBEDDED;
8307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8308 opts_type = OPTS_TYPE_PT_GENERATE_LE
8309 | OPTS_TYPE_PT_ADD80
8310 | OPTS_TYPE_PT_ADDBITS14
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_HEX;
8313 kern_type = KERN_TYPE_MD55_PWSLT1;
8314 dgst_size = DGST_SIZE_4_4;
8315 parse_func = phps_parse_hash;
8316 sort_by_digest = sort_by_digest_4_4;
8317 opti_type = OPTI_TYPE_ZERO_BYTE
8318 | OPTI_TYPE_PRECOMPUTE_INIT
8319 | OPTI_TYPE_PRECOMPUTE_MERKLE
8320 | OPTI_TYPE_EARLY_SKIP;
8321 dgst_pos0 = 0;
8322 dgst_pos1 = 3;
8323 dgst_pos2 = 2;
8324 dgst_pos3 = 1;
8325 break;
8326
8327 case 2711: hash_type = HASH_TYPE_MD5;
8328 salt_type = SALT_TYPE_INTERN;
8329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8330 opts_type = OPTS_TYPE_PT_GENERATE_LE
8331 | OPTS_TYPE_PT_ADD80
8332 | OPTS_TYPE_PT_ADDBITS14
8333 | OPTS_TYPE_ST_ADD80;
8334 kern_type = KERN_TYPE_MD55_PWSLT2;
8335 dgst_size = DGST_SIZE_4_4;
8336 parse_func = vb30_parse_hash;
8337 sort_by_digest = sort_by_digest_4_4;
8338 opti_type = OPTI_TYPE_ZERO_BYTE
8339 | OPTI_TYPE_PRECOMPUTE_INIT
8340 | OPTI_TYPE_EARLY_SKIP;
8341 dgst_pos0 = 0;
8342 dgst_pos1 = 3;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 1;
8345 break;
8346
8347 case 2811: hash_type = HASH_TYPE_MD5;
8348 salt_type = SALT_TYPE_INTERN;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_LE
8351 | OPTS_TYPE_PT_ADD80
8352 | OPTS_TYPE_PT_ADDBITS14;
8353 kern_type = KERN_TYPE_MD55_SLTPW;
8354 dgst_size = DGST_SIZE_4_4;
8355 parse_func = ipb2_parse_hash;
8356 sort_by_digest = sort_by_digest_4_4;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_PRECOMPUTE_INIT
8359 | OPTI_TYPE_EARLY_SKIP;
8360 dgst_pos0 = 0;
8361 dgst_pos1 = 3;
8362 dgst_pos2 = 2;
8363 dgst_pos3 = 1;
8364 break;
8365
8366 case 3000: hash_type = HASH_TYPE_LM;
8367 salt_type = SALT_TYPE_NONE;
8368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8369 opts_type = OPTS_TYPE_PT_GENERATE_LE
8370 | OPTS_TYPE_PT_UPPER
8371 | OPTS_TYPE_PT_BITSLICE;
8372 kern_type = KERN_TYPE_LM;
8373 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8374 parse_func = lm_parse_hash;
8375 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8376 opti_type = OPTI_TYPE_ZERO_BYTE
8377 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 1;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 3;
8382 break;
8383
8384 case 3100: hash_type = HASH_TYPE_ORACLEH;
8385 salt_type = SALT_TYPE_INTERN;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_PT_UPPER
8389 | OPTS_TYPE_ST_UPPER;
8390 kern_type = KERN_TYPE_ORACLEH;
8391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8392 parse_func = oracleh_parse_hash;
8393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8394 opti_type = OPTI_TYPE_ZERO_BYTE;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 1;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 3;
8399 break;
8400
8401 case 3200: hash_type = HASH_TYPE_BCRYPT;
8402 salt_type = SALT_TYPE_EMBEDDED;
8403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE
8405 | OPTS_TYPE_ST_GENERATE_LE;
8406 kern_type = KERN_TYPE_BCRYPT;
8407 dgst_size = DGST_SIZE_4_6;
8408 parse_func = bcrypt_parse_hash;
8409 sort_by_digest = sort_by_digest_4_6;
8410 opti_type = OPTI_TYPE_ZERO_BYTE;
8411 dgst_pos0 = 0;
8412 dgst_pos1 = 1;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 3;
8415 break;
8416
8417 case 3710: hash_type = HASH_TYPE_MD5;
8418 salt_type = SALT_TYPE_INTERN;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_LE
8421 | OPTS_TYPE_PT_ADD80
8422 | OPTS_TYPE_PT_ADDBITS14;
8423 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8424 dgst_size = DGST_SIZE_4_4;
8425 parse_func = md5s_parse_hash;
8426 sort_by_digest = sort_by_digest_4_4;
8427 opti_type = OPTI_TYPE_ZERO_BYTE
8428 | OPTI_TYPE_PRECOMPUTE_INIT
8429 | OPTI_TYPE_PRECOMPUTE_MERKLE
8430 | OPTI_TYPE_EARLY_SKIP;
8431 dgst_pos0 = 0;
8432 dgst_pos1 = 3;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 1;
8435 break;
8436
8437 case 3711: hash_type = HASH_TYPE_MD5;
8438 salt_type = SALT_TYPE_EMBEDDED;
8439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_LE
8441 | OPTS_TYPE_PT_ADD80
8442 | OPTS_TYPE_PT_ADDBITS14;
8443 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8444 dgst_size = DGST_SIZE_4_4;
8445 parse_func = mediawiki_b_parse_hash;
8446 sort_by_digest = sort_by_digest_4_4;
8447 opti_type = OPTI_TYPE_ZERO_BYTE
8448 | OPTI_TYPE_PRECOMPUTE_INIT
8449 | OPTI_TYPE_PRECOMPUTE_MERKLE
8450 | OPTI_TYPE_EARLY_SKIP;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 3;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 1;
8455 break;
8456
8457 case 3800: hash_type = HASH_TYPE_MD5;
8458 salt_type = SALT_TYPE_INTERN;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_LE
8461 | OPTS_TYPE_ST_ADDBITS14;
8462 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8463 dgst_size = DGST_SIZE_4_4;
8464 parse_func = md5s_parse_hash;
8465 sort_by_digest = sort_by_digest_4_4;
8466 opti_type = OPTI_TYPE_ZERO_BYTE
8467 | OPTI_TYPE_PRECOMPUTE_INIT
8468 | OPTI_TYPE_PRECOMPUTE_MERKLE
8469 | OPTI_TYPE_EARLY_SKIP
8470 | OPTI_TYPE_NOT_ITERATED
8471 | OPTI_TYPE_RAW_HASH;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 3;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 1;
8476 break;
8477
8478 case 4300: hash_type = HASH_TYPE_MD5;
8479 salt_type = SALT_TYPE_VIRTUAL;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE
8482 | OPTS_TYPE_PT_ADD80
8483 | OPTS_TYPE_PT_ADDBITS14
8484 | OPTS_TYPE_ST_ADD80;
8485 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8486 dgst_size = DGST_SIZE_4_4;
8487 parse_func = md5md5_parse_hash;
8488 sort_by_digest = sort_by_digest_4_4;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_PRECOMPUTE_INIT
8491 | OPTI_TYPE_PRECOMPUTE_MERKLE
8492 | OPTI_TYPE_EARLY_SKIP;
8493 dgst_pos0 = 0;
8494 dgst_pos1 = 3;
8495 dgst_pos2 = 2;
8496 dgst_pos3 = 1;
8497 break;
8498
8499
8500 case 4400: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_NONE;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_BE
8504 | OPTS_TYPE_PT_ADD80
8505 | OPTS_TYPE_PT_ADDBITS15;
8506 kern_type = KERN_TYPE_MD5_SHA1;
8507 dgst_size = DGST_SIZE_4_4;
8508 parse_func = md5_parse_hash;
8509 sort_by_digest = sort_by_digest_4_4;
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_INIT
8512 | OPTI_TYPE_PRECOMPUTE_MERKLE
8513 | OPTI_TYPE_EARLY_SKIP
8514 | OPTI_TYPE_NOT_ITERATED
8515 | OPTI_TYPE_NOT_SALTED
8516 | OPTI_TYPE_RAW_HASH;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 3;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 1;
8521 break;
8522
8523 case 4500: hash_type = HASH_TYPE_SHA1;
8524 salt_type = SALT_TYPE_NONE;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_BE
8527 | OPTS_TYPE_PT_ADD80
8528 | OPTS_TYPE_PT_ADDBITS15;
8529 kern_type = KERN_TYPE_SHA11;
8530 dgst_size = DGST_SIZE_4_5;
8531 parse_func = sha1_parse_hash;
8532 sort_by_digest = sort_by_digest_4_5;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_PRECOMPUTE_MERKLE
8536 | OPTI_TYPE_EARLY_SKIP
8537 | OPTI_TYPE_NOT_SALTED;
8538 dgst_pos0 = 3;
8539 dgst_pos1 = 4;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544 case 4700: hash_type = HASH_TYPE_SHA1;
8545 salt_type = SALT_TYPE_NONE;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE
8548 | OPTS_TYPE_PT_ADD80
8549 | OPTS_TYPE_PT_ADDBITS14;
8550 kern_type = KERN_TYPE_SHA1_MD5;
8551 dgst_size = DGST_SIZE_4_5;
8552 parse_func = sha1_parse_hash;
8553 sort_by_digest = sort_by_digest_4_5;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP
8558 | OPTI_TYPE_NOT_ITERATED
8559 | OPTI_TYPE_NOT_SALTED
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 3;
8562 dgst_pos1 = 4;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 4800: hash_type = HASH_TYPE_MD5;
8568 salt_type = SALT_TYPE_EMBEDDED;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_PT_ADDBITS14;
8572 kern_type = KERN_TYPE_MD5_CHAP;
8573 dgst_size = DGST_SIZE_4_4;
8574 parse_func = chap_parse_hash;
8575 sort_by_digest = sort_by_digest_4_4;
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_INIT
8578 | OPTI_TYPE_PRECOMPUTE_MERKLE
8579 | OPTI_TYPE_MEET_IN_MIDDLE
8580 | OPTI_TYPE_EARLY_SKIP
8581 | OPTI_TYPE_NOT_ITERATED
8582 | OPTI_TYPE_RAW_HASH;
8583 dgst_pos0 = 0;
8584 dgst_pos1 = 3;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 1;
8587 break;
8588
8589 case 4900: hash_type = HASH_TYPE_SHA1;
8590 salt_type = SALT_TYPE_INTERN;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8593 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8594 dgst_size = DGST_SIZE_4_5;
8595 parse_func = sha1s_parse_hash;
8596 sort_by_digest = sort_by_digest_4_5;
8597 opti_type = OPTI_TYPE_ZERO_BYTE
8598 | OPTI_TYPE_PRECOMPUTE_INIT
8599 | OPTI_TYPE_PRECOMPUTE_MERKLE
8600 | OPTI_TYPE_EARLY_SKIP;
8601 dgst_pos0 = 3;
8602 dgst_pos1 = 4;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 1;
8605 break;
8606
8607 case 5000: hash_type = HASH_TYPE_KECCAK;
8608 salt_type = SALT_TYPE_EMBEDDED;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE
8611 | OPTS_TYPE_PT_ADD01;
8612 kern_type = KERN_TYPE_KECCAK;
8613 dgst_size = DGST_SIZE_8_25;
8614 parse_func = keccak_parse_hash;
8615 sort_by_digest = sort_by_digest_8_25;
8616 opti_type = OPTI_TYPE_ZERO_BYTE
8617 | OPTI_TYPE_USES_BITS_64
8618 | OPTI_TYPE_RAW_HASH;
8619 dgst_pos0 = 2;
8620 dgst_pos1 = 3;
8621 dgst_pos2 = 4;
8622 dgst_pos3 = 5;
8623 break;
8624
8625 case 5100: hash_type = HASH_TYPE_MD5H;
8626 salt_type = SALT_TYPE_NONE;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_LE
8629 | OPTS_TYPE_PT_ADD80
8630 | OPTS_TYPE_PT_ADDBITS14;
8631 kern_type = KERN_TYPE_MD5H;
8632 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8633 parse_func = md5half_parse_hash;
8634 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8635 opti_type = OPTI_TYPE_ZERO_BYTE
8636 | OPTI_TYPE_RAW_HASH;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 1;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 3;
8641 break;
8642
8643 case 5200: hash_type = HASH_TYPE_SHA256;
8644 salt_type = SALT_TYPE_EMBEDDED;
8645 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8647 kern_type = KERN_TYPE_PSAFE3;
8648 dgst_size = DGST_SIZE_4_8;
8649 parse_func = psafe3_parse_hash;
8650 sort_by_digest = sort_by_digest_4_8;
8651 opti_type = OPTI_TYPE_ZERO_BYTE;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 1;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 3;
8656 break;
8657
8658 case 5300: hash_type = HASH_TYPE_MD5;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE
8662 | OPTS_TYPE_ST_ADD80;
8663 kern_type = KERN_TYPE_IKEPSK_MD5;
8664 dgst_size = DGST_SIZE_4_4;
8665 parse_func = ikepsk_md5_parse_hash;
8666 sort_by_digest = sort_by_digest_4_4;
8667 opti_type = OPTI_TYPE_ZERO_BYTE;
8668 dgst_pos0 = 0;
8669 dgst_pos1 = 3;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 1;
8672 break;
8673
8674 case 5400: hash_type = HASH_TYPE_SHA1;
8675 salt_type = SALT_TYPE_EMBEDDED;
8676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_BE
8678 | OPTS_TYPE_ST_ADD80;
8679 kern_type = KERN_TYPE_IKEPSK_SHA1;
8680 dgst_size = DGST_SIZE_4_5;
8681 parse_func = ikepsk_sha1_parse_hash;
8682 sort_by_digest = sort_by_digest_4_5;
8683 opti_type = OPTI_TYPE_ZERO_BYTE;
8684 dgst_pos0 = 3;
8685 dgst_pos1 = 4;
8686 dgst_pos2 = 2;
8687 dgst_pos3 = 1;
8688 break;
8689
8690 case 5500: hash_type = HASH_TYPE_NETNTLM;
8691 salt_type = SALT_TYPE_EMBEDDED;
8692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8693 opts_type = OPTS_TYPE_PT_GENERATE_LE
8694 | OPTS_TYPE_PT_ADD80
8695 | OPTS_TYPE_PT_ADDBITS14
8696 | OPTS_TYPE_PT_UNICODE
8697 | OPTS_TYPE_ST_HEX;
8698 kern_type = KERN_TYPE_NETNTLMv1;
8699 dgst_size = DGST_SIZE_4_4;
8700 parse_func = netntlmv1_parse_hash;
8701 sort_by_digest = sort_by_digest_4_4;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8704 dgst_pos0 = 0;
8705 dgst_pos1 = 1;
8706 dgst_pos2 = 2;
8707 dgst_pos3 = 3;
8708 break;
8709
8710 case 5600: hash_type = HASH_TYPE_MD5;
8711 salt_type = SALT_TYPE_EMBEDDED;
8712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8713 opts_type = OPTS_TYPE_PT_GENERATE_LE
8714 | OPTS_TYPE_PT_ADD80
8715 | OPTS_TYPE_PT_ADDBITS14
8716 | OPTS_TYPE_PT_UNICODE;
8717 kern_type = KERN_TYPE_NETNTLMv2;
8718 dgst_size = DGST_SIZE_4_4;
8719 parse_func = netntlmv2_parse_hash;
8720 sort_by_digest = sort_by_digest_4_4;
8721 opti_type = OPTI_TYPE_ZERO_BYTE;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 3;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 1;
8726 break;
8727
8728 case 5700: hash_type = HASH_TYPE_SHA256;
8729 salt_type = SALT_TYPE_NONE;
8730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_BE
8732 | OPTS_TYPE_PT_ADD80
8733 | OPTS_TYPE_PT_ADDBITS15;
8734 kern_type = KERN_TYPE_SHA256;
8735 dgst_size = DGST_SIZE_4_8;
8736 parse_func = cisco4_parse_hash;
8737 sort_by_digest = sort_by_digest_4_8;
8738 opti_type = OPTI_TYPE_ZERO_BYTE
8739 | OPTI_TYPE_PRECOMPUTE_INIT
8740 | OPTI_TYPE_PRECOMPUTE_MERKLE
8741 | OPTI_TYPE_EARLY_SKIP
8742 | OPTI_TYPE_NOT_ITERATED
8743 | OPTI_TYPE_NOT_SALTED
8744 | OPTI_TYPE_RAW_HASH;
8745 dgst_pos0 = 3;
8746 dgst_pos1 = 7;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 6;
8749 break;
8750
8751 case 5800: hash_type = HASH_TYPE_SHA1;
8752 salt_type = SALT_TYPE_INTERN;
8753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8755 | OPTS_TYPE_ST_ADD80;
8756 kern_type = KERN_TYPE_ANDROIDPIN;
8757 dgst_size = DGST_SIZE_4_5;
8758 parse_func = androidpin_parse_hash;
8759 sort_by_digest = sort_by_digest_4_5;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8768 salt_type = SALT_TYPE_NONE;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADD80;
8772 kern_type = KERN_TYPE_RIPEMD160;
8773 dgst_size = DGST_SIZE_4_5;
8774 parse_func = ripemd160_parse_hash;
8775 sort_by_digest = sort_by_digest_4_5;
8776 opti_type = OPTI_TYPE_ZERO_BYTE;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8784 salt_type = SALT_TYPE_NONE;
8785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_BE
8787 | OPTS_TYPE_PT_ADD80;
8788 kern_type = KERN_TYPE_WHIRLPOOL;
8789 dgst_size = DGST_SIZE_4_16;
8790 parse_func = whirlpool_parse_hash;
8791 sort_by_digest = sort_by_digest_4_16;
8792 opti_type = OPTI_TYPE_ZERO_BYTE;
8793 dgst_pos0 = 0;
8794 dgst_pos1 = 1;
8795 dgst_pos2 = 2;
8796 dgst_pos3 = 3;
8797 break;
8798
8799 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8800 salt_type = SALT_TYPE_EMBEDDED;
8801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8803 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8804 dgst_size = DGST_SIZE_4_5;
8805 parse_func = truecrypt_parse_hash_2k;
8806 sort_by_digest = sort_by_digest_4_5;
8807 opti_type = OPTI_TYPE_ZERO_BYTE;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 1;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 3;
8812 break;
8813
8814 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8815 salt_type = SALT_TYPE_EMBEDDED;
8816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8818 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8819 dgst_size = DGST_SIZE_4_5;
8820 parse_func = truecrypt_parse_hash_2k;
8821 sort_by_digest = sort_by_digest_4_5;
8822 opti_type = OPTI_TYPE_ZERO_BYTE;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8833 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8834 dgst_size = DGST_SIZE_4_5;
8835 parse_func = truecrypt_parse_hash_2k;
8836 sort_by_digest = sort_by_digest_4_5;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6221: hash_type = HASH_TYPE_SHA512;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8848 kern_type = KERN_TYPE_TCSHA512_XTS512;
8849 dgst_size = DGST_SIZE_8_8;
8850 parse_func = truecrypt_parse_hash_1k;
8851 sort_by_digest = sort_by_digest_8_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_USES_BITS_64;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6222: hash_type = HASH_TYPE_SHA512;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8864 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8865 dgst_size = DGST_SIZE_8_8;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_8_8;
8868 opti_type = OPTI_TYPE_ZERO_BYTE
8869 | OPTI_TYPE_USES_BITS_64;
8870 dgst_pos0 = 0;
8871 dgst_pos1 = 1;
8872 dgst_pos2 = 2;
8873 dgst_pos3 = 3;
8874 break;
8875
8876 case 6223: hash_type = HASH_TYPE_SHA512;
8877 salt_type = SALT_TYPE_EMBEDDED;
8878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8879 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8880 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8881 dgst_size = DGST_SIZE_8_8;
8882 parse_func = truecrypt_parse_hash_1k;
8883 sort_by_digest = sort_by_digest_8_8;
8884 opti_type = OPTI_TYPE_ZERO_BYTE
8885 | OPTI_TYPE_USES_BITS_64;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8896 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8897 dgst_size = DGST_SIZE_4_8;
8898 parse_func = truecrypt_parse_hash_1k;
8899 sort_by_digest = sort_by_digest_4_8;
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8911 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8912 dgst_size = DGST_SIZE_4_8;
8913 parse_func = truecrypt_parse_hash_1k;
8914 sort_by_digest = sort_by_digest_4_8;
8915 opti_type = OPTI_TYPE_ZERO_BYTE;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8926 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8927 dgst_size = DGST_SIZE_4_8;
8928 parse_func = truecrypt_parse_hash_1k;
8929 sort_by_digest = sort_by_digest_4_8;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8942 dgst_size = DGST_SIZE_4_5;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8957 dgst_size = DGST_SIZE_4_5;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_5;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8972 dgst_size = DGST_SIZE_4_5;
8973 parse_func = truecrypt_parse_hash_1k;
8974 sort_by_digest = sort_by_digest_4_5;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6300: hash_type = HASH_TYPE_MD5;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_MD5AIX;
8987 dgst_size = DGST_SIZE_4_4;
8988 parse_func = md5aix_parse_hash;
8989 sort_by_digest = sort_by_digest_4_4;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6400: hash_type = HASH_TYPE_SHA256;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9001 kern_type = KERN_TYPE_SHA256AIX;
9002 dgst_size = DGST_SIZE_4_8;
9003 parse_func = sha256aix_parse_hash;
9004 sort_by_digest = sort_by_digest_4_8;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6500: hash_type = HASH_TYPE_SHA512;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9016 kern_type = KERN_TYPE_SHA512AIX;
9017 dgst_size = DGST_SIZE_8_8;
9018 parse_func = sha512aix_parse_hash;
9019 sort_by_digest = sort_by_digest_8_8;
9020 opti_type = OPTI_TYPE_ZERO_BYTE
9021 | OPTI_TYPE_USES_BITS_64;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 6600: hash_type = HASH_TYPE_AES;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9032 kern_type = KERN_TYPE_AGILEKEY;
9033 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9034 parse_func = agilekey_parse_hash;
9035 sort_by_digest = sort_by_digest_4_5;
9036 opti_type = OPTI_TYPE_ZERO_BYTE;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 6700: hash_type = HASH_TYPE_SHA1;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9047 kern_type = KERN_TYPE_SHA1AIX;
9048 dgst_size = DGST_SIZE_4_5;
9049 parse_func = sha1aix_parse_hash;
9050 sort_by_digest = sort_by_digest_4_5;
9051 opti_type = OPTI_TYPE_ZERO_BYTE;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6800: hash_type = HASH_TYPE_AES;
9059 salt_type = SALT_TYPE_EMBEDDED;
9060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9062 kern_type = KERN_TYPE_LASTPASS;
9063 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9064 parse_func = lastpass_parse_hash;
9065 sort_by_digest = sort_by_digest_4_8;
9066 opti_type = OPTI_TYPE_ZERO_BYTE;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6900: hash_type = HASH_TYPE_GOST;
9074 salt_type = SALT_TYPE_NONE;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9077 kern_type = KERN_TYPE_GOST;
9078 dgst_size = DGST_SIZE_4_8;
9079 parse_func = gost_parse_hash;
9080 sort_by_digest = sort_by_digest_4_8;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 7100: hash_type = HASH_TYPE_SHA512;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9092 kern_type = KERN_TYPE_PBKDF2_SHA512;
9093 dgst_size = DGST_SIZE_8_16;
9094 parse_func = sha512osx_parse_hash;
9095 sort_by_digest = sort_by_digest_8_16;
9096 opti_type = OPTI_TYPE_ZERO_BYTE
9097 | OPTI_TYPE_USES_BITS_64
9098 | OPTI_TYPE_SLOW_HASH_SIMD;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 7200: hash_type = HASH_TYPE_SHA512;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9109 kern_type = KERN_TYPE_PBKDF2_SHA512;
9110 dgst_size = DGST_SIZE_8_16;
9111 parse_func = sha512grub_parse_hash;
9112 sort_by_digest = sort_by_digest_8_16;
9113 opti_type = OPTI_TYPE_ZERO_BYTE
9114 | OPTI_TYPE_USES_BITS_64
9115 | OPTI_TYPE_SLOW_HASH_SIMD;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 7300: hash_type = HASH_TYPE_SHA1;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_BE
9126 | OPTS_TYPE_ST_ADD80
9127 | OPTS_TYPE_ST_ADDBITS15;
9128 kern_type = KERN_TYPE_RAKP;
9129 dgst_size = DGST_SIZE_4_5;
9130 parse_func = rakp_parse_hash;
9131 sort_by_digest = sort_by_digest_4_5;
9132 opti_type = OPTI_TYPE_ZERO_BYTE
9133 | OPTI_TYPE_NOT_ITERATED;
9134 dgst_pos0 = 3;
9135 dgst_pos1 = 4;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 1;
9138 break;
9139
9140 case 7400: hash_type = HASH_TYPE_SHA256;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9144 kern_type = KERN_TYPE_SHA256CRYPT;
9145 dgst_size = DGST_SIZE_4_8;
9146 parse_func = sha256crypt_parse_hash;
9147 sort_by_digest = sort_by_digest_4_8;
9148 opti_type = OPTI_TYPE_ZERO_BYTE;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 1;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 3;
9153 break;
9154
9155 case 7500: hash_type = HASH_TYPE_KRB5PA;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9159 kern_type = KERN_TYPE_KRB5PA;
9160 dgst_size = DGST_SIZE_4_4;
9161 parse_func = krb5pa_parse_hash;
9162 sort_by_digest = sort_by_digest_4_4;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_NOT_ITERATED;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 7600: hash_type = HASH_TYPE_SHA1;
9172 salt_type = SALT_TYPE_INTERN;
9173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_BE
9175 | OPTS_TYPE_PT_ADD80
9176 | OPTS_TYPE_PT_ADDBITS15;
9177 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9178 dgst_size = DGST_SIZE_4_5;
9179 parse_func = redmine_parse_hash;
9180 sort_by_digest = sort_by_digest_4_5;
9181 opti_type = OPTI_TYPE_ZERO_BYTE
9182 | OPTI_TYPE_PRECOMPUTE_INIT
9183 | OPTI_TYPE_EARLY_SKIP
9184 | OPTI_TYPE_NOT_ITERATED
9185 | OPTI_TYPE_PREPENDED_SALT;
9186 dgst_pos0 = 3;
9187 dgst_pos1 = 4;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 1;
9190 break;
9191
9192 case 7700: hash_type = HASH_TYPE_SAPB;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE
9196 | OPTS_TYPE_PT_UPPER
9197 | OPTS_TYPE_ST_UPPER;
9198 kern_type = KERN_TYPE_SAPB;
9199 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9200 parse_func = sapb_parse_hash;
9201 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9202 opti_type = OPTI_TYPE_ZERO_BYTE
9203 | OPTI_TYPE_PRECOMPUTE_INIT
9204 | OPTI_TYPE_NOT_ITERATED;
9205 dgst_pos0 = 0;
9206 dgst_pos1 = 1;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 3;
9209 break;
9210
9211 case 7800: hash_type = HASH_TYPE_SAPG;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_BE
9215 | OPTS_TYPE_ST_ADD80
9216 | OPTS_TYPE_ST_UPPER;
9217 kern_type = KERN_TYPE_SAPG;
9218 dgst_size = DGST_SIZE_4_5;
9219 parse_func = sapg_parse_hash;
9220 sort_by_digest = sort_by_digest_4_5;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_NOT_ITERATED;
9224 dgst_pos0 = 3;
9225 dgst_pos1 = 4;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 1;
9228 break;
9229
9230 case 7900: hash_type = HASH_TYPE_SHA512;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9234 kern_type = KERN_TYPE_DRUPAL7;
9235 dgst_size = DGST_SIZE_8_8;
9236 parse_func = drupal7_parse_hash;
9237 sort_by_digest = sort_by_digest_8_8;
9238 opti_type = OPTI_TYPE_ZERO_BYTE
9239 | OPTI_TYPE_USES_BITS_64;
9240 dgst_pos0 = 0;
9241 dgst_pos1 = 1;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 3;
9244 break;
9245
9246 case 8000: hash_type = HASH_TYPE_SHA256;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_BE
9250 | OPTS_TYPE_PT_UNICODE
9251 | OPTS_TYPE_ST_ADD80
9252 | OPTS_TYPE_ST_HEX;
9253 kern_type = KERN_TYPE_SYBASEASE;
9254 dgst_size = DGST_SIZE_4_8;
9255 parse_func = sybasease_parse_hash;
9256 sort_by_digest = sort_by_digest_4_8;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_PRECOMPUTE_INIT
9259 | OPTI_TYPE_EARLY_SKIP
9260 | OPTI_TYPE_NOT_ITERATED
9261 | OPTI_TYPE_RAW_HASH;
9262 dgst_pos0 = 3;
9263 dgst_pos1 = 7;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 6;
9266 break;
9267
9268 case 8100: hash_type = HASH_TYPE_SHA1;
9269 salt_type = SALT_TYPE_EMBEDDED;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9272 kern_type = KERN_TYPE_NETSCALER;
9273 dgst_size = DGST_SIZE_4_5;
9274 parse_func = netscaler_parse_hash;
9275 sort_by_digest = sort_by_digest_4_5;
9276 opti_type = OPTI_TYPE_ZERO_BYTE
9277 | OPTI_TYPE_PRECOMPUTE_INIT
9278 | OPTI_TYPE_PRECOMPUTE_MERKLE
9279 | OPTI_TYPE_EARLY_SKIP
9280 | OPTI_TYPE_NOT_ITERATED
9281 | OPTI_TYPE_PREPENDED_SALT
9282 | OPTI_TYPE_RAW_HASH;
9283 dgst_pos0 = 3;
9284 dgst_pos1 = 4;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 1;
9287 break;
9288
9289 case 8200: hash_type = HASH_TYPE_SHA256;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9293 kern_type = KERN_TYPE_CLOUDKEY;
9294 dgst_size = DGST_SIZE_4_8;
9295 parse_func = cloudkey_parse_hash;
9296 sort_by_digest = sort_by_digest_4_8;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 8300: hash_type = HASH_TYPE_SHA1;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_BE
9308 | OPTS_TYPE_ST_HEX
9309 | OPTS_TYPE_ST_ADD80;
9310 kern_type = KERN_TYPE_NSEC3;
9311 dgst_size = DGST_SIZE_4_5;
9312 parse_func = nsec3_parse_hash;
9313 sort_by_digest = sort_by_digest_4_5;
9314 opti_type = OPTI_TYPE_ZERO_BYTE;
9315 dgst_pos0 = 3;
9316 dgst_pos1 = 4;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 1;
9319 break;
9320
9321 case 8400: hash_type = HASH_TYPE_SHA1;
9322 salt_type = SALT_TYPE_INTERN;
9323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_BE
9325 | OPTS_TYPE_PT_ADD80
9326 | OPTS_TYPE_PT_ADDBITS15;
9327 kern_type = KERN_TYPE_WBB3;
9328 dgst_size = DGST_SIZE_4_5;
9329 parse_func = wbb3_parse_hash;
9330 sort_by_digest = sort_by_digest_4_5;
9331 opti_type = OPTI_TYPE_ZERO_BYTE
9332 | OPTI_TYPE_PRECOMPUTE_INIT
9333 | OPTI_TYPE_NOT_ITERATED;
9334 dgst_pos0 = 3;
9335 dgst_pos1 = 4;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 1;
9338 break;
9339
9340 case 8500: hash_type = HASH_TYPE_DESRACF;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE
9344 | OPTS_TYPE_ST_UPPER;
9345 kern_type = KERN_TYPE_RACF;
9346 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9347 parse_func = racf_parse_hash;
9348 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9349 opti_type = OPTI_TYPE_ZERO_BYTE
9350 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 8600: hash_type = HASH_TYPE_LOTUS5;
9358 salt_type = SALT_TYPE_NONE;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9361 kern_type = KERN_TYPE_LOTUS5;
9362 dgst_size = DGST_SIZE_4_4;
9363 parse_func = lotus5_parse_hash;
9364 sort_by_digest = sort_by_digest_4_4;
9365 opti_type = OPTI_TYPE_EARLY_SKIP
9366 | OPTI_TYPE_NOT_ITERATED
9367 | OPTI_TYPE_NOT_SALTED
9368 | OPTI_TYPE_RAW_HASH;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 8700: hash_type = HASH_TYPE_LOTUS6;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_LOTUS6;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = lotus6_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_EARLY_SKIP
9384 | OPTI_TYPE_NOT_ITERATED
9385 | OPTI_TYPE_RAW_HASH;
9386 dgst_pos0 = 0;
9387 dgst_pos1 = 1;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 3;
9390 break;
9391
9392 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9393 salt_type = SALT_TYPE_EMBEDDED;
9394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9396 kern_type = KERN_TYPE_ANDROIDFDE;
9397 dgst_size = DGST_SIZE_4_4;
9398 parse_func = androidfde_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4;
9400 opti_type = OPTI_TYPE_ZERO_BYTE;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 1;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 3;
9405 break;
9406
9407 case 8900: hash_type = HASH_TYPE_SCRYPT;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9411 kern_type = KERN_TYPE_SCRYPT;
9412 dgst_size = DGST_SIZE_4_8;
9413 parse_func = scrypt_parse_hash;
9414 sort_by_digest = sort_by_digest_4_8;
9415 opti_type = OPTI_TYPE_ZERO_BYTE;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 9000: hash_type = HASH_TYPE_SHA1;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE
9426 | OPTS_TYPE_ST_GENERATE_LE;
9427 kern_type = KERN_TYPE_PSAFE2;
9428 dgst_size = DGST_SIZE_4_5;
9429 parse_func = psafe2_parse_hash;
9430 sort_by_digest = sort_by_digest_4_5;
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 9100: hash_type = HASH_TYPE_LOTUS8;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_LOTUS8;
9443 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9444 parse_func = lotus8_parse_hash;
9445 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 9200: hash_type = HASH_TYPE_SHA256;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9457 kern_type = KERN_TYPE_PBKDF2_SHA256;
9458 dgst_size = DGST_SIZE_4_32;
9459 parse_func = cisco8_parse_hash;
9460 sort_by_digest = sort_by_digest_4_32;
9461 opti_type = OPTI_TYPE_ZERO_BYTE
9462 | OPTI_TYPE_SLOW_HASH_SIMD;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 9300: hash_type = HASH_TYPE_SCRYPT;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_SCRYPT;
9474 dgst_size = DGST_SIZE_4_8;
9475 parse_func = cisco9_parse_hash;
9476 sort_by_digest = sort_by_digest_4_8;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9488 kern_type = KERN_TYPE_OFFICE2007;
9489 dgst_size = DGST_SIZE_4_4;
9490 parse_func = office2007_parse_hash;
9491 sort_by_digest = sort_by_digest_4_4;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_OFFICE2010;
9504 dgst_size = DGST_SIZE_4_4;
9505 parse_func = office2010_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4;
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9518 kern_type = KERN_TYPE_OFFICE2013;
9519 dgst_size = DGST_SIZE_4_4;
9520 parse_func = office2013_parse_hash;
9521 sort_by_digest = sort_by_digest_4_4;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE
9533 | OPTS_TYPE_PT_ADD80
9534 | OPTS_TYPE_PT_UNICODE;
9535 kern_type = KERN_TYPE_OLDOFFICE01;
9536 dgst_size = DGST_SIZE_4_4;
9537 parse_func = oldoffice01_parse_hash;
9538 sort_by_digest = sort_by_digest_4_4;
9539 opti_type = OPTI_TYPE_ZERO_BYTE
9540 | OPTI_TYPE_PRECOMPUTE_INIT
9541 | OPTI_TYPE_NOT_ITERATED;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE
9552 | OPTS_TYPE_PT_ADD80;
9553 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9554 dgst_size = DGST_SIZE_4_4;
9555 parse_func = oldoffice01cm1_parse_hash;
9556 sort_by_digest = sort_by_digest_4_4;
9557 opti_type = OPTI_TYPE_ZERO_BYTE
9558 | OPTI_TYPE_PRECOMPUTE_INIT
9559 | OPTI_TYPE_NOT_ITERATED;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE
9570 | OPTS_TYPE_PT_ADD80
9571 | OPTS_TYPE_PT_UNICODE
9572 | OPTS_TYPE_PT_NEVERCRACK;
9573 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9574 dgst_size = DGST_SIZE_4_4;
9575 parse_func = oldoffice01cm2_parse_hash;
9576 sort_by_digest = sort_by_digest_4_4;
9577 opti_type = OPTI_TYPE_ZERO_BYTE
9578 | OPTI_TYPE_PRECOMPUTE_INIT
9579 | OPTI_TYPE_NOT_ITERATED;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_BE
9590 | OPTS_TYPE_PT_ADD80
9591 | OPTS_TYPE_PT_UNICODE;
9592 kern_type = KERN_TYPE_OLDOFFICE34;
9593 dgst_size = DGST_SIZE_4_4;
9594 parse_func = oldoffice34_parse_hash;
9595 sort_by_digest = sort_by_digest_4_4;
9596 opti_type = OPTI_TYPE_ZERO_BYTE
9597 | OPTI_TYPE_PRECOMPUTE_INIT
9598 | OPTI_TYPE_NOT_ITERATED;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9610 dgst_size = DGST_SIZE_4_4;
9611 parse_func = oldoffice34cm1_parse_hash;
9612 sort_by_digest = sort_by_digest_4_4;
9613 opti_type = OPTI_TYPE_ZERO_BYTE
9614 | OPTI_TYPE_PRECOMPUTE_INIT
9615 | OPTI_TYPE_NOT_ITERATED;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_BE
9626 | OPTS_TYPE_PT_ADD80
9627 | OPTS_TYPE_PT_UNICODE
9628 | OPTS_TYPE_PT_NEVERCRACK;
9629 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9630 dgst_size = DGST_SIZE_4_4;
9631 parse_func = oldoffice34cm2_parse_hash;
9632 sort_by_digest = sort_by_digest_4_4;
9633 opti_type = OPTI_TYPE_ZERO_BYTE
9634 | OPTI_TYPE_PRECOMPUTE_INIT
9635 | OPTI_TYPE_NOT_ITERATED;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 9900: hash_type = HASH_TYPE_MD5;
9643 salt_type = SALT_TYPE_NONE;
9644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9646 kern_type = KERN_TYPE_RADMIN2;
9647 dgst_size = DGST_SIZE_4_4;
9648 parse_func = radmin2_parse_hash;
9649 sort_by_digest = sort_by_digest_4_4;
9650 opti_type = OPTI_TYPE_ZERO_BYTE
9651 | OPTI_TYPE_PRECOMPUTE_INIT
9652 | OPTI_TYPE_EARLY_SKIP
9653 | OPTI_TYPE_NOT_ITERATED
9654 | OPTI_TYPE_NOT_SALTED;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 3;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 1;
9659 break;
9660
9661 case 10000: hash_type = HASH_TYPE_SHA256;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9665 kern_type = KERN_TYPE_PBKDF2_SHA256;
9666 dgst_size = DGST_SIZE_4_32;
9667 parse_func = djangopbkdf2_parse_hash;
9668 sort_by_digest = sort_by_digest_4_32;
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_SLOW_HASH_SIMD;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 10100: hash_type = HASH_TYPE_SIPHASH;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9681 kern_type = KERN_TYPE_SIPHASH;
9682 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9683 parse_func = siphash_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_NOT_ITERATED
9687 | OPTI_TYPE_RAW_HASH;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 10200: hash_type = HASH_TYPE_MD5;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE
9698 | OPTS_TYPE_ST_ADD80
9699 | OPTS_TYPE_ST_ADDBITS14;
9700 kern_type = KERN_TYPE_HMACMD5_PW;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = crammd5_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_NOT_ITERATED;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 3;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 1;
9710 break;
9711
9712 case 10300: hash_type = HASH_TYPE_SHA1;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9716 kern_type = KERN_TYPE_SAPH_SHA1;
9717 dgst_size = DGST_SIZE_4_5;
9718 parse_func = saph_sha1_parse_hash;
9719 sort_by_digest = sort_by_digest_4_5;
9720 opti_type = OPTI_TYPE_ZERO_BYTE;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 10400: hash_type = HASH_TYPE_PDFU16;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9731 kern_type = KERN_TYPE_PDF11;
9732 dgst_size = DGST_SIZE_4_4;
9733 parse_func = pdf11_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 10410: hash_type = HASH_TYPE_PDFU16;
9744 salt_type = SALT_TYPE_EMBEDDED;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9747 kern_type = KERN_TYPE_PDF11CM1;
9748 dgst_size = DGST_SIZE_4_4;
9749 parse_func = pdf11cm1_parse_hash;
9750 sort_by_digest = sort_by_digest_4_4;
9751 opti_type = OPTI_TYPE_ZERO_BYTE
9752 | OPTI_TYPE_NOT_ITERATED;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 10420: hash_type = HASH_TYPE_PDFU16;
9760 salt_type = SALT_TYPE_EMBEDDED;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9763 kern_type = KERN_TYPE_PDF11CM2;
9764 dgst_size = DGST_SIZE_4_4;
9765 parse_func = pdf11cm2_parse_hash;
9766 sort_by_digest = sort_by_digest_4_4;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_NOT_ITERATED;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 10500: hash_type = HASH_TYPE_PDFU16;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9779 kern_type = KERN_TYPE_PDF14;
9780 dgst_size = DGST_SIZE_4_4;
9781 parse_func = pdf14_parse_hash;
9782 sort_by_digest = sort_by_digest_4_4;
9783 opti_type = OPTI_TYPE_ZERO_BYTE
9784 | OPTI_TYPE_NOT_ITERATED;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 1;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 3;
9789 break;
9790
9791 case 10600: hash_type = HASH_TYPE_SHA256;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_BE
9795 | OPTS_TYPE_ST_ADD80
9796 | OPTS_TYPE_ST_ADDBITS15
9797 | OPTS_TYPE_HASH_COPY;
9798 kern_type = KERN_TYPE_SHA256_PWSLT;
9799 dgst_size = DGST_SIZE_4_8;
9800 parse_func = pdf17l3_parse_hash;
9801 sort_by_digest = sort_by_digest_4_8;
9802 opti_type = OPTI_TYPE_ZERO_BYTE
9803 | OPTI_TYPE_PRECOMPUTE_INIT
9804 | OPTI_TYPE_PRECOMPUTE_MERKLE
9805 | OPTI_TYPE_EARLY_SKIP
9806 | OPTI_TYPE_NOT_ITERATED
9807 | OPTI_TYPE_APPENDED_SALT
9808 | OPTI_TYPE_RAW_HASH;
9809 dgst_pos0 = 3;
9810 dgst_pos1 = 7;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 6;
9813 break;
9814
9815 case 10700: hash_type = HASH_TYPE_PDFU32;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE
9819 | OPTS_TYPE_HASH_COPY;
9820 kern_type = KERN_TYPE_PDF17L8;
9821 dgst_size = DGST_SIZE_4_8;
9822 parse_func = pdf17l8_parse_hash;
9823 sort_by_digest = sort_by_digest_4_8;
9824 opti_type = OPTI_TYPE_ZERO_BYTE
9825 | OPTI_TYPE_NOT_ITERATED;
9826 dgst_pos0 = 0;
9827 dgst_pos1 = 1;
9828 dgst_pos2 = 2;
9829 dgst_pos3 = 3;
9830 break;
9831
9832 case 10800: hash_type = HASH_TYPE_SHA384;
9833 salt_type = SALT_TYPE_NONE;
9834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9835 opts_type = OPTS_TYPE_PT_GENERATE_BE
9836 | OPTS_TYPE_PT_ADD80
9837 | OPTS_TYPE_PT_ADDBITS15;
9838 kern_type = KERN_TYPE_SHA384;
9839 dgst_size = DGST_SIZE_8_8;
9840 parse_func = sha384_parse_hash;
9841 sort_by_digest = sort_by_digest_8_8;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_PRECOMPUTE_MERKLE
9845 | OPTI_TYPE_EARLY_SKIP
9846 | OPTI_TYPE_NOT_ITERATED
9847 | OPTI_TYPE_NOT_SALTED
9848 | OPTI_TYPE_USES_BITS_64
9849 | OPTI_TYPE_RAW_HASH;
9850 dgst_pos0 = 6;
9851 dgst_pos1 = 7;
9852 dgst_pos2 = 4;
9853 dgst_pos3 = 5;
9854 break;
9855
9856 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE
9860 | OPTS_TYPE_ST_BASE64
9861 | OPTS_TYPE_HASH_COPY;
9862 kern_type = KERN_TYPE_PBKDF2_SHA256;
9863 dgst_size = DGST_SIZE_4_32;
9864 parse_func = pbkdf2_sha256_parse_hash;
9865 sort_by_digest = sort_by_digest_4_32;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_SLOW_HASH_SIMD;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 1;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 3;
9872 break;
9873
9874 case 11000: hash_type = HASH_TYPE_MD5;
9875 salt_type = SALT_TYPE_INTERN;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_PT_ADD80;
9879 kern_type = KERN_TYPE_PRESTASHOP;
9880 dgst_size = DGST_SIZE_4_4;
9881 parse_func = prestashop_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4;
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_PRECOMPUTE_INIT
9885 | OPTI_TYPE_NOT_ITERATED
9886 | OPTI_TYPE_PREPENDED_SALT;
9887 dgst_pos0 = 0;
9888 dgst_pos1 = 3;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 1;
9891 break;
9892
9893 case 11100: hash_type = HASH_TYPE_MD5;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE
9897 | OPTS_TYPE_ST_ADD80;
9898 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = postgresql_auth_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_PRECOMPUTE_INIT
9904 | OPTI_TYPE_PRECOMPUTE_MERKLE
9905 | OPTI_TYPE_EARLY_SKIP;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11200: hash_type = HASH_TYPE_SHA1;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_BE
9916 | OPTS_TYPE_PT_ADD80
9917 | OPTS_TYPE_ST_HEX;
9918 kern_type = KERN_TYPE_MYSQL_AUTH;
9919 dgst_size = DGST_SIZE_4_5;
9920 parse_func = mysql_auth_parse_hash;
9921 sort_by_digest = sort_by_digest_4_5;
9922 opti_type = OPTI_TYPE_ZERO_BYTE
9923 | OPTI_TYPE_EARLY_SKIP;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 4;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_ST_HEX
9935 | OPTS_TYPE_ST_ADD80;
9936 kern_type = KERN_TYPE_BITCOIN_WALLET;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = bitcoin_wallet_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 11400: hash_type = HASH_TYPE_MD5;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE
9951 | OPTS_TYPE_PT_ADD80
9952 | OPTS_TYPE_HASH_COPY;
9953 kern_type = KERN_TYPE_SIP_AUTH;
9954 dgst_size = DGST_SIZE_4_4;
9955 parse_func = sip_auth_parse_hash;
9956 sort_by_digest = sort_by_digest_4_4;
9957 opti_type = OPTI_TYPE_ZERO_BYTE;
9958 dgst_pos0 = 0;
9959 dgst_pos1 = 3;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 1;
9962 break;
9963
9964 case 11500: hash_type = HASH_TYPE_CRC32;
9965 salt_type = SALT_TYPE_INTERN;
9966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_ST_GENERATE_LE
9969 | OPTS_TYPE_ST_HEX;
9970 kern_type = KERN_TYPE_CRC32;
9971 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9972 parse_func = crc32_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11600: hash_type = HASH_TYPE_AES;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_PT_NEVERCRACK;
9986 kern_type = KERN_TYPE_SEVEN_ZIP;
9987 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9988 parse_func = seven_zip_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9998 salt_type = SALT_TYPE_NONE;
9999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE
10001 | OPTS_TYPE_PT_ADD01;
10002 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10003 dgst_size = DGST_SIZE_4_8;
10004 parse_func = gost2012sbog_256_parse_hash;
10005 sort_by_digest = sort_by_digest_4_8;
10006 opti_type = OPTI_TYPE_ZERO_BYTE;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10014 salt_type = SALT_TYPE_NONE;
10015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_PT_ADD01;
10018 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10019 dgst_size = DGST_SIZE_4_16;
10020 parse_func = gost2012sbog_512_parse_hash;
10021 sort_by_digest = sort_by_digest_4_16;
10022 opti_type = OPTI_TYPE_ZERO_BYTE;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE
10033 | OPTS_TYPE_ST_BASE64
10034 | OPTS_TYPE_HASH_COPY;
10035 kern_type = KERN_TYPE_PBKDF2_MD5;
10036 dgst_size = DGST_SIZE_4_32;
10037 parse_func = pbkdf2_md5_parse_hash;
10038 sort_by_digest = sort_by_digest_4_32;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_SLOW_HASH_SIMD;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE
10051 | OPTS_TYPE_ST_BASE64
10052 | OPTS_TYPE_HASH_COPY;
10053 kern_type = KERN_TYPE_PBKDF2_SHA1;
10054 dgst_size = DGST_SIZE_4_32;
10055 parse_func = pbkdf2_sha1_parse_hash;
10056 sort_by_digest = sort_by_digest_4_32;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_SLOW_HASH_SIMD;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA512;
10072 dgst_size = DGST_SIZE_8_16;
10073 parse_func = pbkdf2_sha512_parse_hash;
10074 sort_by_digest = sort_by_digest_8_16;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_USES_BITS_64
10077 | OPTI_TYPE_SLOW_HASH_SIMD;
10078 dgst_pos0 = 0;
10079 dgst_pos1 = 1;
10080 dgst_pos2 = 2;
10081 dgst_pos3 = 3;
10082 break;
10083
10084 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10085 salt_type = SALT_TYPE_EMBEDDED;
10086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10087 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10088 kern_type = KERN_TYPE_ECRYPTFS;
10089 dgst_size = DGST_SIZE_8_8;
10090 parse_func = ecryptfs_parse_hash;
10091 sort_by_digest = sort_by_digest_8_8;
10092 opti_type = OPTI_TYPE_ZERO_BYTE
10093 | OPTI_TYPE_USES_BITS_64;
10094 dgst_pos0 = 0;
10095 dgst_pos1 = 1;
10096 dgst_pos2 = 2;
10097 dgst_pos3 = 3;
10098 break;
10099
10100 case 12300: hash_type = HASH_TYPE_ORACLET;
10101 salt_type = SALT_TYPE_EMBEDDED;
10102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10104 kern_type = KERN_TYPE_ORACLET;
10105 dgst_size = DGST_SIZE_8_16;
10106 parse_func = oraclet_parse_hash;
10107 sort_by_digest = sort_by_digest_8_16;
10108 opti_type = OPTI_TYPE_ZERO_BYTE
10109 | OPTI_TYPE_USES_BITS_64;
10110 dgst_pos0 = 0;
10111 dgst_pos1 = 1;
10112 dgst_pos2 = 2;
10113 dgst_pos3 = 3;
10114 break;
10115
10116 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10117 salt_type = SALT_TYPE_EMBEDDED;
10118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10120 kern_type = KERN_TYPE_BSDICRYPT;
10121 dgst_size = DGST_SIZE_4_4;
10122 parse_func = bsdicrypt_parse_hash;
10123 sort_by_digest = sort_by_digest_4_4;
10124 opti_type = OPTI_TYPE_ZERO_BYTE
10125 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 12500: hash_type = HASH_TYPE_RAR3HP;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10136 kern_type = KERN_TYPE_RAR3;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = rar3hp_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE;
10141 dgst_pos0 = 0;
10142 dgst_pos1 = 1;
10143 dgst_pos2 = 2;
10144 dgst_pos3 = 3;
10145 break;
10146
10147 case 12600: hash_type = HASH_TYPE_SHA256;
10148 salt_type = SALT_TYPE_INTERN;
10149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10150 opts_type = OPTS_TYPE_PT_GENERATE_BE
10151 | OPTS_TYPE_PT_ADD80;
10152 kern_type = KERN_TYPE_CF10;
10153 dgst_size = DGST_SIZE_4_8;
10154 parse_func = cf10_parse_hash;
10155 sort_by_digest = sort_by_digest_4_8;
10156 opti_type = OPTI_TYPE_ZERO_BYTE
10157 | OPTI_TYPE_PRECOMPUTE_INIT
10158 | OPTI_TYPE_EARLY_SKIP
10159 | OPTI_TYPE_NOT_ITERATED;
10160 dgst_pos0 = 3;
10161 dgst_pos1 = 7;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 6;
10164 break;
10165
10166 case 12700: hash_type = HASH_TYPE_AES;
10167 salt_type = SALT_TYPE_EMBEDDED;
10168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_LE
10170 | OPTS_TYPE_HASH_COPY;
10171 kern_type = KERN_TYPE_MYWALLET;
10172 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10173 parse_func = mywallet_parse_hash;
10174 sort_by_digest = sort_by_digest_4_5;
10175 opti_type = OPTI_TYPE_ZERO_BYTE;
10176 dgst_pos0 = 0;
10177 dgst_pos1 = 1;
10178 dgst_pos2 = 2;
10179 dgst_pos3 = 3;
10180 break;
10181
10182 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10183 salt_type = SALT_TYPE_EMBEDDED;
10184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10186 kern_type = KERN_TYPE_MS_DRSR;
10187 dgst_size = DGST_SIZE_4_8;
10188 parse_func = ms_drsr_parse_hash;
10189 sort_by_digest = sort_by_digest_4_8;
10190 opti_type = OPTI_TYPE_ZERO_BYTE;
10191 dgst_pos0 = 0;
10192 dgst_pos1 = 1;
10193 dgst_pos2 = 2;
10194 dgst_pos3 = 3;
10195 break;
10196
10197 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10198 salt_type = SALT_TYPE_EMBEDDED;
10199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10201 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10202 dgst_size = DGST_SIZE_4_8;
10203 parse_func = androidfde_samsung_parse_hash;
10204 sort_by_digest = sort_by_digest_4_8;
10205 opti_type = OPTI_TYPE_ZERO_BYTE;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10216 kern_type = KERN_TYPE_RAR5;
10217 dgst_size = DGST_SIZE_4_4;
10218 parse_func = rar5_parse_hash;
10219 sort_by_digest = sort_by_digest_4_4;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_KRB5TGS;
10232 dgst_size = DGST_SIZE_4_4;
10233 parse_func = krb5tgs_parse_hash;
10234 sort_by_digest = sort_by_digest_4_4;
10235 opti_type = OPTI_TYPE_ZERO_BYTE
10236 | OPTI_TYPE_NOT_ITERATED;
10237 dgst_pos0 = 0;
10238 dgst_pos1 = 1;
10239 dgst_pos2 = 2;
10240 dgst_pos3 = 3;
10241 break;
10242
10243 case 13200: hash_type = HASH_TYPE_AES;
10244 salt_type = SALT_TYPE_EMBEDDED;
10245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10247 kern_type = KERN_TYPE_AXCRYPT;
10248 dgst_size = DGST_SIZE_4_4;
10249 parse_func = axcrypt_parse_hash;
10250 sort_by_digest = sort_by_digest_4_4;
10251 opti_type = OPTI_TYPE_ZERO_BYTE;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 13300: hash_type = HASH_TYPE_SHA1;
10259 salt_type = SALT_TYPE_NONE;
10260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_BE
10262 | OPTS_TYPE_PT_ADD80
10263 | OPTS_TYPE_PT_ADDBITS15;
10264 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10265 dgst_size = DGST_SIZE_4_5;
10266 parse_func = sha1axcrypt_parse_hash;
10267 sort_by_digest = sort_by_digest_4_5;
10268 opti_type = OPTI_TYPE_ZERO_BYTE
10269 | OPTI_TYPE_PRECOMPUTE_INIT
10270 | OPTI_TYPE_EARLY_SKIP
10271 | OPTI_TYPE_NOT_ITERATED
10272 | OPTI_TYPE_NOT_SALTED;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 4;
10275 dgst_pos2 = 3;
10276 dgst_pos3 = 2;
10277 break;
10278
10279 case 13400: hash_type = HASH_TYPE_AES;
10280 salt_type = SALT_TYPE_EMBEDDED;
10281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10283 kern_type = KERN_TYPE_KEEPASS;
10284 dgst_size = DGST_SIZE_4_4;
10285 parse_func = keepass_parse_hash;
10286 sort_by_digest = sort_by_digest_4_4;
10287 opti_type = OPTI_TYPE_ZERO_BYTE;
10288 dgst_pos0 = 0;
10289 dgst_pos1 = 1;
10290 dgst_pos2 = 2;
10291 dgst_pos3 = 3;
10292 break;
10293
10294 case 13500: hash_type = HASH_TYPE_SHA1;
10295 salt_type = SALT_TYPE_EMBEDDED;
10296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10297 opts_type = OPTS_TYPE_PT_GENERATE_BE
10298 | OPTS_TYPE_PT_UNICODE
10299 | OPTS_TYPE_PT_ADD80;
10300 kern_type = KERN_TYPE_PSTOKEN;
10301 dgst_size = DGST_SIZE_4_5;
10302 parse_func = pstoken_parse_hash;
10303 sort_by_digest = sort_by_digest_4_5;
10304 opti_type = OPTI_TYPE_ZERO_BYTE
10305 | OPTI_TYPE_PRECOMPUTE_INIT
10306 | OPTI_TYPE_EARLY_SKIP
10307 | OPTI_TYPE_NOT_ITERATED
10308 | OPTI_TYPE_PREPENDED_SALT
10309 | OPTI_TYPE_RAW_HASH;
10310 dgst_pos0 = 3;
10311 dgst_pos1 = 4;
10312 dgst_pos2 = 2;
10313 dgst_pos3 = 1;
10314 break;
10315
10316 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10317 salt_type = SALT_TYPE_EMBEDDED;
10318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10319 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10320 kern_type = KERN_TYPE_ZIP2;
10321 dgst_size = DGST_SIZE_4_4;
10322 parse_func = zip2_parse_hash;
10323 sort_by_digest = sort_by_digest_4_4;
10324 opti_type = OPTI_TYPE_ZERO_BYTE;
10325 dgst_pos0 = 0;
10326 dgst_pos1 = 1;
10327 dgst_pos2 = 2;
10328 dgst_pos3 = 3;
10329 break;
10330
10331 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10332 salt_type = SALT_TYPE_EMBEDDED;
10333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10335 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10336 dgst_size = DGST_SIZE_4_5;
10337 parse_func = veracrypt_parse_hash_655331;
10338 sort_by_digest = sort_by_digest_4_5;
10339 opti_type = OPTI_TYPE_ZERO_BYTE;
10340 dgst_pos0 = 0;
10341 dgst_pos1 = 1;
10342 dgst_pos2 = 2;
10343 dgst_pos3 = 3;
10344 break;
10345
10346 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10347 salt_type = SALT_TYPE_EMBEDDED;
10348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10350 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10351 dgst_size = DGST_SIZE_4_5;
10352 parse_func = veracrypt_parse_hash_655331;
10353 sort_by_digest = sort_by_digest_4_5;
10354 opti_type = OPTI_TYPE_ZERO_BYTE;
10355 dgst_pos0 = 0;
10356 dgst_pos1 = 1;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 3;
10359 break;
10360
10361 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10366 dgst_size = DGST_SIZE_4_5;
10367 parse_func = veracrypt_parse_hash_655331;
10368 sort_by_digest = sort_by_digest_4_5;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 13721: hash_type = HASH_TYPE_SHA512;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10380 kern_type = KERN_TYPE_TCSHA512_XTS512;
10381 dgst_size = DGST_SIZE_8_8;
10382 parse_func = veracrypt_parse_hash_500000;
10383 sort_by_digest = sort_by_digest_8_8;
10384 opti_type = OPTI_TYPE_ZERO_BYTE
10385 | OPTI_TYPE_USES_BITS_64;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 13722: hash_type = HASH_TYPE_SHA512;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10396 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10397 dgst_size = DGST_SIZE_8_8;
10398 parse_func = veracrypt_parse_hash_500000;
10399 sort_by_digest = sort_by_digest_8_8;
10400 opti_type = OPTI_TYPE_ZERO_BYTE
10401 | OPTI_TYPE_USES_BITS_64;
10402 dgst_pos0 = 0;
10403 dgst_pos1 = 1;
10404 dgst_pos2 = 2;
10405 dgst_pos3 = 3;
10406 break;
10407
10408 case 13723: hash_type = HASH_TYPE_SHA512;
10409 salt_type = SALT_TYPE_EMBEDDED;
10410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10411 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10412 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10413 dgst_size = DGST_SIZE_8_8;
10414 parse_func = veracrypt_parse_hash_500000;
10415 sort_by_digest = sort_by_digest_8_8;
10416 opti_type = OPTI_TYPE_ZERO_BYTE
10417 | OPTI_TYPE_USES_BITS_64;
10418 dgst_pos0 = 0;
10419 dgst_pos1 = 1;
10420 dgst_pos2 = 2;
10421 dgst_pos3 = 3;
10422 break;
10423
10424 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10425 salt_type = SALT_TYPE_EMBEDDED;
10426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10428 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10429 dgst_size = DGST_SIZE_4_8;
10430 parse_func = veracrypt_parse_hash_500000;
10431 sort_by_digest = sort_by_digest_4_8;
10432 opti_type = OPTI_TYPE_ZERO_BYTE;
10433 dgst_pos0 = 0;
10434 dgst_pos1 = 1;
10435 dgst_pos2 = 2;
10436 dgst_pos3 = 3;
10437 break;
10438
10439 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10440 salt_type = SALT_TYPE_EMBEDDED;
10441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10443 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10444 dgst_size = DGST_SIZE_4_8;
10445 parse_func = veracrypt_parse_hash_500000;
10446 sort_by_digest = sort_by_digest_4_8;
10447 opti_type = OPTI_TYPE_ZERO_BYTE;
10448 dgst_pos0 = 0;
10449 dgst_pos1 = 1;
10450 dgst_pos2 = 2;
10451 dgst_pos3 = 3;
10452 break;
10453
10454 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10455 salt_type = SALT_TYPE_EMBEDDED;
10456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10458 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10459 dgst_size = DGST_SIZE_4_8;
10460 parse_func = veracrypt_parse_hash_500000;
10461 sort_by_digest = sort_by_digest_4_8;
10462 opti_type = OPTI_TYPE_ZERO_BYTE;
10463 dgst_pos0 = 0;
10464 dgst_pos1 = 1;
10465 dgst_pos2 = 2;
10466 dgst_pos3 = 3;
10467 break;
10468
10469 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10470 salt_type = SALT_TYPE_EMBEDDED;
10471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10473 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10474 dgst_size = DGST_SIZE_4_5;
10475 parse_func = veracrypt_parse_hash_327661;
10476 sort_by_digest = sort_by_digest_4_5;
10477 opti_type = OPTI_TYPE_ZERO_BYTE;
10478 dgst_pos0 = 0;
10479 dgst_pos1 = 1;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 3;
10482 break;
10483
10484 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10488 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10489 dgst_size = DGST_SIZE_4_5;
10490 parse_func = veracrypt_parse_hash_327661;
10491 sort_by_digest = sort_by_digest_4_5;
10492 opti_type = OPTI_TYPE_ZERO_BYTE;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 1;
10495 dgst_pos2 = 2;
10496 dgst_pos3 = 3;
10497 break;
10498
10499 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10504 dgst_size = DGST_SIZE_4_5;
10505 parse_func = veracrypt_parse_hash_327661;
10506 sort_by_digest = sort_by_digest_4_5;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13751: hash_type = HASH_TYPE_SHA256;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10518 kern_type = KERN_TYPE_VCSHA256_XTS512;
10519 dgst_size = DGST_SIZE_4_8;
10520 parse_func = veracrypt_parse_hash_500000;
10521 sort_by_digest = sort_by_digest_4_8;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13752: hash_type = HASH_TYPE_SHA256;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10533 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10534 dgst_size = DGST_SIZE_4_8;
10535 parse_func = veracrypt_parse_hash_500000;
10536 sort_by_digest = sort_by_digest_4_8;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13753: hash_type = HASH_TYPE_SHA256;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10548 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10549 dgst_size = DGST_SIZE_4_8;
10550 parse_func = veracrypt_parse_hash_500000;
10551 sort_by_digest = sort_by_digest_4_8;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13761: hash_type = HASH_TYPE_SHA256;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10563 kern_type = KERN_TYPE_VCSHA256_XTS512;
10564 dgst_size = DGST_SIZE_4_8;
10565 parse_func = veracrypt_parse_hash_200000;
10566 sort_by_digest = sort_by_digest_4_8;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13762: hash_type = HASH_TYPE_SHA256;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10579 dgst_size = DGST_SIZE_4_8;
10580 parse_func = veracrypt_parse_hash_200000;
10581 sort_by_digest = sort_by_digest_4_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13763: hash_type = HASH_TYPE_SHA256;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10593 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10594 dgst_size = DGST_SIZE_4_8;
10595 parse_func = veracrypt_parse_hash_200000;
10596 sort_by_digest = sort_by_digest_4_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604
10605 default: usage_mini_print (PROGNAME); return (-1);
10606 }
10607
10608 /**
10609 * parser
10610 */
10611
10612 data.parse_func = parse_func;
10613
10614 /**
10615 * misc stuff
10616 */
10617
10618 if (hex_salt)
10619 {
10620 if (salt_type == SALT_TYPE_INTERN)
10621 {
10622 opts_type |= OPTS_TYPE_ST_HEX;
10623 }
10624 else
10625 {
10626 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10627
10628 return (-1);
10629 }
10630 }
10631
10632 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10633 | (salt_type == SALT_TYPE_EXTERN)
10634 | (salt_type == SALT_TYPE_EMBEDDED)
10635 | (salt_type == SALT_TYPE_VIRTUAL));
10636
10637 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10638
10639 data.hash_type = hash_type;
10640 data.attack_mode = attack_mode;
10641 data.attack_kern = attack_kern;
10642 data.attack_exec = attack_exec;
10643 data.kern_type = kern_type;
10644 data.opts_type = opts_type;
10645 data.dgst_size = dgst_size;
10646 data.salt_type = salt_type;
10647 data.isSalted = isSalted;
10648 data.sort_by_digest = sort_by_digest;
10649 data.dgst_pos0 = dgst_pos0;
10650 data.dgst_pos1 = dgst_pos1;
10651 data.dgst_pos2 = dgst_pos2;
10652 data.dgst_pos3 = dgst_pos3;
10653
10654 esalt_size = 0;
10655
10656 switch (hash_mode)
10657 {
10658 case 2500: esalt_size = sizeof (wpa_t); break;
10659 case 5300: esalt_size = sizeof (ikepsk_t); break;
10660 case 5400: esalt_size = sizeof (ikepsk_t); break;
10661 case 5500: esalt_size = sizeof (netntlm_t); break;
10662 case 5600: esalt_size = sizeof (netntlm_t); break;
10663 case 6211: esalt_size = sizeof (tc_t); break;
10664 case 6212: esalt_size = sizeof (tc_t); break;
10665 case 6213: esalt_size = sizeof (tc_t); break;
10666 case 6221: esalt_size = sizeof (tc_t); break;
10667 case 6222: esalt_size = sizeof (tc_t); break;
10668 case 6223: esalt_size = sizeof (tc_t); break;
10669 case 6231: esalt_size = sizeof (tc_t); break;
10670 case 6232: esalt_size = sizeof (tc_t); break;
10671 case 6233: esalt_size = sizeof (tc_t); break;
10672 case 6241: esalt_size = sizeof (tc_t); break;
10673 case 6242: esalt_size = sizeof (tc_t); break;
10674 case 6243: esalt_size = sizeof (tc_t); break;
10675 case 6600: esalt_size = sizeof (agilekey_t); break;
10676 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10677 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10678 case 7300: esalt_size = sizeof (rakp_t); break;
10679 case 7500: esalt_size = sizeof (krb5pa_t); break;
10680 case 8200: esalt_size = sizeof (cloudkey_t); break;
10681 case 8800: esalt_size = sizeof (androidfde_t); break;
10682 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10683 case 9400: esalt_size = sizeof (office2007_t); break;
10684 case 9500: esalt_size = sizeof (office2010_t); break;
10685 case 9600: esalt_size = sizeof (office2013_t); break;
10686 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10687 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10688 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10689 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10690 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10691 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10692 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10693 case 10200: esalt_size = sizeof (cram_md5_t); break;
10694 case 10400: esalt_size = sizeof (pdf_t); break;
10695 case 10410: esalt_size = sizeof (pdf_t); break;
10696 case 10420: esalt_size = sizeof (pdf_t); break;
10697 case 10500: esalt_size = sizeof (pdf_t); break;
10698 case 10600: esalt_size = sizeof (pdf_t); break;
10699 case 10700: esalt_size = sizeof (pdf_t); break;
10700 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10701 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10702 case 11400: esalt_size = sizeof (sip_t); break;
10703 case 11600: esalt_size = sizeof (seven_zip_t); break;
10704 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10705 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10706 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10707 case 13000: esalt_size = sizeof (rar5_t); break;
10708 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10709 case 13400: esalt_size = sizeof (keepass_t); break;
10710 case 13500: esalt_size = sizeof (pstoken_t); break;
10711 case 13600: esalt_size = sizeof (zip2_t); break;
10712 case 13711: esalt_size = sizeof (tc_t); break;
10713 case 13712: esalt_size = sizeof (tc_t); break;
10714 case 13713: esalt_size = sizeof (tc_t); break;
10715 case 13721: esalt_size = sizeof (tc_t); break;
10716 case 13722: esalt_size = sizeof (tc_t); break;
10717 case 13723: esalt_size = sizeof (tc_t); break;
10718 case 13731: esalt_size = sizeof (tc_t); break;
10719 case 13732: esalt_size = sizeof (tc_t); break;
10720 case 13733: esalt_size = sizeof (tc_t); break;
10721 case 13741: esalt_size = sizeof (tc_t); break;
10722 case 13742: esalt_size = sizeof (tc_t); break;
10723 case 13743: esalt_size = sizeof (tc_t); break;
10724 case 13751: esalt_size = sizeof (tc_t); break;
10725 case 13752: esalt_size = sizeof (tc_t); break;
10726 case 13753: esalt_size = sizeof (tc_t); break;
10727 case 13761: esalt_size = sizeof (tc_t); break;
10728 case 13762: esalt_size = sizeof (tc_t); break;
10729 case 13763: esalt_size = sizeof (tc_t); break;
10730 }
10731
10732 data.esalt_size = esalt_size;
10733
10734 /**
10735 * choose dictionary parser
10736 */
10737
10738 if (hash_type == HASH_TYPE_LM)
10739 {
10740 get_next_word_func = get_next_word_lm;
10741 }
10742 else if (opts_type & OPTS_TYPE_PT_UPPER)
10743 {
10744 get_next_word_func = get_next_word_uc;
10745 }
10746 else
10747 {
10748 get_next_word_func = get_next_word_std;
10749 }
10750
10751 /**
10752 * dictstat
10753 */
10754
10755 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10756
10757 #ifdef _POSIX
10758 size_t dictstat_nmemb = 0;
10759 #endif
10760
10761 #ifdef _WIN
10762 uint dictstat_nmemb = 0;
10763 #endif
10764
10765 char dictstat[256] = { 0 };
10766
10767 FILE *dictstat_fp = NULL;
10768
10769 if (keyspace == 0)
10770 {
10771 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10772
10773 dictstat_fp = fopen (dictstat, "rb");
10774
10775 if (dictstat_fp)
10776 {
10777 #ifdef _POSIX
10778 struct stat tmpstat;
10779
10780 fstat (fileno (dictstat_fp), &tmpstat);
10781 #endif
10782
10783 #ifdef _WIN
10784 struct stat64 tmpstat;
10785
10786 _fstat64 (fileno (dictstat_fp), &tmpstat);
10787 #endif
10788
10789 if (tmpstat.st_mtime < COMPTIME)
10790 {
10791 /* with v0.15 the format changed so we have to ensure user is using a good version
10792 since there is no version-header in the dictstat file */
10793
10794 fclose (dictstat_fp);
10795
10796 unlink (dictstat);
10797 }
10798 else
10799 {
10800 while (!feof (dictstat_fp))
10801 {
10802 dictstat_t d;
10803
10804 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10805
10806 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10807
10808 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10809 {
10810 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10811
10812 return -1;
10813 }
10814 }
10815
10816 fclose (dictstat_fp);
10817 }
10818 }
10819 }
10820
10821 /**
10822 * potfile
10823 */
10824
10825 char potfile[256] = { 0 };
10826
10827 if (potfile_path == NULL)
10828 {
10829 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10830 }
10831 else
10832 {
10833 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10834 }
10835
10836 data.pot_fp = NULL;
10837
10838 FILE *out_fp = NULL;
10839 FILE *pot_fp = NULL;
10840
10841 if (show == 1 || left == 1)
10842 {
10843 pot_fp = fopen (potfile, "rb");
10844
10845 if (pot_fp == NULL)
10846 {
10847 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10848
10849 return (-1);
10850 }
10851
10852 if (outfile != NULL)
10853 {
10854 if ((out_fp = fopen (outfile, "ab")) == NULL)
10855 {
10856 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10857
10858 fclose (pot_fp);
10859
10860 return (-1);
10861 }
10862 }
10863 else
10864 {
10865 out_fp = stdout;
10866 }
10867 }
10868 else
10869 {
10870 if (potfile_disable == 0)
10871 {
10872 pot_fp = fopen (potfile, "ab");
10873
10874 if (pot_fp == NULL)
10875 {
10876 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10877
10878 return (-1);
10879 }
10880
10881 data.pot_fp = pot_fp;
10882 }
10883 }
10884
10885 pot_t *pot = NULL;
10886
10887 uint pot_cnt = 0;
10888 uint pot_avail = 0;
10889
10890 if (show == 1 || left == 1)
10891 {
10892 SUPPRESS_OUTPUT = 1;
10893
10894 pot_avail = count_lines (pot_fp);
10895
10896 rewind (pot_fp);
10897
10898 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10899
10900 uint pot_hashes_avail = 0;
10901
10902 uint line_num = 0;
10903
10904 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10905
10906 while (!feof (pot_fp))
10907 {
10908 line_num++;
10909
10910 int line_len = fgetl (pot_fp, line_buf);
10911
10912 if (line_len == 0) continue;
10913
10914 char *plain_buf = line_buf + line_len;
10915
10916 pot_t *pot_ptr = &pot[pot_cnt];
10917
10918 hash_t *hashes_buf = &pot_ptr->hash;
10919
10920 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10921 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10922
10923 if (pot_cnt == pot_hashes_avail)
10924 {
10925 uint pos = 0;
10926
10927 for (pos = 0; pos < INCR_POT; pos++)
10928 {
10929 if ((pot_cnt + pos) >= pot_avail) break;
10930
10931 pot_t *tmp_pot = &pot[pot_cnt + pos];
10932
10933 hash_t *tmp_hash = &tmp_pot->hash;
10934
10935 tmp_hash->digest = mymalloc (dgst_size);
10936
10937 if (isSalted)
10938 {
10939 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10940 }
10941
10942 if (esalt_size)
10943 {
10944 tmp_hash->esalt = mymalloc (esalt_size);
10945 }
10946
10947 pot_hashes_avail++;
10948 }
10949 }
10950
10951 int plain_len = 0;
10952
10953 int parser_status;
10954
10955 int iter = MAX_CUT_TRIES;
10956
10957 do
10958 {
10959 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10960 {
10961 if (line_buf[i] == ':')
10962 {
10963 line_len--;
10964
10965 break;
10966 }
10967 }
10968
10969 if (data.hash_mode != 2500)
10970 {
10971 parser_status = parse_func (line_buf, line_len, hashes_buf);
10972 }
10973 else
10974 {
10975 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10976
10977 if (line_len > max_salt_size)
10978 {
10979 parser_status = PARSER_GLOBAL_LENGTH;
10980 }
10981 else
10982 {
10983 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10984
10985 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10986
10987 hashes_buf->salt->salt_len = line_len;
10988
10989 parser_status = PARSER_OK;
10990 }
10991 }
10992
10993 // if NOT parsed without error, we add the ":" to the plain
10994
10995 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10996 {
10997 plain_len++;
10998 plain_buf--;
10999 }
11000
11001 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11002
11003 if (parser_status < PARSER_GLOBAL_ZERO)
11004 {
11005 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11006
11007 continue;
11008 }
11009
11010 if (plain_len >= 255) continue;
11011
11012 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11013
11014 pot_ptr->plain_len = plain_len;
11015
11016 pot_cnt++;
11017 }
11018
11019 myfree (line_buf);
11020
11021 fclose (pot_fp);
11022
11023 SUPPRESS_OUTPUT = 0;
11024
11025 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11026 }
11027
11028 /**
11029 * word len
11030 */
11031
11032 uint pw_min = PW_MIN;
11033 uint pw_max = PW_MAX;
11034
11035 switch (hash_mode)
11036 {
11037 case 125: if (pw_max > 32) pw_max = 32;
11038 break;
11039 case 400: if (pw_max > 40) pw_max = 40;
11040 break;
11041 case 500: if (pw_max > 16) pw_max = 16;
11042 break;
11043 case 1500: if (pw_max > 8) pw_max = 8;
11044 break;
11045 case 1600: if (pw_max > 16) pw_max = 16;
11046 break;
11047 case 1800: if (pw_max > 16) pw_max = 16;
11048 break;
11049 case 2100: if (pw_max > 16) pw_max = 16;
11050 break;
11051 case 2500: if (pw_min < 8) pw_min = 8;
11052 break;
11053 case 3000: if (pw_max > 7) pw_max = 7;
11054 break;
11055 case 5200: if (pw_max > 24) pw_max = 24;
11056 break;
11057 case 5800: if (pw_max > 16) pw_max = 16;
11058 break;
11059 case 6300: if (pw_max > 16) pw_max = 16;
11060 break;
11061 case 7400: if (pw_max > 16) pw_max = 16;
11062 break;
11063 case 7900: if (pw_max > 48) pw_max = 48;
11064 break;
11065 case 8500: if (pw_max > 8) pw_max = 8;
11066 break;
11067 case 8600: if (pw_max > 16) pw_max = 16;
11068 break;
11069 case 9710: pw_min = 5;
11070 pw_max = 5;
11071 break;
11072 case 9810: pw_min = 5;
11073 pw_max = 5;
11074 break;
11075 case 10410: pw_min = 5;
11076 pw_max = 5;
11077 break;
11078 case 10300: if (pw_max < 3) pw_min = 3;
11079 if (pw_max > 40) pw_max = 40;
11080 break;
11081 case 10500: if (pw_max < 3) pw_min = 3;
11082 if (pw_max > 40) pw_max = 40;
11083 break;
11084 case 10700: if (pw_max > 16) pw_max = 16;
11085 break;
11086 case 11300: if (pw_max > 40) pw_max = 40;
11087 break;
11088 case 11600: if (pw_max > 32) pw_max = 32;
11089 break;
11090 case 12500: if (pw_max > 20) pw_max = 20;
11091 break;
11092 case 12800: if (pw_max > 24) pw_max = 24;
11093 break;
11094 }
11095
11096 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11097 {
11098 switch (attack_kern)
11099 {
11100 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11101 break;
11102 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11103 break;
11104 }
11105 }
11106
11107 /**
11108 * charsets : keep them together for more easy maintainnce
11109 */
11110
11111 cs_t mp_sys[6] = { { { 0 }, 0 } };
11112 cs_t mp_usr[4] = { { { 0 }, 0 } };
11113
11114 mp_setup_sys (mp_sys);
11115
11116 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11117 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11118 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11119 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11120
11121 /**
11122 * load hashes, part I: find input mode, count hashes
11123 */
11124
11125 uint hashlist_mode = 0;
11126 uint hashlist_format = HLFMT_HASHCAT;
11127
11128 uint hashes_avail = 0;
11129
11130 if (benchmark == 0)
11131 {
11132 struct stat f;
11133
11134 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11135
11136 if ((hash_mode == 2500) ||
11137 (hash_mode == 5200) ||
11138 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11139 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11140 (hash_mode == 9000))
11141 {
11142 hashlist_mode = HL_MODE_ARG;
11143
11144 char *hashfile = myargv[optind];
11145
11146 data.hashfile = hashfile;
11147
11148 logfile_top_var_string ("target", hashfile);
11149 }
11150
11151 if (hashlist_mode == HL_MODE_ARG)
11152 {
11153 if (hash_mode == 2500)
11154 {
11155 struct stat st;
11156
11157 if (stat (data.hashfile, &st) == -1)
11158 {
11159 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11160
11161 return (-1);
11162 }
11163
11164 hashes_avail = st.st_size / sizeof (hccap_t);
11165 }
11166 else
11167 {
11168 hashes_avail = 1;
11169 }
11170 }
11171 else if (hashlist_mode == HL_MODE_FILE)
11172 {
11173 char *hashfile = myargv[optind];
11174
11175 data.hashfile = hashfile;
11176
11177 logfile_top_var_string ("target", hashfile);
11178
11179 FILE *fp = NULL;
11180
11181 if ((fp = fopen (hashfile, "rb")) == NULL)
11182 {
11183 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11184
11185 return (-1);
11186 }
11187
11188 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11189
11190 hashes_avail = count_lines (fp);
11191
11192 rewind (fp);
11193
11194 if (hashes_avail == 0)
11195 {
11196 log_error ("ERROR: hashfile is empty or corrupt");
11197
11198 fclose (fp);
11199
11200 return (-1);
11201 }
11202
11203 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11204
11205 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11206 {
11207 log_error ("ERROR: remove not supported in native hashfile-format mode");
11208
11209 fclose (fp);
11210
11211 return (-1);
11212 }
11213
11214 fclose (fp);
11215 }
11216 }
11217 else
11218 {
11219 hashlist_mode = HL_MODE_ARG;
11220
11221 hashes_avail = 1;
11222 }
11223
11224 if (hash_mode == 3000) hashes_avail *= 2;
11225
11226 data.hashlist_mode = hashlist_mode;
11227 data.hashlist_format = hashlist_format;
11228
11229 logfile_top_uint (hashlist_mode);
11230 logfile_top_uint (hashlist_format);
11231
11232 /**
11233 * load hashes, part II: allocate required memory, set pointers
11234 */
11235
11236 hash_t *hashes_buf = NULL;
11237 void *digests_buf = NULL;
11238 salt_t *salts_buf = NULL;
11239 void *esalts_buf = NULL;
11240
11241 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11242
11243 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11244
11245 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11246 {
11247 u32 hash_pos;
11248
11249 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11250 {
11251 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11252
11253 hashes_buf[hash_pos].hash_info = hash_info;
11254
11255 if (username && (remove || show || left))
11256 {
11257 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11258 }
11259
11260 if (benchmark)
11261 {
11262 hash_info->orighash = (char *) mymalloc (256);
11263 }
11264 }
11265 }
11266
11267 if (isSalted)
11268 {
11269 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11270
11271 if (esalt_size)
11272 {
11273 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11274 }
11275 }
11276 else
11277 {
11278 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11279 }
11280
11281 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11282 {
11283 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11284
11285 if (isSalted)
11286 {
11287 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11288
11289 if (esalt_size)
11290 {
11291 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11292 }
11293 }
11294 else
11295 {
11296 hashes_buf[hash_pos].salt = &salts_buf[0];
11297 }
11298 }
11299
11300 /**
11301 * load hashes, part III: parse hashes or generate them if benchmark
11302 */
11303
11304 uint hashes_cnt = 0;
11305
11306 if (benchmark == 0)
11307 {
11308 if (keyspace == 1)
11309 {
11310 // useless to read hash file for keyspace, cheat a little bit w/ optind
11311 }
11312 else if (hashes_avail == 0)
11313 {
11314 }
11315 else if (hashlist_mode == HL_MODE_ARG)
11316 {
11317 char *input_buf = myargv[optind];
11318
11319 uint input_len = strlen (input_buf);
11320
11321 logfile_top_var_string ("target", input_buf);
11322
11323 char *hash_buf = NULL;
11324 int hash_len = 0;
11325
11326 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11327
11328 bool hash_fmt_error = 0;
11329
11330 if (hash_len < 1) hash_fmt_error = 1;
11331 if (hash_buf == NULL) hash_fmt_error = 1;
11332
11333 if (hash_fmt_error)
11334 {
11335 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11336 }
11337 else
11338 {
11339 if (opts_type & OPTS_TYPE_HASH_COPY)
11340 {
11341 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11342
11343 hash_info_tmp->orighash = mystrdup (hash_buf);
11344 }
11345
11346 if (isSalted)
11347 {
11348 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11349 }
11350
11351 int parser_status = PARSER_OK;
11352
11353 if (hash_mode == 2500)
11354 {
11355 if (hash_len == 0)
11356 {
11357 log_error ("ERROR: hccap file not specified");
11358
11359 return (-1);
11360 }
11361
11362 hashlist_mode = HL_MODE_FILE;
11363
11364 data.hashlist_mode = hashlist_mode;
11365
11366 FILE *fp = fopen (hash_buf, "rb");
11367
11368 if (fp == NULL)
11369 {
11370 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11371
11372 return (-1);
11373 }
11374
11375 if (hashes_avail < 1)
11376 {
11377 log_error ("ERROR: hccap file is empty or corrupt");
11378
11379 fclose (fp);
11380
11381 return (-1);
11382 }
11383
11384 uint hccap_size = sizeof (hccap_t);
11385
11386 char *in = (char *) mymalloc (hccap_size);
11387
11388 while (!feof (fp))
11389 {
11390 int n = fread (in, hccap_size, 1, fp);
11391
11392 if (n != 1)
11393 {
11394 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11395
11396 break;
11397 }
11398
11399 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11400
11401 if (parser_status != PARSER_OK)
11402 {
11403 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11404
11405 continue;
11406 }
11407
11408 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11409
11410 if ((show == 1) || (left == 1))
11411 {
11412 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11413
11414 char *salt_ptr = (char *) tmp_salt->salt_buf;
11415
11416 int cur_pos = tmp_salt->salt_len;
11417 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11418
11419 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11420
11421 // do the appending task
11422
11423 snprintf (salt_ptr + cur_pos,
11424 rem_len,
11425 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11426 wpa->orig_mac1[0],
11427 wpa->orig_mac1[1],
11428 wpa->orig_mac1[2],
11429 wpa->orig_mac1[3],
11430 wpa->orig_mac1[4],
11431 wpa->orig_mac1[5],
11432 wpa->orig_mac2[0],
11433 wpa->orig_mac2[1],
11434 wpa->orig_mac2[2],
11435 wpa->orig_mac2[3],
11436 wpa->orig_mac2[4],
11437 wpa->orig_mac2[5]);
11438
11439 // memset () the remaining part of the salt
11440
11441 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11442 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11443
11444 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11445
11446 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11447 }
11448
11449 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);
11450 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);
11451
11452 hashes_cnt++;
11453 }
11454
11455 fclose (fp);
11456
11457 myfree (in);
11458 }
11459 else if (hash_mode == 3000)
11460 {
11461 if (hash_len == 32)
11462 {
11463 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11464
11465 hash_t *lm_hash_left = NULL;
11466
11467 if (parser_status == PARSER_OK)
11468 {
11469 lm_hash_left = &hashes_buf[hashes_cnt];
11470
11471 hashes_cnt++;
11472 }
11473 else
11474 {
11475 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11476 }
11477
11478 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11479
11480 hash_t *lm_hash_right = NULL;
11481
11482 if (parser_status == PARSER_OK)
11483 {
11484 lm_hash_right = &hashes_buf[hashes_cnt];
11485
11486 hashes_cnt++;
11487 }
11488 else
11489 {
11490 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11491 }
11492
11493 // show / left
11494
11495 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11496 {
11497 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);
11498 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);
11499 }
11500 }
11501 else
11502 {
11503 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11504
11505 if (parser_status == PARSER_OK)
11506 {
11507 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11508 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11509 }
11510
11511 if (parser_status == PARSER_OK)
11512 {
11513 hashes_cnt++;
11514 }
11515 else
11516 {
11517 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11518 }
11519 }
11520 }
11521 else
11522 {
11523 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11524
11525 if (parser_status == PARSER_OK)
11526 {
11527 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11528 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11529 }
11530
11531 if (parser_status == PARSER_OK)
11532 {
11533 hashes_cnt++;
11534 }
11535 else
11536 {
11537 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11538 }
11539 }
11540 }
11541 }
11542 else if (hashlist_mode == HL_MODE_FILE)
11543 {
11544 char *hashfile = data.hashfile;
11545
11546 FILE *fp;
11547
11548 if ((fp = fopen (hashfile, "rb")) == NULL)
11549 {
11550 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11551
11552 return (-1);
11553 }
11554
11555 uint line_num = 0;
11556
11557 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11558
11559 while (!feof (fp))
11560 {
11561 line_num++;
11562
11563 int line_len = fgetl (fp, line_buf);
11564
11565 if (line_len == 0) continue;
11566
11567 char *hash_buf = NULL;
11568 int hash_len = 0;
11569
11570 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11571
11572 bool hash_fmt_error = 0;
11573
11574 if (hash_len < 1) hash_fmt_error = 1;
11575 if (hash_buf == NULL) hash_fmt_error = 1;
11576
11577 if (hash_fmt_error)
11578 {
11579 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11580
11581 continue;
11582 }
11583
11584 if (username)
11585 {
11586 char *user_buf = NULL;
11587 int user_len = 0;
11588
11589 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11590
11591 if (remove || show)
11592 {
11593 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11594
11595 *user = (user_t *) mymalloc (sizeof (user_t));
11596
11597 user_t *user_ptr = *user;
11598
11599 if (user_buf != NULL)
11600 {
11601 user_ptr->user_name = mystrdup (user_buf);
11602 }
11603 else
11604 {
11605 user_ptr->user_name = mystrdup ("");
11606 }
11607
11608 user_ptr->user_len = user_len;
11609 }
11610 }
11611
11612 if (opts_type & OPTS_TYPE_HASH_COPY)
11613 {
11614 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11615
11616 hash_info_tmp->orighash = mystrdup (hash_buf);
11617 }
11618
11619 if (isSalted)
11620 {
11621 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11622 }
11623
11624 if (hash_mode == 3000)
11625 {
11626 if (hash_len == 32)
11627 {
11628 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11629
11630 if (parser_status < PARSER_GLOBAL_ZERO)
11631 {
11632 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11633
11634 continue;
11635 }
11636
11637 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11638
11639 hashes_cnt++;
11640
11641 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11642
11643 if (parser_status < PARSER_GLOBAL_ZERO)
11644 {
11645 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11646
11647 continue;
11648 }
11649
11650 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11651
11652 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);
11653
11654 hashes_cnt++;
11655
11656 // show / left
11657
11658 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);
11659 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);
11660 }
11661 else
11662 {
11663 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11664
11665 if (parser_status < PARSER_GLOBAL_ZERO)
11666 {
11667 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11668
11669 continue;
11670 }
11671
11672 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);
11673
11674 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11675 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11676
11677 hashes_cnt++;
11678 }
11679 }
11680 else
11681 {
11682 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11683
11684 if (parser_status < PARSER_GLOBAL_ZERO)
11685 {
11686 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11687
11688 continue;
11689 }
11690
11691 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);
11692
11693 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11694 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11695
11696 hashes_cnt++;
11697 }
11698 }
11699
11700 myfree (line_buf);
11701
11702 fclose (fp);
11703
11704 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11705
11706 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11707 }
11708 }
11709 else
11710 {
11711 if (isSalted)
11712 {
11713 hashes_buf[0].salt->salt_len = 8;
11714
11715 // special salt handling
11716
11717 switch (hash_mode)
11718 {
11719 case 1500: hashes_buf[0].salt->salt_len = 2;
11720 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11721 break;
11722 case 1731: hashes_buf[0].salt->salt_len = 4;
11723 break;
11724 case 2410: hashes_buf[0].salt->salt_len = 4;
11725 break;
11726 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11727 break;
11728 case 3100: hashes_buf[0].salt->salt_len = 1;
11729 break;
11730 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11731 break;
11732 case 5800: hashes_buf[0].salt->salt_len = 16;
11733 break;
11734 case 6800: hashes_buf[0].salt->salt_len = 32;
11735 break;
11736 case 8400: hashes_buf[0].salt->salt_len = 40;
11737 break;
11738 case 8800: hashes_buf[0].salt->salt_len = 16;
11739 break;
11740 case 8900: hashes_buf[0].salt->salt_len = 16;
11741 hashes_buf[0].salt->scrypt_N = 1024;
11742 hashes_buf[0].salt->scrypt_r = 1;
11743 hashes_buf[0].salt->scrypt_p = 1;
11744 break;
11745 case 9100: hashes_buf[0].salt->salt_len = 16;
11746 break;
11747 case 9300: hashes_buf[0].salt->salt_len = 14;
11748 hashes_buf[0].salt->scrypt_N = 16384;
11749 hashes_buf[0].salt->scrypt_r = 1;
11750 hashes_buf[0].salt->scrypt_p = 1;
11751 break;
11752 case 9400: hashes_buf[0].salt->salt_len = 16;
11753 break;
11754 case 9500: hashes_buf[0].salt->salt_len = 16;
11755 break;
11756 case 9600: hashes_buf[0].salt->salt_len = 16;
11757 break;
11758 case 9700: hashes_buf[0].salt->salt_len = 16;
11759 break;
11760 case 9710: hashes_buf[0].salt->salt_len = 16;
11761 break;
11762 case 9720: hashes_buf[0].salt->salt_len = 16;
11763 break;
11764 case 9800: hashes_buf[0].salt->salt_len = 16;
11765 break;
11766 case 9810: hashes_buf[0].salt->salt_len = 16;
11767 break;
11768 case 9820: hashes_buf[0].salt->salt_len = 16;
11769 break;
11770 case 10300: hashes_buf[0].salt->salt_len = 12;
11771 break;
11772 case 11500: hashes_buf[0].salt->salt_len = 4;
11773 break;
11774 case 11600: hashes_buf[0].salt->salt_len = 4;
11775 break;
11776 case 12400: hashes_buf[0].salt->salt_len = 4;
11777 break;
11778 case 12500: hashes_buf[0].salt->salt_len = 8;
11779 break;
11780 case 12600: hashes_buf[0].salt->salt_len = 64;
11781 break;
11782 }
11783
11784 // special esalt handling
11785
11786 switch (hash_mode)
11787 {
11788 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11789 break;
11790 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11791 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11792 break;
11793 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11794 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11795 break;
11796 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11797 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11798 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11799 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11800 break;
11801 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11802 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11803 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11804 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11805 break;
11806 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11807 break;
11808 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11809 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11810 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11811 break;
11812 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11813 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11814 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11815 break;
11816 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11817 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11818 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11819 break;
11820 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11821 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11822 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11823 break;
11824 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11825 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11826 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11827 break;
11828 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11829 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11830 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11831 break;
11832 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11833 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11834 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11835 break;
11836 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11837 break;
11838 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11839 break;
11840 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11841 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11842 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11843 break;
11844 }
11845 }
11846
11847 // set hashfile
11848
11849 switch (hash_mode)
11850 {
11851 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11852 break;
11853 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11854 break;
11855 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11856 break;
11857 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11858 break;
11859 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11860 break;
11861 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11862 break;
11863 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11864 break;
11865 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11866 break;
11867 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11868 break;
11869 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11870 break;
11871 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11872 break;
11873 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11874 break;
11875 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11876 break;
11877 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11878 break;
11879 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11880 break;
11881 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11882 break;
11883 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11884 break;
11885 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11886 break;
11887 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11888 break;
11889 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11898 break;
11899 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11900 break;
11901 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11902 break;
11903 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11904 break;
11905 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11906 break;
11907 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11908 break;
11909 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11910 break;
11911 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11912 break;
11913 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11914 break;
11915 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11916 break;
11917 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11918 break;
11919 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11920 break;
11921 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 }
11924
11925 // set default iterations
11926
11927 switch (hash_mode)
11928 {
11929 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11930 break;
11931 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11932 break;
11933 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11934 break;
11935 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11936 break;
11937 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11938 break;
11939 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11940 break;
11941 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11942 break;
11943 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11944 break;
11945 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11946 break;
11947 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11948 break;
11949 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11950 break;
11951 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11952 break;
11953 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11954 break;
11955 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11956 break;
11957 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11958 break;
11959 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11960 break;
11961 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11962 break;
11963 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11964 break;
11965 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11966 break;
11967 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11968 break;
11969 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11970 break;
11971 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11972 break;
11973 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11974 break;
11975 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11976 break;
11977 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11978 break;
11979 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11980 break;
11981 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11982 break;
11983 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11984 break;
11985 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11986 break;
11987 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11988 break;
11989 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11990 break;
11991 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11992 break;
11993 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11994 break;
11995 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11996 break;
11997 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11998 break;
11999 case 8900: hashes_buf[0].salt->salt_iter = 1;
12000 break;
12001 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12002 break;
12003 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12004 break;
12005 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12006 break;
12007 case 9300: hashes_buf[0].salt->salt_iter = 1;
12008 break;
12009 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12010 break;
12011 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12012 break;
12013 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12014 break;
12015 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12016 break;
12017 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12018 break;
12019 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12020 break;
12021 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12022 break;
12023 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12024 break;
12025 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12026 break;
12027 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12028 break;
12029 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12030 break;
12031 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12032 break;
12033 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12034 break;
12035 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12036 break;
12037 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12038 break;
12039 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12040 break;
12041 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12042 break;
12043 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12044 break;
12045 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12046 break;
12047 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12048 break;
12049 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12050 break;
12051 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12052 break;
12053 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12054 break;
12055 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12056 break;
12057 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12058 break;
12059 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12060 break;
12061 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12062 break;
12063 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12064 break;
12065 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12066 break;
12067 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12068 break;
12069 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12070 break;
12071 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12072 break;
12073 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12074 break;
12075 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12076 break;
12077 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12078 break;
12079 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12080 break;
12081 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12082 break;
12083 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12084 break;
12085 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12086 break;
12087 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12088 break;
12089 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12090 break;
12091 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12092 break;
12093 }
12094
12095 hashes_cnt = 1;
12096 }
12097
12098 if (show == 1 || left == 1)
12099 {
12100 for (uint i = 0; i < pot_cnt; i++)
12101 {
12102 pot_t *pot_ptr = &pot[i];
12103
12104 hash_t *hashes_buf = &pot_ptr->hash;
12105
12106 local_free (hashes_buf->digest);
12107
12108 if (isSalted)
12109 {
12110 local_free (hashes_buf->salt);
12111 }
12112 }
12113
12114 local_free (pot);
12115
12116 if (data.quiet == 0) log_info_nn ("");
12117
12118 return (0);
12119 }
12120
12121 if (keyspace == 0)
12122 {
12123 if (hashes_cnt == 0)
12124 {
12125 log_error ("ERROR: No hashes loaded");
12126
12127 return (-1);
12128 }
12129 }
12130
12131 /**
12132 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12133 */
12134
12135 if (data.outfile != NULL)
12136 {
12137 if (data.hashfile != NULL)
12138 {
12139 #ifdef _POSIX
12140 struct stat tmpstat_outfile;
12141 struct stat tmpstat_hashfile;
12142 #endif
12143
12144 #ifdef _WIN
12145 struct stat64 tmpstat_outfile;
12146 struct stat64 tmpstat_hashfile;
12147 #endif
12148
12149 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12150
12151 if (tmp_outfile_fp)
12152 {
12153 #ifdef _POSIX
12154 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12155 #endif
12156
12157 #ifdef _WIN
12158 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12159 #endif
12160
12161 fclose (tmp_outfile_fp);
12162 }
12163
12164 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12165
12166 if (tmp_hashfile_fp)
12167 {
12168 #ifdef _POSIX
12169 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12170 #endif
12171
12172 #ifdef _WIN
12173 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12174 #endif
12175
12176 fclose (tmp_hashfile_fp);
12177 }
12178
12179 if (tmp_outfile_fp && tmp_outfile_fp)
12180 {
12181 tmpstat_outfile.st_mode = 0;
12182 tmpstat_outfile.st_nlink = 0;
12183 tmpstat_outfile.st_uid = 0;
12184 tmpstat_outfile.st_gid = 0;
12185 tmpstat_outfile.st_rdev = 0;
12186 tmpstat_outfile.st_atime = 0;
12187
12188 tmpstat_hashfile.st_mode = 0;
12189 tmpstat_hashfile.st_nlink = 0;
12190 tmpstat_hashfile.st_uid = 0;
12191 tmpstat_hashfile.st_gid = 0;
12192 tmpstat_hashfile.st_rdev = 0;
12193 tmpstat_hashfile.st_atime = 0;
12194
12195 #ifdef _POSIX
12196 tmpstat_outfile.st_blksize = 0;
12197 tmpstat_outfile.st_blocks = 0;
12198
12199 tmpstat_hashfile.st_blksize = 0;
12200 tmpstat_hashfile.st_blocks = 0;
12201 #endif
12202
12203 #ifdef _POSIX
12204 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12205 {
12206 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12207
12208 return (-1);
12209 }
12210 #endif
12211
12212 #ifdef _WIN
12213 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12214 {
12215 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12216
12217 return (-1);
12218 }
12219 #endif
12220 }
12221 }
12222 }
12223
12224 /**
12225 * Remove duplicates
12226 */
12227
12228 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12229
12230 if (isSalted)
12231 {
12232 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12233 }
12234 else
12235 {
12236 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12237 }
12238
12239 uint hashes_cnt_orig = hashes_cnt;
12240
12241 hashes_cnt = 1;
12242
12243 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12244 {
12245 if (isSalted)
12246 {
12247 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12248 {
12249 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12250 }
12251 }
12252 else
12253 {
12254 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12255 }
12256
12257 if (hashes_pos > hashes_cnt)
12258 {
12259 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12260 }
12261
12262 hashes_cnt++;
12263 }
12264
12265 /**
12266 * Potfile removes
12267 */
12268
12269 uint potfile_remove_cracks = 0;
12270
12271 if (potfile_disable == 0)
12272 {
12273 hash_t hash_buf;
12274
12275 hash_buf.digest = mymalloc (dgst_size);
12276 hash_buf.salt = NULL;
12277 hash_buf.esalt = NULL;
12278 hash_buf.hash_info = NULL;
12279 hash_buf.cracked = 0;
12280
12281 if (isSalted)
12282 {
12283 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12284 }
12285
12286 if (esalt_size)
12287 {
12288 hash_buf.esalt = mymalloc (esalt_size);
12289 }
12290
12291 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12292
12293 // no solution for these special hash types (for instane because they use hashfile in output etc)
12294 if ((hash_mode != 5200) &&
12295 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12296 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12297 (hash_mode != 9000))
12298 {
12299 FILE *fp = fopen (potfile, "rb");
12300
12301 if (fp != NULL)
12302 {
12303 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12304
12305 // to be safe work with a copy (because of line_len loop, i etc)
12306 // moved up here because it's easier to handle continue case
12307 // it's just 64kb
12308
12309 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12310
12311 while (!feof (fp))
12312 {
12313 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12314
12315 if (ptr == NULL) break;
12316
12317 int line_len = strlen (line_buf);
12318
12319 if (line_len == 0) continue;
12320
12321 int iter = MAX_CUT_TRIES;
12322
12323 for (int i = line_len - 1; i && iter; i--, line_len--)
12324 {
12325 if (line_buf[i] != ':') continue;
12326
12327 if (isSalted)
12328 {
12329 memset (hash_buf.salt, 0, sizeof (salt_t));
12330 }
12331
12332 hash_t *found = NULL;
12333
12334 if (hash_mode == 6800)
12335 {
12336 if (i < 64) // 64 = 16 * uint in salt_buf[]
12337 {
12338 // manipulate salt_buf
12339 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12340
12341 hash_buf.salt->salt_len = i;
12342
12343 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12344 }
12345 }
12346 else if (hash_mode == 2500)
12347 {
12348 if (i < 64) // 64 = 16 * uint in salt_buf[]
12349 {
12350 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12351 // manipulate salt_buf
12352
12353 memcpy (line_buf_cpy, line_buf, i);
12354
12355 char *mac2_pos = strrchr (line_buf_cpy, ':');
12356
12357 if (mac2_pos == NULL) continue;
12358
12359 mac2_pos[0] = 0;
12360 mac2_pos++;
12361
12362 if (strlen (mac2_pos) != 12) continue;
12363
12364 char *mac1_pos = strrchr (line_buf_cpy, ':');
12365
12366 if (mac1_pos == NULL) continue;
12367
12368 mac1_pos[0] = 0;
12369 mac1_pos++;
12370
12371 if (strlen (mac1_pos) != 12) continue;
12372
12373 uint essid_length = mac1_pos - line_buf_cpy - 1;
12374
12375 // here we need the ESSID
12376 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12377
12378 hash_buf.salt->salt_len = essid_length;
12379
12380 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12381
12382 if (found)
12383 {
12384 wpa_t *wpa = (wpa_t *) found->esalt;
12385
12386 // compare hex string(s) vs binary MAC address(es)
12387
12388 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12389 {
12390 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12391 {
12392 found = NULL;
12393
12394 break;
12395 }
12396 }
12397
12398 // early skip ;)
12399 if (!found) continue;
12400
12401 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12402 {
12403 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12404 {
12405 found = NULL;
12406
12407 break;
12408 }
12409 }
12410 }
12411 }
12412 }
12413 else
12414 {
12415 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12416
12417 if (parser_status == PARSER_OK)
12418 {
12419 if (isSalted)
12420 {
12421 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12422 }
12423 else
12424 {
12425 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12426 }
12427 }
12428 }
12429
12430 if (found == NULL) continue;
12431
12432 if (!found->cracked) potfile_remove_cracks++;
12433
12434 found->cracked = 1;
12435
12436 if (found) break;
12437
12438 iter--;
12439 }
12440 }
12441
12442 myfree (line_buf_cpy);
12443
12444 myfree (line_buf);
12445
12446 fclose (fp);
12447 }
12448 }
12449
12450 if (esalt_size)
12451 {
12452 local_free (hash_buf.esalt);
12453 }
12454
12455 if (isSalted)
12456 {
12457 local_free (hash_buf.salt);
12458 }
12459
12460 local_free (hash_buf.digest);
12461 }
12462
12463 /**
12464 * Now generate all the buffers required for later
12465 */
12466
12467 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12468
12469 salt_t *salts_buf_new = NULL;
12470 void *esalts_buf_new = NULL;
12471
12472 if (isSalted)
12473 {
12474 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12475
12476 if (esalt_size)
12477 {
12478 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12479 }
12480 }
12481 else
12482 {
12483 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12484 }
12485
12486 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12487
12488 uint digests_cnt = hashes_cnt;
12489 uint digests_done = 0;
12490
12491 size_t size_digests = digests_cnt * dgst_size;
12492 size_t size_shown = digests_cnt * sizeof (uint);
12493
12494 uint *digests_shown = (uint *) mymalloc (size_shown);
12495 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12496
12497 uint salts_cnt = 0;
12498 uint salts_done = 0;
12499
12500 hashinfo_t **hash_info = NULL;
12501
12502 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12503 {
12504 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12505
12506 if (username && (remove || show))
12507 {
12508 uint user_pos;
12509
12510 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12511 {
12512 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12513
12514 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12515 }
12516 }
12517 }
12518
12519 uint *salts_shown = (uint *) mymalloc (size_shown);
12520
12521 salt_t *salt_buf;
12522
12523 {
12524 // copied from inner loop
12525
12526 salt_buf = &salts_buf_new[salts_cnt];
12527
12528 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12529
12530 if (esalt_size)
12531 {
12532 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12533 }
12534
12535 salt_buf->digests_cnt = 0;
12536 salt_buf->digests_done = 0;
12537 salt_buf->digests_offset = 0;
12538
12539 salts_cnt++;
12540 }
12541
12542 if (hashes_buf[0].cracked == 1)
12543 {
12544 digests_shown[0] = 1;
12545
12546 digests_done++;
12547
12548 salt_buf->digests_done++;
12549 }
12550
12551 salt_buf->digests_cnt++;
12552
12553 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12554
12555 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12556 {
12557 hash_info[0] = hashes_buf[0].hash_info;
12558 }
12559
12560 // copy from inner loop
12561
12562 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12563 {
12564 if (isSalted)
12565 {
12566 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12567 {
12568 salt_buf = &salts_buf_new[salts_cnt];
12569
12570 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12571
12572 if (esalt_size)
12573 {
12574 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12575 }
12576
12577 salt_buf->digests_cnt = 0;
12578 salt_buf->digests_done = 0;
12579 salt_buf->digests_offset = hashes_pos;
12580
12581 salts_cnt++;
12582 }
12583 }
12584
12585 if (hashes_buf[hashes_pos].cracked == 1)
12586 {
12587 digests_shown[hashes_pos] = 1;
12588
12589 digests_done++;
12590
12591 salt_buf->digests_done++;
12592 }
12593
12594 salt_buf->digests_cnt++;
12595
12596 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12597
12598 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12599 {
12600 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12601 }
12602 }
12603
12604 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12605 {
12606 salt_t *salt_buf = &salts_buf_new[salt_pos];
12607
12608 if (salt_buf->digests_done == salt_buf->digests_cnt)
12609 {
12610 salts_shown[salt_pos] = 1;
12611
12612 salts_done++;
12613 }
12614
12615 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12616 }
12617
12618 local_free (digests_buf);
12619 local_free (salts_buf);
12620 local_free (esalts_buf);
12621
12622 digests_buf = digests_buf_new;
12623 salts_buf = salts_buf_new;
12624 esalts_buf = esalts_buf_new;
12625
12626 local_free (hashes_buf);
12627
12628 /**
12629 * special modification not set from parser
12630 */
12631
12632 switch (hash_mode)
12633 {
12634 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12635 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12636 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12637 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12638 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12639 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12640 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12641 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12642 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12643 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12644 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12645 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12646 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12647 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12648 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12649 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12650 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12651 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12652 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12653 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12654 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12655 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12656 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12657 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12658 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12659 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12660 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12661 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12662 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12663 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12664 }
12665
12666 if (truecrypt_keyfiles)
12667 {
12668 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12669
12670 char *keyfiles = strdup (truecrypt_keyfiles);
12671
12672 char *keyfile = strtok (keyfiles, ",");
12673
12674 do
12675 {
12676 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12677
12678 } while ((keyfile = strtok (NULL, ",")) != NULL);
12679
12680 free (keyfiles);
12681 }
12682
12683 if (veracrypt_keyfiles)
12684 {
12685 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12686
12687 char *keyfiles = strdup (veracrypt_keyfiles);
12688
12689 char *keyfile = strtok (keyfiles, ",");
12690
12691 do
12692 {
12693 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12694
12695 } while ((keyfile = strtok (NULL, ",")) != NULL);
12696
12697 free (keyfiles);
12698 }
12699
12700 data.digests_cnt = digests_cnt;
12701 data.digests_done = digests_done;
12702 data.digests_buf = digests_buf;
12703 data.digests_shown = digests_shown;
12704 data.digests_shown_tmp = digests_shown_tmp;
12705
12706 data.salts_cnt = salts_cnt;
12707 data.salts_done = salts_done;
12708 data.salts_buf = salts_buf;
12709 data.salts_shown = salts_shown;
12710
12711 data.esalts_buf = esalts_buf;
12712 data.hash_info = hash_info;
12713
12714 /**
12715 * Automatic Optimizers
12716 */
12717
12718 if (salts_cnt == 1)
12719 opti_type |= OPTI_TYPE_SINGLE_SALT;
12720
12721 if (digests_cnt == 1)
12722 opti_type |= OPTI_TYPE_SINGLE_HASH;
12723
12724 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12725 opti_type |= OPTI_TYPE_NOT_ITERATED;
12726
12727 if (attack_mode == ATTACK_MODE_BF)
12728 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12729
12730 data.opti_type = opti_type;
12731
12732 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12733 {
12734 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12735 {
12736 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12737 {
12738 if (opts_type & OPTS_TYPE_ST_ADD80)
12739 {
12740 opts_type &= ~OPTS_TYPE_ST_ADD80;
12741 opts_type |= OPTS_TYPE_PT_ADD80;
12742 }
12743
12744 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12745 {
12746 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12747 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12748 }
12749
12750 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12751 {
12752 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12753 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12754 }
12755 }
12756 }
12757 }
12758
12759 /**
12760 * Some algorithm, like descrypt, can benefit from JIT compilation
12761 */
12762
12763 int force_jit_compilation = -1;
12764
12765 if (hash_mode == 8900)
12766 {
12767 force_jit_compilation = 8900;
12768 }
12769 else if (hash_mode == 9300)
12770 {
12771 force_jit_compilation = 8900;
12772 }
12773 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12774 {
12775 force_jit_compilation = 1500;
12776 }
12777
12778 /**
12779 * generate bitmap tables
12780 */
12781
12782 const uint bitmap_shift1 = 5;
12783 const uint bitmap_shift2 = 13;
12784
12785 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12786
12787 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12788 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12789 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12790 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12791 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12792 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12793 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12794 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12795
12796 uint bitmap_bits;
12797 uint bitmap_nums;
12798 uint bitmap_mask;
12799 uint bitmap_size;
12800
12801 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12802 {
12803 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12804
12805 bitmap_nums = 1 << bitmap_bits;
12806
12807 bitmap_mask = bitmap_nums - 1;
12808
12809 bitmap_size = bitmap_nums * sizeof (uint);
12810
12811 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12812
12813 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;
12814 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;
12815
12816 break;
12817 }
12818
12819 bitmap_nums = 1 << bitmap_bits;
12820
12821 bitmap_mask = bitmap_nums - 1;
12822
12823 bitmap_size = bitmap_nums * sizeof (uint);
12824
12825 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);
12826 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);
12827
12828 /**
12829 * prepare quick rule
12830 */
12831
12832 data.rule_buf_l = rule_buf_l;
12833 data.rule_buf_r = rule_buf_r;
12834
12835 int rule_len_l = (int) strlen (rule_buf_l);
12836 int rule_len_r = (int) strlen (rule_buf_r);
12837
12838 data.rule_len_l = rule_len_l;
12839 data.rule_len_r = rule_len_r;
12840
12841 /**
12842 * load rules
12843 */
12844
12845 uint *all_kernel_rules_cnt = NULL;
12846
12847 kernel_rule_t **all_kernel_rules_buf = NULL;
12848
12849 if (rp_files_cnt)
12850 {
12851 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12852
12853 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12854 }
12855
12856 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12857
12858 int rule_len = 0;
12859
12860 for (uint i = 0; i < rp_files_cnt; i++)
12861 {
12862 uint kernel_rules_avail = 0;
12863
12864 uint kernel_rules_cnt = 0;
12865
12866 kernel_rule_t *kernel_rules_buf = NULL;
12867
12868 char *rp_file = rp_files[i];
12869
12870 char in[BLOCK_SIZE] = { 0 };
12871 char out[BLOCK_SIZE] = { 0 };
12872
12873 FILE *fp = NULL;
12874
12875 uint rule_line = 0;
12876
12877 if ((fp = fopen (rp_file, "rb")) == NULL)
12878 {
12879 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12880
12881 return (-1);
12882 }
12883
12884 while (!feof (fp))
12885 {
12886 memset (rule_buf, 0, HCBUFSIZ);
12887
12888 rule_len = fgetl (fp, rule_buf);
12889
12890 rule_line++;
12891
12892 if (rule_len == 0) continue;
12893
12894 if (rule_buf[0] == '#') continue;
12895
12896 if (kernel_rules_avail == kernel_rules_cnt)
12897 {
12898 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12899
12900 kernel_rules_avail += INCR_RULES;
12901 }
12902
12903 memset (in, 0, BLOCK_SIZE);
12904 memset (out, 0, BLOCK_SIZE);
12905
12906 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12907
12908 if (result == -1)
12909 {
12910 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12911
12912 continue;
12913 }
12914
12915 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12916 {
12917 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12918
12919 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12920
12921 continue;
12922 }
12923
12924 /* its so slow
12925 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12926 {
12927 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12928
12929 continue;
12930 }
12931 */
12932
12933 kernel_rules_cnt++;
12934 }
12935
12936 fclose (fp);
12937
12938 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12939
12940 all_kernel_rules_buf[i] = kernel_rules_buf;
12941 }
12942
12943 /**
12944 * merge rules or automatic rule generator
12945 */
12946
12947 uint kernel_rules_cnt = 0;
12948
12949 kernel_rule_t *kernel_rules_buf = NULL;
12950
12951 if (attack_mode == ATTACK_MODE_STRAIGHT)
12952 {
12953 if (rp_files_cnt)
12954 {
12955 kernel_rules_cnt = 1;
12956
12957 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12958
12959 repeats[0] = kernel_rules_cnt;
12960
12961 for (uint i = 0; i < rp_files_cnt; i++)
12962 {
12963 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12964
12965 repeats[i + 1] = kernel_rules_cnt;
12966 }
12967
12968 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12969
12970 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12971
12972 for (uint i = 0; i < kernel_rules_cnt; i++)
12973 {
12974 uint out_pos = 0;
12975
12976 kernel_rule_t *out = &kernel_rules_buf[i];
12977
12978 for (uint j = 0; j < rp_files_cnt; j++)
12979 {
12980 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12981 uint in_pos;
12982
12983 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12984
12985 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12986 {
12987 if (out_pos == RULES_MAX - 1)
12988 {
12989 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12990
12991 break;
12992 }
12993
12994 out->cmds[out_pos] = in->cmds[in_pos];
12995 }
12996 }
12997 }
12998
12999 local_free (repeats);
13000 }
13001 else if (rp_gen)
13002 {
13003 uint kernel_rules_avail = 0;
13004
13005 while (kernel_rules_cnt < rp_gen)
13006 {
13007 if (kernel_rules_avail == kernel_rules_cnt)
13008 {
13009 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13010
13011 kernel_rules_avail += INCR_RULES;
13012 }
13013
13014 memset (rule_buf, 0, HCBUFSIZ);
13015
13016 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13017
13018 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13019
13020 kernel_rules_cnt++;
13021 }
13022 }
13023 }
13024
13025 myfree (rule_buf);
13026
13027 /**
13028 * generate NOP rules
13029 */
13030
13031 if (kernel_rules_cnt == 0)
13032 {
13033 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13034
13035 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13036
13037 kernel_rules_cnt++;
13038 }
13039
13040 data.kernel_rules_cnt = kernel_rules_cnt;
13041 data.kernel_rules_buf = kernel_rules_buf;
13042
13043 /**
13044 * OpenCL platforms: detect
13045 */
13046
13047 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13048 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13049
13050 cl_uint platforms_cnt = 0;
13051 cl_uint platform_devices_cnt = 0;
13052
13053 if (keyspace == 0)
13054 {
13055 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13056
13057 if (platforms_cnt == 0)
13058 {
13059 log_info ("");
13060 log_info ("ATTENTION! No OpenCL compatible platform found");
13061 log_info ("");
13062 log_info ("You're probably missing the OpenCL runtime installation");
13063 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13064 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13065 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13066 log_info ("");
13067
13068 return (-1);
13069 }
13070
13071 if (opencl_platforms_filter != (uint) -1)
13072 {
13073 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13074
13075 if (opencl_platforms_filter > platform_cnt_mask)
13076 {
13077 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13078
13079 return (-1);
13080 }
13081 }
13082 }
13083
13084 /**
13085 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13086 */
13087
13088 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13089 {
13090 cl_platform_id platform = platforms[platform_id];
13091
13092 char platform_vendor[INFOSZ] = { 0 };
13093
13094 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13095
13096 #ifdef HAVE_HWMON
13097 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13098 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13099 {
13100 // make sure that we do not directly control the fan for NVidia
13101
13102 gpu_temp_retain = 0;
13103
13104 data.gpu_temp_retain = gpu_temp_retain;
13105 }
13106 #endif // HAVE_NVML || HAVE_NVAPI
13107 #endif
13108 }
13109
13110 /**
13111 * OpenCL device types:
13112 * 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.
13113 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13114 */
13115
13116 if (opencl_device_types == NULL)
13117 {
13118 cl_device_type device_types_all = 0;
13119
13120 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13121 {
13122 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13123
13124 cl_platform_id platform = platforms[platform_id];
13125
13126 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13127
13128 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13129 {
13130 cl_device_id device = platform_devices[platform_devices_id];
13131
13132 cl_device_type device_type;
13133
13134 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13135
13136 device_types_all |= device_type;
13137 }
13138 }
13139
13140 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13141 {
13142 device_types_filter |= CL_DEVICE_TYPE_CPU;
13143 }
13144 }
13145
13146 /**
13147 * OpenCL devices: simply push all devices from all platforms into the same device array
13148 */
13149
13150 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13151
13152 data.devices_param = devices_param;
13153
13154 uint devices_cnt = 0;
13155
13156 uint devices_active = 0;
13157
13158 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13159 {
13160 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13161
13162 cl_platform_id platform = platforms[platform_id];
13163
13164 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13165
13166 char platform_vendor[INFOSZ] = { 0 };
13167
13168 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13169
13170 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13171 // this causes trouble with vendor id based macros
13172 // we'll assign generic to those without special optimization available
13173
13174 cl_uint vendor_id = 0;
13175
13176 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13177 {
13178 vendor_id = VENDOR_ID_AMD;
13179 }
13180 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13181 {
13182 vendor_id = VENDOR_ID_APPLE;
13183 }
13184 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13185 {
13186 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13187 }
13188 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13189 {
13190 vendor_id = VENDOR_ID_INTEL_SDK;
13191 }
13192 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13193 {
13194 vendor_id = VENDOR_ID_MESA;
13195 }
13196 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13197 {
13198 vendor_id = VENDOR_ID_NV;
13199 }
13200 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13201 {
13202 vendor_id = VENDOR_ID_POCL;
13203 }
13204 else
13205 {
13206 vendor_id = VENDOR_ID_GENERIC;
13207 }
13208
13209 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13210 {
13211 size_t param_value_size = 0;
13212
13213 const uint device_id = devices_cnt;
13214
13215 hc_device_param_t *device_param = &data.devices_param[device_id];
13216
13217 device_param->vendor_id = vendor_id;
13218
13219 device_param->device = platform_devices[platform_devices_id];
13220
13221 device_param->device_id = device_id;
13222
13223 device_param->platform_devices_id = platform_devices_id;
13224
13225 // device_type
13226
13227 cl_device_type device_type;
13228
13229 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13230
13231 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13232
13233 device_param->device_type = device_type;
13234
13235 // device_name
13236
13237 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13238
13239 char *device_name = (char *) mymalloc (param_value_size);
13240
13241 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13242
13243 device_param->device_name = device_name;
13244
13245 // tuning db
13246
13247 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13248
13249 // device_version
13250
13251 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13252
13253 char *device_version = (char *) mymalloc (param_value_size);
13254
13255 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13256
13257 device_param->device_version = device_version;
13258
13259 // device_opencl_version
13260
13261 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13262
13263 char *device_opencl_version = (char *) mymalloc (param_value_size);
13264
13265 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13266
13267 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13268
13269 myfree (device_opencl_version);
13270
13271 // vector_width
13272
13273 cl_uint vector_width;
13274
13275 if (opencl_vector_width_chgd == 0)
13276 {
13277 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13278 {
13279 if (opti_type & OPTI_TYPE_USES_BITS_64)
13280 {
13281 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13282 }
13283 else
13284 {
13285 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13286 }
13287 }
13288 else
13289 {
13290 vector_width = (cl_uint) tuningdb_entry->vector_width;
13291 }
13292 }
13293 else
13294 {
13295 vector_width = opencl_vector_width;
13296 }
13297
13298 if (vector_width > 16) vector_width = 16;
13299
13300 device_param->vector_width = vector_width;
13301
13302 // max_compute_units
13303
13304 cl_uint device_processors;
13305
13306 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13307
13308 device_param->device_processors = device_processors;
13309
13310 // device_maxmem_alloc
13311 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13312
13313 cl_ulong device_maxmem_alloc;
13314
13315 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13316
13317 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13318
13319 // device_global_mem
13320
13321 cl_ulong device_global_mem;
13322
13323 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13324
13325 device_param->device_global_mem = device_global_mem;
13326
13327 // max_work_group_size
13328
13329 size_t device_maxworkgroup_size;
13330
13331 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13332
13333 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13334
13335 // max_clock_frequency
13336
13337 cl_uint device_maxclock_frequency;
13338
13339 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13340
13341 device_param->device_maxclock_frequency = device_maxclock_frequency;
13342
13343 // device_endian_little
13344
13345 cl_bool device_endian_little;
13346
13347 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13348
13349 if (device_endian_little == CL_FALSE)
13350 {
13351 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13352
13353 device_param->skipped = 1;
13354 }
13355
13356 // device_available
13357
13358 cl_bool device_available;
13359
13360 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13361
13362 if (device_available == CL_FALSE)
13363 {
13364 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13365
13366 device_param->skipped = 1;
13367 }
13368
13369 // device_compiler_available
13370
13371 cl_bool device_compiler_available;
13372
13373 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13374
13375 if (device_compiler_available == CL_FALSE)
13376 {
13377 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13378
13379 device_param->skipped = 1;
13380 }
13381
13382 // device_execution_capabilities
13383
13384 cl_device_exec_capabilities device_execution_capabilities;
13385
13386 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13387
13388 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13389 {
13390 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13391
13392 device_param->skipped = 1;
13393 }
13394
13395 // device_extensions
13396
13397 size_t device_extensions_size;
13398
13399 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13400
13401 char *device_extensions = mymalloc (device_extensions_size + 1);
13402
13403 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13404
13405 if (strstr (device_extensions, "base_atomics") == 0)
13406 {
13407 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13408
13409 device_param->skipped = 1;
13410 }
13411
13412 if (strstr (device_extensions, "byte_addressable_store") == 0)
13413 {
13414 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13415
13416 device_param->skipped = 1;
13417 }
13418
13419 myfree (device_extensions);
13420
13421 // device_local_mem_size
13422
13423 cl_ulong device_local_mem_size;
13424
13425 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13426
13427 if (device_local_mem_size < 32768)
13428 {
13429 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13430
13431 device_param->skipped = 1;
13432 }
13433
13434
13435 // skipped
13436
13437 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13438 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13439
13440 // driver_version
13441
13442 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13443
13444 char *driver_version = (char *) mymalloc (param_value_size);
13445
13446 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13447
13448 device_param->driver_version = driver_version;
13449
13450 // device_name_chksum
13451
13452 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13453
13454 #if __x86_64__
13455 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);
13456 #else
13457 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);
13458 #endif
13459
13460 uint device_name_digest[4] = { 0 };
13461
13462 md5_64 ((uint *) device_name_chksum, device_name_digest);
13463
13464 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13465
13466 device_param->device_name_chksum = device_name_chksum;
13467
13468 // device_processor_cores
13469
13470 if (device_type & CL_DEVICE_TYPE_CPU)
13471 {
13472 cl_uint device_processor_cores = 1;
13473
13474 device_param->device_processor_cores = device_processor_cores;
13475 }
13476
13477 if (device_type & CL_DEVICE_TYPE_GPU)
13478 {
13479 if (vendor_id == VENDOR_ID_AMD)
13480 {
13481 cl_uint device_processor_cores = 0;
13482
13483 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13486
13487 device_param->device_processor_cores = device_processor_cores;
13488 }
13489 else if (vendor_id == VENDOR_ID_NV)
13490 {
13491 cl_uint kernel_exec_timeout = 0;
13492
13493 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13494
13495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13496
13497 device_param->kernel_exec_timeout = kernel_exec_timeout;
13498
13499 cl_uint device_processor_cores = 0;
13500
13501 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13502
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13504
13505 device_param->device_processor_cores = device_processor_cores;
13506
13507 cl_uint sm_minor = 0;
13508 cl_uint sm_major = 0;
13509
13510 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13511 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13512
13513 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13515
13516 device_param->sm_minor = sm_minor;
13517 device_param->sm_major = sm_major;
13518 }
13519 else
13520 {
13521 cl_uint device_processor_cores = 1;
13522
13523 device_param->device_processor_cores = device_processor_cores;
13524 }
13525 }
13526
13527 // display results
13528
13529 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13530 {
13531 if (status_automat == 0)
13532 {
13533 if (device_param->skipped == 0)
13534 {
13535 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13536 device_id + 1,
13537 device_name,
13538 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13539 (unsigned int) (device_global_mem / 1024 / 1024),
13540 (unsigned int) (device_maxclock_frequency),
13541 (unsigned int) device_processors);
13542 }
13543 else
13544 {
13545 log_info ("Device #%u: %s, skipped",
13546 device_id + 1,
13547 device_name);
13548 }
13549 }
13550 }
13551
13552 // common driver check
13553
13554 if (device_param->skipped == 0)
13555 {
13556 if (device_type & CL_DEVICE_TYPE_GPU)
13557 {
13558 if (vendor_id == VENDOR_ID_AMD)
13559 {
13560 int catalyst_check = (force == 1) ? 0 : 1;
13561
13562 int catalyst_warn = 0;
13563
13564 int catalyst_broken = 0;
13565
13566 if (catalyst_check == 1)
13567 {
13568 catalyst_warn = 1;
13569
13570 // v14.9 and higher
13571 if (atoi (device_param->driver_version) >= 1573)
13572 {
13573 catalyst_warn = 0;
13574 }
13575
13576 catalyst_check = 0;
13577 }
13578
13579 if (catalyst_broken == 1)
13580 {
13581 log_info ("");
13582 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13583 log_info ("It will pass over cracked hashes and does not report them as cracked");
13584 log_info ("You are STRONGLY encouraged not to use it");
13585 log_info ("You can use --force to override this but do not post error reports if you do so");
13586 log_info ("");
13587
13588 return (-1);
13589 }
13590
13591 if (catalyst_warn == 1)
13592 {
13593 log_info ("");
13594 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13595 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13596 log_info ("See hashcat's homepage for official supported catalyst drivers");
13597 #ifdef _WIN
13598 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13599 #endif
13600 log_info ("You can use --force to override this but do not post error reports if you do so");
13601 log_info ("");
13602
13603 return (-1);
13604 }
13605 }
13606 else if (vendor_id == VENDOR_ID_NV)
13607 {
13608 if (device_param->kernel_exec_timeout != 0)
13609 {
13610 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);
13611 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13612 }
13613 }
13614 }
13615
13616 if (device_type & CL_DEVICE_TYPE_CPU)
13617 {
13618 if (vendor_id == VENDOR_ID_AMD)
13619 {
13620 if (force == 0)
13621 {
13622 log_info ("");
13623 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13624 log_info ("You are STRONGLY encouraged not to use it");
13625 log_info ("You can use --force to override this but do not post error reports if you do so");
13626 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13627 log_info ("");
13628
13629 return (-1);
13630 }
13631 }
13632 }
13633
13634 /**
13635 * kernel accel and loops tuning db adjustment
13636 */
13637
13638 device_param->kernel_accel_min = 1;
13639 device_param->kernel_accel_max = 1024;
13640
13641 device_param->kernel_loops_min = 1;
13642 device_param->kernel_loops_max = 1024;
13643
13644 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13645
13646 if (tuningdb_entry)
13647 {
13648 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13649 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13650
13651 if (_kernel_accel)
13652 {
13653 device_param->kernel_accel_min = _kernel_accel;
13654 device_param->kernel_accel_max = _kernel_accel;
13655 }
13656
13657 if (_kernel_loops)
13658 {
13659 if (workload_profile == 1)
13660 {
13661 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13662 }
13663 else if (workload_profile == 2)
13664 {
13665 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13666 }
13667
13668 device_param->kernel_loops_min = _kernel_loops;
13669 device_param->kernel_loops_max = _kernel_loops;
13670 }
13671 }
13672
13673 // commandline parameters overwrite tuningdb entries
13674
13675 if (kernel_accel)
13676 {
13677 device_param->kernel_accel_min = kernel_accel;
13678 device_param->kernel_accel_max = kernel_accel;
13679 }
13680
13681 if (kernel_loops)
13682 {
13683 device_param->kernel_loops_min = kernel_loops;
13684 device_param->kernel_loops_max = kernel_loops;
13685 }
13686
13687 /**
13688 * activate device
13689 */
13690
13691 devices_active++;
13692 }
13693
13694 // next please
13695
13696 devices_cnt++;
13697 }
13698 }
13699
13700 if (keyspace == 0 && devices_active == 0)
13701 {
13702 log_error ("ERROR: No devices found/left");
13703
13704 return (-1);
13705 }
13706
13707 // 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)
13708
13709 if (devices_filter != (uint) -1)
13710 {
13711 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13712
13713 if (devices_filter > devices_cnt_mask)
13714 {
13715 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13716
13717 return (-1);
13718 }
13719 }
13720
13721 data.devices_cnt = devices_cnt;
13722
13723 data.devices_active = devices_active;
13724
13725 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13726 {
13727 if (status_automat == 0)
13728 {
13729 log_info ("");
13730 }
13731 }
13732
13733 /**
13734 * HM devices: init
13735 */
13736
13737 #ifdef HAVE_HWMON
13738 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13739 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13740 #endif
13741
13742 #ifdef HAVE_ADL
13743 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13744 #endif
13745
13746 if (gpu_temp_disable == 0)
13747 {
13748 #if defined(WIN) && defined(HAVE_NVAPI)
13749 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13750
13751 if (nvapi_init (nvapi) == 0)
13752 data.hm_nv = nvapi;
13753
13754 if (data.hm_nv)
13755 {
13756 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13757 {
13758 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13759
13760 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13761
13762 int tmp_out = 0;
13763
13764 for (int i = 0; i < tmp_in; i++)
13765 {
13766 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13767 }
13768
13769 for (int i = 0; i < tmp_out; i++)
13770 {
13771 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13772
13773 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13774
13775 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;
13776 }
13777 }
13778 }
13779 #endif // WIN && HAVE_NVAPI
13780
13781 #if defined(LINUX) && defined(HAVE_NVML)
13782 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13783
13784 if (nvml_init (nvml) == 0)
13785 data.hm_nv = nvml;
13786
13787 if (data.hm_nv)
13788 {
13789 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13790 {
13791 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13792
13793 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13794
13795 int tmp_out = 0;
13796
13797 for (int i = 0; i < tmp_in; i++)
13798 {
13799 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13800 }
13801
13802 for (int i = 0; i < tmp_out; i++)
13803 {
13804 unsigned int speed;
13805
13806 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;
13807 }
13808 }
13809 }
13810 #endif // LINUX && HAVE_NVML
13811
13812 data.hm_amd = NULL;
13813
13814 #ifdef HAVE_ADL
13815 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13816
13817 if (adl_init (adl) == 0)
13818 data.hm_amd = adl;
13819
13820 if (data.hm_amd)
13821 {
13822 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13823 {
13824 // total number of adapters
13825
13826 int hm_adapters_num;
13827
13828 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13829
13830 // adapter info
13831
13832 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13833
13834 if (lpAdapterInfo == NULL) return (-1);
13835
13836 // get a list (of ids of) valid/usable adapters
13837
13838 int num_adl_adapters = 0;
13839
13840 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13841
13842 if (num_adl_adapters > 0)
13843 {
13844 hc_thread_mutex_lock (mux_adl);
13845
13846 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13847
13848 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13849
13850 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13851 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13852
13853 hc_thread_mutex_unlock (mux_adl);
13854 }
13855
13856 myfree (valid_adl_device_list);
13857 myfree (lpAdapterInfo);
13858 }
13859 }
13860 #endif // HAVE_ADL
13861
13862 if (data.hm_amd == NULL && data.hm_nv == NULL)
13863 {
13864 gpu_temp_disable = 1;
13865 }
13866 }
13867
13868 /**
13869 * OpenCL devices: allocate buffer for device specific information
13870 */
13871
13872 #ifdef HAVE_HWMON
13873 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13874
13875 #ifdef HAVE_ADL
13876 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13877
13878 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13879 #endif // ADL
13880 #endif
13881
13882 /**
13883 * enable custom signal handler(s)
13884 */
13885
13886 if (benchmark == 0)
13887 {
13888 hc_signal (sigHandler_default);
13889 }
13890 else
13891 {
13892 hc_signal (sigHandler_benchmark);
13893 }
13894
13895 /**
13896 * User-defined GPU temp handling
13897 */
13898
13899 #ifdef HAVE_HWMON
13900 if (gpu_temp_disable == 1)
13901 {
13902 gpu_temp_abort = 0;
13903 gpu_temp_retain = 0;
13904 }
13905
13906 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13907 {
13908 if (gpu_temp_abort < gpu_temp_retain)
13909 {
13910 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13911
13912 return (-1);
13913 }
13914 }
13915
13916 data.gpu_temp_disable = gpu_temp_disable;
13917 data.gpu_temp_abort = gpu_temp_abort;
13918 data.gpu_temp_retain = gpu_temp_retain;
13919 #endif
13920
13921 /**
13922 * inform the user
13923 */
13924
13925 if (data.quiet == 0)
13926 {
13927 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13928
13929 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);
13930
13931 if (attack_mode == ATTACK_MODE_STRAIGHT)
13932 {
13933 log_info ("Rules: %u", kernel_rules_cnt);
13934 }
13935
13936 if (opti_type)
13937 {
13938 log_info ("Applicable Optimizers:");
13939
13940 for (uint i = 0; i < 32; i++)
13941 {
13942 const uint opti_bit = 1u << i;
13943
13944 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13945 }
13946 }
13947
13948 /**
13949 * Watchdog and Temperature balance
13950 */
13951
13952 #ifdef HAVE_HWMON
13953 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13954 {
13955 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13956 }
13957
13958 if (gpu_temp_abort == 0)
13959 {
13960 log_info ("Watchdog: Temperature abort trigger disabled");
13961 }
13962 else
13963 {
13964 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13965 }
13966
13967 if (gpu_temp_retain == 0)
13968 {
13969 log_info ("Watchdog: Temperature retain trigger disabled");
13970 }
13971 else
13972 {
13973 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13974 }
13975
13976 if (data.quiet == 0) log_info ("");
13977 #endif
13978 }
13979
13980 /**
13981 * HM devices: copy
13982 */
13983
13984 if (gpu_temp_disable == 0)
13985 {
13986 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13987 {
13988 hc_device_param_t *device_param = &data.devices_param[device_id];
13989
13990 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13991
13992 if (device_param->skipped) continue;
13993
13994 const uint platform_devices_id = device_param->platform_devices_id;
13995
13996 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13997 if (device_param->vendor_id == VENDOR_ID_NV)
13998 {
13999 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14000 }
14001 #endif
14002
14003 #ifdef HAVE_ADL
14004 if (device_param->vendor_id == VENDOR_ID_AMD)
14005 {
14006 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14007 }
14008 #endif
14009 }
14010 }
14011
14012 /*
14013 * Temporary fix:
14014 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14015 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14016 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14017 * Driver / ADL bug?
14018 */
14019
14020 #ifdef HAVE_ADL
14021 if (powertune_enable == 1)
14022 {
14023 hc_thread_mutex_lock (mux_adl);
14024
14025 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14026 {
14027 hc_device_param_t *device_param = &data.devices_param[device_id];
14028
14029 if (device_param->skipped) continue;
14030
14031 if (data.hm_device[device_id].od_version == 6)
14032 {
14033 // set powertune value only
14034
14035 int powertune_supported = 0;
14036
14037 int ADL_rc = 0;
14038
14039 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14040 {
14041 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14042
14043 return (-1);
14044 }
14045
14046 if (powertune_supported != 0)
14047 {
14048 // powertune set
14049 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14050
14051 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14052 {
14053 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14054
14055 return (-1);
14056 }
14057
14058 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14059 {
14060 log_error ("ERROR: Failed to set new ADL PowerControl values");
14061
14062 return (-1);
14063 }
14064 }
14065 }
14066 }
14067
14068 hc_thread_mutex_unlock (mux_adl);
14069 }
14070 #endif // HAVE_ADK
14071 #endif // HAVE_HWMON
14072
14073 #ifdef DEBUG
14074 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14075 #endif
14076
14077 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14078
14079 uint kernel_power_all = 0;
14080
14081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14082 {
14083 /**
14084 * host buffer
14085 */
14086
14087 hc_device_param_t *device_param = &data.devices_param[device_id];
14088
14089 if (device_param->skipped) continue;
14090
14091 /**
14092 * device properties
14093 */
14094
14095 const char *device_name_chksum = device_param->device_name_chksum;
14096 const u32 device_processors = device_param->device_processors;
14097 const u32 device_processor_cores = device_param->device_processor_cores;
14098
14099 /**
14100 * create context for each device
14101 */
14102
14103 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14104
14105 /**
14106 * create command-queue
14107 */
14108
14109 // not supported with NV
14110 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14111
14112 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14113
14114 /**
14115 * kernel threads: some algorithms need a fixed kernel-threads count
14116 * because of shared memory usage or bitslice
14117 * there needs to be some upper limit, otherwise there's too much overhead
14118 */
14119
14120 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14121
14122 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14123 {
14124 kernel_threads = KERNEL_THREADS_MAX_CPU;
14125 }
14126
14127 if (hash_mode == 1500) kernel_threads = 64; // DES
14128 if (hash_mode == 3000) kernel_threads = 64; // DES
14129 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14130 if (hash_mode == 7500) kernel_threads = 64; // RC4
14131 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14132 if (hash_mode == 9700) kernel_threads = 64; // RC4
14133 if (hash_mode == 9710) kernel_threads = 64; // RC4
14134 if (hash_mode == 9800) kernel_threads = 64; // RC4
14135 if (hash_mode == 9810) kernel_threads = 64; // RC4
14136 if (hash_mode == 10400) kernel_threads = 64; // RC4
14137 if (hash_mode == 10410) kernel_threads = 64; // RC4
14138 if (hash_mode == 10500) kernel_threads = 64; // RC4
14139 if (hash_mode == 13100) kernel_threads = 64; // RC4
14140
14141 /**
14142 * create input buffers on device : calculate size of fixed memory buffers
14143 */
14144
14145 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14146 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14147
14148 device_param->size_root_css = size_root_css;
14149 device_param->size_markov_css = size_markov_css;
14150
14151 size_t size_results = kernel_threads * sizeof (uint);
14152
14153 device_param->size_results = size_results;
14154
14155 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14156 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14157
14158 size_t size_plains = digests_cnt * sizeof (plain_t);
14159 size_t size_salts = salts_cnt * sizeof (salt_t);
14160 size_t size_esalts = salts_cnt * esalt_size;
14161
14162 device_param->size_plains = size_plains;
14163 device_param->size_digests = size_digests;
14164 device_param->size_shown = size_shown;
14165 device_param->size_salts = size_salts;
14166
14167 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14168 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14169 size_t size_tm = 32 * sizeof (bs_word_t);
14170
14171 // scryptV stuff
14172
14173 size_t size_scryptV = 1;
14174
14175 if ((hash_mode == 8900) || (hash_mode == 9300))
14176 {
14177 uint tmto_start = 0;
14178 uint tmto_stop = 10;
14179
14180 if (scrypt_tmto)
14181 {
14182 tmto_start = scrypt_tmto;
14183 }
14184 else
14185 {
14186 // in case the user did not specify the tmto manually
14187 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14188 // but set the lower end only in case the user has a device with too less memory
14189
14190 if (hash_mode == 8900)
14191 {
14192 if (device_param->vendor_id == VENDOR_ID_AMD)
14193 {
14194 tmto_start = 1;
14195 }
14196 else if (device_param->vendor_id == VENDOR_ID_NV)
14197 {
14198 tmto_start = 2;
14199 }
14200 }
14201 else if (hash_mode == 9300)
14202 {
14203 if (device_param->vendor_id == VENDOR_ID_AMD)
14204 {
14205 tmto_start = 2;
14206 }
14207 else if (device_param->vendor_id == VENDOR_ID_NV)
14208 {
14209 tmto_start = 2;
14210 }
14211 }
14212 }
14213
14214 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14215 {
14216 // TODO: in theory the following calculation needs to be done per salt, not global
14217 // we assume all hashes have the same scrypt settings
14218
14219 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14220
14221 size_scryptV /= 1 << tmto;
14222
14223 size_scryptV *= device_processors * device_processor_cores;
14224
14225 if (size_scryptV > device_param->device_maxmem_alloc)
14226 {
14227 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14228
14229 continue;
14230 }
14231
14232 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14233 {
14234 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14235 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14236 }
14237
14238 break;
14239 }
14240
14241 if (data.salts_buf[0].scrypt_phy == 0)
14242 {
14243 log_error ("ERROR: can't allocate enough device memory");
14244
14245 return -1;
14246 }
14247
14248 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14249 }
14250
14251 /**
14252 * some algorithms need a fixed kernel-loops count
14253 */
14254
14255 if (hash_mode == 1500)
14256 {
14257 const u32 kernel_loops_fixed = 1024;
14258
14259 device_param->kernel_loops_min = kernel_loops_fixed;
14260 device_param->kernel_loops_max = kernel_loops_fixed;
14261 }
14262
14263 if (hash_mode == 3000)
14264 {
14265 const u32 kernel_loops_fixed = 1024;
14266
14267 device_param->kernel_loops_min = kernel_loops_fixed;
14268 device_param->kernel_loops_max = kernel_loops_fixed;
14269 }
14270
14271 if (hash_mode == 8900)
14272 {
14273 const u32 kernel_loops_fixed = 1;
14274
14275 device_param->kernel_loops_min = kernel_loops_fixed;
14276 device_param->kernel_loops_max = kernel_loops_fixed;
14277 }
14278
14279 if (hash_mode == 9300)
14280 {
14281 const u32 kernel_loops_fixed = 1;
14282
14283 device_param->kernel_loops_min = kernel_loops_fixed;
14284 device_param->kernel_loops_max = kernel_loops_fixed;
14285 }
14286
14287 if (hash_mode == 12500)
14288 {
14289 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14290
14291 device_param->kernel_loops_min = kernel_loops_fixed;
14292 device_param->kernel_loops_max = kernel_loops_fixed;
14293 }
14294
14295 /**
14296 * some algorithms have a maximum kernel-loops count
14297 */
14298
14299 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14300 {
14301 u32 innerloop_cnt = 0;
14302
14303 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14304 {
14305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14306 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14307 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14308 }
14309 else
14310 {
14311 innerloop_cnt = data.salts_buf[0].salt_iter;
14312 }
14313
14314 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14315 (innerloop_cnt <= device_param->kernel_loops_max))
14316 {
14317 device_param->kernel_loops_max = innerloop_cnt;
14318 }
14319 }
14320
14321 /**
14322 * some algorithms need a special kernel-accel
14323 */
14324
14325 if (hash_mode == 8900)
14326 {
14327 device_param->kernel_accel_min = 1;
14328 device_param->kernel_accel_max = 64;
14329 }
14330
14331 if (hash_mode == 9300)
14332 {
14333 device_param->kernel_accel_min = 1;
14334 device_param->kernel_accel_max = 64;
14335 }
14336
14337 u32 kernel_accel_min = device_param->kernel_accel_min;
14338 u32 kernel_accel_max = device_param->kernel_accel_max;
14339
14340 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14341
14342 size_t size_pws = 4;
14343 size_t size_tmps = 4;
14344 size_t size_hooks = 4;
14345
14346 while (kernel_accel_max >= kernel_accel_min)
14347 {
14348 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14349
14350 // size_pws
14351
14352 size_pws = kernel_power_max * sizeof (pw_t);
14353
14354 // size_tmps
14355
14356 switch (hash_mode)
14357 {
14358 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14359 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14360 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14361 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14362 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14363 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14364 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14365 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14366 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14367 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14368 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14369 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14370 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14371 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14372 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14373 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14374 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14375 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14376 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14377 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14378 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14379 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14380 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14381 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14382 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14383 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14384 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14385 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14386 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14387 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14388 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14389 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14390 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14391 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14392 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14393 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14394 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14395 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14396 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14397 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14398 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14399 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14400 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14401 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14402 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14403 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14404 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14405 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14406 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14407 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14408 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14409 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14410 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14411 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14412 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14413 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14414 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14415 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14416 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14417 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14418 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14419 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14420 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14421 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14422 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14423 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14424 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14425 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14426 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14427 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14428 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14429 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14430 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14431 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14432 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14433 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14434 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14435 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14436 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14437 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14438 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14439 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14440 };
14441
14442 // size_hooks
14443
14444 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14445 {
14446 // none yet
14447 }
14448
14449 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14450 // if not, decrease amplifier and try again
14451
14452 int skip = 0;
14453
14454 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14455 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14456 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14457
14458 if (( bitmap_size
14459 + bitmap_size
14460 + bitmap_size
14461 + bitmap_size
14462 + bitmap_size
14463 + bitmap_size
14464 + bitmap_size
14465 + bitmap_size
14466 + size_bfs
14467 + size_combs
14468 + size_digests
14469 + size_esalts
14470 + size_hooks
14471 + size_markov_css
14472 + size_plains
14473 + size_pws
14474 + size_pws // not a bug
14475 + size_results
14476 + size_root_css
14477 + size_rules
14478 + size_rules_c
14479 + size_salts
14480 + size_scryptV
14481 + size_shown
14482 + size_tm
14483 + size_tmps) > device_param->device_global_mem) skip = 1;
14484
14485 if (skip == 1)
14486 {
14487 kernel_accel_max--;
14488
14489 continue;
14490 }
14491
14492 break;
14493 }
14494
14495 /*
14496 if (kernel_accel_max == 0)
14497 {
14498 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14499
14500 return -1;
14501 }
14502 */
14503
14504 device_param->kernel_accel_min = kernel_accel_min;
14505 device_param->kernel_accel_max = kernel_accel_max;
14506
14507 /*
14508 if (kernel_accel_max < kernel_accel)
14509 {
14510 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14511
14512 device_param->kernel_accel = kernel_accel_max;
14513 }
14514 */
14515
14516 device_param->size_bfs = size_bfs;
14517 device_param->size_combs = size_combs;
14518 device_param->size_rules = size_rules;
14519 device_param->size_rules_c = size_rules_c;
14520 device_param->size_pws = size_pws;
14521 device_param->size_tmps = size_tmps;
14522 device_param->size_hooks = size_hooks;
14523
14524 // do not confuse kernel_accel_max with kernel_accel here
14525
14526 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14527
14528 device_param->kernel_threads = kernel_threads;
14529 device_param->kernel_power_user = kernel_power;
14530
14531 kernel_power_all += kernel_power;
14532
14533 /**
14534 * default building options
14535 */
14536
14537 char build_opts[1024] = { 0 };
14538
14539 // we don't have sm_* on vendors not NV but it doesn't matter
14540
14541 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);
14542
14543 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14544 {
14545 // we do vectorizing much better than the auto-vectorizer
14546
14547 char build_opts_new[1024] = { 0 };
14548
14549 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14550
14551 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14552 }
14553
14554 #ifdef DEBUG
14555 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14556 #endif
14557
14558 /**
14559 * main kernel
14560 */
14561
14562 {
14563 /**
14564 * kernel source filename
14565 */
14566
14567 char source_file[256] = { 0 };
14568
14569 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14570
14571 struct stat sst;
14572
14573 if (stat (source_file, &sst) == -1)
14574 {
14575 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14576
14577 return -1;
14578 }
14579
14580 /**
14581 * kernel cached filename
14582 */
14583
14584 char cached_file[256] = { 0 };
14585
14586 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14587
14588 int cached = 1;
14589
14590 struct stat cst;
14591
14592 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14593 {
14594 cached = 0;
14595 }
14596
14597 /**
14598 * kernel compile or load
14599 */
14600
14601 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14602
14603 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14604
14605 if (force_jit_compilation == -1)
14606 {
14607 if (cached == 0)
14608 {
14609 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14610
14611 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14612
14613 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14614
14615 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14616
14617 #ifdef DEBUG
14618 size_t build_log_size = 0;
14619
14620 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14621
14622 if (build_log_size > 1)
14623 {
14624 char *build_log = (char *) malloc (build_log_size + 1);
14625
14626 memset (build_log, 0, build_log_size + 1);
14627
14628 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14629
14630 puts (build_log);
14631
14632 free (build_log);
14633 }
14634 #endif
14635
14636 if (rc != 0)
14637 {
14638 device_param->skipped = true;
14639
14640 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14641
14642 continue;
14643 }
14644
14645 size_t binary_size;
14646
14647 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14648
14649 u8 *binary = (u8 *) mymalloc (binary_size);
14650
14651 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14652
14653 writeProgramBin (cached_file, binary, binary_size);
14654
14655 local_free (binary);
14656 }
14657 else
14658 {
14659 #ifdef DEBUG
14660 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14661 #endif
14662
14663 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14664
14665 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14666
14667 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14668 }
14669 }
14670 else
14671 {
14672 #ifdef DEBUG
14673 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14674 #endif
14675
14676 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14677
14678 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14679
14680 char build_opts_update[1024] = { 0 };
14681
14682 if (force_jit_compilation == 1500)
14683 {
14684 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14685 }
14686 else if (force_jit_compilation == 8900)
14687 {
14688 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);
14689 }
14690 else
14691 {
14692 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14693 }
14694
14695 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14696
14697 #ifdef DEBUG
14698 size_t build_log_size = 0;
14699
14700 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14701
14702 if (build_log_size > 1)
14703 {
14704 char *build_log = (char *) malloc (build_log_size + 1);
14705
14706 memset (build_log, 0, build_log_size + 1);
14707
14708 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14709
14710 puts (build_log);
14711
14712 free (build_log);
14713 }
14714 #endif
14715
14716 if (rc != 0)
14717 {
14718 device_param->skipped = true;
14719
14720 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14721 }
14722 }
14723
14724 local_free (kernel_lengths);
14725 local_free (kernel_sources[0]);
14726 local_free (kernel_sources);
14727 }
14728
14729 /**
14730 * word generator kernel
14731 */
14732
14733 if (attack_mode != ATTACK_MODE_STRAIGHT)
14734 {
14735 /**
14736 * kernel mp source filename
14737 */
14738
14739 char source_file[256] = { 0 };
14740
14741 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14742
14743 struct stat sst;
14744
14745 if (stat (source_file, &sst) == -1)
14746 {
14747 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14748
14749 return -1;
14750 }
14751
14752 /**
14753 * kernel mp cached filename
14754 */
14755
14756 char cached_file[256] = { 0 };
14757
14758 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14759
14760 int cached = 1;
14761
14762 struct stat cst;
14763
14764 if (stat (cached_file, &cst) == -1)
14765 {
14766 cached = 0;
14767 }
14768
14769 /**
14770 * kernel compile or load
14771 */
14772
14773 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14774
14775 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14776
14777 if (cached == 0)
14778 {
14779 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14780 if (quiet == 0) log_info ("");
14781
14782 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14783
14784 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14785
14786 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14787
14788 if (rc != 0)
14789 {
14790 device_param->skipped = true;
14791
14792 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14793
14794 continue;
14795 }
14796
14797 size_t binary_size;
14798
14799 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14800
14801 u8 *binary = (u8 *) mymalloc (binary_size);
14802
14803 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14804
14805 writeProgramBin (cached_file, binary, binary_size);
14806
14807 local_free (binary);
14808 }
14809 else
14810 {
14811 #ifdef DEBUG
14812 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14813 #endif
14814
14815 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14816
14817 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14818
14819 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14820 }
14821
14822 local_free (kernel_lengths);
14823 local_free (kernel_sources[0]);
14824 local_free (kernel_sources);
14825 }
14826
14827 /**
14828 * amplifier kernel
14829 */
14830
14831 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14832 {
14833
14834 }
14835 else
14836 {
14837 /**
14838 * kernel amp source filename
14839 */
14840
14841 char source_file[256] = { 0 };
14842
14843 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14844
14845 struct stat sst;
14846
14847 if (stat (source_file, &sst) == -1)
14848 {
14849 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14850
14851 return -1;
14852 }
14853
14854 /**
14855 * kernel amp cached filename
14856 */
14857
14858 char cached_file[256] = { 0 };
14859
14860 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14861
14862 int cached = 1;
14863
14864 struct stat cst;
14865
14866 if (stat (cached_file, &cst) == -1)
14867 {
14868 cached = 0;
14869 }
14870
14871 /**
14872 * kernel compile or load
14873 */
14874
14875 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14876
14877 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14878
14879 if (cached == 0)
14880 {
14881 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14882 if (quiet == 0) log_info ("");
14883
14884 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14885
14886 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14887
14888 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14889
14890 if (rc != 0)
14891 {
14892 device_param->skipped = true;
14893
14894 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14895
14896 continue;
14897 }
14898
14899 size_t binary_size;
14900
14901 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14902
14903 u8 *binary = (u8 *) mymalloc (binary_size);
14904
14905 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14906
14907 writeProgramBin (cached_file, binary, binary_size);
14908
14909 local_free (binary);
14910 }
14911 else
14912 {
14913 #ifdef DEBUG
14914 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14915 #endif
14916
14917 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14918
14919 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14920
14921 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14922 }
14923
14924 local_free (kernel_lengths);
14925 local_free (kernel_sources[0]);
14926 local_free (kernel_sources);
14927 }
14928
14929 // some algorithm collide too fast, make that impossible
14930
14931 if (benchmark == 1)
14932 {
14933 ((uint *) digests_buf)[0] = -1;
14934 ((uint *) digests_buf)[1] = -1;
14935 ((uint *) digests_buf)[2] = -1;
14936 ((uint *) digests_buf)[3] = -1;
14937 }
14938
14939 /**
14940 * global buffers
14941 */
14942
14943 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14944 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14945 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14946 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14947 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14948 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14949 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14950 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14951 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14952 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14953 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14954 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14955 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14956 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14957 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14958 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14959 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14960 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14961
14962 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);
14963 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);
14964 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);
14965 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);
14966 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);
14967 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);
14968 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);
14969 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);
14970 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14971 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14972 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14973
14974 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14975 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14976 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14977 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14978 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14979 run_kernel_bzero (device_param, device_param->d_result, size_results);
14980
14981 /**
14982 * special buffers
14983 */
14984
14985 if (attack_kern == ATTACK_KERN_STRAIGHT)
14986 {
14987 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14988 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14989
14990 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14991
14992 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14993 }
14994 else if (attack_kern == ATTACK_KERN_COMBI)
14995 {
14996 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14997 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14998 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14999 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15000
15001 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15002 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15003 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15004 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15005 }
15006 else if (attack_kern == ATTACK_KERN_BF)
15007 {
15008 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15009 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15010 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15011 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15012 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15013
15014 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15015 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15016 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15017 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15018 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15019 }
15020
15021 if (size_esalts)
15022 {
15023 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15024
15025 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15026 }
15027
15028 /**
15029 * main host data
15030 */
15031
15032 uint *result = (uint *) mymalloc (size_results);
15033
15034 device_param->result = result;
15035
15036 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15037
15038 device_param->pws_buf = pws_buf;
15039
15040 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15041
15042 device_param->combs_buf = combs_buf;
15043
15044 void *hooks_buf = mymalloc (size_hooks);
15045
15046 device_param->hooks_buf = hooks_buf;
15047
15048 /**
15049 * kernel args
15050 */
15051
15052 device_param->kernel_params_buf32[21] = bitmap_mask;
15053 device_param->kernel_params_buf32[22] = bitmap_shift1;
15054 device_param->kernel_params_buf32[23] = bitmap_shift2;
15055 device_param->kernel_params_buf32[24] = 0; // salt_pos
15056 device_param->kernel_params_buf32[25] = 0; // loop_pos
15057 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15058 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15059 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15060 device_param->kernel_params_buf32[29] = 0; // digests_offset
15061 device_param->kernel_params_buf32[30] = 0; // combs_mode
15062 device_param->kernel_params_buf32[31] = 0; // gid_max
15063
15064 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15065 ? &device_param->d_pws_buf
15066 : &device_param->d_pws_amp_buf;
15067 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15068 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15069 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15070 device_param->kernel_params[ 4] = &device_param->d_tmps;
15071 device_param->kernel_params[ 5] = &device_param->d_hooks;
15072 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15073 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15074 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15075 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15076 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15077 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15078 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15079 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15080 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15081 device_param->kernel_params[15] = &device_param->d_digests_buf;
15082 device_param->kernel_params[16] = &device_param->d_digests_shown;
15083 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15084 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15085 device_param->kernel_params[19] = &device_param->d_result;
15086 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15087 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15088 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15089 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15090 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15091 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15092 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15093 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15094 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15095 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15096 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15097 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15098
15099 device_param->kernel_params_mp_buf64[3] = 0;
15100 device_param->kernel_params_mp_buf32[4] = 0;
15101 device_param->kernel_params_mp_buf32[5] = 0;
15102 device_param->kernel_params_mp_buf32[6] = 0;
15103 device_param->kernel_params_mp_buf32[7] = 0;
15104 device_param->kernel_params_mp_buf32[8] = 0;
15105
15106 device_param->kernel_params_mp[0] = NULL;
15107 device_param->kernel_params_mp[1] = NULL;
15108 device_param->kernel_params_mp[2] = NULL;
15109 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15110 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15111 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15112 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15113 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15114 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15115
15116 device_param->kernel_params_mp_l_buf64[3] = 0;
15117 device_param->kernel_params_mp_l_buf32[4] = 0;
15118 device_param->kernel_params_mp_l_buf32[5] = 0;
15119 device_param->kernel_params_mp_l_buf32[6] = 0;
15120 device_param->kernel_params_mp_l_buf32[7] = 0;
15121 device_param->kernel_params_mp_l_buf32[8] = 0;
15122 device_param->kernel_params_mp_l_buf32[9] = 0;
15123
15124 device_param->kernel_params_mp_l[0] = NULL;
15125 device_param->kernel_params_mp_l[1] = NULL;
15126 device_param->kernel_params_mp_l[2] = NULL;
15127 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15128 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15129 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15130 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15131 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15132 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15133 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15134
15135 device_param->kernel_params_mp_r_buf64[3] = 0;
15136 device_param->kernel_params_mp_r_buf32[4] = 0;
15137 device_param->kernel_params_mp_r_buf32[5] = 0;
15138 device_param->kernel_params_mp_r_buf32[6] = 0;
15139 device_param->kernel_params_mp_r_buf32[7] = 0;
15140 device_param->kernel_params_mp_r_buf32[8] = 0;
15141
15142 device_param->kernel_params_mp_r[0] = NULL;
15143 device_param->kernel_params_mp_r[1] = NULL;
15144 device_param->kernel_params_mp_r[2] = NULL;
15145 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15146 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15147 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15148 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15149 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15150 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15151
15152 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15153 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15154
15155 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15156 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15157 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15158 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15159 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15160 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15161 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15162
15163 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15164 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15165
15166 /**
15167 * kernel name
15168 */
15169
15170 size_t kernel_wgs_tmp;
15171
15172 char kernel_name[64] = { 0 };
15173
15174 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15175 {
15176 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15177 {
15178 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15179
15180 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15181
15182 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15183
15184 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15185
15186 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15187
15188 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15189 }
15190 else
15191 {
15192 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15193
15194 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15195
15196 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15197
15198 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15199
15200 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15201
15202 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15203 }
15204
15205 if (data.attack_mode == ATTACK_MODE_BF)
15206 {
15207 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15208 {
15209 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15210
15211 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15212
15213 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);
15214 }
15215 }
15216 }
15217 else
15218 {
15219 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15220
15221 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15222
15223 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15224
15225 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15226
15227 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15228
15229 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15230
15231 if (opts_type & OPTS_TYPE_HOOK12)
15232 {
15233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15234
15235 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15236
15237 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);
15238 }
15239
15240 if (opts_type & OPTS_TYPE_HOOK23)
15241 {
15242 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15243
15244 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15245
15246 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);
15247 }
15248 }
15249
15250 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);
15251 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);
15252 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);
15253
15254 for (uint i = 0; i <= 20; i++)
15255 {
15256 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15257 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15258 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15259
15260 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15261 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15262 }
15263
15264 for (uint i = 21; i <= 31; i++)
15265 {
15266 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15267 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15268 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15269
15270 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15271 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15272 }
15273
15274 if (attack_mode == ATTACK_MODE_BF)
15275 {
15276 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15277 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15278
15279 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);
15280 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);
15281
15282 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15283 {
15284 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15285 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15286 }
15287 }
15288 else if (attack_mode == ATTACK_MODE_HYBRID1)
15289 {
15290 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15291
15292 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);
15293 }
15294 else if (attack_mode == ATTACK_MODE_HYBRID2)
15295 {
15296 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15297
15298 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);
15299 }
15300
15301 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15302 {
15303 // nothing to do
15304 }
15305 else
15306 {
15307 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15308
15309 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);
15310 }
15311
15312 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15313 {
15314 // nothing to do
15315 }
15316 else
15317 {
15318 for (uint i = 0; i < 5; i++)
15319 {
15320 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15321 }
15322
15323 for (uint i = 5; i < 7; i++)
15324 {
15325 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15326 }
15327 }
15328
15329 // maybe this has been updated by clGetKernelWorkGroupInfo()
15330 // value can only be decreased, so we don't need to reallocate buffers
15331
15332 device_param->kernel_threads = kernel_threads;
15333
15334 /**
15335 * Store initial fanspeed if gpu_temp_retain is enabled
15336 */
15337
15338 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15339 int gpu_temp_retain_set = 0;
15340
15341 if (gpu_temp_disable == 0)
15342 {
15343 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15344 {
15345 hc_thread_mutex_lock (mux_adl);
15346
15347 if (data.hm_device[device_id].fan_supported == 1)
15348 {
15349 if (gpu_temp_retain_chgd == 0)
15350 {
15351 uint cur_temp = 0;
15352 uint default_temp = 0;
15353
15354 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);
15355
15356 if (ADL_rc == ADL_OK)
15357 {
15358 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15359
15360 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15361
15362 // special case with multi gpu setups: always use minimum retain
15363
15364 if (gpu_temp_retain_set == 0)
15365 {
15366 gpu_temp_retain = gpu_temp_retain_target;
15367 gpu_temp_retain_set = 1;
15368 }
15369 else
15370 {
15371 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15372 }
15373
15374 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15375 }
15376 }
15377
15378 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15379
15380 temp_retain_fanspeed_value[device_id] = fan_speed;
15381
15382 if (fan_speed == -1)
15383 {
15384 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15385
15386 temp_retain_fanspeed_value[device_id] = 0;
15387 }
15388 }
15389
15390 hc_thread_mutex_unlock (mux_adl);
15391 }
15392 }
15393
15394 /**
15395 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15396 */
15397
15398 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15399 {
15400 hc_thread_mutex_lock (mux_adl);
15401
15402 if (data.hm_device[device_id].od_version == 6)
15403 {
15404 int ADL_rc;
15405
15406 // check powertune capabilities first, if not available then skip device
15407
15408 int powertune_supported = 0;
15409
15410 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15411 {
15412 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15413
15414 return (-1);
15415 }
15416
15417 if (powertune_supported != 0)
15418 {
15419 // powercontrol settings
15420
15421 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15422
15423 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15424 {
15425 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15426 }
15427
15428 if (ADL_rc != ADL_OK)
15429 {
15430 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15431
15432 return (-1);
15433 }
15434
15435 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15436 {
15437 log_error ("ERROR: Failed to set new ADL PowerControl values");
15438
15439 return (-1);
15440 }
15441
15442 // clocks
15443
15444 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15445
15446 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15447
15448 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)
15449 {
15450 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15451
15452 return (-1);
15453 }
15454
15455 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15456
15457 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15458
15459 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15460 {
15461 log_error ("ERROR: Failed to get ADL device capabilities");
15462
15463 return (-1);
15464 }
15465
15466 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15467 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15468
15469 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15470 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15471
15472 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15473 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15474
15475 // warning if profile has too low max values
15476
15477 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15478 {
15479 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15480 }
15481
15482 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15483 {
15484 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15485 }
15486
15487 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15488
15489 performance_state->iNumberOfPerformanceLevels = 2;
15490
15491 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15492 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15493 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15494 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15495
15496 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)
15497 {
15498 log_info ("ERROR: Failed to set ADL performance state");
15499
15500 return (-1);
15501 }
15502
15503 local_free (performance_state);
15504 }
15505 }
15506
15507 hc_thread_mutex_unlock (mux_adl);
15508 }
15509 #endif // HAVE_HWMON && HAVE_ADL
15510 }
15511
15512 data.kernel_power_all = kernel_power_all;
15513
15514 if (data.quiet == 0) log_info_nn ("");
15515
15516 /**
15517 * In benchmark-mode, inform user which algorithm is checked
15518 */
15519
15520 if (benchmark == 1)
15521 {
15522 if (status_automat == 0)
15523 {
15524 quiet = 0;
15525
15526 data.quiet = quiet;
15527
15528 char *hash_type = strhashtype (data.hash_mode); // not a bug
15529
15530 log_info ("Hashtype: %s", hash_type);
15531 log_info ("");
15532 }
15533 }
15534
15535 /**
15536 * keep track of the progress
15537 */
15538
15539 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15540 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15541 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15542
15543 /**
15544 * open filehandles
15545 */
15546
15547 #if _WIN
15548 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15549 {
15550 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15551
15552 return (-1);
15553 }
15554
15555 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15556 {
15557 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15558
15559 return (-1);
15560 }
15561
15562 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15563 {
15564 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15565
15566 return (-1);
15567 }
15568 #endif
15569
15570 /**
15571 * dictionary pad
15572 */
15573
15574 segment_size *= (1024 * 1024);
15575
15576 data.segment_size = segment_size;
15577
15578 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15579
15580 wl_data->buf = (char *) mymalloc (segment_size);
15581 wl_data->avail = segment_size;
15582 wl_data->incr = segment_size;
15583 wl_data->cnt = 0;
15584 wl_data->pos = 0;
15585
15586 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15587
15588 data.wordlist_mode = wordlist_mode;
15589
15590 cs_t *css_buf = NULL;
15591 uint css_cnt = 0;
15592 uint dictcnt = 0;
15593 uint maskcnt = 1;
15594 char **masks = NULL;
15595 char **dictfiles = NULL;
15596
15597 uint mask_from_file = 0;
15598
15599 if (attack_mode == ATTACK_MODE_STRAIGHT)
15600 {
15601 if (wordlist_mode == WL_MODE_FILE)
15602 {
15603 int wls_left = myargc - (optind + 1);
15604
15605 for (int i = 0; i < wls_left; i++)
15606 {
15607 char *l0_filename = myargv[optind + 1 + i];
15608
15609 struct stat l0_stat;
15610
15611 if (stat (l0_filename, &l0_stat) == -1)
15612 {
15613 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15614
15615 return (-1);
15616 }
15617
15618 uint is_dir = S_ISDIR (l0_stat.st_mode);
15619
15620 if (is_dir == 0)
15621 {
15622 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15623
15624 dictcnt++;
15625
15626 dictfiles[dictcnt - 1] = l0_filename;
15627 }
15628 else
15629 {
15630 // do not allow --keyspace w/ a directory
15631
15632 if (keyspace == 1)
15633 {
15634 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15635
15636 return (-1);
15637 }
15638
15639 char **dictionary_files = NULL;
15640
15641 dictionary_files = scan_directory (l0_filename);
15642
15643 if (dictionary_files != NULL)
15644 {
15645 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15646
15647 for (int d = 0; dictionary_files[d] != NULL; d++)
15648 {
15649 char *l1_filename = dictionary_files[d];
15650
15651 struct stat l1_stat;
15652
15653 if (stat (l1_filename, &l1_stat) == -1)
15654 {
15655 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15656
15657 return (-1);
15658 }
15659
15660 if (S_ISREG (l1_stat.st_mode))
15661 {
15662 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15663
15664 dictcnt++;
15665
15666 dictfiles[dictcnt - 1] = strdup (l1_filename);
15667 }
15668 }
15669 }
15670
15671 local_free (dictionary_files);
15672 }
15673 }
15674
15675 if (dictcnt < 1)
15676 {
15677 log_error ("ERROR: No usable dictionary file found.");
15678
15679 return (-1);
15680 }
15681 }
15682 else if (wordlist_mode == WL_MODE_STDIN)
15683 {
15684 dictcnt = 1;
15685 }
15686 }
15687 else if (attack_mode == ATTACK_MODE_COMBI)
15688 {
15689 // display
15690
15691 char *dictfile1 = myargv[optind + 1 + 0];
15692 char *dictfile2 = myargv[optind + 1 + 1];
15693
15694 // find the bigger dictionary and use as base
15695
15696 FILE *fp1 = NULL;
15697 FILE *fp2 = NULL;
15698
15699 struct stat tmp_stat;
15700
15701 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15702 {
15703 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15704
15705 return (-1);
15706 }
15707
15708 if (stat (dictfile1, &tmp_stat) == -1)
15709 {
15710 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15711
15712 fclose (fp1);
15713
15714 return (-1);
15715 }
15716
15717 if (S_ISDIR (tmp_stat.st_mode))
15718 {
15719 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15720
15721 fclose (fp1);
15722
15723 return (-1);
15724 }
15725
15726 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15727 {
15728 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15729
15730 fclose (fp1);
15731
15732 return (-1);
15733 }
15734
15735 if (stat (dictfile2, &tmp_stat) == -1)
15736 {
15737 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15738
15739 fclose (fp1);
15740 fclose (fp2);
15741
15742 return (-1);
15743 }
15744
15745 if (S_ISDIR (tmp_stat.st_mode))
15746 {
15747 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15748
15749 fclose (fp1);
15750 fclose (fp2);
15751
15752 return (-1);
15753 }
15754
15755 data.combs_cnt = 1;
15756
15757 data.quiet = 1;
15758
15759 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15760
15761 data.quiet = quiet;
15762
15763 if (words1_cnt == 0)
15764 {
15765 log_error ("ERROR: %s: empty file", dictfile1);
15766
15767 fclose (fp1);
15768 fclose (fp2);
15769
15770 return (-1);
15771 }
15772
15773 data.combs_cnt = 1;
15774
15775 data.quiet = 1;
15776
15777 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15778
15779 data.quiet = quiet;
15780
15781 if (words2_cnt == 0)
15782 {
15783 log_error ("ERROR: %s: empty file", dictfile2);
15784
15785 fclose (fp1);
15786 fclose (fp2);
15787
15788 return (-1);
15789 }
15790
15791 fclose (fp1);
15792 fclose (fp2);
15793
15794 data.dictfile = dictfile1;
15795 data.dictfile2 = dictfile2;
15796
15797 if (words1_cnt >= words2_cnt)
15798 {
15799 data.combs_cnt = words2_cnt;
15800 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15801
15802 dictfiles = &data.dictfile;
15803
15804 dictcnt = 1;
15805 }
15806 else
15807 {
15808 data.combs_cnt = words1_cnt;
15809 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15810
15811 dictfiles = &data.dictfile2;
15812
15813 dictcnt = 1;
15814
15815 // we also have to switch wordlist related rules!
15816
15817 char *tmpc = data.rule_buf_l;
15818
15819 data.rule_buf_l = data.rule_buf_r;
15820 data.rule_buf_r = tmpc;
15821
15822 int tmpi = data.rule_len_l;
15823
15824 data.rule_len_l = data.rule_len_r;
15825 data.rule_len_r = tmpi;
15826 }
15827 }
15828 else if (attack_mode == ATTACK_MODE_BF)
15829 {
15830 char *mask = NULL;
15831
15832 maskcnt = 0;
15833
15834 if (benchmark == 0)
15835 {
15836 mask = myargv[optind + 1];
15837
15838 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15839
15840 if ((optind + 2) <= myargc)
15841 {
15842 struct stat file_stat;
15843
15844 if (stat (mask, &file_stat) == -1)
15845 {
15846 maskcnt = 1;
15847
15848 masks[maskcnt - 1] = mystrdup (mask);
15849 }
15850 else
15851 {
15852 int wls_left = myargc - (optind + 1);
15853
15854 uint masks_avail = INCR_MASKS;
15855
15856 for (int i = 0; i < wls_left; i++)
15857 {
15858 if (i != 0)
15859 {
15860 mask = myargv[optind + 1 + i];
15861
15862 if (stat (mask, &file_stat) == -1)
15863 {
15864 log_error ("ERROR: %s: %s", mask, strerror (errno));
15865
15866 return (-1);
15867 }
15868 }
15869
15870 uint is_file = S_ISREG (file_stat.st_mode);
15871
15872 if (is_file == 1)
15873 {
15874 FILE *mask_fp;
15875
15876 if ((mask_fp = fopen (mask, "r")) == NULL)
15877 {
15878 log_error ("ERROR: %s: %s", mask, strerror (errno));
15879
15880 return (-1);
15881 }
15882
15883 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15884
15885 while (!feof (mask_fp))
15886 {
15887 memset (line_buf, 0, HCBUFSIZ);
15888
15889 int line_len = fgetl (mask_fp, line_buf);
15890
15891 if (line_len == 0) continue;
15892
15893 if (line_buf[0] == '#') continue;
15894
15895 if (masks_avail == maskcnt)
15896 {
15897 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15898
15899 masks_avail += INCR_MASKS;
15900 }
15901
15902 masks[maskcnt] = mystrdup (line_buf);
15903
15904 maskcnt++;
15905 }
15906
15907 myfree (line_buf);
15908
15909 fclose (mask_fp);
15910 }
15911 else
15912 {
15913 log_error ("ERROR: %s: unsupported file-type", mask);
15914
15915 return (-1);
15916 }
15917 }
15918
15919 mask_from_file = 1;
15920 }
15921 }
15922 else
15923 {
15924 custom_charset_1 = (char *) "?l?d?u";
15925 custom_charset_2 = (char *) "?l?d";
15926 custom_charset_3 = (char *) "?l?d*!$@_";
15927
15928 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15929 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15930 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15931
15932 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15933
15934 wordlist_mode = WL_MODE_MASK;
15935
15936 data.wordlist_mode = wordlist_mode;
15937
15938 increment = 1;
15939
15940 maskcnt = 1;
15941 }
15942 }
15943 else
15944 {
15945 /**
15946 * generate full masks and charsets
15947 */
15948
15949 masks = (char **) mymalloc (sizeof (char *));
15950
15951 switch (hash_mode)
15952 {
15953 case 1731: pw_min = 5;
15954 pw_max = 5;
15955 mask = mystrdup ("?b?b?b?b?b");
15956 break;
15957 case 12500: pw_min = 5;
15958 pw_max = 5;
15959 mask = mystrdup ("?b?b?b?b?b");
15960 break;
15961 default: pw_min = 7;
15962 pw_max = 7;
15963 mask = mystrdup ("?b?b?b?b?b?b?b");
15964 break;
15965 }
15966
15967 maskcnt = 1;
15968
15969 masks[maskcnt - 1] = mystrdup (mask);
15970
15971 wordlist_mode = WL_MODE_MASK;
15972
15973 data.wordlist_mode = wordlist_mode;
15974
15975 increment = 1;
15976 }
15977
15978 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15979
15980 if (increment)
15981 {
15982 if (increment_min > pw_min) pw_min = increment_min;
15983
15984 if (increment_max < pw_max) pw_max = increment_max;
15985 }
15986 }
15987 else if (attack_mode == ATTACK_MODE_HYBRID1)
15988 {
15989 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15990
15991 // display
15992
15993 char *mask = myargv[myargc - 1];
15994
15995 maskcnt = 0;
15996
15997 masks = (char **) mymalloc (1 * sizeof (char *));
15998
15999 // mod
16000
16001 struct stat file_stat;
16002
16003 if (stat (mask, &file_stat) == -1)
16004 {
16005 maskcnt = 1;
16006
16007 masks[maskcnt - 1] = mystrdup (mask);
16008 }
16009 else
16010 {
16011 uint is_file = S_ISREG (file_stat.st_mode);
16012
16013 if (is_file == 1)
16014 {
16015 FILE *mask_fp;
16016
16017 if ((mask_fp = fopen (mask, "r")) == NULL)
16018 {
16019 log_error ("ERROR: %s: %s", mask, strerror (errno));
16020
16021 return (-1);
16022 }
16023
16024 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16025
16026 uint masks_avail = 1;
16027
16028 while (!feof (mask_fp))
16029 {
16030 memset (line_buf, 0, HCBUFSIZ);
16031
16032 int line_len = fgetl (mask_fp, line_buf);
16033
16034 if (line_len == 0) continue;
16035
16036 if (line_buf[0] == '#') continue;
16037
16038 if (masks_avail == maskcnt)
16039 {
16040 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16041
16042 masks_avail += INCR_MASKS;
16043 }
16044
16045 masks[maskcnt] = mystrdup (line_buf);
16046
16047 maskcnt++;
16048 }
16049
16050 myfree (line_buf);
16051
16052 fclose (mask_fp);
16053
16054 mask_from_file = 1;
16055 }
16056 else
16057 {
16058 maskcnt = 1;
16059
16060 masks[maskcnt - 1] = mystrdup (mask);
16061 }
16062 }
16063
16064 // base
16065
16066 int wls_left = myargc - (optind + 2);
16067
16068 for (int i = 0; i < wls_left; i++)
16069 {
16070 char *filename = myargv[optind + 1 + i];
16071
16072 struct stat file_stat;
16073
16074 if (stat (filename, &file_stat) == -1)
16075 {
16076 log_error ("ERROR: %s: %s", filename, strerror (errno));
16077
16078 return (-1);
16079 }
16080
16081 uint is_dir = S_ISDIR (file_stat.st_mode);
16082
16083 if (is_dir == 0)
16084 {
16085 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16086
16087 dictcnt++;
16088
16089 dictfiles[dictcnt - 1] = filename;
16090 }
16091 else
16092 {
16093 // do not allow --keyspace w/ a directory
16094
16095 if (keyspace == 1)
16096 {
16097 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16098
16099 return (-1);
16100 }
16101
16102 char **dictionary_files = NULL;
16103
16104 dictionary_files = scan_directory (filename);
16105
16106 if (dictionary_files != NULL)
16107 {
16108 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16109
16110 for (int d = 0; dictionary_files[d] != NULL; d++)
16111 {
16112 char *l1_filename = dictionary_files[d];
16113
16114 struct stat l1_stat;
16115
16116 if (stat (l1_filename, &l1_stat) == -1)
16117 {
16118 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16119
16120 return (-1);
16121 }
16122
16123 if (S_ISREG (l1_stat.st_mode))
16124 {
16125 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16126
16127 dictcnt++;
16128
16129 dictfiles[dictcnt - 1] = strdup (l1_filename);
16130 }
16131 }
16132 }
16133
16134 local_free (dictionary_files);
16135 }
16136 }
16137
16138 if (dictcnt < 1)
16139 {
16140 log_error ("ERROR: No usable dictionary file found.");
16141
16142 return (-1);
16143 }
16144
16145 if (increment)
16146 {
16147 maskcnt = 0;
16148
16149 uint mask_min = increment_min; // we can't reject smaller masks here
16150 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16151
16152 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16153 {
16154 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16155
16156 if (cur_mask == NULL) break;
16157
16158 masks[maskcnt] = cur_mask;
16159
16160 maskcnt++;
16161
16162 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16163 }
16164 }
16165 }
16166 else if (attack_mode == ATTACK_MODE_HYBRID2)
16167 {
16168 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16169
16170 // display
16171
16172 char *mask = myargv[optind + 1 + 0];
16173
16174 maskcnt = 0;
16175
16176 masks = (char **) mymalloc (1 * sizeof (char *));
16177
16178 // mod
16179
16180 struct stat file_stat;
16181
16182 if (stat (mask, &file_stat) == -1)
16183 {
16184 maskcnt = 1;
16185
16186 masks[maskcnt - 1] = mystrdup (mask);
16187 }
16188 else
16189 {
16190 uint is_file = S_ISREG (file_stat.st_mode);
16191
16192 if (is_file == 1)
16193 {
16194 FILE *mask_fp;
16195
16196 if ((mask_fp = fopen (mask, "r")) == NULL)
16197 {
16198 log_error ("ERROR: %s: %s", mask, strerror (errno));
16199
16200 return (-1);
16201 }
16202
16203 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16204
16205 uint masks_avail = 1;
16206
16207 while (!feof (mask_fp))
16208 {
16209 memset (line_buf, 0, HCBUFSIZ);
16210
16211 int line_len = fgetl (mask_fp, line_buf);
16212
16213 if (line_len == 0) continue;
16214
16215 if (line_buf[0] == '#') continue;
16216
16217 if (masks_avail == maskcnt)
16218 {
16219 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16220
16221 masks_avail += INCR_MASKS;
16222 }
16223
16224 masks[maskcnt] = mystrdup (line_buf);
16225
16226 maskcnt++;
16227 }
16228
16229 myfree (line_buf);
16230
16231 fclose (mask_fp);
16232
16233 mask_from_file = 1;
16234 }
16235 else
16236 {
16237 maskcnt = 1;
16238
16239 masks[maskcnt - 1] = mystrdup (mask);
16240 }
16241 }
16242
16243 // base
16244
16245 int wls_left = myargc - (optind + 2);
16246
16247 for (int i = 0; i < wls_left; i++)
16248 {
16249 char *filename = myargv[optind + 2 + i];
16250
16251 struct stat file_stat;
16252
16253 if (stat (filename, &file_stat) == -1)
16254 {
16255 log_error ("ERROR: %s: %s", filename, strerror (errno));
16256
16257 return (-1);
16258 }
16259
16260 uint is_dir = S_ISDIR (file_stat.st_mode);
16261
16262 if (is_dir == 0)
16263 {
16264 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16265
16266 dictcnt++;
16267
16268 dictfiles[dictcnt - 1] = filename;
16269 }
16270 else
16271 {
16272 // do not allow --keyspace w/ a directory
16273
16274 if (keyspace == 1)
16275 {
16276 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16277
16278 return (-1);
16279 }
16280
16281 char **dictionary_files = NULL;
16282
16283 dictionary_files = scan_directory (filename);
16284
16285 if (dictionary_files != NULL)
16286 {
16287 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16288
16289 for (int d = 0; dictionary_files[d] != NULL; d++)
16290 {
16291 char *l1_filename = dictionary_files[d];
16292
16293 struct stat l1_stat;
16294
16295 if (stat (l1_filename, &l1_stat) == -1)
16296 {
16297 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16298
16299 return (-1);
16300 }
16301
16302 if (S_ISREG (l1_stat.st_mode))
16303 {
16304 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16305
16306 dictcnt++;
16307
16308 dictfiles[dictcnt - 1] = strdup (l1_filename);
16309 }
16310 }
16311 }
16312
16313 local_free (dictionary_files);
16314 }
16315 }
16316
16317 if (dictcnt < 1)
16318 {
16319 log_error ("ERROR: No usable dictionary file found.");
16320
16321 return (-1);
16322 }
16323
16324 if (increment)
16325 {
16326 maskcnt = 0;
16327
16328 uint mask_min = increment_min; // we can't reject smaller masks here
16329 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16330
16331 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16332 {
16333 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16334
16335 if (cur_mask == NULL) break;
16336
16337 masks[maskcnt] = cur_mask;
16338
16339 maskcnt++;
16340
16341 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16342 }
16343 }
16344 }
16345
16346 data.pw_min = pw_min;
16347 data.pw_max = pw_max;
16348
16349 /**
16350 * weak hash check
16351 */
16352
16353 if (weak_hash_threshold >= salts_cnt)
16354 {
16355 hc_device_param_t *device_param = NULL;
16356
16357 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16358 {
16359 device_param = &data.devices_param[device_id];
16360
16361 if (device_param->skipped) continue;
16362
16363 break;
16364 }
16365
16366 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16367
16368 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16369 {
16370 weak_hash_check (device_param, salt_pos);
16371 }
16372
16373 // Display hack, guarantee that there is at least one \r before real start
16374
16375 //if (data.quiet == 0) log_info ("");
16376 }
16377
16378 /**
16379 * status and monitor threads
16380 */
16381
16382 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16383
16384 hc_thread_t i_thread = 0;
16385
16386 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16387 {
16388 hc_thread_create (i_thread, thread_keypress, &benchmark);
16389 }
16390
16391 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16392
16393 uint ni_threads_cnt = 0;
16394
16395 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16396
16397 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16398
16399 ni_threads_cnt++;
16400
16401 /**
16402 * Outfile remove
16403 */
16404
16405 if (keyspace == 0)
16406 {
16407 if (outfile_check_timer != 0)
16408 {
16409 if (data.outfile_check_directory != NULL)
16410 {
16411 if ((hash_mode != 5200) &&
16412 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16413 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16414 (hash_mode != 9000))
16415 {
16416 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16417
16418 ni_threads_cnt++;
16419 }
16420 else
16421 {
16422 outfile_check_timer = 0;
16423 }
16424 }
16425 else
16426 {
16427 outfile_check_timer = 0;
16428 }
16429 }
16430 }
16431
16432 /**
16433 * Inform the user if we got some hashes remove because of the pot file remove feature
16434 */
16435
16436 if (data.quiet == 0)
16437 {
16438 if (potfile_remove_cracks > 0)
16439 {
16440 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16441 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16442 }
16443 }
16444
16445 data.outfile_check_timer = outfile_check_timer;
16446
16447 /**
16448 * main loop
16449 */
16450
16451 char **induction_dictionaries = NULL;
16452
16453 int induction_dictionaries_cnt = 0;
16454
16455 hcstat_table_t *root_table_buf = NULL;
16456 hcstat_table_t *markov_table_buf = NULL;
16457
16458 uint initial_restore_done = 0;
16459
16460 data.maskcnt = maskcnt;
16461
16462 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16463 {
16464 if (data.devices_status == STATUS_CRACKED) break;
16465
16466 data.devices_status = STATUS_INIT;
16467
16468 if (maskpos > rd->maskpos)
16469 {
16470 rd->dictpos = 0;
16471 }
16472
16473 rd->maskpos = maskpos;
16474 data.maskpos = maskpos;
16475
16476 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16477 {
16478 char *mask = masks[maskpos];
16479
16480 if (mask_from_file == 1)
16481 {
16482 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16483
16484 char *str_ptr;
16485 uint str_pos;
16486
16487 uint mask_offset = 0;
16488
16489 uint separator_cnt;
16490
16491 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16492 {
16493 str_ptr = strstr (mask + mask_offset, ",");
16494
16495 if (str_ptr == NULL) break;
16496
16497 str_pos = str_ptr - mask;
16498
16499 // escaped separator, i.e. "\,"
16500
16501 if (str_pos > 0)
16502 {
16503 if (mask[str_pos - 1] == '\\')
16504 {
16505 separator_cnt --;
16506
16507 mask_offset = str_pos + 1;
16508
16509 continue;
16510 }
16511 }
16512
16513 // reset the offset
16514
16515 mask_offset = 0;
16516
16517 mask[str_pos] = '\0';
16518
16519 switch (separator_cnt)
16520 {
16521 case 0:
16522 mp_reset_usr (mp_usr, 0);
16523
16524 custom_charset_1 = mask;
16525 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16526 break;
16527
16528 case 1:
16529 mp_reset_usr (mp_usr, 1);
16530
16531 custom_charset_2 = mask;
16532 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16533 break;
16534
16535 case 2:
16536 mp_reset_usr (mp_usr, 2);
16537
16538 custom_charset_3 = mask;
16539 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16540 break;
16541
16542 case 3:
16543 mp_reset_usr (mp_usr, 3);
16544
16545 custom_charset_4 = mask;
16546 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16547 break;
16548 }
16549
16550 mask = mask + str_pos + 1;
16551 }
16552 }
16553
16554 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16555 {
16556 if (maskpos > 0)
16557 {
16558 local_free (css_buf);
16559 local_free (data.root_css_buf);
16560 local_free (data.markov_css_buf);
16561
16562 local_free (masks[maskpos - 1]);
16563 }
16564
16565 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16566
16567 data.mask = mask;
16568 data.css_cnt = css_cnt;
16569 data.css_buf = css_buf;
16570
16571 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16572
16573 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16574
16575 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16576 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16577
16578 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16579
16580 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16581
16582 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16583 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16584
16585 data.root_css_buf = root_css_buf;
16586 data.markov_css_buf = markov_css_buf;
16587
16588 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16589
16590 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16591
16592 local_free (root_table_buf);
16593 local_free (markov_table_buf);
16594
16595 // args
16596
16597 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16598 {
16599 hc_device_param_t *device_param = &data.devices_param[device_id];
16600
16601 if (device_param->skipped) continue;
16602
16603 device_param->kernel_params_mp[0] = &device_param->d_combs;
16604 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16605 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16606
16607 device_param->kernel_params_mp_buf64[3] = 0;
16608 device_param->kernel_params_mp_buf32[4] = css_cnt;
16609 device_param->kernel_params_mp_buf32[5] = 0;
16610 device_param->kernel_params_mp_buf32[6] = 0;
16611 device_param->kernel_params_mp_buf32[7] = 0;
16612
16613 if (attack_mode == ATTACK_MODE_HYBRID1)
16614 {
16615 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16616 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16617 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16618 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16619 }
16620 else if (attack_mode == ATTACK_MODE_HYBRID2)
16621 {
16622 device_param->kernel_params_mp_buf32[5] = 0;
16623 device_param->kernel_params_mp_buf32[6] = 0;
16624 device_param->kernel_params_mp_buf32[7] = 0;
16625 }
16626
16627 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]);
16628 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]);
16629 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]);
16630
16631 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);
16632 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);
16633 }
16634 }
16635 else if (attack_mode == ATTACK_MODE_BF)
16636 {
16637 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16638
16639 if (increment)
16640 {
16641 for (uint i = 0; i < dictcnt; i++)
16642 {
16643 local_free (dictfiles[i]);
16644 }
16645
16646 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16647 {
16648 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16649
16650 if (l1_filename == NULL) break;
16651
16652 dictcnt++;
16653
16654 dictfiles[dictcnt - 1] = l1_filename;
16655 }
16656 }
16657 else
16658 {
16659 dictcnt++;
16660
16661 dictfiles[dictcnt - 1] = mask;
16662 }
16663
16664 if (dictcnt == 0)
16665 {
16666 log_error ("ERROR: Mask is too small");
16667
16668 return (-1);
16669 }
16670 }
16671 }
16672
16673 free (induction_dictionaries);
16674
16675 // induction_dictionaries_cnt = 0; // implied
16676
16677 if (attack_mode != ATTACK_MODE_BF)
16678 {
16679 if (keyspace == 0)
16680 {
16681 induction_dictionaries = scan_directory (induction_directory);
16682
16683 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16684 }
16685 }
16686
16687 if (induction_dictionaries_cnt)
16688 {
16689 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16690 }
16691
16692 /**
16693 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16694 */
16695 if (keyspace == 1)
16696 {
16697 if ((maskcnt > 1) || (dictcnt > 1))
16698 {
16699 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16700
16701 return (-1);
16702 }
16703 }
16704
16705 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16706 {
16707 char *subid = logfile_generate_subid ();
16708
16709 data.subid = subid;
16710
16711 logfile_sub_msg ("START");
16712
16713 data.devices_status = STATUS_INIT;
16714
16715 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16716 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16717 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16718
16719 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16720
16721 data.cpt_pos = 0;
16722
16723 data.cpt_start = time (NULL);
16724
16725 data.cpt_total = 0;
16726
16727 if (data.restore == 0)
16728 {
16729 rd->words_cur = skip;
16730
16731 skip = 0;
16732
16733 data.skip = 0;
16734 }
16735
16736 data.ms_paused = 0;
16737
16738 data.words_cur = rd->words_cur;
16739
16740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16741 {
16742 hc_device_param_t *device_param = &data.devices_param[device_id];
16743
16744 if (device_param->skipped) continue;
16745
16746 device_param->speed_pos = 0;
16747
16748 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16749 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16750
16751 device_param->exec_pos = 0;
16752
16753 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16754
16755 device_param->kernel_power = device_param->kernel_power_user;
16756
16757 device_param->outerloop_pos = 0;
16758 device_param->outerloop_left = 0;
16759 device_param->innerloop_pos = 0;
16760 device_param->innerloop_left = 0;
16761
16762 // some more resets:
16763
16764 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16765
16766 device_param->pws_cnt = 0;
16767
16768 device_param->words_off = 0;
16769 device_param->words_done = 0;
16770 }
16771
16772 data.kernel_power_div = 0;
16773
16774 // figure out some workload
16775
16776 if (attack_mode == ATTACK_MODE_STRAIGHT)
16777 {
16778 if (data.wordlist_mode == WL_MODE_FILE)
16779 {
16780 char *dictfile = NULL;
16781
16782 if (induction_dictionaries_cnt)
16783 {
16784 dictfile = induction_dictionaries[0];
16785 }
16786 else
16787 {
16788 dictfile = dictfiles[dictpos];
16789 }
16790
16791 data.dictfile = dictfile;
16792
16793 logfile_sub_string (dictfile);
16794
16795 for (uint i = 0; i < rp_files_cnt; i++)
16796 {
16797 logfile_sub_var_string ("rulefile", rp_files[i]);
16798 }
16799
16800 FILE *fd2 = fopen (dictfile, "rb");
16801
16802 if (fd2 == NULL)
16803 {
16804 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16805
16806 return (-1);
16807 }
16808
16809 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16810
16811 fclose (fd2);
16812
16813 if (data.words_cnt == 0)
16814 {
16815 if (data.devices_status == STATUS_CRACKED) break;
16816 if (data.devices_status == STATUS_ABORTED) break;
16817
16818 dictpos++;
16819
16820 continue;
16821 }
16822 }
16823 }
16824 else if (attack_mode == ATTACK_MODE_COMBI)
16825 {
16826 char *dictfile = data.dictfile;
16827 char *dictfile2 = data.dictfile2;
16828
16829 logfile_sub_string (dictfile);
16830 logfile_sub_string (dictfile2);
16831
16832 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16833 {
16834 FILE *fd2 = fopen (dictfile, "rb");
16835
16836 if (fd2 == NULL)
16837 {
16838 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16839
16840 return (-1);
16841 }
16842
16843 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16844
16845 fclose (fd2);
16846 }
16847 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16848 {
16849 FILE *fd2 = fopen (dictfile2, "rb");
16850
16851 if (fd2 == NULL)
16852 {
16853 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16854
16855 return (-1);
16856 }
16857
16858 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16859
16860 fclose (fd2);
16861 }
16862
16863 if (data.words_cnt == 0)
16864 {
16865 if (data.devices_status == STATUS_CRACKED) break;
16866 if (data.devices_status == STATUS_ABORTED) break;
16867
16868 dictpos++;
16869
16870 continue;
16871 }
16872 }
16873 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16874 {
16875 char *dictfile = NULL;
16876
16877 if (induction_dictionaries_cnt)
16878 {
16879 dictfile = induction_dictionaries[0];
16880 }
16881 else
16882 {
16883 dictfile = dictfiles[dictpos];
16884 }
16885
16886 data.dictfile = dictfile;
16887
16888 char *mask = data.mask;
16889
16890 logfile_sub_string (dictfile);
16891 logfile_sub_string (mask);
16892
16893 FILE *fd2 = fopen (dictfile, "rb");
16894
16895 if (fd2 == NULL)
16896 {
16897 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16898
16899 return (-1);
16900 }
16901
16902 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16903
16904 fclose (fd2);
16905
16906 if (data.words_cnt == 0)
16907 {
16908 if (data.devices_status == STATUS_CRACKED) break;
16909 if (data.devices_status == STATUS_ABORTED) break;
16910
16911 dictpos++;
16912
16913 continue;
16914 }
16915 }
16916 else if (attack_mode == ATTACK_MODE_BF)
16917 {
16918 local_free (css_buf);
16919 local_free (data.root_css_buf);
16920 local_free (data.markov_css_buf);
16921
16922 char *mask = dictfiles[dictpos];
16923
16924 logfile_sub_string (mask);
16925
16926 // base
16927
16928 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16929
16930 if (opts_type & OPTS_TYPE_PT_UNICODE)
16931 {
16932 uint css_cnt_unicode = css_cnt * 2;
16933
16934 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16935
16936 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16937 {
16938 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16939
16940 css_buf_unicode[j + 1].cs_buf[0] = 0;
16941 css_buf_unicode[j + 1].cs_len = 1;
16942 }
16943
16944 free (css_buf);
16945
16946 css_buf = css_buf_unicode;
16947 css_cnt = css_cnt_unicode;
16948 }
16949
16950 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16951
16952 uint mask_min = pw_min;
16953 uint mask_max = pw_max;
16954
16955 if (opts_type & OPTS_TYPE_PT_UNICODE)
16956 {
16957 mask_min *= 2;
16958 mask_max *= 2;
16959 }
16960
16961 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16962 {
16963 if (css_cnt < mask_min)
16964 {
16965 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16966 }
16967
16968 if (css_cnt > mask_max)
16969 {
16970 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16971 }
16972
16973 // skip to next mask
16974
16975 dictpos++;
16976
16977 rd->dictpos = dictpos;
16978
16979 logfile_sub_msg ("STOP");
16980
16981 continue;
16982 }
16983
16984 uint save_css_cnt = css_cnt;
16985
16986 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16987 {
16988 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16989 {
16990 uint salt_len = (uint) data.salts_buf[0].salt_len;
16991 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16992
16993 uint css_cnt_salt = css_cnt + salt_len;
16994
16995 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16996
16997 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16998
16999 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17000 {
17001 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17002 css_buf_salt[j].cs_len = 1;
17003 }
17004
17005 free (css_buf);
17006
17007 css_buf = css_buf_salt;
17008 css_cnt = css_cnt_salt;
17009 }
17010 }
17011
17012 data.mask = mask;
17013 data.css_cnt = css_cnt;
17014 data.css_buf = css_buf;
17015
17016 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17017
17018 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17019
17020 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17021
17022 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17023 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17024
17025 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17026
17027 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17028
17029 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17030 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17031
17032 data.root_css_buf = root_css_buf;
17033 data.markov_css_buf = markov_css_buf;
17034
17035 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17036
17037 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17038
17039 local_free (root_table_buf);
17040 local_free (markov_table_buf);
17041
17042 // copy + args
17043
17044 uint css_cnt_l = css_cnt;
17045 uint css_cnt_r;
17046
17047 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17048 {
17049 if (save_css_cnt < 6)
17050 {
17051 css_cnt_r = 1;
17052 }
17053 else if (save_css_cnt == 6)
17054 {
17055 css_cnt_r = 2;
17056 }
17057 else
17058 {
17059 if (opts_type & OPTS_TYPE_PT_UNICODE)
17060 {
17061 if (save_css_cnt == 8 || save_css_cnt == 10)
17062 {
17063 css_cnt_r = 2;
17064 }
17065 else
17066 {
17067 css_cnt_r = 4;
17068 }
17069 }
17070 else
17071 {
17072 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17073 {
17074 css_cnt_r = 3;
17075 }
17076 else
17077 {
17078 css_cnt_r = 4;
17079 }
17080 }
17081 }
17082 }
17083 else
17084 {
17085 css_cnt_r = 1;
17086
17087 /* unfinished code?
17088 int sum = css_buf[css_cnt_r - 1].cs_len;
17089
17090 for (uint i = 1; i < 4 && i < css_cnt; i++)
17091 {
17092 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17093
17094 css_cnt_r++;
17095
17096 sum *= css_buf[css_cnt_r - 1].cs_len;
17097 }
17098 */
17099 }
17100
17101 css_cnt_l -= css_cnt_r;
17102
17103 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17104
17105 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17106 {
17107 hc_device_param_t *device_param = &data.devices_param[device_id];
17108
17109 if (device_param->skipped) continue;
17110
17111 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17112 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17113 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17114
17115 device_param->kernel_params_mp_l_buf64[3] = 0;
17116 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17117 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17118 device_param->kernel_params_mp_l_buf32[6] = 0;
17119 device_param->kernel_params_mp_l_buf32[7] = 0;
17120 device_param->kernel_params_mp_l_buf32[8] = 0;
17121
17122 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17123 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17124 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17125 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17126
17127 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17128 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17129 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17130
17131 device_param->kernel_params_mp_r_buf64[3] = 0;
17132 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17133 device_param->kernel_params_mp_r_buf32[5] = 0;
17134 device_param->kernel_params_mp_r_buf32[6] = 0;
17135 device_param->kernel_params_mp_r_buf32[7] = 0;
17136
17137 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]);
17138 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]);
17139 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]);
17140
17141 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]);
17142 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]);
17143 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]);
17144
17145 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);
17146 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);
17147 }
17148 }
17149
17150 u64 words_base = data.words_cnt;
17151
17152 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17153 {
17154 if (data.kernel_rules_cnt)
17155 {
17156 words_base /= data.kernel_rules_cnt;
17157 }
17158 }
17159 else if (data.attack_kern == ATTACK_KERN_COMBI)
17160 {
17161 if (data.combs_cnt)
17162 {
17163 words_base /= data.combs_cnt;
17164 }
17165 }
17166 else if (data.attack_kern == ATTACK_KERN_BF)
17167 {
17168 if (data.bfs_cnt)
17169 {
17170 words_base /= data.bfs_cnt;
17171 }
17172 }
17173
17174 data.words_base = words_base;
17175
17176 if (keyspace == 1)
17177 {
17178 log_info ("%llu", (unsigned long long int) words_base);
17179
17180 return (0);
17181 }
17182
17183 if (data.words_cur > data.words_base)
17184 {
17185 log_error ("ERROR: restore value greater keyspace");
17186
17187 return (-1);
17188 }
17189
17190 if (data.words_cur)
17191 {
17192 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17193 {
17194 for (uint i = 0; i < data.salts_cnt; i++)
17195 {
17196 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17197 }
17198 }
17199 else if (data.attack_kern == ATTACK_KERN_COMBI)
17200 {
17201 for (uint i = 0; i < data.salts_cnt; i++)
17202 {
17203 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17204 }
17205 }
17206 else if (data.attack_kern == ATTACK_KERN_BF)
17207 {
17208 for (uint i = 0; i < data.salts_cnt; i++)
17209 {
17210 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17211 }
17212 }
17213 }
17214
17215 /*
17216 * Inform user about possible slow speeds
17217 */
17218
17219 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17220 {
17221 if (data.words_base < kernel_power_all)
17222 {
17223 if (quiet == 0)
17224 {
17225 log_info ("ATTENTION!");
17226 log_info (" The wordlist or mask you are using is too small.");
17227 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17228 log_info (" The cracking speed will drop.");
17229 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17230 log_info ("");
17231 }
17232 }
17233 }
17234
17235 /*
17236 * Update loopback file
17237 */
17238
17239 if (loopback == 1)
17240 {
17241 time_t now;
17242
17243 time (&now);
17244
17245 uint random_num = get_random_num (0, 9999);
17246
17247 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17248
17249 data.loopback_file = loopback_file;
17250 }
17251
17252 /*
17253 * Update dictionary statistic
17254 */
17255
17256 if (keyspace == 0)
17257 {
17258 dictstat_fp = fopen (dictstat, "wb");
17259
17260 if (dictstat_fp)
17261 {
17262 lock_file (dictstat_fp);
17263
17264 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17265
17266 fclose (dictstat_fp);
17267 }
17268 }
17269
17270 data.devices_status = STATUS_RUNNING;
17271
17272 if (initial_restore_done == 0)
17273 {
17274 if (data.restore_disable == 0) cycle_restore ();
17275
17276 initial_restore_done = 1;
17277 }
17278
17279 hc_timer_set (&data.timer_running);
17280
17281 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17282 {
17283 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17284 {
17285 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17286 if (quiet == 0) fflush (stdout);
17287 }
17288 }
17289 else if (wordlist_mode == WL_MODE_STDIN)
17290 {
17291 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17292 if (data.quiet == 0) log_info ("");
17293 }
17294
17295 time_t runtime_start;
17296
17297 time (&runtime_start);
17298
17299 data.runtime_start = runtime_start;
17300
17301 /**
17302 * create cracker threads
17303 */
17304
17305 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17306
17307 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17308 {
17309 hc_device_param_t *device_param = &devices_param[device_id];
17310
17311 if (wordlist_mode == WL_MODE_STDIN)
17312 {
17313 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17314 }
17315 else
17316 {
17317 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17318 }
17319 }
17320
17321 // wait for crack threads to exit
17322
17323 hc_thread_wait (data.devices_cnt, c_threads);
17324
17325 local_free (c_threads);
17326
17327 data.restore = 0;
17328
17329 // finalize task
17330
17331 logfile_sub_var_uint ("status-after-work", data.devices_status);
17332
17333 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17334
17335 if (data.devices_status == STATUS_CRACKED) break;
17336 if (data.devices_status == STATUS_ABORTED) break;
17337
17338 if (data.devices_status == STATUS_BYPASS)
17339 {
17340 data.devices_status = STATUS_RUNNING;
17341 }
17342
17343 if (induction_dictionaries_cnt)
17344 {
17345 unlink (induction_dictionaries[0]);
17346 }
17347
17348 free (induction_dictionaries);
17349
17350 if (attack_mode != ATTACK_MODE_BF)
17351 {
17352 induction_dictionaries = scan_directory (induction_directory);
17353
17354 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17355 }
17356
17357 if (benchmark == 0)
17358 {
17359 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17360 {
17361 if (quiet == 0) clear_prompt ();
17362
17363 if (quiet == 0) log_info ("");
17364
17365 if (status == 1)
17366 {
17367 status_display ();
17368 }
17369 else
17370 {
17371 if (quiet == 0) status_display ();
17372 }
17373
17374 if (quiet == 0) log_info ("");
17375 }
17376 }
17377
17378 if (attack_mode == ATTACK_MODE_BF)
17379 {
17380 dictpos++;
17381
17382 rd->dictpos = dictpos;
17383 }
17384 else
17385 {
17386 if (induction_dictionaries_cnt)
17387 {
17388 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17389 }
17390 else
17391 {
17392 dictpos++;
17393
17394 rd->dictpos = dictpos;
17395 }
17396 }
17397
17398 time_t runtime_stop;
17399
17400 time (&runtime_stop);
17401
17402 data.runtime_stop = runtime_stop;
17403
17404 logfile_sub_uint (runtime_start);
17405 logfile_sub_uint (runtime_stop);
17406
17407 logfile_sub_msg ("STOP");
17408
17409 global_free (subid);
17410 }
17411
17412 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17413
17414 if (data.devices_status == STATUS_CRACKED) break;
17415 if (data.devices_status == STATUS_ABORTED) break;
17416 if (data.devices_status == STATUS_QUIT) break;
17417
17418 if (data.devices_status == STATUS_BYPASS)
17419 {
17420 data.devices_status = STATUS_RUNNING;
17421 }
17422 }
17423
17424 // 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
17425
17426 if (attack_mode == ATTACK_MODE_STRAIGHT)
17427 {
17428 if (data.wordlist_mode == WL_MODE_FILE)
17429 {
17430 if (data.dictfile == NULL)
17431 {
17432 if (dictfiles != NULL)
17433 {
17434 data.dictfile = dictfiles[0];
17435
17436 hc_timer_set (&data.timer_running);
17437 }
17438 }
17439 }
17440 }
17441 // NOTE: combi is okay because it is already set beforehand
17442 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17443 {
17444 if (data.dictfile == NULL)
17445 {
17446 if (dictfiles != NULL)
17447 {
17448 hc_timer_set (&data.timer_running);
17449
17450 data.dictfile = dictfiles[0];
17451 }
17452 }
17453 }
17454 else if (attack_mode == ATTACK_MODE_BF)
17455 {
17456 if (data.mask == NULL)
17457 {
17458 hc_timer_set (&data.timer_running);
17459
17460 data.mask = masks[0];
17461 }
17462 }
17463
17464 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17465 {
17466 data.devices_status = STATUS_EXHAUSTED;
17467 }
17468
17469 // if cracked / aborted remove last induction dictionary
17470
17471 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17472 {
17473 struct stat induct_stat;
17474
17475 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17476 {
17477 unlink (induction_dictionaries[file_pos]);
17478 }
17479 }
17480
17481 // wait for non-interactive threads
17482
17483 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17484 {
17485 hc_thread_wait (1, &ni_threads[thread_idx]);
17486 }
17487
17488 local_free (ni_threads);
17489
17490 // wait for interactive threads
17491
17492 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17493 {
17494 hc_thread_wait (1, &i_thread);
17495 }
17496
17497 // we dont need restore file anymore
17498 if (data.restore_disable == 0)
17499 {
17500 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17501 {
17502 unlink (eff_restore_file);
17503 unlink (new_restore_file);
17504 }
17505 else
17506 {
17507 cycle_restore ();
17508 }
17509 }
17510
17511 // finally save left hashes
17512
17513 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17514 {
17515 save_hash ();
17516 }
17517
17518 /**
17519 * Clean up
17520 */
17521
17522 if (benchmark == 1)
17523 {
17524 status_benchmark ();
17525
17526 if (status_automat == 0)
17527 {
17528 log_info ("");
17529 }
17530 }
17531 else
17532 {
17533 if (quiet == 0) clear_prompt ();
17534
17535 if (quiet == 0) log_info ("");
17536
17537 if (status == 1)
17538 {
17539 status_display ();
17540 }
17541 else
17542 {
17543 if (quiet == 0) status_display ();
17544 }
17545
17546 if (quiet == 0) log_info ("");
17547 }
17548
17549 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17550 {
17551 hc_device_param_t *device_param = &data.devices_param[device_id];
17552
17553 if (device_param->skipped) continue;
17554
17555 local_free (device_param->result);
17556
17557 local_free (device_param->combs_buf);
17558
17559 local_free (device_param->hooks_buf);
17560
17561 local_free (device_param->device_name);
17562
17563 local_free (device_param->device_name_chksum);
17564
17565 local_free (device_param->device_version);
17566
17567 local_free (device_param->driver_version);
17568
17569 if (device_param->pws_buf) myfree (device_param->pws_buf);
17570 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17571 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17572 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17573 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17574 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17575 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17576 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17577 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17578 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17579 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17580 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17581 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17582 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17583 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17584 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17585 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17586 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17587 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17588 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17589 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17590 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17591 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17592 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17593 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17594 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17595 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17596 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17597 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17598
17599 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17600 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17601 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17602 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17603 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17604 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17605 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17606 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17607 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17608 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17609
17610 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17611 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17612 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17613
17614 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17615 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17616 }
17617
17618 // reset default fan speed
17619
17620 #ifdef HAVE_HWMON
17621 if (gpu_temp_disable == 0)
17622 {
17623 #ifdef HAVE_ADL
17624 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17625 {
17626 hc_thread_mutex_lock (mux_adl);
17627
17628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17629 {
17630 hc_device_param_t *device_param = &data.devices_param[device_id];
17631
17632 if (device_param->skipped) continue;
17633
17634 if (data.hm_device[device_id].fan_supported == 1)
17635 {
17636 int fanspeed = temp_retain_fanspeed_value[device_id];
17637
17638 if (fanspeed == -1) continue;
17639
17640 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17641
17642 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17643 }
17644 }
17645
17646 hc_thread_mutex_unlock (mux_adl);
17647 }
17648 #endif // HAVE_ADL
17649 }
17650
17651 #ifdef HAVE_ADL
17652 // reset power tuning
17653
17654 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17655 {
17656 hc_thread_mutex_lock (mux_adl);
17657
17658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17659 {
17660 hc_device_param_t *device_param = &data.devices_param[device_id];
17661
17662 if (device_param->skipped) continue;
17663
17664 if (data.hm_device[device_id].od_version == 6)
17665 {
17666 // check powertune capabilities first, if not available then skip device
17667
17668 int powertune_supported = 0;
17669
17670 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17671 {
17672 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17673
17674 return (-1);
17675 }
17676
17677 if (powertune_supported != 0)
17678 {
17679 // powercontrol settings
17680
17681 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)
17682 {
17683 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17684
17685 return (-1);
17686 }
17687
17688 // clocks
17689
17690 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17691
17692 performance_state->iNumberOfPerformanceLevels = 2;
17693
17694 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17695 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17696 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17697 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17698
17699 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)
17700 {
17701 log_info ("ERROR: Failed to restore ADL performance state");
17702
17703 return (-1);
17704 }
17705
17706 local_free (performance_state);
17707 }
17708 }
17709 }
17710
17711 hc_thread_mutex_unlock (mux_adl);
17712 }
17713 #endif // HAVE_ADL
17714
17715 if (gpu_temp_disable == 0)
17716 {
17717 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17718 if (data.hm_nv)
17719 {
17720 #if defined(LINUX) && defined(HAVE_NVML)
17721
17722 hm_NVML_nvmlShutdown (data.hm_nv);
17723
17724 nvml_close (data.hm_nv);
17725
17726 #elif defined(WIN) && (HAVE_NVAPI)
17727
17728 hm_NvAPI_Unload (data.hm_nv);
17729
17730 nvapi_close (data.hm_nv);
17731
17732 #endif
17733
17734 data.hm_nv = NULL;
17735 }
17736 #endif
17737
17738 #ifdef HAVE_ADL
17739 if (data.hm_amd)
17740 {
17741 hm_ADL_Main_Control_Destroy (data.hm_amd);
17742
17743 adl_close (data.hm_amd);
17744 data.hm_amd = NULL;
17745 }
17746 #endif
17747 }
17748 #endif // HAVE_HWMON
17749
17750 // free memory
17751
17752 local_free (masks);
17753
17754 local_free (dictstat_base);
17755
17756 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17757 {
17758 pot_t *pot_ptr = &pot[pot_pos];
17759
17760 hash_t *hash = &pot_ptr->hash;
17761
17762 local_free (hash->digest);
17763
17764 if (isSalted)
17765 {
17766 local_free (hash->salt);
17767 }
17768 }
17769
17770 local_free (pot);
17771
17772 local_free (all_kernel_rules_cnt);
17773 local_free (all_kernel_rules_buf);
17774
17775 local_free (wl_data->buf);
17776 local_free (wl_data);
17777
17778 local_free (bitmap_s1_a);
17779 local_free (bitmap_s1_b);
17780 local_free (bitmap_s1_c);
17781 local_free (bitmap_s1_d);
17782 local_free (bitmap_s2_a);
17783 local_free (bitmap_s2_b);
17784 local_free (bitmap_s2_c);
17785 local_free (bitmap_s2_d);
17786
17787 #ifdef HAVE_HWMON
17788 local_free (temp_retain_fanspeed_value);
17789 #ifdef HAVE_ADL
17790 local_free (od_clock_mem_status);
17791 local_free (od_power_control_status);
17792 #endif // ADL
17793 #endif
17794
17795 global_free (devices_param);
17796
17797 global_free (kernel_rules_buf);
17798
17799 global_free (root_css_buf);
17800 global_free (markov_css_buf);
17801
17802 global_free (digests_buf);
17803 global_free (digests_shown);
17804 global_free (digests_shown_tmp);
17805
17806 global_free (salts_buf);
17807 global_free (salts_shown);
17808
17809 global_free (esalts_buf);
17810
17811 global_free (words_progress_done);
17812 global_free (words_progress_rejected);
17813 global_free (words_progress_restored);
17814
17815 if (pot_fp) fclose (pot_fp);
17816
17817 if (data.devices_status == STATUS_QUIT) break;
17818 }
17819
17820 // destroy others mutex
17821
17822 hc_thread_mutex_delete (mux_dispatcher);
17823 hc_thread_mutex_delete (mux_counter);
17824 hc_thread_mutex_delete (mux_display);
17825 hc_thread_mutex_delete (mux_adl);
17826
17827 // free memory
17828
17829 local_free (eff_restore_file);
17830 local_free (new_restore_file);
17831
17832 local_free (rd);
17833
17834 // tuning db
17835
17836 tuning_db_destroy (tuning_db);
17837
17838 // loopback
17839
17840 local_free (loopback_file);
17841
17842 if (loopback == 1) unlink (loopback_file);
17843
17844 // induction directory
17845
17846 if (induction_dir == NULL)
17847 {
17848 if (attack_mode != ATTACK_MODE_BF)
17849 {
17850 if (rmdir (induction_directory) == -1)
17851 {
17852 if (errno == ENOENT)
17853 {
17854 // good, we can ignore
17855 }
17856 else if (errno == ENOTEMPTY)
17857 {
17858 // good, we can ignore
17859 }
17860 else
17861 {
17862 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17863
17864 return (-1);
17865 }
17866 }
17867
17868 local_free (induction_directory);
17869 }
17870 }
17871
17872 // outfile-check directory
17873
17874 if (outfile_check_dir == NULL)
17875 {
17876 if (rmdir (outfile_check_directory) == -1)
17877 {
17878 if (errno == ENOENT)
17879 {
17880 // good, we can ignore
17881 }
17882 else if (errno == ENOTEMPTY)
17883 {
17884 // good, we can ignore
17885 }
17886 else
17887 {
17888 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17889
17890 return (-1);
17891 }
17892 }
17893
17894 local_free (outfile_check_directory);
17895 }
17896
17897 time_t proc_stop;
17898
17899 time (&proc_stop);
17900
17901 logfile_top_uint (proc_start);
17902 logfile_top_uint (proc_stop);
17903
17904 logfile_top_msg ("STOP");
17905
17906 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17907 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17908
17909 if (data.ocl) ocl_close (data.ocl);
17910
17911 if (data.devices_status == STATUS_ABORTED) return 2;
17912 if (data.devices_status == STATUS_QUIT) return 2;
17913 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17914 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17915 if (data.devices_status == STATUS_CRACKED) return 0;
17916
17917 return -1;
17918 }
Hashcat additions to support pwdhash