projects / hashcat.git / blob
? search:


c311e1c313106feed27d708331ecd0c81fc406b7
[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 137
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 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 double hashes_all_ms = 0;
1164
1165 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_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 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 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);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 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);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark_automat ()
1612 {
1613 u64 speed_cnt[DEVICES_MAX] = { 0 };
1614 double speed_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 speed_cnt[device_id] = device_param->speed_cnt[0];
1623 speed_ms[device_id] = device_param->speed_ms[0];
1624 }
1625
1626 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 hashes_dev_ms[device_id] = 0;
1635
1636 if (speed_ms[device_id])
1637 {
1638 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1639 }
1640 }
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1649 }
1650 }
1651
1652 static void status_benchmark ()
1653 {
1654 if (data.devices_status == STATUS_INIT) return;
1655 if (data.devices_status == STATUS_STARTING) return;
1656 if (data.devices_status == STATUS_BYPASS) return;
1657
1658 if (data.status_automat == 1)
1659 {
1660 status_benchmark_automat ();
1661
1662 return;
1663 }
1664
1665 u64 speed_cnt[DEVICES_MAX] = { 0 };
1666 double speed_ms[DEVICES_MAX] = { 0 };
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 speed_cnt[device_id] = device_param->speed_cnt[0];
1675 speed_ms[device_id] = device_param->speed_ms[0];
1676 }
1677
1678 double hashes_all_ms = 0;
1679
1680 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 hashes_dev_ms[device_id] = 0;
1689
1690 if (speed_ms[device_id])
1691 {
1692 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1693
1694 hashes_all_ms += hashes_dev_ms[device_id];
1695 }
1696 }
1697
1698 /**
1699 * exec time
1700 */
1701
1702 double exec_all_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 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1711
1712 exec_all_ms[device_id] = exec_ms_avg;
1713 }
1714
1715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1716 {
1717 hc_device_param_t *device_param = &data.devices_param[device_id];
1718
1719 if (device_param->skipped) continue;
1720
1721 char display_dev_cur[16] = { 0 };
1722
1723 strncpy (display_dev_cur, "0.00", 4);
1724
1725 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1726
1727 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1728 }
1729
1730 char display_all_cur[16] = { 0 };
1731
1732 strncpy (display_all_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1735
1736 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1737 }
1738
1739 /**
1740 * hashcat -only- functions
1741 */
1742
1743 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1744 {
1745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1746 {
1747 if (attack_kern == ATTACK_KERN_STRAIGHT)
1748 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1749 else if (attack_kern == ATTACK_KERN_COMBI)
1750 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1751 else if (attack_kern == ATTACK_KERN_BF)
1752 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1753 }
1754 else
1755 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1756 }
1757
1758 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)
1759 {
1760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1761 {
1762 if (attack_kern == ATTACK_KERN_STRAIGHT)
1763 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 else if (attack_kern == ATTACK_KERN_COMBI)
1765 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1766 else if (attack_kern == ATTACK_KERN_BF)
1767 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1768 }
1769 else
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1772 }
1773 }
1774
1775 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1780 }
1781 else
1782 {
1783 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1784 }
1785 }
1786
1787 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)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1792 }
1793 else
1794 {
1795 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1796 }
1797 }
1798
1799 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1802 }
1803
1804 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1807 }
1808
1809 static uint convert_from_hex (char *line_buf, const uint line_len)
1810 {
1811 if (line_len & 1) return (line_len); // not in hex
1812
1813 if (data.hex_wordlist == 1)
1814 {
1815 uint i;
1816 uint j;
1817
1818 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1819 {
1820 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1821 }
1822
1823 memset (line_buf + i, 0, line_len - i);
1824
1825 return (i);
1826 }
1827 else if (line_len >= 6) // $HEX[] = 6
1828 {
1829 if (line_buf[0] != '$') return (line_len);
1830 if (line_buf[1] != 'H') return (line_len);
1831 if (line_buf[2] != 'E') return (line_len);
1832 if (line_buf[3] != 'X') return (line_len);
1833 if (line_buf[4] != '[') return (line_len);
1834 if (line_buf[line_len - 1] != ']') return (line_len);
1835
1836 uint i;
1837 uint j;
1838
1839 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1840 {
1841 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1842 }
1843
1844 memset (line_buf + i, 0, line_len - i);
1845
1846 return (i);
1847 }
1848
1849 return (line_len);
1850 }
1851
1852 static void clear_prompt ()
1853 {
1854 fputc ('\r', stdout);
1855
1856 for (size_t i = 0; i < strlen (PROMPT); i++)
1857 {
1858 fputc (' ', stdout);
1859 }
1860
1861 fputc ('\r', stdout);
1862
1863 fflush (stdout);
1864 }
1865
1866 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1867 {
1868 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);
1869 }
1870
1871 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1872 {
1873 char *outfile = data.outfile;
1874 uint quiet = data.quiet;
1875 FILE *pot_fp = data.pot_fp;
1876 uint loopback = data.loopback;
1877 uint debug_mode = data.debug_mode;
1878 char *debug_file = data.debug_file;
1879
1880 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1881 int debug_rule_len = 0; // -1 error
1882 uint debug_plain_len = 0;
1883
1884 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1885
1886 // hash
1887
1888 char out_buf[HCBUFSIZ] = { 0 };
1889
1890 ascii_digest (out_buf, salt_pos, digest_pos);
1891
1892 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1893
1894 // plain
1895
1896 plain_t plain;
1897
1898 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);
1899
1900 uint gidvid = plain.gidvid;
1901 uint il_pos = plain.il_pos;
1902
1903 u64 crackpos = device_param->words_off;
1904
1905 uint plain_buf[16] = { 0 };
1906
1907 u8 *plain_ptr = (u8 *) plain_buf;
1908 unsigned int plain_len = 0;
1909
1910 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 const uint off = device_param->innerloop_pos + il_pos;
1927
1928 if (debug_mode > 0)
1929 {
1930 debug_rule_len = 0;
1931
1932 // save rule
1933 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1936
1937 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1938 }
1939
1940 // save plain
1941 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1942 {
1943 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1944
1945 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1946
1947 debug_plain_len = plain_len;
1948 }
1949 }
1950
1951 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1952
1953 crackpos += gidvid;
1954 crackpos *= data.kernel_rules_cnt;
1955 crackpos += device_param->innerloop_pos + il_pos;
1956
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 else if (data.attack_mode == ATTACK_MODE_COMBI)
1960 {
1961 u64 gidd = gidvid;
1962 u64 gidm = 0;
1963
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidd, &pw);
1967
1968 for (int i = 0, j = gidm; i < 16; i++, j++)
1969 {
1970 plain_buf[i] = pw.i[j];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 u64 gidd = gidvid;
2023 u64 gidm = 0;
2024
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidd, &pw);
2028
2029 for (int i = 0, j = gidm; i < 16; i++, j++)
2030 {
2031 plain_buf[i] = pw.i[j];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 u64 gidd = gidvid;
2057 u64 gidm = 0;
2058
2059 pw_t pw;
2060
2061 gidd_to_pw_t (device_param, gidd, &pw);
2062
2063 for (int i = 0, j = gidm; i < 16; i++, j++)
2064 {
2065 plain_buf[i] = pw.i[j];
2066 }
2067
2068 plain_len = pw.pw_len;
2069
2070 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2071
2072 uint start = 0;
2073 uint stop = device_param->kernel_params_mp_buf32[4];
2074
2075 memmove (plain_ptr + stop, plain_ptr, plain_len);
2076
2077 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090
2091 if (data.attack_mode == ATTACK_MODE_BF)
2092 {
2093 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2094 {
2095 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2096 {
2097 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2098 {
2099 plain_len = plain_len - data.salts_buf[0].salt_len;
2100 }
2101 }
2102
2103 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2104 {
2105 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2106 {
2107 plain_ptr[j] = plain_ptr[i];
2108 }
2109
2110 plain_len = plain_len / 2;
2111 }
2112 }
2113 }
2114
2115 // if enabled, update also the potfile
2116
2117 if (pot_fp)
2118 {
2119 lock_file (pot_fp);
2120
2121 fprintf (pot_fp, "%s:", out_buf);
2122
2123 format_plain (pot_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', pot_fp);
2126
2127 fflush (pot_fp);
2128
2129 unlock_file (pot_fp);
2130 }
2131
2132 // outfile
2133
2134 FILE *out_fp = NULL;
2135
2136 if (outfile != NULL)
2137 {
2138 if ((out_fp = fopen (outfile, "ab")) == NULL)
2139 {
2140 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2141
2142 out_fp = stdout;
2143 }
2144 lock_file (out_fp);
2145 }
2146 else
2147 {
2148 out_fp = stdout;
2149
2150 if (quiet == 0) clear_prompt ();
2151 }
2152
2153 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2154
2155 if (outfile != NULL)
2156 {
2157 if (out_fp != stdout)
2158 {
2159 fclose (out_fp);
2160 }
2161 }
2162 else
2163 {
2164 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2165 {
2166 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2167 {
2168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2169 if (quiet == 0) fflush (stdout);
2170 }
2171 }
2172 }
2173
2174 // loopback
2175
2176 if (loopback)
2177 {
2178 char *loopback_file = data.loopback_file;
2179
2180 FILE *fb_fp = NULL;
2181
2182 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2183 {
2184 lock_file (fb_fp);
2185
2186 format_plain (fb_fp, plain_ptr, plain_len, 1);
2187
2188 fputc ('\n', fb_fp);
2189
2190 fclose (fb_fp);
2191 }
2192 }
2193
2194 // (rule) debug mode
2195
2196 // the next check implies that:
2197 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2198 // - debug_mode > 0
2199
2200 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2201 {
2202 if (debug_rule_len < 0) debug_rule_len = 0;
2203
2204 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2205
2206 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2207
2208 if ((quiet == 0) && (debug_file == NULL))
2209 {
2210 fprintf (stdout, "%s", PROMPT);
2211
2212 fflush (stdout);
2213 }
2214 }
2215 }
2216
2217 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2218 {
2219 salt_t *salt_buf = &data.salts_buf[salt_pos];
2220
2221 int found = 0;
2222
2223 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);
2224
2225 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2226
2227 if (found == 1)
2228 {
2229 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2230
2231 log_info_nn ("");
2232
2233 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);
2234
2235 uint cpt_cracked = 0;
2236
2237 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2238 {
2239 uint idx = salt_buf->digests_offset + digest_pos;
2240
2241 if (data.digests_shown_tmp[idx] == 0) continue;
2242
2243 if (data.digests_shown[idx] == 1) continue;
2244
2245 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2246 {
2247 data.digests_shown[idx] = 1;
2248
2249 data.digests_done++;
2250
2251 cpt_cracked++;
2252
2253 salt_buf->digests_done++;
2254
2255 if (salt_buf->digests_done == salt_buf->digests_cnt)
2256 {
2257 data.salts_shown[salt_pos] = 1;
2258
2259 data.salts_done++;
2260 }
2261 }
2262
2263 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2264
2265 check_hash (device_param, salt_pos, digest_pos);
2266 }
2267
2268 if (cpt_cracked > 0)
2269 {
2270 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2271 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2272
2273 data.cpt_pos++;
2274
2275 data.cpt_total += cpt_cracked;
2276
2277 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2278 }
2279
2280 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2281 {
2282 // we need to reset cracked state on the device
2283 // otherwise host thinks again and again the hash was cracked
2284 // and returns invalid password each time
2285
2286 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2287
2288 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);
2289 }
2290
2291 memset (device_param->result, 0, device_param->size_results);
2292
2293 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);
2294 }
2295 }
2296
2297 static void save_hash ()
2298 {
2299 char *hashfile = data.hashfile;
2300
2301 char new_hashfile[256] = { 0 };
2302 char old_hashfile[256] = { 0 };
2303
2304 snprintf (new_hashfile, 255, "%s.new", hashfile);
2305 snprintf (old_hashfile, 255, "%s.old", hashfile);
2306
2307 unlink (new_hashfile);
2308
2309 char separator = data.separator;
2310
2311 FILE *fp = fopen (new_hashfile, "wb");
2312
2313 if (fp == NULL)
2314 {
2315 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2321 {
2322 if (data.salts_shown[salt_pos] == 1) continue;
2323
2324 salt_t *salt_buf = &data.salts_buf[salt_pos];
2325
2326 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2327 {
2328 uint idx = salt_buf->digests_offset + digest_pos;
2329
2330 if (data.digests_shown[idx] == 1) continue;
2331
2332 if (data.hash_mode != 2500)
2333 {
2334 char out_buf[HCBUFSIZ] = { 0 };
2335
2336 if (data.username == 1)
2337 {
2338 user_t *user = data.hash_info[idx]->user;
2339
2340 uint i;
2341
2342 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2343
2344 fputc (separator, fp);
2345 }
2346
2347 ascii_digest (out_buf, salt_pos, digest_pos);
2348
2349 fputs (out_buf, fp);
2350
2351 log_out (fp, "");
2352 }
2353 else
2354 {
2355 hccap_t hccap;
2356
2357 to_hccap_t (&hccap, salt_pos, digest_pos);
2358
2359 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2360 }
2361 }
2362 }
2363
2364 fflush (fp);
2365
2366 fclose (fp);
2367
2368 unlink (old_hashfile);
2369
2370 if (rename (hashfile, old_hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (hashfile);
2378
2379 if (rename (new_hashfile, hashfile) != 0)
2380 {
2381 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2382
2383 exit (-1);
2384 }
2385
2386 unlink (old_hashfile);
2387 }
2388
2389 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2390 {
2391 // function called only in case kernel_power_all > words_left
2392
2393 float kernel_power_div = (float) (total_left) / kernel_power_all;
2394
2395 kernel_power_div += kernel_power_div / 100;
2396
2397 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2398
2399 while (kernel_power_new < total_left)
2400 {
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404 }
2405
2406 if (data.quiet == 0)
2407 {
2408 clear_prompt ();
2409
2410 //log_info ("");
2411
2412 log_info ("INFO: approaching final keyspace, workload adjusted");
2413 log_info ("");
2414
2415 fprintf (stdout, "%s", PROMPT);
2416
2417 fflush (stdout);
2418 }
2419
2420 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2421
2422 return kernel_power_div;
2423 }
2424
2425 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2426 {
2427 uint num_elements = num;
2428
2429 device_param->kernel_params_buf32[30] = data.combs_mode;
2430 device_param->kernel_params_buf32[31] = num;
2431
2432 uint kernel_threads = device_param->kernel_threads;
2433
2434 while (num_elements % kernel_threads) num_elements++;
2435
2436 cl_kernel kernel = NULL;
2437
2438 switch (kern_run)
2439 {
2440 case KERN_RUN_1: kernel = device_param->kernel1; break;
2441 case KERN_RUN_12: kernel = device_param->kernel12; break;
2442 case KERN_RUN_2: kernel = device_param->kernel2; break;
2443 case KERN_RUN_23: kernel = device_param->kernel23; break;
2444 case KERN_RUN_3: kernel = device_param->kernel3; break;
2445 }
2446
2447 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2448 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2449 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2450 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2451 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2452 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2453 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2454 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2455 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2456 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2457 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2458
2459 cl_event event;
2460
2461 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2462 {
2463 const size_t global_work_size[3] = { num_elements, 32, 1 };
2464 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468 else
2469 {
2470 if (kern_run == KERN_RUN_2)
2471 {
2472 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2473 {
2474 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2475 }
2476 }
2477
2478 while (num_elements % kernel_threads) num_elements++;
2479
2480 const size_t global_work_size[3] = { num_elements, 1, 1 };
2481 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2482
2483 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2484 }
2485
2486 hc_clFlush (data.ocl, device_param->command_queue);
2487
2488 hc_clWaitForEvents (data.ocl, 1, &event);
2489
2490 if (event_update)
2491 {
2492 cl_ulong time_start;
2493 cl_ulong time_end;
2494
2495 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2496 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2497
2498 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2499
2500 uint exec_pos = device_param->exec_pos;
2501
2502 device_param->exec_ms[exec_pos] = exec_time;
2503
2504 exec_pos++;
2505
2506 if (exec_pos == EXEC_CACHE)
2507 {
2508 exec_pos = 0;
2509 }
2510
2511 device_param->exec_pos = exec_pos;
2512 }
2513
2514 hc_clReleaseEvent (data.ocl, event);
2515
2516 hc_clFinish (data.ocl, device_param->command_queue);
2517 }
2518
2519 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2520 {
2521 uint num_elements = num;
2522
2523 switch (kern_run)
2524 {
2525 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2526 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2527 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2528 }
2529
2530 // causes problems with special threads like in bcrypt
2531 // const uint kernel_threads = device_param->kernel_threads;
2532
2533 uint kernel_threads = device_param->kernel_threads;
2534
2535 while (num_elements % kernel_threads) num_elements++;
2536
2537 cl_kernel kernel = NULL;
2538
2539 switch (kern_run)
2540 {
2541 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2542 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2543 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2544 }
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2549 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2550 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2551 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2552 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2553 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2554 break;
2555 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2561 break;
2562 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2568 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2569 break;
2570 }
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_tm (hc_device_param_t *device_param)
2583 {
2584 const uint num_elements = 1024; // fixed
2585
2586 uint kernel_threads = 32;
2587
2588 cl_kernel kernel = device_param->kernel_tm;
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2601 {
2602 uint num_elements = num;
2603
2604 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2605 device_param->kernel_params_amp_buf32[6] = num_elements;
2606
2607 // causes problems with special threads like in bcrypt
2608 // const uint kernel_threads = device_param->kernel_threads;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = device_param->kernel_amp;
2615
2616 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2617 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2618
2619 const size_t global_work_size[3] = { num_elements, 1, 1 };
2620 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2621
2622 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2623
2624 hc_clFlush (data.ocl, device_param->command_queue);
2625
2626 hc_clFinish (data.ocl, device_param->command_queue);
2627 }
2628
2629 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2630 {
2631 int rc = -1;
2632
2633 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2634 {
2635 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2636
2637 const cl_uchar zero = 0;
2638
2639 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2640 }
2641
2642 if (rc != 0)
2643 {
2644 // NOTE: clEnqueueFillBuffer () always fails with -59
2645 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2646 // How's that possible, OpenCL 1.2 support is advertised??
2647 // We need to workaround...
2648
2649 #define FILLSZ 0x100000
2650
2651 char *tmp = (char *) mymalloc (FILLSZ);
2652
2653 for (size_t i = 0; i < size; i += FILLSZ)
2654 {
2655 const size_t left = size - i;
2656
2657 const size_t fillsz = MIN (FILLSZ, left);
2658
2659 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2660 }
2661
2662 myfree (tmp);
2663 }
2664 }
2665
2666 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)
2667 {
2668 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2669 {
2670 if (attack_mode == ATTACK_MODE_BF)
2671 {
2672 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2673 {
2674 const uint size_tm = 32 * sizeof (bs_word_t);
2675
2676 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2677
2678 run_kernel_tm (device_param);
2679
2680 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);
2681 }
2682 }
2683
2684 if (highest_pw_len < 16)
2685 {
2686 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2687 }
2688 else if (highest_pw_len < 32)
2689 {
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691 }
2692 else
2693 {
2694 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2695 }
2696 }
2697 else
2698 {
2699 run_kernel_amp (device_param, pws_cnt);
2700
2701 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2702
2703 if (opts_type & OPTS_TYPE_HOOK12)
2704 {
2705 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2706 }
2707
2708 uint iter = salt_buf->salt_iter;
2709
2710 uint loop_step = device_param->kernel_loops;
2711
2712 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2713 {
2714 uint loop_left = iter - loop_pos;
2715
2716 loop_left = MIN (loop_left, loop_step);
2717
2718 device_param->kernel_params_buf32[25] = loop_pos;
2719 device_param->kernel_params_buf32[26] = loop_left;
2720
2721 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2722
2723 if (data.devices_status == STATUS_CRACKED) break;
2724 if (data.devices_status == STATUS_ABORTED) break;
2725 if (data.devices_status == STATUS_QUIT) break;
2726
2727 /**
2728 * speed
2729 */
2730
2731 const float iter_part = (float) (loop_pos + loop_left) / iter;
2732
2733 const u64 perf_sum_all = pws_cnt * iter_part;
2734
2735 double speed_ms;
2736
2737 hc_timer_get (device_param->timer_speed, speed_ms);
2738
2739 const u32 speed_pos = device_param->speed_pos;
2740
2741 device_param->speed_cnt[speed_pos] = perf_sum_all;
2742
2743 device_param->speed_ms[speed_pos] = speed_ms;
2744
2745 if (data.benchmark == 1)
2746 {
2747 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2748 }
2749 }
2750
2751 if (opts_type & OPTS_TYPE_HOOK23)
2752 {
2753 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2754
2755 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);
2756
2757 // do something with data
2758
2759 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);
2760 }
2761
2762 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2763 }
2764 }
2765
2766 static int run_rule_engine (const int rule_len, const char *rule_buf)
2767 {
2768 if (rule_len == 0)
2769 {
2770 return 0;
2771 }
2772 else if (rule_len == 1)
2773 {
2774 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2775 }
2776
2777 return 1;
2778 }
2779
2780 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2781 {
2782 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2783 {
2784 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);
2785 }
2786 else if (data.attack_kern == ATTACK_KERN_COMBI)
2787 {
2788 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2789 {
2790 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2791 {
2792 for (u32 i = 0; i < pws_cnt; i++)
2793 {
2794 const u32 pw_len = device_param->pws_buf[i].pw_len;
2795
2796 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2797
2798 ptr[pw_len] = 0x01;
2799 }
2800 }
2801 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x80;
2810 }
2811 }
2812 }
2813
2814 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);
2815 }
2816 else if (data.attack_kern == ATTACK_KERN_BF)
2817 {
2818 const u64 off = device_param->words_off;
2819
2820 device_param->kernel_params_mp_l_buf64[3] = off;
2821
2822 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2823 }
2824 }
2825
2826 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2827 {
2828 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2829
2830 device_param->kernel_params_buf32[25] = 0;
2831 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2832 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2833
2834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2835 {
2836 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2837 }
2838 else
2839 {
2840 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2841 }
2842
2843 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2844
2845 return exec_ms_prev;
2846 }
2847
2848 static void autotune (hc_device_param_t *device_param)
2849 {
2850 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2851
2852 const u32 kernel_accel_min = device_param->kernel_accel_min;
2853 const u32 kernel_accel_max = device_param->kernel_accel_max;
2854
2855 const u32 kernel_loops_min = device_param->kernel_loops_min;
2856 const u32 kernel_loops_max = device_param->kernel_loops_max;
2857
2858 u32 kernel_accel = kernel_accel_min;
2859 u32 kernel_loops = kernel_loops_min;
2860
2861 // init some fake words
2862
2863 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2864
2865 for (u32 i = 0; i < kernel_power_max; i++)
2866 {
2867 device_param->pws_buf[i].i[0] = i;
2868 device_param->pws_buf[i].i[1] = 0x01234567;
2869 device_param->pws_buf[i].pw_len = 7;
2870 }
2871
2872 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);
2873
2874 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2875 {
2876 run_kernel_amp (device_param, kernel_power_max);
2877 }
2878
2879 // begin actual testing
2880
2881 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2882
2883 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2884 {
2885 // we do this in case the user specified a fixed -u and -n on the commandline
2886 // so we have a cached kernel for benchmark
2887
2888 try_run (device_param, kernel_accel, kernel_loops);
2889 try_run (device_param, kernel_accel, kernel_loops);
2890 try_run (device_param, kernel_accel, kernel_loops);
2891 try_run (device_param, kernel_accel, kernel_loops);
2892 try_run (device_param, kernel_accel, kernel_loops);
2893 }
2894
2895 // first find out highest kernel-loops that stays below target_ms
2896
2897 #define STEPS_CNT 10
2898
2899 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2900 {
2901 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 for (int i = 0; i < STEPS_CNT; i++)
2911 {
2912 const u32 kernel_accel_try = 1 << i;
2913
2914 if (kernel_accel_try < kernel_accel_min) continue;
2915 if (kernel_accel_try > kernel_accel_max) break;
2916
2917 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2918
2919 if (exec_ms > target_ms) break;
2920
2921 exec_ms_final = exec_ms;
2922
2923 kernel_accel = kernel_accel_try;
2924 }
2925 }
2926
2927 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2928 // in such a case the above function would not create any change
2929 // we'll use the runtime to find out if we're allow to do last improvement
2930
2931 if (exec_ms_final > 0)
2932 {
2933 if ((exec_ms_final * 2) <= target_ms)
2934 {
2935 const double exec_left = target_ms / exec_ms_final;
2936
2937 const double accel_left = kernel_accel_max / kernel_accel;
2938
2939 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2940
2941 if (exec_accel_min >= 2)
2942 {
2943 kernel_accel *= exec_accel_min;
2944 }
2945 }
2946 }
2947
2948 // balancing the workload turns out to be very efficient
2949
2950 if (kernel_loops_min != kernel_loops_max)
2951 {
2952 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2953
2954 u32 sqrtv;
2955
2956 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2957 {
2958 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2959 }
2960
2961 const u32 kernel_accel_try = sqrtv;
2962 const u32 kernel_loops_try = sqrtv;
2963
2964 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2965 {
2966 kernel_accel = kernel_accel_try;
2967 kernel_loops = kernel_loops_try;
2968 }
2969 }
2970
2971 // reset fake words
2972
2973 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2974
2975 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);
2976 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);
2977
2978 // reset timer
2979
2980 device_param->exec_pos = 0;
2981
2982 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2983
2984 // store
2985
2986 device_param->kernel_accel = kernel_accel;
2987 device_param->kernel_loops = kernel_loops;
2988
2989 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2990
2991 device_param->kernel_power = kernel_power;
2992
2993 #ifdef DEBUG
2994
2995 if (data.quiet == 0)
2996 {
2997 clear_prompt ();
2998
2999 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3000 "Device #%u: autotuned kernel-loops to %u\n",
3001 device_param->device_id + 1, kernel_accel,
3002 device_param->device_id + 1, kernel_loops);
3003
3004 fprintf (stdout, "%s", PROMPT);
3005
3006 fflush (stdout);
3007 }
3008
3009 #endif
3010 }
3011
3012 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3013 {
3014 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3015
3016 // init speed timer
3017
3018 uint speed_pos = device_param->speed_pos;
3019
3020 #ifdef _POSIX
3021 if (device_param->timer_speed.tv_sec == 0)
3022 {
3023 hc_timer_set (&device_param->timer_speed);
3024 }
3025 #endif
3026
3027 #ifdef _WIN
3028 if (device_param->timer_speed.QuadPart == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 // find higest password length, this is for optimization stuff
3035
3036 uint highest_pw_len = 0;
3037
3038 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3039 {
3040 }
3041 else if (data.attack_kern == ATTACK_KERN_COMBI)
3042 {
3043 }
3044 else if (data.attack_kern == ATTACK_KERN_BF)
3045 {
3046 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3047 + device_param->kernel_params_mp_l_buf32[5];
3048 }
3049
3050 // iteration type
3051
3052 uint innerloop_step = 0;
3053 uint innerloop_cnt = 0;
3054
3055 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3056 else innerloop_step = 1;
3057
3058 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3059 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3060 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3061
3062 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3063
3064 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3065 {
3066 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3067
3068 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3069
3070 if (data.devices_status == STATUS_CRACKED) break;
3071 if (data.devices_status == STATUS_ABORTED) break;
3072 if (data.devices_status == STATUS_QUIT) break;
3073 if (data.devices_status == STATUS_BYPASS) break;
3074
3075 salt_t *salt_buf = &data.salts_buf[salt_pos];
3076
3077 device_param->kernel_params_buf32[24] = salt_pos;
3078 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3079 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3080
3081 FILE *combs_fp = device_param->combs_fp;
3082
3083 if (data.attack_mode == ATTACK_MODE_COMBI)
3084 {
3085 rewind (combs_fp);
3086 }
3087
3088 // innerloops
3089
3090 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3091 {
3092 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3093
3094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3095
3096 if (data.devices_status == STATUS_CRACKED) break;
3097 if (data.devices_status == STATUS_ABORTED) break;
3098 if (data.devices_status == STATUS_QUIT) break;
3099 if (data.devices_status == STATUS_BYPASS) break;
3100
3101 uint innerloop_left = innerloop_cnt - innerloop_pos;
3102
3103 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3104
3105 device_param->innerloop_pos = innerloop_pos;
3106 device_param->innerloop_left = innerloop_left;
3107
3108 device_param->kernel_params_buf32[27] = innerloop_left;
3109
3110 // i think we can get rid of this
3111 if (innerloop_left == 0)
3112 {
3113 puts ("bug, how should this happen????\n");
3114
3115 continue;
3116 }
3117
3118 if (data.salts_shown[salt_pos] == 1)
3119 {
3120 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3121
3122 continue;
3123 }
3124
3125 // initialize amplifiers
3126
3127 if (data.attack_mode == ATTACK_MODE_COMBI)
3128 {
3129 uint i = 0;
3130
3131 while (i < innerloop_left)
3132 {
3133 if (feof (combs_fp)) break;
3134
3135 int line_len = fgetl (combs_fp, line_buf);
3136
3137 if (line_len >= PW_MAX1) continue;
3138
3139 line_len = convert_from_hex (line_buf, line_len);
3140
3141 char *line_buf_new = line_buf;
3142
3143 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3144 {
3145 char rule_buf_out[BLOCK_SIZE] = { 0 };
3146
3147 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3148
3149 if (rule_len_out < 0)
3150 {
3151 data.words_progress_rejected[salt_pos] += pws_cnt;
3152
3153 continue;
3154 }
3155
3156 line_len = rule_len_out;
3157
3158 line_buf_new = rule_buf_out;
3159 }
3160
3161 line_len = MIN (line_len, PW_DICTMAX);
3162
3163 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3164
3165 memcpy (ptr, line_buf_new, line_len);
3166
3167 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3168
3169 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3170 {
3171 uppercase (ptr, line_len);
3172 }
3173
3174 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3175 {
3176 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3177 {
3178 ptr[line_len] = 0x80;
3179 }
3180
3181 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3182 {
3183 ptr[line_len] = 0x01;
3184 }
3185 }
3186
3187 device_param->combs_buf[i].pw_len = line_len;
3188
3189 i++;
3190 }
3191
3192 for (uint j = i; j < innerloop_left; j++)
3193 {
3194 device_param->combs_buf[j].i[0] = 0;
3195 device_param->combs_buf[j].i[1] = 0;
3196 device_param->combs_buf[j].i[2] = 0;
3197 device_param->combs_buf[j].i[3] = 0;
3198 device_param->combs_buf[j].i[4] = 0;
3199 device_param->combs_buf[j].i[5] = 0;
3200 device_param->combs_buf[j].i[6] = 0;
3201 device_param->combs_buf[j].i[7] = 0;
3202
3203 device_param->combs_buf[j].pw_len = 0;
3204 }
3205
3206 innerloop_left = i;
3207 }
3208 else if (data.attack_mode == ATTACK_MODE_BF)
3209 {
3210 u64 off = innerloop_pos;
3211
3212 device_param->kernel_params_mp_r_buf64[3] = off;
3213
3214 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3215 }
3216 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3217 {
3218 u64 off = innerloop_pos;
3219
3220 device_param->kernel_params_mp_buf64[3] = off;
3221
3222 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3223 }
3224 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3225 {
3226 u64 off = innerloop_pos;
3227
3228 device_param->kernel_params_mp_buf64[3] = off;
3229
3230 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3231 }
3232
3233 // copy amplifiers
3234
3235 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3236 {
3237 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);
3238 }
3239 else if (data.attack_mode == ATTACK_MODE_COMBI)
3240 {
3241 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);
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 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);
3246 }
3247 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3248 {
3249 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);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3252 {
3253 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);
3254 }
3255
3256 if (data.benchmark == 1)
3257 {
3258 hc_timer_set (&device_param->timer_speed);
3259 }
3260
3261 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3262
3263 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3264
3265 if (data.devices_status == STATUS_CRACKED) break;
3266 if (data.devices_status == STATUS_ABORTED) break;
3267 if (data.devices_status == STATUS_QUIT) break;
3268
3269 /**
3270 * result
3271 */
3272
3273 hc_thread_mutex_lock (mux_display);
3274
3275 check_cracked (device_param, salt_pos);
3276
3277 hc_thread_mutex_unlock (mux_display);
3278
3279 /**
3280 * progress
3281 */
3282
3283 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3284
3285 hc_thread_mutex_lock (mux_counter);
3286
3287 data.words_progress_done[salt_pos] += perf_sum_all;
3288
3289 hc_thread_mutex_unlock (mux_counter);
3290
3291 /**
3292 * speed
3293 */
3294
3295 double speed_ms;
3296
3297 hc_timer_get (device_param->timer_speed, speed_ms);
3298
3299 hc_timer_set (&device_param->timer_speed);
3300
3301 hc_thread_mutex_lock (mux_display);
3302
3303 // current speed
3304
3305 device_param->speed_cnt[speed_pos] = perf_sum_all;
3306
3307 device_param->speed_ms[speed_pos] = speed_ms;
3308
3309 hc_thread_mutex_unlock (mux_display);
3310
3311 speed_pos++;
3312
3313 if (speed_pos == SPEED_CACHE)
3314 {
3315 speed_pos = 0;
3316 }
3317
3318 /**
3319 * benchmark
3320 */
3321
3322 if (data.benchmark == 1) break;
3323 }
3324 }
3325
3326 device_param->speed_pos = speed_pos;
3327
3328 myfree (line_buf);
3329 }
3330
3331 static void load_segment (wl_data_t *wl_data, FILE *fd)
3332 {
3333 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3334
3335 wl_data->pos = 0;
3336
3337 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3338
3339 wl_data->buf[wl_data->cnt] = 0;
3340
3341 if (wl_data->cnt == 0) return;
3342
3343 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3344
3345 while (!feof (fd))
3346 {
3347 if (wl_data->cnt == wl_data->avail)
3348 {
3349 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3350
3351 wl_data->avail += wl_data->incr;
3352 }
3353
3354 const int c = fgetc (fd);
3355
3356 if (c == EOF) break;
3357
3358 wl_data->buf[wl_data->cnt] = (char) c;
3359
3360 wl_data->cnt++;
3361
3362 if (c == '\n') break;
3363 }
3364
3365 // ensure stream ends with a newline
3366
3367 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3368 {
3369 wl_data->cnt++;
3370
3371 wl_data->buf[wl_data->cnt - 1] = '\n';
3372 }
3373
3374 return;
3375 }
3376
3377 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3378 {
3379 char *ptr = buf;
3380
3381 for (u32 i = 0; i < sz; i++, ptr++)
3382 {
3383 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3384
3385 if (i == 7)
3386 {
3387 *off = i;
3388 *len = i;
3389
3390 return;
3391 }
3392
3393 if (*ptr != '\n') continue;
3394
3395 *off = i + 1;
3396
3397 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3398
3399 *len = i;
3400
3401 return;
3402 }
3403
3404 *off = sz;
3405 *len = sz;
3406 }
3407
3408 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3409 {
3410 char *ptr = buf;
3411
3412 for (u32 i = 0; i < sz; i++, ptr++)
3413 {
3414 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3415
3416 if (*ptr != '\n') continue;
3417
3418 *off = i + 1;
3419
3420 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3421
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 *off = sz;
3428 *len = sz;
3429 }
3430
3431 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr != '\n') continue;
3438
3439 *off = i + 1;
3440
3441 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3442
3443 *len = i;
3444
3445 return;
3446 }
3447
3448 *off = sz;
3449 *len = sz;
3450 }
3451
3452 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3453 {
3454 while (wl_data->pos < wl_data->cnt)
3455 {
3456 uint off;
3457 uint len;
3458
3459 char *ptr = wl_data->buf + wl_data->pos;
3460
3461 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3462
3463 wl_data->pos += off;
3464
3465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3466 {
3467 char rule_buf_out[BLOCK_SIZE] = { 0 };
3468
3469 int rule_len_out = -1;
3470
3471 if (len < BLOCK_SIZE)
3472 {
3473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3474 }
3475
3476 if (rule_len_out < 0)
3477 {
3478 continue;
3479 }
3480
3481 if (rule_len_out > PW_MAX)
3482 {
3483 continue;
3484 }
3485 }
3486 else
3487 {
3488 if (len > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493
3494 *out_buf = ptr;
3495 *out_len = len;
3496
3497 return;
3498 }
3499
3500 if (feof (fd))
3501 {
3502 fprintf (stderr, "BUG feof()!!\n");
3503
3504 return;
3505 }
3506
3507 load_segment (wl_data, fd);
3508
3509 get_next_word (wl_data, fd, out_buf, out_len);
3510 }
3511
3512 #ifdef _POSIX
3513 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3514 #endif
3515
3516 #ifdef _WIN
3517 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3518 #endif
3519 {
3520 hc_signal (NULL);
3521
3522 dictstat_t d;
3523
3524 d.cnt = 0;
3525
3526 #ifdef _POSIX
3527 fstat (fileno (fd), &d.stat);
3528 #endif
3529
3530 #ifdef _WIN
3531 _fstat64 (fileno (fd), &d.stat);
3532 #endif
3533
3534 d.stat.st_mode = 0;
3535 d.stat.st_nlink = 0;
3536 d.stat.st_uid = 0;
3537 d.stat.st_gid = 0;
3538 d.stat.st_rdev = 0;
3539 d.stat.st_atime = 0;
3540
3541 #ifdef _POSIX
3542 d.stat.st_blksize = 0;
3543 d.stat.st_blocks = 0;
3544 #endif
3545
3546 if (d.stat.st_size == 0) return 0;
3547
3548 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3549
3550 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3551 {
3552 if (d_cache)
3553 {
3554 u64 cnt = d_cache->cnt;
3555
3556 u64 keyspace = cnt;
3557
3558 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3559 {
3560 keyspace *= data.kernel_rules_cnt;
3561 }
3562 else if (data.attack_kern == ATTACK_KERN_COMBI)
3563 {
3564 keyspace *= data.combs_cnt;
3565 }
3566
3567 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);
3568 if (data.quiet == 0) log_info ("");
3569
3570 hc_signal (sigHandler_default);
3571
3572 return (keyspace);
3573 }
3574 }
3575
3576 time_t now = 0;
3577 time_t prev = 0;
3578
3579 u64 comp = 0;
3580 u64 cnt = 0;
3581 u64 cnt2 = 0;
3582
3583 while (!feof (fd))
3584 {
3585 load_segment (wl_data, fd);
3586
3587 comp += wl_data->cnt;
3588
3589 u32 i = 0;
3590
3591 while (i < wl_data->cnt)
3592 {
3593 u32 len;
3594 u32 off;
3595
3596 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3597
3598 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3599 {
3600 char rule_buf_out[BLOCK_SIZE] = { 0 };
3601
3602 int rule_len_out = -1;
3603
3604 if (len < BLOCK_SIZE)
3605 {
3606 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3607 }
3608
3609 if (rule_len_out < 0)
3610 {
3611 len = PW_MAX1;
3612 }
3613 else
3614 {
3615 len = rule_len_out;
3616 }
3617 }
3618
3619 if (len < PW_MAX1)
3620 {
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 cnt += data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 cnt += data.combs_cnt;
3628 }
3629
3630 d.cnt++;
3631 }
3632
3633 i += off;
3634
3635 cnt2++;
3636 }
3637
3638 time (&now);
3639
3640 if ((now - prev) == 0) continue;
3641
3642 float percent = (float) comp / (float) d.stat.st_size;
3643
3644 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);
3645
3646 time (&prev);
3647 }
3648
3649 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);
3650 if (data.quiet == 0) log_info ("");
3651
3652 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3653
3654 hc_signal (sigHandler_default);
3655
3656 return (cnt);
3657 }
3658
3659 static void *thread_monitor (void *p)
3660 {
3661 uint runtime_check = 0;
3662 uint remove_check = 0;
3663 uint status_check = 0;
3664 uint restore_check = 0;
3665
3666 uint restore_left = data.restore_timer;
3667 uint remove_left = data.remove_timer;
3668 uint status_left = data.status_timer;
3669
3670 #ifdef HAVE_HWMON
3671 uint hwmon_check = 0;
3672
3673 // these variables are mainly used for fan control (AMD only)
3674
3675 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3676
3677 // temperature controller "loopback" values
3678
3679 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3680 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3681
3682 #ifdef HAVE_ADL
3683 int temp_threshold = 1; // degrees celcius
3684
3685 int fan_speed_min = 15; // in percentage
3686 int fan_speed_max = 100;
3687 #endif // HAVE_ADL
3688
3689 time_t last_temp_check_time;
3690 #endif // HAVE_HWMON
3691
3692 uint sleep_time = 1;
3693
3694 if (data.runtime)
3695 {
3696 runtime_check = 1;
3697 }
3698
3699 if (data.restore_timer)
3700 {
3701 restore_check = 1;
3702 }
3703
3704 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3705 {
3706 remove_check = 1;
3707 }
3708
3709 if (data.status == 1)
3710 {
3711 status_check = 1;
3712 }
3713
3714 #ifdef HAVE_HWMON
3715 if (data.gpu_temp_disable == 0)
3716 {
3717 time (&last_temp_check_time);
3718
3719 hwmon_check = 1;
3720 }
3721 #endif
3722
3723 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3724 {
3725 #ifdef HAVE_HWMON
3726 if (hwmon_check == 0)
3727 #endif
3728 return (p);
3729 }
3730
3731 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3732 {
3733 hc_sleep (sleep_time);
3734
3735 if (data.devices_status != STATUS_RUNNING) continue;
3736
3737 #ifdef HAVE_HWMON
3738 if (hwmon_check == 1)
3739 {
3740 hc_thread_mutex_lock (mux_adl);
3741
3742 time_t temp_check_time;
3743
3744 time (&temp_check_time);
3745
3746 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3747
3748 if (Ta == 0) Ta = 1;
3749
3750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3751 {
3752 hc_device_param_t *device_param = &data.devices_param[device_id];
3753
3754 if (device_param->skipped) continue;
3755
3756 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3757
3758 const int temperature = hm_get_temperature_with_device_id (device_id);
3759
3760 if (temperature > (int) data.gpu_temp_abort)
3761 {
3762 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3763
3764 if (data.devices_status != STATUS_QUIT) myabort ();
3765
3766 break;
3767 }
3768
3769 #ifdef HAVE_ADL
3770 const int gpu_temp_retain = data.gpu_temp_retain;
3771
3772 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3773 {
3774 if (data.hm_device[device_id].fan_supported == 1)
3775 {
3776 int temp_cur = temperature;
3777
3778 int temp_diff_new = gpu_temp_retain - temp_cur;
3779
3780 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3781
3782 // calculate Ta value (time difference in seconds between the last check and this check)
3783
3784 last_temp_check_time = temp_check_time;
3785
3786 float Kp = 1.8;
3787 float Ki = 0.005;
3788 float Kd = 6;
3789
3790 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3791
3792 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);
3793
3794 if (abs (fan_diff_required) >= temp_threshold)
3795 {
3796 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3797
3798 int fan_speed_level = fan_speed_cur;
3799
3800 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3801
3802 int fan_speed_new = fan_speed_level - fan_diff_required;
3803
3804 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3805 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3806
3807 if (fan_speed_new != fan_speed_cur)
3808 {
3809 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3810 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3811
3812 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3813 {
3814 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3815
3816 fan_speed_chgd[device_id] = 1;
3817 }
3818
3819 temp_diff_old[device_id] = temp_diff_new;
3820 }
3821 }
3822 }
3823 }
3824 #endif // HAVE_ADL
3825 }
3826
3827 hc_thread_mutex_unlock (mux_adl);
3828 }
3829 #endif // HAVE_HWMON
3830
3831 if (restore_check == 1)
3832 {
3833 restore_left--;
3834
3835 if (restore_left == 0)
3836 {
3837 if (data.restore_disable == 0) cycle_restore ();
3838
3839 restore_left = data.restore_timer;
3840 }
3841 }
3842
3843 if ((runtime_check == 1) && (data.runtime_start > 0))
3844 {
3845 time_t runtime_cur;
3846
3847 time (&runtime_cur);
3848
3849 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3850
3851 if (runtime_left <= 0)
3852 {
3853 if (data.benchmark == 0)
3854 {
3855 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3856 }
3857
3858 if (data.devices_status != STATUS_QUIT) myabort ();
3859 }
3860 }
3861
3862 if (remove_check == 1)
3863 {
3864 remove_left--;
3865
3866 if (remove_left == 0)
3867 {
3868 if (data.digests_saved != data.digests_done)
3869 {
3870 data.digests_saved = data.digests_done;
3871
3872 save_hash ();
3873 }
3874
3875 remove_left = data.remove_timer;
3876 }
3877 }
3878
3879 if (status_check == 1)
3880 {
3881 status_left--;
3882
3883 if (status_left == 0)
3884 {
3885 hc_thread_mutex_lock (mux_display);
3886
3887 if (data.quiet == 0) clear_prompt ();
3888
3889 if (data.quiet == 0) log_info ("");
3890
3891 status_display ();
3892
3893 if (data.quiet == 0) log_info ("");
3894
3895 hc_thread_mutex_unlock (mux_display);
3896
3897 status_left = data.status_timer;
3898 }
3899 }
3900 }
3901
3902 #ifdef HAVE_HWMON
3903 myfree (fan_speed_chgd);
3904
3905 myfree (temp_diff_old);
3906 myfree (temp_diff_sum);
3907 #endif
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static void *thread_outfile_remove (void *p)
3915 {
3916 // some hash-dependent constants
3917 char *outfile_dir = data.outfile_check_directory;
3918 uint dgst_size = data.dgst_size;
3919 uint isSalted = data.isSalted;
3920 uint esalt_size = data.esalt_size;
3921 uint hash_mode = data.hash_mode;
3922
3923 uint outfile_check_timer = data.outfile_check_timer;
3924
3925 char separator = data.separator;
3926
3927 // some hash-dependent functions
3928 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3929 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3930
3931 // buffers
3932 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3933
3934 hash_buf.digest = mymalloc (dgst_size);
3935
3936 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3937
3938 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3939
3940 uint digest_buf[64] = { 0 };
3941
3942 outfile_data_t *out_info = NULL;
3943
3944 char **out_files = NULL;
3945
3946 time_t folder_mtime = 0;
3947
3948 int out_cnt = 0;
3949
3950 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3951
3952 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3953 {
3954 hc_sleep (1);
3955
3956 if (data.devices_status != STATUS_RUNNING) continue;
3957
3958 check_left--;
3959
3960 if (check_left == 0)
3961 {
3962 struct stat outfile_check_stat;
3963
3964 if (stat (outfile_dir, &outfile_check_stat) == 0)
3965 {
3966 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3967
3968 if (is_dir == 1)
3969 {
3970 if (outfile_check_stat.st_mtime > folder_mtime)
3971 {
3972 char **out_files_new = scan_directory (outfile_dir);
3973
3974 int out_cnt_new = count_dictionaries (out_files_new);
3975
3976 outfile_data_t *out_info_new = NULL;
3977
3978 if (out_cnt_new > 0)
3979 {
3980 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3981
3982 for (int i = 0; i < out_cnt_new; i++)
3983 {
3984 out_info_new[i].file_name = out_files_new[i];
3985
3986 // check if there are files that we have seen/checked before (and not changed)
3987
3988 for (int j = 0; j < out_cnt; j++)
3989 {
3990 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3991 {
3992 struct stat outfile_stat;
3993
3994 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3995 {
3996 if (outfile_stat.st_ctime == out_info[j].ctime)
3997 {
3998 out_info_new[i].ctime = out_info[j].ctime;
3999 out_info_new[i].seek = out_info[j].seek;
4000 }
4001 }
4002 }
4003 }
4004 }
4005 }
4006
4007 local_free (out_info);
4008 local_free (out_files);
4009
4010 out_files = out_files_new;
4011 out_cnt = out_cnt_new;
4012 out_info = out_info_new;
4013
4014 folder_mtime = outfile_check_stat.st_mtime;
4015 }
4016
4017 for (int j = 0; j < out_cnt; j++)
4018 {
4019 FILE *fp = fopen (out_info[j].file_name, "rb");
4020
4021 if (fp != NULL)
4022 {
4023 //hc_thread_mutex_lock (mux_display);
4024
4025 #ifdef _POSIX
4026 struct stat outfile_stat;
4027
4028 fstat (fileno (fp), &outfile_stat);
4029 #endif
4030
4031 #ifdef _WIN
4032 struct stat64 outfile_stat;
4033
4034 _fstat64 (fileno (fp), &outfile_stat);
4035 #endif
4036
4037 if (outfile_stat.st_ctime > out_info[j].ctime)
4038 {
4039 out_info[j].ctime = outfile_stat.st_ctime;
4040 out_info[j].seek = 0;
4041 }
4042
4043 fseek (fp, out_info[j].seek, SEEK_SET);
4044
4045 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4046
4047 while (!feof (fp))
4048 {
4049 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4050
4051 if (ptr == NULL) break;
4052
4053 int line_len = strlen (line_buf);
4054
4055 if (line_len <= 0) continue;
4056
4057 int iter = MAX_CUT_TRIES;
4058
4059 for (uint i = line_len - 1; i && iter; i--, line_len--)
4060 {
4061 if (line_buf[i] != separator) continue;
4062
4063 int parser_status = PARSER_OK;
4064
4065 if ((hash_mode != 2500) && (hash_mode != 6800))
4066 {
4067 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4068 }
4069
4070 uint found = 0;
4071
4072 if (parser_status == PARSER_OK)
4073 {
4074 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4075 {
4076 if (data.salts_shown[salt_pos] == 1) continue;
4077
4078 salt_t *salt_buf = &data.salts_buf[salt_pos];
4079
4080 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4081 {
4082 uint idx = salt_buf->digests_offset + digest_pos;
4083
4084 if (data.digests_shown[idx] == 1) continue;
4085
4086 uint cracked = 0;
4087
4088 if (hash_mode == 6800)
4089 {
4090 if (i == salt_buf->salt_len)
4091 {
4092 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4093 }
4094 }
4095 else if (hash_mode == 2500)
4096 {
4097 // BSSID : MAC1 : MAC2 (:plain)
4098 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4099 {
4100 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4101
4102 if (!cracked) continue;
4103
4104 // now compare MAC1 and MAC2 too, since we have this additional info
4105 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4106 char *mac2_pos = mac1_pos + 12 + 1;
4107
4108 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4109 wpa_t *wpa = &wpas[salt_pos];
4110
4111 // compare hex string(s) vs binary MAC address(es)
4112
4113 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4114 {
4115 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4116 {
4117 cracked = 0;
4118
4119 break;
4120 }
4121 }
4122
4123 // early skip ;)
4124 if (!cracked) continue;
4125
4126 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4127 {
4128 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4129 {
4130 cracked = 0;
4131
4132 break;
4133 }
4134 }
4135 }
4136 }
4137 else
4138 {
4139 char *digests_buf_ptr = (char *) data.digests_buf;
4140
4141 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4142
4143 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4144 }
4145
4146 if (cracked == 1)
4147 {
4148 found = 1;
4149
4150 data.digests_shown[idx] = 1;
4151
4152 data.digests_done++;
4153
4154 salt_buf->digests_done++;
4155
4156 if (salt_buf->digests_done == salt_buf->digests_cnt)
4157 {
4158 data.salts_shown[salt_pos] = 1;
4159
4160 data.salts_done++;
4161
4162 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4163 }
4164 }
4165 }
4166
4167 if (data.devices_status == STATUS_CRACKED) break;
4168 }
4169 }
4170
4171 if (found) break;
4172
4173 if (data.devices_status == STATUS_CRACKED) break;
4174
4175 iter--;
4176 }
4177
4178 if (data.devices_status == STATUS_CRACKED) break;
4179 }
4180
4181 myfree (line_buf);
4182
4183 out_info[j].seek = ftell (fp);
4184
4185 //hc_thread_mutex_unlock (mux_display);
4186
4187 fclose (fp);
4188 }
4189 }
4190 }
4191 }
4192
4193 check_left = outfile_check_timer;
4194 }
4195 }
4196
4197 if (esalt_size) local_free (hash_buf.esalt);
4198
4199 if (isSalted) local_free (hash_buf.salt);
4200
4201 local_free (hash_buf.digest);
4202
4203 local_free (out_info);
4204
4205 local_free (out_files);
4206
4207 p = NULL;
4208
4209 return (p);
4210 }
4211
4212 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4213 {
4214 if (device_param->pws_cnt < device_param->kernel_power)
4215 {
4216 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4217
4218 u8 *ptr = (u8 *) pw->i;
4219
4220 memcpy (ptr, pw_buf, pw_len);
4221
4222 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4223
4224 pw->pw_len = pw_len;
4225
4226 device_param->pws_cnt++;
4227 }
4228 else
4229 {
4230 fprintf (stderr, "BUG pw_add()!!\n");
4231
4232 return;
4233 }
4234 }
4235
4236 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4237 {
4238 hc_thread_mutex_lock (mux_dispatcher);
4239
4240 const u64 words_cur = data.words_cur;
4241 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4242
4243 device_param->words_off = words_cur;
4244
4245 const u64 words_left = words_base - words_cur;
4246
4247 if (allow_div)
4248 {
4249 if (data.kernel_power_all > words_left)
4250 {
4251 if (data.kernel_power_div == 0)
4252 {
4253 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4254 }
4255 }
4256
4257 if (data.kernel_power_div)
4258 {
4259 if (device_param->kernel_power == device_param->kernel_power_user)
4260 {
4261 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4262
4263 if (kernel_power_new < device_param->kernel_power)
4264 {
4265 device_param->kernel_power = kernel_power_new;
4266 }
4267 }
4268 }
4269 }
4270
4271 const uint kernel_power = device_param->kernel_power;
4272
4273 uint work = MIN (words_left, kernel_power);
4274
4275 work = MIN (work, max);
4276
4277 data.words_cur += work;
4278
4279 hc_thread_mutex_unlock (mux_dispatcher);
4280
4281 return work;
4282 }
4283
4284 static void *thread_calc_stdin (void *p)
4285 {
4286 hc_device_param_t *device_param = (hc_device_param_t *) p;
4287
4288 if (device_param->skipped) return NULL;
4289
4290 autotune (device_param);
4291
4292 char *buf = (char *) mymalloc (HCBUFSIZ);
4293
4294 const uint attack_kern = data.attack_kern;
4295
4296 const uint kernel_power = device_param->kernel_power;
4297
4298 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 if (feof (stdin) != 0)
4303 {
4304 hc_thread_mutex_unlock (mux_dispatcher);
4305
4306 break;
4307 }
4308
4309 uint words_cur = 0;
4310
4311 while (words_cur < kernel_power)
4312 {
4313 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4314
4315 if (line_buf == NULL) break;
4316
4317 uint line_len = in_superchop (line_buf);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (line_len > PW_MAX)
4341 {
4342 continue;
4343 }
4344
4345 if (attack_kern == ATTACK_KERN_STRAIGHT)
4346 {
4347 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4348 {
4349 hc_thread_mutex_lock (mux_counter);
4350
4351 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4352 {
4353 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4354 }
4355
4356 hc_thread_mutex_unlock (mux_counter);
4357
4358 continue;
4359 }
4360 }
4361 else if (attack_kern == ATTACK_KERN_COMBI)
4362 {
4363 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4364 // since we still need to combine the plains
4365
4366 if (line_len > data.pw_max)
4367 {
4368 hc_thread_mutex_lock (mux_counter);
4369
4370 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4371 {
4372 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4373 }
4374
4375 hc_thread_mutex_unlock (mux_counter);
4376
4377 continue;
4378 }
4379 }
4380
4381 pw_add (device_param, (u8 *) line_buf, line_len);
4382
4383 words_cur++;
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // flush
4399
4400 const uint pws_cnt = device_param->pws_cnt;
4401
4402 if (pws_cnt)
4403 {
4404 run_copy (device_param, pws_cnt);
4405
4406 run_cracker (device_param, pws_cnt);
4407
4408 device_param->pws_cnt = 0;
4409
4410 if (attack_kern == ATTACK_KERN_STRAIGHT)
4411 {
4412 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4417 }
4418 }
4419 }
4420
4421 device_param->kernel_accel = 0;
4422 device_param->kernel_loops = 0;
4423
4424 myfree (buf);
4425
4426 return NULL;
4427 }
4428
4429 static void *thread_calc (void *p)
4430 {
4431 hc_device_param_t *device_param = (hc_device_param_t *) p;
4432
4433 if (device_param->skipped) return NULL;
4434
4435 autotune (device_param);
4436
4437 const uint attack_mode = data.attack_mode;
4438 const uint attack_kern = data.attack_kern;
4439
4440 if (attack_mode == ATTACK_MODE_BF)
4441 {
4442 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4443 {
4444 const uint work = get_work (device_param, -1, true);
4445
4446 if (work == 0) break;
4447
4448 const u64 words_off = device_param->words_off;
4449 const u64 words_fin = words_off + work;
4450
4451 const uint pws_cnt = work;
4452
4453 device_param->pws_cnt = pws_cnt;
4454
4455 if (pws_cnt)
4456 {
4457 run_copy (device_param, pws_cnt);
4458
4459 run_cracker (device_param, pws_cnt);
4460
4461 device_param->pws_cnt = 0;
4462
4463 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4464 }
4465
4466 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 if (data.benchmark == 1) break;
4474
4475 device_param->words_done = words_fin;
4476 }
4477 }
4478 else
4479 {
4480 const uint segment_size = data.segment_size;
4481
4482 char *dictfile = data.dictfile;
4483
4484 if (attack_mode == ATTACK_MODE_COMBI)
4485 {
4486 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4487 {
4488 dictfile = data.dictfile2;
4489 }
4490 }
4491
4492 FILE *fd = fopen (dictfile, "rb");
4493
4494 if (fd == NULL)
4495 {
4496 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4497
4498 return NULL;
4499 }
4500
4501 if (attack_mode == ATTACK_MODE_COMBI)
4502 {
4503 const uint combs_mode = data.combs_mode;
4504
4505 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4506 {
4507 const char *dictfilec = data.dictfile2;
4508
4509 FILE *combs_fp = fopen (dictfilec, "rb");
4510
4511 if (combs_fp == NULL)
4512 {
4513 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4514
4515 fclose (fd);
4516
4517 return NULL;
4518 }
4519
4520 device_param->combs_fp = combs_fp;
4521 }
4522 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4523 {
4524 const char *dictfilec = data.dictfile;
4525
4526 FILE *combs_fp = fopen (dictfilec, "rb");
4527
4528 if (combs_fp == NULL)
4529 {
4530 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4531
4532 fclose (fd);
4533
4534 return NULL;
4535 }
4536
4537 device_param->combs_fp = combs_fp;
4538 }
4539 }
4540
4541 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4542
4543 wl_data->buf = (char *) mymalloc (segment_size);
4544 wl_data->avail = segment_size;
4545 wl_data->incr = segment_size;
4546 wl_data->cnt = 0;
4547 wl_data->pos = 0;
4548
4549 u64 words_cur = 0;
4550
4551 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4552 {
4553 u64 words_off = 0;
4554 u64 words_fin = 0;
4555
4556 bool allow_div = true;
4557
4558 u64 max = -1;
4559
4560 while (max)
4561 {
4562 const uint work = get_work (device_param, max, allow_div);
4563
4564 allow_div = false;
4565
4566 if (work == 0) break;
4567
4568 words_off = device_param->words_off;
4569 words_fin = words_off + work;
4570
4571 char *line_buf;
4572 uint line_len;
4573
4574 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4575
4576 max = 0;
4577
4578 for ( ; words_cur < words_fin; words_cur++)
4579 {
4580 get_next_word (wl_data, fd, &line_buf, &line_len);
4581
4582 line_len = convert_from_hex (line_buf, line_len);
4583
4584 // post-process rule engine
4585
4586 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4587 {
4588 char rule_buf_out[BLOCK_SIZE] = { 0 };
4589
4590 int rule_len_out = -1;
4591
4592 if (line_len < BLOCK_SIZE)
4593 {
4594 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4595 }
4596
4597 if (rule_len_out < 0) continue;
4598
4599 line_buf = rule_buf_out;
4600 line_len = rule_len_out;
4601 }
4602
4603 if (attack_kern == ATTACK_KERN_STRAIGHT)
4604 {
4605 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4606 {
4607 max++;
4608
4609 hc_thread_mutex_lock (mux_counter);
4610
4611 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4612 {
4613 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4614 }
4615
4616 hc_thread_mutex_unlock (mux_counter);
4617
4618 continue;
4619 }
4620 }
4621 else if (attack_kern == ATTACK_KERN_COMBI)
4622 {
4623 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4624 // since we still need to combine the plains
4625
4626 if (line_len > data.pw_max)
4627 {
4628 max++;
4629
4630 hc_thread_mutex_lock (mux_counter);
4631
4632 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4633 {
4634 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4635 }
4636
4637 hc_thread_mutex_unlock (mux_counter);
4638
4639 continue;
4640 }
4641 }
4642
4643 pw_add (device_param, (u8 *) line_buf, line_len);
4644
4645 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4646
4647 if (data.devices_status == STATUS_CRACKED) break;
4648 if (data.devices_status == STATUS_ABORTED) break;
4649 if (data.devices_status == STATUS_QUIT) break;
4650 if (data.devices_status == STATUS_BYPASS) break;
4651 }
4652
4653 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4654
4655 if (data.devices_status == STATUS_CRACKED) break;
4656 if (data.devices_status == STATUS_ABORTED) break;
4657 if (data.devices_status == STATUS_QUIT) break;
4658 if (data.devices_status == STATUS_BYPASS) break;
4659 }
4660
4661 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 if (data.devices_status == STATUS_ABORTED) break;
4665 if (data.devices_status == STATUS_QUIT) break;
4666 if (data.devices_status == STATUS_BYPASS) break;
4667
4668 //
4669 // flush
4670 //
4671
4672 const uint pws_cnt = device_param->pws_cnt;
4673
4674 if (pws_cnt)
4675 {
4676 run_copy (device_param, pws_cnt);
4677
4678 run_cracker (device_param, pws_cnt);
4679
4680 device_param->pws_cnt = 0;
4681
4682 if (attack_kern == ATTACK_KERN_STRAIGHT)
4683 {
4684 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4685 }
4686 else if (attack_kern == ATTACK_KERN_COMBI)
4687 {
4688 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4689 }
4690 }
4691
4692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4693
4694 if (data.devices_status == STATUS_CRACKED) break;
4695 if (data.devices_status == STATUS_ABORTED) break;
4696 if (data.devices_status == STATUS_QUIT) break;
4697 if (data.devices_status == STATUS_BYPASS) break;
4698
4699 if (words_fin == 0) break;
4700
4701 device_param->words_done = words_fin;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 fclose (device_param->combs_fp);
4707 }
4708
4709 free (wl_data->buf);
4710 free (wl_data);
4711
4712 fclose (fd);
4713 }
4714
4715 device_param->kernel_accel = 0;
4716 device_param->kernel_loops = 0;
4717
4718 return NULL;
4719 }
4720
4721 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4722 {
4723 if (!device_param)
4724 {
4725 log_error ("ERROR: %s : Invalid argument", __func__);
4726
4727 exit (-1);
4728 }
4729
4730 salt_t *salt_buf = &data.salts_buf[salt_pos];
4731
4732 device_param->kernel_params_buf32[24] = salt_pos;
4733 device_param->kernel_params_buf32[27] = 1;
4734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4736 device_param->kernel_params_buf32[30] = 0;
4737 device_param->kernel_params_buf32[31] = 1;
4738
4739 char *dictfile_old = data.dictfile;
4740
4741 const char *weak_hash_check = "weak-hash-check";
4742
4743 data.dictfile = (char *) weak_hash_check;
4744
4745 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4746
4747 data.kernel_rules_buf[0].cmds[0] = 0;
4748
4749 /**
4750 * run the kernel
4751 */
4752
4753 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4754 {
4755 run_kernel (KERN_RUN_1, device_param, 1, false);
4756 }
4757 else
4758 {
4759 run_kernel (KERN_RUN_1, device_param, 1, false);
4760
4761 uint loop_step = 16;
4762
4763 const uint iter = salt_buf->salt_iter;
4764
4765 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4766 {
4767 uint loop_left = iter - loop_pos;
4768
4769 loop_left = MIN (loop_left, loop_step);
4770
4771 device_param->kernel_params_buf32[25] = loop_pos;
4772 device_param->kernel_params_buf32[26] = loop_left;
4773
4774 run_kernel (KERN_RUN_2, device_param, 1, false);
4775 }
4776
4777 run_kernel (KERN_RUN_3, device_param, 1, false);
4778 }
4779
4780 /**
4781 * result
4782 */
4783
4784 check_cracked (device_param, salt_pos);
4785
4786 /**
4787 * cleanup
4788 */
4789
4790 device_param->kernel_params_buf32[24] = 0;
4791 device_param->kernel_params_buf32[25] = 0;
4792 device_param->kernel_params_buf32[26] = 0;
4793 device_param->kernel_params_buf32[27] = 0;
4794 device_param->kernel_params_buf32[28] = 0;
4795 device_param->kernel_params_buf32[29] = 0;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 0;
4798
4799 data.dictfile = dictfile_old;
4800
4801 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4802 }
4803
4804 // hlfmt hashcat
4805
4806 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4807 {
4808 if (data.username == 0)
4809 {
4810 *hashbuf_pos = line_buf;
4811 *hashbuf_len = line_len;
4812 }
4813 else
4814 {
4815 char *pos = line_buf;
4816 int len = line_len;
4817
4818 for (int i = 0; i < line_len; i++, pos++, len--)
4819 {
4820 if (line_buf[i] == data.separator)
4821 {
4822 pos++;
4823
4824 len--;
4825
4826 break;
4827 }
4828 }
4829
4830 *hashbuf_pos = pos;
4831 *hashbuf_len = len;
4832 }
4833 }
4834
4835 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4836 {
4837 char *pos = NULL;
4838 int len = 0;
4839
4840 int sep_cnt = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == data.separator)
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 0)
4852 {
4853 if (pos == NULL) pos = line_buf + i;
4854
4855 len++;
4856 }
4857 }
4858
4859 *userbuf_pos = pos;
4860 *userbuf_len = len;
4861 }
4862
4863 // hlfmt pwdump
4864
4865 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4866 {
4867 int sep_cnt = 0;
4868
4869 int sep2_len = 0;
4870 int sep3_len = 0;
4871
4872 for (int i = 0; i < line_len; i++)
4873 {
4874 if (line_buf[i] == ':')
4875 {
4876 sep_cnt++;
4877
4878 continue;
4879 }
4880
4881 if (sep_cnt == 2) sep2_len++;
4882 if (sep_cnt == 3) sep3_len++;
4883 }
4884
4885 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4886
4887 return 0;
4888 }
4889
4890 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4891 {
4892 char *pos = NULL;
4893 int len = 0;
4894
4895 int sep_cnt = 0;
4896
4897 for (int i = 0; i < line_len; i++)
4898 {
4899 if (line_buf[i] == ':')
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (data.hash_mode == 1000)
4907 {
4908 if (sep_cnt == 3)
4909 {
4910 if (pos == NULL) pos = line_buf + i;
4911
4912 len++;
4913 }
4914 }
4915 else if (data.hash_mode == 3000)
4916 {
4917 if (sep_cnt == 2)
4918 {
4919 if (pos == NULL) pos = line_buf + i;
4920
4921 len++;
4922 }
4923 }
4924 }
4925
4926 *hashbuf_pos = pos;
4927 *hashbuf_len = len;
4928 }
4929
4930 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4931 {
4932 char *pos = NULL;
4933 int len = 0;
4934
4935 int sep_cnt = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 0)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953
4954 *userbuf_pos = pos;
4955 *userbuf_len = len;
4956 }
4957
4958 // hlfmt passwd
4959
4960 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4961 {
4962 int sep_cnt = 0;
4963
4964 char sep5_first = 0;
4965 char sep6_first = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4977 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4978 }
4979
4980 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4981
4982 return 0;
4983 }
4984
4985 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4986 {
4987 char *pos = NULL;
4988 int len = 0;
4989
4990 int sep_cnt = 0;
4991
4992 for (int i = 0; i < line_len; i++)
4993 {
4994 if (line_buf[i] == ':')
4995 {
4996 sep_cnt++;
4997
4998 continue;
4999 }
5000
5001 if (sep_cnt == 1)
5002 {
5003 if (pos == NULL) pos = line_buf + i;
5004
5005 len++;
5006 }
5007 }
5008
5009 *hashbuf_pos = pos;
5010 *hashbuf_len = len;
5011 }
5012
5013 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5014 {
5015 char *pos = NULL;
5016 int len = 0;
5017
5018 int sep_cnt = 0;
5019
5020 for (int i = 0; i < line_len; i++)
5021 {
5022 if (line_buf[i] == ':')
5023 {
5024 sep_cnt++;
5025
5026 continue;
5027 }
5028
5029 if (sep_cnt == 0)
5030 {
5031 if (pos == NULL) pos = line_buf + i;
5032
5033 len++;
5034 }
5035 }
5036
5037 *userbuf_pos = pos;
5038 *userbuf_len = len;
5039 }
5040
5041 // hlfmt shadow
5042
5043 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5044 {
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == ':') sep_cnt++;
5050 }
5051
5052 if (sep_cnt == 8) return 1;
5053
5054 return 0;
5055 }
5056
5057 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5058 {
5059 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5060 }
5061
5062 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5065 }
5066
5067 // hlfmt main
5068
5069 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5070 {
5071 switch (hashfile_format)
5072 {
5073 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5074 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5075 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5076 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5077 }
5078 }
5079
5080 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5081 {
5082 switch (hashfile_format)
5083 {
5084 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5085 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5086 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5087 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5088 }
5089 }
5090
5091 char *strhlfmt (const uint hashfile_format)
5092 {
5093 switch (hashfile_format)
5094 {
5095 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5096 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5097 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5098 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5099 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5100 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5101 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5102 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5103 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5104 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5105 }
5106
5107 return ((char *) "Unknown");
5108 }
5109
5110 static uint hlfmt_detect (FILE *fp, uint max_check)
5111 {
5112 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5113
5114 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5115 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5116
5117 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5118
5119 uint num_check = 0;
5120
5121 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5122
5123 while (!feof (fp))
5124 {
5125 int line_len = fgetl (fp, line_buf);
5126
5127 if (line_len == 0) continue;
5128
5129 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5130 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5131 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5132
5133 if (num_check == max_check) break;
5134
5135 num_check++;
5136 }
5137
5138 myfree (line_buf);
5139
5140 uint hashlist_format = HLFMT_HASHCAT;
5141
5142 for (int i = 1; i < HLFMTS_CNT; i++)
5143 {
5144 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5145
5146 hashlist_format = i;
5147 }
5148
5149 free (formats_cnt);
5150
5151 return hashlist_format;
5152 }
5153
5154 /**
5155 * some further helper function
5156 */
5157
5158 // wrapper around mymalloc for ADL
5159
5160 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5161 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5162 {
5163 return mymalloc (iSize);
5164 }
5165 #endif
5166
5167 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)
5168 {
5169 u64 collisions = 0;
5170
5171 const uint dgst_pos0 = data.dgst_pos0;
5172 const uint dgst_pos1 = data.dgst_pos1;
5173 const uint dgst_pos2 = data.dgst_pos2;
5174 const uint dgst_pos3 = data.dgst_pos3;
5175
5176 memset (bitmap_a, 0, bitmap_size);
5177 memset (bitmap_b, 0, bitmap_size);
5178 memset (bitmap_c, 0, bitmap_size);
5179 memset (bitmap_d, 0, bitmap_size);
5180
5181 for (uint i = 0; i < digests_cnt; i++)
5182 {
5183 uint *digest_ptr = (uint *) digests_buf_ptr;
5184
5185 digests_buf_ptr += dgst_size;
5186
5187 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5188 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5189 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5190 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5191
5192 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5193 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5194 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5195 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5196
5197 if (bitmap_a[idx0] & val0) collisions++;
5198 if (bitmap_b[idx1] & val1) collisions++;
5199 if (bitmap_c[idx2] & val2) collisions++;
5200 if (bitmap_d[idx3] & val3) collisions++;
5201
5202 bitmap_a[idx0] |= val0;
5203 bitmap_b[idx1] |= val1;
5204 bitmap_c[idx2] |= val2;
5205 bitmap_d[idx3] |= val3;
5206
5207 if (collisions >= collisions_max) return 0x7fffffff;
5208 }
5209
5210 return collisions;
5211 }
5212
5213 /**
5214 * main
5215 */
5216
5217 int main (int argc, char **argv)
5218 {
5219 /**
5220 * To help users a bit
5221 */
5222
5223 char *compute = getenv ("COMPUTE");
5224
5225 if (compute)
5226 {
5227 static char display[100];
5228
5229 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5230
5231 putenv (display);
5232 }
5233 else
5234 {
5235 if (getenv ("DISPLAY") == NULL)
5236 putenv ((char *) "DISPLAY=:0");
5237 }
5238
5239 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5240 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5241
5242 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5243 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5244
5245 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5246 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5247
5248 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5249 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5250
5251 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5252 putenv ((char *) "POCL_KERNEL_CACHE=0");
5253
5254 /**
5255 * Real init
5256 */
5257
5258 memset (&data, 0, sizeof (hc_global_data_t));
5259
5260 time_t proc_start;
5261
5262 time (&proc_start);
5263
5264 data.proc_start = proc_start;
5265
5266 int myargc = argc;
5267 char **myargv = argv;
5268
5269 hc_thread_mutex_init (mux_dispatcher);
5270 hc_thread_mutex_init (mux_counter);
5271 hc_thread_mutex_init (mux_display);
5272 hc_thread_mutex_init (mux_adl);
5273
5274 /**
5275 * commandline parameters
5276 */
5277
5278 uint usage = USAGE;
5279 uint version = VERSION;
5280 uint quiet = QUIET;
5281 uint benchmark = BENCHMARK;
5282 uint show = SHOW;
5283 uint left = LEFT;
5284 uint username = USERNAME;
5285 uint remove = REMOVE;
5286 uint remove_timer = REMOVE_TIMER;
5287 u64 skip = SKIP;
5288 u64 limit = LIMIT;
5289 uint keyspace = KEYSPACE;
5290 uint potfile_disable = POTFILE_DISABLE;
5291 char *potfile_path = NULL;
5292 uint debug_mode = DEBUG_MODE;
5293 char *debug_file = NULL;
5294 char *induction_dir = NULL;
5295 char *outfile_check_dir = NULL;
5296 uint force = FORCE;
5297 uint runtime = RUNTIME;
5298 uint hash_mode = HASH_MODE;
5299 uint attack_mode = ATTACK_MODE;
5300 uint markov_disable = MARKOV_DISABLE;
5301 uint markov_classic = MARKOV_CLASSIC;
5302 uint markov_threshold = MARKOV_THRESHOLD;
5303 char *markov_hcstat = NULL;
5304 char *outfile = NULL;
5305 uint outfile_format = OUTFILE_FORMAT;
5306 uint outfile_autohex = OUTFILE_AUTOHEX;
5307 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5308 uint restore = RESTORE;
5309 uint restore_timer = RESTORE_TIMER;
5310 uint restore_disable = RESTORE_DISABLE;
5311 uint status = STATUS;
5312 uint status_timer = STATUS_TIMER;
5313 uint status_automat = STATUS_AUTOMAT;
5314 uint loopback = LOOPBACK;
5315 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5316 char *session = NULL;
5317 uint hex_charset = HEX_CHARSET;
5318 uint hex_salt = HEX_SALT;
5319 uint hex_wordlist = HEX_WORDLIST;
5320 uint rp_gen = RP_GEN;
5321 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5322 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5323 uint rp_gen_seed = RP_GEN_SEED;
5324 char *rule_buf_l = (char *) RULE_BUF_L;
5325 char *rule_buf_r = (char *) RULE_BUF_R;
5326 uint increment = INCREMENT;
5327 uint increment_min = INCREMENT_MIN;
5328 uint increment_max = INCREMENT_MAX;
5329 char *cpu_affinity = NULL;
5330 OCL_PTR *ocl = NULL;
5331 char *opencl_devices = NULL;
5332 char *opencl_platforms = NULL;
5333 char *opencl_device_types = NULL;
5334 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5335 char *truecrypt_keyfiles = NULL;
5336 uint workload_profile = WORKLOAD_PROFILE;
5337 uint kernel_accel = KERNEL_ACCEL;
5338 uint kernel_loops = KERNEL_LOOPS;
5339 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5340 #ifdef HAVE_HWMON
5341 uint gpu_temp_abort = GPU_TEMP_ABORT;
5342 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5343 #ifdef HAVE_ADL
5344 uint powertune_enable = POWERTUNE_ENABLE;
5345 #endif
5346 #endif
5347 uint logfile_disable = LOGFILE_DISABLE;
5348 uint segment_size = SEGMENT_SIZE;
5349 uint scrypt_tmto = SCRYPT_TMTO;
5350 char separator = SEPARATOR;
5351 uint bitmap_min = BITMAP_MIN;
5352 uint bitmap_max = BITMAP_MAX;
5353 char *custom_charset_1 = NULL;
5354 char *custom_charset_2 = NULL;
5355 char *custom_charset_3 = NULL;
5356 char *custom_charset_4 = NULL;
5357
5358 #define IDX_HELP 'h'
5359 #define IDX_VERSION 'V'
5360 #define IDX_VERSION_LOWER 'v'
5361 #define IDX_QUIET 0xff02
5362 #define IDX_SHOW 0xff03
5363 #define IDX_LEFT 0xff04
5364 #define IDX_REMOVE 0xff05
5365 #define IDX_REMOVE_TIMER 0xff37
5366 #define IDX_SKIP 's'
5367 #define IDX_LIMIT 'l'
5368 #define IDX_KEYSPACE 0xff35
5369 #define IDX_POTFILE_DISABLE 0xff06
5370 #define IDX_POTFILE_PATH 0xffe0
5371 #define IDX_DEBUG_MODE 0xff43
5372 #define IDX_DEBUG_FILE 0xff44
5373 #define IDX_INDUCTION_DIR 0xff46
5374 #define IDX_OUTFILE_CHECK_DIR 0xff47
5375 #define IDX_USERNAME 0xff07
5376 #define IDX_FORCE 0xff08
5377 #define IDX_RUNTIME 0xff09
5378 #define IDX_BENCHMARK 'b'
5379 #define IDX_HASH_MODE 'm'
5380 #define IDX_ATTACK_MODE 'a'
5381 #define IDX_RP_FILE 'r'
5382 #define IDX_RP_GEN 'g'
5383 #define IDX_RP_GEN_FUNC_MIN 0xff10
5384 #define IDX_RP_GEN_FUNC_MAX 0xff11
5385 #define IDX_RP_GEN_SEED 0xff34
5386 #define IDX_RULE_BUF_L 'j'
5387 #define IDX_RULE_BUF_R 'k'
5388 #define IDX_INCREMENT 'i'
5389 #define IDX_INCREMENT_MIN 0xff12
5390 #define IDX_INCREMENT_MAX 0xff13
5391 #define IDX_OUTFILE 'o'
5392 #define IDX_OUTFILE_FORMAT 0xff14
5393 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5394 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5395 #define IDX_RESTORE 0xff15
5396 #define IDX_RESTORE_DISABLE 0xff27
5397 #define IDX_STATUS 0xff17
5398 #define IDX_STATUS_TIMER 0xff18
5399 #define IDX_STATUS_AUTOMAT 0xff50
5400 #define IDX_LOOPBACK 0xff38
5401 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5402 #define IDX_SESSION 0xff19
5403 #define IDX_HEX_CHARSET 0xff20
5404 #define IDX_HEX_SALT 0xff21
5405 #define IDX_HEX_WORDLIST 0xff40
5406 #define IDX_MARKOV_DISABLE 0xff22
5407 #define IDX_MARKOV_CLASSIC 0xff23
5408 #define IDX_MARKOV_THRESHOLD 't'
5409 #define IDX_MARKOV_HCSTAT 0xff24
5410 #define IDX_CPU_AFFINITY 0xff25
5411 #define IDX_OPENCL_DEVICES 'd'
5412 #define IDX_OPENCL_PLATFORMS 0xff72
5413 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5414 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5415 #define IDX_WORKLOAD_PROFILE 'w'
5416 #define IDX_KERNEL_ACCEL 'n'
5417 #define IDX_KERNEL_LOOPS 'u'
5418 #define IDX_GPU_TEMP_DISABLE 0xff29
5419 #define IDX_GPU_TEMP_ABORT 0xff30
5420 #define IDX_GPU_TEMP_RETAIN 0xff31
5421 #define IDX_POWERTUNE_ENABLE 0xff41
5422 #define IDX_LOGFILE_DISABLE 0xff51
5423 #define IDX_TRUECRYPT_KEYFILES 0xff52
5424 #define IDX_SCRYPT_TMTO 0xff61
5425 #define IDX_SEGMENT_SIZE 'c'
5426 #define IDX_SEPARATOR 'p'
5427 #define IDX_BITMAP_MIN 0xff70
5428 #define IDX_BITMAP_MAX 0xff71
5429 #define IDX_CUSTOM_CHARSET_1 '1'
5430 #define IDX_CUSTOM_CHARSET_2 '2'
5431 #define IDX_CUSTOM_CHARSET_3 '3'
5432 #define IDX_CUSTOM_CHARSET_4 '4'
5433
5434 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5435
5436 struct option long_options[] =
5437 {
5438 {"help", no_argument, 0, IDX_HELP},
5439 {"version", no_argument, 0, IDX_VERSION},
5440 {"quiet", no_argument, 0, IDX_QUIET},
5441 {"show", no_argument, 0, IDX_SHOW},
5442 {"left", no_argument, 0, IDX_LEFT},
5443 {"username", no_argument, 0, IDX_USERNAME},
5444 {"remove", no_argument, 0, IDX_REMOVE},
5445 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5446 {"skip", required_argument, 0, IDX_SKIP},
5447 {"limit", required_argument, 0, IDX_LIMIT},
5448 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5449 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5450 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5451 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5452 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5453 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5454 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5455 {"force", no_argument, 0, IDX_FORCE},
5456 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5457 {"restore", no_argument, 0, IDX_RESTORE},
5458 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5459 {"status", no_argument, 0, IDX_STATUS},
5460 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5461 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5462 {"loopback", no_argument, 0, IDX_LOOPBACK},
5463 {"weak-hash-threshold",
5464 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5465 {"session", required_argument, 0, IDX_SESSION},
5466 {"runtime", required_argument, 0, IDX_RUNTIME},
5467 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5468 {"generate-rules-func-min",
5469 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5470 {"generate-rules-func-max",
5471 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5472 {"generate-rules-seed",
5473 required_argument, 0, IDX_RP_GEN_SEED},
5474 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5475 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5476 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5477 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5478 {"rules-file", required_argument, 0, IDX_RP_FILE},
5479 {"outfile", required_argument, 0, IDX_OUTFILE},
5480 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5481 {"outfile-autohex-disable",
5482 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5483 {"outfile-check-timer",
5484 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5485 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5486 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5487 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5488 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5489 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5490 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5491 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5492 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5493 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5494 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5495 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5496 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5497 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5498 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5499 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5500 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5501 #ifdef HAVE_HWMON
5502 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5503 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5504 #ifdef HAVE_ADL
5505 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5506 #endif
5507 #endif // HAVE_HWMON
5508 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5509 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5510 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5511 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5512 // deprecated
5513 {"seperator", required_argument, 0, IDX_SEPARATOR},
5514 {"separator", required_argument, 0, IDX_SEPARATOR},
5515 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5516 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5517 {"increment", no_argument, 0, IDX_INCREMENT},
5518 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5519 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5520 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5521 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5522 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5523 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5524
5525 {0, 0, 0, 0}
5526 };
5527
5528 uint rp_files_cnt = 0;
5529
5530 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5531
5532 int option_index = 0;
5533 int c = -1;
5534
5535 optind = 1;
5536 optopt = 0;
5537
5538 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5539 {
5540 switch (c)
5541 {
5542 case IDX_HELP: usage = 1; break;
5543 case IDX_VERSION:
5544 case IDX_VERSION_LOWER: version = 1; break;
5545 case IDX_RESTORE: restore = 1; break;
5546 case IDX_SESSION: session = optarg; break;
5547 case IDX_SHOW: show = 1; break;
5548 case IDX_LEFT: left = 1; break;
5549 case '?': return (-1);
5550 }
5551 }
5552
5553 if (optopt != 0)
5554 {
5555 log_error ("ERROR: Invalid argument specified");
5556
5557 return (-1);
5558 }
5559
5560 /**
5561 * exit functions
5562 */
5563
5564 if (version)
5565 {
5566 log_info ("%s", VERSION_TAG);
5567
5568 return (0);
5569 }
5570
5571 if (usage)
5572 {
5573 usage_big_print (PROGNAME);
5574
5575 return (0);
5576 }
5577
5578 /**
5579 * session needs to be set, always!
5580 */
5581
5582 if (session == NULL) session = (char *) PROGNAME;
5583
5584 /**
5585 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5586 */
5587
5588 char *exec_path = get_exec_path ();
5589
5590 #ifdef LINUX
5591
5592 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5593 char *resolved_exec_path = realpath (exec_path, NULL);
5594
5595 char *install_dir = get_install_dir (resolved_exec_path);
5596 char *profile_dir = NULL;
5597 char *session_dir = NULL;
5598 char *shared_dir = NULL;
5599
5600 if (strcmp (install_dir, resolved_install_folder) == 0)
5601 {
5602 struct passwd *pw = getpwuid (getuid ());
5603
5604 const char *homedir = pw->pw_dir;
5605
5606 profile_dir = get_profile_dir (homedir);
5607 session_dir = get_session_dir (profile_dir);
5608 shared_dir = strdup (SHARED_FOLDER);
5609
5610 mkdir (profile_dir, 0700);
5611 mkdir (session_dir, 0700);
5612 }
5613 else
5614 {
5615 profile_dir = install_dir;
5616 session_dir = install_dir;
5617 shared_dir = install_dir;
5618 }
5619
5620 myfree (resolved_install_folder);
5621 myfree (resolved_exec_path);
5622
5623 #else
5624
5625 char *install_dir = get_install_dir (exec_path);
5626 char *profile_dir = install_dir;
5627 char *session_dir = install_dir;
5628 char *shared_dir = install_dir;
5629
5630 #endif
5631
5632 data.install_dir = install_dir;
5633 data.profile_dir = profile_dir;
5634 data.session_dir = session_dir;
5635 data.shared_dir = shared_dir;
5636
5637 myfree (exec_path);
5638
5639 /**
5640 * kernel cache, we need to make sure folder exist
5641 */
5642
5643 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5644
5645 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5646
5647 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5648
5649 mkdir (kernels_folder, 0700);
5650
5651 myfree (kernels_folder);
5652
5653 /**
5654 * session
5655 */
5656
5657 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5658
5659 data.session = session;
5660
5661 char *eff_restore_file = (char *) mymalloc (session_size);
5662 char *new_restore_file = (char *) mymalloc (session_size);
5663
5664 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5665 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5666
5667 data.eff_restore_file = eff_restore_file;
5668 data.new_restore_file = new_restore_file;
5669
5670 if (((show == 1) || (left == 1)) && (restore == 1))
5671 {
5672 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5673 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5674
5675 return (-1);
5676 }
5677
5678 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5679 if ((show == 1) || (left == 1))
5680 {
5681 restore_disable = 1;
5682
5683 restore = 0;
5684 }
5685
5686 data.restore_disable = restore_disable;
5687
5688 restore_data_t *rd = init_restore (argc, argv);
5689
5690 data.rd = rd;
5691
5692 /**
5693 * restore file
5694 */
5695
5696 if (restore == 1)
5697 {
5698 read_restore (eff_restore_file, rd);
5699
5700 if (rd->version_bin < RESTORE_MIN)
5701 {
5702 log_error ("ERROR: Incompatible restore-file version");
5703
5704 return (-1);
5705 }
5706
5707 myargc = rd->argc;
5708 myargv = rd->argv;
5709
5710 #ifdef _POSIX
5711 rd->pid = getpid ();
5712 #elif _WIN
5713 rd->pid = GetCurrentProcessId ();
5714 #endif
5715 }
5716
5717 uint hash_mode_chgd = 0;
5718 uint runtime_chgd = 0;
5719 uint kernel_loops_chgd = 0;
5720 uint kernel_accel_chgd = 0;
5721 uint attack_mode_chgd = 0;
5722 uint outfile_format_chgd = 0;
5723 uint rp_gen_seed_chgd = 0;
5724 uint remove_timer_chgd = 0;
5725 uint increment_min_chgd = 0;
5726 uint increment_max_chgd = 0;
5727 uint workload_profile_chgd = 0;
5728 uint opencl_vector_width_chgd = 0;
5729
5730 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5731 uint gpu_temp_retain_chgd = 0;
5732 uint gpu_temp_abort_chgd = 0;
5733 #endif
5734
5735 optind = 1;
5736 optopt = 0;
5737 option_index = 0;
5738
5739 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5740 {
5741 switch (c)
5742 {
5743 //case IDX_HELP: usage = 1; break;
5744 //case IDX_VERSION: version = 1; break;
5745 //case IDX_RESTORE: restore = 1; break;
5746 case IDX_QUIET: quiet = 1; break;
5747 //case IDX_SHOW: show = 1; break;
5748 case IDX_SHOW: break;
5749 //case IDX_LEFT: left = 1; break;
5750 case IDX_LEFT: break;
5751 case IDX_USERNAME: username = 1; break;
5752 case IDX_REMOVE: remove = 1; break;
5753 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5754 remove_timer_chgd = 1; break;
5755 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5756 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5757 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5758 case IDX_DEBUG_FILE: debug_file = optarg; break;
5759 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5760 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5761 case IDX_FORCE: force = 1; break;
5762 case IDX_SKIP: skip = atoll (optarg); break;
5763 case IDX_LIMIT: limit = atoll (optarg); break;
5764 case IDX_KEYSPACE: keyspace = 1; break;
5765 case IDX_BENCHMARK: benchmark = 1; break;
5766 case IDX_RESTORE: break;
5767 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5768 case IDX_STATUS: status = 1; break;
5769 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5770 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5771 case IDX_LOOPBACK: loopback = 1; break;
5772 case IDX_WEAK_HASH_THRESHOLD:
5773 weak_hash_threshold = atoi (optarg); break;
5774 //case IDX_SESSION: session = optarg; break;
5775 case IDX_SESSION: break;
5776 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5777 hash_mode_chgd = 1; break;
5778 case IDX_RUNTIME: runtime = atoi (optarg);
5779 runtime_chgd = 1; break;
5780 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5781 attack_mode_chgd = 1; break;
5782 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5783 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5784 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5785 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5786 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5787 rp_gen_seed_chgd = 1; break;
5788 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5789 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5790 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5791 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5792 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5793 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5794 case IDX_OUTFILE: outfile = optarg; break;
5795 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5796 outfile_format_chgd = 1; break;
5797 case IDX_OUTFILE_AUTOHEX_DISABLE:
5798 outfile_autohex = 0; break;
5799 case IDX_OUTFILE_CHECK_TIMER:
5800 outfile_check_timer = atoi (optarg); break;
5801 case IDX_HEX_CHARSET: hex_charset = 1; break;
5802 case IDX_HEX_SALT: hex_salt = 1; break;
5803 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5804 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5805 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5806 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5807 case IDX_OPENCL_DEVICE_TYPES:
5808 opencl_device_types = optarg; break;
5809 case IDX_OPENCL_VECTOR_WIDTH:
5810 opencl_vector_width = atoi (optarg);
5811 opencl_vector_width_chgd = 1; break;
5812 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5813 workload_profile_chgd = 1; break;
5814 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5815 kernel_accel_chgd = 1; break;
5816 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5817 kernel_loops_chgd = 1; break;
5818 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5819 #ifdef HAVE_HWMON
5820 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5821 #ifdef HAVE_ADL
5822 gpu_temp_abort_chgd = 1;
5823 #endif
5824 break;
5825 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5826 #ifdef HAVE_ADL
5827 gpu_temp_retain_chgd = 1;
5828 #endif
5829 break;
5830 #ifdef HAVE_ADL
5831 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5832 #endif
5833 #endif // HAVE_HWMON
5834 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5835 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5836 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5837 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5838 case IDX_SEPARATOR: separator = optarg[0]; break;
5839 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5840 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5841 case IDX_INCREMENT: increment = 1; break;
5842 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5843 increment_min_chgd = 1; break;
5844 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5845 increment_max_chgd = 1; break;
5846 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5847 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5848 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5849 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5850
5851 default:
5852 log_error ("ERROR: Invalid argument specified");
5853 return (-1);
5854 }
5855 }
5856
5857 if (optopt != 0)
5858 {
5859 log_error ("ERROR: Invalid argument specified");
5860
5861 return (-1);
5862 }
5863
5864 /**
5865 * Inform user things getting started,
5866 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5867 * - we do not need to check algorithm_pos
5868 */
5869
5870 if (quiet == 0)
5871 {
5872 if (benchmark == 1)
5873 {
5874 if (status_automat == 0)
5875 {
5876 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5877 log_info ("");
5878 }
5879 else
5880 {
5881 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5882 }
5883 }
5884 else if (restore == 1)
5885 {
5886 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5887 log_info ("");
5888 }
5889 else
5890 {
5891 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5892 log_info ("");
5893 }
5894 }
5895
5896 /**
5897 * sanity check
5898 */
5899
5900 if (attack_mode > 7)
5901 {
5902 log_error ("ERROR: Invalid attack-mode specified");
5903
5904 return (-1);
5905 }
5906
5907 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5908 {
5909 log_error ("ERROR: Invalid runtime specified");
5910
5911 return (-1);
5912 }
5913
5914 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5915 {
5916 log_error ("ERROR: Invalid hash-type specified");
5917
5918 return (-1);
5919 }
5920
5921 // renamed hash modes
5922
5923 if (hash_mode_chgd)
5924 {
5925 int n = -1;
5926
5927 switch (hash_mode)
5928 {
5929 case 123: n = 124;
5930 break;
5931 }
5932
5933 if (n >= 0)
5934 {
5935 log_error ("Old -m specified, use -m %d instead", n);
5936
5937 return (-1);
5938 }
5939 }
5940
5941 if (username == 1)
5942 {
5943 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5944 {
5945 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5946
5947 return (-1);
5948 }
5949 }
5950
5951 if (outfile_format > 16)
5952 {
5953 log_error ("ERROR: Invalid outfile-format specified");
5954
5955 return (-1);
5956 }
5957
5958 if (left == 1)
5959 {
5960 if (outfile_format_chgd == 1)
5961 {
5962 if (outfile_format > 1)
5963 {
5964 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5965
5966 return (-1);
5967 }
5968 }
5969 else
5970 {
5971 outfile_format = OUTFILE_FMT_HASH;
5972 }
5973 }
5974
5975 if (show == 1)
5976 {
5977 if (outfile_format_chgd == 1)
5978 {
5979 if ((outfile_format > 7) && (outfile_format < 16))
5980 {
5981 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5982
5983 return (-1);
5984 }
5985 }
5986 }
5987
5988 if (increment_min < INCREMENT_MIN)
5989 {
5990 log_error ("ERROR: Invalid increment-min specified");
5991
5992 return (-1);
5993 }
5994
5995 if (increment_max > INCREMENT_MAX)
5996 {
5997 log_error ("ERROR: Invalid increment-max specified");
5998
5999 return (-1);
6000 }
6001
6002 if (increment_min > increment_max)
6003 {
6004 log_error ("ERROR: Invalid increment-min specified");
6005
6006 return (-1);
6007 }
6008
6009 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6010 {
6011 log_error ("ERROR: increment is not allowed in attack-mode 0");
6012
6013 return (-1);
6014 }
6015
6016 if ((increment == 0) && (increment_min_chgd == 1))
6017 {
6018 log_error ("ERROR: increment-min is only supported together with increment switch");
6019
6020 return (-1);
6021 }
6022
6023 if ((increment == 0) && (increment_max_chgd == 1))
6024 {
6025 log_error ("ERROR: increment-max is only supported together with increment switch");
6026
6027 return (-1);
6028 }
6029
6030 if (rp_files_cnt && rp_gen)
6031 {
6032 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6033
6034 return (-1);
6035 }
6036
6037 if (rp_files_cnt || rp_gen)
6038 {
6039 if (attack_mode != ATTACK_MODE_STRAIGHT)
6040 {
6041 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6042
6043 return (-1);
6044 }
6045 }
6046
6047 if (rp_gen_func_min > rp_gen_func_max)
6048 {
6049 log_error ("ERROR: Invalid rp-gen-func-min specified");
6050
6051 return (-1);
6052 }
6053
6054 if (kernel_accel_chgd == 1)
6055 {
6056 if (kernel_accel < 1)
6057 {
6058 log_error ("ERROR: Invalid kernel-accel specified");
6059
6060 return (-1);
6061 }
6062
6063 if (kernel_accel > 1024)
6064 {
6065 log_error ("ERROR: Invalid kernel-accel specified");
6066
6067 return (-1);
6068 }
6069 }
6070
6071 if (kernel_loops_chgd == 1)
6072 {
6073 if (kernel_loops < 1)
6074 {
6075 log_error ("ERROR: Invalid kernel-loops specified");
6076
6077 return (-1);
6078 }
6079
6080 if (kernel_loops > 1024)
6081 {
6082 log_error ("ERROR: Invalid kernel-loops specified");
6083
6084 return (-1);
6085 }
6086 }
6087
6088 if ((workload_profile < 1) || (workload_profile > 3))
6089 {
6090 log_error ("ERROR: workload-profile %i not available", workload_profile);
6091
6092 return (-1);
6093 }
6094
6095 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6096 {
6097 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6098
6099 return (-1);
6100 }
6101
6102 if (show == 1 || left == 1)
6103 {
6104 attack_mode = ATTACK_MODE_NONE;
6105
6106 if (remove == 1)
6107 {
6108 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6109
6110 return (-1);
6111 }
6112
6113 if (potfile_disable == 1)
6114 {
6115 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6116
6117 return (-1);
6118 }
6119 }
6120
6121 uint attack_kern = ATTACK_KERN_NONE;
6122
6123 switch (attack_mode)
6124 {
6125 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6126 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6127 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6128 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6129 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6130 }
6131
6132 if (benchmark == 0)
6133 {
6134 if (keyspace == 1)
6135 {
6136 int num_additional_params = 1;
6137
6138 if (attack_kern == ATTACK_KERN_COMBI)
6139 {
6140 num_additional_params = 2;
6141 }
6142
6143 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6144
6145 if (keyspace_wordlist_specified == 0) optind--;
6146 }
6147
6148 if (attack_kern == ATTACK_KERN_NONE)
6149 {
6150 if ((optind + 1) != myargc)
6151 {
6152 usage_mini_print (myargv[0]);
6153
6154 return (-1);
6155 }
6156 }
6157 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6158 {
6159 if ((optind + 1) > myargc)
6160 {
6161 usage_mini_print (myargv[0]);
6162
6163 return (-1);
6164 }
6165 }
6166 else if (attack_kern == ATTACK_KERN_COMBI)
6167 {
6168 if ((optind + 3) != myargc)
6169 {
6170 usage_mini_print (myargv[0]);
6171
6172 return (-1);
6173 }
6174 }
6175 else if (attack_kern == ATTACK_KERN_BF)
6176 {
6177 if ((optind + 1) > myargc)
6178 {
6179 usage_mini_print (myargv[0]);
6180
6181 return (-1);
6182 }
6183 }
6184 else
6185 {
6186 usage_mini_print (myargv[0]);
6187
6188 return (-1);
6189 }
6190 }
6191 else
6192 {
6193 if (myargv[optind] != 0)
6194 {
6195 log_error ("ERROR: Invalid argument for benchmark mode specified");
6196
6197 return (-1);
6198 }
6199
6200 if (attack_mode_chgd == 1)
6201 {
6202 if (attack_mode != ATTACK_MODE_BF)
6203 {
6204 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6205
6206 return (-1);
6207 }
6208 }
6209 }
6210
6211 if (skip != 0 && limit != 0)
6212 {
6213 limit += skip;
6214 }
6215
6216 if (keyspace == 1)
6217 {
6218 if (show == 1)
6219 {
6220 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6221
6222 return (-1);
6223 }
6224 else if (left == 1)
6225 {
6226 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6227
6228 return (-1);
6229 }
6230
6231 potfile_disable = 1;
6232
6233 restore_disable = 1;
6234
6235 restore = 0;
6236
6237 weak_hash_threshold = 0;
6238
6239 quiet = 1;
6240 }
6241
6242 if (remove_timer_chgd == 1)
6243 {
6244 if (remove == 0)
6245 {
6246 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6247
6248 return (-1);
6249 }
6250
6251 if (remove_timer < 1)
6252 {
6253 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (loopback == 1)
6260 {
6261 if (attack_mode == ATTACK_MODE_STRAIGHT)
6262 {
6263 if ((rp_files_cnt == 0) && (rp_gen == 0))
6264 {
6265 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6266
6267 return (-1);
6268 }
6269 }
6270 else
6271 {
6272 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6273
6274 return (-1);
6275 }
6276 }
6277
6278 if (debug_mode > 0)
6279 {
6280 if (attack_mode != ATTACK_MODE_STRAIGHT)
6281 {
6282 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6283
6284 return (-1);
6285 }
6286
6287 if ((rp_files_cnt == 0) && (rp_gen == 0))
6288 {
6289 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6290
6291 return (-1);
6292 }
6293 }
6294
6295 if (debug_mode > 4)
6296 {
6297 log_error ("ERROR: Invalid debug-mode specified");
6298
6299 return (-1);
6300 }
6301
6302 if (debug_file != NULL)
6303 {
6304 if (debug_mode < 1)
6305 {
6306 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6307
6308 return (-1);
6309 }
6310 }
6311
6312 if (induction_dir != NULL)
6313 {
6314 if (attack_mode == ATTACK_MODE_BF)
6315 {
6316 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6317
6318 return (-1);
6319 }
6320 }
6321
6322 if (attack_mode != ATTACK_MODE_STRAIGHT)
6323 {
6324 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6325 {
6326 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6327
6328 return (-1);
6329 }
6330
6331 weak_hash_threshold = 0;
6332 }
6333
6334 /**
6335 * induction directory
6336 */
6337
6338 char *induction_directory = NULL;
6339
6340 if (attack_mode != ATTACK_MODE_BF)
6341 {
6342 if (induction_dir == NULL)
6343 {
6344 induction_directory = (char *) mymalloc (session_size);
6345
6346 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6347
6348 // create induction folder if it does not already exist
6349
6350 if (keyspace == 0)
6351 {
6352 if (rmdir (induction_directory) == -1)
6353 {
6354 if (errno == ENOENT)
6355 {
6356 // good, we can ignore
6357 }
6358 else if (errno == ENOTEMPTY)
6359 {
6360 char *induction_directory_mv = (char *) mymalloc (session_size);
6361
6362 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6363
6364 if (rename (induction_directory, induction_directory_mv) != 0)
6365 {
6366 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6367
6368 return (-1);
6369 }
6370 }
6371 else
6372 {
6373 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (mkdir (induction_directory, 0700) == -1)
6380 {
6381 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6382
6383 return (-1);
6384 }
6385 }
6386 }
6387 else
6388 {
6389 induction_directory = induction_dir;
6390 }
6391 }
6392
6393 data.induction_directory = induction_directory;
6394
6395 /**
6396 * loopback
6397 */
6398
6399 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6400
6401 char *loopback_file = (char *) mymalloc (loopback_size);
6402
6403 /**
6404 * tuning db
6405 */
6406
6407 char tuning_db_file[256] = { 0 };
6408
6409 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6410
6411 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6412
6413 /**
6414 * outfile-check directory
6415 */
6416
6417 char *outfile_check_directory = NULL;
6418
6419 if (outfile_check_dir == NULL)
6420 {
6421 outfile_check_directory = (char *) mymalloc (session_size);
6422
6423 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6424 }
6425 else
6426 {
6427 outfile_check_directory = outfile_check_dir;
6428 }
6429
6430 data.outfile_check_directory = outfile_check_directory;
6431
6432 if (keyspace == 0)
6433 {
6434 struct stat outfile_check_stat;
6435
6436 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6437 {
6438 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6439
6440 if (is_dir == 0)
6441 {
6442 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6443
6444 return (-1);
6445 }
6446 }
6447 else if (outfile_check_dir == NULL)
6448 {
6449 if (mkdir (outfile_check_directory, 0700) == -1)
6450 {
6451 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6452
6453 return (-1);
6454 }
6455 }
6456 }
6457
6458 /**
6459 * special other stuff
6460 */
6461
6462 if (hash_mode == 9710)
6463 {
6464 outfile_format = 5;
6465 outfile_format_chgd = 1;
6466 }
6467
6468 if (hash_mode == 9810)
6469 {
6470 outfile_format = 5;
6471 outfile_format_chgd = 1;
6472 }
6473
6474 if (hash_mode == 10410)
6475 {
6476 outfile_format = 5;
6477 outfile_format_chgd = 1;
6478 }
6479
6480 /**
6481 * store stuff
6482 */
6483
6484 data.hash_mode = hash_mode;
6485 data.restore = restore;
6486 data.restore_timer = restore_timer;
6487 data.restore_disable = restore_disable;
6488 data.status = status;
6489 data.status_timer = status_timer;
6490 data.status_automat = status_automat;
6491 data.loopback = loopback;
6492 data.runtime = runtime;
6493 data.remove = remove;
6494 data.remove_timer = remove_timer;
6495 data.debug_mode = debug_mode;
6496 data.debug_file = debug_file;
6497 data.username = username;
6498 data.quiet = quiet;
6499 data.outfile = outfile;
6500 data.outfile_format = outfile_format;
6501 data.outfile_autohex = outfile_autohex;
6502 data.hex_charset = hex_charset;
6503 data.hex_salt = hex_salt;
6504 data.hex_wordlist = hex_wordlist;
6505 data.separator = separator;
6506 data.rp_files = rp_files;
6507 data.rp_files_cnt = rp_files_cnt;
6508 data.rp_gen = rp_gen;
6509 data.rp_gen_seed = rp_gen_seed;
6510 data.force = force;
6511 data.benchmark = benchmark;
6512 data.skip = skip;
6513 data.limit = limit;
6514 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6515 data.powertune_enable = powertune_enable;
6516 #endif
6517 data.logfile_disable = logfile_disable;
6518 data.truecrypt_keyfiles = truecrypt_keyfiles;
6519 data.scrypt_tmto = scrypt_tmto;
6520 data.workload_profile = workload_profile;
6521
6522 /**
6523 * cpu affinity
6524 */
6525
6526 if (cpu_affinity)
6527 {
6528 set_cpu_affinity (cpu_affinity);
6529 }
6530
6531 if (rp_gen_seed_chgd == 0)
6532 {
6533 srand (proc_start);
6534 }
6535 else
6536 {
6537 srand (rp_gen_seed);
6538 }
6539
6540 /**
6541 * logfile init
6542 */
6543
6544 if (logfile_disable == 0)
6545 {
6546 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6547
6548 char *logfile = (char *) mymalloc (logfile_size);
6549
6550 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6551
6552 data.logfile = logfile;
6553
6554 char *topid = logfile_generate_topid ();
6555
6556 data.topid = topid;
6557 }
6558
6559 // logfile_append() checks for logfile_disable internally to make it easier from here
6560
6561 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6562 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6563 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6564 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6565 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6566 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6567 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6568 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6569 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6570 #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));
6571
6572 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6573 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6574 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6575 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6576 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6577 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6578 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6579 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6580
6581 logfile_top_msg ("START");
6582
6583 logfile_top_uint (attack_mode);
6584 logfile_top_uint (attack_kern);
6585 logfile_top_uint (benchmark);
6586 logfile_top_uint (bitmap_min);
6587 logfile_top_uint (bitmap_max);
6588 logfile_top_uint (debug_mode);
6589 logfile_top_uint (force);
6590 logfile_top_uint (kernel_accel);
6591 logfile_top_uint (kernel_loops);
6592 logfile_top_uint (gpu_temp_disable);
6593 #ifdef HAVE_HWMON
6594 logfile_top_uint (gpu_temp_abort);
6595 logfile_top_uint (gpu_temp_retain);
6596 #endif
6597 logfile_top_uint (hash_mode);
6598 logfile_top_uint (hex_charset);
6599 logfile_top_uint (hex_salt);
6600 logfile_top_uint (hex_wordlist);
6601 logfile_top_uint (increment);
6602 logfile_top_uint (increment_max);
6603 logfile_top_uint (increment_min);
6604 logfile_top_uint (keyspace);
6605 logfile_top_uint (left);
6606 logfile_top_uint (logfile_disable);
6607 logfile_top_uint (loopback);
6608 logfile_top_uint (markov_classic);
6609 logfile_top_uint (markov_disable);
6610 logfile_top_uint (markov_threshold);
6611 logfile_top_uint (outfile_autohex);
6612 logfile_top_uint (outfile_check_timer);
6613 logfile_top_uint (outfile_format);
6614 logfile_top_uint (potfile_disable);
6615 logfile_top_string (potfile_path);
6616 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6617 logfile_top_uint (powertune_enable);
6618 #endif
6619 logfile_top_uint (scrypt_tmto);
6620 logfile_top_uint (quiet);
6621 logfile_top_uint (remove);
6622 logfile_top_uint (remove_timer);
6623 logfile_top_uint (restore);
6624 logfile_top_uint (restore_disable);
6625 logfile_top_uint (restore_timer);
6626 logfile_top_uint (rp_gen);
6627 logfile_top_uint (rp_gen_func_max);
6628 logfile_top_uint (rp_gen_func_min);
6629 logfile_top_uint (rp_gen_seed);
6630 logfile_top_uint (runtime);
6631 logfile_top_uint (segment_size);
6632 logfile_top_uint (show);
6633 logfile_top_uint (status);
6634 logfile_top_uint (status_automat);
6635 logfile_top_uint (status_timer);
6636 logfile_top_uint (usage);
6637 logfile_top_uint (username);
6638 logfile_top_uint (version);
6639 logfile_top_uint (weak_hash_threshold);
6640 logfile_top_uint (workload_profile);
6641 logfile_top_uint64 (limit);
6642 logfile_top_uint64 (skip);
6643 logfile_top_char (separator);
6644 logfile_top_string (cpu_affinity);
6645 logfile_top_string (custom_charset_1);
6646 logfile_top_string (custom_charset_2);
6647 logfile_top_string (custom_charset_3);
6648 logfile_top_string (custom_charset_4);
6649 logfile_top_string (debug_file);
6650 logfile_top_string (opencl_devices);
6651 logfile_top_string (opencl_platforms);
6652 logfile_top_string (opencl_device_types);
6653 logfile_top_uint (opencl_vector_width);
6654 logfile_top_string (induction_dir);
6655 logfile_top_string (markov_hcstat);
6656 logfile_top_string (outfile);
6657 logfile_top_string (outfile_check_dir);
6658 logfile_top_string (rule_buf_l);
6659 logfile_top_string (rule_buf_r);
6660 logfile_top_string (session);
6661 logfile_top_string (truecrypt_keyfiles);
6662
6663 /**
6664 * Init OpenCL library loader
6665 */
6666
6667 if (keyspace == 0)
6668 {
6669 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6670
6671 ocl_init (ocl);
6672
6673 data.ocl = ocl;
6674 }
6675
6676 /**
6677 * OpenCL platform selection
6678 */
6679
6680 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6681
6682 /**
6683 * OpenCL device selection
6684 */
6685
6686 u32 devices_filter = setup_devices_filter (opencl_devices);
6687
6688 /**
6689 * OpenCL device type selection
6690 */
6691
6692 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6693
6694 /**
6695 * benchmark
6696 */
6697
6698 if (benchmark == 1)
6699 {
6700 /**
6701 * disable useless stuff for benchmark
6702 */
6703
6704 status_timer = 0;
6705 restore_timer = 0;
6706 restore_disable = 1;
6707 potfile_disable = 1;
6708 weak_hash_threshold = 0;
6709 gpu_temp_disable = 1;
6710
6711 data.status_timer = status_timer;
6712 data.restore_timer = restore_timer;
6713 data.restore_disable = restore_disable;
6714
6715 /**
6716 * force attack mode to be bruteforce
6717 */
6718
6719 attack_mode = ATTACK_MODE_BF;
6720 attack_kern = ATTACK_KERN_BF;
6721
6722 if (workload_profile_chgd == 0)
6723 {
6724 workload_profile = 3;
6725
6726 data.workload_profile = workload_profile;
6727 }
6728 }
6729
6730 /**
6731 * config
6732 */
6733
6734 uint hash_type = 0;
6735 uint salt_type = 0;
6736 uint attack_exec = 0;
6737 uint opts_type = 0;
6738 uint kern_type = 0;
6739 uint dgst_size = 0;
6740 uint esalt_size = 0;
6741 uint opti_type = 0;
6742 uint dgst_pos0 = -1;
6743 uint dgst_pos1 = -1;
6744 uint dgst_pos2 = -1;
6745 uint dgst_pos3 = -1;
6746
6747 int (*parse_func) (char *, uint, hash_t *);
6748 int (*sort_by_digest) (const void *, const void *);
6749
6750 uint algorithm_pos = 0;
6751 uint algorithm_max = 1;
6752
6753 uint *algorithms = default_benchmark_algorithms;
6754
6755 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6756
6757 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6758 {
6759 /*
6760 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6761 * the following algos are skipped entirely
6762 */
6763
6764 if (algorithm_pos > 0)
6765 {
6766 local_free (rd);
6767
6768 rd = init_restore (argc, argv);
6769
6770 data.rd = rd;
6771 }
6772
6773 /**
6774 * update hash_mode in case of multihash benchmark
6775 */
6776
6777 if (benchmark == 1)
6778 {
6779 if (hash_mode_chgd == 0)
6780 {
6781 hash_mode = algorithms[algorithm_pos];
6782
6783 data.hash_mode = hash_mode;
6784 }
6785
6786 quiet = 1;
6787
6788 data.quiet = quiet;
6789 }
6790
6791 switch (hash_mode)
6792 {
6793 case 0: hash_type = HASH_TYPE_MD5;
6794 salt_type = SALT_TYPE_NONE;
6795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6796 opts_type = OPTS_TYPE_PT_GENERATE_LE
6797 | OPTS_TYPE_PT_ADD80
6798 | OPTS_TYPE_PT_ADDBITS14;
6799 kern_type = KERN_TYPE_MD5;
6800 dgst_size = DGST_SIZE_4_4;
6801 parse_func = md5_parse_hash;
6802 sort_by_digest = sort_by_digest_4_4;
6803 opti_type = OPTI_TYPE_ZERO_BYTE
6804 | OPTI_TYPE_PRECOMPUTE_INIT
6805 | OPTI_TYPE_PRECOMPUTE_MERKLE
6806 | OPTI_TYPE_MEET_IN_MIDDLE
6807 | OPTI_TYPE_EARLY_SKIP
6808 | OPTI_TYPE_NOT_ITERATED
6809 | OPTI_TYPE_NOT_SALTED
6810 | OPTI_TYPE_RAW_HASH;
6811 dgst_pos0 = 0;
6812 dgst_pos1 = 3;
6813 dgst_pos2 = 2;
6814 dgst_pos3 = 1;
6815 break;
6816
6817 case 10: hash_type = HASH_TYPE_MD5;
6818 salt_type = SALT_TYPE_INTERN;
6819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6820 opts_type = OPTS_TYPE_PT_GENERATE_LE
6821 | OPTS_TYPE_ST_ADD80
6822 | OPTS_TYPE_ST_ADDBITS14;
6823 kern_type = KERN_TYPE_MD5_PWSLT;
6824 dgst_size = DGST_SIZE_4_4;
6825 parse_func = md5s_parse_hash;
6826 sort_by_digest = sort_by_digest_4_4;
6827 opti_type = OPTI_TYPE_ZERO_BYTE
6828 | OPTI_TYPE_PRECOMPUTE_INIT
6829 | OPTI_TYPE_PRECOMPUTE_MERKLE
6830 | OPTI_TYPE_MEET_IN_MIDDLE
6831 | OPTI_TYPE_EARLY_SKIP
6832 | OPTI_TYPE_NOT_ITERATED
6833 | OPTI_TYPE_APPENDED_SALT
6834 | OPTI_TYPE_RAW_HASH;
6835 dgst_pos0 = 0;
6836 dgst_pos1 = 3;
6837 dgst_pos2 = 2;
6838 dgst_pos3 = 1;
6839 break;
6840
6841 case 11: hash_type = HASH_TYPE_MD5;
6842 salt_type = SALT_TYPE_INTERN;
6843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6844 opts_type = OPTS_TYPE_PT_GENERATE_LE
6845 | OPTS_TYPE_ST_ADD80
6846 | OPTS_TYPE_ST_ADDBITS14;
6847 kern_type = KERN_TYPE_MD5_PWSLT;
6848 dgst_size = DGST_SIZE_4_4;
6849 parse_func = joomla_parse_hash;
6850 sort_by_digest = sort_by_digest_4_4;
6851 opti_type = OPTI_TYPE_ZERO_BYTE
6852 | OPTI_TYPE_PRECOMPUTE_INIT
6853 | OPTI_TYPE_PRECOMPUTE_MERKLE
6854 | OPTI_TYPE_MEET_IN_MIDDLE
6855 | OPTI_TYPE_EARLY_SKIP
6856 | OPTI_TYPE_NOT_ITERATED
6857 | OPTI_TYPE_APPENDED_SALT
6858 | OPTI_TYPE_RAW_HASH;
6859 dgst_pos0 = 0;
6860 dgst_pos1 = 3;
6861 dgst_pos2 = 2;
6862 dgst_pos3 = 1;
6863 break;
6864
6865 case 12: hash_type = HASH_TYPE_MD5;
6866 salt_type = SALT_TYPE_INTERN;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_LE
6869 | OPTS_TYPE_ST_ADD80
6870 | OPTS_TYPE_ST_ADDBITS14;
6871 kern_type = KERN_TYPE_MD5_PWSLT;
6872 dgst_size = DGST_SIZE_4_4;
6873 parse_func = postgresql_parse_hash;
6874 sort_by_digest = sort_by_digest_4_4;
6875 opti_type = OPTI_TYPE_ZERO_BYTE
6876 | OPTI_TYPE_PRECOMPUTE_INIT
6877 | OPTI_TYPE_PRECOMPUTE_MERKLE
6878 | OPTI_TYPE_MEET_IN_MIDDLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_APPENDED_SALT
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 0;
6884 dgst_pos1 = 3;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 20: hash_type = HASH_TYPE_MD5;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_LE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS14;
6895 kern_type = KERN_TYPE_MD5_SLTPW;
6896 dgst_size = DGST_SIZE_4_4;
6897 parse_func = md5s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_4;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_PREPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 0;
6907 dgst_pos1 = 3;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 21: hash_type = HASH_TYPE_MD5;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_LE
6916 | OPTS_TYPE_PT_ADD80
6917 | OPTS_TYPE_PT_ADDBITS14;
6918 kern_type = KERN_TYPE_MD5_SLTPW;
6919 dgst_size = DGST_SIZE_4_4;
6920 parse_func = osc_parse_hash;
6921 sort_by_digest = sort_by_digest_4_4;
6922 opti_type = OPTI_TYPE_ZERO_BYTE
6923 | OPTI_TYPE_PRECOMPUTE_INIT
6924 | OPTI_TYPE_PRECOMPUTE_MERKLE
6925 | OPTI_TYPE_EARLY_SKIP
6926 | OPTI_TYPE_NOT_ITERATED
6927 | OPTI_TYPE_PREPENDED_SALT
6928 | OPTI_TYPE_RAW_HASH;
6929 dgst_pos0 = 0;
6930 dgst_pos1 = 3;
6931 dgst_pos2 = 2;
6932 dgst_pos3 = 1;
6933 break;
6934
6935 case 22: hash_type = HASH_TYPE_MD5;
6936 salt_type = SALT_TYPE_EMBEDDED;
6937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6938 opts_type = OPTS_TYPE_PT_GENERATE_LE
6939 | OPTS_TYPE_PT_ADD80
6940 | OPTS_TYPE_PT_ADDBITS14;
6941 kern_type = KERN_TYPE_MD5_SLTPW;
6942 dgst_size = DGST_SIZE_4_4;
6943 parse_func = netscreen_parse_hash;
6944 sort_by_digest = sort_by_digest_4_4;
6945 opti_type = OPTI_TYPE_ZERO_BYTE
6946 | OPTI_TYPE_PRECOMPUTE_INIT
6947 | OPTI_TYPE_PRECOMPUTE_MERKLE
6948 | OPTI_TYPE_EARLY_SKIP
6949 | OPTI_TYPE_NOT_ITERATED
6950 | OPTI_TYPE_PREPENDED_SALT
6951 | OPTI_TYPE_RAW_HASH;
6952 dgst_pos0 = 0;
6953 dgst_pos1 = 3;
6954 dgst_pos2 = 2;
6955 dgst_pos3 = 1;
6956 break;
6957
6958 case 23: hash_type = HASH_TYPE_MD5;
6959 salt_type = SALT_TYPE_EMBEDDED;
6960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6961 opts_type = OPTS_TYPE_PT_GENERATE_LE
6962 | OPTS_TYPE_PT_ADD80
6963 | OPTS_TYPE_PT_ADDBITS14;
6964 kern_type = KERN_TYPE_MD5_SLTPW;
6965 dgst_size = DGST_SIZE_4_4;
6966 parse_func = skype_parse_hash;
6967 sort_by_digest = sort_by_digest_4_4;
6968 opti_type = OPTI_TYPE_ZERO_BYTE
6969 | OPTI_TYPE_PRECOMPUTE_INIT
6970 | OPTI_TYPE_PRECOMPUTE_MERKLE
6971 | OPTI_TYPE_EARLY_SKIP
6972 | OPTI_TYPE_NOT_ITERATED
6973 | OPTI_TYPE_PREPENDED_SALT
6974 | OPTI_TYPE_RAW_HASH;
6975 dgst_pos0 = 0;
6976 dgst_pos1 = 3;
6977 dgst_pos2 = 2;
6978 dgst_pos3 = 1;
6979 break;
6980
6981 case 30: hash_type = HASH_TYPE_MD5;
6982 salt_type = SALT_TYPE_INTERN;
6983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6984 opts_type = OPTS_TYPE_PT_GENERATE_LE
6985 | OPTS_TYPE_PT_UNICODE
6986 | OPTS_TYPE_ST_ADD80
6987 | OPTS_TYPE_ST_ADDBITS14;
6988 kern_type = KERN_TYPE_MD5_PWUSLT;
6989 dgst_size = DGST_SIZE_4_4;
6990 parse_func = md5s_parse_hash;
6991 sort_by_digest = sort_by_digest_4_4;
6992 opti_type = OPTI_TYPE_ZERO_BYTE
6993 | OPTI_TYPE_PRECOMPUTE_INIT
6994 | OPTI_TYPE_PRECOMPUTE_MERKLE
6995 | OPTI_TYPE_MEET_IN_MIDDLE
6996 | OPTI_TYPE_EARLY_SKIP
6997 | OPTI_TYPE_NOT_ITERATED
6998 | OPTI_TYPE_APPENDED_SALT
6999 | OPTI_TYPE_RAW_HASH;
7000 dgst_pos0 = 0;
7001 dgst_pos1 = 3;
7002 dgst_pos2 = 2;
7003 dgst_pos3 = 1;
7004 break;
7005
7006 case 40: hash_type = HASH_TYPE_MD5;
7007 salt_type = SALT_TYPE_INTERN;
7008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7009 opts_type = OPTS_TYPE_PT_GENERATE_LE
7010 | OPTS_TYPE_PT_ADD80
7011 | OPTS_TYPE_PT_ADDBITS14
7012 | OPTS_TYPE_PT_UNICODE;
7013 kern_type = KERN_TYPE_MD5_SLTPWU;
7014 dgst_size = DGST_SIZE_4_4;
7015 parse_func = md5s_parse_hash;
7016 sort_by_digest = sort_by_digest_4_4;
7017 opti_type = OPTI_TYPE_ZERO_BYTE
7018 | OPTI_TYPE_PRECOMPUTE_INIT
7019 | OPTI_TYPE_PRECOMPUTE_MERKLE
7020 | OPTI_TYPE_EARLY_SKIP
7021 | OPTI_TYPE_NOT_ITERATED
7022 | OPTI_TYPE_PREPENDED_SALT
7023 | OPTI_TYPE_RAW_HASH;
7024 dgst_pos0 = 0;
7025 dgst_pos1 = 3;
7026 dgst_pos2 = 2;
7027 dgst_pos3 = 1;
7028 break;
7029
7030 case 50: hash_type = HASH_TYPE_MD5;
7031 salt_type = SALT_TYPE_INTERN;
7032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7033 opts_type = OPTS_TYPE_PT_GENERATE_LE
7034 | OPTS_TYPE_ST_ADD80
7035 | OPTS_TYPE_ST_ADDBITS14;
7036 kern_type = KERN_TYPE_HMACMD5_PW;
7037 dgst_size = DGST_SIZE_4_4;
7038 parse_func = hmacmd5_parse_hash;
7039 sort_by_digest = sort_by_digest_4_4;
7040 opti_type = OPTI_TYPE_ZERO_BYTE
7041 | OPTI_TYPE_NOT_ITERATED;
7042 dgst_pos0 = 0;
7043 dgst_pos1 = 3;
7044 dgst_pos2 = 2;
7045 dgst_pos3 = 1;
7046 break;
7047
7048 case 60: hash_type = HASH_TYPE_MD5;
7049 salt_type = SALT_TYPE_INTERN;
7050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7051 opts_type = OPTS_TYPE_PT_GENERATE_LE
7052 | OPTS_TYPE_PT_ADD80
7053 | OPTS_TYPE_PT_ADDBITS14;
7054 kern_type = KERN_TYPE_HMACMD5_SLT;
7055 dgst_size = DGST_SIZE_4_4;
7056 parse_func = hmacmd5_parse_hash;
7057 sort_by_digest = sort_by_digest_4_4;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_NOT_ITERATED;
7060 dgst_pos0 = 0;
7061 dgst_pos1 = 3;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 100: hash_type = HASH_TYPE_SHA1;
7067 salt_type = SALT_TYPE_NONE;
7068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7069 opts_type = OPTS_TYPE_PT_GENERATE_BE
7070 | OPTS_TYPE_PT_ADD80
7071 | OPTS_TYPE_PT_ADDBITS15;
7072 kern_type = KERN_TYPE_SHA1;
7073 dgst_size = DGST_SIZE_4_5;
7074 parse_func = sha1_parse_hash;
7075 sort_by_digest = sort_by_digest_4_5;
7076 opti_type = OPTI_TYPE_ZERO_BYTE
7077 | OPTI_TYPE_PRECOMPUTE_INIT
7078 | OPTI_TYPE_PRECOMPUTE_MERKLE
7079 | OPTI_TYPE_EARLY_SKIP
7080 | OPTI_TYPE_NOT_ITERATED
7081 | OPTI_TYPE_NOT_SALTED
7082 | OPTI_TYPE_RAW_HASH;
7083 dgst_pos0 = 3;
7084 dgst_pos1 = 4;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 1;
7087 break;
7088
7089 case 101: hash_type = HASH_TYPE_SHA1;
7090 salt_type = SALT_TYPE_NONE;
7091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7092 opts_type = OPTS_TYPE_PT_GENERATE_BE
7093 | OPTS_TYPE_PT_ADD80
7094 | OPTS_TYPE_PT_ADDBITS15;
7095 kern_type = KERN_TYPE_SHA1;
7096 dgst_size = DGST_SIZE_4_5;
7097 parse_func = sha1b64_parse_hash;
7098 sort_by_digest = sort_by_digest_4_5;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_EARLY_SKIP
7103 | OPTI_TYPE_NOT_ITERATED
7104 | OPTI_TYPE_NOT_SALTED
7105 | OPTI_TYPE_RAW_HASH;
7106 dgst_pos0 = 3;
7107 dgst_pos1 = 4;
7108 dgst_pos2 = 2;
7109 dgst_pos3 = 1;
7110 break;
7111
7112 case 110: hash_type = HASH_TYPE_SHA1;
7113 salt_type = SALT_TYPE_INTERN;
7114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7115 opts_type = OPTS_TYPE_PT_GENERATE_BE
7116 | OPTS_TYPE_ST_ADD80
7117 | OPTS_TYPE_ST_ADDBITS15;
7118 kern_type = KERN_TYPE_SHA1_PWSLT;
7119 dgst_size = DGST_SIZE_4_5;
7120 parse_func = sha1s_parse_hash;
7121 sort_by_digest = sort_by_digest_4_5;
7122 opti_type = OPTI_TYPE_ZERO_BYTE
7123 | OPTI_TYPE_PRECOMPUTE_INIT
7124 | OPTI_TYPE_PRECOMPUTE_MERKLE
7125 | OPTI_TYPE_EARLY_SKIP
7126 | OPTI_TYPE_NOT_ITERATED
7127 | OPTI_TYPE_APPENDED_SALT
7128 | OPTI_TYPE_RAW_HASH;
7129 dgst_pos0 = 3;
7130 dgst_pos1 = 4;
7131 dgst_pos2 = 2;
7132 dgst_pos3 = 1;
7133 break;
7134
7135 case 111: hash_type = HASH_TYPE_SHA1;
7136 salt_type = SALT_TYPE_EMBEDDED;
7137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7138 opts_type = OPTS_TYPE_PT_GENERATE_BE
7139 | OPTS_TYPE_ST_ADD80
7140 | OPTS_TYPE_ST_ADDBITS15;
7141 kern_type = KERN_TYPE_SHA1_PWSLT;
7142 dgst_size = DGST_SIZE_4_5;
7143 parse_func = sha1b64s_parse_hash;
7144 sort_by_digest = sort_by_digest_4_5;
7145 opti_type = OPTI_TYPE_ZERO_BYTE
7146 | OPTI_TYPE_PRECOMPUTE_INIT
7147 | OPTI_TYPE_PRECOMPUTE_MERKLE
7148 | OPTI_TYPE_EARLY_SKIP
7149 | OPTI_TYPE_NOT_ITERATED
7150 | OPTI_TYPE_APPENDED_SALT
7151 | OPTI_TYPE_RAW_HASH;
7152 dgst_pos0 = 3;
7153 dgst_pos1 = 4;
7154 dgst_pos2 = 2;
7155 dgst_pos3 = 1;
7156 break;
7157
7158 case 112: hash_type = HASH_TYPE_SHA1;
7159 salt_type = SALT_TYPE_INTERN;
7160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7161 opts_type = OPTS_TYPE_PT_GENERATE_BE
7162 | OPTS_TYPE_ST_ADD80
7163 | OPTS_TYPE_ST_ADDBITS15
7164 | OPTS_TYPE_ST_HEX;
7165 kern_type = KERN_TYPE_SHA1_PWSLT;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = oracles_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_APPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 120: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_INTERN;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_PT_ADD80
7187 | OPTS_TYPE_PT_ADDBITS15;
7188 kern_type = KERN_TYPE_SHA1_SLTPW;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = sha1s_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_PREPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 121: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_PT_ADD80
7210 | OPTS_TYPE_PT_ADDBITS15
7211 | OPTS_TYPE_ST_LOWER;
7212 kern_type = KERN_TYPE_SHA1_SLTPW;
7213 dgst_size = DGST_SIZE_4_5;
7214 parse_func = smf_parse_hash;
7215 sort_by_digest = sort_by_digest_4_5;
7216 opti_type = OPTI_TYPE_ZERO_BYTE
7217 | OPTI_TYPE_PRECOMPUTE_INIT
7218 | OPTI_TYPE_PRECOMPUTE_MERKLE
7219 | OPTI_TYPE_EARLY_SKIP
7220 | OPTI_TYPE_NOT_ITERATED
7221 | OPTI_TYPE_PREPENDED_SALT
7222 | OPTI_TYPE_RAW_HASH;
7223 dgst_pos0 = 3;
7224 dgst_pos1 = 4;
7225 dgst_pos2 = 2;
7226 dgst_pos3 = 1;
7227 break;
7228
7229 case 122: hash_type = HASH_TYPE_SHA1;
7230 salt_type = SALT_TYPE_EMBEDDED;
7231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7232 opts_type = OPTS_TYPE_PT_GENERATE_BE
7233 | OPTS_TYPE_PT_ADD80
7234 | OPTS_TYPE_PT_ADDBITS15
7235 | OPTS_TYPE_ST_HEX;
7236 kern_type = KERN_TYPE_SHA1_SLTPW;
7237 dgst_size = DGST_SIZE_4_5;
7238 parse_func = osx1_parse_hash;
7239 sort_by_digest = sort_by_digest_4_5;
7240 opti_type = OPTI_TYPE_ZERO_BYTE
7241 | OPTI_TYPE_PRECOMPUTE_INIT
7242 | OPTI_TYPE_PRECOMPUTE_MERKLE
7243 | OPTI_TYPE_EARLY_SKIP
7244 | OPTI_TYPE_NOT_ITERATED
7245 | OPTI_TYPE_PREPENDED_SALT
7246 | OPTI_TYPE_RAW_HASH;
7247 dgst_pos0 = 3;
7248 dgst_pos1 = 4;
7249 dgst_pos2 = 2;
7250 dgst_pos3 = 1;
7251 break;
7252
7253 case 124: hash_type = HASH_TYPE_SHA1;
7254 salt_type = SALT_TYPE_EMBEDDED;
7255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7256 opts_type = OPTS_TYPE_PT_GENERATE_BE
7257 | OPTS_TYPE_PT_ADD80
7258 | OPTS_TYPE_PT_ADDBITS15;
7259 kern_type = KERN_TYPE_SHA1_SLTPW;
7260 dgst_size = DGST_SIZE_4_5;
7261 parse_func = djangosha1_parse_hash;
7262 sort_by_digest = sort_by_digest_4_5;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_PREPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 125: hash_type = HASH_TYPE_SHA1;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_BE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS15
7282 | OPTS_TYPE_ST_HEX;
7283 kern_type = KERN_TYPE_SHA1_SLTPW;
7284 dgst_size = DGST_SIZE_4_5;
7285 parse_func = arubaos_parse_hash;
7286 sort_by_digest = sort_by_digest_4_5;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_PREPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 3;
7295 dgst_pos1 = 4;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 130: hash_type = HASH_TYPE_SHA1;
7301 salt_type = SALT_TYPE_INTERN;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_BE
7304 | OPTS_TYPE_PT_UNICODE
7305 | OPTS_TYPE_ST_ADD80
7306 | OPTS_TYPE_ST_ADDBITS15;
7307 kern_type = KERN_TYPE_SHA1_PWUSLT;
7308 dgst_size = DGST_SIZE_4_5;
7309 parse_func = sha1s_parse_hash;
7310 sort_by_digest = sort_by_digest_4_5;
7311 opti_type = OPTI_TYPE_ZERO_BYTE
7312 | OPTI_TYPE_PRECOMPUTE_INIT
7313 | OPTI_TYPE_PRECOMPUTE_MERKLE
7314 | OPTI_TYPE_EARLY_SKIP
7315 | OPTI_TYPE_NOT_ITERATED
7316 | OPTI_TYPE_APPENDED_SALT
7317 | OPTI_TYPE_RAW_HASH;
7318 dgst_pos0 = 3;
7319 dgst_pos1 = 4;
7320 dgst_pos2 = 2;
7321 dgst_pos3 = 1;
7322 break;
7323
7324 case 131: hash_type = HASH_TYPE_SHA1;
7325 salt_type = SALT_TYPE_EMBEDDED;
7326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7327 opts_type = OPTS_TYPE_PT_GENERATE_BE
7328 | OPTS_TYPE_PT_UNICODE
7329 | OPTS_TYPE_PT_UPPER
7330 | OPTS_TYPE_ST_ADD80
7331 | OPTS_TYPE_ST_ADDBITS15
7332 | OPTS_TYPE_ST_HEX;
7333 kern_type = KERN_TYPE_SHA1_PWUSLT;
7334 dgst_size = DGST_SIZE_4_5;
7335 parse_func = mssql2000_parse_hash;
7336 sort_by_digest = sort_by_digest_4_5;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_APPENDED_SALT
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 4;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 1;
7348 break;
7349
7350 case 132: hash_type = HASH_TYPE_SHA1;
7351 salt_type = SALT_TYPE_EMBEDDED;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_PT_UNICODE
7355 | OPTS_TYPE_ST_ADD80
7356 | OPTS_TYPE_ST_ADDBITS15
7357 | OPTS_TYPE_ST_HEX;
7358 kern_type = KERN_TYPE_SHA1_PWUSLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = mssql2005_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 133: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_EMBEDDED;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_UNICODE
7380 | OPTS_TYPE_ST_ADD80
7381 | OPTS_TYPE_ST_ADDBITS15;
7382 kern_type = KERN_TYPE_SHA1_PWUSLT;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = peoplesoft_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 140: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_INTERN;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_ADD80
7404 | OPTS_TYPE_PT_ADDBITS15
7405 | OPTS_TYPE_PT_UNICODE;
7406 kern_type = KERN_TYPE_SHA1_SLTPWU;
7407 dgst_size = DGST_SIZE_4_5;
7408 parse_func = sha1s_parse_hash;
7409 sort_by_digest = sort_by_digest_4_5;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_PREPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 141: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_EMBEDDED;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_PT_ADD80
7428 | OPTS_TYPE_PT_ADDBITS15
7429 | OPTS_TYPE_PT_UNICODE
7430 | OPTS_TYPE_ST_BASE64;
7431 kern_type = KERN_TYPE_SHA1_SLTPWU;
7432 dgst_size = DGST_SIZE_4_5;
7433 parse_func = episerver_parse_hash;
7434 sort_by_digest = sort_by_digest_4_5;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 150: hash_type = HASH_TYPE_SHA1;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_ST_ADD80
7453 | OPTS_TYPE_ST_ADDBITS15;
7454 kern_type = KERN_TYPE_HMACSHA1_PW;
7455 dgst_size = DGST_SIZE_4_5;
7456 parse_func = hmacsha1_parse_hash;
7457 sort_by_digest = sort_by_digest_4_5;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_NOT_ITERATED;
7460 dgst_pos0 = 3;
7461 dgst_pos1 = 4;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 1;
7464 break;
7465
7466 case 160: hash_type = HASH_TYPE_SHA1;
7467 salt_type = SALT_TYPE_INTERN;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_BE
7470 | OPTS_TYPE_PT_ADD80
7471 | OPTS_TYPE_PT_ADDBITS15;
7472 kern_type = KERN_TYPE_HMACSHA1_SLT;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = hmacsha1_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_NOT_ITERATED;
7478 dgst_pos0 = 3;
7479 dgst_pos1 = 4;
7480 dgst_pos2 = 2;
7481 dgst_pos3 = 1;
7482 break;
7483
7484 case 190: hash_type = HASH_TYPE_SHA1;
7485 salt_type = SALT_TYPE_NONE;
7486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7487 opts_type = OPTS_TYPE_PT_GENERATE_BE
7488 | OPTS_TYPE_PT_ADD80
7489 | OPTS_TYPE_PT_ADDBITS15;
7490 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7491 dgst_size = DGST_SIZE_4_5;
7492 parse_func = sha1linkedin_parse_hash;
7493 sort_by_digest = sort_by_digest_4_5;
7494 opti_type = OPTI_TYPE_ZERO_BYTE
7495 | OPTI_TYPE_PRECOMPUTE_INIT
7496 | OPTI_TYPE_EARLY_SKIP
7497 | OPTI_TYPE_NOT_ITERATED
7498 | OPTI_TYPE_NOT_SALTED;
7499 dgst_pos0 = 0;
7500 dgst_pos1 = 4;
7501 dgst_pos2 = 3;
7502 dgst_pos3 = 2;
7503 break;
7504
7505 case 200: hash_type = HASH_TYPE_MYSQL;
7506 salt_type = SALT_TYPE_NONE;
7507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7508 opts_type = 0;
7509 kern_type = KERN_TYPE_MYSQL;
7510 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7511 parse_func = mysql323_parse_hash;
7512 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7513 opti_type = OPTI_TYPE_ZERO_BYTE;
7514 dgst_pos0 = 0;
7515 dgst_pos1 = 1;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 3;
7518 break;
7519
7520 case 300: hash_type = HASH_TYPE_SHA1;
7521 salt_type = SALT_TYPE_NONE;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_BE
7524 | OPTS_TYPE_PT_ADD80
7525 | OPTS_TYPE_PT_ADDBITS15;
7526 kern_type = KERN_TYPE_MYSQL41;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = sha1_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_NOT_SALTED;
7536 dgst_pos0 = 3;
7537 dgst_pos1 = 4;
7538 dgst_pos2 = 2;
7539 dgst_pos3 = 1;
7540 break;
7541
7542 case 400: hash_type = HASH_TYPE_MD5;
7543 salt_type = SALT_TYPE_EMBEDDED;
7544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7546 kern_type = KERN_TYPE_PHPASS;
7547 dgst_size = DGST_SIZE_4_4;
7548 parse_func = phpass_parse_hash;
7549 sort_by_digest = sort_by_digest_4_4;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_SLOW_HASH_SIMD;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 1;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 3;
7556 break;
7557
7558 case 500: hash_type = HASH_TYPE_MD5;
7559 salt_type = SALT_TYPE_EMBEDDED;
7560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7562 kern_type = KERN_TYPE_MD5CRYPT;
7563 dgst_size = DGST_SIZE_4_4;
7564 parse_func = md5crypt_parse_hash;
7565 sort_by_digest = sort_by_digest_4_4;
7566 opti_type = OPTI_TYPE_ZERO_BYTE;
7567 dgst_pos0 = 0;
7568 dgst_pos1 = 1;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 3;
7571 break;
7572
7573 case 501: hash_type = HASH_TYPE_MD5;
7574 salt_type = SALT_TYPE_EMBEDDED;
7575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7576 opts_type = OPTS_TYPE_PT_GENERATE_LE
7577 | OPTS_TYPE_HASH_COPY;
7578 kern_type = KERN_TYPE_MD5CRYPT;
7579 dgst_size = DGST_SIZE_4_4;
7580 parse_func = juniper_parse_hash;
7581 sort_by_digest = sort_by_digest_4_4;
7582 opti_type = OPTI_TYPE_ZERO_BYTE;
7583 dgst_pos0 = 0;
7584 dgst_pos1 = 1;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 3;
7587 break;
7588
7589 case 900: hash_type = HASH_TYPE_MD4;
7590 salt_type = SALT_TYPE_NONE;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE
7593 | OPTS_TYPE_PT_ADD80
7594 | OPTS_TYPE_PT_ADDBITS14;
7595 kern_type = KERN_TYPE_MD4;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = md4_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE
7600 | OPTI_TYPE_PRECOMPUTE_INIT
7601 | OPTI_TYPE_PRECOMPUTE_MERKLE
7602 | OPTI_TYPE_MEET_IN_MIDDLE
7603 | OPTI_TYPE_EARLY_SKIP
7604 | OPTI_TYPE_NOT_ITERATED
7605 | OPTI_TYPE_NOT_SALTED
7606 | OPTI_TYPE_RAW_HASH;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 3;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 1;
7611 break;
7612
7613 case 1000: hash_type = HASH_TYPE_MD4;
7614 salt_type = SALT_TYPE_NONE;
7615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE
7617 | OPTS_TYPE_PT_ADD80
7618 | OPTS_TYPE_PT_ADDBITS14
7619 | OPTS_TYPE_PT_UNICODE;
7620 kern_type = KERN_TYPE_MD4_PWU;
7621 dgst_size = DGST_SIZE_4_4;
7622 parse_func = md4_parse_hash;
7623 sort_by_digest = sort_by_digest_4_4;
7624 opti_type = OPTI_TYPE_ZERO_BYTE
7625 | OPTI_TYPE_PRECOMPUTE_INIT
7626 | OPTI_TYPE_PRECOMPUTE_MERKLE
7627 | OPTI_TYPE_MEET_IN_MIDDLE
7628 | OPTI_TYPE_EARLY_SKIP
7629 | OPTI_TYPE_NOT_ITERATED
7630 | OPTI_TYPE_NOT_SALTED
7631 | OPTI_TYPE_RAW_HASH;
7632 dgst_pos0 = 0;
7633 dgst_pos1 = 3;
7634 dgst_pos2 = 2;
7635 dgst_pos3 = 1;
7636 break;
7637
7638 case 1100: hash_type = HASH_TYPE_MD4;
7639 salt_type = SALT_TYPE_INTERN;
7640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7641 opts_type = OPTS_TYPE_PT_GENERATE_LE
7642 | OPTS_TYPE_PT_ADD80
7643 | OPTS_TYPE_PT_ADDBITS14
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_UNICODE
7647 | OPTS_TYPE_ST_LOWER;
7648 kern_type = KERN_TYPE_MD44_PWUSLT;
7649 dgst_size = DGST_SIZE_4_4;
7650 parse_func = dcc_parse_hash;
7651 sort_by_digest = sort_by_digest_4_4;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 3;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 1;
7661 break;
7662
7663 case 1400: hash_type = HASH_TYPE_SHA256;
7664 salt_type = SALT_TYPE_NONE;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15;
7669 kern_type = KERN_TYPE_SHA256;
7670 dgst_size = DGST_SIZE_4_8;
7671 parse_func = sha256_parse_hash;
7672 sort_by_digest = sort_by_digest_4_8;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_EARLY_SKIP
7677 | OPTI_TYPE_NOT_ITERATED
7678 | OPTI_TYPE_NOT_SALTED
7679 | OPTI_TYPE_RAW_HASH;
7680 dgst_pos0 = 3;
7681 dgst_pos1 = 7;
7682 dgst_pos2 = 2;
7683 dgst_pos3 = 6;
7684 break;
7685
7686 case 1410: hash_type = HASH_TYPE_SHA256;
7687 salt_type = SALT_TYPE_INTERN;
7688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7689 opts_type = OPTS_TYPE_PT_GENERATE_BE
7690 | OPTS_TYPE_ST_ADD80
7691 | OPTS_TYPE_ST_ADDBITS15;
7692 kern_type = KERN_TYPE_SHA256_PWSLT;
7693 dgst_size = DGST_SIZE_4_8;
7694 parse_func = sha256s_parse_hash;
7695 sort_by_digest = sort_by_digest_4_8;
7696 opti_type = OPTI_TYPE_ZERO_BYTE
7697 | OPTI_TYPE_PRECOMPUTE_INIT
7698 | OPTI_TYPE_PRECOMPUTE_MERKLE
7699 | OPTI_TYPE_EARLY_SKIP
7700 | OPTI_TYPE_NOT_ITERATED
7701 | OPTI_TYPE_APPENDED_SALT
7702 | OPTI_TYPE_RAW_HASH;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 7;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 6;
7707 break;
7708
7709 case 1420: hash_type = HASH_TYPE_SHA256;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS15;
7715 kern_type = KERN_TYPE_SHA256_SLTPW;
7716 dgst_size = DGST_SIZE_4_8;
7717 parse_func = sha256s_parse_hash;
7718 sort_by_digest = sort_by_digest_4_8;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_PRECOMPUTE_INIT
7721 | OPTI_TYPE_PRECOMPUTE_MERKLE
7722 | OPTI_TYPE_EARLY_SKIP
7723 | OPTI_TYPE_NOT_ITERATED
7724 | OPTI_TYPE_PREPENDED_SALT
7725 | OPTI_TYPE_RAW_HASH;
7726 dgst_pos0 = 3;
7727 dgst_pos1 = 7;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 6;
7730 break;
7731
7732 case 1421: hash_type = HASH_TYPE_SHA256;
7733 salt_type = SALT_TYPE_EMBEDDED;
7734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7735 opts_type = OPTS_TYPE_PT_GENERATE_BE
7736 | OPTS_TYPE_PT_ADD80
7737 | OPTS_TYPE_PT_ADDBITS15;
7738 kern_type = KERN_TYPE_SHA256_SLTPW;
7739 dgst_size = DGST_SIZE_4_8;
7740 parse_func = hmailserver_parse_hash;
7741 sort_by_digest = sort_by_digest_4_8;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED
7747 | OPTI_TYPE_PREPENDED_SALT
7748 | OPTI_TYPE_RAW_HASH;
7749 dgst_pos0 = 3;
7750 dgst_pos1 = 7;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 6;
7753 break;
7754
7755 case 1430: hash_type = HASH_TYPE_SHA256;
7756 salt_type = SALT_TYPE_INTERN;
7757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_BE
7759 | OPTS_TYPE_PT_UNICODE
7760 | OPTS_TYPE_ST_ADD80
7761 | OPTS_TYPE_ST_ADDBITS15;
7762 kern_type = KERN_TYPE_SHA256_PWUSLT;
7763 dgst_size = DGST_SIZE_4_8;
7764 parse_func = sha256s_parse_hash;
7765 sort_by_digest = sort_by_digest_4_8;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_PRECOMPUTE_INIT
7768 | OPTI_TYPE_PRECOMPUTE_MERKLE
7769 | OPTI_TYPE_EARLY_SKIP
7770 | OPTI_TYPE_NOT_ITERATED
7771 | OPTI_TYPE_APPENDED_SALT
7772 | OPTI_TYPE_RAW_HASH;
7773 dgst_pos0 = 3;
7774 dgst_pos1 = 7;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 6;
7777 break;
7778
7779 case 1440: hash_type = HASH_TYPE_SHA256;
7780 salt_type = SALT_TYPE_INTERN;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_BE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS15
7785 | OPTS_TYPE_PT_UNICODE;
7786 kern_type = KERN_TYPE_SHA256_SLTPWU;
7787 dgst_size = DGST_SIZE_4_8;
7788 parse_func = sha256s_parse_hash;
7789 sort_by_digest = sort_by_digest_4_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_PREPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 7;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 6;
7801 break;
7802
7803 case 1441: hash_type = HASH_TYPE_SHA256;
7804 salt_type = SALT_TYPE_EMBEDDED;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_PT_ADD80
7808 | OPTS_TYPE_PT_ADDBITS15
7809 | OPTS_TYPE_PT_UNICODE
7810 | OPTS_TYPE_ST_BASE64;
7811 kern_type = KERN_TYPE_SHA256_SLTPWU;
7812 dgst_size = DGST_SIZE_4_8;
7813 parse_func = episerver4_parse_hash;
7814 sort_by_digest = sort_by_digest_4_8;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_PREPENDED_SALT
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 3;
7823 dgst_pos1 = 7;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 6;
7826 break;
7827
7828 case 1450: hash_type = HASH_TYPE_SHA256;
7829 salt_type = SALT_TYPE_INTERN;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_ST_ADD80;
7833 kern_type = KERN_TYPE_HMACSHA256_PW;
7834 dgst_size = DGST_SIZE_4_8;
7835 parse_func = hmacsha256_parse_hash;
7836 sort_by_digest = sort_by_digest_4_8;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_NOT_ITERATED;
7839 dgst_pos0 = 3;
7840 dgst_pos1 = 7;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 6;
7843 break;
7844
7845 case 1460: hash_type = HASH_TYPE_SHA256;
7846 salt_type = SALT_TYPE_INTERN;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_ADD80
7850 | OPTS_TYPE_PT_ADDBITS15;
7851 kern_type = KERN_TYPE_HMACSHA256_SLT;
7852 dgst_size = DGST_SIZE_4_8;
7853 parse_func = hmacsha256_parse_hash;
7854 sort_by_digest = sort_by_digest_4_8;
7855 opti_type = OPTI_TYPE_ZERO_BYTE
7856 | OPTI_TYPE_NOT_ITERATED;
7857 dgst_pos0 = 3;
7858 dgst_pos1 = 7;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 6;
7861 break;
7862
7863 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_LE
7867 | OPTS_TYPE_PT_BITSLICE;
7868 kern_type = KERN_TYPE_DESCRYPT;
7869 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7870 parse_func = descrypt_parse_hash;
7871 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7874 dgst_pos0 = 0;
7875 dgst_pos1 = 1;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 3;
7878 break;
7879
7880 case 1600: hash_type = HASH_TYPE_MD5;
7881 salt_type = SALT_TYPE_EMBEDDED;
7882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7884 kern_type = KERN_TYPE_APR1CRYPT;
7885 dgst_size = DGST_SIZE_4_4;
7886 parse_func = md5apr1_parse_hash;
7887 sort_by_digest = sort_by_digest_4_4;
7888 opti_type = OPTI_TYPE_ZERO_BYTE;
7889 dgst_pos0 = 0;
7890 dgst_pos1 = 1;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 3;
7893 break;
7894
7895 case 1700: hash_type = HASH_TYPE_SHA512;
7896 salt_type = SALT_TYPE_NONE;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_BE
7899 | OPTS_TYPE_PT_ADD80
7900 | OPTS_TYPE_PT_ADDBITS15;
7901 kern_type = KERN_TYPE_SHA512;
7902 dgst_size = DGST_SIZE_8_8;
7903 parse_func = sha512_parse_hash;
7904 sort_by_digest = sort_by_digest_8_8;
7905 opti_type = OPTI_TYPE_ZERO_BYTE
7906 | OPTI_TYPE_PRECOMPUTE_INIT
7907 | OPTI_TYPE_PRECOMPUTE_MERKLE
7908 | OPTI_TYPE_EARLY_SKIP
7909 | OPTI_TYPE_NOT_ITERATED
7910 | OPTI_TYPE_NOT_SALTED
7911 | OPTI_TYPE_USES_BITS_64
7912 | OPTI_TYPE_RAW_HASH;
7913 dgst_pos0 = 14;
7914 dgst_pos1 = 15;
7915 dgst_pos2 = 6;
7916 dgst_pos3 = 7;
7917 break;
7918
7919 case 1710: hash_type = HASH_TYPE_SHA512;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_ST_ADD80
7924 | OPTS_TYPE_ST_ADDBITS15;
7925 kern_type = KERN_TYPE_SHA512_PWSLT;
7926 dgst_size = DGST_SIZE_8_8;
7927 parse_func = sha512s_parse_hash;
7928 sort_by_digest = sort_by_digest_8_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_PRECOMPUTE_INIT
7931 | OPTI_TYPE_PRECOMPUTE_MERKLE
7932 | OPTI_TYPE_EARLY_SKIP
7933 | OPTI_TYPE_NOT_ITERATED
7934 | OPTI_TYPE_APPENDED_SALT
7935 | OPTI_TYPE_USES_BITS_64
7936 | OPTI_TYPE_RAW_HASH;
7937 dgst_pos0 = 14;
7938 dgst_pos1 = 15;
7939 dgst_pos2 = 6;
7940 dgst_pos3 = 7;
7941 break;
7942
7943 case 1711: hash_type = HASH_TYPE_SHA512;
7944 salt_type = SALT_TYPE_EMBEDDED;
7945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7946 opts_type = OPTS_TYPE_PT_GENERATE_BE
7947 | OPTS_TYPE_ST_ADD80
7948 | OPTS_TYPE_ST_ADDBITS15;
7949 kern_type = KERN_TYPE_SHA512_PWSLT;
7950 dgst_size = DGST_SIZE_8_8;
7951 parse_func = sha512b64s_parse_hash;
7952 sort_by_digest = sort_by_digest_8_8;
7953 opti_type = OPTI_TYPE_ZERO_BYTE
7954 | OPTI_TYPE_PRECOMPUTE_INIT
7955 | OPTI_TYPE_PRECOMPUTE_MERKLE
7956 | OPTI_TYPE_EARLY_SKIP
7957 | OPTI_TYPE_NOT_ITERATED
7958 | OPTI_TYPE_APPENDED_SALT
7959 | OPTI_TYPE_USES_BITS_64
7960 | OPTI_TYPE_RAW_HASH;
7961 dgst_pos0 = 14;
7962 dgst_pos1 = 15;
7963 dgst_pos2 = 6;
7964 dgst_pos3 = 7;
7965 break;
7966
7967 case 1720: hash_type = HASH_TYPE_SHA512;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_PT_ADD80
7972 | OPTS_TYPE_PT_ADDBITS15;
7973 kern_type = KERN_TYPE_SHA512_SLTPW;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = sha512s_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_PREPENDED_SALT
7983 | OPTI_TYPE_USES_BITS_64
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 14;
7986 dgst_pos1 = 15;
7987 dgst_pos2 = 6;
7988 dgst_pos3 = 7;
7989 break;
7990
7991 case 1722: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_EMBEDDED;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_ADD80
7996 | OPTS_TYPE_PT_ADDBITS15
7997 | OPTS_TYPE_ST_HEX;
7998 kern_type = KERN_TYPE_SHA512_SLTPW;
7999 dgst_size = DGST_SIZE_8_8;
8000 parse_func = osx512_parse_hash;
8001 sort_by_digest = sort_by_digest_8_8;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_PREPENDED_SALT
8008 | OPTI_TYPE_USES_BITS_64
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 14;
8011 dgst_pos1 = 15;
8012 dgst_pos2 = 6;
8013 dgst_pos3 = 7;
8014 break;
8015
8016 case 1730: hash_type = HASH_TYPE_SHA512;
8017 salt_type = SALT_TYPE_INTERN;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA512_PWSLTU;
8024 dgst_size = DGST_SIZE_8_8;
8025 parse_func = sha512s_parse_hash;
8026 sort_by_digest = sort_by_digest_8_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_USES_BITS_64
8034 | OPTI_TYPE_RAW_HASH;
8035 dgst_pos0 = 14;
8036 dgst_pos1 = 15;
8037 dgst_pos2 = 6;
8038 dgst_pos3 = 7;
8039 break;
8040
8041 case 1731: hash_type = HASH_TYPE_SHA512;
8042 salt_type = SALT_TYPE_EMBEDDED;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_BE
8045 | OPTS_TYPE_PT_UNICODE
8046 | OPTS_TYPE_ST_ADD80
8047 | OPTS_TYPE_ST_ADDBITS15
8048 | OPTS_TYPE_ST_HEX;
8049 kern_type = KERN_TYPE_SHA512_PWSLTU;
8050 dgst_size = DGST_SIZE_8_8;
8051 parse_func = mssql2012_parse_hash;
8052 sort_by_digest = sort_by_digest_8_8;
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_INIT
8055 | OPTI_TYPE_PRECOMPUTE_MERKLE
8056 | OPTI_TYPE_EARLY_SKIP
8057 | OPTI_TYPE_NOT_ITERATED
8058 | OPTI_TYPE_APPENDED_SALT
8059 | OPTI_TYPE_USES_BITS_64
8060 | OPTI_TYPE_RAW_HASH;
8061 dgst_pos0 = 14;
8062 dgst_pos1 = 15;
8063 dgst_pos2 = 6;
8064 dgst_pos3 = 7;
8065 break;
8066
8067 case 1740: hash_type = HASH_TYPE_SHA512;
8068 salt_type = SALT_TYPE_INTERN;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_BE
8071 | OPTS_TYPE_PT_ADD80
8072 | OPTS_TYPE_PT_ADDBITS15
8073 | OPTS_TYPE_PT_UNICODE;
8074 kern_type = KERN_TYPE_SHA512_SLTPWU;
8075 dgst_size = DGST_SIZE_8_8;
8076 parse_func = sha512s_parse_hash;
8077 sort_by_digest = sort_by_digest_8_8;
8078 opti_type = OPTI_TYPE_ZERO_BYTE
8079 | OPTI_TYPE_PRECOMPUTE_INIT
8080 | OPTI_TYPE_PRECOMPUTE_MERKLE
8081 | OPTI_TYPE_EARLY_SKIP
8082 | OPTI_TYPE_NOT_ITERATED
8083 | OPTI_TYPE_PREPENDED_SALT
8084 | OPTI_TYPE_USES_BITS_64
8085 | OPTI_TYPE_RAW_HASH;
8086 dgst_pos0 = 14;
8087 dgst_pos1 = 15;
8088 dgst_pos2 = 6;
8089 dgst_pos3 = 7;
8090 break;
8091
8092 case 1750: hash_type = HASH_TYPE_SHA512;
8093 salt_type = SALT_TYPE_INTERN;
8094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_BE
8096 | OPTS_TYPE_ST_ADD80;
8097 kern_type = KERN_TYPE_HMACSHA512_PW;
8098 dgst_size = DGST_SIZE_8_8;
8099 parse_func = hmacsha512_parse_hash;
8100 sort_by_digest = sort_by_digest_8_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_USES_BITS_64
8103 | OPTI_TYPE_NOT_ITERATED;
8104 dgst_pos0 = 14;
8105 dgst_pos1 = 15;
8106 dgst_pos2 = 6;
8107 dgst_pos3 = 7;
8108 break;
8109
8110 case 1760: hash_type = HASH_TYPE_SHA512;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_HMACSHA512_SLT;
8117 dgst_size = DGST_SIZE_8_8;
8118 parse_func = hmacsha512_parse_hash;
8119 sort_by_digest = sort_by_digest_8_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_USES_BITS_64
8122 | OPTI_TYPE_NOT_ITERATED;
8123 dgst_pos0 = 14;
8124 dgst_pos1 = 15;
8125 dgst_pos2 = 6;
8126 dgst_pos3 = 7;
8127 break;
8128
8129 case 1800: hash_type = HASH_TYPE_SHA512;
8130 salt_type = SALT_TYPE_EMBEDDED;
8131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8133 kern_type = KERN_TYPE_SHA512CRYPT;
8134 dgst_size = DGST_SIZE_8_8;
8135 parse_func = sha512crypt_parse_hash;
8136 sort_by_digest = sort_by_digest_8_8;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_USES_BITS_64;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 1;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 3;
8143 break;
8144
8145 case 2100: hash_type = HASH_TYPE_DCC2;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8149 | OPTS_TYPE_ST_LOWER
8150 | OPTS_TYPE_ST_UNICODE;
8151 kern_type = KERN_TYPE_DCC2;
8152 dgst_size = DGST_SIZE_4_4;
8153 parse_func = dcc2_parse_hash;
8154 sort_by_digest = sort_by_digest_4_4;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_SLOW_HASH_SIMD;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 1;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 3;
8161 break;
8162
8163 case 2400: hash_type = HASH_TYPE_MD5;
8164 salt_type = SALT_TYPE_NONE;
8165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8167 kern_type = KERN_TYPE_MD5PIX;
8168 dgst_size = DGST_SIZE_4_4;
8169 parse_func = md5pix_parse_hash;
8170 sort_by_digest = sort_by_digest_4_4;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_PRECOMPUTE_INIT
8173 | OPTI_TYPE_PRECOMPUTE_MERKLE
8174 | OPTI_TYPE_EARLY_SKIP
8175 | OPTI_TYPE_NOT_ITERATED
8176 | OPTI_TYPE_NOT_SALTED;
8177 dgst_pos0 = 0;
8178 dgst_pos1 = 3;
8179 dgst_pos2 = 2;
8180 dgst_pos3 = 1;
8181 break;
8182
8183 case 2410: hash_type = HASH_TYPE_MD5;
8184 salt_type = SALT_TYPE_INTERN;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8187 kern_type = KERN_TYPE_MD5ASA;
8188 dgst_size = DGST_SIZE_4_4;
8189 parse_func = md5asa_parse_hash;
8190 sort_by_digest = sort_by_digest_4_4;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_PRECOMPUTE_INIT
8193 | OPTI_TYPE_PRECOMPUTE_MERKLE
8194 | OPTI_TYPE_EARLY_SKIP
8195 | OPTI_TYPE_NOT_ITERATED;
8196 dgst_pos0 = 0;
8197 dgst_pos1 = 3;
8198 dgst_pos2 = 2;
8199 dgst_pos3 = 1;
8200 break;
8201
8202 case 2500: hash_type = HASH_TYPE_WPA;
8203 salt_type = SALT_TYPE_EMBEDDED;
8204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8206 kern_type = KERN_TYPE_WPA;
8207 dgst_size = DGST_SIZE_4_4;
8208 parse_func = wpa_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_SLOW_HASH_SIMD;
8212 dgst_pos0 = 0;
8213 dgst_pos1 = 1;
8214 dgst_pos2 = 2;
8215 dgst_pos3 = 3;
8216 break;
8217
8218 case 2600: hash_type = HASH_TYPE_MD5;
8219 salt_type = SALT_TYPE_VIRTUAL;
8220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8221 opts_type = OPTS_TYPE_PT_GENERATE_LE
8222 | OPTS_TYPE_PT_ADD80
8223 | OPTS_TYPE_PT_ADDBITS14
8224 | OPTS_TYPE_ST_ADD80;
8225 kern_type = KERN_TYPE_MD55_PWSLT1;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = md5md5_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_PRECOMPUTE_INIT
8231 | OPTI_TYPE_PRECOMPUTE_MERKLE
8232 | OPTI_TYPE_EARLY_SKIP;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 3;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 1;
8237 break;
8238
8239 case 2611: hash_type = HASH_TYPE_MD5;
8240 salt_type = SALT_TYPE_INTERN;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_PT_ADD80
8244 | OPTS_TYPE_PT_ADDBITS14
8245 | OPTS_TYPE_ST_ADD80;
8246 kern_type = KERN_TYPE_MD55_PWSLT1;
8247 dgst_size = DGST_SIZE_4_4;
8248 parse_func = vb3_parse_hash;
8249 sort_by_digest = sort_by_digest_4_4;
8250 opti_type = OPTI_TYPE_ZERO_BYTE
8251 | OPTI_TYPE_PRECOMPUTE_INIT
8252 | OPTI_TYPE_PRECOMPUTE_MERKLE
8253 | OPTI_TYPE_EARLY_SKIP;
8254 dgst_pos0 = 0;
8255 dgst_pos1 = 3;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 1;
8258 break;
8259
8260 case 2612: hash_type = HASH_TYPE_MD5;
8261 salt_type = SALT_TYPE_EMBEDDED;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE
8264 | OPTS_TYPE_PT_ADD80
8265 | OPTS_TYPE_PT_ADDBITS14
8266 | OPTS_TYPE_ST_ADD80
8267 | OPTS_TYPE_ST_HEX;
8268 kern_type = KERN_TYPE_MD55_PWSLT1;
8269 dgst_size = DGST_SIZE_4_4;
8270 parse_func = phps_parse_hash;
8271 sort_by_digest = sort_by_digest_4_4;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP;
8276 dgst_pos0 = 0;
8277 dgst_pos1 = 3;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 1;
8280 break;
8281
8282 case 2711: hash_type = HASH_TYPE_MD5;
8283 salt_type = SALT_TYPE_INTERN;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_ADD80
8287 | OPTS_TYPE_PT_ADDBITS14
8288 | OPTS_TYPE_ST_ADD80;
8289 kern_type = KERN_TYPE_MD55_PWSLT2;
8290 dgst_size = DGST_SIZE_4_4;
8291 parse_func = vb30_parse_hash;
8292 sort_by_digest = sort_by_digest_4_4;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_EARLY_SKIP;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 3;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 1;
8300 break;
8301
8302 case 2811: hash_type = HASH_TYPE_MD5;
8303 salt_type = SALT_TYPE_INTERN;
8304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE
8306 | OPTS_TYPE_PT_ADD80
8307 | OPTS_TYPE_PT_ADDBITS14;
8308 kern_type = KERN_TYPE_MD55_SLTPW;
8309 dgst_size = DGST_SIZE_4_4;
8310 parse_func = ipb2_parse_hash;
8311 sort_by_digest = sort_by_digest_4_4;
8312 opti_type = OPTI_TYPE_ZERO_BYTE
8313 | OPTI_TYPE_PRECOMPUTE_INIT
8314 | OPTI_TYPE_EARLY_SKIP;
8315 dgst_pos0 = 0;
8316 dgst_pos1 = 3;
8317 dgst_pos2 = 2;
8318 dgst_pos3 = 1;
8319 break;
8320
8321 case 3000: hash_type = HASH_TYPE_LM;
8322 salt_type = SALT_TYPE_NONE;
8323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_LE
8325 | OPTS_TYPE_PT_UPPER
8326 | OPTS_TYPE_PT_BITSLICE;
8327 kern_type = KERN_TYPE_LM;
8328 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8329 parse_func = lm_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 1;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 3;
8337 break;
8338
8339 case 3100: hash_type = HASH_TYPE_ORACLEH;
8340 salt_type = SALT_TYPE_INTERN;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_LE
8343 | OPTS_TYPE_PT_UPPER
8344 | OPTS_TYPE_ST_UPPER;
8345 kern_type = KERN_TYPE_ORACLEH;
8346 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8347 parse_func = oracleh_parse_hash;
8348 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8349 opti_type = OPTI_TYPE_ZERO_BYTE;
8350 dgst_pos0 = 0;
8351 dgst_pos1 = 1;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 3;
8354 break;
8355
8356 case 3200: hash_type = HASH_TYPE_BCRYPT;
8357 salt_type = SALT_TYPE_EMBEDDED;
8358 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_LE
8360 | OPTS_TYPE_ST_GENERATE_LE;
8361 kern_type = KERN_TYPE_BCRYPT;
8362 dgst_size = DGST_SIZE_4_6;
8363 parse_func = bcrypt_parse_hash;
8364 sort_by_digest = sort_by_digest_4_6;
8365 opti_type = OPTI_TYPE_ZERO_BYTE;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 1;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 3;
8370 break;
8371
8372 case 3710: hash_type = HASH_TYPE_MD5;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_PT_ADD80
8377 | OPTS_TYPE_PT_ADDBITS14;
8378 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8379 dgst_size = DGST_SIZE_4_4;
8380 parse_func = md5s_parse_hash;
8381 sort_by_digest = sort_by_digest_4_4;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_PRECOMPUTE_INIT
8384 | OPTI_TYPE_PRECOMPUTE_MERKLE
8385 | OPTI_TYPE_EARLY_SKIP;
8386 dgst_pos0 = 0;
8387 dgst_pos1 = 3;
8388 dgst_pos2 = 2;
8389 dgst_pos3 = 1;
8390 break;
8391
8392 case 3711: hash_type = HASH_TYPE_MD5;
8393 salt_type = SALT_TYPE_EMBEDDED;
8394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8395 opts_type = OPTS_TYPE_PT_GENERATE_LE
8396 | OPTS_TYPE_PT_ADD80
8397 | OPTS_TYPE_PT_ADDBITS14;
8398 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8399 dgst_size = DGST_SIZE_4_4;
8400 parse_func = mediawiki_b_parse_hash;
8401 sort_by_digest = sort_by_digest_4_4;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_PRECOMPUTE_INIT
8404 | OPTI_TYPE_PRECOMPUTE_MERKLE
8405 | OPTI_TYPE_EARLY_SKIP;
8406 dgst_pos0 = 0;
8407 dgst_pos1 = 3;
8408 dgst_pos2 = 2;
8409 dgst_pos3 = 1;
8410 break;
8411
8412 case 3800: hash_type = HASH_TYPE_MD5;
8413 salt_type = SALT_TYPE_INTERN;
8414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8415 opts_type = OPTS_TYPE_PT_GENERATE_LE
8416 | OPTS_TYPE_ST_ADDBITS14;
8417 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8418 dgst_size = DGST_SIZE_4_4;
8419 parse_func = md5s_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4;
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_INIT
8423 | OPTI_TYPE_PRECOMPUTE_MERKLE
8424 | OPTI_TYPE_EARLY_SKIP
8425 | OPTI_TYPE_NOT_ITERATED
8426 | OPTI_TYPE_RAW_HASH;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 4300: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_VIRTUAL;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_PT_ADD80
8438 | OPTS_TYPE_PT_ADDBITS14
8439 | OPTS_TYPE_ST_ADD80;
8440 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8441 dgst_size = DGST_SIZE_4_4;
8442 parse_func = md5md5_parse_hash;
8443 sort_by_digest = sort_by_digest_4_4;
8444 opti_type = OPTI_TYPE_ZERO_BYTE
8445 | OPTI_TYPE_PRECOMPUTE_INIT
8446 | OPTI_TYPE_PRECOMPUTE_MERKLE
8447 | OPTI_TYPE_EARLY_SKIP;
8448 dgst_pos0 = 0;
8449 dgst_pos1 = 3;
8450 dgst_pos2 = 2;
8451 dgst_pos3 = 1;
8452 break;
8453
8454
8455 case 4400: hash_type = HASH_TYPE_MD5;
8456 salt_type = SALT_TYPE_NONE;
8457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_BE
8459 | OPTS_TYPE_PT_ADD80
8460 | OPTS_TYPE_PT_ADDBITS15;
8461 kern_type = KERN_TYPE_MD5_SHA1;
8462 dgst_size = DGST_SIZE_4_4;
8463 parse_func = md5_parse_hash;
8464 sort_by_digest = sort_by_digest_4_4;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP
8469 | OPTI_TYPE_NOT_ITERATED
8470 | OPTI_TYPE_NOT_SALTED
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 4500: hash_type = HASH_TYPE_SHA1;
8479 salt_type = SALT_TYPE_NONE;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_BE
8482 | OPTS_TYPE_PT_ADD80
8483 | OPTS_TYPE_PT_ADDBITS15;
8484 kern_type = KERN_TYPE_SHA11;
8485 dgst_size = DGST_SIZE_4_5;
8486 parse_func = sha1_parse_hash;
8487 sort_by_digest = sort_by_digest_4_5;
8488 opti_type = OPTI_TYPE_ZERO_BYTE
8489 | OPTI_TYPE_PRECOMPUTE_INIT
8490 | OPTI_TYPE_PRECOMPUTE_MERKLE
8491 | OPTI_TYPE_EARLY_SKIP
8492 | OPTI_TYPE_NOT_SALTED;
8493 dgst_pos0 = 3;
8494 dgst_pos1 = 4;
8495 dgst_pos2 = 2;
8496 dgst_pos3 = 1;
8497 break;
8498
8499 case 4700: hash_type = HASH_TYPE_SHA1;
8500 salt_type = SALT_TYPE_NONE;
8501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8502 opts_type = OPTS_TYPE_PT_GENERATE_LE
8503 | OPTS_TYPE_PT_ADD80
8504 | OPTS_TYPE_PT_ADDBITS14;
8505 kern_type = KERN_TYPE_SHA1_MD5;
8506 dgst_size = DGST_SIZE_4_5;
8507 parse_func = sha1_parse_hash;
8508 sort_by_digest = sort_by_digest_4_5;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_PRECOMPUTE_INIT
8511 | OPTI_TYPE_PRECOMPUTE_MERKLE
8512 | OPTI_TYPE_EARLY_SKIP
8513 | OPTI_TYPE_NOT_ITERATED
8514 | OPTI_TYPE_NOT_SALTED
8515 | OPTI_TYPE_RAW_HASH;
8516 dgst_pos0 = 3;
8517 dgst_pos1 = 4;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 4800: hash_type = HASH_TYPE_MD5;
8523 salt_type = SALT_TYPE_EMBEDDED;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_LE
8526 | OPTS_TYPE_PT_ADDBITS14;
8527 kern_type = KERN_TYPE_MD5_CHAP;
8528 dgst_size = DGST_SIZE_4_4;
8529 parse_func = chap_parse_hash;
8530 sort_by_digest = sort_by_digest_4_4;
8531 opti_type = OPTI_TYPE_ZERO_BYTE
8532 | OPTI_TYPE_PRECOMPUTE_INIT
8533 | OPTI_TYPE_PRECOMPUTE_MERKLE
8534 | OPTI_TYPE_MEET_IN_MIDDLE
8535 | OPTI_TYPE_EARLY_SKIP
8536 | OPTI_TYPE_NOT_ITERATED
8537 | OPTI_TYPE_RAW_HASH;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544 case 4900: hash_type = HASH_TYPE_SHA1;
8545 salt_type = SALT_TYPE_INTERN;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8548 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8549 dgst_size = DGST_SIZE_4_5;
8550 parse_func = sha1s_parse_hash;
8551 sort_by_digest = sort_by_digest_4_5;
8552 opti_type = OPTI_TYPE_ZERO_BYTE
8553 | OPTI_TYPE_PRECOMPUTE_INIT
8554 | OPTI_TYPE_PRECOMPUTE_MERKLE
8555 | OPTI_TYPE_EARLY_SKIP;
8556 dgst_pos0 = 3;
8557 dgst_pos1 = 4;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 1;
8560 break;
8561
8562 case 5000: hash_type = HASH_TYPE_KECCAK;
8563 salt_type = SALT_TYPE_EMBEDDED;
8564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE
8566 | OPTS_TYPE_PT_ADD01;
8567 kern_type = KERN_TYPE_KECCAK;
8568 dgst_size = DGST_SIZE_8_25;
8569 parse_func = keccak_parse_hash;
8570 sort_by_digest = sort_by_digest_8_25;
8571 opti_type = OPTI_TYPE_ZERO_BYTE
8572 | OPTI_TYPE_USES_BITS_64
8573 | OPTI_TYPE_RAW_HASH;
8574 dgst_pos0 = 2;
8575 dgst_pos1 = 3;
8576 dgst_pos2 = 4;
8577 dgst_pos3 = 5;
8578 break;
8579
8580 case 5100: hash_type = HASH_TYPE_MD5H;
8581 salt_type = SALT_TYPE_NONE;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_LE
8584 | OPTS_TYPE_PT_ADD80
8585 | OPTS_TYPE_PT_ADDBITS14;
8586 kern_type = KERN_TYPE_MD5H;
8587 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8588 parse_func = md5half_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_RAW_HASH;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 1;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 3;
8596 break;
8597
8598 case 5200: hash_type = HASH_TYPE_SHA256;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8602 kern_type = KERN_TYPE_PSAFE3;
8603 dgst_size = DGST_SIZE_4_8;
8604 parse_func = psafe3_parse_hash;
8605 sort_by_digest = sort_by_digest_4_8;
8606 opti_type = OPTI_TYPE_ZERO_BYTE;
8607 dgst_pos0 = 0;
8608 dgst_pos1 = 1;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 3;
8611 break;
8612
8613 case 5300: hash_type = HASH_TYPE_MD5;
8614 salt_type = SALT_TYPE_EMBEDDED;
8615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE
8617 | OPTS_TYPE_ST_ADD80;
8618 kern_type = KERN_TYPE_IKEPSK_MD5;
8619 dgst_size = DGST_SIZE_4_4;
8620 parse_func = ikepsk_md5_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4;
8622 opti_type = OPTI_TYPE_ZERO_BYTE;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 3;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 1;
8627 break;
8628
8629 case 5400: hash_type = HASH_TYPE_SHA1;
8630 salt_type = SALT_TYPE_EMBEDDED;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_BE
8633 | OPTS_TYPE_ST_ADD80;
8634 kern_type = KERN_TYPE_IKEPSK_SHA1;
8635 dgst_size = DGST_SIZE_4_5;
8636 parse_func = ikepsk_sha1_parse_hash;
8637 sort_by_digest = sort_by_digest_4_5;
8638 opti_type = OPTI_TYPE_ZERO_BYTE;
8639 dgst_pos0 = 3;
8640 dgst_pos1 = 4;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 1;
8643 break;
8644
8645 case 5500: hash_type = HASH_TYPE_NETNTLM;
8646 salt_type = SALT_TYPE_EMBEDDED;
8647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE
8649 | OPTS_TYPE_PT_ADD80
8650 | OPTS_TYPE_PT_ADDBITS14
8651 | OPTS_TYPE_PT_UNICODE
8652 | OPTS_TYPE_ST_HEX;
8653 kern_type = KERN_TYPE_NETNTLMv1;
8654 dgst_size = DGST_SIZE_4_4;
8655 parse_func = netntlmv1_parse_hash;
8656 sort_by_digest = sort_by_digest_4_4;
8657 opti_type = OPTI_TYPE_ZERO_BYTE
8658 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 5600: hash_type = HASH_TYPE_MD5;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE
8669 | OPTS_TYPE_PT_ADD80
8670 | OPTS_TYPE_PT_ADDBITS14
8671 | OPTS_TYPE_PT_UNICODE;
8672 kern_type = KERN_TYPE_NETNTLMv2;
8673 dgst_size = DGST_SIZE_4_4;
8674 parse_func = netntlmv2_parse_hash;
8675 sort_by_digest = sort_by_digest_4_4;
8676 opti_type = OPTI_TYPE_ZERO_BYTE;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 3;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 1;
8681 break;
8682
8683 case 5700: hash_type = HASH_TYPE_SHA256;
8684 salt_type = SALT_TYPE_NONE;
8685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_BE
8687 | OPTS_TYPE_PT_ADD80
8688 | OPTS_TYPE_PT_ADDBITS15;
8689 kern_type = KERN_TYPE_SHA256;
8690 dgst_size = DGST_SIZE_4_8;
8691 parse_func = cisco4_parse_hash;
8692 sort_by_digest = sort_by_digest_4_8;
8693 opti_type = OPTI_TYPE_ZERO_BYTE
8694 | OPTI_TYPE_PRECOMPUTE_INIT
8695 | OPTI_TYPE_PRECOMPUTE_MERKLE
8696 | OPTI_TYPE_EARLY_SKIP
8697 | OPTI_TYPE_NOT_ITERATED
8698 | OPTI_TYPE_NOT_SALTED
8699 | OPTI_TYPE_RAW_HASH;
8700 dgst_pos0 = 3;
8701 dgst_pos1 = 7;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 6;
8704 break;
8705
8706 case 5800: hash_type = HASH_TYPE_SHA1;
8707 salt_type = SALT_TYPE_INTERN;
8708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8710 | OPTS_TYPE_ST_ADD80;
8711 kern_type = KERN_TYPE_ANDROIDPIN;
8712 dgst_size = DGST_SIZE_4_5;
8713 parse_func = androidpin_parse_hash;
8714 sort_by_digest = sort_by_digest_4_5;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8723 salt_type = SALT_TYPE_NONE;
8724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE
8726 | OPTS_TYPE_PT_ADD80;
8727 kern_type = KERN_TYPE_RIPEMD160;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = ripemd160_parse_hash;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 1;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 3;
8736 break;
8737
8738 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8739 salt_type = SALT_TYPE_NONE;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_PT_ADD80;
8743 kern_type = KERN_TYPE_WHIRLPOOL;
8744 dgst_size = DGST_SIZE_4_16;
8745 parse_func = whirlpool_parse_hash;
8746 sort_by_digest = sort_by_digest_4_16;
8747 opti_type = OPTI_TYPE_ZERO_BYTE;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 1;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 3;
8752 break;
8753
8754 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8755 salt_type = SALT_TYPE_EMBEDDED;
8756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8758 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8759 dgst_size = DGST_SIZE_4_5;
8760 parse_func = truecrypt_parse_hash_2k;
8761 sort_by_digest = sort_by_digest_4_5;
8762 opti_type = OPTI_TYPE_ZERO_BYTE;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8770 salt_type = SALT_TYPE_EMBEDDED;
8771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8773 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8774 dgst_size = DGST_SIZE_4_5;
8775 parse_func = truecrypt_parse_hash_2k;
8776 sort_by_digest = sort_by_digest_4_5;
8777 opti_type = OPTI_TYPE_ZERO_BYTE;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 1;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 3;
8782 break;
8783
8784 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8785 salt_type = SALT_TYPE_EMBEDDED;
8786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8788 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8789 dgst_size = DGST_SIZE_4_5;
8790 parse_func = truecrypt_parse_hash_2k;
8791 sort_by_digest = sort_by_digest_4_5;
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 6221: hash_type = HASH_TYPE_SHA512;
8800 salt_type = SALT_TYPE_EMBEDDED;
8801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8803 kern_type = KERN_TYPE_TCSHA512_XTS512;
8804 dgst_size = DGST_SIZE_8_8;
8805 parse_func = truecrypt_parse_hash_1k;
8806 sort_by_digest = sort_by_digest_8_8;
8807 opti_type = OPTI_TYPE_ZERO_BYTE
8808 | OPTI_TYPE_USES_BITS_64;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 1;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 3;
8813 break;
8814
8815 case 6222: hash_type = HASH_TYPE_SHA512;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8819 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8820 dgst_size = DGST_SIZE_8_8;
8821 parse_func = truecrypt_parse_hash_1k;
8822 sort_by_digest = sort_by_digest_8_8;
8823 opti_type = OPTI_TYPE_ZERO_BYTE
8824 | OPTI_TYPE_USES_BITS_64;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 1;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 3;
8829 break;
8830
8831 case 6223: hash_type = HASH_TYPE_SHA512;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8835 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8836 dgst_size = DGST_SIZE_8_8;
8837 parse_func = truecrypt_parse_hash_1k;
8838 sort_by_digest = sort_by_digest_8_8;
8839 opti_type = OPTI_TYPE_ZERO_BYTE
8840 | OPTI_TYPE_USES_BITS_64;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 1;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 3;
8845 break;
8846
8847 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8848 salt_type = SALT_TYPE_EMBEDDED;
8849 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8851 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8852 dgst_size = DGST_SIZE_4_8;
8853 parse_func = truecrypt_parse_hash_1k;
8854 sort_by_digest = sort_by_digest_4_8;
8855 opti_type = OPTI_TYPE_ZERO_BYTE;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8866 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8867 dgst_size = DGST_SIZE_4_8;
8868 parse_func = truecrypt_parse_hash_1k;
8869 sort_by_digest = sort_by_digest_4_8;
8870 opti_type = OPTI_TYPE_ZERO_BYTE;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8881 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8882 dgst_size = DGST_SIZE_4_8;
8883 parse_func = truecrypt_parse_hash_1k;
8884 sort_by_digest = sort_by_digest_4_8;
8885 opti_type = OPTI_TYPE_ZERO_BYTE;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 6241: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS512;
8897 dgst_size = DGST_SIZE_4_5;
8898 parse_func = truecrypt_parse_hash_1k;
8899 sort_by_digest = sort_by_digest_4_5;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS1024;
8912 dgst_size = DGST_SIZE_4_5;
8913 parse_func = truecrypt_parse_hash_1k;
8914 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS1536;
8927 dgst_size = DGST_SIZE_4_5;
8928 parse_func = truecrypt_parse_hash_1k;
8929 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
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_MD5AIX;
8942 dgst_size = DGST_SIZE_4_4;
8943 parse_func = md5aix_parse_hash;
8944 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8956 kern_type = KERN_TYPE_SHA256AIX;
8957 dgst_size = DGST_SIZE_4_8;
8958 parse_func = sha256aix_parse_hash;
8959 sort_by_digest = sort_by_digest_4_8;
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 6500: hash_type = HASH_TYPE_SHA512;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8971 kern_type = KERN_TYPE_SHA512AIX;
8972 dgst_size = DGST_SIZE_8_8;
8973 parse_func = sha512aix_parse_hash;
8974 sort_by_digest = sort_by_digest_8_8;
8975 opti_type = OPTI_TYPE_ZERO_BYTE
8976 | OPTI_TYPE_USES_BITS_64;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6600: hash_type = HASH_TYPE_AES;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8987 kern_type = KERN_TYPE_AGILEKEY;
8988 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8989 parse_func = agilekey_parse_hash;
8990 sort_by_digest = sort_by_digest_4_5;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 6700: hash_type = HASH_TYPE_SHA1;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9002 kern_type = KERN_TYPE_SHA1AIX;
9003 dgst_size = DGST_SIZE_4_5;
9004 parse_func = sha1aix_parse_hash;
9005 sort_by_digest = sort_by_digest_4_5;
9006 opti_type = OPTI_TYPE_ZERO_BYTE;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 6800: hash_type = HASH_TYPE_AES;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9017 kern_type = KERN_TYPE_LASTPASS;
9018 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9019 parse_func = lastpass_parse_hash;
9020 sort_by_digest = sort_by_digest_4_8;
9021 opti_type = OPTI_TYPE_ZERO_BYTE;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 6900: hash_type = HASH_TYPE_GOST;
9029 salt_type = SALT_TYPE_NONE;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9032 kern_type = KERN_TYPE_GOST;
9033 dgst_size = DGST_SIZE_4_8;
9034 parse_func = gost_parse_hash;
9035 sort_by_digest = sort_by_digest_4_8;
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 7100: hash_type = HASH_TYPE_SHA512;
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_PBKDF2_SHA512;
9048 dgst_size = DGST_SIZE_8_16;
9049 parse_func = sha512osx_parse_hash;
9050 sort_by_digest = sort_by_digest_8_16;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_USES_BITS_64
9053 | OPTI_TYPE_SLOW_HASH_SIMD;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 7200: hash_type = HASH_TYPE_SHA512;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9064 kern_type = KERN_TYPE_PBKDF2_SHA512;
9065 dgst_size = DGST_SIZE_8_16;
9066 parse_func = sha512grub_parse_hash;
9067 sort_by_digest = sort_by_digest_8_16;
9068 opti_type = OPTI_TYPE_ZERO_BYTE
9069 | OPTI_TYPE_USES_BITS_64
9070 | OPTI_TYPE_SLOW_HASH_SIMD;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 7300: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_BE
9081 | OPTS_TYPE_ST_ADD80
9082 | OPTS_TYPE_ST_ADDBITS15;
9083 kern_type = KERN_TYPE_RAKP;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = rakp_parse_hash;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_NOT_ITERATED;
9089 dgst_pos0 = 3;
9090 dgst_pos1 = 4;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 1;
9093 break;
9094
9095 case 7400: hash_type = HASH_TYPE_SHA256;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9099 kern_type = KERN_TYPE_SHA256CRYPT;
9100 dgst_size = DGST_SIZE_4_8;
9101 parse_func = sha256crypt_parse_hash;
9102 sort_by_digest = sort_by_digest_4_8;
9103 opti_type = OPTI_TYPE_ZERO_BYTE;
9104 dgst_pos0 = 0;
9105 dgst_pos1 = 1;
9106 dgst_pos2 = 2;
9107 dgst_pos3 = 3;
9108 break;
9109
9110 case 7500: hash_type = HASH_TYPE_KRB5PA;
9111 salt_type = SALT_TYPE_EMBEDDED;
9112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9114 kern_type = KERN_TYPE_KRB5PA;
9115 dgst_size = DGST_SIZE_4_4;
9116 parse_func = krb5pa_parse_hash;
9117 sort_by_digest = sort_by_digest_4_4;
9118 opti_type = OPTI_TYPE_ZERO_BYTE
9119 | OPTI_TYPE_NOT_ITERATED;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 7600: hash_type = HASH_TYPE_SHA1;
9127 salt_type = SALT_TYPE_INTERN;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_BE
9130 | OPTS_TYPE_PT_ADD80
9131 | OPTS_TYPE_PT_ADDBITS15;
9132 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = redmine_parse_hash;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_PRECOMPUTE_INIT
9138 | OPTI_TYPE_EARLY_SKIP
9139 | OPTI_TYPE_NOT_ITERATED
9140 | OPTI_TYPE_PREPENDED_SALT;
9141 dgst_pos0 = 3;
9142 dgst_pos1 = 4;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 1;
9145 break;
9146
9147 case 7700: hash_type = HASH_TYPE_SAPB;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE
9151 | OPTS_TYPE_PT_UPPER
9152 | OPTS_TYPE_ST_UPPER;
9153 kern_type = KERN_TYPE_SAPB;
9154 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9155 parse_func = sapb_parse_hash;
9156 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_PRECOMPUTE_INIT
9159 | OPTI_TYPE_NOT_ITERATED;
9160 dgst_pos0 = 0;
9161 dgst_pos1 = 1;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 3;
9164 break;
9165
9166 case 7800: hash_type = HASH_TYPE_SAPG;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9169 opts_type = OPTS_TYPE_PT_GENERATE_BE
9170 | OPTS_TYPE_ST_ADD80
9171 | OPTS_TYPE_ST_UPPER;
9172 kern_type = KERN_TYPE_SAPG;
9173 dgst_size = DGST_SIZE_4_5;
9174 parse_func = sapg_parse_hash;
9175 sort_by_digest = sort_by_digest_4_5;
9176 opti_type = OPTI_TYPE_ZERO_BYTE
9177 | OPTI_TYPE_PRECOMPUTE_INIT
9178 | OPTI_TYPE_NOT_ITERATED;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 4;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 1;
9183 break;
9184
9185 case 7900: hash_type = HASH_TYPE_SHA512;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9189 kern_type = KERN_TYPE_DRUPAL7;
9190 dgst_size = DGST_SIZE_8_8;
9191 parse_func = drupal7_parse_hash;
9192 sort_by_digest = sort_by_digest_8_8;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_USES_BITS_64;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 1;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 3;
9199 break;
9200
9201 case 8000: hash_type = HASH_TYPE_SHA256;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_BE
9205 | OPTS_TYPE_PT_UNICODE
9206 | OPTS_TYPE_ST_ADD80
9207 | OPTS_TYPE_ST_HEX;
9208 kern_type = KERN_TYPE_SYBASEASE;
9209 dgst_size = DGST_SIZE_4_8;
9210 parse_func = sybasease_parse_hash;
9211 sort_by_digest = sort_by_digest_4_8;
9212 opti_type = OPTI_TYPE_ZERO_BYTE
9213 | OPTI_TYPE_PRECOMPUTE_INIT
9214 | OPTI_TYPE_EARLY_SKIP
9215 | OPTI_TYPE_NOT_ITERATED
9216 | OPTI_TYPE_RAW_HASH;
9217 dgst_pos0 = 3;
9218 dgst_pos1 = 7;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 6;
9221 break;
9222
9223 case 8100: hash_type = HASH_TYPE_SHA1;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9227 kern_type = KERN_TYPE_NETSCALER;
9228 dgst_size = DGST_SIZE_4_5;
9229 parse_func = netscaler_parse_hash;
9230 sort_by_digest = sort_by_digest_4_5;
9231 opti_type = OPTI_TYPE_ZERO_BYTE
9232 | OPTI_TYPE_PRECOMPUTE_INIT
9233 | OPTI_TYPE_PRECOMPUTE_MERKLE
9234 | OPTI_TYPE_EARLY_SKIP
9235 | OPTI_TYPE_NOT_ITERATED
9236 | OPTI_TYPE_PREPENDED_SALT
9237 | OPTI_TYPE_RAW_HASH;
9238 dgst_pos0 = 3;
9239 dgst_pos1 = 4;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 1;
9242 break;
9243
9244 case 8200: hash_type = HASH_TYPE_SHA256;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9248 kern_type = KERN_TYPE_CLOUDKEY;
9249 dgst_size = DGST_SIZE_4_8;
9250 parse_func = cloudkey_parse_hash;
9251 sort_by_digest = sort_by_digest_4_8;
9252 opti_type = OPTI_TYPE_ZERO_BYTE;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 8300: hash_type = HASH_TYPE_SHA1;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_BE
9263 | OPTS_TYPE_ST_HEX
9264 | OPTS_TYPE_ST_ADD80;
9265 kern_type = KERN_TYPE_NSEC3;
9266 dgst_size = DGST_SIZE_4_5;
9267 parse_func = nsec3_parse_hash;
9268 sort_by_digest = sort_by_digest_4_5;
9269 opti_type = OPTI_TYPE_ZERO_BYTE;
9270 dgst_pos0 = 3;
9271 dgst_pos1 = 4;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 1;
9274 break;
9275
9276 case 8400: hash_type = HASH_TYPE_SHA1;
9277 salt_type = SALT_TYPE_INTERN;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_BE
9280 | OPTS_TYPE_PT_ADD80
9281 | OPTS_TYPE_PT_ADDBITS15;
9282 kern_type = KERN_TYPE_WBB3;
9283 dgst_size = DGST_SIZE_4_5;
9284 parse_func = wbb3_parse_hash;
9285 sort_by_digest = sort_by_digest_4_5;
9286 opti_type = OPTI_TYPE_ZERO_BYTE
9287 | OPTI_TYPE_PRECOMPUTE_INIT
9288 | OPTI_TYPE_NOT_ITERATED;
9289 dgst_pos0 = 3;
9290 dgst_pos1 = 4;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 1;
9293 break;
9294
9295 case 8500: hash_type = HASH_TYPE_DESRACF;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_LE
9299 | OPTS_TYPE_ST_UPPER;
9300 kern_type = KERN_TYPE_RACF;
9301 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9302 parse_func = racf_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 8600: hash_type = HASH_TYPE_LOTUS5;
9313 salt_type = SALT_TYPE_NONE;
9314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9316 kern_type = KERN_TYPE_LOTUS5;
9317 dgst_size = DGST_SIZE_4_4;
9318 parse_func = lotus5_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4;
9320 opti_type = OPTI_TYPE_EARLY_SKIP
9321 | OPTI_TYPE_NOT_ITERATED
9322 | OPTI_TYPE_NOT_SALTED
9323 | OPTI_TYPE_RAW_HASH;
9324 dgst_pos0 = 0;
9325 dgst_pos1 = 1;
9326 dgst_pos2 = 2;
9327 dgst_pos3 = 3;
9328 break;
9329
9330 case 8700: hash_type = HASH_TYPE_LOTUS6;
9331 salt_type = SALT_TYPE_EMBEDDED;
9332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9333 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9334 kern_type = KERN_TYPE_LOTUS6;
9335 dgst_size = DGST_SIZE_4_4;
9336 parse_func = lotus6_parse_hash;
9337 sort_by_digest = sort_by_digest_4_4;
9338 opti_type = OPTI_TYPE_EARLY_SKIP
9339 | OPTI_TYPE_NOT_ITERATED
9340 | OPTI_TYPE_RAW_HASH;
9341 dgst_pos0 = 0;
9342 dgst_pos1 = 1;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 3;
9345 break;
9346
9347 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9351 kern_type = KERN_TYPE_ANDROIDFDE;
9352 dgst_size = DGST_SIZE_4_4;
9353 parse_func = androidfde_parse_hash;
9354 sort_by_digest = sort_by_digest_4_4;
9355 opti_type = OPTI_TYPE_ZERO_BYTE;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 8900: hash_type = HASH_TYPE_SCRYPT;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_SCRYPT;
9367 dgst_size = DGST_SIZE_4_8;
9368 parse_func = scrypt_parse_hash;
9369 sort_by_digest = sort_by_digest_4_8;
9370 opti_type = OPTI_TYPE_ZERO_BYTE;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 1;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 3;
9375 break;
9376
9377 case 9000: hash_type = HASH_TYPE_SHA1;
9378 salt_type = SALT_TYPE_EMBEDDED;
9379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_LE
9381 | OPTS_TYPE_ST_GENERATE_LE;
9382 kern_type = KERN_TYPE_PSAFE2;
9383 dgst_size = DGST_SIZE_4_5;
9384 parse_func = psafe2_parse_hash;
9385 sort_by_digest = sort_by_digest_4_5;
9386 opti_type = OPTI_TYPE_ZERO_BYTE;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 9100: hash_type = HASH_TYPE_LOTUS8;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9397 kern_type = KERN_TYPE_LOTUS8;
9398 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9399 parse_func = lotus8_parse_hash;
9400 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9401 opti_type = OPTI_TYPE_ZERO_BYTE;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 9200: hash_type = HASH_TYPE_SHA256;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9412 kern_type = KERN_TYPE_PBKDF2_SHA256;
9413 dgst_size = DGST_SIZE_4_32;
9414 parse_func = cisco8_parse_hash;
9415 sort_by_digest = sort_by_digest_4_32;
9416 opti_type = OPTI_TYPE_ZERO_BYTE
9417 | OPTI_TYPE_SLOW_HASH_SIMD;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 9300: hash_type = HASH_TYPE_SCRYPT;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_SCRYPT;
9429 dgst_size = DGST_SIZE_4_8;
9430 parse_func = cisco9_parse_hash;
9431 sort_by_digest = sort_by_digest_4_8;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9443 kern_type = KERN_TYPE_OFFICE2007;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = office2007_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_OFFICE2010;
9459 dgst_size = DGST_SIZE_4_4;
9460 parse_func = office2010_parse_hash;
9461 sort_by_digest = sort_by_digest_4_4;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 9600: hash_type = HASH_TYPE_OFFICE2013;
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_OFFICE2013;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = office2013_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
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 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80
9489 | OPTS_TYPE_PT_UNICODE;
9490 kern_type = KERN_TYPE_OLDOFFICE01;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = oldoffice01_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE
9495 | OPTI_TYPE_PRECOMPUTE_INIT
9496 | OPTI_TYPE_NOT_ITERATED;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_PT_ADD80;
9508 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = oldoffice01cm1_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_NOT_ITERATED;
9515 dgst_pos0 = 0;
9516 dgst_pos1 = 1;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 3;
9519 break;
9520
9521 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE
9525 | OPTS_TYPE_PT_ADD80
9526 | OPTS_TYPE_PT_UNICODE
9527 | OPTS_TYPE_PT_NEVERCRACK;
9528 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = oldoffice01cm2_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_PRECOMPUTE_INIT
9534 | OPTI_TYPE_NOT_ITERATED;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_PT_UNICODE;
9547 kern_type = KERN_TYPE_OLDOFFICE34;
9548 dgst_size = DGST_SIZE_4_4;
9549 parse_func = oldoffice34_parse_hash;
9550 sort_by_digest = sort_by_digest_4_4;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = oldoffice34cm1_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_BE
9581 | OPTS_TYPE_PT_ADD80
9582 | OPTS_TYPE_PT_UNICODE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = oldoffice34cm2_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_ZERO_BYTE
9589 | OPTI_TYPE_PRECOMPUTE_INIT
9590 | OPTI_TYPE_NOT_ITERATED;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9900: hash_type = HASH_TYPE_MD5;
9598 salt_type = SALT_TYPE_NONE;
9599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_RADMIN2;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = radmin2_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_EARLY_SKIP
9608 | OPTI_TYPE_NOT_ITERATED
9609 | OPTI_TYPE_NOT_SALTED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 3;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 1;
9614 break;
9615
9616 case 10000: hash_type = HASH_TYPE_SHA256;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9620 kern_type = KERN_TYPE_PBKDF2_SHA256;
9621 dgst_size = DGST_SIZE_4_32;
9622 parse_func = djangopbkdf2_parse_hash;
9623 sort_by_digest = sort_by_digest_4_32;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_SLOW_HASH_SIMD;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 10100: hash_type = HASH_TYPE_SIPHASH;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_SIPHASH;
9637 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9638 parse_func = siphash_parse_hash;
9639 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9640 opti_type = OPTI_TYPE_ZERO_BYTE
9641 | OPTI_TYPE_NOT_ITERATED
9642 | OPTI_TYPE_RAW_HASH;
9643 dgst_pos0 = 0;
9644 dgst_pos1 = 1;
9645 dgst_pos2 = 2;
9646 dgst_pos3 = 3;
9647 break;
9648
9649 case 10200: hash_type = HASH_TYPE_MD5;
9650 salt_type = SALT_TYPE_EMBEDDED;
9651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9652 opts_type = OPTS_TYPE_PT_GENERATE_LE
9653 | OPTS_TYPE_ST_ADD80
9654 | OPTS_TYPE_ST_ADDBITS14;
9655 kern_type = KERN_TYPE_HMACMD5_PW;
9656 dgst_size = DGST_SIZE_4_4;
9657 parse_func = crammd5_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_NOT_ITERATED;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 3;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 1;
9665 break;
9666
9667 case 10300: hash_type = HASH_TYPE_SHA1;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9671 kern_type = KERN_TYPE_SAPH_SHA1;
9672 dgst_size = DGST_SIZE_4_5;
9673 parse_func = saph_sha1_parse_hash;
9674 sort_by_digest = sort_by_digest_4_5;
9675 opti_type = OPTI_TYPE_ZERO_BYTE;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 10400: hash_type = HASH_TYPE_PDFU16;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9686 kern_type = KERN_TYPE_PDF11;
9687 dgst_size = DGST_SIZE_4_4;
9688 parse_func = pdf11_parse_hash;
9689 sort_by_digest = sort_by_digest_4_4;
9690 opti_type = OPTI_TYPE_ZERO_BYTE
9691 | OPTI_TYPE_NOT_ITERATED;
9692 dgst_pos0 = 0;
9693 dgst_pos1 = 1;
9694 dgst_pos2 = 2;
9695 dgst_pos3 = 3;
9696 break;
9697
9698 case 10410: hash_type = HASH_TYPE_PDFU16;
9699 salt_type = SALT_TYPE_EMBEDDED;
9700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9702 kern_type = KERN_TYPE_PDF11CM1;
9703 dgst_size = DGST_SIZE_4_4;
9704 parse_func = pdf11cm1_parse_hash;
9705 sort_by_digest = sort_by_digest_4_4;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_NOT_ITERATED;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 10420: hash_type = HASH_TYPE_PDFU16;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_PDF11CM2;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = pdf11cm2_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 10500: hash_type = HASH_TYPE_PDFU16;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9734 kern_type = KERN_TYPE_PDF14;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = pdf14_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 10600: hash_type = HASH_TYPE_SHA256;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_BE
9750 | OPTS_TYPE_ST_ADD80
9751 | OPTS_TYPE_ST_ADDBITS15
9752 | OPTS_TYPE_HASH_COPY;
9753 kern_type = KERN_TYPE_SHA256_PWSLT;
9754 dgst_size = DGST_SIZE_4_8;
9755 parse_func = pdf17l3_parse_hash;
9756 sort_by_digest = sort_by_digest_4_8;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_PRECOMPUTE_INIT
9759 | OPTI_TYPE_PRECOMPUTE_MERKLE
9760 | OPTI_TYPE_EARLY_SKIP
9761 | OPTI_TYPE_NOT_ITERATED
9762 | OPTI_TYPE_APPENDED_SALT
9763 | OPTI_TYPE_RAW_HASH;
9764 dgst_pos0 = 3;
9765 dgst_pos1 = 7;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 6;
9768 break;
9769
9770 case 10700: hash_type = HASH_TYPE_PDFU32;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE
9774 | OPTS_TYPE_HASH_COPY;
9775 kern_type = KERN_TYPE_PDF17L8;
9776 dgst_size = DGST_SIZE_4_8;
9777 parse_func = pdf17l8_parse_hash;
9778 sort_by_digest = sort_by_digest_4_8;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_NOT_ITERATED;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 10800: hash_type = HASH_TYPE_SHA384;
9788 salt_type = SALT_TYPE_NONE;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_PT_ADD80
9792 | OPTS_TYPE_PT_ADDBITS15;
9793 kern_type = KERN_TYPE_SHA384;
9794 dgst_size = DGST_SIZE_8_8;
9795 parse_func = sha384_parse_hash;
9796 sort_by_digest = sort_by_digest_8_8;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_PRECOMPUTE_MERKLE
9800 | OPTI_TYPE_EARLY_SKIP
9801 | OPTI_TYPE_NOT_ITERATED
9802 | OPTI_TYPE_NOT_SALTED
9803 | OPTI_TYPE_USES_BITS_64
9804 | OPTI_TYPE_RAW_HASH;
9805 dgst_pos0 = 6;
9806 dgst_pos1 = 7;
9807 dgst_pos2 = 4;
9808 dgst_pos3 = 5;
9809 break;
9810
9811 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_LE
9815 | OPTS_TYPE_ST_BASE64
9816 | OPTS_TYPE_HASH_COPY;
9817 kern_type = KERN_TYPE_PBKDF2_SHA256;
9818 dgst_size = DGST_SIZE_4_32;
9819 parse_func = pbkdf2_sha256_parse_hash;
9820 sort_by_digest = sort_by_digest_4_32;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_SLOW_HASH_SIMD;
9823 dgst_pos0 = 0;
9824 dgst_pos1 = 1;
9825 dgst_pos2 = 2;
9826 dgst_pos3 = 3;
9827 break;
9828
9829 case 11000: hash_type = HASH_TYPE_MD5;
9830 salt_type = SALT_TYPE_INTERN;
9831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9832 opts_type = OPTS_TYPE_PT_GENERATE_LE
9833 | OPTS_TYPE_PT_ADD80;
9834 kern_type = KERN_TYPE_PRESTASHOP;
9835 dgst_size = DGST_SIZE_4_4;
9836 parse_func = prestashop_parse_hash;
9837 sort_by_digest = sort_by_digest_4_4;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_PRECOMPUTE_INIT
9840 | OPTI_TYPE_NOT_ITERATED
9841 | OPTI_TYPE_PREPENDED_SALT;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 3;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 1;
9846 break;
9847
9848 case 11100: hash_type = HASH_TYPE_MD5;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_ADD80;
9853 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9854 dgst_size = DGST_SIZE_4_4;
9855 parse_func = postgresql_auth_parse_hash;
9856 sort_by_digest = sort_by_digest_4_4;
9857 opti_type = OPTI_TYPE_ZERO_BYTE
9858 | OPTI_TYPE_PRECOMPUTE_INIT
9859 | OPTI_TYPE_PRECOMPUTE_MERKLE
9860 | OPTI_TYPE_EARLY_SKIP;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 3;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 1;
9865 break;
9866
9867 case 11200: hash_type = HASH_TYPE_SHA1;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_BE
9871 | OPTS_TYPE_PT_ADD80
9872 | OPTS_TYPE_ST_HEX;
9873 kern_type = KERN_TYPE_MYSQL_AUTH;
9874 dgst_size = DGST_SIZE_4_5;
9875 parse_func = mysql_auth_parse_hash;
9876 sort_by_digest = sort_by_digest_4_5;
9877 opti_type = OPTI_TYPE_ZERO_BYTE
9878 | OPTI_TYPE_EARLY_SKIP;
9879 dgst_pos0 = 3;
9880 dgst_pos1 = 4;
9881 dgst_pos2 = 2;
9882 dgst_pos3 = 1;
9883 break;
9884
9885 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9886 salt_type = SALT_TYPE_EMBEDDED;
9887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9888 opts_type = OPTS_TYPE_PT_GENERATE_LE
9889 | OPTS_TYPE_ST_HEX
9890 | OPTS_TYPE_ST_ADD80;
9891 kern_type = KERN_TYPE_BITCOIN_WALLET;
9892 dgst_size = DGST_SIZE_4_4;
9893 parse_func = bitcoin_wallet_parse_hash;
9894 sort_by_digest = sort_by_digest_4_4;
9895 opti_type = OPTI_TYPE_ZERO_BYTE;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 1;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 3;
9900 break;
9901
9902 case 11400: hash_type = HASH_TYPE_MD5;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE
9906 | OPTS_TYPE_PT_ADD80
9907 | OPTS_TYPE_HASH_COPY;
9908 kern_type = KERN_TYPE_SIP_AUTH;
9909 dgst_size = DGST_SIZE_4_4;
9910 parse_func = sip_auth_parse_hash;
9911 sort_by_digest = sort_by_digest_4_4;
9912 opti_type = OPTI_TYPE_ZERO_BYTE;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 3;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 1;
9917 break;
9918
9919 case 11500: hash_type = HASH_TYPE_CRC32;
9920 salt_type = SALT_TYPE_INTERN;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_ST_GENERATE_LE
9924 | OPTS_TYPE_ST_HEX;
9925 kern_type = KERN_TYPE_CRC32;
9926 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9927 parse_func = crc32_parse_hash;
9928 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 11600: hash_type = HASH_TYPE_AES;
9937 salt_type = SALT_TYPE_EMBEDDED;
9938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE
9940 | OPTS_TYPE_PT_NEVERCRACK;
9941 kern_type = KERN_TYPE_SEVEN_ZIP;
9942 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9943 parse_func = seven_zip_parse_hash;
9944 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9953 salt_type = SALT_TYPE_NONE;
9954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_PT_ADD01;
9957 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9958 dgst_size = DGST_SIZE_4_8;
9959 parse_func = gost2012sbog_256_parse_hash;
9960 sort_by_digest = sort_by_digest_4_8;
9961 opti_type = OPTI_TYPE_ZERO_BYTE;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9969 salt_type = SALT_TYPE_NONE;
9970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE
9972 | OPTS_TYPE_PT_ADD01;
9973 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9974 dgst_size = DGST_SIZE_4_16;
9975 parse_func = gost2012sbog_512_parse_hash;
9976 sort_by_digest = sort_by_digest_4_16;
9977 opti_type = OPTI_TYPE_ZERO_BYTE;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9985 salt_type = SALT_TYPE_EMBEDDED;
9986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE
9988 | OPTS_TYPE_ST_BASE64
9989 | OPTS_TYPE_HASH_COPY;
9990 kern_type = KERN_TYPE_PBKDF2_MD5;
9991 dgst_size = DGST_SIZE_4_32;
9992 parse_func = pbkdf2_md5_parse_hash;
9993 sort_by_digest = sort_by_digest_4_32;
9994 opti_type = OPTI_TYPE_ZERO_BYTE
9995 | OPTI_TYPE_SLOW_HASH_SIMD;
9996 dgst_pos0 = 0;
9997 dgst_pos1 = 1;
9998 dgst_pos2 = 2;
9999 dgst_pos3 = 3;
10000 break;
10001
10002 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10003 salt_type = SALT_TYPE_EMBEDDED;
10004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10005 opts_type = OPTS_TYPE_PT_GENERATE_LE
10006 | OPTS_TYPE_ST_BASE64
10007 | OPTS_TYPE_HASH_COPY;
10008 kern_type = KERN_TYPE_PBKDF2_SHA1;
10009 dgst_size = DGST_SIZE_4_32;
10010 parse_func = pbkdf2_sha1_parse_hash;
10011 sort_by_digest = sort_by_digest_4_32;
10012 opti_type = OPTI_TYPE_ZERO_BYTE
10013 | OPTI_TYPE_SLOW_HASH_SIMD;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE
10024 | OPTS_TYPE_ST_BASE64
10025 | OPTS_TYPE_HASH_COPY;
10026 kern_type = KERN_TYPE_PBKDF2_SHA512;
10027 dgst_size = DGST_SIZE_8_16;
10028 parse_func = pbkdf2_sha512_parse_hash;
10029 sort_by_digest = sort_by_digest_8_16;
10030 opti_type = OPTI_TYPE_ZERO_BYTE
10031 | OPTI_TYPE_USES_BITS_64
10032 | OPTI_TYPE_SLOW_HASH_SIMD;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10040 salt_type = SALT_TYPE_EMBEDDED;
10041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10043 kern_type = KERN_TYPE_ECRYPTFS;
10044 dgst_size = DGST_SIZE_8_8;
10045 parse_func = ecryptfs_parse_hash;
10046 sort_by_digest = sort_by_digest_8_8;
10047 opti_type = OPTI_TYPE_ZERO_BYTE
10048 | OPTI_TYPE_USES_BITS_64;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 12300: hash_type = HASH_TYPE_ORACLET;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10059 kern_type = KERN_TYPE_ORACLET;
10060 dgst_size = DGST_SIZE_8_16;
10061 parse_func = oraclet_parse_hash;
10062 sort_by_digest = sort_by_digest_8_16;
10063 opti_type = OPTI_TYPE_ZERO_BYTE
10064 | OPTI_TYPE_USES_BITS_64;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10072 salt_type = SALT_TYPE_EMBEDDED;
10073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10075 kern_type = KERN_TYPE_BSDICRYPT;
10076 dgst_size = DGST_SIZE_4_4;
10077 parse_func = bsdicrypt_parse_hash;
10078 sort_by_digest = sort_by_digest_4_4;
10079 opti_type = OPTI_TYPE_ZERO_BYTE
10080 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 12500: hash_type = HASH_TYPE_RAR3HP;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10091 kern_type = KERN_TYPE_RAR3;
10092 dgst_size = DGST_SIZE_4_4;
10093 parse_func = rar3hp_parse_hash;
10094 sort_by_digest = sort_by_digest_4_4;
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 12600: hash_type = HASH_TYPE_SHA256;
10103 salt_type = SALT_TYPE_INTERN;
10104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_BE
10106 | OPTS_TYPE_PT_ADD80;
10107 kern_type = KERN_TYPE_CF10;
10108 dgst_size = DGST_SIZE_4_8;
10109 parse_func = cf10_parse_hash;
10110 sort_by_digest = sort_by_digest_4_8;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_PRECOMPUTE_INIT
10113 | OPTI_TYPE_EARLY_SKIP
10114 | OPTI_TYPE_NOT_ITERATED;
10115 dgst_pos0 = 3;
10116 dgst_pos1 = 7;
10117 dgst_pos2 = 2;
10118 dgst_pos3 = 6;
10119 break;
10120
10121 case 12700: hash_type = HASH_TYPE_AES;
10122 salt_type = SALT_TYPE_EMBEDDED;
10123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10124 opts_type = OPTS_TYPE_PT_GENERATE_LE
10125 | OPTS_TYPE_HASH_COPY;
10126 kern_type = KERN_TYPE_MYWALLET;
10127 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10128 parse_func = mywallet_parse_hash;
10129 sort_by_digest = sort_by_digest_4_5;
10130 opti_type = OPTI_TYPE_ZERO_BYTE;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 1;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 3;
10135 break;
10136
10137 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10141 kern_type = KERN_TYPE_MS_DRSR;
10142 dgst_size = DGST_SIZE_4_8;
10143 parse_func = ms_drsr_parse_hash;
10144 sort_by_digest = sort_by_digest_4_8;
10145 opti_type = OPTI_TYPE_ZERO_BYTE;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10153 salt_type = SALT_TYPE_EMBEDDED;
10154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10156 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10157 dgst_size = DGST_SIZE_4_8;
10158 parse_func = androidfde_samsung_parse_hash;
10159 sort_by_digest = sort_by_digest_4_8;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10171 kern_type = KERN_TYPE_RAR5;
10172 dgst_size = DGST_SIZE_4_4;
10173 parse_func = rar5_parse_hash;
10174 sort_by_digest = sort_by_digest_4_4;
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 13100: hash_type = HASH_TYPE_KRB5TGS;
10183 salt_type = SALT_TYPE_EMBEDDED;
10184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10186 kern_type = KERN_TYPE_KRB5TGS;
10187 dgst_size = DGST_SIZE_4_4;
10188 parse_func = krb5tgs_parse_hash;
10189 sort_by_digest = sort_by_digest_4_4;
10190 opti_type = OPTI_TYPE_ZERO_BYTE
10191 | OPTI_TYPE_NOT_ITERATED;
10192 dgst_pos0 = 0;
10193 dgst_pos1 = 1;
10194 dgst_pos2 = 2;
10195 dgst_pos3 = 3;
10196 break;
10197
10198 case 13200: hash_type = HASH_TYPE_AES;
10199 salt_type = SALT_TYPE_EMBEDDED;
10200 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10201 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10202 kern_type = KERN_TYPE_AXCRYPT;
10203 dgst_size = DGST_SIZE_4_4;
10204 parse_func = axcrypt_parse_hash;
10205 sort_by_digest = sort_by_digest_4_4;
10206 opti_type = OPTI_TYPE_ZERO_BYTE;
10207 dgst_pos0 = 0;
10208 dgst_pos1 = 1;
10209 dgst_pos2 = 2;
10210 dgst_pos3 = 3;
10211 break;
10212
10213 case 13300: hash_type = HASH_TYPE_SHA1;
10214 salt_type = SALT_TYPE_NONE;
10215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10216 opts_type = OPTS_TYPE_PT_GENERATE_BE
10217 | OPTS_TYPE_PT_ADD80
10218 | OPTS_TYPE_PT_ADDBITS15;
10219 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10220 dgst_size = DGST_SIZE_4_5;
10221 parse_func = sha1axcrypt_parse_hash;
10222 sort_by_digest = sort_by_digest_4_5;
10223 opti_type = OPTI_TYPE_ZERO_BYTE
10224 | OPTI_TYPE_PRECOMPUTE_INIT
10225 | OPTI_TYPE_EARLY_SKIP
10226 | OPTI_TYPE_NOT_ITERATED
10227 | OPTI_TYPE_NOT_SALTED;
10228 dgst_pos0 = 0;
10229 dgst_pos1 = 4;
10230 dgst_pos2 = 3;
10231 dgst_pos3 = 2;
10232 break;
10233
10234 case 13400: hash_type = HASH_TYPE_AES;
10235 salt_type = SALT_TYPE_EMBEDDED;
10236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10238 kern_type = KERN_TYPE_KEEPASS;
10239 dgst_size = DGST_SIZE_4_4;
10240 parse_func = keepass_parse_hash;
10241 sort_by_digest = sort_by_digest_4_4;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13500: hash_type = HASH_TYPE_SHA1;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_BE
10253 | OPTS_TYPE_PT_UNICODE
10254 | OPTS_TYPE_PT_ADD80;
10255 kern_type = KERN_TYPE_PSTOKEN;
10256 dgst_size = DGST_SIZE_4_5;
10257 parse_func = pstoken_parse_hash;
10258 sort_by_digest = sort_by_digest_4_5;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_PRECOMPUTE_INIT
10261 | OPTI_TYPE_EARLY_SKIP
10262 | OPTI_TYPE_NOT_ITERATED
10263 | OPTI_TYPE_PREPENDED_SALT
10264 | OPTI_TYPE_RAW_HASH;
10265 dgst_pos0 = 3;
10266 dgst_pos1 = 4;
10267 dgst_pos2 = 2;
10268 dgst_pos3 = 1;
10269 break;
10270
10271 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10272 salt_type = SALT_TYPE_EMBEDDED;
10273 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10275 kern_type = KERN_TYPE_ZIP2;
10276 dgst_size = DGST_SIZE_4_4;
10277 parse_func = zip2_parse_hash;
10278 sort_by_digest = sort_by_digest_4_4;
10279 opti_type = OPTI_TYPE_ZERO_BYTE;
10280 dgst_pos0 = 0;
10281 dgst_pos1 = 1;
10282 dgst_pos2 = 2;
10283 dgst_pos3 = 3;
10284 break;
10285
10286 default: usage_mini_print (PROGNAME); return (-1);
10287 }
10288
10289 /**
10290 * parser
10291 */
10292
10293 data.parse_func = parse_func;
10294
10295 /**
10296 * misc stuff
10297 */
10298
10299 if (hex_salt)
10300 {
10301 if (salt_type == SALT_TYPE_INTERN)
10302 {
10303 opts_type |= OPTS_TYPE_ST_HEX;
10304 }
10305 else
10306 {
10307 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10308
10309 return (-1);
10310 }
10311 }
10312
10313 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10314 | (salt_type == SALT_TYPE_EXTERN)
10315 | (salt_type == SALT_TYPE_EMBEDDED)
10316 | (salt_type == SALT_TYPE_VIRTUAL));
10317
10318 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10319
10320 data.hash_type = hash_type;
10321 data.attack_mode = attack_mode;
10322 data.attack_kern = attack_kern;
10323 data.attack_exec = attack_exec;
10324 data.kern_type = kern_type;
10325 data.opts_type = opts_type;
10326 data.dgst_size = dgst_size;
10327 data.salt_type = salt_type;
10328 data.isSalted = isSalted;
10329 data.sort_by_digest = sort_by_digest;
10330 data.dgst_pos0 = dgst_pos0;
10331 data.dgst_pos1 = dgst_pos1;
10332 data.dgst_pos2 = dgst_pos2;
10333 data.dgst_pos3 = dgst_pos3;
10334
10335 esalt_size = 0;
10336
10337 switch (hash_mode)
10338 {
10339 case 2500: esalt_size = sizeof (wpa_t); break;
10340 case 5300: esalt_size = sizeof (ikepsk_t); break;
10341 case 5400: esalt_size = sizeof (ikepsk_t); break;
10342 case 5500: esalt_size = sizeof (netntlm_t); break;
10343 case 5600: esalt_size = sizeof (netntlm_t); break;
10344 case 6211: esalt_size = sizeof (tc_t); break;
10345 case 6212: esalt_size = sizeof (tc_t); break;
10346 case 6213: esalt_size = sizeof (tc_t); break;
10347 case 6221: esalt_size = sizeof (tc_t); break;
10348 case 6222: esalt_size = sizeof (tc_t); break;
10349 case 6223: esalt_size = sizeof (tc_t); break;
10350 case 6231: esalt_size = sizeof (tc_t); break;
10351 case 6232: esalt_size = sizeof (tc_t); break;
10352 case 6233: esalt_size = sizeof (tc_t); break;
10353 case 6241: esalt_size = sizeof (tc_t); break;
10354 case 6242: esalt_size = sizeof (tc_t); break;
10355 case 6243: esalt_size = sizeof (tc_t); break;
10356 case 6600: esalt_size = sizeof (agilekey_t); break;
10357 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10358 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10359 case 7300: esalt_size = sizeof (rakp_t); break;
10360 case 7500: esalt_size = sizeof (krb5pa_t); break;
10361 case 8200: esalt_size = sizeof (cloudkey_t); break;
10362 case 8800: esalt_size = sizeof (androidfde_t); break;
10363 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10364 case 9400: esalt_size = sizeof (office2007_t); break;
10365 case 9500: esalt_size = sizeof (office2010_t); break;
10366 case 9600: esalt_size = sizeof (office2013_t); break;
10367 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10368 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10369 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10370 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10371 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10372 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10373 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10374 case 10200: esalt_size = sizeof (cram_md5_t); break;
10375 case 10400: esalt_size = sizeof (pdf_t); break;
10376 case 10410: esalt_size = sizeof (pdf_t); break;
10377 case 10420: esalt_size = sizeof (pdf_t); break;
10378 case 10500: esalt_size = sizeof (pdf_t); break;
10379 case 10600: esalt_size = sizeof (pdf_t); break;
10380 case 10700: esalt_size = sizeof (pdf_t); break;
10381 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10382 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10383 case 11400: esalt_size = sizeof (sip_t); break;
10384 case 11600: esalt_size = sizeof (seven_zip_t); break;
10385 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10386 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10387 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10388 case 13000: esalt_size = sizeof (rar5_t); break;
10389 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10390 case 13400: esalt_size = sizeof (keepass_t); break;
10391 case 13500: esalt_size = sizeof (pstoken_t); break;
10392 case 13600: esalt_size = sizeof (zip2_t); break;
10393 }
10394
10395 data.esalt_size = esalt_size;
10396
10397 /**
10398 * choose dictionary parser
10399 */
10400
10401 if (hash_type == HASH_TYPE_LM)
10402 {
10403 get_next_word_func = get_next_word_lm;
10404 }
10405 else if (opts_type & OPTS_TYPE_PT_UPPER)
10406 {
10407 get_next_word_func = get_next_word_uc;
10408 }
10409 else
10410 {
10411 get_next_word_func = get_next_word_std;
10412 }
10413
10414 /**
10415 * dictstat
10416 */
10417
10418 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10419
10420 #ifdef _POSIX
10421 size_t dictstat_nmemb = 0;
10422 #endif
10423
10424 #ifdef _WIN
10425 uint dictstat_nmemb = 0;
10426 #endif
10427
10428 char dictstat[256] = { 0 };
10429
10430 FILE *dictstat_fp = NULL;
10431
10432 if (keyspace == 0)
10433 {
10434 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10435
10436 dictstat_fp = fopen (dictstat, "rb");
10437
10438 if (dictstat_fp)
10439 {
10440 #ifdef _POSIX
10441 struct stat tmpstat;
10442
10443 fstat (fileno (dictstat_fp), &tmpstat);
10444 #endif
10445
10446 #ifdef _WIN
10447 struct stat64 tmpstat;
10448
10449 _fstat64 (fileno (dictstat_fp), &tmpstat);
10450 #endif
10451
10452 if (tmpstat.st_mtime < COMPTIME)
10453 {
10454 /* with v0.15 the format changed so we have to ensure user is using a good version
10455 since there is no version-header in the dictstat file */
10456
10457 fclose (dictstat_fp);
10458
10459 unlink (dictstat);
10460 }
10461 else
10462 {
10463 while (!feof (dictstat_fp))
10464 {
10465 dictstat_t d;
10466
10467 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10468
10469 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10470
10471 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10472 {
10473 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10474
10475 return -1;
10476 }
10477 }
10478
10479 fclose (dictstat_fp);
10480 }
10481 }
10482 }
10483
10484 /**
10485 * potfile
10486 */
10487
10488 char potfile[256] = { 0 };
10489
10490 if (potfile_path == NULL)
10491 {
10492 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10493 }
10494 else
10495 {
10496 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10497 }
10498
10499 data.pot_fp = NULL;
10500
10501 FILE *out_fp = NULL;
10502 FILE *pot_fp = NULL;
10503
10504 if (show == 1 || left == 1)
10505 {
10506 pot_fp = fopen (potfile, "rb");
10507
10508 if (pot_fp == NULL)
10509 {
10510 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10511
10512 return (-1);
10513 }
10514
10515 if (outfile != NULL)
10516 {
10517 if ((out_fp = fopen (outfile, "ab")) == NULL)
10518 {
10519 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10520
10521 fclose (pot_fp);
10522
10523 return (-1);
10524 }
10525 }
10526 else
10527 {
10528 out_fp = stdout;
10529 }
10530 }
10531 else
10532 {
10533 if (potfile_disable == 0)
10534 {
10535 pot_fp = fopen (potfile, "ab");
10536
10537 if (pot_fp == NULL)
10538 {
10539 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10540
10541 return (-1);
10542 }
10543
10544 data.pot_fp = pot_fp;
10545 }
10546 }
10547
10548 pot_t *pot = NULL;
10549
10550 uint pot_cnt = 0;
10551 uint pot_avail = 0;
10552
10553 if (show == 1 || left == 1)
10554 {
10555 SUPPRESS_OUTPUT = 1;
10556
10557 pot_avail = count_lines (pot_fp);
10558
10559 rewind (pot_fp);
10560
10561 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10562
10563 uint pot_hashes_avail = 0;
10564
10565 uint line_num = 0;
10566
10567 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10568
10569 while (!feof (pot_fp))
10570 {
10571 line_num++;
10572
10573 int line_len = fgetl (pot_fp, line_buf);
10574
10575 if (line_len == 0) continue;
10576
10577 char *plain_buf = line_buf + line_len;
10578
10579 pot_t *pot_ptr = &pot[pot_cnt];
10580
10581 hash_t *hashes_buf = &pot_ptr->hash;
10582
10583 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10584 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10585
10586 if (pot_cnt == pot_hashes_avail)
10587 {
10588 uint pos = 0;
10589
10590 for (pos = 0; pos < INCR_POT; pos++)
10591 {
10592 if ((pot_cnt + pos) >= pot_avail) break;
10593
10594 pot_t *tmp_pot = &pot[pot_cnt + pos];
10595
10596 hash_t *tmp_hash = &tmp_pot->hash;
10597
10598 tmp_hash->digest = mymalloc (dgst_size);
10599
10600 if (isSalted)
10601 {
10602 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10603 }
10604
10605 if (esalt_size)
10606 {
10607 tmp_hash->esalt = mymalloc (esalt_size);
10608 }
10609
10610 pot_hashes_avail++;
10611 }
10612 }
10613
10614 int plain_len = 0;
10615
10616 int parser_status;
10617
10618 int iter = MAX_CUT_TRIES;
10619
10620 do
10621 {
10622 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10623 {
10624 if (line_buf[i] == ':')
10625 {
10626 line_len--;
10627
10628 break;
10629 }
10630 }
10631
10632 if (data.hash_mode != 2500)
10633 {
10634 parser_status = parse_func (line_buf, line_len, hashes_buf);
10635 }
10636 else
10637 {
10638 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10639
10640 if (line_len > max_salt_size)
10641 {
10642 parser_status = PARSER_GLOBAL_LENGTH;
10643 }
10644 else
10645 {
10646 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10647
10648 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10649
10650 hashes_buf->salt->salt_len = line_len;
10651
10652 parser_status = PARSER_OK;
10653 }
10654 }
10655
10656 // if NOT parsed without error, we add the ":" to the plain
10657
10658 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10659 {
10660 plain_len++;
10661 plain_buf--;
10662 }
10663
10664 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10665
10666 if (parser_status < PARSER_GLOBAL_ZERO)
10667 {
10668 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10669
10670 continue;
10671 }
10672
10673 if (plain_len >= 255) continue;
10674
10675 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10676
10677 pot_ptr->plain_len = plain_len;
10678
10679 pot_cnt++;
10680 }
10681
10682 myfree (line_buf);
10683
10684 fclose (pot_fp);
10685
10686 SUPPRESS_OUTPUT = 0;
10687
10688 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10689 }
10690
10691 /**
10692 * word len
10693 */
10694
10695 uint pw_min = PW_MIN;
10696 uint pw_max = PW_MAX;
10697
10698 switch (hash_mode)
10699 {
10700 case 125: if (pw_max > 32) pw_max = 32;
10701 break;
10702 case 400: if (pw_max > 40) pw_max = 40;
10703 break;
10704 case 500: if (pw_max > 16) pw_max = 16;
10705 break;
10706 case 1500: if (pw_max > 8) pw_max = 8;
10707 break;
10708 case 1600: if (pw_max > 16) pw_max = 16;
10709 break;
10710 case 1800: if (pw_max > 16) pw_max = 16;
10711 break;
10712 case 2100: if (pw_max > 16) pw_max = 16;
10713 break;
10714 case 2500: if (pw_min < 8) pw_min = 8;
10715 break;
10716 case 3000: if (pw_max > 7) pw_max = 7;
10717 break;
10718 case 5200: if (pw_max > 24) pw_max = 24;
10719 break;
10720 case 5800: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 6300: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 7400: if (pw_max > 16) pw_max = 16;
10725 break;
10726 case 7900: if (pw_max > 48) pw_max = 48;
10727 break;
10728 case 8500: if (pw_max > 8) pw_max = 8;
10729 break;
10730 case 8600: if (pw_max > 16) pw_max = 16;
10731 break;
10732 case 9710: pw_min = 5;
10733 pw_max = 5;
10734 break;
10735 case 9810: pw_min = 5;
10736 pw_max = 5;
10737 break;
10738 case 10410: pw_min = 5;
10739 pw_max = 5;
10740 break;
10741 case 10300: if (pw_max < 3) pw_min = 3;
10742 if (pw_max > 40) pw_max = 40;
10743 break;
10744 case 10500: if (pw_max < 3) pw_min = 3;
10745 if (pw_max > 40) pw_max = 40;
10746 break;
10747 case 10700: if (pw_max > 16) pw_max = 16;
10748 break;
10749 case 11300: if (pw_max > 40) pw_max = 40;
10750 break;
10751 case 11600: if (pw_max > 32) pw_max = 32;
10752 break;
10753 case 12500: if (pw_max > 20) pw_max = 20;
10754 break;
10755 case 12800: if (pw_max > 24) pw_max = 24;
10756 break;
10757 }
10758
10759 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10760 {
10761 switch (attack_kern)
10762 {
10763 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10764 break;
10765 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10766 break;
10767 }
10768 }
10769
10770 /**
10771 * charsets : keep them together for more easy maintainnce
10772 */
10773
10774 cs_t mp_sys[6] = { { { 0 }, 0 } };
10775 cs_t mp_usr[4] = { { { 0 }, 0 } };
10776
10777 mp_setup_sys (mp_sys);
10778
10779 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10780 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10781 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10782 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10783
10784 /**
10785 * load hashes, part I: find input mode, count hashes
10786 */
10787
10788 uint hashlist_mode = 0;
10789 uint hashlist_format = HLFMT_HASHCAT;
10790
10791 uint hashes_avail = 0;
10792
10793 if (benchmark == 0)
10794 {
10795 struct stat f;
10796
10797 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10798
10799 if ((hash_mode == 2500) ||
10800 (hash_mode == 5200) ||
10801 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10802 (hash_mode == 9000))
10803 {
10804 hashlist_mode = HL_MODE_ARG;
10805
10806 char *hashfile = myargv[optind];
10807
10808 data.hashfile = hashfile;
10809
10810 logfile_top_var_string ("target", hashfile);
10811 }
10812
10813 if (hashlist_mode == HL_MODE_ARG)
10814 {
10815 if (hash_mode == 2500)
10816 {
10817 struct stat st;
10818
10819 if (stat (data.hashfile, &st) == -1)
10820 {
10821 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10822
10823 return (-1);
10824 }
10825
10826 hashes_avail = st.st_size / sizeof (hccap_t);
10827 }
10828 else
10829 {
10830 hashes_avail = 1;
10831 }
10832 }
10833 else if (hashlist_mode == HL_MODE_FILE)
10834 {
10835 char *hashfile = myargv[optind];
10836
10837 data.hashfile = hashfile;
10838
10839 logfile_top_var_string ("target", hashfile);
10840
10841 FILE *fp = NULL;
10842
10843 if ((fp = fopen (hashfile, "rb")) == NULL)
10844 {
10845 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10846
10847 return (-1);
10848 }
10849
10850 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10851
10852 hashes_avail = count_lines (fp);
10853
10854 rewind (fp);
10855
10856 if (hashes_avail == 0)
10857 {
10858 log_error ("ERROR: hashfile is empty or corrupt");
10859
10860 fclose (fp);
10861
10862 return (-1);
10863 }
10864
10865 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10866
10867 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10868 {
10869 log_error ("ERROR: remove not supported in native hashfile-format mode");
10870
10871 fclose (fp);
10872
10873 return (-1);
10874 }
10875
10876 fclose (fp);
10877 }
10878 }
10879 else
10880 {
10881 hashlist_mode = HL_MODE_ARG;
10882
10883 hashes_avail = 1;
10884 }
10885
10886 if (hash_mode == 3000) hashes_avail *= 2;
10887
10888 data.hashlist_mode = hashlist_mode;
10889 data.hashlist_format = hashlist_format;
10890
10891 logfile_top_uint (hashlist_mode);
10892 logfile_top_uint (hashlist_format);
10893
10894 /**
10895 * load hashes, part II: allocate required memory, set pointers
10896 */
10897
10898 hash_t *hashes_buf = NULL;
10899 void *digests_buf = NULL;
10900 salt_t *salts_buf = NULL;
10901 void *esalts_buf = NULL;
10902
10903 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10904
10905 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10906
10907 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10908 {
10909 u32 hash_pos;
10910
10911 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10912 {
10913 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10914
10915 hashes_buf[hash_pos].hash_info = hash_info;
10916
10917 if (username && (remove || show || left))
10918 {
10919 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10920 }
10921
10922 if (benchmark)
10923 {
10924 hash_info->orighash = (char *) mymalloc (256);
10925 }
10926 }
10927 }
10928
10929 if (isSalted)
10930 {
10931 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10932
10933 if (esalt_size)
10934 {
10935 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10936 }
10937 }
10938 else
10939 {
10940 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10941 }
10942
10943 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10944 {
10945 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10946
10947 if (isSalted)
10948 {
10949 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10950
10951 if (esalt_size)
10952 {
10953 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10954 }
10955 }
10956 else
10957 {
10958 hashes_buf[hash_pos].salt = &salts_buf[0];
10959 }
10960 }
10961
10962 /**
10963 * load hashes, part III: parse hashes or generate them if benchmark
10964 */
10965
10966 uint hashes_cnt = 0;
10967
10968 if (benchmark == 0)
10969 {
10970 if (keyspace == 1)
10971 {
10972 // useless to read hash file for keyspace, cheat a little bit w/ optind
10973 }
10974 else if (hashes_avail == 0)
10975 {
10976 }
10977 else if (hashlist_mode == HL_MODE_ARG)
10978 {
10979 char *input_buf = myargv[optind];
10980
10981 uint input_len = strlen (input_buf);
10982
10983 logfile_top_var_string ("target", input_buf);
10984
10985 char *hash_buf = NULL;
10986 int hash_len = 0;
10987
10988 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10989
10990 bool hash_fmt_error = 0;
10991
10992 if (hash_len < 1) hash_fmt_error = 1;
10993 if (hash_buf == NULL) hash_fmt_error = 1;
10994
10995 if (hash_fmt_error)
10996 {
10997 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10998 }
10999 else
11000 {
11001 if (opts_type & OPTS_TYPE_HASH_COPY)
11002 {
11003 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11004
11005 hash_info_tmp->orighash = mystrdup (hash_buf);
11006 }
11007
11008 if (isSalted)
11009 {
11010 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11011 }
11012
11013 int parser_status = PARSER_OK;
11014
11015 if (hash_mode == 2500)
11016 {
11017 if (hash_len == 0)
11018 {
11019 log_error ("ERROR: hccap file not specified");
11020
11021 return (-1);
11022 }
11023
11024 hashlist_mode = HL_MODE_FILE;
11025
11026 data.hashlist_mode = hashlist_mode;
11027
11028 FILE *fp = fopen (hash_buf, "rb");
11029
11030 if (fp == NULL)
11031 {
11032 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11033
11034 return (-1);
11035 }
11036
11037 if (hashes_avail < 1)
11038 {
11039 log_error ("ERROR: hccap file is empty or corrupt");
11040
11041 fclose (fp);
11042
11043 return (-1);
11044 }
11045
11046 uint hccap_size = sizeof (hccap_t);
11047
11048 char *in = (char *) mymalloc (hccap_size);
11049
11050 while (!feof (fp))
11051 {
11052 int n = fread (in, hccap_size, 1, fp);
11053
11054 if (n != 1)
11055 {
11056 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11057
11058 break;
11059 }
11060
11061 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11062
11063 if (parser_status != PARSER_OK)
11064 {
11065 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11066
11067 continue;
11068 }
11069
11070 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11071
11072 if ((show == 1) || (left == 1))
11073 {
11074 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11075
11076 char *salt_ptr = (char *) tmp_salt->salt_buf;
11077
11078 int cur_pos = tmp_salt->salt_len;
11079 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11080
11081 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11082
11083 // do the appending task
11084
11085 snprintf (salt_ptr + cur_pos,
11086 rem_len,
11087 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11088 wpa->orig_mac1[0],
11089 wpa->orig_mac1[1],
11090 wpa->orig_mac1[2],
11091 wpa->orig_mac1[3],
11092 wpa->orig_mac1[4],
11093 wpa->orig_mac1[5],
11094 wpa->orig_mac2[0],
11095 wpa->orig_mac2[1],
11096 wpa->orig_mac2[2],
11097 wpa->orig_mac2[3],
11098 wpa->orig_mac2[4],
11099 wpa->orig_mac2[5]);
11100
11101 // memset () the remaining part of the salt
11102
11103 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11104 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11105
11106 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11107
11108 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11109 }
11110
11111 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);
11112 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);
11113
11114 hashes_cnt++;
11115 }
11116
11117 fclose (fp);
11118
11119 myfree (in);
11120 }
11121 else if (hash_mode == 3000)
11122 {
11123 if (hash_len == 32)
11124 {
11125 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11126
11127 hash_t *lm_hash_left = NULL;
11128
11129 if (parser_status == PARSER_OK)
11130 {
11131 lm_hash_left = &hashes_buf[hashes_cnt];
11132
11133 hashes_cnt++;
11134 }
11135 else
11136 {
11137 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11138 }
11139
11140 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11141
11142 hash_t *lm_hash_right = NULL;
11143
11144 if (parser_status == PARSER_OK)
11145 {
11146 lm_hash_right = &hashes_buf[hashes_cnt];
11147
11148 hashes_cnt++;
11149 }
11150 else
11151 {
11152 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11153 }
11154
11155 // show / left
11156
11157 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11158 {
11159 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);
11160 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);
11161 }
11162 }
11163 else
11164 {
11165 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11166
11167 if (parser_status == PARSER_OK)
11168 {
11169 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11170 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11171 }
11172
11173 if (parser_status == PARSER_OK)
11174 {
11175 hashes_cnt++;
11176 }
11177 else
11178 {
11179 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11180 }
11181 }
11182 }
11183 else
11184 {
11185 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11186
11187 if (parser_status == PARSER_OK)
11188 {
11189 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11190 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11191 }
11192
11193 if (parser_status == PARSER_OK)
11194 {
11195 hashes_cnt++;
11196 }
11197 else
11198 {
11199 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11200 }
11201 }
11202 }
11203 }
11204 else if (hashlist_mode == HL_MODE_FILE)
11205 {
11206 char *hashfile = data.hashfile;
11207
11208 FILE *fp;
11209
11210 if ((fp = fopen (hashfile, "rb")) == NULL)
11211 {
11212 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11213
11214 return (-1);
11215 }
11216
11217 uint line_num = 0;
11218
11219 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11220
11221 while (!feof (fp))
11222 {
11223 line_num++;
11224
11225 int line_len = fgetl (fp, line_buf);
11226
11227 if (line_len == 0) continue;
11228
11229 char *hash_buf = NULL;
11230 int hash_len = 0;
11231
11232 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11233
11234 bool hash_fmt_error = 0;
11235
11236 if (hash_len < 1) hash_fmt_error = 1;
11237 if (hash_buf == NULL) hash_fmt_error = 1;
11238
11239 if (hash_fmt_error)
11240 {
11241 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11242
11243 continue;
11244 }
11245
11246 if (username)
11247 {
11248 char *user_buf = NULL;
11249 int user_len = 0;
11250
11251 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11252
11253 if (remove || show)
11254 {
11255 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11256
11257 *user = (user_t *) mymalloc (sizeof (user_t));
11258
11259 user_t *user_ptr = *user;
11260
11261 if (user_buf != NULL)
11262 {
11263 user_ptr->user_name = mystrdup (user_buf);
11264 }
11265 else
11266 {
11267 user_ptr->user_name = mystrdup ("");
11268 }
11269
11270 user_ptr->user_len = user_len;
11271 }
11272 }
11273
11274 if (opts_type & OPTS_TYPE_HASH_COPY)
11275 {
11276 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11277
11278 hash_info_tmp->orighash = mystrdup (hash_buf);
11279 }
11280
11281 if (isSalted)
11282 {
11283 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11284 }
11285
11286 if (hash_mode == 3000)
11287 {
11288 if (hash_len == 32)
11289 {
11290 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11291
11292 if (parser_status < PARSER_GLOBAL_ZERO)
11293 {
11294 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11295
11296 continue;
11297 }
11298
11299 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11300
11301 hashes_cnt++;
11302
11303 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11304
11305 if (parser_status < PARSER_GLOBAL_ZERO)
11306 {
11307 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11308
11309 continue;
11310 }
11311
11312 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11313
11314 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);
11315
11316 hashes_cnt++;
11317
11318 // show / left
11319
11320 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);
11321 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);
11322 }
11323 else
11324 {
11325 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11326
11327 if (parser_status < PARSER_GLOBAL_ZERO)
11328 {
11329 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11330
11331 continue;
11332 }
11333
11334 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);
11335
11336 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11337 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11338
11339 hashes_cnt++;
11340 }
11341 }
11342 else
11343 {
11344 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11345
11346 if (parser_status < PARSER_GLOBAL_ZERO)
11347 {
11348 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11349
11350 continue;
11351 }
11352
11353 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);
11354
11355 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11356 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11357
11358 hashes_cnt++;
11359 }
11360 }
11361
11362 myfree (line_buf);
11363
11364 fclose (fp);
11365
11366 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11367
11368 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11369 }
11370 }
11371 else
11372 {
11373 if (isSalted)
11374 {
11375 hashes_buf[0].salt->salt_len = 8;
11376
11377 // special salt handling
11378
11379 switch (hash_mode)
11380 {
11381 case 1500: hashes_buf[0].salt->salt_len = 2;
11382 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11383 break;
11384 case 1731: hashes_buf[0].salt->salt_len = 4;
11385 break;
11386 case 2410: hashes_buf[0].salt->salt_len = 4;
11387 break;
11388 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11389 break;
11390 case 3100: hashes_buf[0].salt->salt_len = 1;
11391 break;
11392 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11393 break;
11394 case 5800: hashes_buf[0].salt->salt_len = 16;
11395 break;
11396 case 6800: hashes_buf[0].salt->salt_len = 32;
11397 break;
11398 case 8400: hashes_buf[0].salt->salt_len = 40;
11399 break;
11400 case 8800: hashes_buf[0].salt->salt_len = 16;
11401 break;
11402 case 8900: hashes_buf[0].salt->salt_len = 16;
11403 hashes_buf[0].salt->scrypt_N = 1024;
11404 hashes_buf[0].salt->scrypt_r = 1;
11405 hashes_buf[0].salt->scrypt_p = 1;
11406 break;
11407 case 9100: hashes_buf[0].salt->salt_len = 16;
11408 break;
11409 case 9300: hashes_buf[0].salt->salt_len = 14;
11410 hashes_buf[0].salt->scrypt_N = 16384;
11411 hashes_buf[0].salt->scrypt_r = 1;
11412 hashes_buf[0].salt->scrypt_p = 1;
11413 break;
11414 case 9400: hashes_buf[0].salt->salt_len = 16;
11415 break;
11416 case 9500: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 9600: hashes_buf[0].salt->salt_len = 16;
11419 break;
11420 case 9700: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 9710: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9720: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9800: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9810: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9820: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 10300: hashes_buf[0].salt->salt_len = 12;
11433 break;
11434 case 11500: hashes_buf[0].salt->salt_len = 4;
11435 break;
11436 case 11600: hashes_buf[0].salt->salt_len = 4;
11437 break;
11438 case 12400: hashes_buf[0].salt->salt_len = 4;
11439 break;
11440 case 12500: hashes_buf[0].salt->salt_len = 8;
11441 break;
11442 case 12600: hashes_buf[0].salt->salt_len = 64;
11443 break;
11444 }
11445
11446 // special esalt handling
11447
11448 switch (hash_mode)
11449 {
11450 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11451 break;
11452 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11453 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11454 break;
11455 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11456 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11457 break;
11458 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11459 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11460 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11461 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11462 break;
11463 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11464 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11465 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11466 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11467 break;
11468 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11469 break;
11470 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11471 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11472 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11473 break;
11474 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11475 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11476 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11477 break;
11478 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11481 break;
11482 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11485 break;
11486 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11489 break;
11490 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11491 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11492 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11493 break;
11494 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11495 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11496 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11497 break;
11498 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11499 break;
11500 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11501 break;
11502 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11503 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11504 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11505 break;
11506 }
11507 }
11508
11509 // set hashfile
11510
11511 switch (hash_mode)
11512 {
11513 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11514 break;
11515 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11516 break;
11517 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11518 break;
11519 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11520 break;
11521 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11544 break;
11545 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11546 break;
11547 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11548 break;
11549 }
11550
11551 // set default iterations
11552
11553 switch (hash_mode)
11554 {
11555 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11556 break;
11557 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11558 break;
11559 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11560 break;
11561 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11564 break;
11565 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11566 break;
11567 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11568 break;
11569 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11570 break;
11571 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11572 break;
11573 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11574 break;
11575 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11576 break;
11577 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11578 break;
11579 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11580 break;
11581 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11582 break;
11583 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11600 break;
11601 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11602 break;
11603 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11604 break;
11605 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11606 break;
11607 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11608 break;
11609 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11610 break;
11611 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11612 break;
11613 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11614 break;
11615 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11616 break;
11617 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11618 break;
11619 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11620 break;
11621 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11622 break;
11623 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11624 break;
11625 case 8900: hashes_buf[0].salt->salt_iter = 1;
11626 break;
11627 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11628 break;
11629 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11630 break;
11631 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11632 break;
11633 case 9300: hashes_buf[0].salt->salt_iter = 1;
11634 break;
11635 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11636 break;
11637 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11638 break;
11639 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11640 break;
11641 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11642 break;
11643 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11644 break;
11645 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11646 break;
11647 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11648 break;
11649 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11650 break;
11651 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11652 break;
11653 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11654 break;
11655 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11656 break;
11657 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11658 break;
11659 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11660 break;
11661 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11662 break;
11663 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11664 break;
11665 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11666 break;
11667 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11668 break;
11669 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11670 break;
11671 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11672 break;
11673 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11674 break;
11675 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11676 break;
11677 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11678 break;
11679 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11680 break;
11681 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11682 break;
11683 }
11684
11685 hashes_cnt = 1;
11686 }
11687
11688 if (show == 1 || left == 1)
11689 {
11690 for (uint i = 0; i < pot_cnt; i++)
11691 {
11692 pot_t *pot_ptr = &pot[i];
11693
11694 hash_t *hashes_buf = &pot_ptr->hash;
11695
11696 local_free (hashes_buf->digest);
11697
11698 if (isSalted)
11699 {
11700 local_free (hashes_buf->salt);
11701 }
11702 }
11703
11704 local_free (pot);
11705
11706 if (data.quiet == 0) log_info_nn ("");
11707
11708 return (0);
11709 }
11710
11711 if (keyspace == 0)
11712 {
11713 if (hashes_cnt == 0)
11714 {
11715 log_error ("ERROR: No hashes loaded");
11716
11717 return (-1);
11718 }
11719 }
11720
11721 /**
11722 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11723 */
11724
11725 if (data.outfile != NULL)
11726 {
11727 if (data.hashfile != NULL)
11728 {
11729 #ifdef _POSIX
11730 struct stat tmpstat_outfile;
11731 struct stat tmpstat_hashfile;
11732 #endif
11733
11734 #ifdef _WIN
11735 struct stat64 tmpstat_outfile;
11736 struct stat64 tmpstat_hashfile;
11737 #endif
11738
11739 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11740
11741 if (tmp_outfile_fp)
11742 {
11743 #ifdef _POSIX
11744 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11745 #endif
11746
11747 #ifdef _WIN
11748 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11749 #endif
11750
11751 fclose (tmp_outfile_fp);
11752 }
11753
11754 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11755
11756 if (tmp_hashfile_fp)
11757 {
11758 #ifdef _POSIX
11759 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11760 #endif
11761
11762 #ifdef _WIN
11763 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11764 #endif
11765
11766 fclose (tmp_hashfile_fp);
11767 }
11768
11769 if (tmp_outfile_fp && tmp_outfile_fp)
11770 {
11771 tmpstat_outfile.st_mode = 0;
11772 tmpstat_outfile.st_nlink = 0;
11773 tmpstat_outfile.st_uid = 0;
11774 tmpstat_outfile.st_gid = 0;
11775 tmpstat_outfile.st_rdev = 0;
11776 tmpstat_outfile.st_atime = 0;
11777
11778 tmpstat_hashfile.st_mode = 0;
11779 tmpstat_hashfile.st_nlink = 0;
11780 tmpstat_hashfile.st_uid = 0;
11781 tmpstat_hashfile.st_gid = 0;
11782 tmpstat_hashfile.st_rdev = 0;
11783 tmpstat_hashfile.st_atime = 0;
11784
11785 #ifdef _POSIX
11786 tmpstat_outfile.st_blksize = 0;
11787 tmpstat_outfile.st_blocks = 0;
11788
11789 tmpstat_hashfile.st_blksize = 0;
11790 tmpstat_hashfile.st_blocks = 0;
11791 #endif
11792
11793 #ifdef _POSIX
11794 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11795 {
11796 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11797
11798 return (-1);
11799 }
11800 #endif
11801
11802 #ifdef _WIN
11803 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11804 {
11805 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11806
11807 return (-1);
11808 }
11809 #endif
11810 }
11811 }
11812 }
11813
11814 /**
11815 * Remove duplicates
11816 */
11817
11818 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11819
11820 if (isSalted)
11821 {
11822 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11823 }
11824 else
11825 {
11826 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11827 }
11828
11829 uint hashes_cnt_orig = hashes_cnt;
11830
11831 hashes_cnt = 1;
11832
11833 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11834 {
11835 if (isSalted)
11836 {
11837 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11838 {
11839 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11840 }
11841 }
11842 else
11843 {
11844 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11845 }
11846
11847 if (hashes_pos > hashes_cnt)
11848 {
11849 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11850 }
11851
11852 hashes_cnt++;
11853 }
11854
11855 /**
11856 * Potfile removes
11857 */
11858
11859 uint potfile_remove_cracks = 0;
11860
11861 if (potfile_disable == 0)
11862 {
11863 hash_t hash_buf;
11864
11865 hash_buf.digest = mymalloc (dgst_size);
11866 hash_buf.salt = NULL;
11867 hash_buf.esalt = NULL;
11868 hash_buf.hash_info = NULL;
11869 hash_buf.cracked = 0;
11870
11871 if (isSalted)
11872 {
11873 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11874 }
11875
11876 if (esalt_size)
11877 {
11878 hash_buf.esalt = mymalloc (esalt_size);
11879 }
11880
11881 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11882
11883 // no solution for these special hash types (for instane because they use hashfile in output etc)
11884 if ((hash_mode != 5200) &&
11885 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11886 (hash_mode != 9000))
11887 {
11888 FILE *fp = fopen (potfile, "rb");
11889
11890 if (fp != NULL)
11891 {
11892 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11893
11894 // to be safe work with a copy (because of line_len loop, i etc)
11895 // moved up here because it's easier to handle continue case
11896 // it's just 64kb
11897
11898 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11899
11900 while (!feof (fp))
11901 {
11902 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11903
11904 if (ptr == NULL) break;
11905
11906 int line_len = strlen (line_buf);
11907
11908 if (line_len == 0) continue;
11909
11910 int iter = MAX_CUT_TRIES;
11911
11912 for (int i = line_len - 1; i && iter; i--, line_len--)
11913 {
11914 if (line_buf[i] != ':') continue;
11915
11916 if (isSalted)
11917 {
11918 memset (hash_buf.salt, 0, sizeof (salt_t));
11919 }
11920
11921 hash_t *found = NULL;
11922
11923 if (hash_mode == 6800)
11924 {
11925 if (i < 64) // 64 = 16 * uint in salt_buf[]
11926 {
11927 // manipulate salt_buf
11928 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11929
11930 hash_buf.salt->salt_len = i;
11931
11932 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11933 }
11934 }
11935 else if (hash_mode == 2500)
11936 {
11937 if (i < 64) // 64 = 16 * uint in salt_buf[]
11938 {
11939 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11940 // manipulate salt_buf
11941
11942 memcpy (line_buf_cpy, line_buf, i);
11943
11944 char *mac2_pos = strrchr (line_buf_cpy, ':');
11945
11946 if (mac2_pos == NULL) continue;
11947
11948 mac2_pos[0] = 0;
11949 mac2_pos++;
11950
11951 if (strlen (mac2_pos) != 12) continue;
11952
11953 char *mac1_pos = strrchr (line_buf_cpy, ':');
11954
11955 if (mac1_pos == NULL) continue;
11956
11957 mac1_pos[0] = 0;
11958 mac1_pos++;
11959
11960 if (strlen (mac1_pos) != 12) continue;
11961
11962 uint essid_length = mac1_pos - line_buf_cpy - 1;
11963
11964 // here we need the ESSID
11965 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11966
11967 hash_buf.salt->salt_len = essid_length;
11968
11969 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11970
11971 if (found)
11972 {
11973 wpa_t *wpa = (wpa_t *) found->esalt;
11974
11975 // compare hex string(s) vs binary MAC address(es)
11976
11977 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11978 {
11979 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11980 {
11981 found = NULL;
11982
11983 break;
11984 }
11985 }
11986
11987 // early skip ;)
11988 if (!found) continue;
11989
11990 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11991 {
11992 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11993 {
11994 found = NULL;
11995
11996 break;
11997 }
11998 }
11999 }
12000 }
12001 }
12002 else
12003 {
12004 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12005
12006 if (parser_status == PARSER_OK)
12007 {
12008 if (isSalted)
12009 {
12010 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12011 }
12012 else
12013 {
12014 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12015 }
12016 }
12017 }
12018
12019 if (found == NULL) continue;
12020
12021 if (!found->cracked) potfile_remove_cracks++;
12022
12023 found->cracked = 1;
12024
12025 if (found) break;
12026
12027 iter--;
12028 }
12029 }
12030
12031 myfree (line_buf_cpy);
12032
12033 myfree (line_buf);
12034
12035 fclose (fp);
12036 }
12037 }
12038
12039 if (esalt_size)
12040 {
12041 local_free (hash_buf.esalt);
12042 }
12043
12044 if (isSalted)
12045 {
12046 local_free (hash_buf.salt);
12047 }
12048
12049 local_free (hash_buf.digest);
12050 }
12051
12052 /**
12053 * Now generate all the buffers required for later
12054 */
12055
12056 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12057
12058 salt_t *salts_buf_new = NULL;
12059 void *esalts_buf_new = NULL;
12060
12061 if (isSalted)
12062 {
12063 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12064
12065 if (esalt_size)
12066 {
12067 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12068 }
12069 }
12070 else
12071 {
12072 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12073 }
12074
12075 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12076
12077 uint digests_cnt = hashes_cnt;
12078 uint digests_done = 0;
12079
12080 size_t size_digests = digests_cnt * dgst_size;
12081 size_t size_shown = digests_cnt * sizeof (uint);
12082
12083 uint *digests_shown = (uint *) mymalloc (size_shown);
12084 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12085
12086 uint salts_cnt = 0;
12087 uint salts_done = 0;
12088
12089 hashinfo_t **hash_info = NULL;
12090
12091 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12092 {
12093 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12094
12095 if (username && (remove || show))
12096 {
12097 uint user_pos;
12098
12099 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12100 {
12101 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12102
12103 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12104 }
12105 }
12106 }
12107
12108 uint *salts_shown = (uint *) mymalloc (size_shown);
12109
12110 salt_t *salt_buf;
12111
12112 {
12113 // copied from inner loop
12114
12115 salt_buf = &salts_buf_new[salts_cnt];
12116
12117 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12118
12119 if (esalt_size)
12120 {
12121 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12122 }
12123
12124 salt_buf->digests_cnt = 0;
12125 salt_buf->digests_done = 0;
12126 salt_buf->digests_offset = 0;
12127
12128 salts_cnt++;
12129 }
12130
12131 if (hashes_buf[0].cracked == 1)
12132 {
12133 digests_shown[0] = 1;
12134
12135 digests_done++;
12136
12137 salt_buf->digests_done++;
12138 }
12139
12140 salt_buf->digests_cnt++;
12141
12142 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12143
12144 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12145 {
12146 hash_info[0] = hashes_buf[0].hash_info;
12147 }
12148
12149 // copy from inner loop
12150
12151 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12152 {
12153 if (isSalted)
12154 {
12155 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12156 {
12157 salt_buf = &salts_buf_new[salts_cnt];
12158
12159 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12160
12161 if (esalt_size)
12162 {
12163 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12164 }
12165
12166 salt_buf->digests_cnt = 0;
12167 salt_buf->digests_done = 0;
12168 salt_buf->digests_offset = hashes_pos;
12169
12170 salts_cnt++;
12171 }
12172 }
12173
12174 if (hashes_buf[hashes_pos].cracked == 1)
12175 {
12176 digests_shown[hashes_pos] = 1;
12177
12178 digests_done++;
12179
12180 salt_buf->digests_done++;
12181 }
12182
12183 salt_buf->digests_cnt++;
12184
12185 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12186
12187 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12188 {
12189 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12190 }
12191 }
12192
12193 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12194 {
12195 salt_t *salt_buf = &salts_buf_new[salt_pos];
12196
12197 if (salt_buf->digests_done == salt_buf->digests_cnt)
12198 {
12199 salts_shown[salt_pos] = 1;
12200
12201 salts_done++;
12202 }
12203
12204 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12205 }
12206
12207 local_free (digests_buf);
12208 local_free (salts_buf);
12209 local_free (esalts_buf);
12210
12211 digests_buf = digests_buf_new;
12212 salts_buf = salts_buf_new;
12213 esalts_buf = esalts_buf_new;
12214
12215 local_free (hashes_buf);
12216
12217 /**
12218 * special modification not set from parser
12219 */
12220
12221 switch (hash_mode)
12222 {
12223 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12224 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12225 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12226 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12227 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12228 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12229 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12230 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12231 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12232 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12233 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12234 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12235 }
12236
12237 if (truecrypt_keyfiles)
12238 {
12239 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12240
12241 char *keyfiles = strdup (truecrypt_keyfiles);
12242
12243 char *keyfile = strtok (keyfiles, ",");
12244
12245 do
12246 {
12247 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12248
12249 } while ((keyfile = strtok (NULL, ",")) != NULL);
12250
12251 free (keyfiles);
12252 }
12253
12254 data.digests_cnt = digests_cnt;
12255 data.digests_done = digests_done;
12256 data.digests_buf = digests_buf;
12257 data.digests_shown = digests_shown;
12258 data.digests_shown_tmp = digests_shown_tmp;
12259
12260 data.salts_cnt = salts_cnt;
12261 data.salts_done = salts_done;
12262 data.salts_buf = salts_buf;
12263 data.salts_shown = salts_shown;
12264
12265 data.esalts_buf = esalts_buf;
12266 data.hash_info = hash_info;
12267
12268 /**
12269 * Automatic Optimizers
12270 */
12271
12272 if (salts_cnt == 1)
12273 opti_type |= OPTI_TYPE_SINGLE_SALT;
12274
12275 if (digests_cnt == 1)
12276 opti_type |= OPTI_TYPE_SINGLE_HASH;
12277
12278 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12279 opti_type |= OPTI_TYPE_NOT_ITERATED;
12280
12281 if (attack_mode == ATTACK_MODE_BF)
12282 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12283
12284 data.opti_type = opti_type;
12285
12286 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12287 {
12288 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12289 {
12290 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12291 {
12292 if (opts_type & OPTS_TYPE_ST_ADD80)
12293 {
12294 opts_type &= ~OPTS_TYPE_ST_ADD80;
12295 opts_type |= OPTS_TYPE_PT_ADD80;
12296 }
12297
12298 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12299 {
12300 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12301 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12302 }
12303
12304 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12305 {
12306 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12307 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12308 }
12309 }
12310 }
12311 }
12312
12313 /**
12314 * Some algorithm, like descrypt, can benefit from JIT compilation
12315 */
12316
12317 int force_jit_compilation = -1;
12318
12319 if (hash_mode == 8900)
12320 {
12321 force_jit_compilation = 8900;
12322 }
12323 else if (hash_mode == 9300)
12324 {
12325 force_jit_compilation = 8900;
12326 }
12327 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12328 {
12329 force_jit_compilation = 1500;
12330 }
12331
12332 /**
12333 * generate bitmap tables
12334 */
12335
12336 const uint bitmap_shift1 = 5;
12337 const uint bitmap_shift2 = 13;
12338
12339 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12340
12341 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12342 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12343 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12347 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12348 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12349
12350 uint bitmap_bits;
12351 uint bitmap_nums;
12352 uint bitmap_mask;
12353 uint bitmap_size;
12354
12355 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12356 {
12357 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12358
12359 bitmap_nums = 1 << bitmap_bits;
12360
12361 bitmap_mask = bitmap_nums - 1;
12362
12363 bitmap_size = bitmap_nums * sizeof (uint);
12364
12365 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12366
12367 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;
12368 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;
12369
12370 break;
12371 }
12372
12373 bitmap_nums = 1 << bitmap_bits;
12374
12375 bitmap_mask = bitmap_nums - 1;
12376
12377 bitmap_size = bitmap_nums * sizeof (uint);
12378
12379 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);
12380 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);
12381
12382 /**
12383 * prepare quick rule
12384 */
12385
12386 data.rule_buf_l = rule_buf_l;
12387 data.rule_buf_r = rule_buf_r;
12388
12389 int rule_len_l = (int) strlen (rule_buf_l);
12390 int rule_len_r = (int) strlen (rule_buf_r);
12391
12392 data.rule_len_l = rule_len_l;
12393 data.rule_len_r = rule_len_r;
12394
12395 /**
12396 * load rules
12397 */
12398
12399 uint *all_kernel_rules_cnt = NULL;
12400
12401 kernel_rule_t **all_kernel_rules_buf = NULL;
12402
12403 if (rp_files_cnt)
12404 {
12405 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12406
12407 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12408 }
12409
12410 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12411
12412 int rule_len = 0;
12413
12414 for (uint i = 0; i < rp_files_cnt; i++)
12415 {
12416 uint kernel_rules_avail = 0;
12417
12418 uint kernel_rules_cnt = 0;
12419
12420 kernel_rule_t *kernel_rules_buf = NULL;
12421
12422 char *rp_file = rp_files[i];
12423
12424 char in[BLOCK_SIZE] = { 0 };
12425 char out[BLOCK_SIZE] = { 0 };
12426
12427 FILE *fp = NULL;
12428
12429 uint rule_line = 0;
12430
12431 if ((fp = fopen (rp_file, "rb")) == NULL)
12432 {
12433 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12434
12435 return (-1);
12436 }
12437
12438 while (!feof (fp))
12439 {
12440 memset (rule_buf, 0, HCBUFSIZ);
12441
12442 rule_len = fgetl (fp, rule_buf);
12443
12444 rule_line++;
12445
12446 if (rule_len == 0) continue;
12447
12448 if (rule_buf[0] == '#') continue;
12449
12450 if (kernel_rules_avail == kernel_rules_cnt)
12451 {
12452 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12453
12454 kernel_rules_avail += INCR_RULES;
12455 }
12456
12457 memset (in, 0, BLOCK_SIZE);
12458 memset (out, 0, BLOCK_SIZE);
12459
12460 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12461
12462 if (result == -1)
12463 {
12464 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12465
12466 continue;
12467 }
12468
12469 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12470 {
12471 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12472
12473 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12474
12475 continue;
12476 }
12477
12478 /* its so slow
12479 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12480 {
12481 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12482
12483 continue;
12484 }
12485 */
12486
12487 kernel_rules_cnt++;
12488 }
12489
12490 fclose (fp);
12491
12492 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12493
12494 all_kernel_rules_buf[i] = kernel_rules_buf;
12495 }
12496
12497 /**
12498 * merge rules or automatic rule generator
12499 */
12500
12501 uint kernel_rules_cnt = 0;
12502
12503 kernel_rule_t *kernel_rules_buf = NULL;
12504
12505 if (attack_mode == ATTACK_MODE_STRAIGHT)
12506 {
12507 if (rp_files_cnt)
12508 {
12509 kernel_rules_cnt = 1;
12510
12511 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12512
12513 repeats[0] = kernel_rules_cnt;
12514
12515 for (uint i = 0; i < rp_files_cnt; i++)
12516 {
12517 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12518
12519 repeats[i + 1] = kernel_rules_cnt;
12520 }
12521
12522 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12523
12524 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12525
12526 for (uint i = 0; i < kernel_rules_cnt; i++)
12527 {
12528 uint out_pos = 0;
12529
12530 kernel_rule_t *out = &kernel_rules_buf[i];
12531
12532 for (uint j = 0; j < rp_files_cnt; j++)
12533 {
12534 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12535 uint in_pos;
12536
12537 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12538
12539 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12540 {
12541 if (out_pos == RULES_MAX - 1)
12542 {
12543 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12544
12545 break;
12546 }
12547
12548 out->cmds[out_pos] = in->cmds[in_pos];
12549 }
12550 }
12551 }
12552
12553 local_free (repeats);
12554 }
12555 else if (rp_gen)
12556 {
12557 uint kernel_rules_avail = 0;
12558
12559 while (kernel_rules_cnt < rp_gen)
12560 {
12561 if (kernel_rules_avail == kernel_rules_cnt)
12562 {
12563 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12564
12565 kernel_rules_avail += INCR_RULES;
12566 }
12567
12568 memset (rule_buf, 0, HCBUFSIZ);
12569
12570 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12571
12572 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12573
12574 kernel_rules_cnt++;
12575 }
12576 }
12577 }
12578
12579 myfree (rule_buf);
12580
12581 /**
12582 * generate NOP rules
12583 */
12584
12585 if (kernel_rules_cnt == 0)
12586 {
12587 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12588
12589 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12590
12591 kernel_rules_cnt++;
12592 }
12593
12594 data.kernel_rules_cnt = kernel_rules_cnt;
12595 data.kernel_rules_buf = kernel_rules_buf;
12596
12597 /**
12598 * OpenCL platforms: detect
12599 */
12600
12601 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12602 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12603
12604 cl_uint platforms_cnt = 0;
12605 cl_uint platform_devices_cnt = 0;
12606
12607 if (keyspace == 0)
12608 {
12609 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12610
12611 if (platforms_cnt == 0)
12612 {
12613 log_info ("");
12614 log_info ("ATTENTION! No OpenCL compatible platform found");
12615 log_info ("");
12616 log_info ("You're probably missing the OpenCL runtime installation");
12617 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12618 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12619 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12620 log_info ("");
12621
12622 return (-1);
12623 }
12624
12625 if (opencl_platforms_filter != (uint) -1)
12626 {
12627 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12628
12629 if (opencl_platforms_filter > platform_cnt_mask)
12630 {
12631 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12632
12633 return (-1);
12634 }
12635 }
12636 }
12637
12638 /**
12639 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12640 */
12641
12642 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12643 {
12644 cl_platform_id platform = platforms[platform_id];
12645
12646 char platform_vendor[INFOSZ] = { 0 };
12647
12648 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12649
12650 #ifdef HAVE_HWMON
12651 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12652 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12653 {
12654 // make sure that we do not directly control the fan for NVidia
12655
12656 gpu_temp_retain = 0;
12657
12658 data.gpu_temp_retain = gpu_temp_retain;
12659 }
12660 #endif // HAVE_NVML || HAVE_NVAPI
12661 #endif
12662 }
12663
12664 /**
12665 * OpenCL device types:
12666 * 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.
12667 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12668 */
12669
12670 if (opencl_device_types == NULL)
12671 {
12672 cl_device_type device_types_all = 0;
12673
12674 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12675 {
12676 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12677
12678 cl_platform_id platform = platforms[platform_id];
12679
12680 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12681
12682 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12683 {
12684 cl_device_id device = platform_devices[platform_devices_id];
12685
12686 cl_device_type device_type;
12687
12688 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12689
12690 device_types_all |= device_type;
12691 }
12692 }
12693
12694 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12695 {
12696 device_types_filter |= CL_DEVICE_TYPE_CPU;
12697 }
12698 }
12699
12700 /**
12701 * OpenCL devices: simply push all devices from all platforms into the same device array
12702 */
12703
12704 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12705
12706 data.devices_param = devices_param;
12707
12708 uint devices_cnt = 0;
12709
12710 uint devices_active = 0;
12711
12712 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12713 {
12714 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12715
12716 cl_platform_id platform = platforms[platform_id];
12717
12718 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12719
12720 char platform_vendor[INFOSZ] = { 0 };
12721
12722 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12723
12724 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12725 // this causes trouble with vendor id based macros
12726 // we'll assign generic to those without special optimization available
12727
12728 cl_uint vendor_id = 0;
12729
12730 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12731 {
12732 vendor_id = VENDOR_ID_AMD;
12733 }
12734 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12735 {
12736 vendor_id = VENDOR_ID_APPLE;
12737 }
12738 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12739 {
12740 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12741 }
12742 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12743 {
12744 vendor_id = VENDOR_ID_INTEL_SDK;
12745 }
12746 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12747 {
12748 vendor_id = VENDOR_ID_MESA;
12749 }
12750 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12751 {
12752 vendor_id = VENDOR_ID_NV;
12753 }
12754 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12755 {
12756 vendor_id = VENDOR_ID_POCL;
12757 }
12758 else
12759 {
12760 vendor_id = VENDOR_ID_GENERIC;
12761 }
12762
12763 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12764 {
12765 size_t param_value_size = 0;
12766
12767 const uint device_id = devices_cnt;
12768
12769 hc_device_param_t *device_param = &data.devices_param[device_id];
12770
12771 device_param->vendor_id = vendor_id;
12772
12773 device_param->device = platform_devices[platform_devices_id];
12774
12775 device_param->device_id = device_id;
12776
12777 device_param->platform_devices_id = platform_devices_id;
12778
12779 // device_type
12780
12781 cl_device_type device_type;
12782
12783 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12784
12785 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12786
12787 device_param->device_type = device_type;
12788
12789 // device_name
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12792
12793 char *device_name = (char *) mymalloc (param_value_size);
12794
12795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12796
12797 device_param->device_name = device_name;
12798
12799 // tuning db
12800
12801 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12802
12803 // device_version
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12806
12807 char *device_version = (char *) mymalloc (param_value_size);
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12810
12811 device_param->device_version = device_version;
12812
12813 // device_opencl_version
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12816
12817 char *device_opencl_version = (char *) mymalloc (param_value_size);
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12820
12821 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12822
12823 myfree (device_opencl_version);
12824
12825 // vector_width
12826
12827 cl_uint vector_width;
12828
12829 if (opencl_vector_width_chgd == 0)
12830 {
12831 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12832 {
12833 if (opti_type & OPTI_TYPE_USES_BITS_64)
12834 {
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12836 }
12837 else
12838 {
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12840 }
12841 }
12842 else
12843 {
12844 vector_width = (cl_uint) tuningdb_entry->vector_width;
12845 }
12846 }
12847 else
12848 {
12849 vector_width = opencl_vector_width;
12850 }
12851
12852 if (vector_width > 16) vector_width = 16;
12853
12854 device_param->vector_width = vector_width;
12855
12856 // max_compute_units
12857
12858 cl_uint device_processors;
12859
12860 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12861
12862 device_param->device_processors = device_processors;
12863
12864 // device_maxmem_alloc
12865 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12866
12867 cl_ulong device_maxmem_alloc;
12868
12869 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12870
12871 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12872
12873 // device_global_mem
12874
12875 cl_ulong device_global_mem;
12876
12877 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12878
12879 device_param->device_global_mem = device_global_mem;
12880
12881 // max_work_group_size
12882
12883 size_t device_maxworkgroup_size;
12884
12885 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12886
12887 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12888
12889 // max_clock_frequency
12890
12891 cl_uint device_maxclock_frequency;
12892
12893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12894
12895 device_param->device_maxclock_frequency = device_maxclock_frequency;
12896
12897 // device_endian_little
12898
12899 cl_bool device_endian_little;
12900
12901 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12902
12903 if (device_endian_little == CL_FALSE)
12904 {
12905 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12906
12907 device_param->skipped = 1;
12908 }
12909
12910 // device_available
12911
12912 cl_bool device_available;
12913
12914 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12915
12916 if (device_available == CL_FALSE)
12917 {
12918 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12919
12920 device_param->skipped = 1;
12921 }
12922
12923 // device_compiler_available
12924
12925 cl_bool device_compiler_available;
12926
12927 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12928
12929 if (device_compiler_available == CL_FALSE)
12930 {
12931 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12932
12933 device_param->skipped = 1;
12934 }
12935
12936 // device_execution_capabilities
12937
12938 cl_device_exec_capabilities device_execution_capabilities;
12939
12940 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12941
12942 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12943 {
12944 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12945
12946 device_param->skipped = 1;
12947 }
12948
12949 // device_extensions
12950
12951 size_t device_extensions_size;
12952
12953 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12954
12955 char *device_extensions = mymalloc (device_extensions_size + 1);
12956
12957 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12958
12959 if (strstr (device_extensions, "base_atomics") == 0)
12960 {
12961 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12962
12963 device_param->skipped = 1;
12964 }
12965
12966 if (strstr (device_extensions, "byte_addressable_store") == 0)
12967 {
12968 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12969
12970 device_param->skipped = 1;
12971 }
12972
12973 myfree (device_extensions);
12974
12975 // device_local_mem_size
12976
12977 cl_ulong device_local_mem_size;
12978
12979 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12980
12981 if (device_local_mem_size < 32768)
12982 {
12983 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12984
12985 device_param->skipped = 1;
12986 }
12987
12988
12989 // skipped
12990
12991 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12992 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12993
12994 // driver_version
12995
12996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12997
12998 char *driver_version = (char *) mymalloc (param_value_size);
12999
13000 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13001
13002 device_param->driver_version = driver_version;
13003
13004 // device_name_chksum
13005
13006 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13007
13008 #if __x86_64__
13009 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);
13010 #else
13011 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);
13012 #endif
13013
13014 uint device_name_digest[4] = { 0 };
13015
13016 md5_64 ((uint *) device_name_chksum, device_name_digest);
13017
13018 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13019
13020 device_param->device_name_chksum = device_name_chksum;
13021
13022 // device_processor_cores
13023
13024 if (device_type & CL_DEVICE_TYPE_CPU)
13025 {
13026 cl_uint device_processor_cores = 1;
13027
13028 device_param->device_processor_cores = device_processor_cores;
13029 }
13030
13031 if (device_type & CL_DEVICE_TYPE_GPU)
13032 {
13033 if (vendor_id == VENDOR_ID_AMD)
13034 {
13035 cl_uint device_processor_cores = 0;
13036
13037 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13038
13039 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13040
13041 device_param->device_processor_cores = device_processor_cores;
13042 }
13043 else if (vendor_id == VENDOR_ID_NV)
13044 {
13045 cl_uint kernel_exec_timeout = 0;
13046
13047 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13048
13049 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13050
13051 device_param->kernel_exec_timeout = kernel_exec_timeout;
13052
13053 cl_uint device_processor_cores = 0;
13054
13055 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13056
13057 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13058
13059 device_param->device_processor_cores = device_processor_cores;
13060
13061 cl_uint sm_minor = 0;
13062 cl_uint sm_major = 0;
13063
13064 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13065 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13066
13067 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13068 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13069
13070 device_param->sm_minor = sm_minor;
13071 device_param->sm_major = sm_major;
13072 }
13073 else
13074 {
13075 cl_uint device_processor_cores = 1;
13076
13077 device_param->device_processor_cores = device_processor_cores;
13078 }
13079 }
13080
13081 // display results
13082
13083 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13084 {
13085 if (status_automat == 0)
13086 {
13087 if (device_param->skipped == 0)
13088 {
13089 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13090 device_id + 1,
13091 device_name,
13092 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13093 (unsigned int) (device_global_mem / 1024 / 1024),
13094 (unsigned int) (device_maxclock_frequency),
13095 (unsigned int) device_processors);
13096 }
13097 else
13098 {
13099 log_info ("Device #%u: %s, skipped",
13100 device_id + 1,
13101 device_name);
13102 }
13103 }
13104 }
13105
13106 // common driver check
13107
13108 if (device_param->skipped == 0)
13109 {
13110 if (device_type & CL_DEVICE_TYPE_GPU)
13111 {
13112 if (vendor_id == VENDOR_ID_AMD)
13113 {
13114 int catalyst_check = (force == 1) ? 0 : 1;
13115
13116 int catalyst_warn = 0;
13117
13118 int catalyst_broken = 0;
13119
13120 if (catalyst_check == 1)
13121 {
13122 catalyst_warn = 1;
13123
13124 // v14.9 and higher
13125 if (atoi (device_param->driver_version) >= 1573)
13126 {
13127 catalyst_warn = 0;
13128 }
13129
13130 catalyst_check = 0;
13131 }
13132
13133 if (catalyst_broken == 1)
13134 {
13135 log_info ("");
13136 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13137 log_info ("It will pass over cracked hashes and does not report them as cracked");
13138 log_info ("You are STRONGLY encouraged not to use it");
13139 log_info ("You can use --force to override this but do not post error reports if you do so");
13140 log_info ("");
13141
13142 return (-1);
13143 }
13144
13145 if (catalyst_warn == 1)
13146 {
13147 log_info ("");
13148 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13149 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13150 log_info ("See hashcat's homepage for official supported catalyst drivers");
13151 #ifdef _WIN
13152 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13153 #endif
13154 log_info ("You can use --force to override this but do not post error reports if you do so");
13155 log_info ("");
13156
13157 return (-1);
13158 }
13159 }
13160 else if (vendor_id == VENDOR_ID_NV)
13161 {
13162 if (device_param->kernel_exec_timeout != 0)
13163 {
13164 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);
13165 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13166 }
13167 }
13168 }
13169
13170 if (device_type & CL_DEVICE_TYPE_CPU)
13171 {
13172 if (vendor_id == VENDOR_ID_AMD)
13173 {
13174 if (force == 0)
13175 {
13176 log_info ("");
13177 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13178 log_info ("You are STRONGLY encouraged not to use it");
13179 log_info ("You can use --force to override this but do not post error reports if you do so");
13180 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13181 log_info ("");
13182
13183 return (-1);
13184 }
13185 }
13186 }
13187
13188 /**
13189 * kernel accel and loops tuning db adjustment
13190 */
13191
13192 device_param->kernel_accel_min = 1;
13193 device_param->kernel_accel_max = 1024;
13194
13195 device_param->kernel_loops_min = 1;
13196 device_param->kernel_loops_max = 1024;
13197
13198 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13199
13200 if (tuningdb_entry)
13201 {
13202 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13203 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13204
13205 if (_kernel_accel)
13206 {
13207 device_param->kernel_accel_min = _kernel_accel;
13208 device_param->kernel_accel_max = _kernel_accel;
13209 }
13210
13211 if (_kernel_loops)
13212 {
13213 if (workload_profile == 1)
13214 {
13215 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13216 }
13217 else if (workload_profile == 2)
13218 {
13219 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13220 }
13221
13222 device_param->kernel_loops_min = _kernel_loops;
13223 device_param->kernel_loops_max = _kernel_loops;
13224 }
13225 }
13226
13227 // commandline parameters overwrite tuningdb entries
13228
13229 if (kernel_accel)
13230 {
13231 device_param->kernel_accel_min = kernel_accel;
13232 device_param->kernel_accel_max = kernel_accel;
13233 }
13234
13235 if (kernel_loops)
13236 {
13237 device_param->kernel_loops_min = kernel_loops;
13238 device_param->kernel_loops_max = kernel_loops;
13239 }
13240
13241 /**
13242 * activate device
13243 */
13244
13245 devices_active++;
13246 }
13247
13248 // next please
13249
13250 devices_cnt++;
13251 }
13252 }
13253
13254 if (keyspace == 0 && devices_active == 0)
13255 {
13256 log_error ("ERROR: No devices found/left");
13257
13258 return (-1);
13259 }
13260
13261 // 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)
13262
13263 if (devices_filter != (uint) -1)
13264 {
13265 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13266
13267 if (devices_filter > devices_cnt_mask)
13268 {
13269 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13270
13271 return (-1);
13272 }
13273 }
13274
13275 data.devices_cnt = devices_cnt;
13276
13277 data.devices_active = devices_active;
13278
13279 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13280 {
13281 if (status_automat == 0)
13282 {
13283 log_info ("");
13284 }
13285 }
13286
13287 /**
13288 * HM devices: init
13289 */
13290
13291 #ifdef HAVE_HWMON
13292 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13293 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13294 #endif
13295
13296 #ifdef HAVE_ADL
13297 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13298 #endif
13299
13300 if (gpu_temp_disable == 0)
13301 {
13302 #if defined(WIN) && defined(HAVE_NVAPI)
13303 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13304
13305 if (nvapi_init (nvapi) == 0)
13306 data.hm_nv = nvapi;
13307
13308 if (data.hm_nv)
13309 {
13310 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13311 {
13312 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13313
13314 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13315
13316 int tmp_out = 0;
13317
13318 for (int i = 0; i < tmp_in; i++)
13319 {
13320 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13321 }
13322
13323 for (int i = 0; i < tmp_out; i++)
13324 {
13325 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13326
13327 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13328
13329 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;
13330 }
13331 }
13332 }
13333 #endif // WIN && HAVE_NVAPI
13334
13335 #if defined(LINUX) && defined(HAVE_NVML)
13336 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13337
13338 if (nvml_init (nvml) == 0)
13339 data.hm_nv = nvml;
13340
13341 if (data.hm_nv)
13342 {
13343 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13344 {
13345 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13346
13347 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13348
13349 int tmp_out = 0;
13350
13351 for (int i = 0; i < tmp_in; i++)
13352 {
13353 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13354 }
13355
13356 for (int i = 0; i < tmp_out; i++)
13357 {
13358 unsigned int speed;
13359
13360 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;
13361 }
13362 }
13363 }
13364 #endif // LINUX && HAVE_NVML
13365
13366 data.hm_amd = NULL;
13367
13368 #ifdef HAVE_ADL
13369 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13370
13371 if (adl_init (adl) == 0)
13372 data.hm_amd = adl;
13373
13374 if (data.hm_amd)
13375 {
13376 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13377 {
13378 // total number of adapters
13379
13380 int hm_adapters_num;
13381
13382 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13383
13384 // adapter info
13385
13386 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13387
13388 if (lpAdapterInfo == NULL) return (-1);
13389
13390 // get a list (of ids of) valid/usable adapters
13391
13392 int num_adl_adapters = 0;
13393
13394 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13395
13396 if (num_adl_adapters > 0)
13397 {
13398 hc_thread_mutex_lock (mux_adl);
13399
13400 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13401
13402 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13403
13404 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13405 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13406
13407 hc_thread_mutex_unlock (mux_adl);
13408 }
13409
13410 myfree (valid_adl_device_list);
13411 myfree (lpAdapterInfo);
13412 }
13413 }
13414 #endif // HAVE_ADL
13415
13416 if (data.hm_amd == NULL && data.hm_nv == NULL)
13417 {
13418 gpu_temp_disable = 1;
13419 }
13420 }
13421
13422 /**
13423 * OpenCL devices: allocate buffer for device specific information
13424 */
13425
13426 #ifdef HAVE_HWMON
13427 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13428
13429 #ifdef HAVE_ADL
13430 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13431
13432 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13433 #endif // ADL
13434 #endif
13435
13436 /**
13437 * enable custom signal handler(s)
13438 */
13439
13440 if (benchmark == 0)
13441 {
13442 hc_signal (sigHandler_default);
13443 }
13444 else
13445 {
13446 hc_signal (sigHandler_benchmark);
13447 }
13448
13449 /**
13450 * User-defined GPU temp handling
13451 */
13452
13453 #ifdef HAVE_HWMON
13454 if (gpu_temp_disable == 1)
13455 {
13456 gpu_temp_abort = 0;
13457 gpu_temp_retain = 0;
13458 }
13459
13460 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13461 {
13462 if (gpu_temp_abort < gpu_temp_retain)
13463 {
13464 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13465
13466 return (-1);
13467 }
13468 }
13469
13470 data.gpu_temp_disable = gpu_temp_disable;
13471 data.gpu_temp_abort = gpu_temp_abort;
13472 data.gpu_temp_retain = gpu_temp_retain;
13473 #endif
13474
13475 /**
13476 * inform the user
13477 */
13478
13479 if (data.quiet == 0)
13480 {
13481 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13482
13483 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);
13484
13485 if (attack_mode == ATTACK_MODE_STRAIGHT)
13486 {
13487 log_info ("Rules: %u", kernel_rules_cnt);
13488 }
13489
13490 if (opti_type)
13491 {
13492 log_info ("Applicable Optimizers:");
13493
13494 for (uint i = 0; i < 32; i++)
13495 {
13496 const uint opti_bit = 1u << i;
13497
13498 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13499 }
13500 }
13501
13502 /**
13503 * Watchdog and Temperature balance
13504 */
13505
13506 #ifdef HAVE_HWMON
13507 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13508 {
13509 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13510 }
13511
13512 if (gpu_temp_abort == 0)
13513 {
13514 log_info ("Watchdog: Temperature abort trigger disabled");
13515 }
13516 else
13517 {
13518 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13519 }
13520
13521 if (gpu_temp_retain == 0)
13522 {
13523 log_info ("Watchdog: Temperature retain trigger disabled");
13524 }
13525 else
13526 {
13527 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13528 }
13529
13530 if (data.quiet == 0) log_info ("");
13531 #endif
13532 }
13533
13534 /**
13535 * HM devices: copy
13536 */
13537
13538 if (gpu_temp_disable == 0)
13539 {
13540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13541 {
13542 hc_device_param_t *device_param = &data.devices_param[device_id];
13543
13544 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13545
13546 if (device_param->skipped) continue;
13547
13548 const uint platform_devices_id = device_param->platform_devices_id;
13549
13550 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13551 if (device_param->vendor_id == VENDOR_ID_NV)
13552 {
13553 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13554 }
13555 #endif
13556
13557 #ifdef HAVE_ADL
13558 if (device_param->vendor_id == VENDOR_ID_AMD)
13559 {
13560 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13561 }
13562 #endif
13563 }
13564 }
13565
13566 /*
13567 * Temporary fix:
13568 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13569 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13570 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13571 * Driver / ADL bug?
13572 */
13573
13574 #ifdef HAVE_ADL
13575 if (powertune_enable == 1)
13576 {
13577 hc_thread_mutex_lock (mux_adl);
13578
13579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13580 {
13581 hc_device_param_t *device_param = &data.devices_param[device_id];
13582
13583 if (device_param->skipped) continue;
13584
13585 if (data.hm_device[device_id].od_version == 6)
13586 {
13587 // set powertune value only
13588
13589 int powertune_supported = 0;
13590
13591 int ADL_rc = 0;
13592
13593 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13594 {
13595 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13596
13597 return (-1);
13598 }
13599
13600 if (powertune_supported != 0)
13601 {
13602 // powertune set
13603 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13604
13605 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13606 {
13607 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13608
13609 return (-1);
13610 }
13611
13612 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13613 {
13614 log_error ("ERROR: Failed to set new ADL PowerControl values");
13615
13616 return (-1);
13617 }
13618 }
13619 }
13620 }
13621
13622 hc_thread_mutex_unlock (mux_adl);
13623 }
13624 #endif // HAVE_ADK
13625 #endif // HAVE_HWMON
13626
13627 #ifdef DEBUG
13628 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13629 #endif
13630
13631 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13632
13633 uint kernel_power_all = 0;
13634
13635 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13636 {
13637 /**
13638 * host buffer
13639 */
13640
13641 hc_device_param_t *device_param = &data.devices_param[device_id];
13642
13643 if (device_param->skipped) continue;
13644
13645 /**
13646 * device properties
13647 */
13648
13649 const char *device_name_chksum = device_param->device_name_chksum;
13650 const u32 device_processors = device_param->device_processors;
13651 const u32 device_processor_cores = device_param->device_processor_cores;
13652
13653 /**
13654 * create context for each device
13655 */
13656
13657 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13658
13659 /**
13660 * create command-queue
13661 */
13662
13663 // not supported with NV
13664 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13665
13666 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13667
13668 /**
13669 * kernel threads: some algorithms need a fixed kernel-threads count
13670 * because of shared memory usage or bitslice
13671 * there needs to be some upper limit, otherwise there's too much overhead
13672 */
13673
13674 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13675
13676 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13677 {
13678 kernel_threads = KERNEL_THREADS_MAX_CPU;
13679 }
13680
13681 if (hash_mode == 1500) kernel_threads = 64; // DES
13682 if (hash_mode == 3000) kernel_threads = 64; // DES
13683 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13684 if (hash_mode == 7500) kernel_threads = 64; // RC4
13685 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13686 if (hash_mode == 9700) kernel_threads = 64; // RC4
13687 if (hash_mode == 9710) kernel_threads = 64; // RC4
13688 if (hash_mode == 9800) kernel_threads = 64; // RC4
13689 if (hash_mode == 9810) kernel_threads = 64; // RC4
13690 if (hash_mode == 10400) kernel_threads = 64; // RC4
13691 if (hash_mode == 10410) kernel_threads = 64; // RC4
13692 if (hash_mode == 10500) kernel_threads = 64; // RC4
13693 if (hash_mode == 13100) kernel_threads = 64; // RC4
13694
13695 /**
13696 * create input buffers on device : calculate size of fixed memory buffers
13697 */
13698
13699 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13700 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13701
13702 device_param->size_root_css = size_root_css;
13703 device_param->size_markov_css = size_markov_css;
13704
13705 size_t size_results = kernel_threads * sizeof (uint);
13706
13707 device_param->size_results = size_results;
13708
13709 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13710 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13711
13712 size_t size_plains = digests_cnt * sizeof (plain_t);
13713 size_t size_salts = salts_cnt * sizeof (salt_t);
13714 size_t size_esalts = salts_cnt * esalt_size;
13715
13716 device_param->size_plains = size_plains;
13717 device_param->size_digests = size_digests;
13718 device_param->size_shown = size_shown;
13719 device_param->size_salts = size_salts;
13720
13721 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13722 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13723 size_t size_tm = 32 * sizeof (bs_word_t);
13724
13725 // scryptV stuff
13726
13727 size_t size_scryptV = 1;
13728
13729 if ((hash_mode == 8900) || (hash_mode == 9300))
13730 {
13731 uint tmto_start = 0;
13732 uint tmto_stop = 10;
13733
13734 if (scrypt_tmto)
13735 {
13736 tmto_start = scrypt_tmto;
13737 }
13738 else
13739 {
13740 // in case the user did not specify the tmto manually
13741 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13742 // but set the lower end only in case the user has a device with too less memory
13743
13744 if (hash_mode == 8900)
13745 {
13746 if (device_param->vendor_id == VENDOR_ID_AMD)
13747 {
13748 tmto_start = 1;
13749 }
13750 else if (device_param->vendor_id == VENDOR_ID_NV)
13751 {
13752 tmto_start = 2;
13753 }
13754 }
13755 else if (hash_mode == 9300)
13756 {
13757 if (device_param->vendor_id == VENDOR_ID_AMD)
13758 {
13759 tmto_start = 2;
13760 }
13761 else if (device_param->vendor_id == VENDOR_ID_NV)
13762 {
13763 tmto_start = 2;
13764 }
13765 }
13766 }
13767
13768 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13769 {
13770 // TODO: in theory the following calculation needs to be done per salt, not global
13771 // we assume all hashes have the same scrypt settings
13772
13773 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13774
13775 size_scryptV /= 1 << tmto;
13776
13777 size_scryptV *= device_processors * device_processor_cores;
13778
13779 if (size_scryptV > device_param->device_maxmem_alloc)
13780 {
13781 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13782
13783 continue;
13784 }
13785
13786 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13787 {
13788 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13789 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13790 }
13791
13792 break;
13793 }
13794
13795 if (data.salts_buf[0].scrypt_phy == 0)
13796 {
13797 log_error ("ERROR: can't allocate enough device memory");
13798
13799 return -1;
13800 }
13801
13802 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13803 }
13804
13805 /**
13806 * some algorithms need a fixed kernel-loops count
13807 */
13808
13809 if (hash_mode == 1500)
13810 {
13811 const u32 kernel_loops_fixed = 1024;
13812
13813 device_param->kernel_loops_min = kernel_loops_fixed;
13814 device_param->kernel_loops_max = kernel_loops_fixed;
13815 }
13816
13817 if (hash_mode == 3000)
13818 {
13819 const u32 kernel_loops_fixed = 1024;
13820
13821 device_param->kernel_loops_min = kernel_loops_fixed;
13822 device_param->kernel_loops_max = kernel_loops_fixed;
13823 }
13824
13825 if (hash_mode == 8900)
13826 {
13827 const u32 kernel_loops_fixed = 1;
13828
13829 device_param->kernel_loops_min = kernel_loops_fixed;
13830 device_param->kernel_loops_max = kernel_loops_fixed;
13831 }
13832
13833 if (hash_mode == 9300)
13834 {
13835 const u32 kernel_loops_fixed = 1;
13836
13837 device_param->kernel_loops_min = kernel_loops_fixed;
13838 device_param->kernel_loops_max = kernel_loops_fixed;
13839 }
13840
13841 if (hash_mode == 12500)
13842 {
13843 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13844
13845 device_param->kernel_loops_min = kernel_loops_fixed;
13846 device_param->kernel_loops_max = kernel_loops_fixed;
13847 }
13848
13849 /**
13850 * some algorithms have a maximum kernel-loops count
13851 */
13852
13853 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13854 {
13855 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13856 {
13857 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13858 }
13859 }
13860
13861 /**
13862 * some algorithms need a special kernel-accel
13863 */
13864
13865 if (hash_mode == 8900)
13866 {
13867 device_param->kernel_accel_min = 1;
13868 device_param->kernel_accel_max = 64;
13869 }
13870
13871 if (hash_mode == 9300)
13872 {
13873 device_param->kernel_accel_min = 1;
13874 device_param->kernel_accel_max = 64;
13875 }
13876
13877 u32 kernel_accel_min = device_param->kernel_accel_min;
13878 u32 kernel_accel_max = device_param->kernel_accel_max;
13879
13880 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13881
13882 size_t size_pws = 4;
13883 size_t size_tmps = 4;
13884 size_t size_hooks = 4;
13885
13886 while (kernel_accel_max >= kernel_accel_min)
13887 {
13888 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13889
13890 // size_pws
13891
13892 size_pws = kernel_power_max * sizeof (pw_t);
13893
13894 // size_tmps
13895
13896 switch (hash_mode)
13897 {
13898 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13899 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13900 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13901 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13902 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13903 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13904 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13905 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13906 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13907 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13908 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13909 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13910 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13911 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13912 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13913 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13914 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13915 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13916 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13917 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13918 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13919 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13920 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13921 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13922 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13923 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13924 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13925 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13926 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13927 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13928 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13929 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13930 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13931 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13932 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13933 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13934 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13935 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13936 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13937 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13938 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13939 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13940 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13941 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13942 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13943 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13944 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13945 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13946 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13947 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13948 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13949 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13950 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13951 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13952 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13953 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13954 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13955 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13956 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13957 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13958 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13959 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13960 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13961 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13962 };
13963
13964 // size_hooks
13965
13966 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13967 {
13968 // none yet
13969 }
13970
13971 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13972 // if not, decrease amplifier and try again
13973
13974 int skip = 0;
13975
13976 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13977 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13978 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13979
13980 if (( bitmap_size
13981 + bitmap_size
13982 + bitmap_size
13983 + bitmap_size
13984 + bitmap_size
13985 + bitmap_size
13986 + bitmap_size
13987 + bitmap_size
13988 + size_bfs
13989 + size_combs
13990 + size_digests
13991 + size_esalts
13992 + size_hooks
13993 + size_markov_css
13994 + size_plains
13995 + size_pws
13996 + size_pws // not a bug
13997 + size_results
13998 + size_root_css
13999 + size_rules
14000 + size_rules_c
14001 + size_salts
14002 + size_scryptV
14003 + size_shown
14004 + size_tm
14005 + size_tmps) > device_param->device_global_mem) skip = 1;
14006
14007 if (skip == 1)
14008 {
14009 kernel_accel_max--;
14010
14011 continue;
14012 }
14013
14014 break;
14015 }
14016
14017 /*
14018 if (kernel_accel_max == 0)
14019 {
14020 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14021
14022 return -1;
14023 }
14024 */
14025
14026 device_param->kernel_accel_min = kernel_accel_min;
14027 device_param->kernel_accel_max = kernel_accel_max;
14028
14029 /*
14030 if (kernel_accel_max < kernel_accel)
14031 {
14032 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14033
14034 device_param->kernel_accel = kernel_accel_max;
14035 }
14036 */
14037
14038 device_param->size_bfs = size_bfs;
14039 device_param->size_combs = size_combs;
14040 device_param->size_rules = size_rules;
14041 device_param->size_rules_c = size_rules_c;
14042 device_param->size_pws = size_pws;
14043 device_param->size_tmps = size_tmps;
14044 device_param->size_hooks = size_hooks;
14045
14046 // do not confuse kernel_accel_max with kernel_accel here
14047
14048 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14049
14050 device_param->kernel_threads = kernel_threads;
14051 device_param->kernel_power_user = kernel_power;
14052
14053 kernel_power_all += kernel_power;
14054
14055 /**
14056 * default building options
14057 */
14058
14059 char build_opts[1024] = { 0 };
14060
14061 // we don't have sm_* on vendors not NV but it doesn't matter
14062
14063 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);
14064
14065 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14066 {
14067 // we do vectorizing much better than the auto-vectorizer
14068
14069 char build_opts_new[1024] = { 0 };
14070
14071 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14072
14073 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14074 }
14075
14076 #ifdef DEBUG
14077 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14078 #endif
14079
14080 /**
14081 * main kernel
14082 */
14083
14084 {
14085 /**
14086 * kernel source filename
14087 */
14088
14089 char source_file[256] = { 0 };
14090
14091 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14092
14093 struct stat sst;
14094
14095 if (stat (source_file, &sst) == -1)
14096 {
14097 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14098
14099 return -1;
14100 }
14101
14102 /**
14103 * kernel cached filename
14104 */
14105
14106 char cached_file[256] = { 0 };
14107
14108 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14109
14110 int cached = 1;
14111
14112 struct stat cst;
14113
14114 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14115 {
14116 cached = 0;
14117 }
14118
14119 /**
14120 * kernel compile or load
14121 */
14122
14123 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14124
14125 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14126
14127 if (force_jit_compilation == -1)
14128 {
14129 if (cached == 0)
14130 {
14131 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14132
14133 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14134
14135 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14136
14137 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14138
14139 #ifdef DEBUG
14140 size_t build_log_size = 0;
14141
14142 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14143
14144 if (build_log_size > 1)
14145 {
14146 char *build_log = (char *) malloc (build_log_size + 1);
14147
14148 memset (build_log, 0, build_log_size + 1);
14149
14150 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14151
14152 puts (build_log);
14153
14154 free (build_log);
14155 }
14156 #endif
14157
14158 if (rc != 0)
14159 {
14160 device_param->skipped = true;
14161
14162 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14163
14164 continue;
14165 }
14166
14167 size_t binary_size;
14168
14169 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14170
14171 u8 *binary = (u8 *) mymalloc (binary_size);
14172
14173 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14174
14175 writeProgramBin (cached_file, binary, binary_size);
14176
14177 local_free (binary);
14178 }
14179 else
14180 {
14181 #ifdef DEBUG
14182 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14183 #endif
14184
14185 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14186
14187 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14188
14189 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14190 }
14191 }
14192 else
14193 {
14194 #ifdef DEBUG
14195 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14196 #endif
14197
14198 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14199
14200 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14201
14202 char build_opts_update[1024] = { 0 };
14203
14204 if (force_jit_compilation == 1500)
14205 {
14206 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14207 }
14208 else if (force_jit_compilation == 8900)
14209 {
14210 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);
14211 }
14212 else
14213 {
14214 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14215 }
14216
14217 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14218
14219 #ifdef DEBUG
14220 size_t build_log_size = 0;
14221
14222 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14223
14224 if (build_log_size > 1)
14225 {
14226 char *build_log = (char *) malloc (build_log_size + 1);
14227
14228 memset (build_log, 0, build_log_size + 1);
14229
14230 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14231
14232 puts (build_log);
14233
14234 free (build_log);
14235 }
14236 #endif
14237
14238 if (rc != 0)
14239 {
14240 device_param->skipped = true;
14241
14242 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14243 }
14244 }
14245
14246 local_free (kernel_lengths);
14247 local_free (kernel_sources[0]);
14248 local_free (kernel_sources);
14249 }
14250
14251 /**
14252 * word generator kernel
14253 */
14254
14255 if (attack_mode != ATTACK_MODE_STRAIGHT)
14256 {
14257 /**
14258 * kernel mp source filename
14259 */
14260
14261 char source_file[256] = { 0 };
14262
14263 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14264
14265 struct stat sst;
14266
14267 if (stat (source_file, &sst) == -1)
14268 {
14269 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14270
14271 return -1;
14272 }
14273
14274 /**
14275 * kernel mp cached filename
14276 */
14277
14278 char cached_file[256] = { 0 };
14279
14280 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14281
14282 int cached = 1;
14283
14284 struct stat cst;
14285
14286 if (stat (cached_file, &cst) == -1)
14287 {
14288 cached = 0;
14289 }
14290
14291 /**
14292 * kernel compile or load
14293 */
14294
14295 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14296
14297 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14298
14299 if (cached == 0)
14300 {
14301 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14302 if (quiet == 0) log_info ("");
14303
14304 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14305
14306 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14307
14308 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14309
14310 if (rc != 0)
14311 {
14312 device_param->skipped = true;
14313
14314 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14315
14316 continue;
14317 }
14318
14319 size_t binary_size;
14320
14321 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14322
14323 u8 *binary = (u8 *) mymalloc (binary_size);
14324
14325 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14326
14327 writeProgramBin (cached_file, binary, binary_size);
14328
14329 local_free (binary);
14330 }
14331 else
14332 {
14333 #ifdef DEBUG
14334 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14335 #endif
14336
14337 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14338
14339 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14340
14341 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14342 }
14343
14344 local_free (kernel_lengths);
14345 local_free (kernel_sources[0]);
14346 local_free (kernel_sources);
14347 }
14348
14349 /**
14350 * amplifier kernel
14351 */
14352
14353 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14354 {
14355
14356 }
14357 else
14358 {
14359 /**
14360 * kernel amp source filename
14361 */
14362
14363 char source_file[256] = { 0 };
14364
14365 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14366
14367 struct stat sst;
14368
14369 if (stat (source_file, &sst) == -1)
14370 {
14371 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14372
14373 return -1;
14374 }
14375
14376 /**
14377 * kernel amp cached filename
14378 */
14379
14380 char cached_file[256] = { 0 };
14381
14382 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14383
14384 int cached = 1;
14385
14386 struct stat cst;
14387
14388 if (stat (cached_file, &cst) == -1)
14389 {
14390 cached = 0;
14391 }
14392
14393 /**
14394 * kernel compile or load
14395 */
14396
14397 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14398
14399 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14400
14401 if (cached == 0)
14402 {
14403 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14404 if (quiet == 0) log_info ("");
14405
14406 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14407
14408 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14409
14410 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14411
14412 if (rc != 0)
14413 {
14414 device_param->skipped = true;
14415
14416 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14417
14418 continue;
14419 }
14420
14421 size_t binary_size;
14422
14423 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14424
14425 u8 *binary = (u8 *) mymalloc (binary_size);
14426
14427 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14428
14429 writeProgramBin (cached_file, binary, binary_size);
14430
14431 local_free (binary);
14432 }
14433 else
14434 {
14435 #ifdef DEBUG
14436 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14437 #endif
14438
14439 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14440
14441 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14442
14443 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14444 }
14445
14446 local_free (kernel_lengths);
14447 local_free (kernel_sources[0]);
14448 local_free (kernel_sources);
14449 }
14450
14451 // some algorithm collide too fast, make that impossible
14452
14453 if (benchmark == 1)
14454 {
14455 ((uint *) digests_buf)[0] = -1;
14456 ((uint *) digests_buf)[1] = -1;
14457 ((uint *) digests_buf)[2] = -1;
14458 ((uint *) digests_buf)[3] = -1;
14459 }
14460
14461 /**
14462 * global buffers
14463 */
14464
14465 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14466 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14467 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14468 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14469 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14470 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14471 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14472 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14473 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14474 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14475 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14476 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14477 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14478 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14479 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14480 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14481 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14482 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14483
14484 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);
14485 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);
14486 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);
14487 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);
14488 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);
14489 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);
14490 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);
14491 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);
14492 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14493 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14494 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14495
14496 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14497 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14498 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14499 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14500 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14501 run_kernel_bzero (device_param, device_param->d_result, size_results);
14502
14503 /**
14504 * special buffers
14505 */
14506
14507 if (attack_kern == ATTACK_KERN_STRAIGHT)
14508 {
14509 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14510 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14511
14512 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14513
14514 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14515 }
14516 else if (attack_kern == ATTACK_KERN_COMBI)
14517 {
14518 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14519 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14520 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14521 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14522
14523 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14524 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14525 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14526 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14527 }
14528 else if (attack_kern == ATTACK_KERN_BF)
14529 {
14530 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14531 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14532 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14533 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14534 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14535
14536 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14537 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14538 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14539 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14540 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14541 }
14542
14543 if (size_esalts)
14544 {
14545 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14546
14547 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14548 }
14549
14550 /**
14551 * main host data
14552 */
14553
14554 uint *result = (uint *) mymalloc (size_results);
14555
14556 device_param->result = result;
14557
14558 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14559
14560 device_param->pws_buf = pws_buf;
14561
14562 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14563
14564 device_param->combs_buf = combs_buf;
14565
14566 void *hooks_buf = mymalloc (size_hooks);
14567
14568 device_param->hooks_buf = hooks_buf;
14569
14570 /**
14571 * kernel args
14572 */
14573
14574 device_param->kernel_params_buf32[21] = bitmap_mask;
14575 device_param->kernel_params_buf32[22] = bitmap_shift1;
14576 device_param->kernel_params_buf32[23] = bitmap_shift2;
14577 device_param->kernel_params_buf32[24] = 0; // salt_pos
14578 device_param->kernel_params_buf32[25] = 0; // loop_pos
14579 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14580 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14581 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14582 device_param->kernel_params_buf32[29] = 0; // digests_offset
14583 device_param->kernel_params_buf32[30] = 0; // combs_mode
14584 device_param->kernel_params_buf32[31] = 0; // gid_max
14585
14586 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14587 ? &device_param->d_pws_buf
14588 : &device_param->d_pws_amp_buf;
14589 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14590 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14591 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14592 device_param->kernel_params[ 4] = &device_param->d_tmps;
14593 device_param->kernel_params[ 5] = &device_param->d_hooks;
14594 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14595 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14596 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14597 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14598 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14599 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14600 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14601 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14602 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14603 device_param->kernel_params[15] = &device_param->d_digests_buf;
14604 device_param->kernel_params[16] = &device_param->d_digests_shown;
14605 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14606 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14607 device_param->kernel_params[19] = &device_param->d_result;
14608 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14609 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14610 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14611 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14612 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14613 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14614 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14615 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14616 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14617 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14618 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14619 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14620
14621 device_param->kernel_params_mp_buf64[3] = 0;
14622 device_param->kernel_params_mp_buf32[4] = 0;
14623 device_param->kernel_params_mp_buf32[5] = 0;
14624 device_param->kernel_params_mp_buf32[6] = 0;
14625 device_param->kernel_params_mp_buf32[7] = 0;
14626 device_param->kernel_params_mp_buf32[8] = 0;
14627
14628 device_param->kernel_params_mp[0] = NULL;
14629 device_param->kernel_params_mp[1] = NULL;
14630 device_param->kernel_params_mp[2] = NULL;
14631 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14632 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14633 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14634 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14635 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14636 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14637
14638 device_param->kernel_params_mp_l_buf64[3] = 0;
14639 device_param->kernel_params_mp_l_buf32[4] = 0;
14640 device_param->kernel_params_mp_l_buf32[5] = 0;
14641 device_param->kernel_params_mp_l_buf32[6] = 0;
14642 device_param->kernel_params_mp_l_buf32[7] = 0;
14643 device_param->kernel_params_mp_l_buf32[8] = 0;
14644 device_param->kernel_params_mp_l_buf32[9] = 0;
14645
14646 device_param->kernel_params_mp_l[0] = NULL;
14647 device_param->kernel_params_mp_l[1] = NULL;
14648 device_param->kernel_params_mp_l[2] = NULL;
14649 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14650 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14651 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14652 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14653 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14654 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14655 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14656
14657 device_param->kernel_params_mp_r_buf64[3] = 0;
14658 device_param->kernel_params_mp_r_buf32[4] = 0;
14659 device_param->kernel_params_mp_r_buf32[5] = 0;
14660 device_param->kernel_params_mp_r_buf32[6] = 0;
14661 device_param->kernel_params_mp_r_buf32[7] = 0;
14662 device_param->kernel_params_mp_r_buf32[8] = 0;
14663
14664 device_param->kernel_params_mp_r[0] = NULL;
14665 device_param->kernel_params_mp_r[1] = NULL;
14666 device_param->kernel_params_mp_r[2] = NULL;
14667 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14668 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14669 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14670 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14671 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14672 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14673
14674 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14675 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14676
14677 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14678 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14679 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14680 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14681 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14682 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14683 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14684
14685 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14686 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14687
14688 /**
14689 * kernel name
14690 */
14691
14692 size_t kernel_wgs_tmp;
14693
14694 char kernel_name[64] = { 0 };
14695
14696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14697 {
14698 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14699 {
14700 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14701
14702 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14703
14704 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14705
14706 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14707
14708 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14709
14710 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14711 }
14712 else
14713 {
14714 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14715
14716 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14717
14718 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14719
14720 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14721
14722 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14723
14724 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14725 }
14726
14727 if (data.attack_mode == ATTACK_MODE_BF)
14728 {
14729 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14730 {
14731 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14732
14733 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14734
14735 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);
14736 }
14737 }
14738 }
14739 else
14740 {
14741 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14742
14743 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14744
14745 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14746
14747 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14748
14749 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14750
14751 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14752
14753 if (opts_type & OPTS_TYPE_HOOK12)
14754 {
14755 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14756
14757 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14758
14759 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);
14760 }
14761
14762 if (opts_type & OPTS_TYPE_HOOK23)
14763 {
14764 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14765
14766 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14767
14768 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);
14769 }
14770 }
14771
14772 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);
14773 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);
14774 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);
14775
14776 for (uint i = 0; i <= 20; i++)
14777 {
14778 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14779 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14780 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14781
14782 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14783 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14784 }
14785
14786 for (uint i = 21; i <= 31; i++)
14787 {
14788 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14789 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14790 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14791
14792 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14793 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14794 }
14795
14796 if (attack_mode == ATTACK_MODE_BF)
14797 {
14798 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14799 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14800
14801 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);
14802 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);
14803
14804 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14805 {
14806 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14807 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14808 }
14809 }
14810 else if (attack_mode == ATTACK_MODE_HYBRID1)
14811 {
14812 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14813
14814 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);
14815 }
14816 else if (attack_mode == ATTACK_MODE_HYBRID2)
14817 {
14818 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14819
14820 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);
14821 }
14822
14823 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14824 {
14825 // nothing to do
14826 }
14827 else
14828 {
14829 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14830
14831 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);
14832 }
14833
14834 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14835 {
14836 // nothing to do
14837 }
14838 else
14839 {
14840 for (uint i = 0; i < 5; i++)
14841 {
14842 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14843 }
14844
14845 for (uint i = 5; i < 7; i++)
14846 {
14847 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14848 }
14849 }
14850
14851 // maybe this has been updated by clGetKernelWorkGroupInfo()
14852 // value can only be decreased, so we don't need to reallocate buffers
14853
14854 device_param->kernel_threads = kernel_threads;
14855
14856 /**
14857 * Store initial fanspeed if gpu_temp_retain is enabled
14858 */
14859
14860 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14861 int gpu_temp_retain_set = 0;
14862
14863 if (gpu_temp_disable == 0)
14864 {
14865 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14866 {
14867 hc_thread_mutex_lock (mux_adl);
14868
14869 if (data.hm_device[device_id].fan_supported == 1)
14870 {
14871 if (gpu_temp_retain_chgd == 0)
14872 {
14873 uint cur_temp = 0;
14874 uint default_temp = 0;
14875
14876 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);
14877
14878 if (ADL_rc == ADL_OK)
14879 {
14880 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14881
14882 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14883
14884 // special case with multi gpu setups: always use minimum retain
14885
14886 if (gpu_temp_retain_set == 0)
14887 {
14888 gpu_temp_retain = gpu_temp_retain_target;
14889 gpu_temp_retain_set = 1;
14890 }
14891 else
14892 {
14893 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14894 }
14895
14896 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14897 }
14898 }
14899
14900 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14901
14902 temp_retain_fanspeed_value[device_id] = fan_speed;
14903
14904 if (fan_speed == -1)
14905 {
14906 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14907
14908 temp_retain_fanspeed_value[device_id] = 0;
14909 }
14910 }
14911
14912 hc_thread_mutex_unlock (mux_adl);
14913 }
14914 }
14915
14916 /**
14917 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14918 */
14919
14920 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14921 {
14922 hc_thread_mutex_lock (mux_adl);
14923
14924 if (data.hm_device[device_id].od_version == 6)
14925 {
14926 int ADL_rc;
14927
14928 // check powertune capabilities first, if not available then skip device
14929
14930 int powertune_supported = 0;
14931
14932 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14933 {
14934 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14935
14936 return (-1);
14937 }
14938
14939 if (powertune_supported != 0)
14940 {
14941 // powercontrol settings
14942
14943 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14944
14945 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14946 {
14947 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14948 }
14949
14950 if (ADL_rc != ADL_OK)
14951 {
14952 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14953
14954 return (-1);
14955 }
14956
14957 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14958 {
14959 log_error ("ERROR: Failed to set new ADL PowerControl values");
14960
14961 return (-1);
14962 }
14963
14964 // clocks
14965
14966 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14967
14968 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14969
14970 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)
14971 {
14972 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14973
14974 return (-1);
14975 }
14976
14977 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14978
14979 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14980
14981 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14982 {
14983 log_error ("ERROR: Failed to get ADL device capabilities");
14984
14985 return (-1);
14986 }
14987
14988 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14989 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14990
14991 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14992 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14993
14994 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14995 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14996
14997 // warning if profile has too low max values
14998
14999 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15000 {
15001 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15002 }
15003
15004 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15005 {
15006 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15007 }
15008
15009 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15010
15011 performance_state->iNumberOfPerformanceLevels = 2;
15012
15013 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15014 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15015 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15016 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15017
15018 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)
15019 {
15020 log_info ("ERROR: Failed to set ADL performance state");
15021
15022 return (-1);
15023 }
15024
15025 local_free (performance_state);
15026 }
15027 }
15028
15029 hc_thread_mutex_unlock (mux_adl);
15030 }
15031 #endif // HAVE_HWMON && HAVE_ADL
15032 }
15033
15034 data.kernel_power_all = kernel_power_all;
15035
15036 if (data.quiet == 0) log_info_nn ("");
15037
15038 /**
15039 * In benchmark-mode, inform user which algorithm is checked
15040 */
15041
15042 if (benchmark == 1)
15043 {
15044 if (status_automat == 0)
15045 {
15046 quiet = 0;
15047
15048 data.quiet = quiet;
15049
15050 char *hash_type = strhashtype (data.hash_mode); // not a bug
15051
15052 log_info ("Hashtype: %s", hash_type);
15053 log_info ("");
15054 }
15055 }
15056
15057 /**
15058 * keep track of the progress
15059 */
15060
15061 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15062 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15063 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15064
15065 /**
15066 * open filehandles
15067 */
15068
15069 #if _WIN
15070 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15071 {
15072 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15073
15074 return (-1);
15075 }
15076
15077 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15078 {
15079 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15080
15081 return (-1);
15082 }
15083
15084 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15085 {
15086 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15087
15088 return (-1);
15089 }
15090 #endif
15091
15092 /**
15093 * dictionary pad
15094 */
15095
15096 segment_size *= (1024 * 1024);
15097
15098 data.segment_size = segment_size;
15099
15100 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15101
15102 wl_data->buf = (char *) mymalloc (segment_size);
15103 wl_data->avail = segment_size;
15104 wl_data->incr = segment_size;
15105 wl_data->cnt = 0;
15106 wl_data->pos = 0;
15107
15108 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15109
15110 data.wordlist_mode = wordlist_mode;
15111
15112 cs_t *css_buf = NULL;
15113 uint css_cnt = 0;
15114 uint dictcnt = 0;
15115 uint maskcnt = 1;
15116 char **masks = NULL;
15117 char **dictfiles = NULL;
15118
15119 uint mask_from_file = 0;
15120
15121 if (attack_mode == ATTACK_MODE_STRAIGHT)
15122 {
15123 if (wordlist_mode == WL_MODE_FILE)
15124 {
15125 int wls_left = myargc - (optind + 1);
15126
15127 for (int i = 0; i < wls_left; i++)
15128 {
15129 char *l0_filename = myargv[optind + 1 + i];
15130
15131 struct stat l0_stat;
15132
15133 if (stat (l0_filename, &l0_stat) == -1)
15134 {
15135 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15136
15137 return (-1);
15138 }
15139
15140 uint is_dir = S_ISDIR (l0_stat.st_mode);
15141
15142 if (is_dir == 0)
15143 {
15144 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15145
15146 dictcnt++;
15147
15148 dictfiles[dictcnt - 1] = l0_filename;
15149 }
15150 else
15151 {
15152 // do not allow --keyspace w/ a directory
15153
15154 if (keyspace == 1)
15155 {
15156 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15157
15158 return (-1);
15159 }
15160
15161 char **dictionary_files = NULL;
15162
15163 dictionary_files = scan_directory (l0_filename);
15164
15165 if (dictionary_files != NULL)
15166 {
15167 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15168
15169 for (int d = 0; dictionary_files[d] != NULL; d++)
15170 {
15171 char *l1_filename = dictionary_files[d];
15172
15173 struct stat l1_stat;
15174
15175 if (stat (l1_filename, &l1_stat) == -1)
15176 {
15177 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15178
15179 return (-1);
15180 }
15181
15182 if (S_ISREG (l1_stat.st_mode))
15183 {
15184 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15185
15186 dictcnt++;
15187
15188 dictfiles[dictcnt - 1] = strdup (l1_filename);
15189 }
15190 }
15191 }
15192
15193 local_free (dictionary_files);
15194 }
15195 }
15196
15197 if (dictcnt < 1)
15198 {
15199 log_error ("ERROR: No usable dictionary file found.");
15200
15201 return (-1);
15202 }
15203 }
15204 else if (wordlist_mode == WL_MODE_STDIN)
15205 {
15206 dictcnt = 1;
15207 }
15208 }
15209 else if (attack_mode == ATTACK_MODE_COMBI)
15210 {
15211 // display
15212
15213 char *dictfile1 = myargv[optind + 1 + 0];
15214 char *dictfile2 = myargv[optind + 1 + 1];
15215
15216 // find the bigger dictionary and use as base
15217
15218 FILE *fp1 = NULL;
15219 FILE *fp2 = NULL;
15220
15221 struct stat tmp_stat;
15222
15223 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15224 {
15225 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15226
15227 return (-1);
15228 }
15229
15230 if (stat (dictfile1, &tmp_stat) == -1)
15231 {
15232 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15233
15234 fclose (fp1);
15235
15236 return (-1);
15237 }
15238
15239 if (S_ISDIR (tmp_stat.st_mode))
15240 {
15241 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15242
15243 fclose (fp1);
15244
15245 return (-1);
15246 }
15247
15248 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15249 {
15250 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15251
15252 fclose (fp1);
15253
15254 return (-1);
15255 }
15256
15257 if (stat (dictfile2, &tmp_stat) == -1)
15258 {
15259 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15260
15261 fclose (fp1);
15262 fclose (fp2);
15263
15264 return (-1);
15265 }
15266
15267 if (S_ISDIR (tmp_stat.st_mode))
15268 {
15269 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15270
15271 fclose (fp1);
15272 fclose (fp2);
15273
15274 return (-1);
15275 }
15276
15277 data.combs_cnt = 1;
15278
15279 data.quiet = 1;
15280
15281 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15282
15283 data.quiet = quiet;
15284
15285 if (words1_cnt == 0)
15286 {
15287 log_error ("ERROR: %s: empty file", dictfile1);
15288
15289 fclose (fp1);
15290 fclose (fp2);
15291
15292 return (-1);
15293 }
15294
15295 data.combs_cnt = 1;
15296
15297 data.quiet = 1;
15298
15299 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15300
15301 data.quiet = quiet;
15302
15303 if (words2_cnt == 0)
15304 {
15305 log_error ("ERROR: %s: empty file", dictfile2);
15306
15307 fclose (fp1);
15308 fclose (fp2);
15309
15310 return (-1);
15311 }
15312
15313 fclose (fp1);
15314 fclose (fp2);
15315
15316 data.dictfile = dictfile1;
15317 data.dictfile2 = dictfile2;
15318
15319 if (words1_cnt >= words2_cnt)
15320 {
15321 data.combs_cnt = words2_cnt;
15322 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15323
15324 dictfiles = &data.dictfile;
15325
15326 dictcnt = 1;
15327 }
15328 else
15329 {
15330 data.combs_cnt = words1_cnt;
15331 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15332
15333 dictfiles = &data.dictfile2;
15334
15335 dictcnt = 1;
15336
15337 // we also have to switch wordlist related rules!
15338
15339 char *tmpc = data.rule_buf_l;
15340
15341 data.rule_buf_l = data.rule_buf_r;
15342 data.rule_buf_r = tmpc;
15343
15344 int tmpi = data.rule_len_l;
15345
15346 data.rule_len_l = data.rule_len_r;
15347 data.rule_len_r = tmpi;
15348 }
15349 }
15350 else if (attack_mode == ATTACK_MODE_BF)
15351 {
15352 char *mask = NULL;
15353
15354 maskcnt = 0;
15355
15356 if (benchmark == 0)
15357 {
15358 mask = myargv[optind + 1];
15359
15360 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15361
15362 if ((optind + 2) <= myargc)
15363 {
15364 struct stat file_stat;
15365
15366 if (stat (mask, &file_stat) == -1)
15367 {
15368 maskcnt = 1;
15369
15370 masks[maskcnt - 1] = mystrdup (mask);
15371 }
15372 else
15373 {
15374 int wls_left = myargc - (optind + 1);
15375
15376 uint masks_avail = INCR_MASKS;
15377
15378 for (int i = 0; i < wls_left; i++)
15379 {
15380 if (i != 0)
15381 {
15382 mask = myargv[optind + 1 + i];
15383
15384 if (stat (mask, &file_stat) == -1)
15385 {
15386 log_error ("ERROR: %s: %s", mask, strerror (errno));
15387
15388 return (-1);
15389 }
15390 }
15391
15392 uint is_file = S_ISREG (file_stat.st_mode);
15393
15394 if (is_file == 1)
15395 {
15396 FILE *mask_fp;
15397
15398 if ((mask_fp = fopen (mask, "r")) == NULL)
15399 {
15400 log_error ("ERROR: %s: %s", mask, strerror (errno));
15401
15402 return (-1);
15403 }
15404
15405 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15406
15407 while (!feof (mask_fp))
15408 {
15409 memset (line_buf, 0, HCBUFSIZ);
15410
15411 int line_len = fgetl (mask_fp, line_buf);
15412
15413 if (line_len == 0) continue;
15414
15415 if (line_buf[0] == '#') continue;
15416
15417 if (masks_avail == maskcnt)
15418 {
15419 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15420
15421 masks_avail += INCR_MASKS;
15422 }
15423
15424 masks[maskcnt] = mystrdup (line_buf);
15425
15426 maskcnt++;
15427 }
15428
15429 myfree (line_buf);
15430
15431 fclose (mask_fp);
15432 }
15433 else
15434 {
15435 log_error ("ERROR: %s: unsupported file-type", mask);
15436
15437 return (-1);
15438 }
15439 }
15440
15441 mask_from_file = 1;
15442 }
15443 }
15444 else
15445 {
15446 custom_charset_1 = (char *) "?l?d?u";
15447 custom_charset_2 = (char *) "?l?d";
15448 custom_charset_3 = (char *) "?l?d*!$@_";
15449
15450 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15451 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15452 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15453
15454 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15455
15456 wordlist_mode = WL_MODE_MASK;
15457
15458 data.wordlist_mode = wordlist_mode;
15459
15460 increment = 1;
15461
15462 maskcnt = 1;
15463 }
15464 }
15465 else
15466 {
15467 /**
15468 * generate full masks and charsets
15469 */
15470
15471 masks = (char **) mymalloc (sizeof (char *));
15472
15473 switch (hash_mode)
15474 {
15475 case 1731: pw_min = 5;
15476 pw_max = 5;
15477 mask = mystrdup ("?b?b?b?b?b");
15478 break;
15479 case 12500: pw_min = 5;
15480 pw_max = 5;
15481 mask = mystrdup ("?b?b?b?b?b");
15482 break;
15483 default: pw_min = 7;
15484 pw_max = 7;
15485 mask = mystrdup ("?b?b?b?b?b?b?b");
15486 break;
15487 }
15488
15489 maskcnt = 1;
15490
15491 masks[maskcnt - 1] = mystrdup (mask);
15492
15493 wordlist_mode = WL_MODE_MASK;
15494
15495 data.wordlist_mode = wordlist_mode;
15496
15497 increment = 1;
15498 }
15499
15500 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15501
15502 if (increment)
15503 {
15504 if (increment_min > pw_min) pw_min = increment_min;
15505
15506 if (increment_max < pw_max) pw_max = increment_max;
15507 }
15508 }
15509 else if (attack_mode == ATTACK_MODE_HYBRID1)
15510 {
15511 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15512
15513 // display
15514
15515 char *mask = myargv[myargc - 1];
15516
15517 maskcnt = 0;
15518
15519 masks = (char **) mymalloc (1 * sizeof (char *));
15520
15521 // mod
15522
15523 struct stat file_stat;
15524
15525 if (stat (mask, &file_stat) == -1)
15526 {
15527 maskcnt = 1;
15528
15529 masks[maskcnt - 1] = mystrdup (mask);
15530 }
15531 else
15532 {
15533 uint is_file = S_ISREG (file_stat.st_mode);
15534
15535 if (is_file == 1)
15536 {
15537 FILE *mask_fp;
15538
15539 if ((mask_fp = fopen (mask, "r")) == NULL)
15540 {
15541 log_error ("ERROR: %s: %s", mask, strerror (errno));
15542
15543 return (-1);
15544 }
15545
15546 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15547
15548 uint masks_avail = 1;
15549
15550 while (!feof (mask_fp))
15551 {
15552 memset (line_buf, 0, HCBUFSIZ);
15553
15554 int line_len = fgetl (mask_fp, line_buf);
15555
15556 if (line_len == 0) continue;
15557
15558 if (line_buf[0] == '#') continue;
15559
15560 if (masks_avail == maskcnt)
15561 {
15562 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15563
15564 masks_avail += INCR_MASKS;
15565 }
15566
15567 masks[maskcnt] = mystrdup (line_buf);
15568
15569 maskcnt++;
15570 }
15571
15572 myfree (line_buf);
15573
15574 fclose (mask_fp);
15575
15576 mask_from_file = 1;
15577 }
15578 else
15579 {
15580 maskcnt = 1;
15581
15582 masks[maskcnt - 1] = mystrdup (mask);
15583 }
15584 }
15585
15586 // base
15587
15588 int wls_left = myargc - (optind + 2);
15589
15590 for (int i = 0; i < wls_left; i++)
15591 {
15592 char *filename = myargv[optind + 1 + i];
15593
15594 struct stat file_stat;
15595
15596 if (stat (filename, &file_stat) == -1)
15597 {
15598 log_error ("ERROR: %s: %s", filename, strerror (errno));
15599
15600 return (-1);
15601 }
15602
15603 uint is_dir = S_ISDIR (file_stat.st_mode);
15604
15605 if (is_dir == 0)
15606 {
15607 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15608
15609 dictcnt++;
15610
15611 dictfiles[dictcnt - 1] = filename;
15612 }
15613 else
15614 {
15615 // do not allow --keyspace w/ a directory
15616
15617 if (keyspace == 1)
15618 {
15619 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15620
15621 return (-1);
15622 }
15623
15624 char **dictionary_files = NULL;
15625
15626 dictionary_files = scan_directory (filename);
15627
15628 if (dictionary_files != NULL)
15629 {
15630 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15631
15632 for (int d = 0; dictionary_files[d] != NULL; d++)
15633 {
15634 char *l1_filename = dictionary_files[d];
15635
15636 struct stat l1_stat;
15637
15638 if (stat (l1_filename, &l1_stat) == -1)
15639 {
15640 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15641
15642 return (-1);
15643 }
15644
15645 if (S_ISREG (l1_stat.st_mode))
15646 {
15647 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15648
15649 dictcnt++;
15650
15651 dictfiles[dictcnt - 1] = strdup (l1_filename);
15652 }
15653 }
15654 }
15655
15656 local_free (dictionary_files);
15657 }
15658 }
15659
15660 if (dictcnt < 1)
15661 {
15662 log_error ("ERROR: No usable dictionary file found.");
15663
15664 return (-1);
15665 }
15666
15667 if (increment)
15668 {
15669 maskcnt = 0;
15670
15671 uint mask_min = increment_min; // we can't reject smaller masks here
15672 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15673
15674 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15675 {
15676 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15677
15678 if (cur_mask == NULL) break;
15679
15680 masks[maskcnt] = cur_mask;
15681
15682 maskcnt++;
15683
15684 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15685 }
15686 }
15687 }
15688 else if (attack_mode == ATTACK_MODE_HYBRID2)
15689 {
15690 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15691
15692 // display
15693
15694 char *mask = myargv[optind + 1 + 0];
15695
15696 maskcnt = 0;
15697
15698 masks = (char **) mymalloc (1 * sizeof (char *));
15699
15700 // mod
15701
15702 struct stat file_stat;
15703
15704 if (stat (mask, &file_stat) == -1)
15705 {
15706 maskcnt = 1;
15707
15708 masks[maskcnt - 1] = mystrdup (mask);
15709 }
15710 else
15711 {
15712 uint is_file = S_ISREG (file_stat.st_mode);
15713
15714 if (is_file == 1)
15715 {
15716 FILE *mask_fp;
15717
15718 if ((mask_fp = fopen (mask, "r")) == NULL)
15719 {
15720 log_error ("ERROR: %s: %s", mask, strerror (errno));
15721
15722 return (-1);
15723 }
15724
15725 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15726
15727 uint masks_avail = 1;
15728
15729 while (!feof (mask_fp))
15730 {
15731 memset (line_buf, 0, HCBUFSIZ);
15732
15733 int line_len = fgetl (mask_fp, line_buf);
15734
15735 if (line_len == 0) continue;
15736
15737 if (line_buf[0] == '#') continue;
15738
15739 if (masks_avail == maskcnt)
15740 {
15741 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15742
15743 masks_avail += INCR_MASKS;
15744 }
15745
15746 masks[maskcnt] = mystrdup (line_buf);
15747
15748 maskcnt++;
15749 }
15750
15751 myfree (line_buf);
15752
15753 fclose (mask_fp);
15754
15755 mask_from_file = 1;
15756 }
15757 else
15758 {
15759 maskcnt = 1;
15760
15761 masks[maskcnt - 1] = mystrdup (mask);
15762 }
15763 }
15764
15765 // base
15766
15767 int wls_left = myargc - (optind + 2);
15768
15769 for (int i = 0; i < wls_left; i++)
15770 {
15771 char *filename = myargv[optind + 2 + i];
15772
15773 struct stat file_stat;
15774
15775 if (stat (filename, &file_stat) == -1)
15776 {
15777 log_error ("ERROR: %s: %s", filename, strerror (errno));
15778
15779 return (-1);
15780 }
15781
15782 uint is_dir = S_ISDIR (file_stat.st_mode);
15783
15784 if (is_dir == 0)
15785 {
15786 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15787
15788 dictcnt++;
15789
15790 dictfiles[dictcnt - 1] = filename;
15791 }
15792 else
15793 {
15794 // do not allow --keyspace w/ a directory
15795
15796 if (keyspace == 1)
15797 {
15798 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15799
15800 return (-1);
15801 }
15802
15803 char **dictionary_files = NULL;
15804
15805 dictionary_files = scan_directory (filename);
15806
15807 if (dictionary_files != NULL)
15808 {
15809 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15810
15811 for (int d = 0; dictionary_files[d] != NULL; d++)
15812 {
15813 char *l1_filename = dictionary_files[d];
15814
15815 struct stat l1_stat;
15816
15817 if (stat (l1_filename, &l1_stat) == -1)
15818 {
15819 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15820
15821 return (-1);
15822 }
15823
15824 if (S_ISREG (l1_stat.st_mode))
15825 {
15826 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15827
15828 dictcnt++;
15829
15830 dictfiles[dictcnt - 1] = strdup (l1_filename);
15831 }
15832 }
15833 }
15834
15835 local_free (dictionary_files);
15836 }
15837 }
15838
15839 if (dictcnt < 1)
15840 {
15841 log_error ("ERROR: No usable dictionary file found.");
15842
15843 return (-1);
15844 }
15845
15846 if (increment)
15847 {
15848 maskcnt = 0;
15849
15850 uint mask_min = increment_min; // we can't reject smaller masks here
15851 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15852
15853 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15854 {
15855 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15856
15857 if (cur_mask == NULL) break;
15858
15859 masks[maskcnt] = cur_mask;
15860
15861 maskcnt++;
15862
15863 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15864 }
15865 }
15866 }
15867
15868 data.pw_min = pw_min;
15869 data.pw_max = pw_max;
15870
15871 /**
15872 * weak hash check
15873 */
15874
15875 if (weak_hash_threshold >= salts_cnt)
15876 {
15877 hc_device_param_t *device_param = NULL;
15878
15879 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15880 {
15881 device_param = &data.devices_param[device_id];
15882
15883 if (device_param->skipped) continue;
15884
15885 break;
15886 }
15887
15888 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15889
15890 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15891 {
15892 weak_hash_check (device_param, salt_pos);
15893 }
15894
15895 // Display hack, guarantee that there is at least one \r before real start
15896
15897 //if (data.quiet == 0) log_info ("");
15898 }
15899
15900 /**
15901 * status and monitor threads
15902 */
15903
15904 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15905
15906 hc_thread_t i_thread = 0;
15907
15908 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15909 {
15910 hc_thread_create (i_thread, thread_keypress, &benchmark);
15911 }
15912
15913 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15914
15915 uint ni_threads_cnt = 0;
15916
15917 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15918
15919 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15920
15921 ni_threads_cnt++;
15922
15923 /**
15924 * Outfile remove
15925 */
15926
15927 if (keyspace == 0)
15928 {
15929 if (outfile_check_timer != 0)
15930 {
15931 if (data.outfile_check_directory != NULL)
15932 {
15933 if ((hash_mode != 5200) &&
15934 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15935 (hash_mode != 9000))
15936 {
15937 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15938
15939 ni_threads_cnt++;
15940 }
15941 else
15942 {
15943 outfile_check_timer = 0;
15944 }
15945 }
15946 else
15947 {
15948 outfile_check_timer = 0;
15949 }
15950 }
15951 }
15952
15953 /**
15954 * Inform the user if we got some hashes remove because of the pot file remove feature
15955 */
15956
15957 if (data.quiet == 0)
15958 {
15959 if (potfile_remove_cracks > 0)
15960 {
15961 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15962 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15963 }
15964 }
15965
15966 data.outfile_check_timer = outfile_check_timer;
15967
15968 /**
15969 * main loop
15970 */
15971
15972 char **induction_dictionaries = NULL;
15973
15974 int induction_dictionaries_cnt = 0;
15975
15976 hcstat_table_t *root_table_buf = NULL;
15977 hcstat_table_t *markov_table_buf = NULL;
15978
15979 uint initial_restore_done = 0;
15980
15981 data.maskcnt = maskcnt;
15982
15983 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15984 {
15985 if (data.devices_status == STATUS_CRACKED) break;
15986
15987 data.devices_status = STATUS_INIT;
15988
15989 if (maskpos > rd->maskpos)
15990 {
15991 rd->dictpos = 0;
15992 }
15993
15994 rd->maskpos = maskpos;
15995 data.maskpos = maskpos;
15996
15997 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15998 {
15999 char *mask = masks[maskpos];
16000
16001 if (mask_from_file == 1)
16002 {
16003 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16004
16005 char *str_ptr;
16006 uint str_pos;
16007
16008 uint mask_offset = 0;
16009
16010 uint separator_cnt;
16011
16012 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16013 {
16014 str_ptr = strstr (mask + mask_offset, ",");
16015
16016 if (str_ptr == NULL) break;
16017
16018 str_pos = str_ptr - mask;
16019
16020 // escaped separator, i.e. "\,"
16021
16022 if (str_pos > 0)
16023 {
16024 if (mask[str_pos - 1] == '\\')
16025 {
16026 separator_cnt --;
16027
16028 mask_offset = str_pos + 1;
16029
16030 continue;
16031 }
16032 }
16033
16034 // reset the offset
16035
16036 mask_offset = 0;
16037
16038 mask[str_pos] = '\0';
16039
16040 switch (separator_cnt)
16041 {
16042 case 0:
16043 mp_reset_usr (mp_usr, 0);
16044
16045 custom_charset_1 = mask;
16046 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16047 break;
16048
16049 case 1:
16050 mp_reset_usr (mp_usr, 1);
16051
16052 custom_charset_2 = mask;
16053 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16054 break;
16055
16056 case 2:
16057 mp_reset_usr (mp_usr, 2);
16058
16059 custom_charset_3 = mask;
16060 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16061 break;
16062
16063 case 3:
16064 mp_reset_usr (mp_usr, 3);
16065
16066 custom_charset_4 = mask;
16067 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16068 break;
16069 }
16070
16071 mask = mask + str_pos + 1;
16072 }
16073 }
16074
16075 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16076 {
16077 if (maskpos > 0)
16078 {
16079 local_free (css_buf);
16080 local_free (data.root_css_buf);
16081 local_free (data.markov_css_buf);
16082
16083 local_free (masks[maskpos - 1]);
16084 }
16085
16086 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16087
16088 data.mask = mask;
16089 data.css_cnt = css_cnt;
16090 data.css_buf = css_buf;
16091
16092 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16093
16094 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16095
16096 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16097 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16098
16099 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16100
16101 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16102
16103 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16104 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16105
16106 data.root_css_buf = root_css_buf;
16107 data.markov_css_buf = markov_css_buf;
16108
16109 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16110
16111 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16112
16113 local_free (root_table_buf);
16114 local_free (markov_table_buf);
16115
16116 // args
16117
16118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16119 {
16120 hc_device_param_t *device_param = &data.devices_param[device_id];
16121
16122 if (device_param->skipped) continue;
16123
16124 device_param->kernel_params_mp[0] = &device_param->d_combs;
16125 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16126 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16127
16128 device_param->kernel_params_mp_buf64[3] = 0;
16129 device_param->kernel_params_mp_buf32[4] = css_cnt;
16130 device_param->kernel_params_mp_buf32[5] = 0;
16131 device_param->kernel_params_mp_buf32[6] = 0;
16132 device_param->kernel_params_mp_buf32[7] = 0;
16133
16134 if (attack_mode == ATTACK_MODE_HYBRID1)
16135 {
16136 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16137 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16138 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16139 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16140 }
16141 else if (attack_mode == ATTACK_MODE_HYBRID2)
16142 {
16143 device_param->kernel_params_mp_buf32[5] = 0;
16144 device_param->kernel_params_mp_buf32[6] = 0;
16145 device_param->kernel_params_mp_buf32[7] = 0;
16146 }
16147
16148 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]);
16149 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]);
16150 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]);
16151
16152 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);
16153 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);
16154 }
16155 }
16156 else if (attack_mode == ATTACK_MODE_BF)
16157 {
16158 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16159
16160 if (increment)
16161 {
16162 for (uint i = 0; i < dictcnt; i++)
16163 {
16164 local_free (dictfiles[i]);
16165 }
16166
16167 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16168 {
16169 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16170
16171 if (l1_filename == NULL) break;
16172
16173 dictcnt++;
16174
16175 dictfiles[dictcnt - 1] = l1_filename;
16176 }
16177 }
16178 else
16179 {
16180 dictcnt++;
16181
16182 dictfiles[dictcnt - 1] = mask;
16183 }
16184
16185 if (dictcnt == 0)
16186 {
16187 log_error ("ERROR: Mask is too small");
16188
16189 return (-1);
16190 }
16191 }
16192 }
16193
16194 free (induction_dictionaries);
16195
16196 // induction_dictionaries_cnt = 0; // implied
16197
16198 if (attack_mode != ATTACK_MODE_BF)
16199 {
16200 if (keyspace == 0)
16201 {
16202 induction_dictionaries = scan_directory (induction_directory);
16203
16204 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16205 }
16206 }
16207
16208 if (induction_dictionaries_cnt)
16209 {
16210 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16211 }
16212
16213 /**
16214 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16215 */
16216 if (keyspace == 1)
16217 {
16218 if ((maskcnt > 1) || (dictcnt > 1))
16219 {
16220 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16221
16222 return (-1);
16223 }
16224 }
16225
16226 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16227 {
16228 char *subid = logfile_generate_subid ();
16229
16230 data.subid = subid;
16231
16232 logfile_sub_msg ("START");
16233
16234 data.devices_status = STATUS_INIT;
16235
16236 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16237 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16238 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16239
16240 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16241
16242 data.cpt_pos = 0;
16243
16244 data.cpt_start = time (NULL);
16245
16246 data.cpt_total = 0;
16247
16248 if (data.restore == 0)
16249 {
16250 rd->words_cur = skip;
16251
16252 skip = 0;
16253
16254 data.skip = 0;
16255 }
16256
16257 data.ms_paused = 0;
16258
16259 data.words_cur = rd->words_cur;
16260
16261 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16262 {
16263 hc_device_param_t *device_param = &data.devices_param[device_id];
16264
16265 if (device_param->skipped) continue;
16266
16267 device_param->speed_pos = 0;
16268
16269 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16270 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16271
16272 device_param->exec_pos = 0;
16273
16274 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16275
16276 device_param->kernel_power = device_param->kernel_power_user;
16277
16278 device_param->outerloop_pos = 0;
16279 device_param->outerloop_left = 0;
16280 device_param->innerloop_pos = 0;
16281 device_param->innerloop_left = 0;
16282
16283 // some more resets:
16284
16285 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16286
16287 device_param->pws_cnt = 0;
16288
16289 device_param->words_off = 0;
16290 device_param->words_done = 0;
16291 }
16292
16293 data.kernel_power_div = 0;
16294
16295 // figure out some workload
16296
16297 if (attack_mode == ATTACK_MODE_STRAIGHT)
16298 {
16299 if (data.wordlist_mode == WL_MODE_FILE)
16300 {
16301 char *dictfile = NULL;
16302
16303 if (induction_dictionaries_cnt)
16304 {
16305 dictfile = induction_dictionaries[0];
16306 }
16307 else
16308 {
16309 dictfile = dictfiles[dictpos];
16310 }
16311
16312 data.dictfile = dictfile;
16313
16314 logfile_sub_string (dictfile);
16315
16316 for (uint i = 0; i < rp_files_cnt; i++)
16317 {
16318 logfile_sub_var_string ("rulefile", rp_files[i]);
16319 }
16320
16321 FILE *fd2 = fopen (dictfile, "rb");
16322
16323 if (fd2 == NULL)
16324 {
16325 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16326
16327 return (-1);
16328 }
16329
16330 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16331
16332 fclose (fd2);
16333
16334 if (data.words_cnt == 0)
16335 {
16336 if (data.devices_status == STATUS_CRACKED) break;
16337 if (data.devices_status == STATUS_ABORTED) break;
16338
16339 dictpos++;
16340
16341 continue;
16342 }
16343 }
16344 }
16345 else if (attack_mode == ATTACK_MODE_COMBI)
16346 {
16347 char *dictfile = data.dictfile;
16348 char *dictfile2 = data.dictfile2;
16349
16350 logfile_sub_string (dictfile);
16351 logfile_sub_string (dictfile2);
16352
16353 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16354 {
16355 FILE *fd2 = fopen (dictfile, "rb");
16356
16357 if (fd2 == NULL)
16358 {
16359 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16360
16361 return (-1);
16362 }
16363
16364 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16365
16366 fclose (fd2);
16367 }
16368 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16369 {
16370 FILE *fd2 = fopen (dictfile2, "rb");
16371
16372 if (fd2 == NULL)
16373 {
16374 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16375
16376 return (-1);
16377 }
16378
16379 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16380
16381 fclose (fd2);
16382 }
16383
16384 if (data.words_cnt == 0)
16385 {
16386 if (data.devices_status == STATUS_CRACKED) break;
16387 if (data.devices_status == STATUS_ABORTED) break;
16388
16389 dictpos++;
16390
16391 continue;
16392 }
16393 }
16394 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16395 {
16396 char *dictfile = NULL;
16397
16398 if (induction_dictionaries_cnt)
16399 {
16400 dictfile = induction_dictionaries[0];
16401 }
16402 else
16403 {
16404 dictfile = dictfiles[dictpos];
16405 }
16406
16407 data.dictfile = dictfile;
16408
16409 char *mask = data.mask;
16410
16411 logfile_sub_string (dictfile);
16412 logfile_sub_string (mask);
16413
16414 FILE *fd2 = fopen (dictfile, "rb");
16415
16416 if (fd2 == NULL)
16417 {
16418 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16419
16420 return (-1);
16421 }
16422
16423 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16424
16425 fclose (fd2);
16426
16427 if (data.words_cnt == 0)
16428 {
16429 if (data.devices_status == STATUS_CRACKED) break;
16430 if (data.devices_status == STATUS_ABORTED) break;
16431
16432 dictpos++;
16433
16434 continue;
16435 }
16436 }
16437 else if (attack_mode == ATTACK_MODE_BF)
16438 {
16439 local_free (css_buf);
16440 local_free (data.root_css_buf);
16441 local_free (data.markov_css_buf);
16442
16443 char *mask = dictfiles[dictpos];
16444
16445 logfile_sub_string (mask);
16446
16447 // base
16448
16449 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16450
16451 if (opts_type & OPTS_TYPE_PT_UNICODE)
16452 {
16453 uint css_cnt_unicode = css_cnt * 2;
16454
16455 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16456
16457 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16458 {
16459 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16460
16461 css_buf_unicode[j + 1].cs_buf[0] = 0;
16462 css_buf_unicode[j + 1].cs_len = 1;
16463 }
16464
16465 free (css_buf);
16466
16467 css_buf = css_buf_unicode;
16468 css_cnt = css_cnt_unicode;
16469 }
16470
16471 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16472
16473 uint mask_min = pw_min;
16474 uint mask_max = pw_max;
16475
16476 if (opts_type & OPTS_TYPE_PT_UNICODE)
16477 {
16478 mask_min *= 2;
16479 mask_max *= 2;
16480 }
16481
16482 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16483 {
16484 if (css_cnt < mask_min)
16485 {
16486 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16487 }
16488
16489 if (css_cnt > mask_max)
16490 {
16491 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16492 }
16493
16494 // skip to next mask
16495
16496 dictpos++;
16497
16498 rd->dictpos = dictpos;
16499
16500 logfile_sub_msg ("STOP");
16501
16502 continue;
16503 }
16504
16505 uint save_css_cnt = css_cnt;
16506
16507 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16508 {
16509 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16510 {
16511 uint salt_len = (uint) data.salts_buf[0].salt_len;
16512 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16513
16514 uint css_cnt_salt = css_cnt + salt_len;
16515
16516 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16517
16518 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16519
16520 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16521 {
16522 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16523 css_buf_salt[j].cs_len = 1;
16524 }
16525
16526 free (css_buf);
16527
16528 css_buf = css_buf_salt;
16529 css_cnt = css_cnt_salt;
16530 }
16531 }
16532
16533 data.mask = mask;
16534 data.css_cnt = css_cnt;
16535 data.css_buf = css_buf;
16536
16537 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16538
16539 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16540
16541 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16542
16543 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16544 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16545
16546 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16547
16548 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16549
16550 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16551 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16552
16553 data.root_css_buf = root_css_buf;
16554 data.markov_css_buf = markov_css_buf;
16555
16556 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16557
16558 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16559
16560 local_free (root_table_buf);
16561 local_free (markov_table_buf);
16562
16563 // copy + args
16564
16565 uint css_cnt_l = css_cnt;
16566 uint css_cnt_r;
16567
16568 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16569 {
16570 if (save_css_cnt < 6)
16571 {
16572 css_cnt_r = 1;
16573 }
16574 else if (save_css_cnt == 6)
16575 {
16576 css_cnt_r = 2;
16577 }
16578 else
16579 {
16580 if (opts_type & OPTS_TYPE_PT_UNICODE)
16581 {
16582 if (save_css_cnt == 8 || save_css_cnt == 10)
16583 {
16584 css_cnt_r = 2;
16585 }
16586 else
16587 {
16588 css_cnt_r = 4;
16589 }
16590 }
16591 else
16592 {
16593 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16594 {
16595 css_cnt_r = 3;
16596 }
16597 else
16598 {
16599 css_cnt_r = 4;
16600 }
16601 }
16602 }
16603 }
16604 else
16605 {
16606 css_cnt_r = 1;
16607
16608 /* unfinished code?
16609 int sum = css_buf[css_cnt_r - 1].cs_len;
16610
16611 for (uint i = 1; i < 4 && i < css_cnt; i++)
16612 {
16613 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16614
16615 css_cnt_r++;
16616
16617 sum *= css_buf[css_cnt_r - 1].cs_len;
16618 }
16619 */
16620 }
16621
16622 css_cnt_l -= css_cnt_r;
16623
16624 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16625
16626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16627 {
16628 hc_device_param_t *device_param = &data.devices_param[device_id];
16629
16630 if (device_param->skipped) continue;
16631
16632 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16633 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16634 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16635
16636 device_param->kernel_params_mp_l_buf64[3] = 0;
16637 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16638 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16639 device_param->kernel_params_mp_l_buf32[6] = 0;
16640 device_param->kernel_params_mp_l_buf32[7] = 0;
16641 device_param->kernel_params_mp_l_buf32[8] = 0;
16642
16643 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16644 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16645 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16646 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16647
16648 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16649 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16650 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16651
16652 device_param->kernel_params_mp_r_buf64[3] = 0;
16653 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16654 device_param->kernel_params_mp_r_buf32[5] = 0;
16655 device_param->kernel_params_mp_r_buf32[6] = 0;
16656 device_param->kernel_params_mp_r_buf32[7] = 0;
16657
16658 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]);
16659 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]);
16660 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]);
16661
16662 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]);
16663 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]);
16664 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]);
16665
16666 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);
16667 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);
16668 }
16669 }
16670
16671 u64 words_base = data.words_cnt;
16672
16673 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16674 {
16675 if (data.kernel_rules_cnt)
16676 {
16677 words_base /= data.kernel_rules_cnt;
16678 }
16679 }
16680 else if (data.attack_kern == ATTACK_KERN_COMBI)
16681 {
16682 if (data.combs_cnt)
16683 {
16684 words_base /= data.combs_cnt;
16685 }
16686 }
16687 else if (data.attack_kern == ATTACK_KERN_BF)
16688 {
16689 if (data.bfs_cnt)
16690 {
16691 words_base /= data.bfs_cnt;
16692 }
16693 }
16694
16695 data.words_base = words_base;
16696
16697 if (keyspace == 1)
16698 {
16699 log_info ("%llu", (unsigned long long int) words_base);
16700
16701 return (0);
16702 }
16703
16704 if (data.words_cur > data.words_base)
16705 {
16706 log_error ("ERROR: restore value greater keyspace");
16707
16708 return (-1);
16709 }
16710
16711 if (data.words_cur)
16712 {
16713 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16714 {
16715 for (uint i = 0; i < data.salts_cnt; i++)
16716 {
16717 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16718 }
16719 }
16720 else if (data.attack_kern == ATTACK_KERN_COMBI)
16721 {
16722 for (uint i = 0; i < data.salts_cnt; i++)
16723 {
16724 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16725 }
16726 }
16727 else if (data.attack_kern == ATTACK_KERN_BF)
16728 {
16729 for (uint i = 0; i < data.salts_cnt; i++)
16730 {
16731 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16732 }
16733 }
16734 }
16735
16736 /*
16737 * Inform user about possible slow speeds
16738 */
16739
16740 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16741 {
16742 if (data.words_base < kernel_power_all)
16743 {
16744 if (quiet == 0)
16745 {
16746 log_info ("ATTENTION!");
16747 log_info (" The wordlist or mask you are using is too small.");
16748 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16749 log_info (" The cracking speed will drop.");
16750 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16751 log_info ("");
16752 }
16753 }
16754 }
16755
16756 /*
16757 * Update loopback file
16758 */
16759
16760 if (loopback == 1)
16761 {
16762 time_t now;
16763
16764 time (&now);
16765
16766 uint random_num = get_random_num (0, 9999);
16767
16768 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16769
16770 data.loopback_file = loopback_file;
16771 }
16772
16773 /*
16774 * Update dictionary statistic
16775 */
16776
16777 if (keyspace == 0)
16778 {
16779 dictstat_fp = fopen (dictstat, "wb");
16780
16781 if (dictstat_fp)
16782 {
16783 lock_file (dictstat_fp);
16784
16785 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16786
16787 fclose (dictstat_fp);
16788 }
16789 }
16790
16791 data.devices_status = STATUS_RUNNING;
16792
16793 if (initial_restore_done == 0)
16794 {
16795 if (data.restore_disable == 0) cycle_restore ();
16796
16797 initial_restore_done = 1;
16798 }
16799
16800 hc_timer_set (&data.timer_running);
16801
16802 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16803 {
16804 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16805 {
16806 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16807 if (quiet == 0) fflush (stdout);
16808 }
16809 }
16810 else if (wordlist_mode == WL_MODE_STDIN)
16811 {
16812 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16813 if (data.quiet == 0) log_info ("");
16814 }
16815
16816 time_t runtime_start;
16817
16818 time (&runtime_start);
16819
16820 data.runtime_start = runtime_start;
16821
16822 /**
16823 * create cracker threads
16824 */
16825
16826 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16827
16828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16829 {
16830 hc_device_param_t *device_param = &devices_param[device_id];
16831
16832 if (wordlist_mode == WL_MODE_STDIN)
16833 {
16834 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16835 }
16836 else
16837 {
16838 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16839 }
16840 }
16841
16842 // wait for crack threads to exit
16843
16844 hc_thread_wait (data.devices_cnt, c_threads);
16845
16846 local_free (c_threads);
16847
16848 data.restore = 0;
16849
16850 // finalize task
16851
16852 logfile_sub_var_uint ("status-after-work", data.devices_status);
16853
16854 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16855
16856 if (data.devices_status == STATUS_CRACKED) break;
16857 if (data.devices_status == STATUS_ABORTED) break;
16858
16859 if (data.devices_status == STATUS_BYPASS)
16860 {
16861 data.devices_status = STATUS_RUNNING;
16862 }
16863
16864 if (induction_dictionaries_cnt)
16865 {
16866 unlink (induction_dictionaries[0]);
16867 }
16868
16869 free (induction_dictionaries);
16870
16871 if (attack_mode != ATTACK_MODE_BF)
16872 {
16873 induction_dictionaries = scan_directory (induction_directory);
16874
16875 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16876 }
16877
16878 if (benchmark == 0)
16879 {
16880 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16881 {
16882 if (quiet == 0) clear_prompt ();
16883
16884 if (quiet == 0) log_info ("");
16885
16886 if (status == 1)
16887 {
16888 status_display ();
16889 }
16890 else
16891 {
16892 if (quiet == 0) status_display ();
16893 }
16894
16895 if (quiet == 0) log_info ("");
16896 }
16897 }
16898
16899 if (attack_mode == ATTACK_MODE_BF)
16900 {
16901 dictpos++;
16902
16903 rd->dictpos = dictpos;
16904 }
16905 else
16906 {
16907 if (induction_dictionaries_cnt)
16908 {
16909 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16910 }
16911 else
16912 {
16913 dictpos++;
16914
16915 rd->dictpos = dictpos;
16916 }
16917 }
16918
16919 time_t runtime_stop;
16920
16921 time (&runtime_stop);
16922
16923 data.runtime_stop = runtime_stop;
16924
16925 logfile_sub_uint (runtime_start);
16926 logfile_sub_uint (runtime_stop);
16927
16928 logfile_sub_msg ("STOP");
16929
16930 global_free (subid);
16931 }
16932
16933 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16934
16935 if (data.devices_status == STATUS_CRACKED) break;
16936 if (data.devices_status == STATUS_ABORTED) break;
16937 if (data.devices_status == STATUS_QUIT) break;
16938
16939 if (data.devices_status == STATUS_BYPASS)
16940 {
16941 data.devices_status = STATUS_RUNNING;
16942 }
16943 }
16944
16945 // 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
16946
16947 if (attack_mode == ATTACK_MODE_STRAIGHT)
16948 {
16949 if (data.wordlist_mode == WL_MODE_FILE)
16950 {
16951 if (data.dictfile == NULL)
16952 {
16953 if (dictfiles != NULL)
16954 {
16955 data.dictfile = dictfiles[0];
16956
16957 hc_timer_set (&data.timer_running);
16958 }
16959 }
16960 }
16961 }
16962 // NOTE: combi is okay because it is already set beforehand
16963 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16964 {
16965 if (data.dictfile == NULL)
16966 {
16967 if (dictfiles != NULL)
16968 {
16969 hc_timer_set (&data.timer_running);
16970
16971 data.dictfile = dictfiles[0];
16972 }
16973 }
16974 }
16975 else if (attack_mode == ATTACK_MODE_BF)
16976 {
16977 if (data.mask == NULL)
16978 {
16979 hc_timer_set (&data.timer_running);
16980
16981 data.mask = masks[0];
16982 }
16983 }
16984
16985 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16986 {
16987 data.devices_status = STATUS_EXHAUSTED;
16988 }
16989
16990 // if cracked / aborted remove last induction dictionary
16991
16992 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16993 {
16994 struct stat induct_stat;
16995
16996 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16997 {
16998 unlink (induction_dictionaries[file_pos]);
16999 }
17000 }
17001
17002 // wait for non-interactive threads
17003
17004 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17005 {
17006 hc_thread_wait (1, &ni_threads[thread_idx]);
17007 }
17008
17009 local_free (ni_threads);
17010
17011 // wait for interactive threads
17012
17013 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17014 {
17015 hc_thread_wait (1, &i_thread);
17016 }
17017
17018 // we dont need restore file anymore
17019 if (data.restore_disable == 0)
17020 {
17021 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17022 {
17023 unlink (eff_restore_file);
17024 unlink (new_restore_file);
17025 }
17026 else
17027 {
17028 cycle_restore ();
17029 }
17030 }
17031
17032 // finally save left hashes
17033
17034 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17035 {
17036 save_hash ();
17037 }
17038
17039 /**
17040 * Clean up
17041 */
17042
17043 if (benchmark == 1)
17044 {
17045 status_benchmark ();
17046
17047 if (status_automat == 0)
17048 {
17049 log_info ("");
17050 }
17051 }
17052 else
17053 {
17054 if (quiet == 0) clear_prompt ();
17055
17056 if (quiet == 0) log_info ("");
17057
17058 if (status == 1)
17059 {
17060 status_display ();
17061 }
17062 else
17063 {
17064 if (quiet == 0) status_display ();
17065 }
17066
17067 if (quiet == 0) log_info ("");
17068 }
17069
17070 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17071 {
17072 hc_device_param_t *device_param = &data.devices_param[device_id];
17073
17074 if (device_param->skipped) continue;
17075
17076 local_free (device_param->result);
17077
17078 local_free (device_param->combs_buf);
17079
17080 local_free (device_param->hooks_buf);
17081
17082 local_free (device_param->device_name);
17083
17084 local_free (device_param->device_name_chksum);
17085
17086 local_free (device_param->device_version);
17087
17088 local_free (device_param->driver_version);
17089
17090 if (device_param->pws_buf) myfree (device_param->pws_buf);
17091 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17092 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17093 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17094 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17095 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17096 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17097 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17098 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17099 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17100 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17101 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17102 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17103 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17104 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17105 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17106 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17107 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17108 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17109 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17110 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17111 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17112 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17113 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17114 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17115 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17116 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17117 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17118 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17119
17120 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17121 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17122 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17123 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17124 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17125 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17126 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17127 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17128 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17129 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17130
17131 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17132 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17133 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17134
17135 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17136 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17137 }
17138
17139 // reset default fan speed
17140
17141 #ifdef HAVE_HWMON
17142 if (gpu_temp_disable == 0)
17143 {
17144 #ifdef HAVE_ADL
17145 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17146 {
17147 hc_thread_mutex_lock (mux_adl);
17148
17149 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17150 {
17151 hc_device_param_t *device_param = &data.devices_param[device_id];
17152
17153 if (device_param->skipped) continue;
17154
17155 if (data.hm_device[device_id].fan_supported == 1)
17156 {
17157 int fanspeed = temp_retain_fanspeed_value[device_id];
17158
17159 if (fanspeed == -1) continue;
17160
17161 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17162
17163 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17164 }
17165 }
17166
17167 hc_thread_mutex_unlock (mux_adl);
17168 }
17169 #endif // HAVE_ADL
17170 }
17171
17172 #ifdef HAVE_ADL
17173 // reset power tuning
17174
17175 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17176 {
17177 hc_thread_mutex_lock (mux_adl);
17178
17179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17180 {
17181 hc_device_param_t *device_param = &data.devices_param[device_id];
17182
17183 if (device_param->skipped) continue;
17184
17185 if (data.hm_device[device_id].od_version == 6)
17186 {
17187 // check powertune capabilities first, if not available then skip device
17188
17189 int powertune_supported = 0;
17190
17191 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17192 {
17193 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17194
17195 return (-1);
17196 }
17197
17198 if (powertune_supported != 0)
17199 {
17200 // powercontrol settings
17201
17202 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)
17203 {
17204 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17205
17206 return (-1);
17207 }
17208
17209 // clocks
17210
17211 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17212
17213 performance_state->iNumberOfPerformanceLevels = 2;
17214
17215 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17216 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17217 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17218 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17219
17220 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)
17221 {
17222 log_info ("ERROR: Failed to restore ADL performance state");
17223
17224 return (-1);
17225 }
17226
17227 local_free (performance_state);
17228 }
17229 }
17230 }
17231
17232 hc_thread_mutex_unlock (mux_adl);
17233 }
17234 #endif // HAVE_ADL
17235
17236 if (gpu_temp_disable == 0)
17237 {
17238 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17239 if (data.hm_nv)
17240 {
17241 #if defined(LINUX) && defined(HAVE_NVML)
17242
17243 hm_NVML_nvmlShutdown (data.hm_nv);
17244
17245 nvml_close (data.hm_nv);
17246
17247 #elif defined(WIN) && (HAVE_NVAPI)
17248
17249 hm_NvAPI_Unload (data.hm_nv);
17250
17251 nvapi_close (data.hm_nv);
17252
17253 #endif
17254
17255 data.hm_nv = NULL;
17256 }
17257 #endif
17258
17259 #ifdef HAVE_ADL
17260 if (data.hm_amd)
17261 {
17262 hm_ADL_Main_Control_Destroy (data.hm_amd);
17263
17264 adl_close (data.hm_amd);
17265 data.hm_amd = NULL;
17266 }
17267 #endif
17268 }
17269 #endif // HAVE_HWMON
17270
17271 // free memory
17272
17273 local_free (masks);
17274
17275 local_free (dictstat_base);
17276
17277 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17278 {
17279 pot_t *pot_ptr = &pot[pot_pos];
17280
17281 hash_t *hash = &pot_ptr->hash;
17282
17283 local_free (hash->digest);
17284
17285 if (isSalted)
17286 {
17287 local_free (hash->salt);
17288 }
17289 }
17290
17291 local_free (pot);
17292
17293 local_free (all_kernel_rules_cnt);
17294 local_free (all_kernel_rules_buf);
17295
17296 local_free (wl_data->buf);
17297 local_free (wl_data);
17298
17299 local_free (bitmap_s1_a);
17300 local_free (bitmap_s1_b);
17301 local_free (bitmap_s1_c);
17302 local_free (bitmap_s1_d);
17303 local_free (bitmap_s2_a);
17304 local_free (bitmap_s2_b);
17305 local_free (bitmap_s2_c);
17306 local_free (bitmap_s2_d);
17307
17308 #ifdef HAVE_HWMON
17309 local_free (temp_retain_fanspeed_value);
17310 #ifdef HAVE_ADL
17311 local_free (od_clock_mem_status);
17312 local_free (od_power_control_status);
17313 #endif // ADL
17314 #endif
17315
17316 global_free (devices_param);
17317
17318 global_free (kernel_rules_buf);
17319
17320 global_free (root_css_buf);
17321 global_free (markov_css_buf);
17322
17323 global_free (digests_buf);
17324 global_free (digests_shown);
17325 global_free (digests_shown_tmp);
17326
17327 global_free (salts_buf);
17328 global_free (salts_shown);
17329
17330 global_free (esalts_buf);
17331
17332 global_free (words_progress_done);
17333 global_free (words_progress_rejected);
17334 global_free (words_progress_restored);
17335
17336 if (pot_fp) fclose (pot_fp);
17337
17338 if (data.devices_status == STATUS_QUIT) break;
17339 }
17340
17341 // destroy others mutex
17342
17343 hc_thread_mutex_delete (mux_dispatcher);
17344 hc_thread_mutex_delete (mux_counter);
17345 hc_thread_mutex_delete (mux_display);
17346 hc_thread_mutex_delete (mux_adl);
17347
17348 // free memory
17349
17350 local_free (eff_restore_file);
17351 local_free (new_restore_file);
17352
17353 local_free (rd);
17354
17355 // tuning db
17356
17357 tuning_db_destroy (tuning_db);
17358
17359 // loopback
17360
17361 local_free (loopback_file);
17362
17363 if (loopback == 1) unlink (loopback_file);
17364
17365 // induction directory
17366
17367 if (induction_dir == NULL)
17368 {
17369 if (attack_mode != ATTACK_MODE_BF)
17370 {
17371 if (rmdir (induction_directory) == -1)
17372 {
17373 if (errno == ENOENT)
17374 {
17375 // good, we can ignore
17376 }
17377 else if (errno == ENOTEMPTY)
17378 {
17379 // good, we can ignore
17380 }
17381 else
17382 {
17383 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17384
17385 return (-1);
17386 }
17387 }
17388
17389 local_free (induction_directory);
17390 }
17391 }
17392
17393 // outfile-check directory
17394
17395 if (outfile_check_dir == NULL)
17396 {
17397 if (rmdir (outfile_check_directory) == -1)
17398 {
17399 if (errno == ENOENT)
17400 {
17401 // good, we can ignore
17402 }
17403 else if (errno == ENOTEMPTY)
17404 {
17405 // good, we can ignore
17406 }
17407 else
17408 {
17409 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17410
17411 return (-1);
17412 }
17413 }
17414
17415 local_free (outfile_check_directory);
17416 }
17417
17418 time_t proc_stop;
17419
17420 time (&proc_stop);
17421
17422 logfile_top_uint (proc_start);
17423 logfile_top_uint (proc_stop);
17424
17425 logfile_top_msg ("STOP");
17426
17427 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17428 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17429
17430 if (data.ocl) ocl_close (data.ocl);
17431
17432 if (data.devices_status == STATUS_ABORTED) return 2;
17433 if (data.devices_status == STATUS_QUIT) return 2;
17434 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17435 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17436 if (data.devices_status == STATUS_CRACKED) return 0;
17437
17438 return -1;
17439 }
Hashcat additions to support pwdhash