projects / hashcat.git / blob
? search:


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