projects / hashcat.git / blob
? search:


0e1de0ab1c3bfa30247cdc15e7f376f066cfb25b
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 double hashes_all_ms = 0;
1164
1165 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark_automat ()
1612 {
1613 u64 speed_cnt[DEVICES_MAX] = { 0 };
1614 double speed_ms[DEVICES_MAX] = { 0 };
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 speed_cnt[device_id] = device_param->speed_cnt[0];
1623 speed_ms[device_id] = device_param->speed_ms[0];
1624 }
1625
1626 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 hashes_dev_ms[device_id] = 0;
1635
1636 if (speed_ms[device_id])
1637 {
1638 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1639 }
1640 }
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1649 }
1650 }
1651
1652 static void status_benchmark ()
1653 {
1654 if (data.devices_status == STATUS_INIT) return;
1655 if (data.devices_status == STATUS_STARTING) return;
1656 if (data.devices_status == STATUS_BYPASS) return;
1657
1658 if (data.status_automat == 1)
1659 {
1660 status_benchmark_automat ();
1661
1662 return;
1663 }
1664
1665 u64 speed_cnt[DEVICES_MAX] = { 0 };
1666 double speed_ms[DEVICES_MAX] = { 0 };
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 speed_cnt[device_id] = device_param->speed_cnt[0];
1675 speed_ms[device_id] = device_param->speed_ms[0];
1676 }
1677
1678 double hashes_all_ms = 0;
1679
1680 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 hashes_dev_ms[device_id] = 0;
1689
1690 if (speed_ms[device_id])
1691 {
1692 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1693
1694 hashes_all_ms += hashes_dev_ms[device_id];
1695 }
1696 }
1697
1698 /**
1699 * exec time
1700 */
1701
1702 double exec_all_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1711
1712 exec_all_ms[device_id] = exec_ms_avg;
1713 }
1714
1715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1716 {
1717 hc_device_param_t *device_param = &data.devices_param[device_id];
1718
1719 if (device_param->skipped) continue;
1720
1721 char display_dev_cur[16] = { 0 };
1722
1723 strncpy (display_dev_cur, "0.00", 4);
1724
1725 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1726
1727 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1728 }
1729
1730 char display_all_cur[16] = { 0 };
1731
1732 strncpy (display_all_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1735
1736 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1737 }
1738
1739 /**
1740 * hashcat -only- functions
1741 */
1742
1743 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1744 {
1745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1746 {
1747 if (attack_kern == ATTACK_KERN_STRAIGHT)
1748 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1749 else if (attack_kern == ATTACK_KERN_COMBI)
1750 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1751 else if (attack_kern == ATTACK_KERN_BF)
1752 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1753 }
1754 else
1755 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1756 }
1757
1758 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1759 {
1760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1761 {
1762 if (attack_kern == ATTACK_KERN_STRAIGHT)
1763 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 else if (attack_kern == ATTACK_KERN_COMBI)
1765 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1766 else if (attack_kern == ATTACK_KERN_BF)
1767 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1768 }
1769 else
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1772 }
1773 }
1774
1775 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1780 }
1781 else
1782 {
1783 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1784 }
1785 }
1786
1787 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1792 }
1793 else
1794 {
1795 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1796 }
1797 }
1798
1799 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1802 }
1803
1804 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1807 }
1808
1809 static uint convert_from_hex (char *line_buf, const uint line_len)
1810 {
1811 if (line_len & 1) return (line_len); // not in hex
1812
1813 if (data.hex_wordlist == 1)
1814 {
1815 uint i;
1816 uint j;
1817
1818 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1819 {
1820 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1821 }
1822
1823 memset (line_buf + i, 0, line_len - i);
1824
1825 return (i);
1826 }
1827 else if (line_len >= 6) // $HEX[] = 6
1828 {
1829 if (line_buf[0] != '$') return (line_len);
1830 if (line_buf[1] != 'H') return (line_len);
1831 if (line_buf[2] != 'E') return (line_len);
1832 if (line_buf[3] != 'X') return (line_len);
1833 if (line_buf[4] != '[') return (line_len);
1834 if (line_buf[line_len - 1] != ']') return (line_len);
1835
1836 uint i;
1837 uint j;
1838
1839 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1840 {
1841 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1842 }
1843
1844 memset (line_buf + i, 0, line_len - i);
1845
1846 return (i);
1847 }
1848
1849 return (line_len);
1850 }
1851
1852 static void clear_prompt ()
1853 {
1854 fputc ('\r', stdout);
1855
1856 for (size_t i = 0; i < strlen (PROMPT); i++)
1857 {
1858 fputc (' ', stdout);
1859 }
1860
1861 fputc ('\r', stdout);
1862
1863 fflush (stdout);
1864 }
1865
1866 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1867 {
1868 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1869 }
1870
1871 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1872 {
1873 char *outfile = data.outfile;
1874 uint quiet = data.quiet;
1875 FILE *pot_fp = data.pot_fp;
1876 uint loopback = data.loopback;
1877 uint debug_mode = data.debug_mode;
1878 char *debug_file = data.debug_file;
1879
1880 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1881 int debug_rule_len = 0; // -1 error
1882 uint debug_plain_len = 0;
1883
1884 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1885
1886 // hash
1887
1888 char out_buf[HCBUFSIZ] = { 0 };
1889
1890 ascii_digest (out_buf, salt_pos, digest_pos);
1891
1892 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1893
1894 // plain
1895
1896 plain_t plain;
1897
1898 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1899
1900 uint gidvid = plain.gidvid;
1901 uint il_pos = plain.il_pos;
1902
1903 u64 crackpos = device_param->words_off;
1904
1905 uint plain_buf[16] = { 0 };
1906
1907 u8 *plain_ptr = (u8 *) plain_buf;
1908 unsigned int plain_len = 0;
1909
1910 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 const uint off = device_param->innerloop_pos + il_pos;
1927
1928 if (debug_mode > 0)
1929 {
1930 debug_rule_len = 0;
1931
1932 // save rule
1933 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1936
1937 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1938 }
1939
1940 // save plain
1941 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1942 {
1943 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1944
1945 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1946
1947 debug_plain_len = plain_len;
1948 }
1949 }
1950
1951 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1952
1953 crackpos += gidvid;
1954 crackpos *= data.kernel_rules_cnt;
1955 crackpos += device_param->innerloop_pos + il_pos;
1956
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 else if (data.attack_mode == ATTACK_MODE_COMBI)
1960 {
1961 u64 gidd = gidvid;
1962 u64 gidm = 0;
1963
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidd, &pw);
1967
1968 for (int i = 0, j = gidm; i < 16; i++, j++)
1969 {
1970 plain_buf[i] = pw.i[j];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 u64 gidd = gidvid;
2023 u64 gidm = 0;
2024
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidd, &pw);
2028
2029 for (int i = 0, j = gidm; i < 16; i++, j++)
2030 {
2031 plain_buf[i] = pw.i[j];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 u64 gidd = gidvid;
2057 u64 gidm = 0;
2058
2059 pw_t pw;
2060
2061 gidd_to_pw_t (device_param, gidd, &pw);
2062
2063 for (int i = 0, j = gidm; i < 16; i++, j++)
2064 {
2065 plain_buf[i] = pw.i[j];
2066 }
2067
2068 plain_len = pw.pw_len;
2069
2070 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2071
2072 uint start = 0;
2073 uint stop = device_param->kernel_params_mp_buf32[4];
2074
2075 memmove (plain_ptr + stop, plain_ptr, plain_len);
2076
2077 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090
2091 if (data.attack_mode == ATTACK_MODE_BF)
2092 {
2093 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2094 {
2095 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2096 {
2097 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2098 {
2099 plain_len = plain_len - data.salts_buf[0].salt_len;
2100 }
2101 }
2102
2103 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2104 {
2105 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2106 {
2107 plain_ptr[j] = plain_ptr[i];
2108 }
2109
2110 plain_len = plain_len / 2;
2111 }
2112 }
2113 }
2114
2115 // if enabled, update also the potfile
2116
2117 if (pot_fp)
2118 {
2119 lock_file (pot_fp);
2120
2121 fprintf (pot_fp, "%s:", out_buf);
2122
2123 format_plain (pot_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', pot_fp);
2126
2127 fflush (pot_fp);
2128
2129 unlock_file (pot_fp);
2130 }
2131
2132 // outfile
2133
2134 FILE *out_fp = NULL;
2135
2136 if (outfile != NULL)
2137 {
2138 if ((out_fp = fopen (outfile, "ab")) == NULL)
2139 {
2140 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2141
2142 out_fp = stdout;
2143 }
2144 lock_file (out_fp);
2145 }
2146 else
2147 {
2148 out_fp = stdout;
2149
2150 if (quiet == 0) clear_prompt ();
2151 }
2152
2153 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2154
2155 if (outfile != NULL)
2156 {
2157 if (out_fp != stdout)
2158 {
2159 fclose (out_fp);
2160 }
2161 }
2162 else
2163 {
2164 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2165 {
2166 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2167 {
2168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2169 if (quiet == 0) fflush (stdout);
2170 }
2171 }
2172 }
2173
2174 // loopback
2175
2176 if (loopback)
2177 {
2178 char *loopback_file = data.loopback_file;
2179
2180 FILE *fb_fp = NULL;
2181
2182 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2183 {
2184 lock_file (fb_fp);
2185
2186 format_plain (fb_fp, plain_ptr, plain_len, 1);
2187
2188 fputc ('\n', fb_fp);
2189
2190 fclose (fb_fp);
2191 }
2192 }
2193
2194 // (rule) debug mode
2195
2196 // the next check implies that:
2197 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2198 // - debug_mode > 0
2199
2200 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2201 {
2202 if (debug_rule_len < 0) debug_rule_len = 0;
2203
2204 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2205
2206 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2207
2208 if ((quiet == 0) && (debug_file == NULL))
2209 {
2210 fprintf (stdout, "%s", PROMPT);
2211
2212 fflush (stdout);
2213 }
2214 }
2215 }
2216
2217 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2218 {
2219 salt_t *salt_buf = &data.salts_buf[salt_pos];
2220
2221 int found = 0;
2222
2223 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2224
2225 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2226
2227 if (found == 1)
2228 {
2229 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2230
2231 log_info_nn ("");
2232
2233 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2234
2235 uint cpt_cracked = 0;
2236
2237 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2238 {
2239 uint idx = salt_buf->digests_offset + digest_pos;
2240
2241 if (data.digests_shown_tmp[idx] == 0) continue;
2242
2243 if (data.digests_shown[idx] == 1) continue;
2244
2245 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2246 {
2247 data.digests_shown[idx] = 1;
2248
2249 data.digests_done++;
2250
2251 cpt_cracked++;
2252
2253 salt_buf->digests_done++;
2254
2255 if (salt_buf->digests_done == salt_buf->digests_cnt)
2256 {
2257 data.salts_shown[salt_pos] = 1;
2258
2259 data.salts_done++;
2260 }
2261 }
2262
2263 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2264
2265 check_hash (device_param, salt_pos, digest_pos);
2266 }
2267
2268 if (cpt_cracked > 0)
2269 {
2270 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2271 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2272
2273 data.cpt_pos++;
2274
2275 data.cpt_total += cpt_cracked;
2276
2277 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2278 }
2279
2280 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2281 {
2282 // we need to reset cracked state on the device
2283 // otherwise host thinks again and again the hash was cracked
2284 // and returns invalid password each time
2285
2286 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2287
2288 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2289 }
2290
2291 memset (device_param->result, 0, device_param->size_results);
2292
2293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2294 }
2295 }
2296
2297 static void save_hash ()
2298 {
2299 char *hashfile = data.hashfile;
2300
2301 char new_hashfile[256] = { 0 };
2302 char old_hashfile[256] = { 0 };
2303
2304 snprintf (new_hashfile, 255, "%s.new", hashfile);
2305 snprintf (old_hashfile, 255, "%s.old", hashfile);
2306
2307 unlink (new_hashfile);
2308
2309 char separator = data.separator;
2310
2311 FILE *fp = fopen (new_hashfile, "wb");
2312
2313 if (fp == NULL)
2314 {
2315 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2321 {
2322 if (data.salts_shown[salt_pos] == 1) continue;
2323
2324 salt_t *salt_buf = &data.salts_buf[salt_pos];
2325
2326 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2327 {
2328 uint idx = salt_buf->digests_offset + digest_pos;
2329
2330 if (data.digests_shown[idx] == 1) continue;
2331
2332 if (data.hash_mode != 2500)
2333 {
2334 char out_buf[HCBUFSIZ] = { 0 };
2335
2336 if (data.username == 1)
2337 {
2338 user_t *user = data.hash_info[idx]->user;
2339
2340 uint i;
2341
2342 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2343
2344 fputc (separator, fp);
2345 }
2346
2347 ascii_digest (out_buf, salt_pos, digest_pos);
2348
2349 fputs (out_buf, fp);
2350
2351 log_out (fp, "");
2352 }
2353 else
2354 {
2355 hccap_t hccap;
2356
2357 to_hccap_t (&hccap, salt_pos, digest_pos);
2358
2359 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2360 }
2361 }
2362 }
2363
2364 fflush (fp);
2365
2366 fclose (fp);
2367
2368 unlink (old_hashfile);
2369
2370 if (rename (hashfile, old_hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (hashfile);
2378
2379 if (rename (new_hashfile, hashfile) != 0)
2380 {
2381 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2382
2383 exit (-1);
2384 }
2385
2386 unlink (old_hashfile);
2387 }
2388
2389 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2390 {
2391 // function called only in case kernel_power_all > words_left
2392
2393 float kernel_power_div = (float) (total_left) / kernel_power_all;
2394
2395 kernel_power_div += kernel_power_div / 100;
2396
2397 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2398
2399 while (kernel_power_new < total_left)
2400 {
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404 }
2405
2406 if (data.quiet == 0)
2407 {
2408 clear_prompt ();
2409
2410 //log_info ("");
2411
2412 log_info ("INFO: approaching final keyspace, workload adjusted");
2413 log_info ("");
2414
2415 fprintf (stdout, "%s", PROMPT);
2416
2417 fflush (stdout);
2418 }
2419
2420 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2421
2422 return kernel_power_div;
2423 }
2424
2425 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2426 {
2427 uint num_elements = num;
2428
2429 device_param->kernel_params_buf32[30] = data.combs_mode;
2430 device_param->kernel_params_buf32[31] = num;
2431
2432 uint kernel_threads = device_param->kernel_threads;
2433
2434 while (num_elements % kernel_threads) num_elements++;
2435
2436 cl_kernel kernel = NULL;
2437
2438 switch (kern_run)
2439 {
2440 case KERN_RUN_1: kernel = device_param->kernel1; break;
2441 case KERN_RUN_12: kernel = device_param->kernel12; break;
2442 case KERN_RUN_2: kernel = device_param->kernel2; break;
2443 case KERN_RUN_23: kernel = device_param->kernel23; break;
2444 case KERN_RUN_3: kernel = device_param->kernel3; break;
2445 }
2446
2447 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2448 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2449 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2450 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2451 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2452 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2453 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2454 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2455 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2456 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2457 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2458
2459 cl_event event;
2460
2461 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2462 {
2463 const size_t global_work_size[3] = { num_elements, 32, 1 };
2464 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468 else
2469 {
2470 if (kern_run == KERN_RUN_2)
2471 {
2472 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2473 {
2474 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2475 }
2476 }
2477
2478 while (num_elements % kernel_threads) num_elements++;
2479
2480 const size_t global_work_size[3] = { num_elements, 1, 1 };
2481 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2482
2483 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2484 }
2485
2486 hc_clFlush (data.ocl, device_param->command_queue);
2487
2488 hc_clWaitForEvents (data.ocl, 1, &event);
2489
2490 if (event_update)
2491 {
2492 cl_ulong time_start;
2493 cl_ulong time_end;
2494
2495 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2496 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2497
2498 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2499
2500 uint exec_pos = device_param->exec_pos;
2501
2502 device_param->exec_ms[exec_pos] = exec_time;
2503
2504 exec_pos++;
2505
2506 if (exec_pos == EXEC_CACHE)
2507 {
2508 exec_pos = 0;
2509 }
2510
2511 device_param->exec_pos = exec_pos;
2512 }
2513
2514 hc_clReleaseEvent (data.ocl, event);
2515
2516 hc_clFinish (data.ocl, device_param->command_queue);
2517 }
2518
2519 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2520 {
2521 uint num_elements = num;
2522
2523 switch (kern_run)
2524 {
2525 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2526 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2527 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2528 }
2529
2530 // causes problems with special threads like in bcrypt
2531 // const uint kernel_threads = device_param->kernel_threads;
2532
2533 uint kernel_threads = device_param->kernel_threads;
2534
2535 while (num_elements % kernel_threads) num_elements++;
2536
2537 cl_kernel kernel = NULL;
2538
2539 switch (kern_run)
2540 {
2541 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2542 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2543 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2544 }
2545
2546 switch (kern_run)
2547 {
2548 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2549 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2550 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2551 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2552 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2553 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2554 break;
2555 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2556 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2557 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2558 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2559 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2560 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2561 break;
2562 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2563 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2564 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2565 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2566 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2567 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2568 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2569 break;
2570 }
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_tm (hc_device_param_t *device_param)
2583 {
2584 const uint num_elements = 1024; // fixed
2585
2586 uint kernel_threads = 32;
2587
2588 cl_kernel kernel = device_param->kernel_tm;
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2601 {
2602 uint num_elements = num;
2603
2604 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2605 device_param->kernel_params_amp_buf32[6] = num_elements;
2606
2607 // causes problems with special threads like in bcrypt
2608 // const uint kernel_threads = device_param->kernel_threads;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = device_param->kernel_amp;
2615
2616 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2617 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2618
2619 const size_t global_work_size[3] = { num_elements, 1, 1 };
2620 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2621
2622 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2623
2624 hc_clFlush (data.ocl, device_param->command_queue);
2625
2626 hc_clFinish (data.ocl, device_param->command_queue);
2627 }
2628
2629 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2630 {
2631 int rc = -1;
2632
2633 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2634 {
2635 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2636
2637 const cl_uchar zero = 0;
2638
2639 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2640 }
2641
2642 if (rc != 0)
2643 {
2644 // NOTE: clEnqueueFillBuffer () always fails with -59
2645 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2646 // How's that possible, OpenCL 1.2 support is advertised??
2647 // We need to workaround...
2648
2649 #define FILLSZ 0x100000
2650
2651 char *tmp = (char *) mymalloc (FILLSZ);
2652
2653 for (size_t i = 0; i < size; i += FILLSZ)
2654 {
2655 const size_t left = size - i;
2656
2657 const size_t fillsz = MIN (FILLSZ, left);
2658
2659 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2660 }
2661
2662 myfree (tmp);
2663 }
2664 }
2665
2666 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2667 {
2668 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2669 {
2670 if (attack_mode == ATTACK_MODE_BF)
2671 {
2672 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2673 {
2674 const uint size_tm = 32 * sizeof (bs_word_t);
2675
2676 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2677
2678 run_kernel_tm (device_param);
2679
2680 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2681 }
2682 }
2683
2684 if (highest_pw_len < 16)
2685 {
2686 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2687 }
2688 else if (highest_pw_len < 32)
2689 {
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691 }
2692 else
2693 {
2694 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2695 }
2696 }
2697 else
2698 {
2699 run_kernel_amp (device_param, pws_cnt);
2700
2701 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2702
2703 if (opts_type & OPTS_TYPE_HOOK12)
2704 {
2705 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2706 }
2707
2708 uint iter = salt_buf->salt_iter;
2709
2710 uint loop_step = device_param->kernel_loops;
2711
2712 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2713 {
2714 uint loop_left = iter - loop_pos;
2715
2716 loop_left = MIN (loop_left, loop_step);
2717
2718 device_param->kernel_params_buf32[25] = loop_pos;
2719 device_param->kernel_params_buf32[26] = loop_left;
2720
2721 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2722
2723 if (data.devices_status == STATUS_CRACKED) break;
2724 if (data.devices_status == STATUS_ABORTED) break;
2725 if (data.devices_status == STATUS_QUIT) break;
2726
2727 /**
2728 * speed
2729 */
2730
2731 const float iter_part = (float) (loop_pos + loop_left) / iter;
2732
2733 const u64 perf_sum_all = pws_cnt * iter_part;
2734
2735 double speed_ms;
2736
2737 hc_timer_get (device_param->timer_speed, speed_ms);
2738
2739 const u32 speed_pos = device_param->speed_pos;
2740
2741 device_param->speed_cnt[speed_pos] = perf_sum_all;
2742
2743 device_param->speed_ms[speed_pos] = speed_ms;
2744
2745 if (data.benchmark == 1)
2746 {
2747 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2748 }
2749 }
2750
2751 if (opts_type & OPTS_TYPE_HOOK23)
2752 {
2753 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2754
2755 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2756
2757 // do something with data
2758
2759 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2760 }
2761
2762 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2763 }
2764 }
2765
2766 static int run_rule_engine (const int rule_len, const char *rule_buf)
2767 {
2768 if (rule_len == 0)
2769 {
2770 return 0;
2771 }
2772 else if (rule_len == 1)
2773 {
2774 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2775 }
2776
2777 return 1;
2778 }
2779
2780 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2781 {
2782 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2783 {
2784 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2785 }
2786 else if (data.attack_kern == ATTACK_KERN_COMBI)
2787 {
2788 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2789 {
2790 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2791 {
2792 for (u32 i = 0; i < pws_cnt; i++)
2793 {
2794 const u32 pw_len = device_param->pws_buf[i].pw_len;
2795
2796 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2797
2798 ptr[pw_len] = 0x01;
2799 }
2800 }
2801 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x80;
2810 }
2811 }
2812 }
2813
2814 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2815 }
2816 else if (data.attack_kern == ATTACK_KERN_BF)
2817 {
2818 const u64 off = device_param->words_off;
2819
2820 device_param->kernel_params_mp_l_buf64[3] = off;
2821
2822 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2823 }
2824 }
2825
2826 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2827 {
2828 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2829
2830 device_param->kernel_params_buf32[25] = 0;
2831 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2832 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2833
2834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2835 {
2836 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2837 }
2838 else
2839 {
2840 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2841 }
2842
2843 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2844
2845 return exec_ms_prev;
2846 }
2847
2848 static void autotune (hc_device_param_t *device_param)
2849 {
2850 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2851
2852 const u32 kernel_accel_min = device_param->kernel_accel_min;
2853 const u32 kernel_accel_max = device_param->kernel_accel_max;
2854
2855 const u32 kernel_loops_min = device_param->kernel_loops_min;
2856 const u32 kernel_loops_max = device_param->kernel_loops_max;
2857
2858 u32 kernel_accel = kernel_accel_min;
2859 u32 kernel_loops = kernel_loops_min;
2860
2861 // init some fake words
2862
2863 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2864
2865 for (u32 i = 0; i < kernel_power_max; i++)
2866 {
2867 device_param->pws_buf[i].i[0] = i;
2868 device_param->pws_buf[i].i[1] = 0x01234567;
2869 device_param->pws_buf[i].pw_len = 7;
2870 }
2871
2872 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2873
2874 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2875 {
2876 run_kernel_amp (device_param, kernel_power_max);
2877 }
2878
2879 // begin actual testing
2880
2881 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2882
2883 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2884 {
2885 // we do this in case the user specified a fixed -u and -n on the commandline
2886 // so we have a cached kernel for benchmark
2887
2888 try_run (device_param, kernel_accel, kernel_loops);
2889 try_run (device_param, kernel_accel, kernel_loops);
2890 try_run (device_param, kernel_accel, kernel_loops);
2891 try_run (device_param, kernel_accel, kernel_loops);
2892 try_run (device_param, kernel_accel, kernel_loops);
2893 }
2894
2895 // first find out highest kernel-loops that stays below target_ms
2896
2897 #define STEPS_CNT 10
2898
2899 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2900 {
2901 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 for (int i = 0; i < STEPS_CNT; i++)
2911 {
2912 const u32 kernel_accel_try = 1 << i;
2913
2914 if (kernel_accel_try < kernel_accel_min) continue;
2915 if (kernel_accel_try > kernel_accel_max) break;
2916
2917 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2918
2919 if (exec_ms > target_ms) break;
2920
2921 exec_ms_final = exec_ms;
2922
2923 kernel_accel = kernel_accel_try;
2924 }
2925 }
2926
2927 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2928 // in such a case the above function would not create any change
2929 // we'll use the runtime to find out if we're allow to do last improvement
2930
2931 if (exec_ms_final > 0)
2932 {
2933 if ((exec_ms_final * 2) <= target_ms)
2934 {
2935 const double exec_left = target_ms / exec_ms_final;
2936
2937 const double accel_left = kernel_accel_max / kernel_accel;
2938
2939 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2940
2941 if (exec_accel_min >= 2)
2942 {
2943 kernel_accel *= exec_accel_min;
2944 }
2945 }
2946 }
2947
2948 // balancing the workload turns out to be very efficient
2949
2950 if (kernel_loops_min != kernel_loops_max)
2951 {
2952 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2953
2954 u32 sqrtv;
2955
2956 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2957 {
2958 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2959 }
2960
2961 const u32 kernel_accel_try = sqrtv;
2962 const u32 kernel_loops_try = sqrtv;
2963
2964 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2965 {
2966 kernel_accel = kernel_accel_try;
2967 kernel_loops = kernel_loops_try;
2968 }
2969 }
2970
2971 // reset fake words
2972
2973 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2974
2975 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2977
2978 // reset timer
2979
2980 device_param->exec_pos = 0;
2981
2982 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2983
2984 // store
2985
2986 device_param->kernel_accel = kernel_accel;
2987 device_param->kernel_loops = kernel_loops;
2988
2989 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2990
2991 device_param->kernel_power = kernel_power;
2992
2993 #ifdef DEBUG
2994
2995 if (data.quiet == 0)
2996 {
2997 clear_prompt ();
2998
2999 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3000 "Device #%u: autotuned kernel-loops to %u\n",
3001 device_param->device_id + 1, kernel_accel,
3002 device_param->device_id + 1, kernel_loops);
3003
3004 fprintf (stdout, "%s", PROMPT);
3005
3006 fflush (stdout);
3007 }
3008
3009 #endif
3010 }
3011
3012 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3013 {
3014 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3015
3016 // init speed timer
3017
3018 uint speed_pos = device_param->speed_pos;
3019
3020 #ifdef _POSIX
3021 if (device_param->timer_speed.tv_sec == 0)
3022 {
3023 hc_timer_set (&device_param->timer_speed);
3024 }
3025 #endif
3026
3027 #ifdef _WIN
3028 if (device_param->timer_speed.QuadPart == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 // find higest password length, this is for optimization stuff
3035
3036 uint highest_pw_len = 0;
3037
3038 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3039 {
3040 }
3041 else if (data.attack_kern == ATTACK_KERN_COMBI)
3042 {
3043 }
3044 else if (data.attack_kern == ATTACK_KERN_BF)
3045 {
3046 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3047 + device_param->kernel_params_mp_l_buf32[5];
3048 }
3049
3050 // iteration type
3051
3052 uint innerloop_step = 0;
3053 uint innerloop_cnt = 0;
3054
3055 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3056 else innerloop_step = 1;
3057
3058 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3059 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3060 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3061
3062 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3063
3064 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3065 {
3066 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3067
3068 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3069
3070 if (data.devices_status == STATUS_CRACKED) break;
3071 if (data.devices_status == STATUS_ABORTED) break;
3072 if (data.devices_status == STATUS_QUIT) break;
3073 if (data.devices_status == STATUS_BYPASS) break;
3074
3075 salt_t *salt_buf = &data.salts_buf[salt_pos];
3076
3077 device_param->kernel_params_buf32[24] = salt_pos;
3078 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3079 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3080
3081 FILE *combs_fp = device_param->combs_fp;
3082
3083 if (data.attack_mode == ATTACK_MODE_COMBI)
3084 {
3085 rewind (combs_fp);
3086 }
3087
3088 // innerloops
3089
3090 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3091 {
3092 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3093
3094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3095
3096 if (data.devices_status == STATUS_CRACKED) break;
3097 if (data.devices_status == STATUS_ABORTED) break;
3098 if (data.devices_status == STATUS_QUIT) break;
3099 if (data.devices_status == STATUS_BYPASS) break;
3100
3101 uint innerloop_left = innerloop_cnt - innerloop_pos;
3102
3103 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3104
3105 device_param->innerloop_pos = innerloop_pos;
3106 device_param->innerloop_left = innerloop_left;
3107
3108 device_param->kernel_params_buf32[27] = innerloop_left;
3109
3110 // i think we can get rid of this
3111 if (innerloop_left == 0)
3112 {
3113 puts ("bug, how should this happen????\n");
3114
3115 continue;
3116 }
3117
3118 if (data.salts_shown[salt_pos] == 1)
3119 {
3120 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3121
3122 continue;
3123 }
3124
3125 // initialize amplifiers
3126
3127 if (data.attack_mode == ATTACK_MODE_COMBI)
3128 {
3129 uint i = 0;
3130
3131 while (i < innerloop_left)
3132 {
3133 if (feof (combs_fp)) break;
3134
3135 int line_len = fgetl (combs_fp, line_buf);
3136
3137 if (line_len >= PW_MAX1) continue;
3138
3139 line_len = convert_from_hex (line_buf, line_len);
3140
3141 char *line_buf_new = line_buf;
3142
3143 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3144 {
3145 char rule_buf_out[BLOCK_SIZE] = { 0 };
3146
3147 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3148
3149 if (rule_len_out < 0)
3150 {
3151 data.words_progress_rejected[salt_pos] += pws_cnt;
3152
3153 continue;
3154 }
3155
3156 line_len = rule_len_out;
3157
3158 line_buf_new = rule_buf_out;
3159 }
3160
3161 line_len = MIN (line_len, PW_DICTMAX);
3162
3163 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3164
3165 memcpy (ptr, line_buf_new, line_len);
3166
3167 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3168
3169 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3170 {
3171 uppercase (ptr, line_len);
3172 }
3173
3174 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3175 {
3176 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3177 {
3178 ptr[line_len] = 0x80;
3179 }
3180
3181 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3182 {
3183 ptr[line_len] = 0x01;
3184 }
3185 }
3186
3187 device_param->combs_buf[i].pw_len = line_len;
3188
3189 i++;
3190 }
3191
3192 for (uint j = i; j < innerloop_left; j++)
3193 {
3194 device_param->combs_buf[j].i[0] = 0;
3195 device_param->combs_buf[j].i[1] = 0;
3196 device_param->combs_buf[j].i[2] = 0;
3197 device_param->combs_buf[j].i[3] = 0;
3198 device_param->combs_buf[j].i[4] = 0;
3199 device_param->combs_buf[j].i[5] = 0;
3200 device_param->combs_buf[j].i[6] = 0;
3201 device_param->combs_buf[j].i[7] = 0;
3202
3203 device_param->combs_buf[j].pw_len = 0;
3204 }
3205
3206 innerloop_left = i;
3207 }
3208 else if (data.attack_mode == ATTACK_MODE_BF)
3209 {
3210 u64 off = innerloop_pos;
3211
3212 device_param->kernel_params_mp_r_buf64[3] = off;
3213
3214 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3215 }
3216 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3217 {
3218 u64 off = innerloop_pos;
3219
3220 device_param->kernel_params_mp_buf64[3] = off;
3221
3222 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3223 }
3224 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3225 {
3226 u64 off = innerloop_pos;
3227
3228 device_param->kernel_params_mp_buf64[3] = off;
3229
3230 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3231 }
3232
3233 // copy amplifiers
3234
3235 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3236 {
3237 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3238 }
3239 else if (data.attack_mode == ATTACK_MODE_COMBI)
3240 {
3241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3246 }
3247 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3248 {
3249 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3254 }
3255
3256 if (data.benchmark == 1)
3257 {
3258 hc_timer_set (&device_param->timer_speed);
3259 }
3260
3261 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3262
3263 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3264
3265 if (data.devices_status == STATUS_CRACKED) break;
3266 if (data.devices_status == STATUS_ABORTED) break;
3267 if (data.devices_status == STATUS_QUIT) break;
3268
3269 /**
3270 * result
3271 */
3272
3273 hc_thread_mutex_lock (mux_display);
3274
3275 check_cracked (device_param, salt_pos);
3276
3277 hc_thread_mutex_unlock (mux_display);
3278
3279 /**
3280 * progress
3281 */
3282
3283 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3284
3285 hc_thread_mutex_lock (mux_counter);
3286
3287 data.words_progress_done[salt_pos] += perf_sum_all;
3288
3289 hc_thread_mutex_unlock (mux_counter);
3290
3291 /**
3292 * speed
3293 */
3294
3295 double speed_ms;
3296
3297 hc_timer_get (device_param->timer_speed, speed_ms);
3298
3299 hc_timer_set (&device_param->timer_speed);
3300
3301 hc_thread_mutex_lock (mux_display);
3302
3303 // current speed
3304
3305 device_param->speed_cnt[speed_pos] = perf_sum_all;
3306
3307 device_param->speed_ms[speed_pos] = speed_ms;
3308
3309 hc_thread_mutex_unlock (mux_display);
3310
3311 speed_pos++;
3312
3313 if (speed_pos == SPEED_CACHE)
3314 {
3315 speed_pos = 0;
3316 }
3317
3318 /**
3319 * benchmark
3320 */
3321
3322 if (data.benchmark == 1) break;
3323 }
3324 }
3325
3326 device_param->speed_pos = speed_pos;
3327
3328 myfree (line_buf);
3329 }
3330
3331 static void load_segment (wl_data_t *wl_data, FILE *fd)
3332 {
3333 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3334
3335 wl_data->pos = 0;
3336
3337 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3338
3339 wl_data->buf[wl_data->cnt] = 0;
3340
3341 if (wl_data->cnt == 0) return;
3342
3343 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3344
3345 while (!feof (fd))
3346 {
3347 if (wl_data->cnt == wl_data->avail)
3348 {
3349 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3350
3351 wl_data->avail += wl_data->incr;
3352 }
3353
3354 const int c = fgetc (fd);
3355
3356 if (c == EOF) break;
3357
3358 wl_data->buf[wl_data->cnt] = (char) c;
3359
3360 wl_data->cnt++;
3361
3362 if (c == '\n') break;
3363 }
3364
3365 // ensure stream ends with a newline
3366
3367 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3368 {
3369 wl_data->cnt++;
3370
3371 wl_data->buf[wl_data->cnt - 1] = '\n';
3372 }
3373
3374 return;
3375 }
3376
3377 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3378 {
3379 char *ptr = buf;
3380
3381 for (u32 i = 0; i < sz; i++, ptr++)
3382 {
3383 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3384
3385 if (i == 7)
3386 {
3387 *off = i;
3388 *len = i;
3389
3390 return;
3391 }
3392
3393 if (*ptr != '\n') continue;
3394
3395 *off = i + 1;
3396
3397 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3398
3399 *len = i;
3400
3401 return;
3402 }
3403
3404 *off = sz;
3405 *len = sz;
3406 }
3407
3408 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3409 {
3410 char *ptr = buf;
3411
3412 for (u32 i = 0; i < sz; i++, ptr++)
3413 {
3414 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3415
3416 if (*ptr != '\n') continue;
3417
3418 *off = i + 1;
3419
3420 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3421
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 *off = sz;
3428 *len = sz;
3429 }
3430
3431 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr != '\n') continue;
3438
3439 *off = i + 1;
3440
3441 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3442
3443 *len = i;
3444
3445 return;
3446 }
3447
3448 *off = sz;
3449 *len = sz;
3450 }
3451
3452 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3453 {
3454 while (wl_data->pos < wl_data->cnt)
3455 {
3456 uint off;
3457 uint len;
3458
3459 char *ptr = wl_data->buf + wl_data->pos;
3460
3461 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3462
3463 wl_data->pos += off;
3464
3465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3466 {
3467 char rule_buf_out[BLOCK_SIZE] = { 0 };
3468
3469 int rule_len_out = -1;
3470
3471 if (len < BLOCK_SIZE)
3472 {
3473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3474 }
3475
3476 if (rule_len_out < 0)
3477 {
3478 continue;
3479 }
3480
3481 if (rule_len_out > PW_MAX)
3482 {
3483 continue;
3484 }
3485 }
3486 else
3487 {
3488 if (len > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493
3494 *out_buf = ptr;
3495 *out_len = len;
3496
3497 return;
3498 }
3499
3500 if (feof (fd))
3501 {
3502 fprintf (stderr, "BUG feof()!!\n");
3503
3504 return;
3505 }
3506
3507 load_segment (wl_data, fd);
3508
3509 get_next_word (wl_data, fd, out_buf, out_len);
3510 }
3511
3512 #ifdef _POSIX
3513 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3514 #endif
3515
3516 #ifdef _WIN
3517 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3518 #endif
3519 {
3520 hc_signal (NULL);
3521
3522 dictstat_t d;
3523
3524 d.cnt = 0;
3525
3526 #ifdef _POSIX
3527 fstat (fileno (fd), &d.stat);
3528 #endif
3529
3530 #ifdef _WIN
3531 _fstat64 (fileno (fd), &d.stat);
3532 #endif
3533
3534 d.stat.st_mode = 0;
3535 d.stat.st_nlink = 0;
3536 d.stat.st_uid = 0;
3537 d.stat.st_gid = 0;
3538 d.stat.st_rdev = 0;
3539 d.stat.st_atime = 0;
3540
3541 #ifdef _POSIX
3542 d.stat.st_blksize = 0;
3543 d.stat.st_blocks = 0;
3544 #endif
3545
3546 if (d.stat.st_size == 0) return 0;
3547
3548 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3549
3550 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3551 {
3552 if (d_cache)
3553 {
3554 u64 cnt = d_cache->cnt;
3555
3556 u64 keyspace = cnt;
3557
3558 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3559 {
3560 keyspace *= data.kernel_rules_cnt;
3561 }
3562 else if (data.attack_kern == ATTACK_KERN_COMBI)
3563 {
3564 keyspace *= data.combs_cnt;
3565 }
3566
3567 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3568 if (data.quiet == 0) log_info ("");
3569
3570 hc_signal (sigHandler_default);
3571
3572 return (keyspace);
3573 }
3574 }
3575
3576 time_t now = 0;
3577 time_t prev = 0;
3578
3579 u64 comp = 0;
3580 u64 cnt = 0;
3581 u64 cnt2 = 0;
3582
3583 while (!feof (fd))
3584 {
3585 load_segment (wl_data, fd);
3586
3587 comp += wl_data->cnt;
3588
3589 u32 i = 0;
3590
3591 while (i < wl_data->cnt)
3592 {
3593 u32 len;
3594 u32 off;
3595
3596 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3597
3598 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3599 {
3600 char rule_buf_out[BLOCK_SIZE] = { 0 };
3601
3602 int rule_len_out = -1;
3603
3604 if (len < BLOCK_SIZE)
3605 {
3606 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3607 }
3608
3609 if (rule_len_out < 0)
3610 {
3611 len = PW_MAX1;
3612 }
3613 else
3614 {
3615 len = rule_len_out;
3616 }
3617 }
3618
3619 if (len < PW_MAX1)
3620 {
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 cnt += data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 cnt += data.combs_cnt;
3628 }
3629
3630 d.cnt++;
3631 }
3632
3633 i += off;
3634
3635 cnt2++;
3636 }
3637
3638 time (&now);
3639
3640 if ((now - prev) == 0) continue;
3641
3642 float percent = (float) comp / (float) d.stat.st_size;
3643
3644 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3645
3646 time (&prev);
3647 }
3648
3649 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3650 if (data.quiet == 0) log_info ("");
3651
3652 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3653
3654 hc_signal (sigHandler_default);
3655
3656 return (cnt);
3657 }
3658
3659 static void *thread_monitor (void *p)
3660 {
3661 uint runtime_check = 0;
3662 uint remove_check = 0;
3663 uint status_check = 0;
3664 uint restore_check = 0;
3665
3666 uint restore_left = data.restore_timer;
3667 uint remove_left = data.remove_timer;
3668 uint status_left = data.status_timer;
3669
3670 #ifdef HAVE_HWMON
3671 uint hwmon_check = 0;
3672
3673 // these variables are mainly used for fan control (AMD only)
3674
3675 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3676
3677 // temperature controller "loopback" values
3678
3679 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3680 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3681
3682 #ifdef HAVE_ADL
3683 int temp_threshold = 1; // degrees celcius
3684
3685 int fan_speed_min = 15; // in percentage
3686 int fan_speed_max = 100;
3687 #endif // HAVE_ADL
3688
3689 time_t last_temp_check_time;
3690 #endif // HAVE_HWMON
3691
3692 uint sleep_time = 1;
3693
3694 if (data.runtime)
3695 {
3696 runtime_check = 1;
3697 }
3698
3699 if (data.restore_timer)
3700 {
3701 restore_check = 1;
3702 }
3703
3704 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3705 {
3706 remove_check = 1;
3707 }
3708
3709 if (data.status == 1)
3710 {
3711 status_check = 1;
3712 }
3713
3714 #ifdef HAVE_HWMON
3715 if (data.gpu_temp_disable == 0)
3716 {
3717 time (&last_temp_check_time);
3718
3719 hwmon_check = 1;
3720 }
3721 #endif
3722
3723 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3724 {
3725 #ifdef HAVE_HWMON
3726 if (hwmon_check == 0)
3727 #endif
3728 return (p);
3729 }
3730
3731 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3732 {
3733 hc_sleep (sleep_time);
3734
3735 if (data.devices_status != STATUS_RUNNING) continue;
3736
3737 #ifdef HAVE_HWMON
3738 if (hwmon_check == 1)
3739 {
3740 hc_thread_mutex_lock (mux_adl);
3741
3742 time_t temp_check_time;
3743
3744 time (&temp_check_time);
3745
3746 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3747
3748 if (Ta == 0) Ta = 1;
3749
3750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3751 {
3752 hc_device_param_t *device_param = &data.devices_param[device_id];
3753
3754 if (device_param->skipped) continue;
3755
3756 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3757
3758 const int temperature = hm_get_temperature_with_device_id (device_id);
3759
3760 if (temperature > (int) data.gpu_temp_abort)
3761 {
3762 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3763
3764 if (data.devices_status != STATUS_QUIT) myabort ();
3765
3766 break;
3767 }
3768
3769 #ifdef HAVE_ADL
3770 const int gpu_temp_retain = data.gpu_temp_retain;
3771
3772 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3773 {
3774 if (data.hm_device[device_id].fan_supported == 1)
3775 {
3776 int temp_cur = temperature;
3777
3778 int temp_diff_new = gpu_temp_retain - temp_cur;
3779
3780 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3781
3782 // calculate Ta value (time difference in seconds between the last check and this check)
3783
3784 last_temp_check_time = temp_check_time;
3785
3786 float Kp = 1.8;
3787 float Ki = 0.005;
3788 float Kd = 6;
3789
3790 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3791
3792 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3793
3794 if (abs (fan_diff_required) >= temp_threshold)
3795 {
3796 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3797
3798 int fan_speed_level = fan_speed_cur;
3799
3800 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3801
3802 int fan_speed_new = fan_speed_level - fan_diff_required;
3803
3804 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3805 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3806
3807 if (fan_speed_new != fan_speed_cur)
3808 {
3809 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3810 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3811
3812 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3813 {
3814 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3815
3816 fan_speed_chgd[device_id] = 1;
3817 }
3818
3819 temp_diff_old[device_id] = temp_diff_new;
3820 }
3821 }
3822 }
3823 }
3824 #endif // HAVE_ADL
3825 }
3826
3827 hc_thread_mutex_unlock (mux_adl);
3828 }
3829 #endif // HAVE_HWMON
3830
3831 if (restore_check == 1)
3832 {
3833 restore_left--;
3834
3835 if (restore_left == 0)
3836 {
3837 if (data.restore_disable == 0) cycle_restore ();
3838
3839 restore_left = data.restore_timer;
3840 }
3841 }
3842
3843 if ((runtime_check == 1) && (data.runtime_start > 0))
3844 {
3845 time_t runtime_cur;
3846
3847 time (&runtime_cur);
3848
3849 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3850
3851 if (runtime_left <= 0)
3852 {
3853 if (data.benchmark == 0)
3854 {
3855 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3856 }
3857
3858 if (data.devices_status != STATUS_QUIT) myabort ();
3859 }
3860 }
3861
3862 if (remove_check == 1)
3863 {
3864 remove_left--;
3865
3866 if (remove_left == 0)
3867 {
3868 if (data.digests_saved != data.digests_done)
3869 {
3870 data.digests_saved = data.digests_done;
3871
3872 save_hash ();
3873 }
3874
3875 remove_left = data.remove_timer;
3876 }
3877 }
3878
3879 if (status_check == 1)
3880 {
3881 status_left--;
3882
3883 if (status_left == 0)
3884 {
3885 hc_thread_mutex_lock (mux_display);
3886
3887 if (data.quiet == 0) clear_prompt ();
3888
3889 if (data.quiet == 0) log_info ("");
3890
3891 status_display ();
3892
3893 if (data.quiet == 0) log_info ("");
3894
3895 hc_thread_mutex_unlock (mux_display);
3896
3897 status_left = data.status_timer;
3898 }
3899 }
3900 }
3901
3902 #ifdef HAVE_HWMON
3903 myfree (fan_speed_chgd);
3904
3905 myfree (temp_diff_old);
3906 myfree (temp_diff_sum);
3907 #endif
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static void *thread_outfile_remove (void *p)
3915 {
3916 // some hash-dependent constants
3917 char *outfile_dir = data.outfile_check_directory;
3918 uint dgst_size = data.dgst_size;
3919 uint isSalted = data.isSalted;
3920 uint esalt_size = data.esalt_size;
3921 uint hash_mode = data.hash_mode;
3922
3923 uint outfile_check_timer = data.outfile_check_timer;
3924
3925 char separator = data.separator;
3926
3927 // some hash-dependent functions
3928 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3929 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3930
3931 // buffers
3932 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3933
3934 hash_buf.digest = mymalloc (dgst_size);
3935
3936 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3937
3938 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3939
3940 uint digest_buf[64] = { 0 };
3941
3942 outfile_data_t *out_info = NULL;
3943
3944 char **out_files = NULL;
3945
3946 time_t folder_mtime = 0;
3947
3948 int out_cnt = 0;
3949
3950 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3951
3952 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3953 {
3954 hc_sleep (1);
3955
3956 if (data.devices_status != STATUS_RUNNING) continue;
3957
3958 check_left--;
3959
3960 if (check_left == 0)
3961 {
3962 struct stat outfile_check_stat;
3963
3964 if (stat (outfile_dir, &outfile_check_stat) == 0)
3965 {
3966 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3967
3968 if (is_dir == 1)
3969 {
3970 if (outfile_check_stat.st_mtime > folder_mtime)
3971 {
3972 char **out_files_new = scan_directory (outfile_dir);
3973
3974 int out_cnt_new = count_dictionaries (out_files_new);
3975
3976 outfile_data_t *out_info_new = NULL;
3977
3978 if (out_cnt_new > 0)
3979 {
3980 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3981
3982 for (int i = 0; i < out_cnt_new; i++)
3983 {
3984 out_info_new[i].file_name = out_files_new[i];
3985
3986 // check if there are files that we have seen/checked before (and not changed)
3987
3988 for (int j = 0; j < out_cnt; j++)
3989 {
3990 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3991 {
3992 struct stat outfile_stat;
3993
3994 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3995 {
3996 if (outfile_stat.st_ctime == out_info[j].ctime)
3997 {
3998 out_info_new[i].ctime = out_info[j].ctime;
3999 out_info_new[i].seek = out_info[j].seek;
4000 }
4001 }
4002 }
4003 }
4004 }
4005 }
4006
4007 local_free (out_info);
4008 local_free (out_files);
4009
4010 out_files = out_files_new;
4011 out_cnt = out_cnt_new;
4012 out_info = out_info_new;
4013
4014 folder_mtime = outfile_check_stat.st_mtime;
4015 }
4016
4017 for (int j = 0; j < out_cnt; j++)
4018 {
4019 FILE *fp = fopen (out_info[j].file_name, "rb");
4020
4021 if (fp != NULL)
4022 {
4023 //hc_thread_mutex_lock (mux_display);
4024
4025 #ifdef _POSIX
4026 struct stat outfile_stat;
4027
4028 fstat (fileno (fp), &outfile_stat);
4029 #endif
4030
4031 #ifdef _WIN
4032 struct stat64 outfile_stat;
4033
4034 _fstat64 (fileno (fp), &outfile_stat);
4035 #endif
4036
4037 if (outfile_stat.st_ctime > out_info[j].ctime)
4038 {
4039 out_info[j].ctime = outfile_stat.st_ctime;
4040 out_info[j].seek = 0;
4041 }
4042
4043 fseek (fp, out_info[j].seek, SEEK_SET);
4044
4045 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4046
4047 while (!feof (fp))
4048 {
4049 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4050
4051 if (ptr == NULL) break;
4052
4053 int line_len = strlen (line_buf);
4054
4055 if (line_len <= 0) continue;
4056
4057 int iter = MAX_CUT_TRIES;
4058
4059 for (uint i = line_len - 1; i && iter; i--, line_len--)
4060 {
4061 if (line_buf[i] != separator) continue;
4062
4063 int parser_status = PARSER_OK;
4064
4065 if ((hash_mode != 2500) && (hash_mode != 6800))
4066 {
4067 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4068 }
4069
4070 uint found = 0;
4071
4072 if (parser_status == PARSER_OK)
4073 {
4074 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4075 {
4076 if (data.salts_shown[salt_pos] == 1) continue;
4077
4078 salt_t *salt_buf = &data.salts_buf[salt_pos];
4079
4080 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4081 {
4082 uint idx = salt_buf->digests_offset + digest_pos;
4083
4084 if (data.digests_shown[idx] == 1) continue;
4085
4086 uint cracked = 0;
4087
4088 if (hash_mode == 6800)
4089 {
4090 if (i == salt_buf->salt_len)
4091 {
4092 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4093 }
4094 }
4095 else if (hash_mode == 2500)
4096 {
4097 // BSSID : MAC1 : MAC2 (:plain)
4098 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4099 {
4100 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4101
4102 if (!cracked) continue;
4103
4104 // now compare MAC1 and MAC2 too, since we have this additional info
4105 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4106 char *mac2_pos = mac1_pos + 12 + 1;
4107
4108 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4109 wpa_t *wpa = &wpas[salt_pos];
4110
4111 // compare hex string(s) vs binary MAC address(es)
4112
4113 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4114 {
4115 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4116 {
4117 cracked = 0;
4118
4119 break;
4120 }
4121 }
4122
4123 // early skip ;)
4124 if (!cracked) continue;
4125
4126 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4127 {
4128 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4129 {
4130 cracked = 0;
4131
4132 break;
4133 }
4134 }
4135 }
4136 }
4137 else
4138 {
4139 char *digests_buf_ptr = (char *) data.digests_buf;
4140
4141 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4142
4143 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4144 }
4145
4146 if (cracked == 1)
4147 {
4148 found = 1;
4149
4150 data.digests_shown[idx] = 1;
4151
4152 data.digests_done++;
4153
4154 salt_buf->digests_done++;
4155
4156 if (salt_buf->digests_done == salt_buf->digests_cnt)
4157 {
4158 data.salts_shown[salt_pos] = 1;
4159
4160 data.salts_done++;
4161
4162 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4163 }
4164 }
4165 }
4166
4167 if (data.devices_status == STATUS_CRACKED) break;
4168 }
4169 }
4170
4171 if (found) break;
4172
4173 if (data.devices_status == STATUS_CRACKED) break;
4174
4175 iter--;
4176 }
4177
4178 if (data.devices_status == STATUS_CRACKED) break;
4179 }
4180
4181 myfree (line_buf);
4182
4183 out_info[j].seek = ftell (fp);
4184
4185 //hc_thread_mutex_unlock (mux_display);
4186
4187 fclose (fp);
4188 }
4189 }
4190 }
4191 }
4192
4193 check_left = outfile_check_timer;
4194 }
4195 }
4196
4197 if (esalt_size) local_free (hash_buf.esalt);
4198
4199 if (isSalted) local_free (hash_buf.salt);
4200
4201 local_free (hash_buf.digest);
4202
4203 local_free (out_info);
4204
4205 local_free (out_files);
4206
4207 p = NULL;
4208
4209 return (p);
4210 }
4211
4212 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4213 {
4214 if (device_param->pws_cnt < device_param->kernel_power)
4215 {
4216 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4217
4218 u8 *ptr = (u8 *) pw->i;
4219
4220 memcpy (ptr, pw_buf, pw_len);
4221
4222 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4223
4224 pw->pw_len = pw_len;
4225
4226 device_param->pws_cnt++;
4227 }
4228 else
4229 {
4230 fprintf (stderr, "BUG pw_add()!!\n");
4231
4232 return;
4233 }
4234 }
4235
4236 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4237 {
4238 hc_thread_mutex_lock (mux_dispatcher);
4239
4240 const u64 words_cur = data.words_cur;
4241 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4242
4243 device_param->words_off = words_cur;
4244
4245 const u64 words_left = words_base - words_cur;
4246
4247 if (allow_div)
4248 {
4249 if (data.kernel_power_all > words_left)
4250 {
4251 if (data.kernel_power_div == 0)
4252 {
4253 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4254 }
4255 }
4256
4257 if (data.kernel_power_div)
4258 {
4259 if (device_param->kernel_power == device_param->kernel_power_user)
4260 {
4261 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4262
4263 if (kernel_power_new < device_param->kernel_power)
4264 {
4265 device_param->kernel_power = kernel_power_new;
4266 }
4267 }
4268 }
4269 }
4270
4271 const uint kernel_power = device_param->kernel_power;
4272
4273 uint work = MIN (words_left, kernel_power);
4274
4275 work = MIN (work, max);
4276
4277 data.words_cur += work;
4278
4279 hc_thread_mutex_unlock (mux_dispatcher);
4280
4281 return work;
4282 }
4283
4284 static void *thread_calc_stdin (void *p)
4285 {
4286 hc_device_param_t *device_param = (hc_device_param_t *) p;
4287
4288 if (device_param->skipped) return NULL;
4289
4290 autotune (device_param);
4291
4292 char *buf = (char *) mymalloc (HCBUFSIZ);
4293
4294 const uint attack_kern = data.attack_kern;
4295
4296 const uint kernel_power = device_param->kernel_power;
4297
4298 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 if (feof (stdin) != 0)
4303 {
4304 hc_thread_mutex_unlock (mux_dispatcher);
4305
4306 break;
4307 }
4308
4309 uint words_cur = 0;
4310
4311 while (words_cur < kernel_power)
4312 {
4313 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4314
4315 if (line_buf == NULL) break;
4316
4317 uint line_len = in_superchop (line_buf);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (line_len > PW_MAX)
4341 {
4342 continue;
4343 }
4344
4345 if (attack_kern == ATTACK_KERN_STRAIGHT)
4346 {
4347 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4348 {
4349 hc_thread_mutex_lock (mux_counter);
4350
4351 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4352 {
4353 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4354 }
4355
4356 hc_thread_mutex_unlock (mux_counter);
4357
4358 continue;
4359 }
4360 }
4361 else if (attack_kern == ATTACK_KERN_COMBI)
4362 {
4363 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4364 // since we still need to combine the plains
4365
4366 if (line_len > data.pw_max)
4367 {
4368 hc_thread_mutex_lock (mux_counter);
4369
4370 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4371 {
4372 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4373 }
4374
4375 hc_thread_mutex_unlock (mux_counter);
4376
4377 continue;
4378 }
4379 }
4380
4381 pw_add (device_param, (u8 *) line_buf, line_len);
4382
4383 words_cur++;
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // flush
4399
4400 const uint pws_cnt = device_param->pws_cnt;
4401
4402 if (pws_cnt)
4403 {
4404 run_copy (device_param, pws_cnt);
4405
4406 run_cracker (device_param, pws_cnt);
4407
4408 device_param->pws_cnt = 0;
4409
4410 if (attack_kern == ATTACK_KERN_STRAIGHT)
4411 {
4412 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4417 }
4418 }
4419 }
4420
4421 device_param->kernel_accel = 0;
4422 device_param->kernel_loops = 0;
4423
4424 myfree (buf);
4425
4426 return NULL;
4427 }
4428
4429 static void *thread_calc (void *p)
4430 {
4431 hc_device_param_t *device_param = (hc_device_param_t *) p;
4432
4433 if (device_param->skipped) return NULL;
4434
4435 autotune (device_param);
4436
4437 const uint attack_mode = data.attack_mode;
4438 const uint attack_kern = data.attack_kern;
4439
4440 if (attack_mode == ATTACK_MODE_BF)
4441 {
4442 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4443 {
4444 const uint work = get_work (device_param, -1, true);
4445
4446 if (work == 0) break;
4447
4448 const u64 words_off = device_param->words_off;
4449 const u64 words_fin = words_off + work;
4450
4451 const uint pws_cnt = work;
4452
4453 device_param->pws_cnt = pws_cnt;
4454
4455 if (pws_cnt)
4456 {
4457 run_copy (device_param, pws_cnt);
4458
4459 run_cracker (device_param, pws_cnt);
4460
4461 device_param->pws_cnt = 0;
4462
4463 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4464 }
4465
4466 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 if (data.benchmark == 1) break;
4474
4475 device_param->words_done = words_fin;
4476 }
4477 }
4478 else
4479 {
4480 const uint segment_size = data.segment_size;
4481
4482 char *dictfile = data.dictfile;
4483
4484 if (attack_mode == ATTACK_MODE_COMBI)
4485 {
4486 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4487 {
4488 dictfile = data.dictfile2;
4489 }
4490 }
4491
4492 FILE *fd = fopen (dictfile, "rb");
4493
4494 if (fd == NULL)
4495 {
4496 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4497
4498 return NULL;
4499 }
4500
4501 if (attack_mode == ATTACK_MODE_COMBI)
4502 {
4503 const uint combs_mode = data.combs_mode;
4504
4505 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4506 {
4507 const char *dictfilec = data.dictfile2;
4508
4509 FILE *combs_fp = fopen (dictfilec, "rb");
4510
4511 if (combs_fp == NULL)
4512 {
4513 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4514
4515 fclose (fd);
4516
4517 return NULL;
4518 }
4519
4520 device_param->combs_fp = combs_fp;
4521 }
4522 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4523 {
4524 const char *dictfilec = data.dictfile;
4525
4526 FILE *combs_fp = fopen (dictfilec, "rb");
4527
4528 if (combs_fp == NULL)
4529 {
4530 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4531
4532 fclose (fd);
4533
4534 return NULL;
4535 }
4536
4537 device_param->combs_fp = combs_fp;
4538 }
4539 }
4540
4541 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4542
4543 wl_data->buf = (char *) mymalloc (segment_size);
4544 wl_data->avail = segment_size;
4545 wl_data->incr = segment_size;
4546 wl_data->cnt = 0;
4547 wl_data->pos = 0;
4548
4549 u64 words_cur = 0;
4550
4551 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4552 {
4553 u64 words_off = 0;
4554 u64 words_fin = 0;
4555
4556 bool allow_div = true;
4557
4558 u64 max = -1;
4559
4560 while (max)
4561 {
4562 const uint work = get_work (device_param, max, allow_div);
4563
4564 allow_div = false;
4565
4566 if (work == 0) break;
4567
4568 words_off = device_param->words_off;
4569 words_fin = words_off + work;
4570
4571 char *line_buf;
4572 uint line_len;
4573
4574 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4575
4576 max = 0;
4577
4578 for ( ; words_cur < words_fin; words_cur++)
4579 {
4580 get_next_word (wl_data, fd, &line_buf, &line_len);
4581
4582 line_len = convert_from_hex (line_buf, line_len);
4583
4584 // post-process rule engine
4585
4586 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4587 {
4588 char rule_buf_out[BLOCK_SIZE] = { 0 };
4589
4590 int rule_len_out = -1;
4591
4592 if (line_len < BLOCK_SIZE)
4593 {
4594 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4595 }
4596
4597 if (rule_len_out < 0) continue;
4598
4599 line_buf = rule_buf_out;
4600 line_len = rule_len_out;
4601 }
4602
4603 if (attack_kern == ATTACK_KERN_STRAIGHT)
4604 {
4605 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4606 {
4607 max++;
4608
4609 hc_thread_mutex_lock (mux_counter);
4610
4611 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4612 {
4613 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4614 }
4615
4616 hc_thread_mutex_unlock (mux_counter);
4617
4618 continue;
4619 }
4620 }
4621 else if (attack_kern == ATTACK_KERN_COMBI)
4622 {
4623 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4624 // since we still need to combine the plains
4625
4626 if (line_len > data.pw_max)
4627 {
4628 max++;
4629
4630 hc_thread_mutex_lock (mux_counter);
4631
4632 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4633 {
4634 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4635 }
4636
4637 hc_thread_mutex_unlock (mux_counter);
4638
4639 continue;
4640 }
4641 }
4642
4643 pw_add (device_param, (u8 *) line_buf, line_len);
4644
4645 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4646
4647 if (data.devices_status == STATUS_CRACKED) break;
4648 if (data.devices_status == STATUS_ABORTED) break;
4649 if (data.devices_status == STATUS_QUIT) break;
4650 if (data.devices_status == STATUS_BYPASS) break;
4651 }
4652
4653 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4654
4655 if (data.devices_status == STATUS_CRACKED) break;
4656 if (data.devices_status == STATUS_ABORTED) break;
4657 if (data.devices_status == STATUS_QUIT) break;
4658 if (data.devices_status == STATUS_BYPASS) break;
4659 }
4660
4661 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 if (data.devices_status == STATUS_ABORTED) break;
4665 if (data.devices_status == STATUS_QUIT) break;
4666 if (data.devices_status == STATUS_BYPASS) break;
4667
4668 //
4669 // flush
4670 //
4671
4672 const uint pws_cnt = device_param->pws_cnt;
4673
4674 if (pws_cnt)
4675 {
4676 run_copy (device_param, pws_cnt);
4677
4678 run_cracker (device_param, pws_cnt);
4679
4680 device_param->pws_cnt = 0;
4681
4682 if (attack_kern == ATTACK_KERN_STRAIGHT)
4683 {
4684 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4685 }
4686 else if (attack_kern == ATTACK_KERN_COMBI)
4687 {
4688 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4689 }
4690 }
4691
4692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4693
4694 if (data.devices_status == STATUS_CRACKED) break;
4695 if (data.devices_status == STATUS_ABORTED) break;
4696 if (data.devices_status == STATUS_QUIT) break;
4697 if (data.devices_status == STATUS_BYPASS) break;
4698
4699 if (words_fin == 0) break;
4700
4701 device_param->words_done = words_fin;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 fclose (device_param->combs_fp);
4707 }
4708
4709 free (wl_data->buf);
4710 free (wl_data);
4711
4712 fclose (fd);
4713 }
4714
4715 device_param->kernel_accel = 0;
4716 device_param->kernel_loops = 0;
4717
4718 return NULL;
4719 }
4720
4721 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4722 {
4723 if (!device_param)
4724 {
4725 log_error ("ERROR: %s : Invalid argument", __func__);
4726
4727 exit (-1);
4728 }
4729
4730 salt_t *salt_buf = &data.salts_buf[salt_pos];
4731
4732 device_param->kernel_params_buf32[24] = salt_pos;
4733 device_param->kernel_params_buf32[27] = 1;
4734 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4735 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4736 device_param->kernel_params_buf32[30] = 0;
4737 device_param->kernel_params_buf32[31] = 1;
4738
4739 char *dictfile_old = data.dictfile;
4740
4741 const char *weak_hash_check = "weak-hash-check";
4742
4743 data.dictfile = (char *) weak_hash_check;
4744
4745 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4746
4747 data.kernel_rules_buf[0].cmds[0] = 0;
4748
4749 /**
4750 * run the kernel
4751 */
4752
4753 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4754 {
4755 run_kernel (KERN_RUN_1, device_param, 1, false);
4756 }
4757 else
4758 {
4759 run_kernel (KERN_RUN_1, device_param, 1, false);
4760
4761 uint loop_step = 16;
4762
4763 const uint iter = salt_buf->salt_iter;
4764
4765 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4766 {
4767 uint loop_left = iter - loop_pos;
4768
4769 loop_left = MIN (loop_left, loop_step);
4770
4771 device_param->kernel_params_buf32[25] = loop_pos;
4772 device_param->kernel_params_buf32[26] = loop_left;
4773
4774 run_kernel (KERN_RUN_2, device_param, 1, false);
4775 }
4776
4777 run_kernel (KERN_RUN_3, device_param, 1, false);
4778 }
4779
4780 /**
4781 * result
4782 */
4783
4784 check_cracked (device_param, salt_pos);
4785
4786 /**
4787 * cleanup
4788 */
4789
4790 device_param->kernel_params_buf32[24] = 0;
4791 device_param->kernel_params_buf32[25] = 0;
4792 device_param->kernel_params_buf32[26] = 0;
4793 device_param->kernel_params_buf32[27] = 0;
4794 device_param->kernel_params_buf32[28] = 0;
4795 device_param->kernel_params_buf32[29] = 0;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 0;
4798
4799 data.dictfile = dictfile_old;
4800
4801 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4802 }
4803
4804 // hlfmt hashcat
4805
4806 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4807 {
4808 if (data.username == 0)
4809 {
4810 *hashbuf_pos = line_buf;
4811 *hashbuf_len = line_len;
4812 }
4813 else
4814 {
4815 char *pos = line_buf;
4816 int len = line_len;
4817
4818 for (int i = 0; i < line_len; i++, pos++, len--)
4819 {
4820 if (line_buf[i] == data.separator)
4821 {
4822 pos++;
4823
4824 len--;
4825
4826 break;
4827 }
4828 }
4829
4830 *hashbuf_pos = pos;
4831 *hashbuf_len = len;
4832 }
4833 }
4834
4835 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4836 {
4837 char *pos = NULL;
4838 int len = 0;
4839
4840 int sep_cnt = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == data.separator)
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 0)
4852 {
4853 if (pos == NULL) pos = line_buf + i;
4854
4855 len++;
4856 }
4857 }
4858
4859 *userbuf_pos = pos;
4860 *userbuf_len = len;
4861 }
4862
4863 // hlfmt pwdump
4864
4865 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4866 {
4867 int sep_cnt = 0;
4868
4869 int sep2_len = 0;
4870 int sep3_len = 0;
4871
4872 for (int i = 0; i < line_len; i++)
4873 {
4874 if (line_buf[i] == ':')
4875 {
4876 sep_cnt++;
4877
4878 continue;
4879 }
4880
4881 if (sep_cnt == 2) sep2_len++;
4882 if (sep_cnt == 3) sep3_len++;
4883 }
4884
4885 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4886
4887 return 0;
4888 }
4889
4890 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4891 {
4892 char *pos = NULL;
4893 int len = 0;
4894
4895 int sep_cnt = 0;
4896
4897 for (int i = 0; i < line_len; i++)
4898 {
4899 if (line_buf[i] == ':')
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (data.hash_mode == 1000)
4907 {
4908 if (sep_cnt == 3)
4909 {
4910 if (pos == NULL) pos = line_buf + i;
4911
4912 len++;
4913 }
4914 }
4915 else if (data.hash_mode == 3000)
4916 {
4917 if (sep_cnt == 2)
4918 {
4919 if (pos == NULL) pos = line_buf + i;
4920
4921 len++;
4922 }
4923 }
4924 }
4925
4926 *hashbuf_pos = pos;
4927 *hashbuf_len = len;
4928 }
4929
4930 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4931 {
4932 char *pos = NULL;
4933 int len = 0;
4934
4935 int sep_cnt = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 0)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953
4954 *userbuf_pos = pos;
4955 *userbuf_len = len;
4956 }
4957
4958 // hlfmt passwd
4959
4960 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4961 {
4962 int sep_cnt = 0;
4963
4964 char sep5_first = 0;
4965 char sep6_first = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4977 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4978 }
4979
4980 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4981
4982 return 0;
4983 }
4984
4985 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4986 {
4987 char *pos = NULL;
4988 int len = 0;
4989
4990 int sep_cnt = 0;
4991
4992 for (int i = 0; i < line_len; i++)
4993 {
4994 if (line_buf[i] == ':')
4995 {
4996 sep_cnt++;
4997
4998 continue;
4999 }
5000
5001 if (sep_cnt == 1)
5002 {
5003 if (pos == NULL) pos = line_buf + i;
5004
5005 len++;
5006 }
5007 }
5008
5009 *hashbuf_pos = pos;
5010 *hashbuf_len = len;
5011 }
5012
5013 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5014 {
5015 char *pos = NULL;
5016 int len = 0;
5017
5018 int sep_cnt = 0;
5019
5020 for (int i = 0; i < line_len; i++)
5021 {
5022 if (line_buf[i] == ':')
5023 {
5024 sep_cnt++;
5025
5026 continue;
5027 }
5028
5029 if (sep_cnt == 0)
5030 {
5031 if (pos == NULL) pos = line_buf + i;
5032
5033 len++;
5034 }
5035 }
5036
5037 *userbuf_pos = pos;
5038 *userbuf_len = len;
5039 }
5040
5041 // hlfmt shadow
5042
5043 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5044 {
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == ':') sep_cnt++;
5050 }
5051
5052 if (sep_cnt == 8) return 1;
5053
5054 return 0;
5055 }
5056
5057 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5058 {
5059 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5060 }
5061
5062 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5065 }
5066
5067 // hlfmt main
5068
5069 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5070 {
5071 switch (hashfile_format)
5072 {
5073 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5074 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5075 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5076 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5077 }
5078 }
5079
5080 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5081 {
5082 switch (hashfile_format)
5083 {
5084 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5085 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5086 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5087 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5088 }
5089 }
5090
5091 char *strhlfmt (const uint hashfile_format)
5092 {
5093 switch (hashfile_format)
5094 {
5095 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5096 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5097 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5098 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5099 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5100 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5101 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5102 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5103 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5104 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5105 }
5106
5107 return ((char *) "Unknown");
5108 }
5109
5110 static uint hlfmt_detect (FILE *fp, uint max_check)
5111 {
5112 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5113
5114 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5115 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5116
5117 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5118
5119 uint num_check = 0;
5120
5121 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5122
5123 while (!feof (fp))
5124 {
5125 int line_len = fgetl (fp, line_buf);
5126
5127 if (line_len == 0) continue;
5128
5129 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5130 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5131 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5132
5133 if (num_check == max_check) break;
5134
5135 num_check++;
5136 }
5137
5138 myfree (line_buf);
5139
5140 uint hashlist_format = HLFMT_HASHCAT;
5141
5142 for (int i = 1; i < HLFMTS_CNT; i++)
5143 {
5144 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5145
5146 hashlist_format = i;
5147 }
5148
5149 free (formats_cnt);
5150
5151 return hashlist_format;
5152 }
5153
5154 /**
5155 * some further helper function
5156 */
5157
5158 // wrapper around mymalloc for ADL
5159
5160 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5161 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5162 {
5163 return mymalloc (iSize);
5164 }
5165 #endif
5166
5167 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5168 {
5169 u64 collisions = 0;
5170
5171 const uint dgst_pos0 = data.dgst_pos0;
5172 const uint dgst_pos1 = data.dgst_pos1;
5173 const uint dgst_pos2 = data.dgst_pos2;
5174 const uint dgst_pos3 = data.dgst_pos3;
5175
5176 memset (bitmap_a, 0, bitmap_size);
5177 memset (bitmap_b, 0, bitmap_size);
5178 memset (bitmap_c, 0, bitmap_size);
5179 memset (bitmap_d, 0, bitmap_size);
5180
5181 for (uint i = 0; i < digests_cnt; i++)
5182 {
5183 uint *digest_ptr = (uint *) digests_buf_ptr;
5184
5185 digests_buf_ptr += dgst_size;
5186
5187 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5188 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5189 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5190 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5191
5192 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5193 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5194 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5195 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5196
5197 if (bitmap_a[idx0] & val0) collisions++;
5198 if (bitmap_b[idx1] & val1) collisions++;
5199 if (bitmap_c[idx2] & val2) collisions++;
5200 if (bitmap_d[idx3] & val3) collisions++;
5201
5202 bitmap_a[idx0] |= val0;
5203 bitmap_b[idx1] |= val1;
5204 bitmap_c[idx2] |= val2;
5205 bitmap_d[idx3] |= val3;
5206
5207 if (collisions >= collisions_max) return 0x7fffffff;
5208 }
5209
5210 return collisions;
5211 }
5212
5213 /**
5214 * main
5215 */
5216
5217 int main (int argc, char **argv)
5218 {
5219 /**
5220 * To help users a bit
5221 */
5222
5223 char *compute = getenv ("COMPUTE");
5224
5225 if (compute)
5226 {
5227 static char display[100];
5228
5229 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5230
5231 putenv (display);
5232 }
5233 else
5234 {
5235 if (getenv ("DISPLAY") == NULL)
5236 putenv ((char *) "DISPLAY=:0");
5237 }
5238
5239 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5240 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5241
5242 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5243 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5244
5245 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5246 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5247
5248 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5249 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5250
5251 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5252 putenv ((char *) "POCL_KERNEL_CACHE=0");
5253
5254 /**
5255 * Real init
5256 */
5257
5258 memset (&data, 0, sizeof (hc_global_data_t));
5259
5260 time_t proc_start;
5261
5262 time (&proc_start);
5263
5264 data.proc_start = proc_start;
5265
5266 int myargc = argc;
5267 char **myargv = argv;
5268
5269 hc_thread_mutex_init (mux_dispatcher);
5270 hc_thread_mutex_init (mux_counter);
5271 hc_thread_mutex_init (mux_display);
5272 hc_thread_mutex_init (mux_adl);
5273
5274 /**
5275 * commandline parameters
5276 */
5277
5278 uint usage = USAGE;
5279 uint version = VERSION;
5280 uint quiet = QUIET;
5281 uint benchmark = BENCHMARK;
5282 uint show = SHOW;
5283 uint left = LEFT;
5284 uint username = USERNAME;
5285 uint remove = REMOVE;
5286 uint remove_timer = REMOVE_TIMER;
5287 u64 skip = SKIP;
5288 u64 limit = LIMIT;
5289 uint keyspace = KEYSPACE;
5290 uint potfile_disable = POTFILE_DISABLE;
5291 char *potfile_path = NULL;
5292 uint debug_mode = DEBUG_MODE;
5293 char *debug_file = NULL;
5294 char *induction_dir = NULL;
5295 char *outfile_check_dir = NULL;
5296 uint force = FORCE;
5297 uint runtime = RUNTIME;
5298 uint hash_mode = HASH_MODE;
5299 uint attack_mode = ATTACK_MODE;
5300 uint markov_disable = MARKOV_DISABLE;
5301 uint markov_classic = MARKOV_CLASSIC;
5302 uint markov_threshold = MARKOV_THRESHOLD;
5303 char *markov_hcstat = NULL;
5304 char *outfile = NULL;
5305 uint outfile_format = OUTFILE_FORMAT;
5306 uint outfile_autohex = OUTFILE_AUTOHEX;
5307 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5308 uint restore = RESTORE;
5309 uint restore_timer = RESTORE_TIMER;
5310 uint restore_disable = RESTORE_DISABLE;
5311 uint status = STATUS;
5312 uint status_timer = STATUS_TIMER;
5313 uint status_automat = STATUS_AUTOMAT;
5314 uint loopback = LOOPBACK;
5315 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5316 char *session = NULL;
5317 uint hex_charset = HEX_CHARSET;
5318 uint hex_salt = HEX_SALT;
5319 uint hex_wordlist = HEX_WORDLIST;
5320 uint rp_gen = RP_GEN;
5321 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5322 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5323 uint rp_gen_seed = RP_GEN_SEED;
5324 char *rule_buf_l = (char *) RULE_BUF_L;
5325 char *rule_buf_r = (char *) RULE_BUF_R;
5326 uint increment = INCREMENT;
5327 uint increment_min = INCREMENT_MIN;
5328 uint increment_max = INCREMENT_MAX;
5329 char *cpu_affinity = NULL;
5330 OCL_PTR *ocl = NULL;
5331 char *opencl_devices = NULL;
5332 char *opencl_platforms = NULL;
5333 char *opencl_device_types = NULL;
5334 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5335 char *truecrypt_keyfiles = NULL;
5336 uint workload_profile = WORKLOAD_PROFILE;
5337 uint kernel_accel = KERNEL_ACCEL;
5338 uint kernel_loops = KERNEL_LOOPS;
5339 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5340 #ifdef HAVE_HWMON
5341 uint gpu_temp_abort = GPU_TEMP_ABORT;
5342 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5343 #ifdef HAVE_ADL
5344 uint powertune_enable = POWERTUNE_ENABLE;
5345 #endif
5346 #endif
5347 uint logfile_disable = LOGFILE_DISABLE;
5348 uint segment_size = SEGMENT_SIZE;
5349 uint scrypt_tmto = SCRYPT_TMTO;
5350 char separator = SEPARATOR;
5351 uint bitmap_min = BITMAP_MIN;
5352 uint bitmap_max = BITMAP_MAX;
5353 char *custom_charset_1 = NULL;
5354 char *custom_charset_2 = NULL;
5355 char *custom_charset_3 = NULL;
5356 char *custom_charset_4 = NULL;
5357
5358 #define IDX_HELP 'h'
5359 #define IDX_VERSION 'V'
5360 #define IDX_VERSION_LOWER 'v'
5361 #define IDX_QUIET 0xff02
5362 #define IDX_SHOW 0xff03
5363 #define IDX_LEFT 0xff04
5364 #define IDX_REMOVE 0xff05
5365 #define IDX_REMOVE_TIMER 0xff37
5366 #define IDX_SKIP 's'
5367 #define IDX_LIMIT 'l'
5368 #define IDX_KEYSPACE 0xff35
5369 #define IDX_POTFILE_DISABLE 0xff06
5370 #define IDX_POTFILE_PATH 0xffe0
5371 #define IDX_DEBUG_MODE 0xff43
5372 #define IDX_DEBUG_FILE 0xff44
5373 #define IDX_INDUCTION_DIR 0xff46
5374 #define IDX_OUTFILE_CHECK_DIR 0xff47
5375 #define IDX_USERNAME 0xff07
5376 #define IDX_FORCE 0xff08
5377 #define IDX_RUNTIME 0xff09
5378 #define IDX_BENCHMARK 'b'
5379 #define IDX_HASH_MODE 'm'
5380 #define IDX_ATTACK_MODE 'a'
5381 #define IDX_RP_FILE 'r'
5382 #define IDX_RP_GEN 'g'
5383 #define IDX_RP_GEN_FUNC_MIN 0xff10
5384 #define IDX_RP_GEN_FUNC_MAX 0xff11
5385 #define IDX_RP_GEN_SEED 0xff34
5386 #define IDX_RULE_BUF_L 'j'
5387 #define IDX_RULE_BUF_R 'k'
5388 #define IDX_INCREMENT 'i'
5389 #define IDX_INCREMENT_MIN 0xff12
5390 #define IDX_INCREMENT_MAX 0xff13
5391 #define IDX_OUTFILE 'o'
5392 #define IDX_OUTFILE_FORMAT 0xff14
5393 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5394 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5395 #define IDX_RESTORE 0xff15
5396 #define IDX_RESTORE_DISABLE 0xff27
5397 #define IDX_STATUS 0xff17
5398 #define IDX_STATUS_TIMER 0xff18
5399 #define IDX_STATUS_AUTOMAT 0xff50
5400 #define IDX_LOOPBACK 0xff38
5401 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5402 #define IDX_SESSION 0xff19
5403 #define IDX_HEX_CHARSET 0xff20
5404 #define IDX_HEX_SALT 0xff21
5405 #define IDX_HEX_WORDLIST 0xff40
5406 #define IDX_MARKOV_DISABLE 0xff22
5407 #define IDX_MARKOV_CLASSIC 0xff23
5408 #define IDX_MARKOV_THRESHOLD 't'
5409 #define IDX_MARKOV_HCSTAT 0xff24
5410 #define IDX_CPU_AFFINITY 0xff25
5411 #define IDX_OPENCL_DEVICES 'd'
5412 #define IDX_OPENCL_PLATFORMS 0xff72
5413 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5414 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5415 #define IDX_WORKLOAD_PROFILE 'w'
5416 #define IDX_KERNEL_ACCEL 'n'
5417 #define IDX_KERNEL_LOOPS 'u'
5418 #define IDX_GPU_TEMP_DISABLE 0xff29
5419 #define IDX_GPU_TEMP_ABORT 0xff30
5420 #define IDX_GPU_TEMP_RETAIN 0xff31
5421 #define IDX_POWERTUNE_ENABLE 0xff41
5422 #define IDX_LOGFILE_DISABLE 0xff51
5423 #define IDX_TRUECRYPT_KEYFILES 0xff52
5424 #define IDX_SCRYPT_TMTO 0xff61
5425 #define IDX_SEGMENT_SIZE 'c'
5426 #define IDX_SEPARATOR 'p'
5427 #define IDX_BITMAP_MIN 0xff70
5428 #define IDX_BITMAP_MAX 0xff71
5429 #define IDX_CUSTOM_CHARSET_1 '1'
5430 #define IDX_CUSTOM_CHARSET_2 '2'
5431 #define IDX_CUSTOM_CHARSET_3 '3'
5432 #define IDX_CUSTOM_CHARSET_4 '4'
5433
5434 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5435
5436 struct option long_options[] =
5437 {
5438 {"help", no_argument, 0, IDX_HELP},
5439 {"version", no_argument, 0, IDX_VERSION},
5440 {"quiet", no_argument, 0, IDX_QUIET},
5441 {"show", no_argument, 0, IDX_SHOW},
5442 {"left", no_argument, 0, IDX_LEFT},
5443 {"username", no_argument, 0, IDX_USERNAME},
5444 {"remove", no_argument, 0, IDX_REMOVE},
5445 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5446 {"skip", required_argument, 0, IDX_SKIP},
5447 {"limit", required_argument, 0, IDX_LIMIT},
5448 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5449 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5450 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5451 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5452 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5453 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5454 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5455 {"force", no_argument, 0, IDX_FORCE},
5456 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5457 {"restore", no_argument, 0, IDX_RESTORE},
5458 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5459 {"status", no_argument, 0, IDX_STATUS},
5460 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5461 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5462 {"loopback", no_argument, 0, IDX_LOOPBACK},
5463 {"weak-hash-threshold",
5464 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5465 {"session", required_argument, 0, IDX_SESSION},
5466 {"runtime", required_argument, 0, IDX_RUNTIME},
5467 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5468 {"generate-rules-func-min",
5469 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5470 {"generate-rules-func-max",
5471 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5472 {"generate-rules-seed",
5473 required_argument, 0, IDX_RP_GEN_SEED},
5474 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5475 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5476 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5477 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5478 {"rules-file", required_argument, 0, IDX_RP_FILE},
5479 {"outfile", required_argument, 0, IDX_OUTFILE},
5480 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5481 {"outfile-autohex-disable",
5482 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5483 {"outfile-check-timer",
5484 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5485 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5486 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5487 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5488 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5489 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5490 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5491 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5492 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5493 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5494 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5495 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5496 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5497 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5498 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5499 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5500 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5501 #ifdef HAVE_HWMON
5502 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5503 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5504 #ifdef HAVE_ADL
5505 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5506 #endif
5507 #endif // HAVE_HWMON
5508 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5509 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5510 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5511 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5512 // deprecated
5513 {"seperator", required_argument, 0, IDX_SEPARATOR},
5514 {"separator", required_argument, 0, IDX_SEPARATOR},
5515 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5516 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5517 {"increment", no_argument, 0, IDX_INCREMENT},
5518 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5519 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5520 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5521 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5522 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5523 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5524
5525 {0, 0, 0, 0}
5526 };
5527
5528 uint rp_files_cnt = 0;
5529
5530 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5531
5532 int option_index = 0;
5533 int c = -1;
5534
5535 optind = 1;
5536 optopt = 0;
5537
5538 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5539 {
5540 switch (c)
5541 {
5542 case IDX_HELP: usage = 1; break;
5543 case IDX_VERSION:
5544 case IDX_VERSION_LOWER: version = 1; break;
5545 case IDX_RESTORE: restore = 1; break;
5546 case IDX_SESSION: session = optarg; break;
5547 case IDX_SHOW: show = 1; break;
5548 case IDX_LEFT: left = 1; break;
5549 case '?': return (-1);
5550 }
5551 }
5552
5553 if (optopt != 0)
5554 {
5555 log_error ("ERROR: Invalid argument specified");
5556
5557 return (-1);
5558 }
5559
5560 /**
5561 * exit functions
5562 */
5563
5564 if (version)
5565 {
5566 log_info ("%s", VERSION_TAG);
5567
5568 return (0);
5569 }
5570
5571 if (usage)
5572 {
5573 usage_big_print (PROGNAME);
5574
5575 return (0);
5576 }
5577
5578 /**
5579 * session needs to be set, always!
5580 */
5581
5582 if (session == NULL) session = (char *) PROGNAME;
5583
5584 /**
5585 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5586 */
5587
5588 char *exec_path = get_exec_path ();
5589
5590 #ifdef LINUX
5591
5592 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5593 char *resolved_exec_path = realpath (exec_path, NULL);
5594
5595 char *install_dir = get_install_dir (resolved_exec_path);
5596 char *profile_dir = NULL;
5597 char *session_dir = NULL;
5598 char *shared_dir = NULL;
5599
5600 if (strcmp (install_dir, resolved_install_folder) == 0)
5601 {
5602 struct passwd *pw = getpwuid (getuid ());
5603
5604 const char *homedir = pw->pw_dir;
5605
5606 profile_dir = get_profile_dir (homedir);
5607 session_dir = get_session_dir (profile_dir);
5608 shared_dir = strdup (SHARED_FOLDER);
5609
5610 mkdir (profile_dir, 0700);
5611 mkdir (session_dir, 0700);
5612 }
5613 else
5614 {
5615 profile_dir = install_dir;
5616 session_dir = install_dir;
5617 shared_dir = install_dir;
5618 }
5619
5620 myfree (resolved_install_folder);
5621 myfree (resolved_exec_path);
5622
5623 #else
5624
5625 char *install_dir = get_install_dir (exec_path);
5626 char *profile_dir = install_dir;
5627 char *session_dir = install_dir;
5628 char *shared_dir = install_dir;
5629
5630 #endif
5631
5632 data.install_dir = install_dir;
5633 data.profile_dir = profile_dir;
5634 data.session_dir = session_dir;
5635 data.shared_dir = shared_dir;
5636
5637 myfree (exec_path);
5638
5639 /**
5640 * kernel cache, we need to make sure folder exist
5641 */
5642
5643 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5644
5645 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5646
5647 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5648
5649 mkdir (kernels_folder, 0700);
5650
5651 myfree (kernels_folder);
5652
5653 /**
5654 * session
5655 */
5656
5657 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5658
5659 data.session = session;
5660
5661 char *eff_restore_file = (char *) mymalloc (session_size);
5662 char *new_restore_file = (char *) mymalloc (session_size);
5663
5664 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5665 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5666
5667 data.eff_restore_file = eff_restore_file;
5668 data.new_restore_file = new_restore_file;
5669
5670 if (((show == 1) || (left == 1)) && (restore == 1))
5671 {
5672 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5673 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5674
5675 return (-1);
5676 }
5677
5678 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5679 if ((show == 1) || (left == 1))
5680 {
5681 restore_disable = 1;
5682
5683 restore = 0;
5684 }
5685
5686 data.restore_disable = restore_disable;
5687
5688 restore_data_t *rd = init_restore (argc, argv);
5689
5690 data.rd = rd;
5691
5692 /**
5693 * restore file
5694 */
5695
5696 if (restore == 1)
5697 {
5698 read_restore (eff_restore_file, rd);
5699
5700 if (rd->version_bin < RESTORE_MIN)
5701 {
5702 log_error ("ERROR: Incompatible restore-file version");
5703
5704 return (-1);
5705 }
5706
5707 myargc = rd->argc;
5708 myargv = rd->argv;
5709
5710 #ifdef _POSIX
5711 rd->pid = getpid ();
5712 #elif _WIN
5713 rd->pid = GetCurrentProcessId ();
5714 #endif
5715 }
5716
5717 uint hash_mode_chgd = 0;
5718 uint runtime_chgd = 0;
5719 uint kernel_loops_chgd = 0;
5720 uint kernel_accel_chgd = 0;
5721 uint attack_mode_chgd = 0;
5722 uint outfile_format_chgd = 0;
5723 uint rp_gen_seed_chgd = 0;
5724 uint remove_timer_chgd = 0;
5725 uint increment_min_chgd = 0;
5726 uint increment_max_chgd = 0;
5727 uint workload_profile_chgd = 0;
5728 uint opencl_vector_width_chgd = 0;
5729
5730 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5731 uint gpu_temp_retain_chgd = 0;
5732 uint gpu_temp_abort_chgd = 0;
5733 #endif
5734
5735 optind = 1;
5736 optopt = 0;
5737 option_index = 0;
5738
5739 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5740 {
5741 switch (c)
5742 {
5743 //case IDX_HELP: usage = 1; break;
5744 //case IDX_VERSION: version = 1; break;
5745 //case IDX_RESTORE: restore = 1; break;
5746 case IDX_QUIET: quiet = 1; break;
5747 //case IDX_SHOW: show = 1; break;
5748 case IDX_SHOW: break;
5749 //case IDX_LEFT: left = 1; break;
5750 case IDX_LEFT: break;
5751 case IDX_USERNAME: username = 1; break;
5752 case IDX_REMOVE: remove = 1; break;
5753 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5754 remove_timer_chgd = 1; break;
5755 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5756 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5757 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5758 case IDX_DEBUG_FILE: debug_file = optarg; break;
5759 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5760 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5761 case IDX_FORCE: force = 1; break;
5762 case IDX_SKIP: skip = atoll (optarg); break;
5763 case IDX_LIMIT: limit = atoll (optarg); break;
5764 case IDX_KEYSPACE: keyspace = 1; break;
5765 case IDX_BENCHMARK: benchmark = 1; break;
5766 case IDX_RESTORE: break;
5767 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5768 case IDX_STATUS: status = 1; break;
5769 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5770 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5771 case IDX_LOOPBACK: loopback = 1; break;
5772 case IDX_WEAK_HASH_THRESHOLD:
5773 weak_hash_threshold = atoi (optarg); break;
5774 //case IDX_SESSION: session = optarg; break;
5775 case IDX_SESSION: break;
5776 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5777 hash_mode_chgd = 1; break;
5778 case IDX_RUNTIME: runtime = atoi (optarg);
5779 runtime_chgd = 1; break;
5780 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5781 attack_mode_chgd = 1; break;
5782 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5783 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5784 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5785 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5786 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5787 rp_gen_seed_chgd = 1; break;
5788 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5789 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5790 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5791 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5792 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5793 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5794 case IDX_OUTFILE: outfile = optarg; break;
5795 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5796 outfile_format_chgd = 1; break;
5797 case IDX_OUTFILE_AUTOHEX_DISABLE:
5798 outfile_autohex = 0; break;
5799 case IDX_OUTFILE_CHECK_TIMER:
5800 outfile_check_timer = atoi (optarg); break;
5801 case IDX_HEX_CHARSET: hex_charset = 1; break;
5802 case IDX_HEX_SALT: hex_salt = 1; break;
5803 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5804 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5805 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5806 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5807 case IDX_OPENCL_DEVICE_TYPES:
5808 opencl_device_types = optarg; break;
5809 case IDX_OPENCL_VECTOR_WIDTH:
5810 opencl_vector_width = atoi (optarg);
5811 opencl_vector_width_chgd = 1; break;
5812 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5813 workload_profile_chgd = 1; break;
5814 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5815 kernel_accel_chgd = 1; break;
5816 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5817 kernel_loops_chgd = 1; break;
5818 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5819 #ifdef HAVE_HWMON
5820 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5821 #ifdef HAVE_ADL
5822 gpu_temp_abort_chgd = 1;
5823 #endif
5824 break;
5825 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5826 #ifdef HAVE_ADL
5827 gpu_temp_retain_chgd = 1;
5828 #endif
5829 break;
5830 #ifdef HAVE_ADL
5831 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5832 #endif
5833 #endif // HAVE_HWMON
5834 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5835 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5836 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5837 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5838 case IDX_SEPARATOR: separator = optarg[0]; break;
5839 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5840 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5841 case IDX_INCREMENT: increment = 1; break;
5842 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5843 increment_min_chgd = 1; break;
5844 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5845 increment_max_chgd = 1; break;
5846 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5847 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5848 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5849 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5850
5851 default:
5852 log_error ("ERROR: Invalid argument specified");
5853 return (-1);
5854 }
5855 }
5856
5857 if (optopt != 0)
5858 {
5859 log_error ("ERROR: Invalid argument specified");
5860
5861 return (-1);
5862 }
5863
5864 /**
5865 * Inform user things getting started,
5866 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5867 * - we do not need to check algorithm_pos
5868 */
5869
5870 if (quiet == 0)
5871 {
5872 if (benchmark == 1)
5873 {
5874 if (status_automat == 0)
5875 {
5876 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5877 log_info ("");
5878 }
5879 }
5880 else if (restore == 1)
5881 {
5882 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5883 log_info ("");
5884 }
5885 else
5886 {
5887 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5888 log_info ("");
5889 }
5890 }
5891
5892 /**
5893 * sanity check
5894 */
5895
5896 if (attack_mode > 7)
5897 {
5898 log_error ("ERROR: Invalid attack-mode specified");
5899
5900 return (-1);
5901 }
5902
5903 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5904 {
5905 log_error ("ERROR: Invalid runtime specified");
5906
5907 return (-1);
5908 }
5909
5910 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5911 {
5912 log_error ("ERROR: Invalid hash-type specified");
5913
5914 return (-1);
5915 }
5916
5917 // renamed hash modes
5918
5919 if (hash_mode_chgd)
5920 {
5921 int n = -1;
5922
5923 switch (hash_mode)
5924 {
5925 case 123: n = 124;
5926 break;
5927 }
5928
5929 if (n >= 0)
5930 {
5931 log_error ("Old -m specified, use -m %d instead", n);
5932
5933 return (-1);
5934 }
5935 }
5936
5937 if (username == 1)
5938 {
5939 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5940 {
5941 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (outfile_format > 16)
5948 {
5949 log_error ("ERROR: Invalid outfile-format specified");
5950
5951 return (-1);
5952 }
5953
5954 if (left == 1)
5955 {
5956 if (outfile_format_chgd == 1)
5957 {
5958 if (outfile_format > 1)
5959 {
5960 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5961
5962 return (-1);
5963 }
5964 }
5965 else
5966 {
5967 outfile_format = OUTFILE_FMT_HASH;
5968 }
5969 }
5970
5971 if (show == 1)
5972 {
5973 if (outfile_format_chgd == 1)
5974 {
5975 if ((outfile_format > 7) && (outfile_format < 16))
5976 {
5977 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5978
5979 return (-1);
5980 }
5981 }
5982 }
5983
5984 if (increment_min < INCREMENT_MIN)
5985 {
5986 log_error ("ERROR: Invalid increment-min specified");
5987
5988 return (-1);
5989 }
5990
5991 if (increment_max > INCREMENT_MAX)
5992 {
5993 log_error ("ERROR: Invalid increment-max specified");
5994
5995 return (-1);
5996 }
5997
5998 if (increment_min > increment_max)
5999 {
6000 log_error ("ERROR: Invalid increment-min specified");
6001
6002 return (-1);
6003 }
6004
6005 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6006 {
6007 log_error ("ERROR: increment is not allowed in attack-mode 0");
6008
6009 return (-1);
6010 }
6011
6012 if ((increment == 0) && (increment_min_chgd == 1))
6013 {
6014 log_error ("ERROR: increment-min is only supported together with increment switch");
6015
6016 return (-1);
6017 }
6018
6019 if ((increment == 0) && (increment_max_chgd == 1))
6020 {
6021 log_error ("ERROR: increment-max is only supported together with increment switch");
6022
6023 return (-1);
6024 }
6025
6026 if (rp_files_cnt && rp_gen)
6027 {
6028 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6029
6030 return (-1);
6031 }
6032
6033 if (rp_files_cnt || rp_gen)
6034 {
6035 if (attack_mode != ATTACK_MODE_STRAIGHT)
6036 {
6037 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6038
6039 return (-1);
6040 }
6041 }
6042
6043 if (rp_gen_func_min > rp_gen_func_max)
6044 {
6045 log_error ("ERROR: Invalid rp-gen-func-min specified");
6046
6047 return (-1);
6048 }
6049
6050 if (kernel_accel_chgd == 1)
6051 {
6052 if (kernel_accel < 1)
6053 {
6054 log_error ("ERROR: Invalid kernel-accel specified");
6055
6056 return (-1);
6057 }
6058
6059 if (kernel_accel > 1024)
6060 {
6061 log_error ("ERROR: Invalid kernel-accel specified");
6062
6063 return (-1);
6064 }
6065 }
6066
6067 if (kernel_loops_chgd == 1)
6068 {
6069 if (kernel_loops < 1)
6070 {
6071 log_error ("ERROR: Invalid kernel-loops specified");
6072
6073 return (-1);
6074 }
6075
6076 if (kernel_loops > 1024)
6077 {
6078 log_error ("ERROR: Invalid kernel-loops specified");
6079
6080 return (-1);
6081 }
6082 }
6083
6084 if ((workload_profile < 1) || (workload_profile > 3))
6085 {
6086 log_error ("ERROR: workload-profile %i not available", workload_profile);
6087
6088 return (-1);
6089 }
6090
6091 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6092 {
6093 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6094
6095 return (-1);
6096 }
6097
6098 if (show == 1 || left == 1)
6099 {
6100 attack_mode = ATTACK_MODE_NONE;
6101
6102 if (remove == 1)
6103 {
6104 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6105
6106 return (-1);
6107 }
6108
6109 if (potfile_disable == 1)
6110 {
6111 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6112
6113 return (-1);
6114 }
6115 }
6116
6117 uint attack_kern = ATTACK_KERN_NONE;
6118
6119 switch (attack_mode)
6120 {
6121 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6122 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6123 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6124 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6125 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6126 }
6127
6128 if (benchmark == 0)
6129 {
6130 if (keyspace == 1)
6131 {
6132 int num_additional_params = 1;
6133
6134 if (attack_kern == ATTACK_KERN_COMBI)
6135 {
6136 num_additional_params = 2;
6137 }
6138
6139 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6140
6141 if (keyspace_wordlist_specified == 0) optind--;
6142 }
6143
6144 if (attack_kern == ATTACK_KERN_NONE)
6145 {
6146 if ((optind + 1) != myargc)
6147 {
6148 usage_mini_print (myargv[0]);
6149
6150 return (-1);
6151 }
6152 }
6153 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6154 {
6155 if ((optind + 1) > myargc)
6156 {
6157 usage_mini_print (myargv[0]);
6158
6159 return (-1);
6160 }
6161 }
6162 else if (attack_kern == ATTACK_KERN_COMBI)
6163 {
6164 if ((optind + 3) != myargc)
6165 {
6166 usage_mini_print (myargv[0]);
6167
6168 return (-1);
6169 }
6170 }
6171 else if (attack_kern == ATTACK_KERN_BF)
6172 {
6173 if ((optind + 1) > myargc)
6174 {
6175 usage_mini_print (myargv[0]);
6176
6177 return (-1);
6178 }
6179 }
6180 else
6181 {
6182 usage_mini_print (myargv[0]);
6183
6184 return (-1);
6185 }
6186 }
6187 else
6188 {
6189 if (myargv[optind] != 0)
6190 {
6191 log_error ("ERROR: Invalid argument for benchmark mode specified");
6192
6193 return (-1);
6194 }
6195
6196 if (attack_mode_chgd == 1)
6197 {
6198 if (attack_mode != ATTACK_MODE_BF)
6199 {
6200 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6201
6202 return (-1);
6203 }
6204 }
6205 }
6206
6207 if (skip != 0 && limit != 0)
6208 {
6209 limit += skip;
6210 }
6211
6212 if (keyspace == 1)
6213 {
6214 if (show == 1)
6215 {
6216 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6217
6218 return (-1);
6219 }
6220 else if (left == 1)
6221 {
6222 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6223
6224 return (-1);
6225 }
6226
6227 potfile_disable = 1;
6228
6229 restore_disable = 1;
6230
6231 restore = 0;
6232
6233 weak_hash_threshold = 0;
6234
6235 quiet = 1;
6236 }
6237
6238 if (remove_timer_chgd == 1)
6239 {
6240 if (remove == 0)
6241 {
6242 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6243
6244 return (-1);
6245 }
6246
6247 if (remove_timer < 1)
6248 {
6249 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6250
6251 return (-1);
6252 }
6253 }
6254
6255 if (loopback == 1)
6256 {
6257 if (attack_mode == ATTACK_MODE_STRAIGHT)
6258 {
6259 if ((rp_files_cnt == 0) && (rp_gen == 0))
6260 {
6261 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6262
6263 return (-1);
6264 }
6265 }
6266 else
6267 {
6268 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6269
6270 return (-1);
6271 }
6272 }
6273
6274 if (debug_mode > 0)
6275 {
6276 if (attack_mode != ATTACK_MODE_STRAIGHT)
6277 {
6278 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6279
6280 return (-1);
6281 }
6282
6283 if ((rp_files_cnt == 0) && (rp_gen == 0))
6284 {
6285 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6286
6287 return (-1);
6288 }
6289 }
6290
6291 if (debug_mode > 4)
6292 {
6293 log_error ("ERROR: Invalid debug-mode specified");
6294
6295 return (-1);
6296 }
6297
6298 if (debug_file != NULL)
6299 {
6300 if (debug_mode < 1)
6301 {
6302 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6303
6304 return (-1);
6305 }
6306 }
6307
6308 if (induction_dir != NULL)
6309 {
6310 if (attack_mode == ATTACK_MODE_BF)
6311 {
6312 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6313
6314 return (-1);
6315 }
6316 }
6317
6318 if (attack_mode != ATTACK_MODE_STRAIGHT)
6319 {
6320 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6321 {
6322 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6323
6324 return (-1);
6325 }
6326
6327 weak_hash_threshold = 0;
6328 }
6329
6330 /**
6331 * induction directory
6332 */
6333
6334 char *induction_directory = NULL;
6335
6336 if (attack_mode != ATTACK_MODE_BF)
6337 {
6338 if (induction_dir == NULL)
6339 {
6340 induction_directory = (char *) mymalloc (session_size);
6341
6342 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6343
6344 // create induction folder if it does not already exist
6345
6346 if (keyspace == 0)
6347 {
6348 if (rmdir (induction_directory) == -1)
6349 {
6350 if (errno == ENOENT)
6351 {
6352 // good, we can ignore
6353 }
6354 else if (errno == ENOTEMPTY)
6355 {
6356 char *induction_directory_mv = (char *) mymalloc (session_size);
6357
6358 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6359
6360 if (rename (induction_directory, induction_directory_mv) != 0)
6361 {
6362 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6363
6364 return (-1);
6365 }
6366 }
6367 else
6368 {
6369 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6370
6371 return (-1);
6372 }
6373 }
6374
6375 if (mkdir (induction_directory, 0700) == -1)
6376 {
6377 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6378
6379 return (-1);
6380 }
6381 }
6382 }
6383 else
6384 {
6385 induction_directory = induction_dir;
6386 }
6387 }
6388
6389 data.induction_directory = induction_directory;
6390
6391 /**
6392 * loopback
6393 */
6394
6395 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6396
6397 char *loopback_file = (char *) mymalloc (loopback_size);
6398
6399 /**
6400 * tuning db
6401 */
6402
6403 char tuning_db_file[256] = { 0 };
6404
6405 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6406
6407 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6408
6409 /**
6410 * outfile-check directory
6411 */
6412
6413 char *outfile_check_directory = NULL;
6414
6415 if (outfile_check_dir == NULL)
6416 {
6417 outfile_check_directory = (char *) mymalloc (session_size);
6418
6419 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6420 }
6421 else
6422 {
6423 outfile_check_directory = outfile_check_dir;
6424 }
6425
6426 data.outfile_check_directory = outfile_check_directory;
6427
6428 if (keyspace == 0)
6429 {
6430 struct stat outfile_check_stat;
6431
6432 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6433 {
6434 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6435
6436 if (is_dir == 0)
6437 {
6438 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6439
6440 return (-1);
6441 }
6442 }
6443 else if (outfile_check_dir == NULL)
6444 {
6445 if (mkdir (outfile_check_directory, 0700) == -1)
6446 {
6447 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6448
6449 return (-1);
6450 }
6451 }
6452 }
6453
6454 /**
6455 * special other stuff
6456 */
6457
6458 if (hash_mode == 9710)
6459 {
6460 outfile_format = 5;
6461 outfile_format_chgd = 1;
6462 }
6463
6464 if (hash_mode == 9810)
6465 {
6466 outfile_format = 5;
6467 outfile_format_chgd = 1;
6468 }
6469
6470 if (hash_mode == 10410)
6471 {
6472 outfile_format = 5;
6473 outfile_format_chgd = 1;
6474 }
6475
6476 /**
6477 * store stuff
6478 */
6479
6480 data.hash_mode = hash_mode;
6481 data.restore = restore;
6482 data.restore_timer = restore_timer;
6483 data.restore_disable = restore_disable;
6484 data.status = status;
6485 data.status_timer = status_timer;
6486 data.status_automat = status_automat;
6487 data.loopback = loopback;
6488 data.runtime = runtime;
6489 data.remove = remove;
6490 data.remove_timer = remove_timer;
6491 data.debug_mode = debug_mode;
6492 data.debug_file = debug_file;
6493 data.username = username;
6494 data.quiet = quiet;
6495 data.outfile = outfile;
6496 data.outfile_format = outfile_format;
6497 data.outfile_autohex = outfile_autohex;
6498 data.hex_charset = hex_charset;
6499 data.hex_salt = hex_salt;
6500 data.hex_wordlist = hex_wordlist;
6501 data.separator = separator;
6502 data.rp_files = rp_files;
6503 data.rp_files_cnt = rp_files_cnt;
6504 data.rp_gen = rp_gen;
6505 data.rp_gen_seed = rp_gen_seed;
6506 data.force = force;
6507 data.benchmark = benchmark;
6508 data.skip = skip;
6509 data.limit = limit;
6510 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6511 data.powertune_enable = powertune_enable;
6512 #endif
6513 data.logfile_disable = logfile_disable;
6514 data.truecrypt_keyfiles = truecrypt_keyfiles;
6515 data.scrypt_tmto = scrypt_tmto;
6516 data.workload_profile = workload_profile;
6517
6518 /**
6519 * cpu affinity
6520 */
6521
6522 if (cpu_affinity)
6523 {
6524 set_cpu_affinity (cpu_affinity);
6525 }
6526
6527 if (rp_gen_seed_chgd == 0)
6528 {
6529 srand (proc_start);
6530 }
6531 else
6532 {
6533 srand (rp_gen_seed);
6534 }
6535
6536 /**
6537 * logfile init
6538 */
6539
6540 if (logfile_disable == 0)
6541 {
6542 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6543
6544 char *logfile = (char *) mymalloc (logfile_size);
6545
6546 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6547
6548 data.logfile = logfile;
6549
6550 char *topid = logfile_generate_topid ();
6551
6552 data.topid = topid;
6553 }
6554
6555 // logfile_append() checks for logfile_disable internally to make it easier from here
6556
6557 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6558 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6559 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6560 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6561 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6562 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6563 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6564 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6565 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6566 #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));
6567
6568 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6569 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6570 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6571 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6572 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6573 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6574 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6575 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6576
6577 logfile_top_msg ("START");
6578
6579 logfile_top_uint (attack_mode);
6580 logfile_top_uint (attack_kern);
6581 logfile_top_uint (benchmark);
6582 logfile_top_uint (bitmap_min);
6583 logfile_top_uint (bitmap_max);
6584 logfile_top_uint (debug_mode);
6585 logfile_top_uint (force);
6586 logfile_top_uint (kernel_accel);
6587 logfile_top_uint (kernel_loops);
6588 logfile_top_uint (gpu_temp_disable);
6589 #ifdef HAVE_HWMON
6590 logfile_top_uint (gpu_temp_abort);
6591 logfile_top_uint (gpu_temp_retain);
6592 #endif
6593 logfile_top_uint (hash_mode);
6594 logfile_top_uint (hex_charset);
6595 logfile_top_uint (hex_salt);
6596 logfile_top_uint (hex_wordlist);
6597 logfile_top_uint (increment);
6598 logfile_top_uint (increment_max);
6599 logfile_top_uint (increment_min);
6600 logfile_top_uint (keyspace);
6601 logfile_top_uint (left);
6602 logfile_top_uint (logfile_disable);
6603 logfile_top_uint (loopback);
6604 logfile_top_uint (markov_classic);
6605 logfile_top_uint (markov_disable);
6606 logfile_top_uint (markov_threshold);
6607 logfile_top_uint (outfile_autohex);
6608 logfile_top_uint (outfile_check_timer);
6609 logfile_top_uint (outfile_format);
6610 logfile_top_uint (potfile_disable);
6611 logfile_top_string (potfile_path);
6612 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6613 logfile_top_uint (powertune_enable);
6614 #endif
6615 logfile_top_uint (scrypt_tmto);
6616 logfile_top_uint (quiet);
6617 logfile_top_uint (remove);
6618 logfile_top_uint (remove_timer);
6619 logfile_top_uint (restore);
6620 logfile_top_uint (restore_disable);
6621 logfile_top_uint (restore_timer);
6622 logfile_top_uint (rp_gen);
6623 logfile_top_uint (rp_gen_func_max);
6624 logfile_top_uint (rp_gen_func_min);
6625 logfile_top_uint (rp_gen_seed);
6626 logfile_top_uint (runtime);
6627 logfile_top_uint (segment_size);
6628 logfile_top_uint (show);
6629 logfile_top_uint (status);
6630 logfile_top_uint (status_automat);
6631 logfile_top_uint (status_timer);
6632 logfile_top_uint (usage);
6633 logfile_top_uint (username);
6634 logfile_top_uint (version);
6635 logfile_top_uint (weak_hash_threshold);
6636 logfile_top_uint (workload_profile);
6637 logfile_top_uint64 (limit);
6638 logfile_top_uint64 (skip);
6639 logfile_top_char (separator);
6640 logfile_top_string (cpu_affinity);
6641 logfile_top_string (custom_charset_1);
6642 logfile_top_string (custom_charset_2);
6643 logfile_top_string (custom_charset_3);
6644 logfile_top_string (custom_charset_4);
6645 logfile_top_string (debug_file);
6646 logfile_top_string (opencl_devices);
6647 logfile_top_string (opencl_platforms);
6648 logfile_top_string (opencl_device_types);
6649 logfile_top_uint (opencl_vector_width);
6650 logfile_top_string (induction_dir);
6651 logfile_top_string (markov_hcstat);
6652 logfile_top_string (outfile);
6653 logfile_top_string (outfile_check_dir);
6654 logfile_top_string (rule_buf_l);
6655 logfile_top_string (rule_buf_r);
6656 logfile_top_string (session);
6657 logfile_top_string (truecrypt_keyfiles);
6658
6659 /**
6660 * Init OpenCL library loader
6661 */
6662
6663 if (keyspace == 0)
6664 {
6665 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6666
6667 ocl_init (ocl);
6668
6669 data.ocl = ocl;
6670 }
6671
6672 /**
6673 * OpenCL platform selection
6674 */
6675
6676 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6677
6678 /**
6679 * OpenCL device selection
6680 */
6681
6682 u32 devices_filter = setup_devices_filter (opencl_devices);
6683
6684 /**
6685 * OpenCL device type selection
6686 */
6687
6688 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6689
6690 /**
6691 * benchmark
6692 */
6693
6694 if (benchmark == 1)
6695 {
6696 /**
6697 * disable useless stuff for benchmark
6698 */
6699
6700 status_timer = 0;
6701 restore_timer = 0;
6702 restore_disable = 1;
6703 potfile_disable = 1;
6704 weak_hash_threshold = 0;
6705 gpu_temp_disable = 1;
6706
6707 data.status_timer = status_timer;
6708 data.restore_timer = restore_timer;
6709 data.restore_disable = restore_disable;
6710
6711 /**
6712 * force attack mode to be bruteforce
6713 */
6714
6715 attack_mode = ATTACK_MODE_BF;
6716 attack_kern = ATTACK_KERN_BF;
6717
6718 if (workload_profile_chgd == 0)
6719 {
6720 workload_profile = 3;
6721
6722 data.workload_profile = workload_profile;
6723 }
6724 }
6725
6726 /**
6727 * config
6728 */
6729
6730 uint hash_type = 0;
6731 uint salt_type = 0;
6732 uint attack_exec = 0;
6733 uint opts_type = 0;
6734 uint kern_type = 0;
6735 uint dgst_size = 0;
6736 uint esalt_size = 0;
6737 uint opti_type = 0;
6738 uint dgst_pos0 = -1;
6739 uint dgst_pos1 = -1;
6740 uint dgst_pos2 = -1;
6741 uint dgst_pos3 = -1;
6742
6743 int (*parse_func) (char *, uint, hash_t *);
6744 int (*sort_by_digest) (const void *, const void *);
6745
6746 uint algorithm_pos = 0;
6747 uint algorithm_max = 1;
6748
6749 uint *algorithms = default_benchmark_algorithms;
6750
6751 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6752
6753 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6754 {
6755 /*
6756 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6757 * the following algos are skipped entirely
6758 */
6759
6760 if (algorithm_pos > 0)
6761 {
6762 local_free (rd);
6763
6764 rd = init_restore (argc, argv);
6765
6766 data.rd = rd;
6767 }
6768
6769 /**
6770 * update hash_mode in case of multihash benchmark
6771 */
6772
6773 if (benchmark == 1)
6774 {
6775 if (hash_mode_chgd == 0)
6776 {
6777 hash_mode = algorithms[algorithm_pos];
6778
6779 data.hash_mode = hash_mode;
6780 }
6781
6782 quiet = 1;
6783
6784 data.quiet = quiet;
6785 }
6786
6787 switch (hash_mode)
6788 {
6789 case 0: hash_type = HASH_TYPE_MD5;
6790 salt_type = SALT_TYPE_NONE;
6791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6792 opts_type = OPTS_TYPE_PT_GENERATE_LE
6793 | OPTS_TYPE_PT_ADD80
6794 | OPTS_TYPE_PT_ADDBITS14;
6795 kern_type = KERN_TYPE_MD5;
6796 dgst_size = DGST_SIZE_4_4;
6797 parse_func = md5_parse_hash;
6798 sort_by_digest = sort_by_digest_4_4;
6799 opti_type = OPTI_TYPE_ZERO_BYTE
6800 | OPTI_TYPE_PRECOMPUTE_INIT
6801 | OPTI_TYPE_PRECOMPUTE_MERKLE
6802 | OPTI_TYPE_MEET_IN_MIDDLE
6803 | OPTI_TYPE_EARLY_SKIP
6804 | OPTI_TYPE_NOT_ITERATED
6805 | OPTI_TYPE_NOT_SALTED
6806 | OPTI_TYPE_RAW_HASH;
6807 dgst_pos0 = 0;
6808 dgst_pos1 = 3;
6809 dgst_pos2 = 2;
6810 dgst_pos3 = 1;
6811 break;
6812
6813 case 10: hash_type = HASH_TYPE_MD5;
6814 salt_type = SALT_TYPE_INTERN;
6815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6816 opts_type = OPTS_TYPE_PT_GENERATE_LE
6817 | OPTS_TYPE_ST_ADD80
6818 | OPTS_TYPE_ST_ADDBITS14;
6819 kern_type = KERN_TYPE_MD5_PWSLT;
6820 dgst_size = DGST_SIZE_4_4;
6821 parse_func = md5s_parse_hash;
6822 sort_by_digest = sort_by_digest_4_4;
6823 opti_type = OPTI_TYPE_ZERO_BYTE
6824 | OPTI_TYPE_PRECOMPUTE_INIT
6825 | OPTI_TYPE_PRECOMPUTE_MERKLE
6826 | OPTI_TYPE_MEET_IN_MIDDLE
6827 | OPTI_TYPE_EARLY_SKIP
6828 | OPTI_TYPE_NOT_ITERATED
6829 | OPTI_TYPE_APPENDED_SALT
6830 | OPTI_TYPE_RAW_HASH;
6831 dgst_pos0 = 0;
6832 dgst_pos1 = 3;
6833 dgst_pos2 = 2;
6834 dgst_pos3 = 1;
6835 break;
6836
6837 case 11: hash_type = HASH_TYPE_MD5;
6838 salt_type = SALT_TYPE_INTERN;
6839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6840 opts_type = OPTS_TYPE_PT_GENERATE_LE
6841 | OPTS_TYPE_ST_ADD80
6842 | OPTS_TYPE_ST_ADDBITS14;
6843 kern_type = KERN_TYPE_MD5_PWSLT;
6844 dgst_size = DGST_SIZE_4_4;
6845 parse_func = joomla_parse_hash;
6846 sort_by_digest = sort_by_digest_4_4;
6847 opti_type = OPTI_TYPE_ZERO_BYTE
6848 | OPTI_TYPE_PRECOMPUTE_INIT
6849 | OPTI_TYPE_PRECOMPUTE_MERKLE
6850 | OPTI_TYPE_MEET_IN_MIDDLE
6851 | OPTI_TYPE_EARLY_SKIP
6852 | OPTI_TYPE_NOT_ITERATED
6853 | OPTI_TYPE_APPENDED_SALT
6854 | OPTI_TYPE_RAW_HASH;
6855 dgst_pos0 = 0;
6856 dgst_pos1 = 3;
6857 dgst_pos2 = 2;
6858 dgst_pos3 = 1;
6859 break;
6860
6861 case 12: hash_type = HASH_TYPE_MD5;
6862 salt_type = SALT_TYPE_INTERN;
6863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6864 opts_type = OPTS_TYPE_PT_GENERATE_LE
6865 | OPTS_TYPE_ST_ADD80
6866 | OPTS_TYPE_ST_ADDBITS14;
6867 kern_type = KERN_TYPE_MD5_PWSLT;
6868 dgst_size = DGST_SIZE_4_4;
6869 parse_func = postgresql_parse_hash;
6870 sort_by_digest = sort_by_digest_4_4;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_MEET_IN_MIDDLE
6875 | OPTI_TYPE_EARLY_SKIP
6876 | OPTI_TYPE_NOT_ITERATED
6877 | OPTI_TYPE_APPENDED_SALT
6878 | OPTI_TYPE_RAW_HASH;
6879 dgst_pos0 = 0;
6880 dgst_pos1 = 3;
6881 dgst_pos2 = 2;
6882 dgst_pos3 = 1;
6883 break;
6884
6885 case 20: hash_type = HASH_TYPE_MD5;
6886 salt_type = SALT_TYPE_INTERN;
6887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6888 opts_type = OPTS_TYPE_PT_GENERATE_LE
6889 | OPTS_TYPE_PT_ADD80
6890 | OPTS_TYPE_PT_ADDBITS14;
6891 kern_type = KERN_TYPE_MD5_SLTPW;
6892 dgst_size = DGST_SIZE_4_4;
6893 parse_func = md5s_parse_hash;
6894 sort_by_digest = sort_by_digest_4_4;
6895 opti_type = OPTI_TYPE_ZERO_BYTE
6896 | OPTI_TYPE_PRECOMPUTE_INIT
6897 | OPTI_TYPE_PRECOMPUTE_MERKLE
6898 | OPTI_TYPE_EARLY_SKIP
6899 | OPTI_TYPE_NOT_ITERATED
6900 | OPTI_TYPE_PREPENDED_SALT
6901 | OPTI_TYPE_RAW_HASH;
6902 dgst_pos0 = 0;
6903 dgst_pos1 = 3;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 21: hash_type = HASH_TYPE_MD5;
6909 salt_type = SALT_TYPE_INTERN;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_LE
6912 | OPTS_TYPE_PT_ADD80
6913 | OPTS_TYPE_PT_ADDBITS14;
6914 kern_type = KERN_TYPE_MD5_SLTPW;
6915 dgst_size = DGST_SIZE_4_4;
6916 parse_func = osc_parse_hash;
6917 sort_by_digest = sort_by_digest_4_4;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_PREPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 0;
6926 dgst_pos1 = 3;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 22: hash_type = HASH_TYPE_MD5;
6932 salt_type = SALT_TYPE_EMBEDDED;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_LE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS14;
6937 kern_type = KERN_TYPE_MD5_SLTPW;
6938 dgst_size = DGST_SIZE_4_4;
6939 parse_func = netscreen_parse_hash;
6940 sort_by_digest = sort_by_digest_4_4;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_EARLY_SKIP
6945 | OPTI_TYPE_NOT_ITERATED
6946 | OPTI_TYPE_PREPENDED_SALT
6947 | OPTI_TYPE_RAW_HASH;
6948 dgst_pos0 = 0;
6949 dgst_pos1 = 3;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 23: hash_type = HASH_TYPE_MD5;
6955 salt_type = SALT_TYPE_EMBEDDED;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_LE
6958 | OPTS_TYPE_PT_ADD80
6959 | OPTS_TYPE_PT_ADDBITS14;
6960 kern_type = KERN_TYPE_MD5_SLTPW;
6961 dgst_size = DGST_SIZE_4_4;
6962 parse_func = skype_parse_hash;
6963 sort_by_digest = sort_by_digest_4_4;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_PREPENDED_SALT
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 0;
6972 dgst_pos1 = 3;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 30: hash_type = HASH_TYPE_MD5;
6978 salt_type = SALT_TYPE_INTERN;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_LE
6981 | OPTS_TYPE_PT_UNICODE
6982 | OPTS_TYPE_ST_ADD80
6983 | OPTS_TYPE_ST_ADDBITS14;
6984 kern_type = KERN_TYPE_MD5_PWUSLT;
6985 dgst_size = DGST_SIZE_4_4;
6986 parse_func = md5s_parse_hash;
6987 sort_by_digest = sort_by_digest_4_4;
6988 opti_type = OPTI_TYPE_ZERO_BYTE
6989 | OPTI_TYPE_PRECOMPUTE_INIT
6990 | OPTI_TYPE_PRECOMPUTE_MERKLE
6991 | OPTI_TYPE_MEET_IN_MIDDLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_APPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 0;
6997 dgst_pos1 = 3;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 40: hash_type = HASH_TYPE_MD5;
7003 salt_type = SALT_TYPE_INTERN;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_LE
7006 | OPTS_TYPE_PT_ADD80
7007 | OPTS_TYPE_PT_ADDBITS14
7008 | OPTS_TYPE_PT_UNICODE;
7009 kern_type = KERN_TYPE_MD5_SLTPWU;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = md5s_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 0;
7021 dgst_pos1 = 3;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 50: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_INTERN;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_LE
7030 | OPTS_TYPE_ST_ADD80
7031 | OPTS_TYPE_ST_ADDBITS14;
7032 kern_type = KERN_TYPE_HMACMD5_PW;
7033 dgst_size = DGST_SIZE_4_4;
7034 parse_func = hmacmd5_parse_hash;
7035 sort_by_digest = sort_by_digest_4_4;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_NOT_ITERATED;
7038 dgst_pos0 = 0;
7039 dgst_pos1 = 3;
7040 dgst_pos2 = 2;
7041 dgst_pos3 = 1;
7042 break;
7043
7044 case 60: hash_type = HASH_TYPE_MD5;
7045 salt_type = SALT_TYPE_INTERN;
7046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7047 opts_type = OPTS_TYPE_PT_GENERATE_LE
7048 | OPTS_TYPE_PT_ADD80
7049 | OPTS_TYPE_PT_ADDBITS14;
7050 kern_type = KERN_TYPE_HMACMD5_SLT;
7051 dgst_size = DGST_SIZE_4_4;
7052 parse_func = hmacmd5_parse_hash;
7053 sort_by_digest = sort_by_digest_4_4;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_NOT_ITERATED;
7056 dgst_pos0 = 0;
7057 dgst_pos1 = 3;
7058 dgst_pos2 = 2;
7059 dgst_pos3 = 1;
7060 break;
7061
7062 case 100: hash_type = HASH_TYPE_SHA1;
7063 salt_type = SALT_TYPE_NONE;
7064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7065 opts_type = OPTS_TYPE_PT_GENERATE_BE
7066 | OPTS_TYPE_PT_ADD80
7067 | OPTS_TYPE_PT_ADDBITS15;
7068 kern_type = KERN_TYPE_SHA1;
7069 dgst_size = DGST_SIZE_4_5;
7070 parse_func = sha1_parse_hash;
7071 sort_by_digest = sort_by_digest_4_5;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_NOT_SALTED
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 3;
7080 dgst_pos1 = 4;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 101: hash_type = HASH_TYPE_SHA1;
7086 salt_type = SALT_TYPE_NONE;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_BE
7089 | OPTS_TYPE_PT_ADD80
7090 | OPTS_TYPE_PT_ADDBITS15;
7091 kern_type = KERN_TYPE_SHA1;
7092 dgst_size = DGST_SIZE_4_5;
7093 parse_func = sha1b64_parse_hash;
7094 sort_by_digest = sort_by_digest_4_5;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_PRECOMPUTE_INIT
7097 | OPTI_TYPE_PRECOMPUTE_MERKLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_NOT_SALTED
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 3;
7103 dgst_pos1 = 4;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 110: hash_type = HASH_TYPE_SHA1;
7109 salt_type = SALT_TYPE_INTERN;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_BE
7112 | OPTS_TYPE_ST_ADD80
7113 | OPTS_TYPE_ST_ADDBITS15;
7114 kern_type = KERN_TYPE_SHA1_PWSLT;
7115 dgst_size = DGST_SIZE_4_5;
7116 parse_func = sha1s_parse_hash;
7117 sort_by_digest = sort_by_digest_4_5;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_APPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 111: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_EMBEDDED;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS15;
7137 kern_type = KERN_TYPE_SHA1_PWSLT;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = sha1b64s_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_PRECOMPUTE_INIT
7143 | OPTI_TYPE_PRECOMPUTE_MERKLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_APPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 3;
7149 dgst_pos1 = 4;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 112: hash_type = HASH_TYPE_SHA1;
7155 salt_type = SALT_TYPE_INTERN;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_BE
7158 | OPTS_TYPE_ST_ADD80
7159 | OPTS_TYPE_ST_ADDBITS15
7160 | OPTS_TYPE_ST_HEX;
7161 kern_type = KERN_TYPE_SHA1_PWSLT;
7162 dgst_size = DGST_SIZE_4_5;
7163 parse_func = oracles_parse_hash;
7164 sort_by_digest = sort_by_digest_4_5;
7165 opti_type = OPTI_TYPE_ZERO_BYTE
7166 | OPTI_TYPE_PRECOMPUTE_INIT
7167 | OPTI_TYPE_PRECOMPUTE_MERKLE
7168 | OPTI_TYPE_EARLY_SKIP
7169 | OPTI_TYPE_NOT_ITERATED
7170 | OPTI_TYPE_APPENDED_SALT
7171 | OPTI_TYPE_RAW_HASH;
7172 dgst_pos0 = 3;
7173 dgst_pos1 = 4;
7174 dgst_pos2 = 2;
7175 dgst_pos3 = 1;
7176 break;
7177
7178 case 120: hash_type = HASH_TYPE_SHA1;
7179 salt_type = SALT_TYPE_INTERN;
7180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7181 opts_type = OPTS_TYPE_PT_GENERATE_BE
7182 | OPTS_TYPE_PT_ADD80
7183 | OPTS_TYPE_PT_ADDBITS15;
7184 kern_type = KERN_TYPE_SHA1_SLTPW;
7185 dgst_size = DGST_SIZE_4_5;
7186 parse_func = sha1s_parse_hash;
7187 sort_by_digest = sort_by_digest_4_5;
7188 opti_type = OPTI_TYPE_ZERO_BYTE
7189 | OPTI_TYPE_PRECOMPUTE_INIT
7190 | OPTI_TYPE_PRECOMPUTE_MERKLE
7191 | OPTI_TYPE_EARLY_SKIP
7192 | OPTI_TYPE_NOT_ITERATED
7193 | OPTI_TYPE_PREPENDED_SALT
7194 | OPTI_TYPE_RAW_HASH;
7195 dgst_pos0 = 3;
7196 dgst_pos1 = 4;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 121: hash_type = HASH_TYPE_SHA1;
7202 salt_type = SALT_TYPE_INTERN;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_BE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS15
7207 | OPTS_TYPE_ST_LOWER;
7208 kern_type = KERN_TYPE_SHA1_SLTPW;
7209 dgst_size = DGST_SIZE_4_5;
7210 parse_func = smf_parse_hash;
7211 sort_by_digest = sort_by_digest_4_5;
7212 opti_type = OPTI_TYPE_ZERO_BYTE
7213 | OPTI_TYPE_PRECOMPUTE_INIT
7214 | OPTI_TYPE_PRECOMPUTE_MERKLE
7215 | OPTI_TYPE_EARLY_SKIP
7216 | OPTI_TYPE_NOT_ITERATED
7217 | OPTI_TYPE_PREPENDED_SALT
7218 | OPTI_TYPE_RAW_HASH;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 122: hash_type = HASH_TYPE_SHA1;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_BE
7229 | OPTS_TYPE_PT_ADD80
7230 | OPTS_TYPE_PT_ADDBITS15
7231 | OPTS_TYPE_ST_HEX;
7232 kern_type = KERN_TYPE_SHA1_SLTPW;
7233 dgst_size = DGST_SIZE_4_5;
7234 parse_func = osx1_parse_hash;
7235 sort_by_digest = sort_by_digest_4_5;
7236 opti_type = OPTI_TYPE_ZERO_BYTE
7237 | OPTI_TYPE_PRECOMPUTE_INIT
7238 | OPTI_TYPE_PRECOMPUTE_MERKLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_PREPENDED_SALT
7242 | OPTI_TYPE_RAW_HASH;
7243 dgst_pos0 = 3;
7244 dgst_pos1 = 4;
7245 dgst_pos2 = 2;
7246 dgst_pos3 = 1;
7247 break;
7248
7249 case 124: hash_type = HASH_TYPE_SHA1;
7250 salt_type = SALT_TYPE_EMBEDDED;
7251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7252 opts_type = OPTS_TYPE_PT_GENERATE_BE
7253 | OPTS_TYPE_PT_ADD80
7254 | OPTS_TYPE_PT_ADDBITS15;
7255 kern_type = KERN_TYPE_SHA1_SLTPW;
7256 dgst_size = DGST_SIZE_4_5;
7257 parse_func = djangosha1_parse_hash;
7258 sort_by_digest = sort_by_digest_4_5;
7259 opti_type = OPTI_TYPE_ZERO_BYTE
7260 | OPTI_TYPE_PRECOMPUTE_INIT
7261 | OPTI_TYPE_PRECOMPUTE_MERKLE
7262 | OPTI_TYPE_EARLY_SKIP
7263 | OPTI_TYPE_NOT_ITERATED
7264 | OPTI_TYPE_PREPENDED_SALT
7265 | OPTI_TYPE_RAW_HASH;
7266 dgst_pos0 = 3;
7267 dgst_pos1 = 4;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 125: hash_type = HASH_TYPE_SHA1;
7273 salt_type = SALT_TYPE_EMBEDDED;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_BE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS15
7278 | OPTS_TYPE_ST_HEX;
7279 kern_type = KERN_TYPE_SHA1_SLTPW;
7280 dgst_size = DGST_SIZE_4_5;
7281 parse_func = arubaos_parse_hash;
7282 sort_by_digest = sort_by_digest_4_5;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_PRECOMPUTE_INIT
7285 | OPTI_TYPE_PRECOMPUTE_MERKLE
7286 | OPTI_TYPE_EARLY_SKIP
7287 | OPTI_TYPE_NOT_ITERATED
7288 | OPTI_TYPE_PREPENDED_SALT
7289 | OPTI_TYPE_RAW_HASH;
7290 dgst_pos0 = 3;
7291 dgst_pos1 = 4;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 130: hash_type = HASH_TYPE_SHA1;
7297 salt_type = SALT_TYPE_INTERN;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_BE
7300 | OPTS_TYPE_PT_UNICODE
7301 | OPTS_TYPE_ST_ADD80
7302 | OPTS_TYPE_ST_ADDBITS15;
7303 kern_type = KERN_TYPE_SHA1_PWUSLT;
7304 dgst_size = DGST_SIZE_4_5;
7305 parse_func = sha1s_parse_hash;
7306 sort_by_digest = sort_by_digest_4_5;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_APPENDED_SALT
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 3;
7315 dgst_pos1 = 4;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 131: hash_type = HASH_TYPE_SHA1;
7321 salt_type = SALT_TYPE_EMBEDDED;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_BE
7324 | OPTS_TYPE_PT_UNICODE
7325 | OPTS_TYPE_PT_UPPER
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15
7328 | OPTS_TYPE_ST_HEX;
7329 kern_type = KERN_TYPE_SHA1_PWUSLT;
7330 dgst_size = DGST_SIZE_4_5;
7331 parse_func = mssql2000_parse_hash;
7332 sort_by_digest = sort_by_digest_4_5;
7333 opti_type = OPTI_TYPE_ZERO_BYTE
7334 | OPTI_TYPE_PRECOMPUTE_INIT
7335 | OPTI_TYPE_PRECOMPUTE_MERKLE
7336 | OPTI_TYPE_EARLY_SKIP
7337 | OPTI_TYPE_NOT_ITERATED
7338 | OPTI_TYPE_APPENDED_SALT
7339 | OPTI_TYPE_RAW_HASH;
7340 dgst_pos0 = 3;
7341 dgst_pos1 = 4;
7342 dgst_pos2 = 2;
7343 dgst_pos3 = 1;
7344 break;
7345
7346 case 132: hash_type = HASH_TYPE_SHA1;
7347 salt_type = SALT_TYPE_EMBEDDED;
7348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7349 opts_type = OPTS_TYPE_PT_GENERATE_BE
7350 | OPTS_TYPE_PT_UNICODE
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS15
7353 | OPTS_TYPE_ST_HEX;
7354 kern_type = KERN_TYPE_SHA1_PWUSLT;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = mssql2005_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_APPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 4;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 133: hash_type = HASH_TYPE_SHA1;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_ST_ADD80
7377 | OPTS_TYPE_ST_ADDBITS15;
7378 kern_type = KERN_TYPE_SHA1_PWUSLT;
7379 dgst_size = DGST_SIZE_4_5;
7380 parse_func = peoplesoft_parse_hash;
7381 sort_by_digest = sort_by_digest_4_5;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_APPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 3;
7390 dgst_pos1 = 4;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 1;
7393 break;
7394
7395 case 140: hash_type = HASH_TYPE_SHA1;
7396 salt_type = SALT_TYPE_INTERN;
7397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7398 opts_type = OPTS_TYPE_PT_GENERATE_BE
7399 | OPTS_TYPE_PT_ADD80
7400 | OPTS_TYPE_PT_ADDBITS15
7401 | OPTS_TYPE_PT_UNICODE;
7402 kern_type = KERN_TYPE_SHA1_SLTPWU;
7403 dgst_size = DGST_SIZE_4_5;
7404 parse_func = sha1s_parse_hash;
7405 sort_by_digest = sort_by_digest_4_5;
7406 opti_type = OPTI_TYPE_ZERO_BYTE
7407 | OPTI_TYPE_PRECOMPUTE_INIT
7408 | OPTI_TYPE_PRECOMPUTE_MERKLE
7409 | OPTI_TYPE_EARLY_SKIP
7410 | OPTI_TYPE_NOT_ITERATED
7411 | OPTI_TYPE_PREPENDED_SALT
7412 | OPTI_TYPE_RAW_HASH;
7413 dgst_pos0 = 3;
7414 dgst_pos1 = 4;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 1;
7417 break;
7418
7419 case 141: hash_type = HASH_TYPE_SHA1;
7420 salt_type = SALT_TYPE_EMBEDDED;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_PT_ADD80
7424 | OPTS_TYPE_PT_ADDBITS15
7425 | OPTS_TYPE_PT_UNICODE
7426 | OPTS_TYPE_ST_BASE64;
7427 kern_type = KERN_TYPE_SHA1_SLTPWU;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = episerver_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_PREPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 150: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_INTERN;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_ST_ADD80
7449 | OPTS_TYPE_ST_ADDBITS15;
7450 kern_type = KERN_TYPE_HMACSHA1_PW;
7451 dgst_size = DGST_SIZE_4_5;
7452 parse_func = hmacsha1_parse_hash;
7453 sort_by_digest = sort_by_digest_4_5;
7454 opti_type = OPTI_TYPE_ZERO_BYTE
7455 | OPTI_TYPE_NOT_ITERATED;
7456 dgst_pos0 = 3;
7457 dgst_pos1 = 4;
7458 dgst_pos2 = 2;
7459 dgst_pos3 = 1;
7460 break;
7461
7462 case 160: hash_type = HASH_TYPE_SHA1;
7463 salt_type = SALT_TYPE_INTERN;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = OPTS_TYPE_PT_GENERATE_BE
7466 | OPTS_TYPE_PT_ADD80
7467 | OPTS_TYPE_PT_ADDBITS15;
7468 kern_type = KERN_TYPE_HMACSHA1_SLT;
7469 dgst_size = DGST_SIZE_4_5;
7470 parse_func = hmacsha1_parse_hash;
7471 sort_by_digest = sort_by_digest_4_5;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_NOT_ITERATED;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 4;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 190: hash_type = HASH_TYPE_SHA1;
7481 salt_type = SALT_TYPE_NONE;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS15;
7486 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7487 dgst_size = DGST_SIZE_4_5;
7488 parse_func = sha1linkedin_parse_hash;
7489 sort_by_digest = sort_by_digest_4_5;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_EARLY_SKIP
7493 | OPTI_TYPE_NOT_ITERATED
7494 | OPTI_TYPE_NOT_SALTED;
7495 dgst_pos0 = 0;
7496 dgst_pos1 = 4;
7497 dgst_pos2 = 3;
7498 dgst_pos3 = 2;
7499 break;
7500
7501 case 200: hash_type = HASH_TYPE_MYSQL;
7502 salt_type = SALT_TYPE_NONE;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = 0;
7505 kern_type = KERN_TYPE_MYSQL;
7506 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7507 parse_func = mysql323_parse_hash;
7508 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7509 opti_type = OPTI_TYPE_ZERO_BYTE;
7510 dgst_pos0 = 0;
7511 dgst_pos1 = 1;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 3;
7514 break;
7515
7516 case 300: hash_type = HASH_TYPE_SHA1;
7517 salt_type = SALT_TYPE_NONE;
7518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_BE
7520 | OPTS_TYPE_PT_ADD80
7521 | OPTS_TYPE_PT_ADDBITS15;
7522 kern_type = KERN_TYPE_MYSQL41;
7523 dgst_size = DGST_SIZE_4_5;
7524 parse_func = sha1_parse_hash;
7525 sort_by_digest = sort_by_digest_4_5;
7526 opti_type = OPTI_TYPE_ZERO_BYTE
7527 | OPTI_TYPE_PRECOMPUTE_INIT
7528 | OPTI_TYPE_PRECOMPUTE_MERKLE
7529 | OPTI_TYPE_EARLY_SKIP
7530 | OPTI_TYPE_NOT_ITERATED
7531 | OPTI_TYPE_NOT_SALTED;
7532 dgst_pos0 = 3;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 400: hash_type = HASH_TYPE_MD5;
7539 salt_type = SALT_TYPE_EMBEDDED;
7540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7542 kern_type = KERN_TYPE_PHPASS;
7543 dgst_size = DGST_SIZE_4_4;
7544 parse_func = phpass_parse_hash;
7545 sort_by_digest = sort_by_digest_4_4;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_SLOW_HASH_SIMD;
7548 dgst_pos0 = 0;
7549 dgst_pos1 = 1;
7550 dgst_pos2 = 2;
7551 dgst_pos3 = 3;
7552 break;
7553
7554 case 500: hash_type = HASH_TYPE_MD5;
7555 salt_type = SALT_TYPE_EMBEDDED;
7556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7558 kern_type = KERN_TYPE_MD5CRYPT;
7559 dgst_size = DGST_SIZE_4_4;
7560 parse_func = md5crypt_parse_hash;
7561 sort_by_digest = sort_by_digest_4_4;
7562 opti_type = OPTI_TYPE_ZERO_BYTE;
7563 dgst_pos0 = 0;
7564 dgst_pos1 = 1;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 3;
7567 break;
7568
7569 case 501: 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 | OPTS_TYPE_HASH_COPY;
7574 kern_type = KERN_TYPE_MD5CRYPT;
7575 dgst_size = DGST_SIZE_4_4;
7576 parse_func = juniper_parse_hash;
7577 sort_by_digest = sort_by_digest_4_4;
7578 opti_type = OPTI_TYPE_ZERO_BYTE;
7579 dgst_pos0 = 0;
7580 dgst_pos1 = 1;
7581 dgst_pos2 = 2;
7582 dgst_pos3 = 3;
7583 break;
7584
7585 case 900: hash_type = HASH_TYPE_MD4;
7586 salt_type = SALT_TYPE_NONE;
7587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7588 opts_type = OPTS_TYPE_PT_GENERATE_LE
7589 | OPTS_TYPE_PT_ADD80
7590 | OPTS_TYPE_PT_ADDBITS14;
7591 kern_type = KERN_TYPE_MD4;
7592 dgst_size = DGST_SIZE_4_4;
7593 parse_func = md4_parse_hash;
7594 sort_by_digest = sort_by_digest_4_4;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_PRECOMPUTE_INIT
7597 | OPTI_TYPE_PRECOMPUTE_MERKLE
7598 | OPTI_TYPE_MEET_IN_MIDDLE
7599 | OPTI_TYPE_EARLY_SKIP
7600 | OPTI_TYPE_NOT_ITERATED
7601 | OPTI_TYPE_NOT_SALTED
7602 | OPTI_TYPE_RAW_HASH;
7603 dgst_pos0 = 0;
7604 dgst_pos1 = 3;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 1;
7607 break;
7608
7609 case 1000: hash_type = HASH_TYPE_MD4;
7610 salt_type = SALT_TYPE_NONE;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_LE
7613 | OPTS_TYPE_PT_ADD80
7614 | OPTS_TYPE_PT_ADDBITS14
7615 | OPTS_TYPE_PT_UNICODE;
7616 kern_type = KERN_TYPE_MD4_PWU;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = md4_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_MEET_IN_MIDDLE
7624 | OPTI_TYPE_EARLY_SKIP
7625 | OPTI_TYPE_NOT_ITERATED
7626 | OPTI_TYPE_NOT_SALTED
7627 | OPTI_TYPE_RAW_HASH;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 3;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 1;
7632 break;
7633
7634 case 1100: hash_type = HASH_TYPE_MD4;
7635 salt_type = SALT_TYPE_INTERN;
7636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_PT_ADD80
7639 | OPTS_TYPE_PT_ADDBITS14
7640 | OPTS_TYPE_PT_UNICODE
7641 | OPTS_TYPE_ST_ADD80
7642 | OPTS_TYPE_ST_UNICODE
7643 | OPTS_TYPE_ST_LOWER;
7644 kern_type = KERN_TYPE_MD44_PWUSLT;
7645 dgst_size = DGST_SIZE_4_4;
7646 parse_func = dcc_parse_hash;
7647 sort_by_digest = sort_by_digest_4_4;
7648 opti_type = OPTI_TYPE_ZERO_BYTE
7649 | OPTI_TYPE_PRECOMPUTE_INIT
7650 | OPTI_TYPE_PRECOMPUTE_MERKLE
7651 | OPTI_TYPE_EARLY_SKIP
7652 | OPTI_TYPE_NOT_ITERATED;
7653 dgst_pos0 = 0;
7654 dgst_pos1 = 3;
7655 dgst_pos2 = 2;
7656 dgst_pos3 = 1;
7657 break;
7658
7659 case 1400: hash_type = HASH_TYPE_SHA256;
7660 salt_type = SALT_TYPE_NONE;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_BE
7663 | OPTS_TYPE_PT_ADD80
7664 | OPTS_TYPE_PT_ADDBITS15;
7665 kern_type = KERN_TYPE_SHA256;
7666 dgst_size = DGST_SIZE_4_8;
7667 parse_func = sha256_parse_hash;
7668 sort_by_digest = sort_by_digest_4_8;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_PRECOMPUTE_INIT
7671 | OPTI_TYPE_PRECOMPUTE_MERKLE
7672 | OPTI_TYPE_EARLY_SKIP
7673 | OPTI_TYPE_NOT_ITERATED
7674 | OPTI_TYPE_NOT_SALTED
7675 | OPTI_TYPE_RAW_HASH;
7676 dgst_pos0 = 3;
7677 dgst_pos1 = 7;
7678 dgst_pos2 = 2;
7679 dgst_pos3 = 6;
7680 break;
7681
7682 case 1410: hash_type = HASH_TYPE_SHA256;
7683 salt_type = SALT_TYPE_INTERN;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_BE
7686 | OPTS_TYPE_ST_ADD80
7687 | OPTS_TYPE_ST_ADDBITS15;
7688 kern_type = KERN_TYPE_SHA256_PWSLT;
7689 dgst_size = DGST_SIZE_4_8;
7690 parse_func = sha256s_parse_hash;
7691 sort_by_digest = sort_by_digest_4_8;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_PRECOMPUTE_INIT
7694 | OPTI_TYPE_PRECOMPUTE_MERKLE
7695 | OPTI_TYPE_EARLY_SKIP
7696 | OPTI_TYPE_NOT_ITERATED
7697 | OPTI_TYPE_APPENDED_SALT
7698 | OPTI_TYPE_RAW_HASH;
7699 dgst_pos0 = 3;
7700 dgst_pos1 = 7;
7701 dgst_pos2 = 2;
7702 dgst_pos3 = 6;
7703 break;
7704
7705 case 1420: hash_type = HASH_TYPE_SHA256;
7706 salt_type = SALT_TYPE_INTERN;
7707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7708 opts_type = OPTS_TYPE_PT_GENERATE_BE
7709 | OPTS_TYPE_PT_ADD80
7710 | OPTS_TYPE_PT_ADDBITS15;
7711 kern_type = KERN_TYPE_SHA256_SLTPW;
7712 dgst_size = DGST_SIZE_4_8;
7713 parse_func = sha256s_parse_hash;
7714 sort_by_digest = sort_by_digest_4_8;
7715 opti_type = OPTI_TYPE_ZERO_BYTE
7716 | OPTI_TYPE_PRECOMPUTE_INIT
7717 | OPTI_TYPE_PRECOMPUTE_MERKLE
7718 | OPTI_TYPE_EARLY_SKIP
7719 | OPTI_TYPE_NOT_ITERATED
7720 | OPTI_TYPE_PREPENDED_SALT
7721 | OPTI_TYPE_RAW_HASH;
7722 dgst_pos0 = 3;
7723 dgst_pos1 = 7;
7724 dgst_pos2 = 2;
7725 dgst_pos3 = 6;
7726 break;
7727
7728 case 1421: hash_type = HASH_TYPE_SHA256;
7729 salt_type = SALT_TYPE_EMBEDDED;
7730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7731 opts_type = OPTS_TYPE_PT_GENERATE_BE
7732 | OPTS_TYPE_PT_ADD80
7733 | OPTS_TYPE_PT_ADDBITS15;
7734 kern_type = KERN_TYPE_SHA256_SLTPW;
7735 dgst_size = DGST_SIZE_4_8;
7736 parse_func = hmailserver_parse_hash;
7737 sort_by_digest = sort_by_digest_4_8;
7738 opti_type = OPTI_TYPE_ZERO_BYTE
7739 | OPTI_TYPE_PRECOMPUTE_INIT
7740 | OPTI_TYPE_PRECOMPUTE_MERKLE
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED
7743 | OPTI_TYPE_PREPENDED_SALT
7744 | OPTI_TYPE_RAW_HASH;
7745 dgst_pos0 = 3;
7746 dgst_pos1 = 7;
7747 dgst_pos2 = 2;
7748 dgst_pos3 = 6;
7749 break;
7750
7751 case 1430: hash_type = HASH_TYPE_SHA256;
7752 salt_type = SALT_TYPE_INTERN;
7753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7754 opts_type = OPTS_TYPE_PT_GENERATE_BE
7755 | OPTS_TYPE_PT_UNICODE
7756 | OPTS_TYPE_ST_ADD80
7757 | OPTS_TYPE_ST_ADDBITS15;
7758 kern_type = KERN_TYPE_SHA256_PWUSLT;
7759 dgst_size = DGST_SIZE_4_8;
7760 parse_func = sha256s_parse_hash;
7761 sort_by_digest = sort_by_digest_4_8;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_PRECOMPUTE_INIT
7764 | OPTI_TYPE_PRECOMPUTE_MERKLE
7765 | OPTI_TYPE_EARLY_SKIP
7766 | OPTI_TYPE_NOT_ITERATED
7767 | OPTI_TYPE_APPENDED_SALT
7768 | OPTI_TYPE_RAW_HASH;
7769 dgst_pos0 = 3;
7770 dgst_pos1 = 7;
7771 dgst_pos2 = 2;
7772 dgst_pos3 = 6;
7773 break;
7774
7775 case 1440: hash_type = HASH_TYPE_SHA256;
7776 salt_type = SALT_TYPE_INTERN;
7777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7778 opts_type = OPTS_TYPE_PT_GENERATE_BE
7779 | OPTS_TYPE_PT_ADD80
7780 | OPTS_TYPE_PT_ADDBITS15
7781 | OPTS_TYPE_PT_UNICODE;
7782 kern_type = KERN_TYPE_SHA256_SLTPWU;
7783 dgst_size = DGST_SIZE_4_8;
7784 parse_func = sha256s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_8;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_PREPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 7;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 6;
7797 break;
7798
7799 case 1441: hash_type = HASH_TYPE_SHA256;
7800 salt_type = SALT_TYPE_EMBEDDED;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_PT_ADD80
7804 | OPTS_TYPE_PT_ADDBITS15
7805 | OPTS_TYPE_PT_UNICODE
7806 | OPTS_TYPE_ST_BASE64;
7807 kern_type = KERN_TYPE_SHA256_SLTPWU;
7808 dgst_size = DGST_SIZE_4_8;
7809 parse_func = episerver4_parse_hash;
7810 sort_by_digest = sort_by_digest_4_8;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_PRECOMPUTE_INIT
7813 | OPTI_TYPE_PRECOMPUTE_MERKLE
7814 | OPTI_TYPE_EARLY_SKIP
7815 | OPTI_TYPE_NOT_ITERATED
7816 | OPTI_TYPE_PREPENDED_SALT
7817 | OPTI_TYPE_RAW_HASH;
7818 dgst_pos0 = 3;
7819 dgst_pos1 = 7;
7820 dgst_pos2 = 2;
7821 dgst_pos3 = 6;
7822 break;
7823
7824 case 1450: hash_type = HASH_TYPE_SHA256;
7825 salt_type = SALT_TYPE_INTERN;
7826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7827 opts_type = OPTS_TYPE_PT_GENERATE_BE
7828 | OPTS_TYPE_ST_ADD80;
7829 kern_type = KERN_TYPE_HMACSHA256_PW;
7830 dgst_size = DGST_SIZE_4_8;
7831 parse_func = hmacsha256_parse_hash;
7832 sort_by_digest = sort_by_digest_4_8;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_NOT_ITERATED;
7835 dgst_pos0 = 3;
7836 dgst_pos1 = 7;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 6;
7839 break;
7840
7841 case 1460: hash_type = HASH_TYPE_SHA256;
7842 salt_type = SALT_TYPE_INTERN;
7843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_BE
7845 | OPTS_TYPE_PT_ADD80
7846 | OPTS_TYPE_PT_ADDBITS15;
7847 kern_type = KERN_TYPE_HMACSHA256_SLT;
7848 dgst_size = DGST_SIZE_4_8;
7849 parse_func = hmacsha256_parse_hash;
7850 sort_by_digest = sort_by_digest_4_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_NOT_ITERATED;
7853 dgst_pos0 = 3;
7854 dgst_pos1 = 7;
7855 dgst_pos2 = 2;
7856 dgst_pos3 = 6;
7857 break;
7858
7859 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7860 salt_type = SALT_TYPE_EMBEDDED;
7861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7862 opts_type = OPTS_TYPE_PT_GENERATE_LE
7863 | OPTS_TYPE_PT_BITSLICE;
7864 kern_type = KERN_TYPE_DESCRYPT;
7865 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7866 parse_func = descrypt_parse_hash;
7867 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7868 opti_type = OPTI_TYPE_ZERO_BYTE
7869 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7870 dgst_pos0 = 0;
7871 dgst_pos1 = 1;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 3;
7874 break;
7875
7876 case 1600: hash_type = HASH_TYPE_MD5;
7877 salt_type = SALT_TYPE_EMBEDDED;
7878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7880 kern_type = KERN_TYPE_APR1CRYPT;
7881 dgst_size = DGST_SIZE_4_4;
7882 parse_func = md5apr1_parse_hash;
7883 sort_by_digest = sort_by_digest_4_4;
7884 opti_type = OPTI_TYPE_ZERO_BYTE;
7885 dgst_pos0 = 0;
7886 dgst_pos1 = 1;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 3;
7889 break;
7890
7891 case 1700: hash_type = HASH_TYPE_SHA512;
7892 salt_type = SALT_TYPE_NONE;
7893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_BE
7895 | OPTS_TYPE_PT_ADD80
7896 | OPTS_TYPE_PT_ADDBITS15;
7897 kern_type = KERN_TYPE_SHA512;
7898 dgst_size = DGST_SIZE_8_8;
7899 parse_func = sha512_parse_hash;
7900 sort_by_digest = sort_by_digest_8_8;
7901 opti_type = OPTI_TYPE_ZERO_BYTE
7902 | OPTI_TYPE_PRECOMPUTE_INIT
7903 | OPTI_TYPE_PRECOMPUTE_MERKLE
7904 | OPTI_TYPE_EARLY_SKIP
7905 | OPTI_TYPE_NOT_ITERATED
7906 | OPTI_TYPE_NOT_SALTED
7907 | OPTI_TYPE_USES_BITS_64
7908 | OPTI_TYPE_RAW_HASH;
7909 dgst_pos0 = 14;
7910 dgst_pos1 = 15;
7911 dgst_pos2 = 6;
7912 dgst_pos3 = 7;
7913 break;
7914
7915 case 1710: hash_type = HASH_TYPE_SHA512;
7916 salt_type = SALT_TYPE_INTERN;
7917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_BE
7919 | OPTS_TYPE_ST_ADD80
7920 | OPTS_TYPE_ST_ADDBITS15;
7921 kern_type = KERN_TYPE_SHA512_PWSLT;
7922 dgst_size = DGST_SIZE_8_8;
7923 parse_func = sha512s_parse_hash;
7924 sort_by_digest = sort_by_digest_8_8;
7925 opti_type = OPTI_TYPE_ZERO_BYTE
7926 | OPTI_TYPE_PRECOMPUTE_INIT
7927 | OPTI_TYPE_PRECOMPUTE_MERKLE
7928 | OPTI_TYPE_EARLY_SKIP
7929 | OPTI_TYPE_NOT_ITERATED
7930 | OPTI_TYPE_APPENDED_SALT
7931 | OPTI_TYPE_USES_BITS_64
7932 | OPTI_TYPE_RAW_HASH;
7933 dgst_pos0 = 14;
7934 dgst_pos1 = 15;
7935 dgst_pos2 = 6;
7936 dgst_pos3 = 7;
7937 break;
7938
7939 case 1711: hash_type = HASH_TYPE_SHA512;
7940 salt_type = SALT_TYPE_EMBEDDED;
7941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7942 opts_type = OPTS_TYPE_PT_GENERATE_BE
7943 | OPTS_TYPE_ST_ADD80
7944 | OPTS_TYPE_ST_ADDBITS15;
7945 kern_type = KERN_TYPE_SHA512_PWSLT;
7946 dgst_size = DGST_SIZE_8_8;
7947 parse_func = sha512b64s_parse_hash;
7948 sort_by_digest = sort_by_digest_8_8;
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_INIT
7951 | OPTI_TYPE_PRECOMPUTE_MERKLE
7952 | OPTI_TYPE_EARLY_SKIP
7953 | OPTI_TYPE_NOT_ITERATED
7954 | OPTI_TYPE_APPENDED_SALT
7955 | OPTI_TYPE_USES_BITS_64
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 14;
7958 dgst_pos1 = 15;
7959 dgst_pos2 = 6;
7960 dgst_pos3 = 7;
7961 break;
7962
7963 case 1720: hash_type = HASH_TYPE_SHA512;
7964 salt_type = SALT_TYPE_INTERN;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS15;
7969 kern_type = KERN_TYPE_SHA512_SLTPW;
7970 dgst_size = DGST_SIZE_8_8;
7971 parse_func = sha512s_parse_hash;
7972 sort_by_digest = sort_by_digest_8_8;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_ITERATED
7978 | OPTI_TYPE_PREPENDED_SALT
7979 | OPTI_TYPE_USES_BITS_64
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 14;
7982 dgst_pos1 = 15;
7983 dgst_pos2 = 6;
7984 dgst_pos3 = 7;
7985 break;
7986
7987 case 1722: hash_type = HASH_TYPE_SHA512;
7988 salt_type = SALT_TYPE_EMBEDDED;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_ADD80
7992 | OPTS_TYPE_PT_ADDBITS15
7993 | OPTS_TYPE_ST_HEX;
7994 kern_type = KERN_TYPE_SHA512_SLTPW;
7995 dgst_size = DGST_SIZE_8_8;
7996 parse_func = osx512_parse_hash;
7997 sort_by_digest = sort_by_digest_8_8;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_PREPENDED_SALT
8004 | OPTI_TYPE_USES_BITS_64
8005 | OPTI_TYPE_RAW_HASH;
8006 dgst_pos0 = 14;
8007 dgst_pos1 = 15;
8008 dgst_pos2 = 6;
8009 dgst_pos3 = 7;
8010 break;
8011
8012 case 1730: hash_type = HASH_TYPE_SHA512;
8013 salt_type = SALT_TYPE_INTERN;
8014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8015 opts_type = OPTS_TYPE_PT_GENERATE_BE
8016 | OPTS_TYPE_PT_UNICODE
8017 | OPTS_TYPE_ST_ADD80
8018 | OPTS_TYPE_ST_ADDBITS15;
8019 kern_type = KERN_TYPE_SHA512_PWSLTU;
8020 dgst_size = DGST_SIZE_8_8;
8021 parse_func = sha512s_parse_hash;
8022 sort_by_digest = sort_by_digest_8_8;
8023 opti_type = OPTI_TYPE_ZERO_BYTE
8024 | OPTI_TYPE_PRECOMPUTE_INIT
8025 | OPTI_TYPE_PRECOMPUTE_MERKLE
8026 | OPTI_TYPE_EARLY_SKIP
8027 | OPTI_TYPE_NOT_ITERATED
8028 | OPTI_TYPE_APPENDED_SALT
8029 | OPTI_TYPE_USES_BITS_64
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 14;
8032 dgst_pos1 = 15;
8033 dgst_pos2 = 6;
8034 dgst_pos3 = 7;
8035 break;
8036
8037 case 1731: hash_type = HASH_TYPE_SHA512;
8038 salt_type = SALT_TYPE_EMBEDDED;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_UNICODE
8042 | OPTS_TYPE_ST_ADD80
8043 | OPTS_TYPE_ST_ADDBITS15
8044 | OPTS_TYPE_ST_HEX;
8045 kern_type = KERN_TYPE_SHA512_PWSLTU;
8046 dgst_size = DGST_SIZE_8_8;
8047 parse_func = mssql2012_parse_hash;
8048 sort_by_digest = sort_by_digest_8_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_PRECOMPUTE_INIT
8051 | OPTI_TYPE_PRECOMPUTE_MERKLE
8052 | OPTI_TYPE_EARLY_SKIP
8053 | OPTI_TYPE_NOT_ITERATED
8054 | OPTI_TYPE_APPENDED_SALT
8055 | OPTI_TYPE_USES_BITS_64
8056 | OPTI_TYPE_RAW_HASH;
8057 dgst_pos0 = 14;
8058 dgst_pos1 = 15;
8059 dgst_pos2 = 6;
8060 dgst_pos3 = 7;
8061 break;
8062
8063 case 1740: hash_type = HASH_TYPE_SHA512;
8064 salt_type = SALT_TYPE_INTERN;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_ADD80
8068 | OPTS_TYPE_PT_ADDBITS15
8069 | OPTS_TYPE_PT_UNICODE;
8070 kern_type = KERN_TYPE_SHA512_SLTPWU;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = sha512s_parse_hash;
8073 sort_by_digest = sort_by_digest_8_8;
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_PRECOMPUTE_INIT
8076 | OPTI_TYPE_PRECOMPUTE_MERKLE
8077 | OPTI_TYPE_EARLY_SKIP
8078 | OPTI_TYPE_NOT_ITERATED
8079 | OPTI_TYPE_PREPENDED_SALT
8080 | OPTI_TYPE_USES_BITS_64
8081 | OPTI_TYPE_RAW_HASH;
8082 dgst_pos0 = 14;
8083 dgst_pos1 = 15;
8084 dgst_pos2 = 6;
8085 dgst_pos3 = 7;
8086 break;
8087
8088 case 1750: hash_type = HASH_TYPE_SHA512;
8089 salt_type = SALT_TYPE_INTERN;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_ST_ADD80;
8093 kern_type = KERN_TYPE_HMACSHA512_PW;
8094 dgst_size = DGST_SIZE_8_8;
8095 parse_func = hmacsha512_parse_hash;
8096 sort_by_digest = sort_by_digest_8_8;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_USES_BITS_64
8099 | OPTI_TYPE_NOT_ITERATED;
8100 dgst_pos0 = 14;
8101 dgst_pos1 = 15;
8102 dgst_pos2 = 6;
8103 dgst_pos3 = 7;
8104 break;
8105
8106 case 1760: hash_type = HASH_TYPE_SHA512;
8107 salt_type = SALT_TYPE_INTERN;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_BE
8110 | OPTS_TYPE_PT_ADD80
8111 | OPTS_TYPE_PT_ADDBITS15;
8112 kern_type = KERN_TYPE_HMACSHA512_SLT;
8113 dgst_size = DGST_SIZE_8_8;
8114 parse_func = hmacsha512_parse_hash;
8115 sort_by_digest = sort_by_digest_8_8;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_USES_BITS_64
8118 | OPTI_TYPE_NOT_ITERATED;
8119 dgst_pos0 = 14;
8120 dgst_pos1 = 15;
8121 dgst_pos2 = 6;
8122 dgst_pos3 = 7;
8123 break;
8124
8125 case 1800: hash_type = HASH_TYPE_SHA512;
8126 salt_type = SALT_TYPE_EMBEDDED;
8127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8129 kern_type = KERN_TYPE_SHA512CRYPT;
8130 dgst_size = DGST_SIZE_8_8;
8131 parse_func = sha512crypt_parse_hash;
8132 sort_by_digest = sort_by_digest_8_8;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_USES_BITS_64;
8135 dgst_pos0 = 0;
8136 dgst_pos1 = 1;
8137 dgst_pos2 = 2;
8138 dgst_pos3 = 3;
8139 break;
8140
8141 case 2100: hash_type = HASH_TYPE_DCC2;
8142 salt_type = SALT_TYPE_EMBEDDED;
8143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_ST_LOWER
8146 | OPTS_TYPE_ST_UNICODE;
8147 kern_type = KERN_TYPE_DCC2;
8148 dgst_size = DGST_SIZE_4_4;
8149 parse_func = dcc2_parse_hash;
8150 sort_by_digest = sort_by_digest_4_4;
8151 opti_type = OPTI_TYPE_ZERO_BYTE
8152 | OPTI_TYPE_SLOW_HASH_SIMD;
8153 dgst_pos0 = 0;
8154 dgst_pos1 = 1;
8155 dgst_pos2 = 2;
8156 dgst_pos3 = 3;
8157 break;
8158
8159 case 2400: hash_type = HASH_TYPE_MD5;
8160 salt_type = SALT_TYPE_NONE;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8163 kern_type = KERN_TYPE_MD5PIX;
8164 dgst_size = DGST_SIZE_4_4;
8165 parse_func = md5pix_parse_hash;
8166 sort_by_digest = sort_by_digest_4_4;
8167 opti_type = OPTI_TYPE_ZERO_BYTE
8168 | OPTI_TYPE_PRECOMPUTE_INIT
8169 | OPTI_TYPE_PRECOMPUTE_MERKLE
8170 | OPTI_TYPE_EARLY_SKIP
8171 | OPTI_TYPE_NOT_ITERATED
8172 | OPTI_TYPE_NOT_SALTED;
8173 dgst_pos0 = 0;
8174 dgst_pos1 = 3;
8175 dgst_pos2 = 2;
8176 dgst_pos3 = 1;
8177 break;
8178
8179 case 2410: hash_type = HASH_TYPE_MD5;
8180 salt_type = SALT_TYPE_INTERN;
8181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8183 kern_type = KERN_TYPE_MD5ASA;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = md5asa_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4;
8187 opti_type = OPTI_TYPE_ZERO_BYTE
8188 | OPTI_TYPE_PRECOMPUTE_INIT
8189 | OPTI_TYPE_PRECOMPUTE_MERKLE
8190 | OPTI_TYPE_EARLY_SKIP
8191 | OPTI_TYPE_NOT_ITERATED;
8192 dgst_pos0 = 0;
8193 dgst_pos1 = 3;
8194 dgst_pos2 = 2;
8195 dgst_pos3 = 1;
8196 break;
8197
8198 case 2500: hash_type = HASH_TYPE_WPA;
8199 salt_type = SALT_TYPE_EMBEDDED;
8200 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8202 kern_type = KERN_TYPE_WPA;
8203 dgst_size = DGST_SIZE_4_4;
8204 parse_func = wpa_parse_hash;
8205 sort_by_digest = sort_by_digest_4_4;
8206 opti_type = OPTI_TYPE_ZERO_BYTE
8207 | OPTI_TYPE_SLOW_HASH_SIMD;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 1;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 3;
8212 break;
8213
8214 case 2600: hash_type = HASH_TYPE_MD5;
8215 salt_type = SALT_TYPE_VIRTUAL;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE
8218 | OPTS_TYPE_PT_ADD80
8219 | OPTS_TYPE_PT_ADDBITS14
8220 | OPTS_TYPE_ST_ADD80;
8221 kern_type = KERN_TYPE_MD55_PWSLT1;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = md5md5_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 3;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 1;
8233 break;
8234
8235 case 2611: hash_type = HASH_TYPE_MD5;
8236 salt_type = SALT_TYPE_INTERN;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE
8239 | OPTS_TYPE_PT_ADD80
8240 | OPTS_TYPE_PT_ADDBITS14
8241 | OPTS_TYPE_ST_ADD80;
8242 kern_type = KERN_TYPE_MD55_PWSLT1;
8243 dgst_size = DGST_SIZE_4_4;
8244 parse_func = vb3_parse_hash;
8245 sort_by_digest = sort_by_digest_4_4;
8246 opti_type = OPTI_TYPE_ZERO_BYTE
8247 | OPTI_TYPE_PRECOMPUTE_INIT
8248 | OPTI_TYPE_PRECOMPUTE_MERKLE
8249 | OPTI_TYPE_EARLY_SKIP;
8250 dgst_pos0 = 0;
8251 dgst_pos1 = 3;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 1;
8254 break;
8255
8256 case 2612: hash_type = HASH_TYPE_MD5;
8257 salt_type = SALT_TYPE_EMBEDDED;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_LE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS14
8262 | OPTS_TYPE_ST_ADD80
8263 | OPTS_TYPE_ST_HEX;
8264 kern_type = KERN_TYPE_MD55_PWSLT1;
8265 dgst_size = DGST_SIZE_4_4;
8266 parse_func = phps_parse_hash;
8267 sort_by_digest = sort_by_digest_4_4;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_PRECOMPUTE_INIT
8270 | OPTI_TYPE_PRECOMPUTE_MERKLE
8271 | OPTI_TYPE_EARLY_SKIP;
8272 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 2711: hash_type = HASH_TYPE_MD5;
8279 salt_type = SALT_TYPE_INTERN;
8280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_LE
8282 | OPTS_TYPE_PT_ADD80
8283 | OPTS_TYPE_PT_ADDBITS14
8284 | OPTS_TYPE_ST_ADD80;
8285 kern_type = KERN_TYPE_MD55_PWSLT2;
8286 dgst_size = DGST_SIZE_4_4;
8287 parse_func = vb30_parse_hash;
8288 sort_by_digest = sort_by_digest_4_4;
8289 opti_type = OPTI_TYPE_ZERO_BYTE
8290 | OPTI_TYPE_PRECOMPUTE_INIT
8291 | OPTI_TYPE_EARLY_SKIP;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 3;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 2811: hash_type = HASH_TYPE_MD5;
8299 salt_type = SALT_TYPE_INTERN;
8300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE
8302 | OPTS_TYPE_PT_ADD80
8303 | OPTS_TYPE_PT_ADDBITS14;
8304 kern_type = KERN_TYPE_MD55_SLTPW;
8305 dgst_size = DGST_SIZE_4_4;
8306 parse_func = ipb2_parse_hash;
8307 sort_by_digest = sort_by_digest_4_4;
8308 opti_type = OPTI_TYPE_ZERO_BYTE
8309 | OPTI_TYPE_PRECOMPUTE_INIT
8310 | OPTI_TYPE_EARLY_SKIP;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 3;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 1;
8315 break;
8316
8317 case 3000: hash_type = HASH_TYPE_LM;
8318 salt_type = SALT_TYPE_NONE;
8319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE
8321 | OPTS_TYPE_PT_UPPER
8322 | OPTS_TYPE_PT_BITSLICE;
8323 kern_type = KERN_TYPE_LM;
8324 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8325 parse_func = lm_parse_hash;
8326 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8327 opti_type = OPTI_TYPE_ZERO_BYTE
8328 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 1;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 3;
8333 break;
8334
8335 case 3100: hash_type = HASH_TYPE_ORACLEH;
8336 salt_type = SALT_TYPE_INTERN;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE
8339 | OPTS_TYPE_PT_UPPER
8340 | OPTS_TYPE_ST_UPPER;
8341 kern_type = KERN_TYPE_ORACLEH;
8342 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8343 parse_func = oracleh_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8345 opti_type = OPTI_TYPE_ZERO_BYTE;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 1;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 3;
8350 break;
8351
8352 case 3200: hash_type = HASH_TYPE_BCRYPT;
8353 salt_type = SALT_TYPE_EMBEDDED;
8354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_ST_GENERATE_LE;
8357 kern_type = KERN_TYPE_BCRYPT;
8358 dgst_size = DGST_SIZE_4_6;
8359 parse_func = bcrypt_parse_hash;
8360 sort_by_digest = sort_by_digest_4_6;
8361 opti_type = OPTI_TYPE_ZERO_BYTE;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 1;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 3;
8366 break;
8367
8368 case 3710: hash_type = HASH_TYPE_MD5;
8369 salt_type = SALT_TYPE_INTERN;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_ADD80
8373 | OPTS_TYPE_PT_ADDBITS14;
8374 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8375 dgst_size = DGST_SIZE_4_4;
8376 parse_func = md5s_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4;
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_PRECOMPUTE_INIT
8380 | OPTI_TYPE_PRECOMPUTE_MERKLE
8381 | OPTI_TYPE_EARLY_SKIP;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 3;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 1;
8386 break;
8387
8388 case 3711: hash_type = HASH_TYPE_MD5;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE
8392 | OPTS_TYPE_PT_ADD80
8393 | OPTS_TYPE_PT_ADDBITS14;
8394 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8395 dgst_size = DGST_SIZE_4_4;
8396 parse_func = mediawiki_b_parse_hash;
8397 sort_by_digest = sort_by_digest_4_4;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_PRECOMPUTE_INIT
8400 | OPTI_TYPE_PRECOMPUTE_MERKLE
8401 | OPTI_TYPE_EARLY_SKIP;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 3;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 1;
8406 break;
8407
8408 case 3800: hash_type = HASH_TYPE_MD5;
8409 salt_type = SALT_TYPE_INTERN;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE
8412 | OPTS_TYPE_ST_ADDBITS14;
8413 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8414 dgst_size = DGST_SIZE_4_4;
8415 parse_func = md5s_parse_hash;
8416 sort_by_digest = sort_by_digest_4_4;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP
8421 | OPTI_TYPE_NOT_ITERATED
8422 | OPTI_TYPE_RAW_HASH;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 3;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 1;
8427 break;
8428
8429 case 4300: hash_type = HASH_TYPE_MD5;
8430 salt_type = SALT_TYPE_VIRTUAL;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE
8433 | OPTS_TYPE_PT_ADD80
8434 | OPTS_TYPE_PT_ADDBITS14
8435 | OPTS_TYPE_ST_ADD80;
8436 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8437 dgst_size = DGST_SIZE_4_4;
8438 parse_func = md5md5_parse_hash;
8439 sort_by_digest = sort_by_digest_4_4;
8440 opti_type = OPTI_TYPE_ZERO_BYTE
8441 | OPTI_TYPE_PRECOMPUTE_INIT
8442 | OPTI_TYPE_PRECOMPUTE_MERKLE
8443 | OPTI_TYPE_EARLY_SKIP;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 3;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 1;
8448 break;
8449
8450
8451 case 4400: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_NONE;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_BE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS15;
8457 kern_type = KERN_TYPE_MD5_SHA1;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = md5_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP
8465 | OPTI_TYPE_NOT_ITERATED
8466 | OPTI_TYPE_NOT_SALTED
8467 | OPTI_TYPE_RAW_HASH;
8468 dgst_pos0 = 0;
8469 dgst_pos1 = 3;
8470 dgst_pos2 = 2;
8471 dgst_pos3 = 1;
8472 break;
8473
8474 case 4500: hash_type = HASH_TYPE_SHA1;
8475 salt_type = SALT_TYPE_NONE;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_BE
8478 | OPTS_TYPE_PT_ADD80
8479 | OPTS_TYPE_PT_ADDBITS15;
8480 kern_type = KERN_TYPE_SHA11;
8481 dgst_size = DGST_SIZE_4_5;
8482 parse_func = sha1_parse_hash;
8483 sort_by_digest = sort_by_digest_4_5;
8484 opti_type = OPTI_TYPE_ZERO_BYTE
8485 | OPTI_TYPE_PRECOMPUTE_INIT
8486 | OPTI_TYPE_PRECOMPUTE_MERKLE
8487 | OPTI_TYPE_EARLY_SKIP
8488 | OPTI_TYPE_NOT_SALTED;
8489 dgst_pos0 = 3;
8490 dgst_pos1 = 4;
8491 dgst_pos2 = 2;
8492 dgst_pos3 = 1;
8493 break;
8494
8495 case 4700: hash_type = HASH_TYPE_SHA1;
8496 salt_type = SALT_TYPE_NONE;
8497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8498 opts_type = OPTS_TYPE_PT_GENERATE_LE
8499 | OPTS_TYPE_PT_ADD80
8500 | OPTS_TYPE_PT_ADDBITS14;
8501 kern_type = KERN_TYPE_SHA1_MD5;
8502 dgst_size = DGST_SIZE_4_5;
8503 parse_func = sha1_parse_hash;
8504 sort_by_digest = sort_by_digest_4_5;
8505 opti_type = OPTI_TYPE_ZERO_BYTE
8506 | OPTI_TYPE_PRECOMPUTE_INIT
8507 | OPTI_TYPE_PRECOMPUTE_MERKLE
8508 | OPTI_TYPE_EARLY_SKIP
8509 | OPTI_TYPE_NOT_ITERATED
8510 | OPTI_TYPE_NOT_SALTED
8511 | OPTI_TYPE_RAW_HASH;
8512 dgst_pos0 = 3;
8513 dgst_pos1 = 4;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 1;
8516 break;
8517
8518 case 4800: hash_type = HASH_TYPE_MD5;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE
8522 | OPTS_TYPE_PT_ADDBITS14;
8523 kern_type = KERN_TYPE_MD5_CHAP;
8524 dgst_size = DGST_SIZE_4_4;
8525 parse_func = chap_parse_hash;
8526 sort_by_digest = sort_by_digest_4_4;
8527 opti_type = OPTI_TYPE_ZERO_BYTE
8528 | OPTI_TYPE_PRECOMPUTE_INIT
8529 | OPTI_TYPE_PRECOMPUTE_MERKLE
8530 | OPTI_TYPE_MEET_IN_MIDDLE
8531 | OPTI_TYPE_EARLY_SKIP
8532 | OPTI_TYPE_NOT_ITERATED
8533 | OPTI_TYPE_RAW_HASH;
8534 dgst_pos0 = 0;
8535 dgst_pos1 = 3;
8536 dgst_pos2 = 2;
8537 dgst_pos3 = 1;
8538 break;
8539
8540 case 4900: hash_type = HASH_TYPE_SHA1;
8541 salt_type = SALT_TYPE_INTERN;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8544 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8545 dgst_size = DGST_SIZE_4_5;
8546 parse_func = sha1s_parse_hash;
8547 sort_by_digest = sort_by_digest_4_5;
8548 opti_type = OPTI_TYPE_ZERO_BYTE
8549 | OPTI_TYPE_PRECOMPUTE_INIT
8550 | OPTI_TYPE_PRECOMPUTE_MERKLE
8551 | OPTI_TYPE_EARLY_SKIP;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 4;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 1;
8556 break;
8557
8558 case 5000: hash_type = HASH_TYPE_KECCAK;
8559 salt_type = SALT_TYPE_EMBEDDED;
8560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE
8562 | OPTS_TYPE_PT_ADD01;
8563 kern_type = KERN_TYPE_KECCAK;
8564 dgst_size = DGST_SIZE_8_25;
8565 parse_func = keccak_parse_hash;
8566 sort_by_digest = sort_by_digest_8_25;
8567 opti_type = OPTI_TYPE_ZERO_BYTE
8568 | OPTI_TYPE_USES_BITS_64
8569 | OPTI_TYPE_RAW_HASH;
8570 dgst_pos0 = 2;
8571 dgst_pos1 = 3;
8572 dgst_pos2 = 4;
8573 dgst_pos3 = 5;
8574 break;
8575
8576 case 5100: hash_type = HASH_TYPE_MD5H;
8577 salt_type = SALT_TYPE_NONE;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE
8580 | OPTS_TYPE_PT_ADD80
8581 | OPTS_TYPE_PT_ADDBITS14;
8582 kern_type = KERN_TYPE_MD5H;
8583 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8584 parse_func = md5half_parse_hash;
8585 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8586 opti_type = OPTI_TYPE_ZERO_BYTE
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 0;
8589 dgst_pos1 = 1;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 3;
8592 break;
8593
8594 case 5200: hash_type = HASH_TYPE_SHA256;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8598 kern_type = KERN_TYPE_PSAFE3;
8599 dgst_size = DGST_SIZE_4_8;
8600 parse_func = psafe3_parse_hash;
8601 sort_by_digest = sort_by_digest_4_8;
8602 opti_type = OPTI_TYPE_ZERO_BYTE;
8603 dgst_pos0 = 0;
8604 dgst_pos1 = 1;
8605 dgst_pos2 = 2;
8606 dgst_pos3 = 3;
8607 break;
8608
8609 case 5300: hash_type = HASH_TYPE_MD5;
8610 salt_type = SALT_TYPE_EMBEDDED;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE
8613 | OPTS_TYPE_ST_ADD80;
8614 kern_type = KERN_TYPE_IKEPSK_MD5;
8615 dgst_size = DGST_SIZE_4_4;
8616 parse_func = ikepsk_md5_parse_hash;
8617 sort_by_digest = sort_by_digest_4_4;
8618 opti_type = OPTI_TYPE_ZERO_BYTE;
8619 dgst_pos0 = 0;
8620 dgst_pos1 = 3;
8621 dgst_pos2 = 2;
8622 dgst_pos3 = 1;
8623 break;
8624
8625 case 5400: hash_type = HASH_TYPE_SHA1;
8626 salt_type = SALT_TYPE_EMBEDDED;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_BE
8629 | OPTS_TYPE_ST_ADD80;
8630 kern_type = KERN_TYPE_IKEPSK_SHA1;
8631 dgst_size = DGST_SIZE_4_5;
8632 parse_func = ikepsk_sha1_parse_hash;
8633 sort_by_digest = sort_by_digest_4_5;
8634 opti_type = OPTI_TYPE_ZERO_BYTE;
8635 dgst_pos0 = 3;
8636 dgst_pos1 = 4;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 1;
8639 break;
8640
8641 case 5500: hash_type = HASH_TYPE_NETNTLM;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE
8645 | OPTS_TYPE_PT_ADD80
8646 | OPTS_TYPE_PT_ADDBITS14
8647 | OPTS_TYPE_PT_UNICODE
8648 | OPTS_TYPE_ST_HEX;
8649 kern_type = KERN_TYPE_NETNTLMv1;
8650 dgst_size = DGST_SIZE_4_4;
8651 parse_func = netntlmv1_parse_hash;
8652 sort_by_digest = sort_by_digest_4_4;
8653 opti_type = OPTI_TYPE_ZERO_BYTE
8654 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 1;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 3;
8659 break;
8660
8661 case 5600: hash_type = HASH_TYPE_MD5;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_LE
8665 | OPTS_TYPE_PT_ADD80
8666 | OPTS_TYPE_PT_ADDBITS14
8667 | OPTS_TYPE_PT_UNICODE;
8668 kern_type = KERN_TYPE_NETNTLMv2;
8669 dgst_size = DGST_SIZE_4_4;
8670 parse_func = netntlmv2_parse_hash;
8671 sort_by_digest = sort_by_digest_4_4;
8672 opti_type = OPTI_TYPE_ZERO_BYTE;
8673 dgst_pos0 = 0;
8674 dgst_pos1 = 3;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 1;
8677 break;
8678
8679 case 5700: hash_type = HASH_TYPE_SHA256;
8680 salt_type = SALT_TYPE_NONE;
8681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_BE
8683 | OPTS_TYPE_PT_ADD80
8684 | OPTS_TYPE_PT_ADDBITS15;
8685 kern_type = KERN_TYPE_SHA256;
8686 dgst_size = DGST_SIZE_4_8;
8687 parse_func = cisco4_parse_hash;
8688 sort_by_digest = sort_by_digest_4_8;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_INIT
8691 | OPTI_TYPE_PRECOMPUTE_MERKLE
8692 | OPTI_TYPE_EARLY_SKIP
8693 | OPTI_TYPE_NOT_ITERATED
8694 | OPTI_TYPE_NOT_SALTED
8695 | OPTI_TYPE_RAW_HASH;
8696 dgst_pos0 = 3;
8697 dgst_pos1 = 7;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 6;
8700 break;
8701
8702 case 5800: hash_type = HASH_TYPE_SHA1;
8703 salt_type = SALT_TYPE_INTERN;
8704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8706 | OPTS_TYPE_ST_ADD80;
8707 kern_type = KERN_TYPE_ANDROIDPIN;
8708 dgst_size = DGST_SIZE_4_5;
8709 parse_func = androidpin_parse_hash;
8710 sort_by_digest = sort_by_digest_4_5;
8711 opti_type = OPTI_TYPE_ZERO_BYTE;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 1;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 3;
8716 break;
8717
8718 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8719 salt_type = SALT_TYPE_NONE;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_LE
8722 | OPTS_TYPE_PT_ADD80;
8723 kern_type = KERN_TYPE_RIPEMD160;
8724 dgst_size = DGST_SIZE_4_5;
8725 parse_func = ripemd160_parse_hash;
8726 sort_by_digest = sort_by_digest_4_5;
8727 opti_type = OPTI_TYPE_ZERO_BYTE;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 1;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 3;
8732 break;
8733
8734 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8735 salt_type = SALT_TYPE_NONE;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_BE
8738 | OPTS_TYPE_PT_ADD80;
8739 kern_type = KERN_TYPE_WHIRLPOOL;
8740 dgst_size = DGST_SIZE_4_16;
8741 parse_func = whirlpool_parse_hash;
8742 sort_by_digest = sort_by_digest_4_16;
8743 opti_type = OPTI_TYPE_ZERO_BYTE;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8751 salt_type = SALT_TYPE_EMBEDDED;
8752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8754 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8755 dgst_size = DGST_SIZE_4_5;
8756 parse_func = truecrypt_parse_hash_2k;
8757 sort_by_digest = sort_by_digest_4_5;
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 6212: 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_XTS1024;
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 6213: 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_XTS1536;
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 6221: hash_type = HASH_TYPE_SHA512;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8799 kern_type = KERN_TYPE_TCSHA512_XTS512;
8800 dgst_size = DGST_SIZE_8_8;
8801 parse_func = truecrypt_parse_hash_1k;
8802 sort_by_digest = sort_by_digest_8_8;
8803 opti_type = OPTI_TYPE_ZERO_BYTE
8804 | OPTI_TYPE_USES_BITS_64;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 1;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 3;
8809 break;
8810
8811 case 6222: hash_type = HASH_TYPE_SHA512;
8812 salt_type = SALT_TYPE_EMBEDDED;
8813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8815 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8816 dgst_size = DGST_SIZE_8_8;
8817 parse_func = truecrypt_parse_hash_1k;
8818 sort_by_digest = sort_by_digest_8_8;
8819 opti_type = OPTI_TYPE_ZERO_BYTE
8820 | OPTI_TYPE_USES_BITS_64;
8821 dgst_pos0 = 0;
8822 dgst_pos1 = 1;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 3;
8825 break;
8826
8827 case 6223: hash_type = HASH_TYPE_SHA512;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8831 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8832 dgst_size = DGST_SIZE_8_8;
8833 parse_func = truecrypt_parse_hash_1k;
8834 sort_by_digest = sort_by_digest_8_8;
8835 opti_type = OPTI_TYPE_ZERO_BYTE
8836 | OPTI_TYPE_USES_BITS_64;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8848 dgst_size = DGST_SIZE_4_8;
8849 parse_func = truecrypt_parse_hash_1k;
8850 sort_by_digest = sort_by_digest_4_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 6232: 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_XTS1024;
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 6233: 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_XTS1536;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS512;
8893 dgst_size = DGST_SIZE_4_5;
8894 parse_func = truecrypt_parse_hash_1k;
8895 sort_by_digest = sort_by_digest_4_5;
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 6242: 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_XTS1024;
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 6243: 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_XTS1536;
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 6300: hash_type = HASH_TYPE_MD5;
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_MD5AIX;
8938 dgst_size = DGST_SIZE_4_4;
8939 parse_func = md5aix_parse_hash;
8940 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8952 kern_type = KERN_TYPE_SHA256AIX;
8953 dgst_size = DGST_SIZE_4_8;
8954 parse_func = sha256aix_parse_hash;
8955 sort_by_digest = sort_by_digest_4_8;
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 6500: hash_type = HASH_TYPE_SHA512;
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_SHA512AIX;
8968 dgst_size = DGST_SIZE_8_8;
8969 parse_func = sha512aix_parse_hash;
8970 sort_by_digest = sort_by_digest_8_8;
8971 opti_type = OPTI_TYPE_ZERO_BYTE
8972 | OPTI_TYPE_USES_BITS_64;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6600: hash_type = HASH_TYPE_AES;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_AGILEKEY;
8984 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8985 parse_func = agilekey_parse_hash;
8986 sort_by_digest = sort_by_digest_4_5;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6700: hash_type = HASH_TYPE_SHA1;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8998 kern_type = KERN_TYPE_SHA1AIX;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = sha1aix_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 6800: hash_type = HASH_TYPE_AES;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_LASTPASS;
9014 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9015 parse_func = lastpass_parse_hash;
9016 sort_by_digest = sort_by_digest_4_8;
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 6900: hash_type = HASH_TYPE_GOST;
9025 salt_type = SALT_TYPE_NONE;
9026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_GOST;
9029 dgst_size = DGST_SIZE_4_8;
9030 parse_func = gost_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 7100: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_PBKDF2_SHA512;
9044 dgst_size = DGST_SIZE_8_16;
9045 parse_func = sha512osx_parse_hash;
9046 sort_by_digest = sort_by_digest_8_16;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64
9049 | OPTI_TYPE_SLOW_HASH_SIMD;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 7200: hash_type = HASH_TYPE_SHA512;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9060 kern_type = KERN_TYPE_PBKDF2_SHA512;
9061 dgst_size = DGST_SIZE_8_16;
9062 parse_func = sha512grub_parse_hash;
9063 sort_by_digest = sort_by_digest_8_16;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_USES_BITS_64
9066 | OPTI_TYPE_SLOW_HASH_SIMD;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 7300: hash_type = HASH_TYPE_SHA1;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_BE
9077 | OPTS_TYPE_ST_ADD80
9078 | OPTS_TYPE_ST_ADDBITS15;
9079 kern_type = KERN_TYPE_RAKP;
9080 dgst_size = DGST_SIZE_4_5;
9081 parse_func = rakp_parse_hash;
9082 sort_by_digest = sort_by_digest_4_5;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_NOT_ITERATED;
9085 dgst_pos0 = 3;
9086 dgst_pos1 = 4;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 1;
9089 break;
9090
9091 case 7400: hash_type = HASH_TYPE_SHA256;
9092 salt_type = SALT_TYPE_EMBEDDED;
9093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9095 kern_type = KERN_TYPE_SHA256CRYPT;
9096 dgst_size = DGST_SIZE_4_8;
9097 parse_func = sha256crypt_parse_hash;
9098 sort_by_digest = sort_by_digest_4_8;
9099 opti_type = OPTI_TYPE_ZERO_BYTE;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 7500: hash_type = HASH_TYPE_KRB5PA;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9110 kern_type = KERN_TYPE_KRB5PA;
9111 dgst_size = DGST_SIZE_4_4;
9112 parse_func = krb5pa_parse_hash;
9113 sort_by_digest = sort_by_digest_4_4;
9114 opti_type = OPTI_TYPE_ZERO_BYTE
9115 | OPTI_TYPE_NOT_ITERATED;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 7600: hash_type = HASH_TYPE_SHA1;
9123 salt_type = SALT_TYPE_INTERN;
9124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_BE
9126 | OPTS_TYPE_PT_ADD80
9127 | OPTS_TYPE_PT_ADDBITS15;
9128 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9129 dgst_size = DGST_SIZE_4_5;
9130 parse_func = redmine_parse_hash;
9131 sort_by_digest = sort_by_digest_4_5;
9132 opti_type = OPTI_TYPE_ZERO_BYTE
9133 | OPTI_TYPE_PRECOMPUTE_INIT
9134 | OPTI_TYPE_EARLY_SKIP
9135 | OPTI_TYPE_NOT_ITERATED
9136 | OPTI_TYPE_PREPENDED_SALT;
9137 dgst_pos0 = 3;
9138 dgst_pos1 = 4;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 1;
9141 break;
9142
9143 case 7700: hash_type = HASH_TYPE_SAPB;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE
9147 | OPTS_TYPE_PT_UPPER
9148 | OPTS_TYPE_ST_UPPER;
9149 kern_type = KERN_TYPE_SAPB;
9150 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9151 parse_func = sapb_parse_hash;
9152 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9153 opti_type = OPTI_TYPE_ZERO_BYTE
9154 | OPTI_TYPE_PRECOMPUTE_INIT
9155 | OPTI_TYPE_NOT_ITERATED;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 7800: hash_type = HASH_TYPE_SAPG;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_BE
9166 | OPTS_TYPE_ST_ADD80
9167 | OPTS_TYPE_ST_UPPER;
9168 kern_type = KERN_TYPE_SAPG;
9169 dgst_size = DGST_SIZE_4_5;
9170 parse_func = sapg_parse_hash;
9171 sort_by_digest = sort_by_digest_4_5;
9172 opti_type = OPTI_TYPE_ZERO_BYTE
9173 | OPTI_TYPE_PRECOMPUTE_INIT
9174 | OPTI_TYPE_NOT_ITERATED;
9175 dgst_pos0 = 3;
9176 dgst_pos1 = 4;
9177 dgst_pos2 = 2;
9178 dgst_pos3 = 1;
9179 break;
9180
9181 case 7900: hash_type = HASH_TYPE_SHA512;
9182 salt_type = SALT_TYPE_EMBEDDED;
9183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9184 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9185 kern_type = KERN_TYPE_DRUPAL7;
9186 dgst_size = DGST_SIZE_8_8;
9187 parse_func = drupal7_parse_hash;
9188 sort_by_digest = sort_by_digest_8_8;
9189 opti_type = OPTI_TYPE_ZERO_BYTE
9190 | OPTI_TYPE_USES_BITS_64;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 8000: hash_type = HASH_TYPE_SHA256;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_BE
9201 | OPTS_TYPE_PT_UNICODE
9202 | OPTS_TYPE_ST_ADD80
9203 | OPTS_TYPE_ST_HEX;
9204 kern_type = KERN_TYPE_SYBASEASE;
9205 dgst_size = DGST_SIZE_4_8;
9206 parse_func = sybasease_parse_hash;
9207 sort_by_digest = sort_by_digest_4_8;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_PRECOMPUTE_INIT
9210 | OPTI_TYPE_EARLY_SKIP
9211 | OPTI_TYPE_NOT_ITERATED
9212 | OPTI_TYPE_RAW_HASH;
9213 dgst_pos0 = 3;
9214 dgst_pos1 = 7;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 6;
9217 break;
9218
9219 case 8100: hash_type = HASH_TYPE_SHA1;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9223 kern_type = KERN_TYPE_NETSCALER;
9224 dgst_size = DGST_SIZE_4_5;
9225 parse_func = netscaler_parse_hash;
9226 sort_by_digest = sort_by_digest_4_5;
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_PRECOMPUTE_INIT
9229 | OPTI_TYPE_PRECOMPUTE_MERKLE
9230 | OPTI_TYPE_EARLY_SKIP
9231 | OPTI_TYPE_NOT_ITERATED
9232 | OPTI_TYPE_PREPENDED_SALT
9233 | OPTI_TYPE_RAW_HASH;
9234 dgst_pos0 = 3;
9235 dgst_pos1 = 4;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 1;
9238 break;
9239
9240 case 8200: hash_type = HASH_TYPE_SHA256;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9244 kern_type = KERN_TYPE_CLOUDKEY;
9245 dgst_size = DGST_SIZE_4_8;
9246 parse_func = cloudkey_parse_hash;
9247 sort_by_digest = sort_by_digest_4_8;
9248 opti_type = OPTI_TYPE_ZERO_BYTE;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 8300: hash_type = HASH_TYPE_SHA1;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_BE
9259 | OPTS_TYPE_ST_HEX
9260 | OPTS_TYPE_ST_ADD80;
9261 kern_type = KERN_TYPE_NSEC3;
9262 dgst_size = DGST_SIZE_4_5;
9263 parse_func = nsec3_parse_hash;
9264 sort_by_digest = sort_by_digest_4_5;
9265 opti_type = OPTI_TYPE_ZERO_BYTE;
9266 dgst_pos0 = 3;
9267 dgst_pos1 = 4;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 1;
9270 break;
9271
9272 case 8400: hash_type = HASH_TYPE_SHA1;
9273 salt_type = SALT_TYPE_INTERN;
9274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_BE
9276 | OPTS_TYPE_PT_ADD80
9277 | OPTS_TYPE_PT_ADDBITS15;
9278 kern_type = KERN_TYPE_WBB3;
9279 dgst_size = DGST_SIZE_4_5;
9280 parse_func = wbb3_parse_hash;
9281 sort_by_digest = sort_by_digest_4_5;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_NOT_ITERATED;
9285 dgst_pos0 = 3;
9286 dgst_pos1 = 4;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 1;
9289 break;
9290
9291 case 8500: hash_type = HASH_TYPE_DESRACF;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_LE
9295 | OPTS_TYPE_ST_UPPER;
9296 kern_type = KERN_TYPE_RACF;
9297 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9298 parse_func = racf_parse_hash;
9299 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9300 opti_type = OPTI_TYPE_ZERO_BYTE
9301 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 8600: hash_type = HASH_TYPE_LOTUS5;
9309 salt_type = SALT_TYPE_NONE;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9312 kern_type = KERN_TYPE_LOTUS5;
9313 dgst_size = DGST_SIZE_4_4;
9314 parse_func = lotus5_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4;
9316 opti_type = OPTI_TYPE_EARLY_SKIP
9317 | OPTI_TYPE_NOT_ITERATED
9318 | OPTI_TYPE_NOT_SALTED
9319 | OPTI_TYPE_RAW_HASH;
9320 dgst_pos0 = 0;
9321 dgst_pos1 = 1;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 3;
9324 break;
9325
9326 case 8700: hash_type = HASH_TYPE_LOTUS6;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9330 kern_type = KERN_TYPE_LOTUS6;
9331 dgst_size = DGST_SIZE_4_4;
9332 parse_func = lotus6_parse_hash;
9333 sort_by_digest = sort_by_digest_4_4;
9334 opti_type = OPTI_TYPE_EARLY_SKIP
9335 | OPTI_TYPE_NOT_ITERATED
9336 | OPTI_TYPE_RAW_HASH;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9347 kern_type = KERN_TYPE_ANDROIDFDE;
9348 dgst_size = DGST_SIZE_4_4;
9349 parse_func = androidfde_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4;
9351 opti_type = OPTI_TYPE_ZERO_BYTE;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 8900: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
9363 dgst_size = DGST_SIZE_4_8;
9364 parse_func = scrypt_parse_hash;
9365 sort_by_digest = sort_by_digest_4_8;
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 9000: hash_type = HASH_TYPE_SHA1;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE
9377 | OPTS_TYPE_ST_GENERATE_LE;
9378 kern_type = KERN_TYPE_PSAFE2;
9379 dgst_size = DGST_SIZE_4_5;
9380 parse_func = psafe2_parse_hash;
9381 sort_by_digest = sort_by_digest_4_5;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 9100: hash_type = HASH_TYPE_LOTUS8;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_LOTUS8;
9394 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9395 parse_func = lotus8_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9408 kern_type = KERN_TYPE_PBKDF2_SHA256;
9409 dgst_size = DGST_SIZE_4_32;
9410 parse_func = cisco8_parse_hash;
9411 sort_by_digest = sort_by_digest_4_32;
9412 opti_type = OPTI_TYPE_ZERO_BYTE
9413 | OPTI_TYPE_SLOW_HASH_SIMD;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 9300: hash_type = HASH_TYPE_SCRYPT;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_SCRYPT;
9425 dgst_size = DGST_SIZE_4_8;
9426 parse_func = cisco9_parse_hash;
9427 sort_by_digest = sort_by_digest_4_8;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9400: hash_type = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
9440 dgst_size = DGST_SIZE_4_4;
9441 parse_func = office2007_parse_hash;
9442 sort_by_digest = sort_by_digest_4_4;
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 9500: hash_type = HASH_TYPE_OFFICE2010;
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_OFFICE2010;
9455 dgst_size = DGST_SIZE_4_4;
9456 parse_func = office2010_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 9600: hash_type = HASH_TYPE_OFFICE2013;
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_OFFICE2013;
9470 dgst_size = DGST_SIZE_4_4;
9471 parse_func = office2013_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 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE
9484 | OPTS_TYPE_PT_ADD80
9485 | OPTS_TYPE_PT_UNICODE;
9486 kern_type = KERN_TYPE_OLDOFFICE01;
9487 dgst_size = DGST_SIZE_4_4;
9488 parse_func = oldoffice01_parse_hash;
9489 sort_by_digest = sort_by_digest_4_4;
9490 opti_type = OPTI_TYPE_ZERO_BYTE
9491 | OPTI_TYPE_PRECOMPUTE_INIT
9492 | OPTI_TYPE_NOT_ITERATED;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE
9503 | OPTS_TYPE_PT_ADD80;
9504 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9505 dgst_size = DGST_SIZE_4_4;
9506 parse_func = oldoffice01cm1_parse_hash;
9507 sort_by_digest = sort_by_digest_4_4;
9508 opti_type = OPTI_TYPE_ZERO_BYTE
9509 | OPTI_TYPE_PRECOMPUTE_INIT
9510 | OPTI_TYPE_NOT_ITERATED;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9520 opts_type = OPTS_TYPE_PT_GENERATE_LE
9521 | OPTS_TYPE_PT_ADD80
9522 | OPTS_TYPE_PT_UNICODE
9523 | OPTS_TYPE_PT_NEVERCRACK;
9524 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9525 dgst_size = DGST_SIZE_4_4;
9526 parse_func = oldoffice01cm2_parse_hash;
9527 sort_by_digest = sort_by_digest_4_4;
9528 opti_type = OPTI_TYPE_ZERO_BYTE
9529 | OPTI_TYPE_PRECOMPUTE_INIT
9530 | OPTI_TYPE_NOT_ITERATED;
9531 dgst_pos0 = 0;
9532 dgst_pos1 = 1;
9533 dgst_pos2 = 2;
9534 dgst_pos3 = 3;
9535 break;
9536
9537 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9538 salt_type = SALT_TYPE_EMBEDDED;
9539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9540 opts_type = OPTS_TYPE_PT_GENERATE_BE
9541 | OPTS_TYPE_PT_ADD80
9542 | OPTS_TYPE_PT_UNICODE;
9543 kern_type = KERN_TYPE_OLDOFFICE34;
9544 dgst_size = DGST_SIZE_4_4;
9545 parse_func = oldoffice34_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4;
9547 opti_type = OPTI_TYPE_ZERO_BYTE
9548 | OPTI_TYPE_PRECOMPUTE_INIT
9549 | OPTI_TYPE_NOT_ITERATED;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9560 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9561 dgst_size = DGST_SIZE_4_4;
9562 parse_func = oldoffice34cm1_parse_hash;
9563 sort_by_digest = sort_by_digest_4_4;
9564 opti_type = OPTI_TYPE_ZERO_BYTE
9565 | OPTI_TYPE_PRECOMPUTE_INIT
9566 | OPTI_TYPE_NOT_ITERATED;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_BE
9577 | OPTS_TYPE_PT_ADD80
9578 | OPTS_TYPE_PT_UNICODE
9579 | OPTS_TYPE_PT_NEVERCRACK;
9580 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = oldoffice34cm2_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE
9585 | OPTI_TYPE_PRECOMPUTE_INIT
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 9900: hash_type = HASH_TYPE_MD5;
9594 salt_type = SALT_TYPE_NONE;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9597 kern_type = KERN_TYPE_RADMIN2;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = radmin2_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE
9602 | OPTI_TYPE_PRECOMPUTE_INIT
9603 | OPTI_TYPE_EARLY_SKIP
9604 | OPTI_TYPE_NOT_ITERATED
9605 | OPTI_TYPE_NOT_SALTED;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 3;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 1;
9610 break;
9611
9612 case 10000: hash_type = HASH_TYPE_SHA256;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9616 kern_type = KERN_TYPE_PBKDF2_SHA256;
9617 dgst_size = DGST_SIZE_4_32;
9618 parse_func = djangopbkdf2_parse_hash;
9619 sort_by_digest = sort_by_digest_4_32;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_SLOW_HASH_SIMD;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 10100: hash_type = HASH_TYPE_SIPHASH;
9629 salt_type = SALT_TYPE_EMBEDDED;
9630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9632 kern_type = KERN_TYPE_SIPHASH;
9633 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9634 parse_func = siphash_parse_hash;
9635 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_NOT_ITERATED
9638 | OPTI_TYPE_RAW_HASH;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 10200: hash_type = HASH_TYPE_MD5;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE
9649 | OPTS_TYPE_ST_ADD80
9650 | OPTS_TYPE_ST_ADDBITS14;
9651 kern_type = KERN_TYPE_HMACMD5_PW;
9652 dgst_size = DGST_SIZE_4_4;
9653 parse_func = crammd5_parse_hash;
9654 sort_by_digest = sort_by_digest_4_4;
9655 opti_type = OPTI_TYPE_ZERO_BYTE
9656 | OPTI_TYPE_NOT_ITERATED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 3;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 1;
9661 break;
9662
9663 case 10300: hash_type = HASH_TYPE_SHA1;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9667 kern_type = KERN_TYPE_SAPH_SHA1;
9668 dgst_size = DGST_SIZE_4_5;
9669 parse_func = saph_sha1_parse_hash;
9670 sort_by_digest = sort_by_digest_4_5;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 10400: hash_type = HASH_TYPE_PDFU16;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9682 kern_type = KERN_TYPE_PDF11;
9683 dgst_size = DGST_SIZE_4_4;
9684 parse_func = pdf11_parse_hash;
9685 sort_by_digest = sort_by_digest_4_4;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_NOT_ITERATED;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 10410: hash_type = HASH_TYPE_PDFU16;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_PDF11CM1;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = pdf11cm1_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE
9703 | OPTI_TYPE_NOT_ITERATED;
9704 dgst_pos0 = 0;
9705 dgst_pos1 = 1;
9706 dgst_pos2 = 2;
9707 dgst_pos3 = 3;
9708 break;
9709
9710 case 10420: hash_type = HASH_TYPE_PDFU16;
9711 salt_type = SALT_TYPE_EMBEDDED;
9712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9714 kern_type = KERN_TYPE_PDF11CM2;
9715 dgst_size = DGST_SIZE_4_4;
9716 parse_func = pdf11cm2_parse_hash;
9717 sort_by_digest = sort_by_digest_4_4;
9718 opti_type = OPTI_TYPE_ZERO_BYTE
9719 | OPTI_TYPE_NOT_ITERATED;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 10500: hash_type = HASH_TYPE_PDFU16;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9730 kern_type = KERN_TYPE_PDF14;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = pdf14_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_NOT_ITERATED;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 10600: hash_type = HASH_TYPE_SHA256;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_BE
9746 | OPTS_TYPE_ST_ADD80
9747 | OPTS_TYPE_ST_ADDBITS15
9748 | OPTS_TYPE_HASH_COPY;
9749 kern_type = KERN_TYPE_SHA256_PWSLT;
9750 dgst_size = DGST_SIZE_4_8;
9751 parse_func = pdf17l3_parse_hash;
9752 sort_by_digest = sort_by_digest_4_8;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_PRECOMPUTE_INIT
9755 | OPTI_TYPE_PRECOMPUTE_MERKLE
9756 | OPTI_TYPE_EARLY_SKIP
9757 | OPTI_TYPE_NOT_ITERATED
9758 | OPTI_TYPE_APPENDED_SALT
9759 | OPTI_TYPE_RAW_HASH;
9760 dgst_pos0 = 3;
9761 dgst_pos1 = 7;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 6;
9764 break;
9765
9766 case 10700: hash_type = HASH_TYPE_PDFU32;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_HASH_COPY;
9771 kern_type = KERN_TYPE_PDF17L8;
9772 dgst_size = DGST_SIZE_4_8;
9773 parse_func = pdf17l8_parse_hash;
9774 sort_by_digest = sort_by_digest_4_8;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_NOT_ITERATED;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 10800: hash_type = HASH_TYPE_SHA384;
9784 salt_type = SALT_TYPE_NONE;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_BE
9787 | OPTS_TYPE_PT_ADD80
9788 | OPTS_TYPE_PT_ADDBITS15;
9789 kern_type = KERN_TYPE_SHA384;
9790 dgst_size = DGST_SIZE_8_8;
9791 parse_func = sha384_parse_hash;
9792 sort_by_digest = sort_by_digest_8_8;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_PRECOMPUTE_INIT
9795 | OPTI_TYPE_PRECOMPUTE_MERKLE
9796 | OPTI_TYPE_EARLY_SKIP
9797 | OPTI_TYPE_NOT_ITERATED
9798 | OPTI_TYPE_NOT_SALTED
9799 | OPTI_TYPE_USES_BITS_64
9800 | OPTI_TYPE_RAW_HASH;
9801 dgst_pos0 = 6;
9802 dgst_pos1 = 7;
9803 dgst_pos2 = 4;
9804 dgst_pos3 = 5;
9805 break;
9806
9807 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9808 salt_type = SALT_TYPE_EMBEDDED;
9809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_LE
9811 | OPTS_TYPE_ST_BASE64
9812 | OPTS_TYPE_HASH_COPY;
9813 kern_type = KERN_TYPE_PBKDF2_SHA256;
9814 dgst_size = DGST_SIZE_4_32;
9815 parse_func = pbkdf2_sha256_parse_hash;
9816 sort_by_digest = sort_by_digest_4_32;
9817 opti_type = OPTI_TYPE_ZERO_BYTE
9818 | OPTI_TYPE_SLOW_HASH_SIMD;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 11000: hash_type = HASH_TYPE_MD5;
9826 salt_type = SALT_TYPE_INTERN;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE
9829 | OPTS_TYPE_PT_ADD80;
9830 kern_type = KERN_TYPE_PRESTASHOP;
9831 dgst_size = DGST_SIZE_4_4;
9832 parse_func = prestashop_parse_hash;
9833 sort_by_digest = sort_by_digest_4_4;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_PRECOMPUTE_INIT
9836 | OPTI_TYPE_NOT_ITERATED
9837 | OPTI_TYPE_PREPENDED_SALT;
9838 dgst_pos0 = 0;
9839 dgst_pos1 = 3;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 1;
9842 break;
9843
9844 case 11100: hash_type = HASH_TYPE_MD5;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_LE
9848 | OPTS_TYPE_ST_ADD80;
9849 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = postgresql_auth_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_INIT
9855 | OPTI_TYPE_PRECOMPUTE_MERKLE
9856 | OPTI_TYPE_EARLY_SKIP;
9857 dgst_pos0 = 0;
9858 dgst_pos1 = 3;
9859 dgst_pos2 = 2;
9860 dgst_pos3 = 1;
9861 break;
9862
9863 case 11200: hash_type = HASH_TYPE_SHA1;
9864 salt_type = SALT_TYPE_EMBEDDED;
9865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9866 opts_type = OPTS_TYPE_PT_GENERATE_BE
9867 | OPTS_TYPE_PT_ADD80
9868 | OPTS_TYPE_ST_HEX;
9869 kern_type = KERN_TYPE_MYSQL_AUTH;
9870 dgst_size = DGST_SIZE_4_5;
9871 parse_func = mysql_auth_parse_hash;
9872 sort_by_digest = sort_by_digest_4_5;
9873 opti_type = OPTI_TYPE_ZERO_BYTE
9874 | OPTI_TYPE_EARLY_SKIP;
9875 dgst_pos0 = 3;
9876 dgst_pos1 = 4;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 1;
9879 break;
9880
9881 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9882 salt_type = SALT_TYPE_EMBEDDED;
9883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE
9885 | OPTS_TYPE_ST_HEX
9886 | OPTS_TYPE_ST_ADD80;
9887 kern_type = KERN_TYPE_BITCOIN_WALLET;
9888 dgst_size = DGST_SIZE_4_4;
9889 parse_func = bitcoin_wallet_parse_hash;
9890 sort_by_digest = sort_by_digest_4_4;
9891 opti_type = OPTI_TYPE_ZERO_BYTE;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 11400: hash_type = HASH_TYPE_MD5;
9899 salt_type = SALT_TYPE_EMBEDDED;
9900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE
9902 | OPTS_TYPE_PT_ADD80
9903 | OPTS_TYPE_HASH_COPY;
9904 kern_type = KERN_TYPE_SIP_AUTH;
9905 dgst_size = DGST_SIZE_4_4;
9906 parse_func = sip_auth_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4;
9908 opti_type = OPTI_TYPE_ZERO_BYTE;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 3;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 11500: hash_type = HASH_TYPE_CRC32;
9916 salt_type = SALT_TYPE_INTERN;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_ST_GENERATE_LE
9920 | OPTS_TYPE_ST_HEX;
9921 kern_type = KERN_TYPE_CRC32;
9922 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9923 parse_func = crc32_parse_hash;
9924 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 11600: hash_type = HASH_TYPE_AES;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_PT_NEVERCRACK;
9937 kern_type = KERN_TYPE_SEVEN_ZIP;
9938 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9939 parse_func = seven_zip_parse_hash;
9940 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9941 opti_type = OPTI_TYPE_ZERO_BYTE;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9949 salt_type = SALT_TYPE_NONE;
9950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE
9952 | OPTS_TYPE_PT_ADD01;
9953 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9954 dgst_size = DGST_SIZE_4_8;
9955 parse_func = gost2012sbog_256_parse_hash;
9956 sort_by_digest = sort_by_digest_4_8;
9957 opti_type = OPTI_TYPE_ZERO_BYTE;
9958 dgst_pos0 = 0;
9959 dgst_pos1 = 1;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 3;
9962 break;
9963
9964 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9965 salt_type = SALT_TYPE_NONE;
9966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_PT_ADD01;
9969 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9970 dgst_size = DGST_SIZE_4_16;
9971 parse_func = gost2012sbog_512_parse_hash;
9972 sort_by_digest = sort_by_digest_4_16;
9973 opti_type = OPTI_TYPE_ZERO_BYTE;
9974 dgst_pos0 = 0;
9975 dgst_pos1 = 1;
9976 dgst_pos2 = 2;
9977 dgst_pos3 = 3;
9978 break;
9979
9980 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9981 salt_type = SALT_TYPE_EMBEDDED;
9982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9983 opts_type = OPTS_TYPE_PT_GENERATE_LE
9984 | OPTS_TYPE_ST_BASE64
9985 | OPTS_TYPE_HASH_COPY;
9986 kern_type = KERN_TYPE_PBKDF2_MD5;
9987 dgst_size = DGST_SIZE_4_32;
9988 parse_func = pbkdf2_md5_parse_hash;
9989 sort_by_digest = sort_by_digest_4_32;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_SLOW_HASH_SIMD;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE
10002 | OPTS_TYPE_ST_BASE64
10003 | OPTS_TYPE_HASH_COPY;
10004 kern_type = KERN_TYPE_PBKDF2_SHA1;
10005 dgst_size = DGST_SIZE_4_32;
10006 parse_func = pbkdf2_sha1_parse_hash;
10007 sort_by_digest = sort_by_digest_4_32;
10008 opti_type = OPTI_TYPE_ZERO_BYTE
10009 | OPTI_TYPE_SLOW_HASH_SIMD;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_ST_BASE64
10021 | OPTS_TYPE_HASH_COPY;
10022 kern_type = KERN_TYPE_PBKDF2_SHA512;
10023 dgst_size = DGST_SIZE_8_16;
10024 parse_func = pbkdf2_sha512_parse_hash;
10025 sort_by_digest = sort_by_digest_8_16;
10026 opti_type = OPTI_TYPE_ZERO_BYTE
10027 | OPTI_TYPE_USES_BITS_64
10028 | OPTI_TYPE_SLOW_HASH_SIMD;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10036 salt_type = SALT_TYPE_EMBEDDED;
10037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10039 kern_type = KERN_TYPE_ECRYPTFS;
10040 dgst_size = DGST_SIZE_8_8;
10041 parse_func = ecryptfs_parse_hash;
10042 sort_by_digest = sort_by_digest_8_8;
10043 opti_type = OPTI_TYPE_ZERO_BYTE
10044 | OPTI_TYPE_USES_BITS_64;
10045 dgst_pos0 = 0;
10046 dgst_pos1 = 1;
10047 dgst_pos2 = 2;
10048 dgst_pos3 = 3;
10049 break;
10050
10051 case 12300: hash_type = HASH_TYPE_ORACLET;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10055 kern_type = KERN_TYPE_ORACLET;
10056 dgst_size = DGST_SIZE_8_16;
10057 parse_func = oraclet_parse_hash;
10058 sort_by_digest = sort_by_digest_8_16;
10059 opti_type = OPTI_TYPE_ZERO_BYTE
10060 | OPTI_TYPE_USES_BITS_64;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10071 kern_type = KERN_TYPE_BSDICRYPT;
10072 dgst_size = DGST_SIZE_4_4;
10073 parse_func = bsdicrypt_parse_hash;
10074 sort_by_digest = sort_by_digest_4_4;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12500: hash_type = HASH_TYPE_RAR3HP;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_RAR3;
10088 dgst_size = DGST_SIZE_4_4;
10089 parse_func = rar3hp_parse_hash;
10090 sort_by_digest = sort_by_digest_4_4;
10091 opti_type = OPTI_TYPE_ZERO_BYTE;
10092 dgst_pos0 = 0;
10093 dgst_pos1 = 1;
10094 dgst_pos2 = 2;
10095 dgst_pos3 = 3;
10096 break;
10097
10098 case 12600: hash_type = HASH_TYPE_SHA256;
10099 salt_type = SALT_TYPE_INTERN;
10100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10101 opts_type = OPTS_TYPE_PT_GENERATE_BE
10102 | OPTS_TYPE_PT_ADD80;
10103 kern_type = KERN_TYPE_CF10;
10104 dgst_size = DGST_SIZE_4_8;
10105 parse_func = cf10_parse_hash;
10106 sort_by_digest = sort_by_digest_4_8;
10107 opti_type = OPTI_TYPE_ZERO_BYTE
10108 | OPTI_TYPE_PRECOMPUTE_INIT
10109 | OPTI_TYPE_EARLY_SKIP
10110 | OPTI_TYPE_NOT_ITERATED;
10111 dgst_pos0 = 3;
10112 dgst_pos1 = 7;
10113 dgst_pos2 = 2;
10114 dgst_pos3 = 6;
10115 break;
10116
10117 case 12700: hash_type = HASH_TYPE_AES;
10118 salt_type = SALT_TYPE_EMBEDDED;
10119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10120 opts_type = OPTS_TYPE_PT_GENERATE_LE
10121 | OPTS_TYPE_HASH_COPY;
10122 kern_type = KERN_TYPE_MYWALLET;
10123 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10124 parse_func = mywallet_parse_hash;
10125 sort_by_digest = sort_by_digest_4_5;
10126 opti_type = OPTI_TYPE_ZERO_BYTE;
10127 dgst_pos0 = 0;
10128 dgst_pos1 = 1;
10129 dgst_pos2 = 2;
10130 dgst_pos3 = 3;
10131 break;
10132
10133 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10134 salt_type = SALT_TYPE_EMBEDDED;
10135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10137 kern_type = KERN_TYPE_MS_DRSR;
10138 dgst_size = DGST_SIZE_4_8;
10139 parse_func = ms_drsr_parse_hash;
10140 sort_by_digest = sort_by_digest_4_8;
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 12900: 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_ANDROIDFDE_SAMSUNG;
10153 dgst_size = DGST_SIZE_4_8;
10154 parse_func = androidfde_samsung_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 13000: 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_RAR5;
10168 dgst_size = DGST_SIZE_4_4;
10169 parse_func = rar5_parse_hash;
10170 sort_by_digest = sort_by_digest_4_4;
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 13100: hash_type = HASH_TYPE_KRB5TGS;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10182 kern_type = KERN_TYPE_KRB5TGS;
10183 dgst_size = DGST_SIZE_4_4;
10184 parse_func = krb5tgs_parse_hash;
10185 sort_by_digest = sort_by_digest_4_4;
10186 opti_type = OPTI_TYPE_ZERO_BYTE
10187 | OPTI_TYPE_NOT_ITERATED;
10188 dgst_pos0 = 0;
10189 dgst_pos1 = 1;
10190 dgst_pos2 = 2;
10191 dgst_pos3 = 3;
10192 break;
10193
10194 case 13200: hash_type = HASH_TYPE_AES;
10195 salt_type = SALT_TYPE_EMBEDDED;
10196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10198 kern_type = KERN_TYPE_AXCRYPT;
10199 dgst_size = DGST_SIZE_4_4;
10200 parse_func = axcrypt_parse_hash;
10201 sort_by_digest = sort_by_digest_4_4;
10202 opti_type = OPTI_TYPE_ZERO_BYTE;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 13300: hash_type = HASH_TYPE_SHA1;
10210 salt_type = SALT_TYPE_NONE;
10211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_BE
10213 | OPTS_TYPE_PT_ADD80
10214 | OPTS_TYPE_PT_ADDBITS15;
10215 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10216 dgst_size = DGST_SIZE_4_5;
10217 parse_func = sha1axcrypt_parse_hash;
10218 sort_by_digest = sort_by_digest_4_5;
10219 opti_type = OPTI_TYPE_ZERO_BYTE
10220 | OPTI_TYPE_PRECOMPUTE_INIT
10221 | OPTI_TYPE_EARLY_SKIP
10222 | OPTI_TYPE_NOT_ITERATED
10223 | OPTI_TYPE_NOT_SALTED;
10224 dgst_pos0 = 0;
10225 dgst_pos1 = 4;
10226 dgst_pos2 = 3;
10227 dgst_pos3 = 2;
10228 break;
10229
10230 case 13400: hash_type = HASH_TYPE_AES;
10231 salt_type = SALT_TYPE_EMBEDDED;
10232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10234 kern_type = KERN_TYPE_KEEPASS;
10235 dgst_size = DGST_SIZE_4_4;
10236 parse_func = keepass_parse_hash;
10237 sort_by_digest = sort_by_digest_4_4;
10238 opti_type = OPTI_TYPE_ZERO_BYTE;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 13500: hash_type = HASH_TYPE_SHA1;
10246 salt_type = SALT_TYPE_EMBEDDED;
10247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_BE
10249 | OPTS_TYPE_PT_UNICODE
10250 | OPTS_TYPE_PT_ADD80;
10251 kern_type = KERN_TYPE_PSTOKEN;
10252 dgst_size = DGST_SIZE_4_5;
10253 parse_func = pstoken_parse_hash;
10254 sort_by_digest = sort_by_digest_4_5;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_PRECOMPUTE_INIT
10257 | OPTI_TYPE_EARLY_SKIP
10258 | OPTI_TYPE_NOT_ITERATED
10259 | OPTI_TYPE_PREPENDED_SALT
10260 | OPTI_TYPE_RAW_HASH;
10261 dgst_pos0 = 3;
10262 dgst_pos1 = 4;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 1;
10265 break;
10266
10267 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_ZIP2;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = zip2_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE;
10276 dgst_pos0 = 0;
10277 dgst_pos1 = 1;
10278 dgst_pos2 = 2;
10279 dgst_pos3 = 3;
10280 break;
10281
10282 default: usage_mini_print (PROGNAME); return (-1);
10283 }
10284
10285 /**
10286 * parser
10287 */
10288
10289 data.parse_func = parse_func;
10290
10291 /**
10292 * misc stuff
10293 */
10294
10295 if (hex_salt)
10296 {
10297 if (salt_type == SALT_TYPE_INTERN)
10298 {
10299 opts_type |= OPTS_TYPE_ST_HEX;
10300 }
10301 else
10302 {
10303 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10304
10305 return (-1);
10306 }
10307 }
10308
10309 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10310 | (salt_type == SALT_TYPE_EXTERN)
10311 | (salt_type == SALT_TYPE_EMBEDDED)
10312 | (salt_type == SALT_TYPE_VIRTUAL));
10313
10314 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10315
10316 data.hash_type = hash_type;
10317 data.attack_mode = attack_mode;
10318 data.attack_kern = attack_kern;
10319 data.attack_exec = attack_exec;
10320 data.kern_type = kern_type;
10321 data.opts_type = opts_type;
10322 data.dgst_size = dgst_size;
10323 data.salt_type = salt_type;
10324 data.isSalted = isSalted;
10325 data.sort_by_digest = sort_by_digest;
10326 data.dgst_pos0 = dgst_pos0;
10327 data.dgst_pos1 = dgst_pos1;
10328 data.dgst_pos2 = dgst_pos2;
10329 data.dgst_pos3 = dgst_pos3;
10330
10331 esalt_size = 0;
10332
10333 switch (hash_mode)
10334 {
10335 case 2500: esalt_size = sizeof (wpa_t); break;
10336 case 5300: esalt_size = sizeof (ikepsk_t); break;
10337 case 5400: esalt_size = sizeof (ikepsk_t); break;
10338 case 5500: esalt_size = sizeof (netntlm_t); break;
10339 case 5600: esalt_size = sizeof (netntlm_t); break;
10340 case 6211: esalt_size = sizeof (tc_t); break;
10341 case 6212: esalt_size = sizeof (tc_t); break;
10342 case 6213: esalt_size = sizeof (tc_t); break;
10343 case 6221: esalt_size = sizeof (tc_t); break;
10344 case 6222: esalt_size = sizeof (tc_t); break;
10345 case 6223: esalt_size = sizeof (tc_t); break;
10346 case 6231: esalt_size = sizeof (tc_t); break;
10347 case 6232: esalt_size = sizeof (tc_t); break;
10348 case 6233: esalt_size = sizeof (tc_t); break;
10349 case 6241: esalt_size = sizeof (tc_t); break;
10350 case 6242: esalt_size = sizeof (tc_t); break;
10351 case 6243: esalt_size = sizeof (tc_t); break;
10352 case 6600: esalt_size = sizeof (agilekey_t); break;
10353 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10354 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10355 case 7300: esalt_size = sizeof (rakp_t); break;
10356 case 7500: esalt_size = sizeof (krb5pa_t); break;
10357 case 8200: esalt_size = sizeof (cloudkey_t); break;
10358 case 8800: esalt_size = sizeof (androidfde_t); break;
10359 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10360 case 9400: esalt_size = sizeof (office2007_t); break;
10361 case 9500: esalt_size = sizeof (office2010_t); break;
10362 case 9600: esalt_size = sizeof (office2013_t); break;
10363 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10364 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10365 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10366 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10367 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10368 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10369 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10370 case 10200: esalt_size = sizeof (cram_md5_t); break;
10371 case 10400: esalt_size = sizeof (pdf_t); break;
10372 case 10410: esalt_size = sizeof (pdf_t); break;
10373 case 10420: esalt_size = sizeof (pdf_t); break;
10374 case 10500: esalt_size = sizeof (pdf_t); break;
10375 case 10600: esalt_size = sizeof (pdf_t); break;
10376 case 10700: esalt_size = sizeof (pdf_t); break;
10377 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10378 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10379 case 11400: esalt_size = sizeof (sip_t); break;
10380 case 11600: esalt_size = sizeof (seven_zip_t); break;
10381 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10382 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10383 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10384 case 13000: esalt_size = sizeof (rar5_t); break;
10385 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10386 case 13400: esalt_size = sizeof (keepass_t); break;
10387 case 13500: esalt_size = sizeof (pstoken_t); break;
10388 case 13600: esalt_size = sizeof (zip2_t); break;
10389 }
10390
10391 data.esalt_size = esalt_size;
10392
10393 /**
10394 * choose dictionary parser
10395 */
10396
10397 if (hash_type == HASH_TYPE_LM)
10398 {
10399 get_next_word_func = get_next_word_lm;
10400 }
10401 else if (opts_type & OPTS_TYPE_PT_UPPER)
10402 {
10403 get_next_word_func = get_next_word_uc;
10404 }
10405 else
10406 {
10407 get_next_word_func = get_next_word_std;
10408 }
10409
10410 /**
10411 * dictstat
10412 */
10413
10414 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10415
10416 #ifdef _POSIX
10417 size_t dictstat_nmemb = 0;
10418 #endif
10419
10420 #ifdef _WIN
10421 uint dictstat_nmemb = 0;
10422 #endif
10423
10424 char dictstat[256] = { 0 };
10425
10426 FILE *dictstat_fp = NULL;
10427
10428 if (keyspace == 0)
10429 {
10430 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10431
10432 dictstat_fp = fopen (dictstat, "rb");
10433
10434 if (dictstat_fp)
10435 {
10436 #ifdef _POSIX
10437 struct stat tmpstat;
10438
10439 fstat (fileno (dictstat_fp), &tmpstat);
10440 #endif
10441
10442 #ifdef _WIN
10443 struct stat64 tmpstat;
10444
10445 _fstat64 (fileno (dictstat_fp), &tmpstat);
10446 #endif
10447
10448 if (tmpstat.st_mtime < COMPTIME)
10449 {
10450 /* with v0.15 the format changed so we have to ensure user is using a good version
10451 since there is no version-header in the dictstat file */
10452
10453 fclose (dictstat_fp);
10454
10455 unlink (dictstat);
10456 }
10457 else
10458 {
10459 while (!feof (dictstat_fp))
10460 {
10461 dictstat_t d;
10462
10463 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10464
10465 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10466
10467 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10468 {
10469 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10470
10471 return -1;
10472 }
10473 }
10474
10475 fclose (dictstat_fp);
10476 }
10477 }
10478 }
10479
10480 /**
10481 * potfile
10482 */
10483
10484 char potfile[256] = { 0 };
10485
10486 if (potfile_path == NULL)
10487 {
10488 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10489 }
10490 else
10491 {
10492 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10493 }
10494
10495 data.pot_fp = NULL;
10496
10497 FILE *out_fp = NULL;
10498 FILE *pot_fp = NULL;
10499
10500 if (show == 1 || left == 1)
10501 {
10502 pot_fp = fopen (potfile, "rb");
10503
10504 if (pot_fp == NULL)
10505 {
10506 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10507
10508 return (-1);
10509 }
10510
10511 if (outfile != NULL)
10512 {
10513 if ((out_fp = fopen (outfile, "ab")) == NULL)
10514 {
10515 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10516
10517 fclose (pot_fp);
10518
10519 return (-1);
10520 }
10521 }
10522 else
10523 {
10524 out_fp = stdout;
10525 }
10526 }
10527 else
10528 {
10529 if (potfile_disable == 0)
10530 {
10531 pot_fp = fopen (potfile, "ab");
10532
10533 if (pot_fp == NULL)
10534 {
10535 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10536
10537 return (-1);
10538 }
10539
10540 data.pot_fp = pot_fp;
10541 }
10542 }
10543
10544 pot_t *pot = NULL;
10545
10546 uint pot_cnt = 0;
10547 uint pot_avail = 0;
10548
10549 if (show == 1 || left == 1)
10550 {
10551 SUPPRESS_OUTPUT = 1;
10552
10553 pot_avail = count_lines (pot_fp);
10554
10555 rewind (pot_fp);
10556
10557 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10558
10559 uint pot_hashes_avail = 0;
10560
10561 uint line_num = 0;
10562
10563 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10564
10565 while (!feof (pot_fp))
10566 {
10567 line_num++;
10568
10569 int line_len = fgetl (pot_fp, line_buf);
10570
10571 if (line_len == 0) continue;
10572
10573 char *plain_buf = line_buf + line_len;
10574
10575 pot_t *pot_ptr = &pot[pot_cnt];
10576
10577 hash_t *hashes_buf = &pot_ptr->hash;
10578
10579 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10580 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10581
10582 if (pot_cnt == pot_hashes_avail)
10583 {
10584 uint pos = 0;
10585
10586 for (pos = 0; pos < INCR_POT; pos++)
10587 {
10588 if ((pot_cnt + pos) >= pot_avail) break;
10589
10590 pot_t *tmp_pot = &pot[pot_cnt + pos];
10591
10592 hash_t *tmp_hash = &tmp_pot->hash;
10593
10594 tmp_hash->digest = mymalloc (dgst_size);
10595
10596 if (isSalted)
10597 {
10598 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10599 }
10600
10601 if (esalt_size)
10602 {
10603 tmp_hash->esalt = mymalloc (esalt_size);
10604 }
10605
10606 pot_hashes_avail++;
10607 }
10608 }
10609
10610 int plain_len = 0;
10611
10612 int parser_status;
10613
10614 int iter = MAX_CUT_TRIES;
10615
10616 do
10617 {
10618 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10619 {
10620 if (line_buf[i] == ':')
10621 {
10622 line_len--;
10623
10624 break;
10625 }
10626 }
10627
10628 if (data.hash_mode != 2500)
10629 {
10630 parser_status = parse_func (line_buf, line_len, hashes_buf);
10631 }
10632 else
10633 {
10634 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10635
10636 if (line_len > max_salt_size)
10637 {
10638 parser_status = PARSER_GLOBAL_LENGTH;
10639 }
10640 else
10641 {
10642 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10643
10644 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10645
10646 hashes_buf->salt->salt_len = line_len;
10647
10648 parser_status = PARSER_OK;
10649 }
10650 }
10651
10652 // if NOT parsed without error, we add the ":" to the plain
10653
10654 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10655 {
10656 plain_len++;
10657 plain_buf--;
10658 }
10659
10660 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10661
10662 if (parser_status < PARSER_GLOBAL_ZERO)
10663 {
10664 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10665
10666 continue;
10667 }
10668
10669 if (plain_len >= 255) continue;
10670
10671 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10672
10673 pot_ptr->plain_len = plain_len;
10674
10675 pot_cnt++;
10676 }
10677
10678 myfree (line_buf);
10679
10680 fclose (pot_fp);
10681
10682 SUPPRESS_OUTPUT = 0;
10683
10684 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10685 }
10686
10687 /**
10688 * word len
10689 */
10690
10691 uint pw_min = PW_MIN;
10692 uint pw_max = PW_MAX;
10693
10694 switch (hash_mode)
10695 {
10696 case 125: if (pw_max > 32) pw_max = 32;
10697 break;
10698 case 400: if (pw_max > 40) pw_max = 40;
10699 break;
10700 case 500: if (pw_max > 16) pw_max = 16;
10701 break;
10702 case 1500: if (pw_max > 8) pw_max = 8;
10703 break;
10704 case 1600: if (pw_max > 16) pw_max = 16;
10705 break;
10706 case 1800: if (pw_max > 16) pw_max = 16;
10707 break;
10708 case 2100: if (pw_max > 16) pw_max = 16;
10709 break;
10710 case 2500: if (pw_min < 8) pw_min = 8;
10711 break;
10712 case 3000: if (pw_max > 7) pw_max = 7;
10713 break;
10714 case 5200: if (pw_max > 24) pw_max = 24;
10715 break;
10716 case 5800: if (pw_max > 16) pw_max = 16;
10717 break;
10718 case 6300: if (pw_max > 16) pw_max = 16;
10719 break;
10720 case 7400: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 7900: if (pw_max > 48) pw_max = 48;
10723 break;
10724 case 8500: if (pw_max > 8) pw_max = 8;
10725 break;
10726 case 8600: if (pw_max > 16) pw_max = 16;
10727 break;
10728 case 9710: pw_min = 5;
10729 pw_max = 5;
10730 break;
10731 case 9810: pw_min = 5;
10732 pw_max = 5;
10733 break;
10734 case 10410: pw_min = 5;
10735 pw_max = 5;
10736 break;
10737 case 10300: if (pw_max < 3) pw_min = 3;
10738 if (pw_max > 40) pw_max = 40;
10739 break;
10740 case 10500: if (pw_max < 3) pw_min = 3;
10741 if (pw_max > 40) pw_max = 40;
10742 break;
10743 case 10700: if (pw_max > 16) pw_max = 16;
10744 break;
10745 case 11300: if (pw_max > 40) pw_max = 40;
10746 break;
10747 case 11600: if (pw_max > 32) pw_max = 32;
10748 break;
10749 case 12500: if (pw_max > 20) pw_max = 20;
10750 break;
10751 case 12800: if (pw_max > 24) pw_max = 24;
10752 break;
10753 }
10754
10755 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10756 {
10757 switch (attack_kern)
10758 {
10759 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10760 break;
10761 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10762 break;
10763 }
10764 }
10765
10766 /**
10767 * charsets : keep them together for more easy maintainnce
10768 */
10769
10770 cs_t mp_sys[6] = { { { 0 }, 0 } };
10771 cs_t mp_usr[4] = { { { 0 }, 0 } };
10772
10773 mp_setup_sys (mp_sys);
10774
10775 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10776 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10777 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10778 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10779
10780 /**
10781 * load hashes, part I: find input mode, count hashes
10782 */
10783
10784 uint hashlist_mode = 0;
10785 uint hashlist_format = HLFMT_HASHCAT;
10786
10787 uint hashes_avail = 0;
10788
10789 if (benchmark == 0)
10790 {
10791 struct stat f;
10792
10793 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10794
10795 if ((hash_mode == 2500) ||
10796 (hash_mode == 5200) ||
10797 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10798 (hash_mode == 9000))
10799 {
10800 hashlist_mode = HL_MODE_ARG;
10801
10802 char *hashfile = myargv[optind];
10803
10804 data.hashfile = hashfile;
10805
10806 logfile_top_var_string ("target", hashfile);
10807 }
10808
10809 if (hashlist_mode == HL_MODE_ARG)
10810 {
10811 if (hash_mode == 2500)
10812 {
10813 struct stat st;
10814
10815 if (stat (data.hashfile, &st) == -1)
10816 {
10817 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10818
10819 return (-1);
10820 }
10821
10822 hashes_avail = st.st_size / sizeof (hccap_t);
10823 }
10824 else
10825 {
10826 hashes_avail = 1;
10827 }
10828 }
10829 else if (hashlist_mode == HL_MODE_FILE)
10830 {
10831 char *hashfile = myargv[optind];
10832
10833 data.hashfile = hashfile;
10834
10835 logfile_top_var_string ("target", hashfile);
10836
10837 FILE *fp = NULL;
10838
10839 if ((fp = fopen (hashfile, "rb")) == NULL)
10840 {
10841 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10842
10843 return (-1);
10844 }
10845
10846 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10847
10848 hashes_avail = count_lines (fp);
10849
10850 rewind (fp);
10851
10852 if (hashes_avail == 0)
10853 {
10854 log_error ("ERROR: hashfile is empty or corrupt");
10855
10856 fclose (fp);
10857
10858 return (-1);
10859 }
10860
10861 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10862
10863 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10864 {
10865 log_error ("ERROR: remove not supported in native hashfile-format mode");
10866
10867 fclose (fp);
10868
10869 return (-1);
10870 }
10871
10872 fclose (fp);
10873 }
10874 }
10875 else
10876 {
10877 hashlist_mode = HL_MODE_ARG;
10878
10879 hashes_avail = 1;
10880 }
10881
10882 if (hash_mode == 3000) hashes_avail *= 2;
10883
10884 data.hashlist_mode = hashlist_mode;
10885 data.hashlist_format = hashlist_format;
10886
10887 logfile_top_uint (hashlist_mode);
10888 logfile_top_uint (hashlist_format);
10889
10890 /**
10891 * load hashes, part II: allocate required memory, set pointers
10892 */
10893
10894 hash_t *hashes_buf = NULL;
10895 void *digests_buf = NULL;
10896 salt_t *salts_buf = NULL;
10897 void *esalts_buf = NULL;
10898
10899 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10900
10901 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10902
10903 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10904 {
10905 u32 hash_pos;
10906
10907 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10908 {
10909 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10910
10911 hashes_buf[hash_pos].hash_info = hash_info;
10912
10913 if (username && (remove || show || left))
10914 {
10915 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10916 }
10917
10918 if (benchmark)
10919 {
10920 hash_info->orighash = (char *) mymalloc (256);
10921 }
10922 }
10923 }
10924
10925 if (isSalted)
10926 {
10927 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10928
10929 if (esalt_size)
10930 {
10931 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10932 }
10933 }
10934 else
10935 {
10936 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10937 }
10938
10939 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10940 {
10941 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10942
10943 if (isSalted)
10944 {
10945 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10946
10947 if (esalt_size)
10948 {
10949 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10950 }
10951 }
10952 else
10953 {
10954 hashes_buf[hash_pos].salt = &salts_buf[0];
10955 }
10956 }
10957
10958 /**
10959 * load hashes, part III: parse hashes or generate them if benchmark
10960 */
10961
10962 uint hashes_cnt = 0;
10963
10964 if (benchmark == 0)
10965 {
10966 if (keyspace == 1)
10967 {
10968 // useless to read hash file for keyspace, cheat a little bit w/ optind
10969 }
10970 else if (hashes_avail == 0)
10971 {
10972 }
10973 else if (hashlist_mode == HL_MODE_ARG)
10974 {
10975 char *input_buf = myargv[optind];
10976
10977 uint input_len = strlen (input_buf);
10978
10979 logfile_top_var_string ("target", input_buf);
10980
10981 char *hash_buf = NULL;
10982 int hash_len = 0;
10983
10984 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10985
10986 bool hash_fmt_error = 0;
10987
10988 if (hash_len < 1) hash_fmt_error = 1;
10989 if (hash_buf == NULL) hash_fmt_error = 1;
10990
10991 if (hash_fmt_error)
10992 {
10993 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10994 }
10995 else
10996 {
10997 if (opts_type & OPTS_TYPE_HASH_COPY)
10998 {
10999 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11000
11001 hash_info_tmp->orighash = mystrdup (hash_buf);
11002 }
11003
11004 if (isSalted)
11005 {
11006 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11007 }
11008
11009 int parser_status = PARSER_OK;
11010
11011 if (hash_mode == 2500)
11012 {
11013 if (hash_len == 0)
11014 {
11015 log_error ("ERROR: hccap file not specified");
11016
11017 return (-1);
11018 }
11019
11020 hashlist_mode = HL_MODE_FILE;
11021
11022 data.hashlist_mode = hashlist_mode;
11023
11024 FILE *fp = fopen (hash_buf, "rb");
11025
11026 if (fp == NULL)
11027 {
11028 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11029
11030 return (-1);
11031 }
11032
11033 if (hashes_avail < 1)
11034 {
11035 log_error ("ERROR: hccap file is empty or corrupt");
11036
11037 fclose (fp);
11038
11039 return (-1);
11040 }
11041
11042 uint hccap_size = sizeof (hccap_t);
11043
11044 char *in = (char *) mymalloc (hccap_size);
11045
11046 while (!feof (fp))
11047 {
11048 int n = fread (in, hccap_size, 1, fp);
11049
11050 if (n != 1)
11051 {
11052 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11053
11054 break;
11055 }
11056
11057 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11058
11059 if (parser_status != PARSER_OK)
11060 {
11061 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11062
11063 continue;
11064 }
11065
11066 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11067
11068 if ((show == 1) || (left == 1))
11069 {
11070 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11071
11072 char *salt_ptr = (char *) tmp_salt->salt_buf;
11073
11074 int cur_pos = tmp_salt->salt_len;
11075 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11076
11077 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11078
11079 // do the appending task
11080
11081 snprintf (salt_ptr + cur_pos,
11082 rem_len,
11083 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11084 wpa->orig_mac1[0],
11085 wpa->orig_mac1[1],
11086 wpa->orig_mac1[2],
11087 wpa->orig_mac1[3],
11088 wpa->orig_mac1[4],
11089 wpa->orig_mac1[5],
11090 wpa->orig_mac2[0],
11091 wpa->orig_mac2[1],
11092 wpa->orig_mac2[2],
11093 wpa->orig_mac2[3],
11094 wpa->orig_mac2[4],
11095 wpa->orig_mac2[5]);
11096
11097 // memset () the remaining part of the salt
11098
11099 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11100 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11101
11102 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11103
11104 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11105 }
11106
11107 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);
11108 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);
11109
11110 hashes_cnt++;
11111 }
11112
11113 fclose (fp);
11114
11115 myfree (in);
11116 }
11117 else if (hash_mode == 3000)
11118 {
11119 if (hash_len == 32)
11120 {
11121 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11122
11123 hash_t *lm_hash_left = NULL;
11124
11125 if (parser_status == PARSER_OK)
11126 {
11127 lm_hash_left = &hashes_buf[hashes_cnt];
11128
11129 hashes_cnt++;
11130 }
11131 else
11132 {
11133 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11134 }
11135
11136 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11137
11138 hash_t *lm_hash_right = NULL;
11139
11140 if (parser_status == PARSER_OK)
11141 {
11142 lm_hash_right = &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 // show / left
11152
11153 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11154 {
11155 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);
11156 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);
11157 }
11158 }
11159 else
11160 {
11161 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11162
11163 if (parser_status == PARSER_OK)
11164 {
11165 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11166 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11167 }
11168
11169 if (parser_status == PARSER_OK)
11170 {
11171 hashes_cnt++;
11172 }
11173 else
11174 {
11175 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11176 }
11177 }
11178 }
11179 else
11180 {
11181 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11182
11183 if (parser_status == PARSER_OK)
11184 {
11185 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11186 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11187 }
11188
11189 if (parser_status == PARSER_OK)
11190 {
11191 hashes_cnt++;
11192 }
11193 else
11194 {
11195 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11196 }
11197 }
11198 }
11199 }
11200 else if (hashlist_mode == HL_MODE_FILE)
11201 {
11202 char *hashfile = data.hashfile;
11203
11204 FILE *fp;
11205
11206 if ((fp = fopen (hashfile, "rb")) == NULL)
11207 {
11208 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11209
11210 return (-1);
11211 }
11212
11213 uint line_num = 0;
11214
11215 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11216
11217 while (!feof (fp))
11218 {
11219 line_num++;
11220
11221 int line_len = fgetl (fp, line_buf);
11222
11223 if (line_len == 0) continue;
11224
11225 char *hash_buf = NULL;
11226 int hash_len = 0;
11227
11228 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11229
11230 bool hash_fmt_error = 0;
11231
11232 if (hash_len < 1) hash_fmt_error = 1;
11233 if (hash_buf == NULL) hash_fmt_error = 1;
11234
11235 if (hash_fmt_error)
11236 {
11237 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11238
11239 continue;
11240 }
11241
11242 if (username)
11243 {
11244 char *user_buf = NULL;
11245 int user_len = 0;
11246
11247 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11248
11249 if (remove || show)
11250 {
11251 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11252
11253 *user = (user_t *) mymalloc (sizeof (user_t));
11254
11255 user_t *user_ptr = *user;
11256
11257 if (user_buf != NULL)
11258 {
11259 user_ptr->user_name = mystrdup (user_buf);
11260 }
11261 else
11262 {
11263 user_ptr->user_name = mystrdup ("");
11264 }
11265
11266 user_ptr->user_len = user_len;
11267 }
11268 }
11269
11270 if (opts_type & OPTS_TYPE_HASH_COPY)
11271 {
11272 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11273
11274 hash_info_tmp->orighash = mystrdup (hash_buf);
11275 }
11276
11277 if (isSalted)
11278 {
11279 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11280 }
11281
11282 if (hash_mode == 3000)
11283 {
11284 if (hash_len == 32)
11285 {
11286 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11287
11288 if (parser_status < PARSER_GLOBAL_ZERO)
11289 {
11290 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11291
11292 continue;
11293 }
11294
11295 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11296
11297 hashes_cnt++;
11298
11299 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11300
11301 if (parser_status < PARSER_GLOBAL_ZERO)
11302 {
11303 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11304
11305 continue;
11306 }
11307
11308 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11309
11310 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);
11311
11312 hashes_cnt++;
11313
11314 // show / left
11315
11316 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);
11317 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);
11318 }
11319 else
11320 {
11321 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11322
11323 if (parser_status < PARSER_GLOBAL_ZERO)
11324 {
11325 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11326
11327 continue;
11328 }
11329
11330 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);
11331
11332 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11333 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11334
11335 hashes_cnt++;
11336 }
11337 }
11338 else
11339 {
11340 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11341
11342 if (parser_status < PARSER_GLOBAL_ZERO)
11343 {
11344 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11345
11346 continue;
11347 }
11348
11349 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);
11350
11351 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11352 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11353
11354 hashes_cnt++;
11355 }
11356 }
11357
11358 myfree (line_buf);
11359
11360 fclose (fp);
11361
11362 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11363
11364 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11365 }
11366 }
11367 else
11368 {
11369 if (isSalted)
11370 {
11371 hashes_buf[0].salt->salt_len = 8;
11372
11373 // special salt handling
11374
11375 switch (hash_mode)
11376 {
11377 case 1500: hashes_buf[0].salt->salt_len = 2;
11378 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11379 break;
11380 case 1731: hashes_buf[0].salt->salt_len = 4;
11381 break;
11382 case 2410: hashes_buf[0].salt->salt_len = 4;
11383 break;
11384 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11385 break;
11386 case 3100: hashes_buf[0].salt->salt_len = 1;
11387 break;
11388 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11389 break;
11390 case 5800: hashes_buf[0].salt->salt_len = 16;
11391 break;
11392 case 6800: hashes_buf[0].salt->salt_len = 32;
11393 break;
11394 case 8400: hashes_buf[0].salt->salt_len = 40;
11395 break;
11396 case 8800: hashes_buf[0].salt->salt_len = 16;
11397 break;
11398 case 8900: hashes_buf[0].salt->salt_len = 16;
11399 hashes_buf[0].salt->scrypt_N = 1024;
11400 hashes_buf[0].salt->scrypt_r = 1;
11401 hashes_buf[0].salt->scrypt_p = 1;
11402 break;
11403 case 9100: hashes_buf[0].salt->salt_len = 16;
11404 break;
11405 case 9300: hashes_buf[0].salt->salt_len = 14;
11406 hashes_buf[0].salt->scrypt_N = 16384;
11407 hashes_buf[0].salt->scrypt_r = 1;
11408 hashes_buf[0].salt->scrypt_p = 1;
11409 break;
11410 case 9400: hashes_buf[0].salt->salt_len = 16;
11411 break;
11412 case 9500: hashes_buf[0].salt->salt_len = 16;
11413 break;
11414 case 9600: hashes_buf[0].salt->salt_len = 16;
11415 break;
11416 case 9700: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 9710: hashes_buf[0].salt->salt_len = 16;
11419 break;
11420 case 9720: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 9800: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9810: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9820: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 10300: hashes_buf[0].salt->salt_len = 12;
11429 break;
11430 case 11500: hashes_buf[0].salt->salt_len = 4;
11431 break;
11432 case 11600: hashes_buf[0].salt->salt_len = 4;
11433 break;
11434 case 12400: hashes_buf[0].salt->salt_len = 4;
11435 break;
11436 case 12500: hashes_buf[0].salt->salt_len = 8;
11437 break;
11438 case 12600: hashes_buf[0].salt->salt_len = 64;
11439 break;
11440 }
11441
11442 // special esalt handling
11443
11444 switch (hash_mode)
11445 {
11446 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11447 break;
11448 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11449 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11450 break;
11451 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11452 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11453 break;
11454 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11455 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11456 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11457 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11458 break;
11459 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11460 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11461 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11462 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11463 break;
11464 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11465 break;
11466 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11467 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11468 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11469 break;
11470 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11471 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11472 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11473 break;
11474 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11475 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11476 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11477 break;
11478 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11481 break;
11482 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11485 break;
11486 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11489 break;
11490 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11491 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11492 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11493 break;
11494 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11495 break;
11496 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11497 break;
11498 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11499 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11500 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11501 break;
11502 }
11503 }
11504
11505 // set hashfile
11506
11507 switch (hash_mode)
11508 {
11509 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11510 break;
11511 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11512 break;
11513 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11514 break;
11515 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11516 break;
11517 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11518 break;
11519 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11520 break;
11521 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11540 break;
11541 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11542 break;
11543 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11544 break;
11545 }
11546
11547 // set default iterations
11548
11549 switch (hash_mode)
11550 {
11551 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11552 break;
11553 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11554 break;
11555 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11556 break;
11557 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11558 break;
11559 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11560 break;
11561 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11562 break;
11563 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11564 break;
11565 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11566 break;
11567 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11568 break;
11569 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11570 break;
11571 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11572 break;
11573 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11574 break;
11575 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11576 break;
11577 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11578 break;
11579 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11580 break;
11581 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11582 break;
11583 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11596 break;
11597 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11598 break;
11599 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11600 break;
11601 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11602 break;
11603 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11604 break;
11605 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11606 break;
11607 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11608 break;
11609 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11610 break;
11611 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11612 break;
11613 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11614 break;
11615 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11616 break;
11617 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11618 break;
11619 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11620 break;
11621 case 8900: hashes_buf[0].salt->salt_iter = 1;
11622 break;
11623 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11624 break;
11625 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11626 break;
11627 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11628 break;
11629 case 9300: hashes_buf[0].salt->salt_iter = 1;
11630 break;
11631 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11632 break;
11633 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11634 break;
11635 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11636 break;
11637 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11638 break;
11639 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11640 break;
11641 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11642 break;
11643 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11644 break;
11645 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11646 break;
11647 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11648 break;
11649 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11650 break;
11651 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11652 break;
11653 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11654 break;
11655 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11656 break;
11657 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11658 break;
11659 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11660 break;
11661 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11662 break;
11663 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11664 break;
11665 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11666 break;
11667 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11668 break;
11669 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11670 break;
11671 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11672 break;
11673 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11674 break;
11675 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11676 break;
11677 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11678 break;
11679 }
11680
11681 hashes_cnt = 1;
11682 }
11683
11684 if (show == 1 || left == 1)
11685 {
11686 for (uint i = 0; i < pot_cnt; i++)
11687 {
11688 pot_t *pot_ptr = &pot[i];
11689
11690 hash_t *hashes_buf = &pot_ptr->hash;
11691
11692 local_free (hashes_buf->digest);
11693
11694 if (isSalted)
11695 {
11696 local_free (hashes_buf->salt);
11697 }
11698 }
11699
11700 local_free (pot);
11701
11702 if (data.quiet == 0) log_info_nn ("");
11703
11704 return (0);
11705 }
11706
11707 if (keyspace == 0)
11708 {
11709 if (hashes_cnt == 0)
11710 {
11711 log_error ("ERROR: No hashes loaded");
11712
11713 return (-1);
11714 }
11715 }
11716
11717 /**
11718 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11719 */
11720
11721 if (data.outfile != NULL)
11722 {
11723 if (data.hashfile != NULL)
11724 {
11725 #ifdef _POSIX
11726 struct stat tmpstat_outfile;
11727 struct stat tmpstat_hashfile;
11728 #endif
11729
11730 #ifdef _WIN
11731 struct stat64 tmpstat_outfile;
11732 struct stat64 tmpstat_hashfile;
11733 #endif
11734
11735 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11736
11737 if (tmp_outfile_fp)
11738 {
11739 #ifdef _POSIX
11740 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11741 #endif
11742
11743 #ifdef _WIN
11744 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11745 #endif
11746
11747 fclose (tmp_outfile_fp);
11748 }
11749
11750 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11751
11752 if (tmp_hashfile_fp)
11753 {
11754 #ifdef _POSIX
11755 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11756 #endif
11757
11758 #ifdef _WIN
11759 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11760 #endif
11761
11762 fclose (tmp_hashfile_fp);
11763 }
11764
11765 if (tmp_outfile_fp && tmp_outfile_fp)
11766 {
11767 tmpstat_outfile.st_mode = 0;
11768 tmpstat_outfile.st_nlink = 0;
11769 tmpstat_outfile.st_uid = 0;
11770 tmpstat_outfile.st_gid = 0;
11771 tmpstat_outfile.st_rdev = 0;
11772 tmpstat_outfile.st_atime = 0;
11773
11774 tmpstat_hashfile.st_mode = 0;
11775 tmpstat_hashfile.st_nlink = 0;
11776 tmpstat_hashfile.st_uid = 0;
11777 tmpstat_hashfile.st_gid = 0;
11778 tmpstat_hashfile.st_rdev = 0;
11779 tmpstat_hashfile.st_atime = 0;
11780
11781 #ifdef _POSIX
11782 tmpstat_outfile.st_blksize = 0;
11783 tmpstat_outfile.st_blocks = 0;
11784
11785 tmpstat_hashfile.st_blksize = 0;
11786 tmpstat_hashfile.st_blocks = 0;
11787 #endif
11788
11789 #ifdef _POSIX
11790 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11791 {
11792 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11793
11794 return (-1);
11795 }
11796 #endif
11797
11798 #ifdef _WIN
11799 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11800 {
11801 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11802
11803 return (-1);
11804 }
11805 #endif
11806 }
11807 }
11808 }
11809
11810 /**
11811 * Remove duplicates
11812 */
11813
11814 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11815
11816 if (isSalted)
11817 {
11818 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11819 }
11820 else
11821 {
11822 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11823 }
11824
11825 uint hashes_cnt_orig = hashes_cnt;
11826
11827 hashes_cnt = 1;
11828
11829 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11830 {
11831 if (isSalted)
11832 {
11833 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11834 {
11835 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11836 }
11837 }
11838 else
11839 {
11840 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11841 }
11842
11843 if (hashes_pos > hashes_cnt)
11844 {
11845 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11846 }
11847
11848 hashes_cnt++;
11849 }
11850
11851 /**
11852 * Potfile removes
11853 */
11854
11855 uint potfile_remove_cracks = 0;
11856
11857 if (potfile_disable == 0)
11858 {
11859 hash_t hash_buf;
11860
11861 hash_buf.digest = mymalloc (dgst_size);
11862 hash_buf.salt = NULL;
11863 hash_buf.esalt = NULL;
11864 hash_buf.hash_info = NULL;
11865 hash_buf.cracked = 0;
11866
11867 if (isSalted)
11868 {
11869 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11870 }
11871
11872 if (esalt_size)
11873 {
11874 hash_buf.esalt = mymalloc (esalt_size);
11875 }
11876
11877 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11878
11879 // no solution for these special hash types (for instane because they use hashfile in output etc)
11880 if ((hash_mode != 5200) &&
11881 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11882 (hash_mode != 9000))
11883 {
11884 FILE *fp = fopen (potfile, "rb");
11885
11886 if (fp != NULL)
11887 {
11888 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11889
11890 // to be safe work with a copy (because of line_len loop, i etc)
11891 // moved up here because it's easier to handle continue case
11892 // it's just 64kb
11893
11894 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11895
11896 while (!feof (fp))
11897 {
11898 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11899
11900 if (ptr == NULL) break;
11901
11902 int line_len = strlen (line_buf);
11903
11904 if (line_len == 0) continue;
11905
11906 int iter = MAX_CUT_TRIES;
11907
11908 for (int i = line_len - 1; i && iter; i--, line_len--)
11909 {
11910 if (line_buf[i] != ':') continue;
11911
11912 if (isSalted)
11913 {
11914 memset (hash_buf.salt, 0, sizeof (salt_t));
11915 }
11916
11917 hash_t *found = NULL;
11918
11919 if (hash_mode == 6800)
11920 {
11921 if (i < 64) // 64 = 16 * uint in salt_buf[]
11922 {
11923 // manipulate salt_buf
11924 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11925
11926 hash_buf.salt->salt_len = i;
11927
11928 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11929 }
11930 }
11931 else if (hash_mode == 2500)
11932 {
11933 if (i < 64) // 64 = 16 * uint in salt_buf[]
11934 {
11935 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11936 // manipulate salt_buf
11937
11938 memcpy (line_buf_cpy, line_buf, i);
11939
11940 char *mac2_pos = strrchr (line_buf_cpy, ':');
11941
11942 if (mac2_pos == NULL) continue;
11943
11944 mac2_pos[0] = 0;
11945 mac2_pos++;
11946
11947 if (strlen (mac2_pos) != 12) continue;
11948
11949 char *mac1_pos = strrchr (line_buf_cpy, ':');
11950
11951 if (mac1_pos == NULL) continue;
11952
11953 mac1_pos[0] = 0;
11954 mac1_pos++;
11955
11956 if (strlen (mac1_pos) != 12) continue;
11957
11958 uint essid_length = mac1_pos - line_buf_cpy - 1;
11959
11960 // here we need the ESSID
11961 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11962
11963 hash_buf.salt->salt_len = essid_length;
11964
11965 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11966
11967 if (found)
11968 {
11969 wpa_t *wpa = (wpa_t *) found->esalt;
11970
11971 // compare hex string(s) vs binary MAC address(es)
11972
11973 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11974 {
11975 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11976 {
11977 found = NULL;
11978
11979 break;
11980 }
11981 }
11982
11983 // early skip ;)
11984 if (!found) continue;
11985
11986 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11987 {
11988 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11989 {
11990 found = NULL;
11991
11992 break;
11993 }
11994 }
11995 }
11996 }
11997 }
11998 else
11999 {
12000 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12001
12002 if (parser_status == PARSER_OK)
12003 {
12004 if (isSalted)
12005 {
12006 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12007 }
12008 else
12009 {
12010 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12011 }
12012 }
12013 }
12014
12015 if (found == NULL) continue;
12016
12017 if (!found->cracked) potfile_remove_cracks++;
12018
12019 found->cracked = 1;
12020
12021 if (found) break;
12022
12023 iter--;
12024 }
12025 }
12026
12027 myfree (line_buf_cpy);
12028
12029 myfree (line_buf);
12030
12031 fclose (fp);
12032 }
12033 }
12034
12035 if (esalt_size)
12036 {
12037 local_free (hash_buf.esalt);
12038 }
12039
12040 if (isSalted)
12041 {
12042 local_free (hash_buf.salt);
12043 }
12044
12045 local_free (hash_buf.digest);
12046 }
12047
12048 /**
12049 * Now generate all the buffers required for later
12050 */
12051
12052 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12053
12054 salt_t *salts_buf_new = NULL;
12055 void *esalts_buf_new = NULL;
12056
12057 if (isSalted)
12058 {
12059 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12060
12061 if (esalt_size)
12062 {
12063 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12064 }
12065 }
12066 else
12067 {
12068 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12069 }
12070
12071 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12072
12073 uint digests_cnt = hashes_cnt;
12074 uint digests_done = 0;
12075
12076 size_t size_digests = digests_cnt * dgst_size;
12077 size_t size_shown = digests_cnt * sizeof (uint);
12078
12079 uint *digests_shown = (uint *) mymalloc (size_shown);
12080 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12081
12082 uint salts_cnt = 0;
12083 uint salts_done = 0;
12084
12085 hashinfo_t **hash_info = NULL;
12086
12087 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12088 {
12089 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12090
12091 if (username && (remove || show))
12092 {
12093 uint user_pos;
12094
12095 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12096 {
12097 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12098
12099 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12100 }
12101 }
12102 }
12103
12104 uint *salts_shown = (uint *) mymalloc (size_shown);
12105
12106 salt_t *salt_buf;
12107
12108 {
12109 // copied from inner loop
12110
12111 salt_buf = &salts_buf_new[salts_cnt];
12112
12113 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12114
12115 if (esalt_size)
12116 {
12117 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12118 }
12119
12120 salt_buf->digests_cnt = 0;
12121 salt_buf->digests_done = 0;
12122 salt_buf->digests_offset = 0;
12123
12124 salts_cnt++;
12125 }
12126
12127 if (hashes_buf[0].cracked == 1)
12128 {
12129 digests_shown[0] = 1;
12130
12131 digests_done++;
12132
12133 salt_buf->digests_done++;
12134 }
12135
12136 salt_buf->digests_cnt++;
12137
12138 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12139
12140 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12141 {
12142 hash_info[0] = hashes_buf[0].hash_info;
12143 }
12144
12145 // copy from inner loop
12146
12147 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12148 {
12149 if (isSalted)
12150 {
12151 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12152 {
12153 salt_buf = &salts_buf_new[salts_cnt];
12154
12155 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12156
12157 if (esalt_size)
12158 {
12159 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12160 }
12161
12162 salt_buf->digests_cnt = 0;
12163 salt_buf->digests_done = 0;
12164 salt_buf->digests_offset = hashes_pos;
12165
12166 salts_cnt++;
12167 }
12168 }
12169
12170 if (hashes_buf[hashes_pos].cracked == 1)
12171 {
12172 digests_shown[hashes_pos] = 1;
12173
12174 digests_done++;
12175
12176 salt_buf->digests_done++;
12177 }
12178
12179 salt_buf->digests_cnt++;
12180
12181 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12182
12183 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12184 {
12185 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12186 }
12187 }
12188
12189 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12190 {
12191 salt_t *salt_buf = &salts_buf_new[salt_pos];
12192
12193 if (salt_buf->digests_done == salt_buf->digests_cnt)
12194 {
12195 salts_shown[salt_pos] = 1;
12196
12197 salts_done++;
12198 }
12199
12200 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12201 }
12202
12203 local_free (digests_buf);
12204 local_free (salts_buf);
12205 local_free (esalts_buf);
12206
12207 digests_buf = digests_buf_new;
12208 salts_buf = salts_buf_new;
12209 esalts_buf = esalts_buf_new;
12210
12211 local_free (hashes_buf);
12212
12213 /**
12214 * special modification not set from parser
12215 */
12216
12217 switch (hash_mode)
12218 {
12219 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12220 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12221 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12222 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12223 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12224 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12225 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12226 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12227 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12228 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12229 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12230 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12231 }
12232
12233 if (truecrypt_keyfiles)
12234 {
12235 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12236
12237 char *keyfiles = strdup (truecrypt_keyfiles);
12238
12239 char *keyfile = strtok (keyfiles, ",");
12240
12241 do
12242 {
12243 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12244
12245 } while ((keyfile = strtok (NULL, ",")) != NULL);
12246
12247 free (keyfiles);
12248 }
12249
12250 data.digests_cnt = digests_cnt;
12251 data.digests_done = digests_done;
12252 data.digests_buf = digests_buf;
12253 data.digests_shown = digests_shown;
12254 data.digests_shown_tmp = digests_shown_tmp;
12255
12256 data.salts_cnt = salts_cnt;
12257 data.salts_done = salts_done;
12258 data.salts_buf = salts_buf;
12259 data.salts_shown = salts_shown;
12260
12261 data.esalts_buf = esalts_buf;
12262 data.hash_info = hash_info;
12263
12264 /**
12265 * Automatic Optimizers
12266 */
12267
12268 if (salts_cnt == 1)
12269 opti_type |= OPTI_TYPE_SINGLE_SALT;
12270
12271 if (digests_cnt == 1)
12272 opti_type |= OPTI_TYPE_SINGLE_HASH;
12273
12274 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12275 opti_type |= OPTI_TYPE_NOT_ITERATED;
12276
12277 if (attack_mode == ATTACK_MODE_BF)
12278 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12279
12280 data.opti_type = opti_type;
12281
12282 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12283 {
12284 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12285 {
12286 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12287 {
12288 if (opts_type & OPTS_TYPE_ST_ADD80)
12289 {
12290 opts_type &= ~OPTS_TYPE_ST_ADD80;
12291 opts_type |= OPTS_TYPE_PT_ADD80;
12292 }
12293
12294 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12295 {
12296 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12297 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12298 }
12299
12300 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12301 {
12302 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12303 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12304 }
12305 }
12306 }
12307 }
12308
12309 /**
12310 * Some algorithm, like descrypt, can benefit from JIT compilation
12311 */
12312
12313 int force_jit_compilation = -1;
12314
12315 if (hash_mode == 8900)
12316 {
12317 force_jit_compilation = 8900;
12318 }
12319 else if (hash_mode == 9300)
12320 {
12321 force_jit_compilation = 8900;
12322 }
12323 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12324 {
12325 force_jit_compilation = 1500;
12326 }
12327
12328 /**
12329 * generate bitmap tables
12330 */
12331
12332 const uint bitmap_shift1 = 5;
12333 const uint bitmap_shift2 = 13;
12334
12335 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12336
12337 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12338 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12339 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12340 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12341 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12342 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12343 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345
12346 uint bitmap_bits;
12347 uint bitmap_nums;
12348 uint bitmap_mask;
12349 uint bitmap_size;
12350
12351 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12352 {
12353 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12354
12355 bitmap_nums = 1 << bitmap_bits;
12356
12357 bitmap_mask = bitmap_nums - 1;
12358
12359 bitmap_size = bitmap_nums * sizeof (uint);
12360
12361 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12362
12363 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;
12364 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;
12365
12366 break;
12367 }
12368
12369 bitmap_nums = 1 << bitmap_bits;
12370
12371 bitmap_mask = bitmap_nums - 1;
12372
12373 bitmap_size = bitmap_nums * sizeof (uint);
12374
12375 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);
12376 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);
12377
12378 /**
12379 * prepare quick rule
12380 */
12381
12382 data.rule_buf_l = rule_buf_l;
12383 data.rule_buf_r = rule_buf_r;
12384
12385 int rule_len_l = (int) strlen (rule_buf_l);
12386 int rule_len_r = (int) strlen (rule_buf_r);
12387
12388 data.rule_len_l = rule_len_l;
12389 data.rule_len_r = rule_len_r;
12390
12391 /**
12392 * load rules
12393 */
12394
12395 uint *all_kernel_rules_cnt = NULL;
12396
12397 kernel_rule_t **all_kernel_rules_buf = NULL;
12398
12399 if (rp_files_cnt)
12400 {
12401 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12402
12403 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12404 }
12405
12406 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12407
12408 int rule_len = 0;
12409
12410 for (uint i = 0; i < rp_files_cnt; i++)
12411 {
12412 uint kernel_rules_avail = 0;
12413
12414 uint kernel_rules_cnt = 0;
12415
12416 kernel_rule_t *kernel_rules_buf = NULL;
12417
12418 char *rp_file = rp_files[i];
12419
12420 char in[BLOCK_SIZE] = { 0 };
12421 char out[BLOCK_SIZE] = { 0 };
12422
12423 FILE *fp = NULL;
12424
12425 uint rule_line = 0;
12426
12427 if ((fp = fopen (rp_file, "rb")) == NULL)
12428 {
12429 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12430
12431 return (-1);
12432 }
12433
12434 while (!feof (fp))
12435 {
12436 memset (rule_buf, 0, HCBUFSIZ);
12437
12438 rule_len = fgetl (fp, rule_buf);
12439
12440 rule_line++;
12441
12442 if (rule_len == 0) continue;
12443
12444 if (rule_buf[0] == '#') continue;
12445
12446 if (kernel_rules_avail == kernel_rules_cnt)
12447 {
12448 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12449
12450 kernel_rules_avail += INCR_RULES;
12451 }
12452
12453 memset (in, 0, BLOCK_SIZE);
12454 memset (out, 0, BLOCK_SIZE);
12455
12456 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12457
12458 if (result == -1)
12459 {
12460 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12461
12462 continue;
12463 }
12464
12465 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12466 {
12467 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12468
12469 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12470
12471 continue;
12472 }
12473
12474 /* its so slow
12475 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12476 {
12477 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12478
12479 continue;
12480 }
12481 */
12482
12483 kernel_rules_cnt++;
12484 }
12485
12486 fclose (fp);
12487
12488 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12489
12490 all_kernel_rules_buf[i] = kernel_rules_buf;
12491 }
12492
12493 /**
12494 * merge rules or automatic rule generator
12495 */
12496
12497 uint kernel_rules_cnt = 0;
12498
12499 kernel_rule_t *kernel_rules_buf = NULL;
12500
12501 if (attack_mode == ATTACK_MODE_STRAIGHT)
12502 {
12503 if (rp_files_cnt)
12504 {
12505 kernel_rules_cnt = 1;
12506
12507 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12508
12509 repeats[0] = kernel_rules_cnt;
12510
12511 for (uint i = 0; i < rp_files_cnt; i++)
12512 {
12513 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12514
12515 repeats[i + 1] = kernel_rules_cnt;
12516 }
12517
12518 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12519
12520 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12521
12522 for (uint i = 0; i < kernel_rules_cnt; i++)
12523 {
12524 uint out_pos = 0;
12525
12526 kernel_rule_t *out = &kernel_rules_buf[i];
12527
12528 for (uint j = 0; j < rp_files_cnt; j++)
12529 {
12530 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12531 uint in_pos;
12532
12533 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12534
12535 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12536 {
12537 if (out_pos == RULES_MAX - 1)
12538 {
12539 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12540
12541 break;
12542 }
12543
12544 out->cmds[out_pos] = in->cmds[in_pos];
12545 }
12546 }
12547 }
12548
12549 local_free (repeats);
12550 }
12551 else if (rp_gen)
12552 {
12553 uint kernel_rules_avail = 0;
12554
12555 while (kernel_rules_cnt < rp_gen)
12556 {
12557 if (kernel_rules_avail == kernel_rules_cnt)
12558 {
12559 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12560
12561 kernel_rules_avail += INCR_RULES;
12562 }
12563
12564 memset (rule_buf, 0, HCBUFSIZ);
12565
12566 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12567
12568 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12569
12570 kernel_rules_cnt++;
12571 }
12572 }
12573 }
12574
12575 myfree (rule_buf);
12576
12577 /**
12578 * generate NOP rules
12579 */
12580
12581 if (kernel_rules_cnt == 0)
12582 {
12583 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12584
12585 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12586
12587 kernel_rules_cnt++;
12588 }
12589
12590 data.kernel_rules_cnt = kernel_rules_cnt;
12591 data.kernel_rules_buf = kernel_rules_buf;
12592
12593 /**
12594 * OpenCL platforms: detect
12595 */
12596
12597 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12598 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12599
12600 cl_uint platforms_cnt = 0;
12601 cl_uint platform_devices_cnt = 0;
12602
12603 if (keyspace == 0)
12604 {
12605 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12606
12607 if (platforms_cnt == 0)
12608 {
12609 log_info ("");
12610 log_info ("ATTENTION! No OpenCL compatible platform found");
12611 log_info ("");
12612 log_info ("You're probably missing the OpenCL runtime installation");
12613 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12614 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12615 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12616 log_info ("");
12617
12618 return (-1);
12619 }
12620
12621 if (opencl_platforms_filter != (uint) -1)
12622 {
12623 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12624
12625 if (opencl_platforms_filter > platform_cnt_mask)
12626 {
12627 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12628
12629 return (-1);
12630 }
12631 }
12632 }
12633
12634 /**
12635 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12636 */
12637
12638 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12639 {
12640 cl_platform_id platform = platforms[platform_id];
12641
12642 char platform_vendor[INFOSZ] = { 0 };
12643
12644 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12645
12646 #ifdef HAVE_HWMON
12647 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12648 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12649 {
12650 // make sure that we do not directly control the fan for NVidia
12651
12652 gpu_temp_retain = 0;
12653
12654 data.gpu_temp_retain = gpu_temp_retain;
12655 }
12656 #endif // HAVE_NVML || HAVE_NVAPI
12657 #endif
12658 }
12659
12660 /**
12661 * OpenCL device types:
12662 * 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.
12663 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12664 */
12665
12666 if (opencl_device_types == NULL)
12667 {
12668 cl_device_type device_types_all = 0;
12669
12670 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12671 {
12672 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12673
12674 cl_platform_id platform = platforms[platform_id];
12675
12676 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12677
12678 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12679 {
12680 cl_device_id device = platform_devices[platform_devices_id];
12681
12682 cl_device_type device_type;
12683
12684 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12685
12686 device_types_all |= device_type;
12687 }
12688 }
12689
12690 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12691 {
12692 device_types_filter |= CL_DEVICE_TYPE_CPU;
12693 }
12694 }
12695
12696 /**
12697 * OpenCL devices: simply push all devices from all platforms into the same device array
12698 */
12699
12700 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12701
12702 data.devices_param = devices_param;
12703
12704 uint devices_cnt = 0;
12705
12706 uint devices_active = 0;
12707
12708 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12709 {
12710 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12711
12712 cl_platform_id platform = platforms[platform_id];
12713
12714 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12715
12716 char platform_vendor[INFOSZ] = { 0 };
12717
12718 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12719
12720 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12721 // this causes trouble with vendor id based macros
12722 // we'll assign generic to those without special optimization available
12723
12724 cl_uint vendor_id = 0;
12725
12726 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12727 {
12728 vendor_id = VENDOR_ID_AMD;
12729 }
12730 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12731 {
12732 vendor_id = VENDOR_ID_APPLE;
12733 }
12734 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12735 {
12736 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12737 }
12738 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12739 {
12740 vendor_id = VENDOR_ID_INTEL_SDK;
12741 }
12742 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12743 {
12744 vendor_id = VENDOR_ID_MESA;
12745 }
12746 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12747 {
12748 vendor_id = VENDOR_ID_NV;
12749 }
12750 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12751 {
12752 vendor_id = VENDOR_ID_POCL;
12753 }
12754 else
12755 {
12756 vendor_id = VENDOR_ID_GENERIC;
12757 }
12758
12759 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12760 {
12761 size_t param_value_size = 0;
12762
12763 const uint device_id = devices_cnt;
12764
12765 hc_device_param_t *device_param = &data.devices_param[device_id];
12766
12767 device_param->vendor_id = vendor_id;
12768
12769 device_param->device = platform_devices[platform_devices_id];
12770
12771 device_param->device_id = device_id;
12772
12773 device_param->platform_devices_id = platform_devices_id;
12774
12775 // device_type
12776
12777 cl_device_type device_type;
12778
12779 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12780
12781 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12782
12783 device_param->device_type = device_type;
12784
12785 // device_name
12786
12787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12788
12789 char *device_name = (char *) mymalloc (param_value_size);
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12792
12793 device_param->device_name = device_name;
12794
12795 // tuning db
12796
12797 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12798
12799 // device_version
12800
12801 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12802
12803 char *device_version = (char *) mymalloc (param_value_size);
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12806
12807 device_param->device_version = device_version;
12808
12809 // device_opencl_version
12810
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12812
12813 char *device_opencl_version = (char *) mymalloc (param_value_size);
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12816
12817 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12818
12819 myfree (device_opencl_version);
12820
12821 // vector_width
12822
12823 cl_uint vector_width;
12824
12825 if (opencl_vector_width_chgd == 0)
12826 {
12827 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12828 {
12829 if (opti_type & OPTI_TYPE_USES_BITS_64)
12830 {
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12832 }
12833 else
12834 {
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12836 }
12837 }
12838 else
12839 {
12840 vector_width = (cl_uint) tuningdb_entry->vector_width;
12841 }
12842 }
12843 else
12844 {
12845 vector_width = opencl_vector_width;
12846 }
12847
12848 if (vector_width > 16) vector_width = 16;
12849
12850 device_param->vector_width = vector_width;
12851
12852 // max_compute_units
12853
12854 cl_uint device_processors;
12855
12856 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12857
12858 device_param->device_processors = device_processors;
12859
12860 // device_maxmem_alloc
12861 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12862
12863 cl_ulong device_maxmem_alloc;
12864
12865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12866
12867 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12868
12869 // device_global_mem
12870
12871 cl_ulong device_global_mem;
12872
12873 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12874
12875 device_param->device_global_mem = device_global_mem;
12876
12877 // max_work_group_size
12878
12879 size_t device_maxworkgroup_size;
12880
12881 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12882
12883 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12884
12885 // max_clock_frequency
12886
12887 cl_uint device_maxclock_frequency;
12888
12889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12890
12891 device_param->device_maxclock_frequency = device_maxclock_frequency;
12892
12893 // device_endian_little
12894
12895 cl_bool device_endian_little;
12896
12897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12898
12899 if (device_endian_little == CL_FALSE)
12900 {
12901 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12902
12903 device_param->skipped = 1;
12904 }
12905
12906 // device_available
12907
12908 cl_bool device_available;
12909
12910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12911
12912 if (device_available == CL_FALSE)
12913 {
12914 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12915
12916 device_param->skipped = 1;
12917 }
12918
12919 // device_compiler_available
12920
12921 cl_bool device_compiler_available;
12922
12923 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12924
12925 if (device_compiler_available == CL_FALSE)
12926 {
12927 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12928
12929 device_param->skipped = 1;
12930 }
12931
12932 // device_execution_capabilities
12933
12934 cl_device_exec_capabilities device_execution_capabilities;
12935
12936 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12937
12938 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12939 {
12940 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12941
12942 device_param->skipped = 1;
12943 }
12944
12945 // device_extensions
12946
12947 size_t device_extensions_size;
12948
12949 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12950
12951 char *device_extensions = mymalloc (device_extensions_size + 1);
12952
12953 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12954
12955 if (strstr (device_extensions, "base_atomics") == 0)
12956 {
12957 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12958
12959 device_param->skipped = 1;
12960 }
12961
12962 if (strstr (device_extensions, "byte_addressable_store") == 0)
12963 {
12964 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12965
12966 device_param->skipped = 1;
12967 }
12968
12969 myfree (device_extensions);
12970
12971 // device_local_mem_size
12972
12973 cl_ulong device_local_mem_size;
12974
12975 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12976
12977 if (device_local_mem_size < 32768)
12978 {
12979 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12980
12981 device_param->skipped = 1;
12982 }
12983
12984
12985 // skipped
12986
12987 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12988 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12989
12990 // driver_version
12991
12992 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12993
12994 char *driver_version = (char *) mymalloc (param_value_size);
12995
12996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12997
12998 device_param->driver_version = driver_version;
12999
13000 // device_name_chksum
13001
13002 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13003
13004 #if __x86_64__
13005 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);
13006 #else
13007 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);
13008 #endif
13009
13010 uint device_name_digest[4] = { 0 };
13011
13012 md5_64 ((uint *) device_name_chksum, device_name_digest);
13013
13014 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13015
13016 device_param->device_name_chksum = device_name_chksum;
13017
13018 // device_processor_cores
13019
13020 if (device_type & CL_DEVICE_TYPE_CPU)
13021 {
13022 cl_uint device_processor_cores = 1;
13023
13024 device_param->device_processor_cores = device_processor_cores;
13025 }
13026
13027 if (device_type & CL_DEVICE_TYPE_GPU)
13028 {
13029 if (vendor_id == VENDOR_ID_AMD)
13030 {
13031 cl_uint device_processor_cores = 0;
13032
13033 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13034
13035 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13036
13037 device_param->device_processor_cores = device_processor_cores;
13038 }
13039 else if (vendor_id == VENDOR_ID_NV)
13040 {
13041 cl_uint kernel_exec_timeout = 0;
13042
13043 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13044
13045 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13046
13047 device_param->kernel_exec_timeout = kernel_exec_timeout;
13048
13049 cl_uint device_processor_cores = 0;
13050
13051 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13052
13053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13054
13055 device_param->device_processor_cores = device_processor_cores;
13056
13057 cl_uint sm_minor = 0;
13058 cl_uint sm_major = 0;
13059
13060 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13061 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13062
13063 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13064 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13065
13066 device_param->sm_minor = sm_minor;
13067 device_param->sm_major = sm_major;
13068 }
13069 else
13070 {
13071 cl_uint device_processor_cores = 1;
13072
13073 device_param->device_processor_cores = device_processor_cores;
13074 }
13075 }
13076
13077 // display results
13078
13079 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13080 {
13081 if (status_automat == 0)
13082 {
13083 if (device_param->skipped == 0)
13084 {
13085 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13086 device_id + 1,
13087 device_name,
13088 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13089 (unsigned int) (device_global_mem / 1024 / 1024),
13090 (unsigned int) (device_maxclock_frequency),
13091 (unsigned int) device_processors);
13092 }
13093 else
13094 {
13095 log_info ("Device #%u: %s, skipped",
13096 device_id + 1,
13097 device_name);
13098 }
13099 }
13100 }
13101
13102 // common driver check
13103
13104 if (device_param->skipped == 0)
13105 {
13106 if (device_type & CL_DEVICE_TYPE_GPU)
13107 {
13108 if (vendor_id == VENDOR_ID_AMD)
13109 {
13110 int catalyst_check = (force == 1) ? 0 : 1;
13111
13112 int catalyst_warn = 0;
13113
13114 int catalyst_broken = 0;
13115
13116 if (catalyst_check == 1)
13117 {
13118 catalyst_warn = 1;
13119
13120 // v14.9 and higher
13121 if (atoi (device_param->driver_version) >= 1573)
13122 {
13123 catalyst_warn = 0;
13124 }
13125
13126 catalyst_check = 0;
13127 }
13128
13129 if (catalyst_broken == 1)
13130 {
13131 log_info ("");
13132 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13133 log_info ("It will pass over cracked hashes and does not report them as cracked");
13134 log_info ("You are STRONGLY encouraged not to use it");
13135 log_info ("You can use --force to override this but do not post error reports if you do so");
13136 log_info ("");
13137
13138 return (-1);
13139 }
13140
13141 if (catalyst_warn == 1)
13142 {
13143 log_info ("");
13144 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13145 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13146 log_info ("See hashcat's homepage for official supported catalyst drivers");
13147 #ifdef _WIN
13148 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13149 #endif
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 else if (vendor_id == VENDOR_ID_NV)
13157 {
13158 if (device_param->kernel_exec_timeout != 0)
13159 {
13160 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);
13161 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13162 }
13163 }
13164 }
13165
13166 if (device_type & CL_DEVICE_TYPE_CPU)
13167 {
13168 if (vendor_id == VENDOR_ID_AMD)
13169 {
13170 if (force == 0)
13171 {
13172 log_info ("");
13173 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13174 log_info ("You are STRONGLY encouraged not to use it");
13175 log_info ("You can use --force to override this but do not post error reports if you do so");
13176 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13177 log_info ("");
13178
13179 return (-1);
13180 }
13181 }
13182 }
13183
13184 /**
13185 * kernel accel and loops tuning db adjustment
13186 */
13187
13188 device_param->kernel_accel_min = 1;
13189 device_param->kernel_accel_max = 1024;
13190
13191 device_param->kernel_loops_min = 1;
13192 device_param->kernel_loops_max = 1024;
13193
13194 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13195
13196 if (tuningdb_entry)
13197 {
13198 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13199 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13200
13201 if (_kernel_accel)
13202 {
13203 device_param->kernel_accel_min = _kernel_accel;
13204 device_param->kernel_accel_max = _kernel_accel;
13205 }
13206
13207 if (_kernel_loops)
13208 {
13209 if (workload_profile == 1)
13210 {
13211 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13212 }
13213 else if (workload_profile == 2)
13214 {
13215 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13216 }
13217
13218 device_param->kernel_loops_min = _kernel_loops;
13219 device_param->kernel_loops_max = _kernel_loops;
13220 }
13221 }
13222
13223 // commandline parameters overwrite tuningdb entries
13224
13225 if (kernel_accel)
13226 {
13227 device_param->kernel_accel_min = kernel_accel;
13228 device_param->kernel_accel_max = kernel_accel;
13229 }
13230
13231 if (kernel_loops)
13232 {
13233 device_param->kernel_loops_min = kernel_loops;
13234 device_param->kernel_loops_max = kernel_loops;
13235 }
13236
13237 /**
13238 * activate device
13239 */
13240
13241 devices_active++;
13242 }
13243
13244 // next please
13245
13246 devices_cnt++;
13247 }
13248 }
13249
13250 if (keyspace == 0 && devices_active == 0)
13251 {
13252 log_error ("ERROR: No devices found/left");
13253
13254 return (-1);
13255 }
13256
13257 // 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)
13258
13259 if (devices_filter != (uint) -1)
13260 {
13261 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13262
13263 if (devices_filter > devices_cnt_mask)
13264 {
13265 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13266
13267 return (-1);
13268 }
13269 }
13270
13271 data.devices_cnt = devices_cnt;
13272
13273 data.devices_active = devices_active;
13274
13275 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13276 {
13277 if (status_automat == 0)
13278 {
13279 log_info ("");
13280 }
13281 }
13282
13283 /**
13284 * HM devices: init
13285 */
13286
13287 #ifdef HAVE_HWMON
13288 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13289 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13290 #endif
13291
13292 #ifdef HAVE_ADL
13293 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13294 #endif
13295
13296 if (gpu_temp_disable == 0)
13297 {
13298 #if defined(WIN) && defined(HAVE_NVAPI)
13299 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13300
13301 if (nvapi_init (nvapi) == 0)
13302 data.hm_nv = nvapi;
13303
13304 if (data.hm_nv)
13305 {
13306 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13307 {
13308 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13309
13310 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13311
13312 int tmp_out = 0;
13313
13314 for (int i = 0; i < tmp_in; i++)
13315 {
13316 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13317 }
13318
13319 for (int i = 0; i < tmp_out; i++)
13320 {
13321 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13322
13323 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13324
13325 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;
13326 }
13327 }
13328 }
13329 #endif // WIN && HAVE_NVAPI
13330
13331 #if defined(LINUX) && defined(HAVE_NVML)
13332 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13333
13334 if (nvml_init (nvml) == 0)
13335 data.hm_nv = nvml;
13336
13337 if (data.hm_nv)
13338 {
13339 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13340 {
13341 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13342
13343 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13344
13345 int tmp_out = 0;
13346
13347 for (int i = 0; i < tmp_in; i++)
13348 {
13349 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13350 }
13351
13352 for (int i = 0; i < tmp_out; i++)
13353 {
13354 unsigned int speed;
13355
13356 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;
13357 }
13358 }
13359 }
13360 #endif // LINUX && HAVE_NVML
13361
13362 data.hm_amd = NULL;
13363
13364 #ifdef HAVE_ADL
13365 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13366
13367 if (adl_init (adl) == 0)
13368 data.hm_amd = adl;
13369
13370 if (data.hm_amd)
13371 {
13372 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13373 {
13374 // total number of adapters
13375
13376 int hm_adapters_num;
13377
13378 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13379
13380 // adapter info
13381
13382 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13383
13384 if (lpAdapterInfo == NULL) return (-1);
13385
13386 // get a list (of ids of) valid/usable adapters
13387
13388 int num_adl_adapters = 0;
13389
13390 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13391
13392 if (num_adl_adapters > 0)
13393 {
13394 hc_thread_mutex_lock (mux_adl);
13395
13396 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13397
13398 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13399
13400 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13401 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13402
13403 hc_thread_mutex_unlock (mux_adl);
13404 }
13405
13406 myfree (valid_adl_device_list);
13407 myfree (lpAdapterInfo);
13408 }
13409 }
13410 #endif // HAVE_ADL
13411
13412 if (data.hm_amd == NULL && data.hm_nv == NULL)
13413 {
13414 gpu_temp_disable = 1;
13415 }
13416 }
13417
13418 /**
13419 * OpenCL devices: allocate buffer for device specific information
13420 */
13421
13422 #ifdef HAVE_HWMON
13423 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13424
13425 #ifdef HAVE_ADL
13426 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13427
13428 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13429 #endif // ADL
13430 #endif
13431
13432 /**
13433 * enable custom signal handler(s)
13434 */
13435
13436 if (benchmark == 0)
13437 {
13438 hc_signal (sigHandler_default);
13439 }
13440 else
13441 {
13442 hc_signal (sigHandler_benchmark);
13443 }
13444
13445 /**
13446 * User-defined GPU temp handling
13447 */
13448
13449 #ifdef HAVE_HWMON
13450 if (gpu_temp_disable == 1)
13451 {
13452 gpu_temp_abort = 0;
13453 gpu_temp_retain = 0;
13454 }
13455
13456 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13457 {
13458 if (gpu_temp_abort < gpu_temp_retain)
13459 {
13460 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13461
13462 return (-1);
13463 }
13464 }
13465
13466 data.gpu_temp_disable = gpu_temp_disable;
13467 data.gpu_temp_abort = gpu_temp_abort;
13468 data.gpu_temp_retain = gpu_temp_retain;
13469 #endif
13470
13471 /**
13472 * inform the user
13473 */
13474
13475 if (data.quiet == 0)
13476 {
13477 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13478
13479 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);
13480
13481 if (attack_mode == ATTACK_MODE_STRAIGHT)
13482 {
13483 log_info ("Rules: %u", kernel_rules_cnt);
13484 }
13485
13486 if (opti_type)
13487 {
13488 log_info ("Applicable Optimizers:");
13489
13490 for (uint i = 0; i < 32; i++)
13491 {
13492 const uint opti_bit = 1u << i;
13493
13494 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13495 }
13496 }
13497
13498 /**
13499 * Watchdog and Temperature balance
13500 */
13501
13502 #ifdef HAVE_HWMON
13503 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13504 {
13505 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13506 }
13507
13508 if (gpu_temp_abort == 0)
13509 {
13510 log_info ("Watchdog: Temperature abort trigger disabled");
13511 }
13512 else
13513 {
13514 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13515 }
13516
13517 if (gpu_temp_retain == 0)
13518 {
13519 log_info ("Watchdog: Temperature retain trigger disabled");
13520 }
13521 else
13522 {
13523 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13524 }
13525
13526 if (data.quiet == 0) log_info ("");
13527 #endif
13528 }
13529
13530 /**
13531 * HM devices: copy
13532 */
13533
13534 if (gpu_temp_disable == 0)
13535 {
13536 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13537 {
13538 hc_device_param_t *device_param = &data.devices_param[device_id];
13539
13540 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13541
13542 if (device_param->skipped) continue;
13543
13544 const uint platform_devices_id = device_param->platform_devices_id;
13545
13546 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13547 if (device_param->vendor_id == VENDOR_ID_NV)
13548 {
13549 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13550 }
13551 #endif
13552
13553 #ifdef HAVE_ADL
13554 if (device_param->vendor_id == VENDOR_ID_AMD)
13555 {
13556 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13557 }
13558 #endif
13559 }
13560 }
13561
13562 /*
13563 * Temporary fix:
13564 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13565 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13566 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13567 * Driver / ADL bug?
13568 */
13569
13570 #ifdef HAVE_ADL
13571 if (powertune_enable == 1)
13572 {
13573 hc_thread_mutex_lock (mux_adl);
13574
13575 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13576 {
13577 hc_device_param_t *device_param = &data.devices_param[device_id];
13578
13579 if (device_param->skipped) continue;
13580
13581 if (data.hm_device[device_id].od_version == 6)
13582 {
13583 // set powertune value only
13584
13585 int powertune_supported = 0;
13586
13587 int ADL_rc = 0;
13588
13589 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13590 {
13591 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13592
13593 return (-1);
13594 }
13595
13596 if (powertune_supported != 0)
13597 {
13598 // powertune set
13599 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13600
13601 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13602 {
13603 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13604
13605 return (-1);
13606 }
13607
13608 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13609 {
13610 log_error ("ERROR: Failed to set new ADL PowerControl values");
13611
13612 return (-1);
13613 }
13614 }
13615 }
13616 }
13617
13618 hc_thread_mutex_unlock (mux_adl);
13619 }
13620 #endif // HAVE_ADK
13621 #endif // HAVE_HWMON
13622
13623 #ifdef DEBUG
13624 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13625 #endif
13626
13627 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13628
13629 uint kernel_power_all = 0;
13630
13631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13632 {
13633 /**
13634 * host buffer
13635 */
13636
13637 hc_device_param_t *device_param = &data.devices_param[device_id];
13638
13639 if (device_param->skipped) continue;
13640
13641 /**
13642 * device properties
13643 */
13644
13645 const char *device_name_chksum = device_param->device_name_chksum;
13646 const u32 device_processors = device_param->device_processors;
13647 const u32 device_processor_cores = device_param->device_processor_cores;
13648
13649 /**
13650 * create context for each device
13651 */
13652
13653 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13654
13655 /**
13656 * create command-queue
13657 */
13658
13659 // not supported with NV
13660 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13661
13662 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13663
13664 /**
13665 * kernel threads: some algorithms need a fixed kernel-threads count
13666 * because of shared memory usage or bitslice
13667 * there needs to be some upper limit, otherwise there's too much overhead
13668 */
13669
13670 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13671
13672 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13673 {
13674 kernel_threads = KERNEL_THREADS_MAX_CPU;
13675 }
13676
13677 if (hash_mode == 1500) kernel_threads = 64; // DES
13678 if (hash_mode == 3000) kernel_threads = 64; // DES
13679 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13680 if (hash_mode == 7500) kernel_threads = 64; // RC4
13681 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13682 if (hash_mode == 9700) kernel_threads = 64; // RC4
13683 if (hash_mode == 9710) kernel_threads = 64; // RC4
13684 if (hash_mode == 9800) kernel_threads = 64; // RC4
13685 if (hash_mode == 9810) kernel_threads = 64; // RC4
13686 if (hash_mode == 10400) kernel_threads = 64; // RC4
13687 if (hash_mode == 10410) kernel_threads = 64; // RC4
13688 if (hash_mode == 10500) kernel_threads = 64; // RC4
13689 if (hash_mode == 13100) kernel_threads = 64; // RC4
13690
13691 /**
13692 * create input buffers on device : calculate size of fixed memory buffers
13693 */
13694
13695 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13696 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13697
13698 device_param->size_root_css = size_root_css;
13699 device_param->size_markov_css = size_markov_css;
13700
13701 size_t size_results = kernel_threads * sizeof (uint);
13702
13703 device_param->size_results = size_results;
13704
13705 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13706 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13707
13708 size_t size_plains = digests_cnt * sizeof (plain_t);
13709 size_t size_salts = salts_cnt * sizeof (salt_t);
13710 size_t size_esalts = salts_cnt * esalt_size;
13711
13712 device_param->size_plains = size_plains;
13713 device_param->size_digests = size_digests;
13714 device_param->size_shown = size_shown;
13715 device_param->size_salts = size_salts;
13716
13717 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13718 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13719 size_t size_tm = 32 * sizeof (bs_word_t);
13720
13721 // scryptV stuff
13722
13723 size_t size_scryptV = 1;
13724
13725 if ((hash_mode == 8900) || (hash_mode == 9300))
13726 {
13727 uint tmto_start = 0;
13728 uint tmto_stop = 10;
13729
13730 if (scrypt_tmto)
13731 {
13732 tmto_start = scrypt_tmto;
13733 }
13734 else
13735 {
13736 // in case the user did not specify the tmto manually
13737 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13738 // but set the lower end only in case the user has a device with too less memory
13739
13740 if (hash_mode == 8900)
13741 {
13742 if (device_param->vendor_id == VENDOR_ID_AMD)
13743 {
13744 tmto_start = 1;
13745 }
13746 else if (device_param->vendor_id == VENDOR_ID_NV)
13747 {
13748 tmto_start = 2;
13749 }
13750 }
13751 else if (hash_mode == 9300)
13752 {
13753 if (device_param->vendor_id == VENDOR_ID_AMD)
13754 {
13755 tmto_start = 2;
13756 }
13757 else if (device_param->vendor_id == VENDOR_ID_NV)
13758 {
13759 tmto_start = 2;
13760 }
13761 }
13762 }
13763
13764 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13765 {
13766 // TODO: in theory the following calculation needs to be done per salt, not global
13767 // we assume all hashes have the same scrypt settings
13768
13769 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13770
13771 size_scryptV /= 1 << tmto;
13772
13773 size_scryptV *= device_processors * device_processor_cores;
13774
13775 if (size_scryptV > device_param->device_maxmem_alloc)
13776 {
13777 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13778
13779 continue;
13780 }
13781
13782 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13783 {
13784 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13785 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13786 }
13787
13788 break;
13789 }
13790
13791 if (data.salts_buf[0].scrypt_phy == 0)
13792 {
13793 log_error ("ERROR: can't allocate enough device memory");
13794
13795 return -1;
13796 }
13797
13798 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13799 }
13800
13801 /**
13802 * some algorithms need a fixed kernel-loops count
13803 */
13804
13805 if (hash_mode == 1500)
13806 {
13807 const u32 kernel_loops_fixed = 1024;
13808
13809 device_param->kernel_loops_min = kernel_loops_fixed;
13810 device_param->kernel_loops_max = kernel_loops_fixed;
13811 }
13812
13813 if (hash_mode == 3000)
13814 {
13815 const u32 kernel_loops_fixed = 1024;
13816
13817 device_param->kernel_loops_min = kernel_loops_fixed;
13818 device_param->kernel_loops_max = kernel_loops_fixed;
13819 }
13820
13821 if (hash_mode == 8900)
13822 {
13823 const u32 kernel_loops_fixed = 1;
13824
13825 device_param->kernel_loops_min = kernel_loops_fixed;
13826 device_param->kernel_loops_max = kernel_loops_fixed;
13827 }
13828
13829 if (hash_mode == 9300)
13830 {
13831 const u32 kernel_loops_fixed = 1;
13832
13833 device_param->kernel_loops_min = kernel_loops_fixed;
13834 device_param->kernel_loops_max = kernel_loops_fixed;
13835 }
13836
13837 if (hash_mode == 12500)
13838 {
13839 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13840
13841 device_param->kernel_loops_min = kernel_loops_fixed;
13842 device_param->kernel_loops_max = kernel_loops_fixed;
13843 }
13844
13845 /**
13846 * some algorithms have a maximum kernel-loops count
13847 */
13848
13849 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13850 {
13851 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13852 {
13853 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13854 }
13855 }
13856
13857 /**
13858 * some algorithms need a special kernel-accel
13859 */
13860
13861 if (hash_mode == 8900)
13862 {
13863 device_param->kernel_accel_min = 1;
13864 device_param->kernel_accel_max = 64;
13865 }
13866
13867 if (hash_mode == 9300)
13868 {
13869 device_param->kernel_accel_min = 1;
13870 device_param->kernel_accel_max = 64;
13871 }
13872
13873 u32 kernel_accel_min = device_param->kernel_accel_min;
13874 u32 kernel_accel_max = device_param->kernel_accel_max;
13875
13876 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13877
13878 size_t size_pws = 4;
13879 size_t size_tmps = 4;
13880 size_t size_hooks = 4;
13881
13882 while (kernel_accel_max >= kernel_accel_min)
13883 {
13884 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13885
13886 // size_pws
13887
13888 size_pws = kernel_power_max * sizeof (pw_t);
13889
13890 // size_tmps
13891
13892 switch (hash_mode)
13893 {
13894 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13895 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13896 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13897 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13898 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13899 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13900 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13901 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13902 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13903 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13904 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13905 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13906 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13907 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13908 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13909 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13910 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13911 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13912 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13913 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13914 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13915 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13916 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13917 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13918 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13919 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13920 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13921 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13922 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13923 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13924 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13925 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13926 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13927 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13928 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13929 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13930 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13931 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13932 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13933 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13934 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13935 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13936 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13937 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13938 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13939 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13940 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13941 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13942 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13943 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13944 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13945 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13946 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13947 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13948 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13949 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13950 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13951 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13952 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13953 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13954 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13955 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13956 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13957 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13958 };
13959
13960 // size_hooks
13961
13962 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13963 {
13964 // none yet
13965 }
13966
13967 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13968 // if not, decrease amplifier and try again
13969
13970 int skip = 0;
13971
13972 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13973 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13974 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13975
13976 if (( bitmap_size
13977 + bitmap_size
13978 + bitmap_size
13979 + bitmap_size
13980 + bitmap_size
13981 + bitmap_size
13982 + bitmap_size
13983 + bitmap_size
13984 + size_bfs
13985 + size_combs
13986 + size_digests
13987 + size_esalts
13988 + size_hooks
13989 + size_markov_css
13990 + size_plains
13991 + size_pws
13992 + size_pws // not a bug
13993 + size_results
13994 + size_root_css
13995 + size_rules
13996 + size_rules_c
13997 + size_salts
13998 + size_scryptV
13999 + size_shown
14000 + size_tm
14001 + size_tmps) > device_param->device_global_mem) skip = 1;
14002
14003 if (skip == 1)
14004 {
14005 kernel_accel_max--;
14006
14007 continue;
14008 }
14009
14010 break;
14011 }
14012
14013 /*
14014 if (kernel_accel_max == 0)
14015 {
14016 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14017
14018 return -1;
14019 }
14020 */
14021
14022 device_param->kernel_accel_min = kernel_accel_min;
14023 device_param->kernel_accel_max = kernel_accel_max;
14024
14025 /*
14026 if (kernel_accel_max < kernel_accel)
14027 {
14028 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14029
14030 device_param->kernel_accel = kernel_accel_max;
14031 }
14032 */
14033
14034 device_param->size_bfs = size_bfs;
14035 device_param->size_combs = size_combs;
14036 device_param->size_rules = size_rules;
14037 device_param->size_rules_c = size_rules_c;
14038 device_param->size_pws = size_pws;
14039 device_param->size_tmps = size_tmps;
14040 device_param->size_hooks = size_hooks;
14041
14042 // do not confuse kernel_accel_max with kernel_accel here
14043
14044 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14045
14046 device_param->kernel_threads = kernel_threads;
14047 device_param->kernel_power_user = kernel_power;
14048
14049 kernel_power_all += kernel_power;
14050
14051 /**
14052 * default building options
14053 */
14054
14055 char build_opts[1024] = { 0 };
14056
14057 // we don't have sm_* on vendors not NV but it doesn't matter
14058
14059 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);
14060
14061 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14062 {
14063 // we do vectorizing much better than the auto-vectorizer
14064
14065 char build_opts_new[1024] = { 0 };
14066
14067 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14068
14069 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14070 }
14071
14072 #ifdef DEBUG
14073 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14074 #endif
14075
14076 /**
14077 * main kernel
14078 */
14079
14080 {
14081 /**
14082 * kernel source filename
14083 */
14084
14085 char source_file[256] = { 0 };
14086
14087 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14088
14089 struct stat sst;
14090
14091 if (stat (source_file, &sst) == -1)
14092 {
14093 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14094
14095 return -1;
14096 }
14097
14098 /**
14099 * kernel cached filename
14100 */
14101
14102 char cached_file[256] = { 0 };
14103
14104 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14105
14106 int cached = 1;
14107
14108 struct stat cst;
14109
14110 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14111 {
14112 cached = 0;
14113 }
14114
14115 /**
14116 * kernel compile or load
14117 */
14118
14119 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14120
14121 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14122
14123 if (force_jit_compilation == -1)
14124 {
14125 if (cached == 0)
14126 {
14127 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14128
14129 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14130
14131 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14132
14133 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14134
14135 #ifdef DEBUG
14136 size_t build_log_size = 0;
14137
14138 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14139
14140 if (build_log_size > 1)
14141 {
14142 char *build_log = (char *) malloc (build_log_size + 1);
14143
14144 memset (build_log, 0, build_log_size + 1);
14145
14146 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14147
14148 puts (build_log);
14149
14150 free (build_log);
14151 }
14152 #endif
14153
14154 if (rc != 0)
14155 {
14156 device_param->skipped = true;
14157
14158 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14159
14160 continue;
14161 }
14162
14163 size_t binary_size;
14164
14165 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14166
14167 u8 *binary = (u8 *) mymalloc (binary_size);
14168
14169 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14170
14171 writeProgramBin (cached_file, binary, binary_size);
14172
14173 local_free (binary);
14174 }
14175 else
14176 {
14177 #ifdef DEBUG
14178 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14179 #endif
14180
14181 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14182
14183 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14184
14185 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14186 }
14187 }
14188 else
14189 {
14190 #ifdef DEBUG
14191 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14192 #endif
14193
14194 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14195
14196 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14197
14198 char build_opts_update[1024] = { 0 };
14199
14200 if (force_jit_compilation == 1500)
14201 {
14202 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14203 }
14204 else if (force_jit_compilation == 8900)
14205 {
14206 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);
14207 }
14208 else
14209 {
14210 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14211 }
14212
14213 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14214
14215 #ifdef DEBUG
14216 size_t build_log_size = 0;
14217
14218 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14219
14220 if (build_log_size > 1)
14221 {
14222 char *build_log = (char *) malloc (build_log_size + 1);
14223
14224 memset (build_log, 0, build_log_size + 1);
14225
14226 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14227
14228 puts (build_log);
14229
14230 free (build_log);
14231 }
14232 #endif
14233
14234 if (rc != 0)
14235 {
14236 device_param->skipped = true;
14237
14238 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14239 }
14240 }
14241
14242 local_free (kernel_lengths);
14243 local_free (kernel_sources[0]);
14244 local_free (kernel_sources);
14245 }
14246
14247 /**
14248 * word generator kernel
14249 */
14250
14251 if (attack_mode != ATTACK_MODE_STRAIGHT)
14252 {
14253 /**
14254 * kernel mp source filename
14255 */
14256
14257 char source_file[256] = { 0 };
14258
14259 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14260
14261 struct stat sst;
14262
14263 if (stat (source_file, &sst) == -1)
14264 {
14265 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14266
14267 return -1;
14268 }
14269
14270 /**
14271 * kernel mp cached filename
14272 */
14273
14274 char cached_file[256] = { 0 };
14275
14276 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14277
14278 int cached = 1;
14279
14280 struct stat cst;
14281
14282 if (stat (cached_file, &cst) == -1)
14283 {
14284 cached = 0;
14285 }
14286
14287 /**
14288 * kernel compile or load
14289 */
14290
14291 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14292
14293 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14294
14295 if (cached == 0)
14296 {
14297 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14298 if (quiet == 0) log_info ("");
14299
14300 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14301
14302 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14303
14304 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14305
14306 if (rc != 0)
14307 {
14308 device_param->skipped = true;
14309
14310 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14311
14312 continue;
14313 }
14314
14315 size_t binary_size;
14316
14317 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14318
14319 u8 *binary = (u8 *) mymalloc (binary_size);
14320
14321 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14322
14323 writeProgramBin (cached_file, binary, binary_size);
14324
14325 local_free (binary);
14326 }
14327 else
14328 {
14329 #ifdef DEBUG
14330 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14331 #endif
14332
14333 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14334
14335 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14336
14337 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14338 }
14339
14340 local_free (kernel_lengths);
14341 local_free (kernel_sources[0]);
14342 local_free (kernel_sources);
14343 }
14344
14345 /**
14346 * amplifier kernel
14347 */
14348
14349 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14350 {
14351
14352 }
14353 else
14354 {
14355 /**
14356 * kernel amp source filename
14357 */
14358
14359 char source_file[256] = { 0 };
14360
14361 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14362
14363 struct stat sst;
14364
14365 if (stat (source_file, &sst) == -1)
14366 {
14367 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14368
14369 return -1;
14370 }
14371
14372 /**
14373 * kernel amp cached filename
14374 */
14375
14376 char cached_file[256] = { 0 };
14377
14378 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14379
14380 int cached = 1;
14381
14382 struct stat cst;
14383
14384 if (stat (cached_file, &cst) == -1)
14385 {
14386 cached = 0;
14387 }
14388
14389 /**
14390 * kernel compile or load
14391 */
14392
14393 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14394
14395 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14396
14397 if (cached == 0)
14398 {
14399 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14400 if (quiet == 0) log_info ("");
14401
14402 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14403
14404 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14405
14406 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14407
14408 if (rc != 0)
14409 {
14410 device_param->skipped = true;
14411
14412 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14413
14414 continue;
14415 }
14416
14417 size_t binary_size;
14418
14419 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14420
14421 u8 *binary = (u8 *) mymalloc (binary_size);
14422
14423 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14424
14425 writeProgramBin (cached_file, binary, binary_size);
14426
14427 local_free (binary);
14428 }
14429 else
14430 {
14431 #ifdef DEBUG
14432 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14433 #endif
14434
14435 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14436
14437 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14438
14439 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14440 }
14441
14442 local_free (kernel_lengths);
14443 local_free (kernel_sources[0]);
14444 local_free (kernel_sources);
14445 }
14446
14447 // some algorithm collide too fast, make that impossible
14448
14449 if (benchmark == 1)
14450 {
14451 ((uint *) digests_buf)[0] = -1;
14452 ((uint *) digests_buf)[1] = -1;
14453 ((uint *) digests_buf)[2] = -1;
14454 ((uint *) digests_buf)[3] = -1;
14455 }
14456
14457 /**
14458 * global buffers
14459 */
14460
14461 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14462 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14463 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14464 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14465 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14466 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14467 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14468 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14469 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14470 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14471 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14472 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14473 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14474 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14475 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14476 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14477 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14478 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14479
14480 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);
14481 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);
14482 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);
14483 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);
14484 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);
14485 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);
14486 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);
14487 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);
14488 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14489 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14490 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14491
14492 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14493 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14494 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14495 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14496 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14497 run_kernel_bzero (device_param, device_param->d_result, size_results);
14498
14499 /**
14500 * special buffers
14501 */
14502
14503 if (attack_kern == ATTACK_KERN_STRAIGHT)
14504 {
14505 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14506 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14507
14508 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14509
14510 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14511 }
14512 else if (attack_kern == ATTACK_KERN_COMBI)
14513 {
14514 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14515 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14516 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14517 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14518
14519 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14520 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14521 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14522 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14523 }
14524 else if (attack_kern == ATTACK_KERN_BF)
14525 {
14526 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14527 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14528 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14529 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14530 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14531
14532 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14533 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14534 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14535 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14536 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14537 }
14538
14539 if (size_esalts)
14540 {
14541 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14542
14543 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14544 }
14545
14546 /**
14547 * main host data
14548 */
14549
14550 uint *result = (uint *) mymalloc (size_results);
14551
14552 device_param->result = result;
14553
14554 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14555
14556 device_param->pws_buf = pws_buf;
14557
14558 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14559
14560 device_param->combs_buf = combs_buf;
14561
14562 void *hooks_buf = mymalloc (size_hooks);
14563
14564 device_param->hooks_buf = hooks_buf;
14565
14566 /**
14567 * kernel args
14568 */
14569
14570 device_param->kernel_params_buf32[21] = bitmap_mask;
14571 device_param->kernel_params_buf32[22] = bitmap_shift1;
14572 device_param->kernel_params_buf32[23] = bitmap_shift2;
14573 device_param->kernel_params_buf32[24] = 0; // salt_pos
14574 device_param->kernel_params_buf32[25] = 0; // loop_pos
14575 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14576 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14577 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14578 device_param->kernel_params_buf32[29] = 0; // digests_offset
14579 device_param->kernel_params_buf32[30] = 0; // combs_mode
14580 device_param->kernel_params_buf32[31] = 0; // gid_max
14581
14582 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14583 ? &device_param->d_pws_buf
14584 : &device_param->d_pws_amp_buf;
14585 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14586 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14587 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14588 device_param->kernel_params[ 4] = &device_param->d_tmps;
14589 device_param->kernel_params[ 5] = &device_param->d_hooks;
14590 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14591 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14592 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14593 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14594 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14595 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14596 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14597 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14598 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14599 device_param->kernel_params[15] = &device_param->d_digests_buf;
14600 device_param->kernel_params[16] = &device_param->d_digests_shown;
14601 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14602 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14603 device_param->kernel_params[19] = &device_param->d_result;
14604 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14605 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14606 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14607 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14608 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14609 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14610 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14611 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14612 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14613 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14614 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14615 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14616
14617 device_param->kernel_params_mp_buf64[3] = 0;
14618 device_param->kernel_params_mp_buf32[4] = 0;
14619 device_param->kernel_params_mp_buf32[5] = 0;
14620 device_param->kernel_params_mp_buf32[6] = 0;
14621 device_param->kernel_params_mp_buf32[7] = 0;
14622 device_param->kernel_params_mp_buf32[8] = 0;
14623
14624 device_param->kernel_params_mp[0] = NULL;
14625 device_param->kernel_params_mp[1] = NULL;
14626 device_param->kernel_params_mp[2] = NULL;
14627 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14628 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14629 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14630 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14631 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14632 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14633
14634 device_param->kernel_params_mp_l_buf64[3] = 0;
14635 device_param->kernel_params_mp_l_buf32[4] = 0;
14636 device_param->kernel_params_mp_l_buf32[5] = 0;
14637 device_param->kernel_params_mp_l_buf32[6] = 0;
14638 device_param->kernel_params_mp_l_buf32[7] = 0;
14639 device_param->kernel_params_mp_l_buf32[8] = 0;
14640 device_param->kernel_params_mp_l_buf32[9] = 0;
14641
14642 device_param->kernel_params_mp_l[0] = NULL;
14643 device_param->kernel_params_mp_l[1] = NULL;
14644 device_param->kernel_params_mp_l[2] = NULL;
14645 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14646 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14647 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14648 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14649 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14650 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14651 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14652
14653 device_param->kernel_params_mp_r_buf64[3] = 0;
14654 device_param->kernel_params_mp_r_buf32[4] = 0;
14655 device_param->kernel_params_mp_r_buf32[5] = 0;
14656 device_param->kernel_params_mp_r_buf32[6] = 0;
14657 device_param->kernel_params_mp_r_buf32[7] = 0;
14658 device_param->kernel_params_mp_r_buf32[8] = 0;
14659
14660 device_param->kernel_params_mp_r[0] = NULL;
14661 device_param->kernel_params_mp_r[1] = NULL;
14662 device_param->kernel_params_mp_r[2] = NULL;
14663 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14664 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14665 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14666 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14667 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14668 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14669
14670 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14671 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14672
14673 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14674 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14675 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14676 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14677 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14678 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14679 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14680
14681 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14682 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14683
14684 /**
14685 * kernel name
14686 */
14687
14688 size_t kernel_wgs_tmp;
14689
14690 char kernel_name[64] = { 0 };
14691
14692 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14693 {
14694 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14695 {
14696 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14697
14698 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14699
14700 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14701
14702 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14703
14704 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14705
14706 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14707 }
14708 else
14709 {
14710 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14711
14712 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14713
14714 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14715
14716 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14717
14718 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14719
14720 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14721 }
14722
14723 if (data.attack_mode == ATTACK_MODE_BF)
14724 {
14725 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14726 {
14727 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14728
14729 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14730
14731 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);
14732 }
14733 }
14734 }
14735 else
14736 {
14737 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14738
14739 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14740
14741 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14742
14743 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14744
14745 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14746
14747 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14748
14749 if (opts_type & OPTS_TYPE_HOOK12)
14750 {
14751 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14752
14753 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14754
14755 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);
14756 }
14757
14758 if (opts_type & OPTS_TYPE_HOOK23)
14759 {
14760 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14761
14762 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14763
14764 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);
14765 }
14766 }
14767
14768 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);
14769 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);
14770 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);
14771
14772 for (uint i = 0; i <= 20; i++)
14773 {
14774 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14775 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14776 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14777
14778 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14779 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14780 }
14781
14782 for (uint i = 21; i <= 31; i++)
14783 {
14784 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14785 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14786 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14787
14788 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14789 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14790 }
14791
14792 if (attack_mode == ATTACK_MODE_BF)
14793 {
14794 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14795 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14796
14797 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);
14798 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);
14799
14800 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14801 {
14802 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14803 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14804 }
14805 }
14806 else if (attack_mode == ATTACK_MODE_HYBRID1)
14807 {
14808 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14809
14810 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);
14811 }
14812 else if (attack_mode == ATTACK_MODE_HYBRID2)
14813 {
14814 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14815
14816 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);
14817 }
14818
14819 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14820 {
14821 // nothing to do
14822 }
14823 else
14824 {
14825 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14826
14827 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);
14828 }
14829
14830 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14831 {
14832 // nothing to do
14833 }
14834 else
14835 {
14836 for (uint i = 0; i < 5; i++)
14837 {
14838 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14839 }
14840
14841 for (uint i = 5; i < 7; i++)
14842 {
14843 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14844 }
14845 }
14846
14847 // maybe this has been updated by clGetKernelWorkGroupInfo()
14848 // value can only be decreased, so we don't need to reallocate buffers
14849
14850 device_param->kernel_threads = kernel_threads;
14851
14852 /**
14853 * Store initial fanspeed if gpu_temp_retain is enabled
14854 */
14855
14856 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14857 int gpu_temp_retain_set = 0;
14858
14859 if (gpu_temp_disable == 0)
14860 {
14861 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14862 {
14863 hc_thread_mutex_lock (mux_adl);
14864
14865 if (data.hm_device[device_id].fan_supported == 1)
14866 {
14867 if (gpu_temp_retain_chgd == 0)
14868 {
14869 uint cur_temp = 0;
14870 uint default_temp = 0;
14871
14872 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);
14873
14874 if (ADL_rc == ADL_OK)
14875 {
14876 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14877
14878 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14879
14880 // special case with multi gpu setups: always use minimum retain
14881
14882 if (gpu_temp_retain_set == 0)
14883 {
14884 gpu_temp_retain = gpu_temp_retain_target;
14885 gpu_temp_retain_set = 1;
14886 }
14887 else
14888 {
14889 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14890 }
14891
14892 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14893 }
14894 }
14895
14896 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14897
14898 temp_retain_fanspeed_value[device_id] = fan_speed;
14899
14900 if (fan_speed == -1)
14901 {
14902 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14903
14904 temp_retain_fanspeed_value[device_id] = 0;
14905 }
14906 }
14907
14908 hc_thread_mutex_unlock (mux_adl);
14909 }
14910 }
14911
14912 /**
14913 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14914 */
14915
14916 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14917 {
14918 hc_thread_mutex_lock (mux_adl);
14919
14920 if (data.hm_device[device_id].od_version == 6)
14921 {
14922 int ADL_rc;
14923
14924 // check powertune capabilities first, if not available then skip device
14925
14926 int powertune_supported = 0;
14927
14928 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14929 {
14930 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14931
14932 return (-1);
14933 }
14934
14935 if (powertune_supported != 0)
14936 {
14937 // powercontrol settings
14938
14939 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14940
14941 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14942 {
14943 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14944 }
14945
14946 if (ADL_rc != ADL_OK)
14947 {
14948 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14949
14950 return (-1);
14951 }
14952
14953 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14954 {
14955 log_error ("ERROR: Failed to set new ADL PowerControl values");
14956
14957 return (-1);
14958 }
14959
14960 // clocks
14961
14962 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14963
14964 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14965
14966 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)
14967 {
14968 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14969
14970 return (-1);
14971 }
14972
14973 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14974
14975 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14976
14977 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14978 {
14979 log_error ("ERROR: Failed to get ADL device capabilities");
14980
14981 return (-1);
14982 }
14983
14984 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14985 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14986
14987 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14988 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14989
14990 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14991 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14992
14993 // warning if profile has too low max values
14994
14995 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14996 {
14997 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14998 }
14999
15000 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15001 {
15002 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15003 }
15004
15005 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15006
15007 performance_state->iNumberOfPerformanceLevels = 2;
15008
15009 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15010 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15011 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15012 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15013
15014 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)
15015 {
15016 log_info ("ERROR: Failed to set ADL performance state");
15017
15018 return (-1);
15019 }
15020
15021 local_free (performance_state);
15022 }
15023 }
15024
15025 hc_thread_mutex_unlock (mux_adl);
15026 }
15027 #endif // HAVE_HWMON && HAVE_ADL
15028 }
15029
15030 data.kernel_power_all = kernel_power_all;
15031
15032 if (data.quiet == 0) log_info_nn ("");
15033
15034 /**
15035 * In benchmark-mode, inform user which algorithm is checked
15036 */
15037
15038 if (benchmark == 1)
15039 {
15040 if (status_automat == 0)
15041 {
15042 quiet = 0;
15043
15044 data.quiet = quiet;
15045
15046 char *hash_type = strhashtype (data.hash_mode); // not a bug
15047
15048 log_info ("Hashtype: %s", hash_type);
15049 log_info ("");
15050 }
15051 }
15052
15053 /**
15054 * keep track of the progress
15055 */
15056
15057 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15058 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15059 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15060
15061 /**
15062 * open filehandles
15063 */
15064
15065 #if _WIN
15066 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15067 {
15068 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15069
15070 return (-1);
15071 }
15072
15073 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15074 {
15075 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15076
15077 return (-1);
15078 }
15079
15080 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15081 {
15082 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15083
15084 return (-1);
15085 }
15086 #endif
15087
15088 /**
15089 * dictionary pad
15090 */
15091
15092 segment_size *= (1024 * 1024);
15093
15094 data.segment_size = segment_size;
15095
15096 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15097
15098 wl_data->buf = (char *) mymalloc (segment_size);
15099 wl_data->avail = segment_size;
15100 wl_data->incr = segment_size;
15101 wl_data->cnt = 0;
15102 wl_data->pos = 0;
15103
15104 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15105
15106 data.wordlist_mode = wordlist_mode;
15107
15108 cs_t *css_buf = NULL;
15109 uint css_cnt = 0;
15110 uint dictcnt = 0;
15111 uint maskcnt = 1;
15112 char **masks = NULL;
15113 char **dictfiles = NULL;
15114
15115 uint mask_from_file = 0;
15116
15117 if (attack_mode == ATTACK_MODE_STRAIGHT)
15118 {
15119 if (wordlist_mode == WL_MODE_FILE)
15120 {
15121 int wls_left = myargc - (optind + 1);
15122
15123 for (int i = 0; i < wls_left; i++)
15124 {
15125 char *l0_filename = myargv[optind + 1 + i];
15126
15127 struct stat l0_stat;
15128
15129 if (stat (l0_filename, &l0_stat) == -1)
15130 {
15131 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15132
15133 return (-1);
15134 }
15135
15136 uint is_dir = S_ISDIR (l0_stat.st_mode);
15137
15138 if (is_dir == 0)
15139 {
15140 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15141
15142 dictcnt++;
15143
15144 dictfiles[dictcnt - 1] = l0_filename;
15145 }
15146 else
15147 {
15148 // do not allow --keyspace w/ a directory
15149
15150 if (keyspace == 1)
15151 {
15152 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15153
15154 return (-1);
15155 }
15156
15157 char **dictionary_files = NULL;
15158
15159 dictionary_files = scan_directory (l0_filename);
15160
15161 if (dictionary_files != NULL)
15162 {
15163 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15164
15165 for (int d = 0; dictionary_files[d] != NULL; d++)
15166 {
15167 char *l1_filename = dictionary_files[d];
15168
15169 struct stat l1_stat;
15170
15171 if (stat (l1_filename, &l1_stat) == -1)
15172 {
15173 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15174
15175 return (-1);
15176 }
15177
15178 if (S_ISREG (l1_stat.st_mode))
15179 {
15180 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15181
15182 dictcnt++;
15183
15184 dictfiles[dictcnt - 1] = strdup (l1_filename);
15185 }
15186 }
15187 }
15188
15189 local_free (dictionary_files);
15190 }
15191 }
15192
15193 if (dictcnt < 1)
15194 {
15195 log_error ("ERROR: No usable dictionary file found.");
15196
15197 return (-1);
15198 }
15199 }
15200 else if (wordlist_mode == WL_MODE_STDIN)
15201 {
15202 dictcnt = 1;
15203 }
15204 }
15205 else if (attack_mode == ATTACK_MODE_COMBI)
15206 {
15207 // display
15208
15209 char *dictfile1 = myargv[optind + 1 + 0];
15210 char *dictfile2 = myargv[optind + 1 + 1];
15211
15212 // find the bigger dictionary and use as base
15213
15214 FILE *fp1 = NULL;
15215 FILE *fp2 = NULL;
15216
15217 struct stat tmp_stat;
15218
15219 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15220 {
15221 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15222
15223 return (-1);
15224 }
15225
15226 if (stat (dictfile1, &tmp_stat) == -1)
15227 {
15228 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15229
15230 fclose (fp1);
15231
15232 return (-1);
15233 }
15234
15235 if (S_ISDIR (tmp_stat.st_mode))
15236 {
15237 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15238
15239 fclose (fp1);
15240
15241 return (-1);
15242 }
15243
15244 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15245 {
15246 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15247
15248 fclose (fp1);
15249
15250 return (-1);
15251 }
15252
15253 if (stat (dictfile2, &tmp_stat) == -1)
15254 {
15255 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15256
15257 fclose (fp1);
15258 fclose (fp2);
15259
15260 return (-1);
15261 }
15262
15263 if (S_ISDIR (tmp_stat.st_mode))
15264 {
15265 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15266
15267 fclose (fp1);
15268 fclose (fp2);
15269
15270 return (-1);
15271 }
15272
15273 data.combs_cnt = 1;
15274
15275 data.quiet = 1;
15276
15277 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15278
15279 data.quiet = quiet;
15280
15281 if (words1_cnt == 0)
15282 {
15283 log_error ("ERROR: %s: empty file", dictfile1);
15284
15285 fclose (fp1);
15286 fclose (fp2);
15287
15288 return (-1);
15289 }
15290
15291 data.combs_cnt = 1;
15292
15293 data.quiet = 1;
15294
15295 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15296
15297 data.quiet = quiet;
15298
15299 if (words2_cnt == 0)
15300 {
15301 log_error ("ERROR: %s: empty file", dictfile2);
15302
15303 fclose (fp1);
15304 fclose (fp2);
15305
15306 return (-1);
15307 }
15308
15309 fclose (fp1);
15310 fclose (fp2);
15311
15312 data.dictfile = dictfile1;
15313 data.dictfile2 = dictfile2;
15314
15315 if (words1_cnt >= words2_cnt)
15316 {
15317 data.combs_cnt = words2_cnt;
15318 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15319
15320 dictfiles = &data.dictfile;
15321
15322 dictcnt = 1;
15323 }
15324 else
15325 {
15326 data.combs_cnt = words1_cnt;
15327 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15328
15329 dictfiles = &data.dictfile2;
15330
15331 dictcnt = 1;
15332
15333 // we also have to switch wordlist related rules!
15334
15335 char *tmpc = data.rule_buf_l;
15336
15337 data.rule_buf_l = data.rule_buf_r;
15338 data.rule_buf_r = tmpc;
15339
15340 int tmpi = data.rule_len_l;
15341
15342 data.rule_len_l = data.rule_len_r;
15343 data.rule_len_r = tmpi;
15344 }
15345 }
15346 else if (attack_mode == ATTACK_MODE_BF)
15347 {
15348 char *mask = NULL;
15349
15350 maskcnt = 0;
15351
15352 if (benchmark == 0)
15353 {
15354 mask = myargv[optind + 1];
15355
15356 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15357
15358 if ((optind + 2) <= myargc)
15359 {
15360 struct stat file_stat;
15361
15362 if (stat (mask, &file_stat) == -1)
15363 {
15364 maskcnt = 1;
15365
15366 masks[maskcnt - 1] = mystrdup (mask);
15367 }
15368 else
15369 {
15370 int wls_left = myargc - (optind + 1);
15371
15372 uint masks_avail = INCR_MASKS;
15373
15374 for (int i = 0; i < wls_left; i++)
15375 {
15376 if (i != 0)
15377 {
15378 mask = myargv[optind + 1 + i];
15379
15380 if (stat (mask, &file_stat) == -1)
15381 {
15382 log_error ("ERROR: %s: %s", mask, strerror (errno));
15383
15384 return (-1);
15385 }
15386 }
15387
15388 uint is_file = S_ISREG (file_stat.st_mode);
15389
15390 if (is_file == 1)
15391 {
15392 FILE *mask_fp;
15393
15394 if ((mask_fp = fopen (mask, "r")) == NULL)
15395 {
15396 log_error ("ERROR: %s: %s", mask, strerror (errno));
15397
15398 return (-1);
15399 }
15400
15401 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15402
15403 while (!feof (mask_fp))
15404 {
15405 memset (line_buf, 0, HCBUFSIZ);
15406
15407 int line_len = fgetl (mask_fp, line_buf);
15408
15409 if (line_len == 0) continue;
15410
15411 if (line_buf[0] == '#') continue;
15412
15413 if (masks_avail == maskcnt)
15414 {
15415 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15416
15417 masks_avail += INCR_MASKS;
15418 }
15419
15420 masks[maskcnt] = mystrdup (line_buf);
15421
15422 maskcnt++;
15423 }
15424
15425 myfree (line_buf);
15426
15427 fclose (mask_fp);
15428 }
15429 else
15430 {
15431 log_error ("ERROR: %s: unsupported file-type", mask);
15432
15433 return (-1);
15434 }
15435 }
15436
15437 mask_from_file = 1;
15438 }
15439 }
15440 else
15441 {
15442 custom_charset_1 = (char *) "?l?d?u";
15443 custom_charset_2 = (char *) "?l?d";
15444 custom_charset_3 = (char *) "?l?d*!$@_";
15445
15446 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15447 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15448 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15449
15450 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15451
15452 wordlist_mode = WL_MODE_MASK;
15453
15454 data.wordlist_mode = wordlist_mode;
15455
15456 increment = 1;
15457
15458 maskcnt = 1;
15459 }
15460 }
15461 else
15462 {
15463 /**
15464 * generate full masks and charsets
15465 */
15466
15467 masks = (char **) mymalloc (sizeof (char *));
15468
15469 switch (hash_mode)
15470 {
15471 case 1731: pw_min = 5;
15472 pw_max = 5;
15473 mask = mystrdup ("?b?b?b?b?b");
15474 break;
15475 case 12500: pw_min = 5;
15476 pw_max = 5;
15477 mask = mystrdup ("?b?b?b?b?b");
15478 break;
15479 default: pw_min = 7;
15480 pw_max = 7;
15481 mask = mystrdup ("?b?b?b?b?b?b?b");
15482 break;
15483 }
15484
15485 maskcnt = 1;
15486
15487 masks[maskcnt - 1] = mystrdup (mask);
15488
15489 wordlist_mode = WL_MODE_MASK;
15490
15491 data.wordlist_mode = wordlist_mode;
15492
15493 increment = 1;
15494 }
15495
15496 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15497
15498 if (increment)
15499 {
15500 if (increment_min > pw_min) pw_min = increment_min;
15501
15502 if (increment_max < pw_max) pw_max = increment_max;
15503 }
15504 }
15505 else if (attack_mode == ATTACK_MODE_HYBRID1)
15506 {
15507 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15508
15509 // display
15510
15511 char *mask = myargv[myargc - 1];
15512
15513 maskcnt = 0;
15514
15515 masks = (char **) mymalloc (1 * sizeof (char *));
15516
15517 // mod
15518
15519 struct stat file_stat;
15520
15521 if (stat (mask, &file_stat) == -1)
15522 {
15523 maskcnt = 1;
15524
15525 masks[maskcnt - 1] = mystrdup (mask);
15526 }
15527 else
15528 {
15529 uint is_file = S_ISREG (file_stat.st_mode);
15530
15531 if (is_file == 1)
15532 {
15533 FILE *mask_fp;
15534
15535 if ((mask_fp = fopen (mask, "r")) == NULL)
15536 {
15537 log_error ("ERROR: %s: %s", mask, strerror (errno));
15538
15539 return (-1);
15540 }
15541
15542 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15543
15544 uint masks_avail = 1;
15545
15546 while (!feof (mask_fp))
15547 {
15548 memset (line_buf, 0, HCBUFSIZ);
15549
15550 int line_len = fgetl (mask_fp, line_buf);
15551
15552 if (line_len == 0) continue;
15553
15554 if (line_buf[0] == '#') continue;
15555
15556 if (masks_avail == maskcnt)
15557 {
15558 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15559
15560 masks_avail += INCR_MASKS;
15561 }
15562
15563 masks[maskcnt] = mystrdup (line_buf);
15564
15565 maskcnt++;
15566 }
15567
15568 myfree (line_buf);
15569
15570 fclose (mask_fp);
15571
15572 mask_from_file = 1;
15573 }
15574 else
15575 {
15576 maskcnt = 1;
15577
15578 masks[maskcnt - 1] = mystrdup (mask);
15579 }
15580 }
15581
15582 // base
15583
15584 int wls_left = myargc - (optind + 2);
15585
15586 for (int i = 0; i < wls_left; i++)
15587 {
15588 char *filename = myargv[optind + 1 + i];
15589
15590 struct stat file_stat;
15591
15592 if (stat (filename, &file_stat) == -1)
15593 {
15594 log_error ("ERROR: %s: %s", filename, strerror (errno));
15595
15596 return (-1);
15597 }
15598
15599 uint is_dir = S_ISDIR (file_stat.st_mode);
15600
15601 if (is_dir == 0)
15602 {
15603 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15604
15605 dictcnt++;
15606
15607 dictfiles[dictcnt - 1] = filename;
15608 }
15609 else
15610 {
15611 // do not allow --keyspace w/ a directory
15612
15613 if (keyspace == 1)
15614 {
15615 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15616
15617 return (-1);
15618 }
15619
15620 char **dictionary_files = NULL;
15621
15622 dictionary_files = scan_directory (filename);
15623
15624 if (dictionary_files != NULL)
15625 {
15626 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15627
15628 for (int d = 0; dictionary_files[d] != NULL; d++)
15629 {
15630 char *l1_filename = dictionary_files[d];
15631
15632 struct stat l1_stat;
15633
15634 if (stat (l1_filename, &l1_stat) == -1)
15635 {
15636 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15637
15638 return (-1);
15639 }
15640
15641 if (S_ISREG (l1_stat.st_mode))
15642 {
15643 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15644
15645 dictcnt++;
15646
15647 dictfiles[dictcnt - 1] = strdup (l1_filename);
15648 }
15649 }
15650 }
15651
15652 local_free (dictionary_files);
15653 }
15654 }
15655
15656 if (dictcnt < 1)
15657 {
15658 log_error ("ERROR: No usable dictionary file found.");
15659
15660 return (-1);
15661 }
15662
15663 if (increment)
15664 {
15665 maskcnt = 0;
15666
15667 uint mask_min = increment_min; // we can't reject smaller masks here
15668 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15669
15670 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15671 {
15672 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15673
15674 if (cur_mask == NULL) break;
15675
15676 masks[maskcnt] = cur_mask;
15677
15678 maskcnt++;
15679
15680 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15681 }
15682 }
15683 }
15684 else if (attack_mode == ATTACK_MODE_HYBRID2)
15685 {
15686 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15687
15688 // display
15689
15690 char *mask = myargv[optind + 1 + 0];
15691
15692 maskcnt = 0;
15693
15694 masks = (char **) mymalloc (1 * sizeof (char *));
15695
15696 // mod
15697
15698 struct stat file_stat;
15699
15700 if (stat (mask, &file_stat) == -1)
15701 {
15702 maskcnt = 1;
15703
15704 masks[maskcnt - 1] = mystrdup (mask);
15705 }
15706 else
15707 {
15708 uint is_file = S_ISREG (file_stat.st_mode);
15709
15710 if (is_file == 1)
15711 {
15712 FILE *mask_fp;
15713
15714 if ((mask_fp = fopen (mask, "r")) == NULL)
15715 {
15716 log_error ("ERROR: %s: %s", mask, strerror (errno));
15717
15718 return (-1);
15719 }
15720
15721 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15722
15723 uint masks_avail = 1;
15724
15725 while (!feof (mask_fp))
15726 {
15727 memset (line_buf, 0, HCBUFSIZ);
15728
15729 int line_len = fgetl (mask_fp, line_buf);
15730
15731 if (line_len == 0) continue;
15732
15733 if (line_buf[0] == '#') continue;
15734
15735 if (masks_avail == maskcnt)
15736 {
15737 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15738
15739 masks_avail += INCR_MASKS;
15740 }
15741
15742 masks[maskcnt] = mystrdup (line_buf);
15743
15744 maskcnt++;
15745 }
15746
15747 myfree (line_buf);
15748
15749 fclose (mask_fp);
15750
15751 mask_from_file = 1;
15752 }
15753 else
15754 {
15755 maskcnt = 1;
15756
15757 masks[maskcnt - 1] = mystrdup (mask);
15758 }
15759 }
15760
15761 // base
15762
15763 int wls_left = myargc - (optind + 2);
15764
15765 for (int i = 0; i < wls_left; i++)
15766 {
15767 char *filename = myargv[optind + 2 + i];
15768
15769 struct stat file_stat;
15770
15771 if (stat (filename, &file_stat) == -1)
15772 {
15773 log_error ("ERROR: %s: %s", filename, strerror (errno));
15774
15775 return (-1);
15776 }
15777
15778 uint is_dir = S_ISDIR (file_stat.st_mode);
15779
15780 if (is_dir == 0)
15781 {
15782 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15783
15784 dictcnt++;
15785
15786 dictfiles[dictcnt - 1] = filename;
15787 }
15788 else
15789 {
15790 // do not allow --keyspace w/ a directory
15791
15792 if (keyspace == 1)
15793 {
15794 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15795
15796 return (-1);
15797 }
15798
15799 char **dictionary_files = NULL;
15800
15801 dictionary_files = scan_directory (filename);
15802
15803 if (dictionary_files != NULL)
15804 {
15805 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15806
15807 for (int d = 0; dictionary_files[d] != NULL; d++)
15808 {
15809 char *l1_filename = dictionary_files[d];
15810
15811 struct stat l1_stat;
15812
15813 if (stat (l1_filename, &l1_stat) == -1)
15814 {
15815 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15816
15817 return (-1);
15818 }
15819
15820 if (S_ISREG (l1_stat.st_mode))
15821 {
15822 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15823
15824 dictcnt++;
15825
15826 dictfiles[dictcnt - 1] = strdup (l1_filename);
15827 }
15828 }
15829 }
15830
15831 local_free (dictionary_files);
15832 }
15833 }
15834
15835 if (dictcnt < 1)
15836 {
15837 log_error ("ERROR: No usable dictionary file found.");
15838
15839 return (-1);
15840 }
15841
15842 if (increment)
15843 {
15844 maskcnt = 0;
15845
15846 uint mask_min = increment_min; // we can't reject smaller masks here
15847 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15848
15849 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15850 {
15851 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15852
15853 if (cur_mask == NULL) break;
15854
15855 masks[maskcnt] = cur_mask;
15856
15857 maskcnt++;
15858
15859 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15860 }
15861 }
15862 }
15863
15864 data.pw_min = pw_min;
15865 data.pw_max = pw_max;
15866
15867 /**
15868 * weak hash check
15869 */
15870
15871 if (weak_hash_threshold >= salts_cnt)
15872 {
15873 hc_device_param_t *device_param = NULL;
15874
15875 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15876 {
15877 device_param = &data.devices_param[device_id];
15878
15879 if (device_param->skipped) continue;
15880
15881 break;
15882 }
15883
15884 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15885
15886 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15887 {
15888 weak_hash_check (device_param, salt_pos);
15889 }
15890
15891 // Display hack, guarantee that there is at least one \r before real start
15892
15893 //if (data.quiet == 0) log_info ("");
15894 }
15895
15896 /**
15897 * status and monitor threads
15898 */
15899
15900 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15901
15902 hc_thread_t i_thread = 0;
15903
15904 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15905 {
15906 hc_thread_create (i_thread, thread_keypress, &benchmark);
15907 }
15908
15909 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15910
15911 uint ni_threads_cnt = 0;
15912
15913 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15914
15915 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15916
15917 ni_threads_cnt++;
15918
15919 /**
15920 * Outfile remove
15921 */
15922
15923 if (keyspace == 0)
15924 {
15925 if (outfile_check_timer != 0)
15926 {
15927 if (data.outfile_check_directory != NULL)
15928 {
15929 if ((hash_mode != 5200) &&
15930 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15931 (hash_mode != 9000))
15932 {
15933 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15934
15935 ni_threads_cnt++;
15936 }
15937 else
15938 {
15939 outfile_check_timer = 0;
15940 }
15941 }
15942 else
15943 {
15944 outfile_check_timer = 0;
15945 }
15946 }
15947 }
15948
15949 /**
15950 * Inform the user if we got some hashes remove because of the pot file remove feature
15951 */
15952
15953 if (data.quiet == 0)
15954 {
15955 if (potfile_remove_cracks > 0)
15956 {
15957 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15958 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15959 }
15960 }
15961
15962 data.outfile_check_timer = outfile_check_timer;
15963
15964 /**
15965 * main loop
15966 */
15967
15968 char **induction_dictionaries = NULL;
15969
15970 int induction_dictionaries_cnt = 0;
15971
15972 hcstat_table_t *root_table_buf = NULL;
15973 hcstat_table_t *markov_table_buf = NULL;
15974
15975 uint initial_restore_done = 0;
15976
15977 data.maskcnt = maskcnt;
15978
15979 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15980 {
15981 if (data.devices_status == STATUS_CRACKED) break;
15982
15983 data.devices_status = STATUS_INIT;
15984
15985 if (maskpos > rd->maskpos)
15986 {
15987 rd->dictpos = 0;
15988 }
15989
15990 rd->maskpos = maskpos;
15991 data.maskpos = maskpos;
15992
15993 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15994 {
15995 char *mask = masks[maskpos];
15996
15997 if (mask_from_file == 1)
15998 {
15999 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16000
16001 char *str_ptr;
16002 uint str_pos;
16003
16004 uint mask_offset = 0;
16005
16006 uint separator_cnt;
16007
16008 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16009 {
16010 str_ptr = strstr (mask + mask_offset, ",");
16011
16012 if (str_ptr == NULL) break;
16013
16014 str_pos = str_ptr - mask;
16015
16016 // escaped separator, i.e. "\,"
16017
16018 if (str_pos > 0)
16019 {
16020 if (mask[str_pos - 1] == '\\')
16021 {
16022 separator_cnt --;
16023
16024 mask_offset = str_pos + 1;
16025
16026 continue;
16027 }
16028 }
16029
16030 // reset the offset
16031
16032 mask_offset = 0;
16033
16034 mask[str_pos] = '\0';
16035
16036 switch (separator_cnt)
16037 {
16038 case 0:
16039 mp_reset_usr (mp_usr, 0);
16040
16041 custom_charset_1 = mask;
16042 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16043 break;
16044
16045 case 1:
16046 mp_reset_usr (mp_usr, 1);
16047
16048 custom_charset_2 = mask;
16049 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16050 break;
16051
16052 case 2:
16053 mp_reset_usr (mp_usr, 2);
16054
16055 custom_charset_3 = mask;
16056 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16057 break;
16058
16059 case 3:
16060 mp_reset_usr (mp_usr, 3);
16061
16062 custom_charset_4 = mask;
16063 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16064 break;
16065 }
16066
16067 mask = mask + str_pos + 1;
16068 }
16069 }
16070
16071 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16072 {
16073 if (maskpos > 0)
16074 {
16075 local_free (css_buf);
16076 local_free (data.root_css_buf);
16077 local_free (data.markov_css_buf);
16078
16079 local_free (masks[maskpos - 1]);
16080 }
16081
16082 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16083
16084 data.mask = mask;
16085 data.css_cnt = css_cnt;
16086 data.css_buf = css_buf;
16087
16088 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16089
16090 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16091
16092 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16093 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16094
16095 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16096
16097 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16098
16099 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16100 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16101
16102 data.root_css_buf = root_css_buf;
16103 data.markov_css_buf = markov_css_buf;
16104
16105 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16106
16107 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16108
16109 local_free (root_table_buf);
16110 local_free (markov_table_buf);
16111
16112 // args
16113
16114 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16115 {
16116 hc_device_param_t *device_param = &data.devices_param[device_id];
16117
16118 if (device_param->skipped) continue;
16119
16120 device_param->kernel_params_mp[0] = &device_param->d_combs;
16121 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16122 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16123
16124 device_param->kernel_params_mp_buf64[3] = 0;
16125 device_param->kernel_params_mp_buf32[4] = css_cnt;
16126 device_param->kernel_params_mp_buf32[5] = 0;
16127 device_param->kernel_params_mp_buf32[6] = 0;
16128 device_param->kernel_params_mp_buf32[7] = 0;
16129
16130 if (attack_mode == ATTACK_MODE_HYBRID1)
16131 {
16132 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16133 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16134 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16135 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16136 }
16137 else if (attack_mode == ATTACK_MODE_HYBRID2)
16138 {
16139 device_param->kernel_params_mp_buf32[5] = 0;
16140 device_param->kernel_params_mp_buf32[6] = 0;
16141 device_param->kernel_params_mp_buf32[7] = 0;
16142 }
16143
16144 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]);
16145 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]);
16146 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]);
16147
16148 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);
16149 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);
16150 }
16151 }
16152 else if (attack_mode == ATTACK_MODE_BF)
16153 {
16154 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16155
16156 if (increment)
16157 {
16158 for (uint i = 0; i < dictcnt; i++)
16159 {
16160 local_free (dictfiles[i]);
16161 }
16162
16163 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16164 {
16165 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16166
16167 if (l1_filename == NULL) break;
16168
16169 dictcnt++;
16170
16171 dictfiles[dictcnt - 1] = l1_filename;
16172 }
16173 }
16174 else
16175 {
16176 dictcnt++;
16177
16178 dictfiles[dictcnt - 1] = mask;
16179 }
16180
16181 if (dictcnt == 0)
16182 {
16183 log_error ("ERROR: Mask is too small");
16184
16185 return (-1);
16186 }
16187 }
16188 }
16189
16190 free (induction_dictionaries);
16191
16192 // induction_dictionaries_cnt = 0; // implied
16193
16194 if (attack_mode != ATTACK_MODE_BF)
16195 {
16196 if (keyspace == 0)
16197 {
16198 induction_dictionaries = scan_directory (induction_directory);
16199
16200 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16201 }
16202 }
16203
16204 if (induction_dictionaries_cnt)
16205 {
16206 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16207 }
16208
16209 /**
16210 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16211 */
16212 if (keyspace == 1)
16213 {
16214 if ((maskcnt > 1) || (dictcnt > 1))
16215 {
16216 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16217
16218 return (-1);
16219 }
16220 }
16221
16222 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16223 {
16224 char *subid = logfile_generate_subid ();
16225
16226 data.subid = subid;
16227
16228 logfile_sub_msg ("START");
16229
16230 data.devices_status = STATUS_INIT;
16231
16232 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16233 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16234 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16235
16236 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16237
16238 data.cpt_pos = 0;
16239
16240 data.cpt_start = time (NULL);
16241
16242 data.cpt_total = 0;
16243
16244 if (data.restore == 0)
16245 {
16246 rd->words_cur = skip;
16247
16248 skip = 0;
16249
16250 data.skip = 0;
16251 }
16252
16253 data.ms_paused = 0;
16254
16255 data.words_cur = rd->words_cur;
16256
16257 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16258 {
16259 hc_device_param_t *device_param = &data.devices_param[device_id];
16260
16261 if (device_param->skipped) continue;
16262
16263 device_param->speed_pos = 0;
16264
16265 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16266 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16267
16268 device_param->exec_pos = 0;
16269
16270 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16271
16272 device_param->kernel_power = device_param->kernel_power_user;
16273
16274 device_param->outerloop_pos = 0;
16275 device_param->outerloop_left = 0;
16276 device_param->innerloop_pos = 0;
16277 device_param->innerloop_left = 0;
16278
16279 // some more resets:
16280
16281 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16282
16283 device_param->pws_cnt = 0;
16284
16285 device_param->words_off = 0;
16286 device_param->words_done = 0;
16287 }
16288
16289 data.kernel_power_div = 0;
16290
16291 // figure out some workload
16292
16293 if (attack_mode == ATTACK_MODE_STRAIGHT)
16294 {
16295 if (data.wordlist_mode == WL_MODE_FILE)
16296 {
16297 char *dictfile = NULL;
16298
16299 if (induction_dictionaries_cnt)
16300 {
16301 dictfile = induction_dictionaries[0];
16302 }
16303 else
16304 {
16305 dictfile = dictfiles[dictpos];
16306 }
16307
16308 data.dictfile = dictfile;
16309
16310 logfile_sub_string (dictfile);
16311
16312 for (uint i = 0; i < rp_files_cnt; i++)
16313 {
16314 logfile_sub_var_string ("rulefile", rp_files[i]);
16315 }
16316
16317 FILE *fd2 = fopen (dictfile, "rb");
16318
16319 if (fd2 == NULL)
16320 {
16321 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16322
16323 return (-1);
16324 }
16325
16326 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16327
16328 fclose (fd2);
16329
16330 if (data.words_cnt == 0)
16331 {
16332 if (data.devices_status == STATUS_CRACKED) break;
16333 if (data.devices_status == STATUS_ABORTED) break;
16334
16335 dictpos++;
16336
16337 continue;
16338 }
16339 }
16340 }
16341 else if (attack_mode == ATTACK_MODE_COMBI)
16342 {
16343 char *dictfile = data.dictfile;
16344 char *dictfile2 = data.dictfile2;
16345
16346 logfile_sub_string (dictfile);
16347 logfile_sub_string (dictfile2);
16348
16349 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16350 {
16351 FILE *fd2 = fopen (dictfile, "rb");
16352
16353 if (fd2 == NULL)
16354 {
16355 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16356
16357 return (-1);
16358 }
16359
16360 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16361
16362 fclose (fd2);
16363 }
16364 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16365 {
16366 FILE *fd2 = fopen (dictfile2, "rb");
16367
16368 if (fd2 == NULL)
16369 {
16370 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16371
16372 return (-1);
16373 }
16374
16375 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16376
16377 fclose (fd2);
16378 }
16379
16380 if (data.words_cnt == 0)
16381 {
16382 if (data.devices_status == STATUS_CRACKED) break;
16383 if (data.devices_status == STATUS_ABORTED) break;
16384
16385 dictpos++;
16386
16387 continue;
16388 }
16389 }
16390 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16391 {
16392 char *dictfile = NULL;
16393
16394 if (induction_dictionaries_cnt)
16395 {
16396 dictfile = induction_dictionaries[0];
16397 }
16398 else
16399 {
16400 dictfile = dictfiles[dictpos];
16401 }
16402
16403 data.dictfile = dictfile;
16404
16405 char *mask = data.mask;
16406
16407 logfile_sub_string (dictfile);
16408 logfile_sub_string (mask);
16409
16410 FILE *fd2 = fopen (dictfile, "rb");
16411
16412 if (fd2 == NULL)
16413 {
16414 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16415
16416 return (-1);
16417 }
16418
16419 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16420
16421 fclose (fd2);
16422
16423 if (data.words_cnt == 0)
16424 {
16425 if (data.devices_status == STATUS_CRACKED) break;
16426 if (data.devices_status == STATUS_ABORTED) break;
16427
16428 dictpos++;
16429
16430 continue;
16431 }
16432 }
16433 else if (attack_mode == ATTACK_MODE_BF)
16434 {
16435 local_free (css_buf);
16436 local_free (data.root_css_buf);
16437 local_free (data.markov_css_buf);
16438
16439 char *mask = dictfiles[dictpos];
16440
16441 logfile_sub_string (mask);
16442
16443 // base
16444
16445 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16446
16447 if (opts_type & OPTS_TYPE_PT_UNICODE)
16448 {
16449 uint css_cnt_unicode = css_cnt * 2;
16450
16451 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16452
16453 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16454 {
16455 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16456
16457 css_buf_unicode[j + 1].cs_buf[0] = 0;
16458 css_buf_unicode[j + 1].cs_len = 1;
16459 }
16460
16461 free (css_buf);
16462
16463 css_buf = css_buf_unicode;
16464 css_cnt = css_cnt_unicode;
16465 }
16466
16467 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16468
16469 uint mask_min = pw_min;
16470 uint mask_max = pw_max;
16471
16472 if (opts_type & OPTS_TYPE_PT_UNICODE)
16473 {
16474 mask_min *= 2;
16475 mask_max *= 2;
16476 }
16477
16478 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16479 {
16480 if (css_cnt < mask_min)
16481 {
16482 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16483 }
16484
16485 if (css_cnt > mask_max)
16486 {
16487 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16488 }
16489
16490 // skip to next mask
16491
16492 dictpos++;
16493
16494 rd->dictpos = dictpos;
16495
16496 logfile_sub_msg ("STOP");
16497
16498 continue;
16499 }
16500
16501 uint save_css_cnt = css_cnt;
16502
16503 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16504 {
16505 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16506 {
16507 uint salt_len = (uint) data.salts_buf[0].salt_len;
16508 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16509
16510 uint css_cnt_salt = css_cnt + salt_len;
16511
16512 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16513
16514 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16515
16516 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16517 {
16518 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16519 css_buf_salt[j].cs_len = 1;
16520 }
16521
16522 free (css_buf);
16523
16524 css_buf = css_buf_salt;
16525 css_cnt = css_cnt_salt;
16526 }
16527 }
16528
16529 data.mask = mask;
16530 data.css_cnt = css_cnt;
16531 data.css_buf = css_buf;
16532
16533 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16534
16535 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16536
16537 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16538
16539 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16540 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16541
16542 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16543
16544 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16545
16546 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16547 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16548
16549 data.root_css_buf = root_css_buf;
16550 data.markov_css_buf = markov_css_buf;
16551
16552 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16553
16554 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16555
16556 local_free (root_table_buf);
16557 local_free (markov_table_buf);
16558
16559 // copy + args
16560
16561 uint css_cnt_l = css_cnt;
16562 uint css_cnt_r;
16563
16564 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16565 {
16566 if (save_css_cnt < 6)
16567 {
16568 css_cnt_r = 1;
16569 }
16570 else if (save_css_cnt == 6)
16571 {
16572 css_cnt_r = 2;
16573 }
16574 else
16575 {
16576 if (opts_type & OPTS_TYPE_PT_UNICODE)
16577 {
16578 if (save_css_cnt == 8 || save_css_cnt == 10)
16579 {
16580 css_cnt_r = 2;
16581 }
16582 else
16583 {
16584 css_cnt_r = 4;
16585 }
16586 }
16587 else
16588 {
16589 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16590 {
16591 css_cnt_r = 3;
16592 }
16593 else
16594 {
16595 css_cnt_r = 4;
16596 }
16597 }
16598 }
16599 }
16600 else
16601 {
16602 css_cnt_r = 1;
16603
16604 /* unfinished code?
16605 int sum = css_buf[css_cnt_r - 1].cs_len;
16606
16607 for (uint i = 1; i < 4 && i < css_cnt; i++)
16608 {
16609 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16610
16611 css_cnt_r++;
16612
16613 sum *= css_buf[css_cnt_r - 1].cs_len;
16614 }
16615 */
16616 }
16617
16618 css_cnt_l -= css_cnt_r;
16619
16620 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16621
16622 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16623 {
16624 hc_device_param_t *device_param = &data.devices_param[device_id];
16625
16626 if (device_param->skipped) continue;
16627
16628 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16629 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16630 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16631
16632 device_param->kernel_params_mp_l_buf64[3] = 0;
16633 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16634 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16635 device_param->kernel_params_mp_l_buf32[6] = 0;
16636 device_param->kernel_params_mp_l_buf32[7] = 0;
16637 device_param->kernel_params_mp_l_buf32[8] = 0;
16638
16639 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16640 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16641 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16642 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16643
16644 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16645 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16646 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16647
16648 device_param->kernel_params_mp_r_buf64[3] = 0;
16649 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16650 device_param->kernel_params_mp_r_buf32[5] = 0;
16651 device_param->kernel_params_mp_r_buf32[6] = 0;
16652 device_param->kernel_params_mp_r_buf32[7] = 0;
16653
16654 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]);
16655 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]);
16656 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]);
16657
16658 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]);
16659 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]);
16660 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]);
16661
16662 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);
16663 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);
16664 }
16665 }
16666
16667 u64 words_base = data.words_cnt;
16668
16669 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16670 {
16671 if (data.kernel_rules_cnt)
16672 {
16673 words_base /= data.kernel_rules_cnt;
16674 }
16675 }
16676 else if (data.attack_kern == ATTACK_KERN_COMBI)
16677 {
16678 if (data.combs_cnt)
16679 {
16680 words_base /= data.combs_cnt;
16681 }
16682 }
16683 else if (data.attack_kern == ATTACK_KERN_BF)
16684 {
16685 if (data.bfs_cnt)
16686 {
16687 words_base /= data.bfs_cnt;
16688 }
16689 }
16690
16691 data.words_base = words_base;
16692
16693 if (keyspace == 1)
16694 {
16695 log_info ("%llu", (unsigned long long int) words_base);
16696
16697 return (0);
16698 }
16699
16700 if (data.words_cur > data.words_base)
16701 {
16702 log_error ("ERROR: restore value greater keyspace");
16703
16704 return (-1);
16705 }
16706
16707 if (data.words_cur)
16708 {
16709 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16710 {
16711 for (uint i = 0; i < data.salts_cnt; i++)
16712 {
16713 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16714 }
16715 }
16716 else if (data.attack_kern == ATTACK_KERN_COMBI)
16717 {
16718 for (uint i = 0; i < data.salts_cnt; i++)
16719 {
16720 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16721 }
16722 }
16723 else if (data.attack_kern == ATTACK_KERN_BF)
16724 {
16725 for (uint i = 0; i < data.salts_cnt; i++)
16726 {
16727 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16728 }
16729 }
16730 }
16731
16732 /*
16733 * Inform user about possible slow speeds
16734 */
16735
16736 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16737 {
16738 if (data.words_base < kernel_power_all)
16739 {
16740 if (quiet == 0)
16741 {
16742 log_info ("ATTENTION!");
16743 log_info (" The wordlist or mask you are using is too small.");
16744 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16745 log_info (" The cracking speed will drop.");
16746 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16747 log_info ("");
16748 }
16749 }
16750 }
16751
16752 /*
16753 * Update loopback file
16754 */
16755
16756 if (loopback == 1)
16757 {
16758 time_t now;
16759
16760 time (&now);
16761
16762 uint random_num = get_random_num (0, 9999);
16763
16764 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16765
16766 data.loopback_file = loopback_file;
16767 }
16768
16769 /*
16770 * Update dictionary statistic
16771 */
16772
16773 if (keyspace == 0)
16774 {
16775 dictstat_fp = fopen (dictstat, "wb");
16776
16777 if (dictstat_fp)
16778 {
16779 lock_file (dictstat_fp);
16780
16781 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16782
16783 fclose (dictstat_fp);
16784 }
16785 }
16786
16787 data.devices_status = STATUS_RUNNING;
16788
16789 if (initial_restore_done == 0)
16790 {
16791 if (data.restore_disable == 0) cycle_restore ();
16792
16793 initial_restore_done = 1;
16794 }
16795
16796 hc_timer_set (&data.timer_running);
16797
16798 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16799 {
16800 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16801 {
16802 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16803 if (quiet == 0) fflush (stdout);
16804 }
16805 }
16806 else if (wordlist_mode == WL_MODE_STDIN)
16807 {
16808 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16809 if (data.quiet == 0) log_info ("");
16810 }
16811
16812 time_t runtime_start;
16813
16814 time (&runtime_start);
16815
16816 data.runtime_start = runtime_start;
16817
16818 /**
16819 * create cracker threads
16820 */
16821
16822 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16823
16824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16825 {
16826 hc_device_param_t *device_param = &devices_param[device_id];
16827
16828 if (wordlist_mode == WL_MODE_STDIN)
16829 {
16830 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16831 }
16832 else
16833 {
16834 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16835 }
16836 }
16837
16838 // wait for crack threads to exit
16839
16840 hc_thread_wait (data.devices_cnt, c_threads);
16841
16842 local_free (c_threads);
16843
16844 data.restore = 0;
16845
16846 // finalize task
16847
16848 logfile_sub_var_uint ("status-after-work", data.devices_status);
16849
16850 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16851
16852 if (data.devices_status == STATUS_CRACKED) break;
16853 if (data.devices_status == STATUS_ABORTED) break;
16854
16855 if (data.devices_status == STATUS_BYPASS)
16856 {
16857 data.devices_status = STATUS_RUNNING;
16858 }
16859
16860 if (induction_dictionaries_cnt)
16861 {
16862 unlink (induction_dictionaries[0]);
16863 }
16864
16865 free (induction_dictionaries);
16866
16867 if (attack_mode != ATTACK_MODE_BF)
16868 {
16869 induction_dictionaries = scan_directory (induction_directory);
16870
16871 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16872 }
16873
16874 if (benchmark == 0)
16875 {
16876 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16877 {
16878 if (quiet == 0) clear_prompt ();
16879
16880 if (quiet == 0) log_info ("");
16881
16882 if (status == 1)
16883 {
16884 status_display ();
16885 }
16886 else
16887 {
16888 if (quiet == 0) status_display ();
16889 }
16890
16891 if (quiet == 0) log_info ("");
16892 }
16893 }
16894
16895 if (attack_mode == ATTACK_MODE_BF)
16896 {
16897 dictpos++;
16898
16899 rd->dictpos = dictpos;
16900 }
16901 else
16902 {
16903 if (induction_dictionaries_cnt)
16904 {
16905 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16906 }
16907 else
16908 {
16909 dictpos++;
16910
16911 rd->dictpos = dictpos;
16912 }
16913 }
16914
16915 time_t runtime_stop;
16916
16917 time (&runtime_stop);
16918
16919 data.runtime_stop = runtime_stop;
16920
16921 logfile_sub_uint (runtime_start);
16922 logfile_sub_uint (runtime_stop);
16923
16924 logfile_sub_msg ("STOP");
16925
16926 global_free (subid);
16927 }
16928
16929 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16930
16931 if (data.devices_status == STATUS_CRACKED) break;
16932 if (data.devices_status == STATUS_ABORTED) break;
16933 if (data.devices_status == STATUS_QUIT) break;
16934
16935 if (data.devices_status == STATUS_BYPASS)
16936 {
16937 data.devices_status = STATUS_RUNNING;
16938 }
16939 }
16940
16941 // 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
16942
16943 if (attack_mode == ATTACK_MODE_STRAIGHT)
16944 {
16945 if (data.wordlist_mode == WL_MODE_FILE)
16946 {
16947 if (data.dictfile == NULL)
16948 {
16949 if (dictfiles != NULL)
16950 {
16951 data.dictfile = dictfiles[0];
16952
16953 hc_timer_set (&data.timer_running);
16954 }
16955 }
16956 }
16957 }
16958 // NOTE: combi is okay because it is already set beforehand
16959 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16960 {
16961 if (data.dictfile == NULL)
16962 {
16963 if (dictfiles != NULL)
16964 {
16965 hc_timer_set (&data.timer_running);
16966
16967 data.dictfile = dictfiles[0];
16968 }
16969 }
16970 }
16971 else if (attack_mode == ATTACK_MODE_BF)
16972 {
16973 if (data.mask == NULL)
16974 {
16975 hc_timer_set (&data.timer_running);
16976
16977 data.mask = masks[0];
16978 }
16979 }
16980
16981 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16982 {
16983 data.devices_status = STATUS_EXHAUSTED;
16984 }
16985
16986 // if cracked / aborted remove last induction dictionary
16987
16988 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16989 {
16990 struct stat induct_stat;
16991
16992 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16993 {
16994 unlink (induction_dictionaries[file_pos]);
16995 }
16996 }
16997
16998 // wait for non-interactive threads
16999
17000 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17001 {
17002 hc_thread_wait (1, &ni_threads[thread_idx]);
17003 }
17004
17005 local_free (ni_threads);
17006
17007 // wait for interactive threads
17008
17009 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17010 {
17011 hc_thread_wait (1, &i_thread);
17012 }
17013
17014 // we dont need restore file anymore
17015 if (data.restore_disable == 0)
17016 {
17017 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17018 {
17019 unlink (eff_restore_file);
17020 unlink (new_restore_file);
17021 }
17022 else
17023 {
17024 cycle_restore ();
17025 }
17026 }
17027
17028 // finally save left hashes
17029
17030 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17031 {
17032 save_hash ();
17033 }
17034
17035 /**
17036 * Clean up
17037 */
17038
17039 if (benchmark == 1)
17040 {
17041 status_benchmark ();
17042
17043 if (status_automat == 0)
17044 {
17045 log_info ("");
17046 }
17047 }
17048 else
17049 {
17050 if (quiet == 0) clear_prompt ();
17051
17052 if (quiet == 0) log_info ("");
17053
17054 if (status == 1)
17055 {
17056 status_display ();
17057 }
17058 else
17059 {
17060 if (quiet == 0) status_display ();
17061 }
17062
17063 if (quiet == 0) log_info ("");
17064 }
17065
17066 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17067 {
17068 hc_device_param_t *device_param = &data.devices_param[device_id];
17069
17070 if (device_param->skipped) continue;
17071
17072 local_free (device_param->result);
17073
17074 local_free (device_param->combs_buf);
17075
17076 local_free (device_param->hooks_buf);
17077
17078 local_free (device_param->device_name);
17079
17080 local_free (device_param->device_name_chksum);
17081
17082 local_free (device_param->device_version);
17083
17084 local_free (device_param->driver_version);
17085
17086 if (device_param->pws_buf) myfree (device_param->pws_buf);
17087 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17088 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17089 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17090 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17091 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17092 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17093 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17094 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17095 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17096 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17097 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17098 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17099 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17100 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17101 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17102 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17103 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17104 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17105 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17106 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17107 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17108 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17109 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17110 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17111 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17112 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17113 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17114 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17115
17116 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17117 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17118 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17119 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17120 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17121 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17122 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17123 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17124 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17125 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17126
17127 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17128 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17129 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17130
17131 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17132 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17133 }
17134
17135 // reset default fan speed
17136
17137 #ifdef HAVE_HWMON
17138 if (gpu_temp_disable == 0)
17139 {
17140 #ifdef HAVE_ADL
17141 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17142 {
17143 hc_thread_mutex_lock (mux_adl);
17144
17145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17146 {
17147 hc_device_param_t *device_param = &data.devices_param[device_id];
17148
17149 if (device_param->skipped) continue;
17150
17151 if (data.hm_device[device_id].fan_supported == 1)
17152 {
17153 int fanspeed = temp_retain_fanspeed_value[device_id];
17154
17155 if (fanspeed == -1) continue;
17156
17157 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17158
17159 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17160 }
17161 }
17162
17163 hc_thread_mutex_unlock (mux_adl);
17164 }
17165 #endif // HAVE_ADL
17166 }
17167
17168 #ifdef HAVE_ADL
17169 // reset power tuning
17170
17171 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17172 {
17173 hc_thread_mutex_lock (mux_adl);
17174
17175 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17176 {
17177 hc_device_param_t *device_param = &data.devices_param[device_id];
17178
17179 if (device_param->skipped) continue;
17180
17181 if (data.hm_device[device_id].od_version == 6)
17182 {
17183 // check powertune capabilities first, if not available then skip device
17184
17185 int powertune_supported = 0;
17186
17187 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17188 {
17189 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17190
17191 return (-1);
17192 }
17193
17194 if (powertune_supported != 0)
17195 {
17196 // powercontrol settings
17197
17198 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)
17199 {
17200 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17201
17202 return (-1);
17203 }
17204
17205 // clocks
17206
17207 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17208
17209 performance_state->iNumberOfPerformanceLevels = 2;
17210
17211 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17212 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17213 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17214 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17215
17216 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)
17217 {
17218 log_info ("ERROR: Failed to restore ADL performance state");
17219
17220 return (-1);
17221 }
17222
17223 local_free (performance_state);
17224 }
17225 }
17226 }
17227
17228 hc_thread_mutex_unlock (mux_adl);
17229 }
17230 #endif // HAVE_ADL
17231
17232 if (gpu_temp_disable == 0)
17233 {
17234 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17235 if (data.hm_nv)
17236 {
17237 #if defined(LINUX) && defined(HAVE_NVML)
17238
17239 hm_NVML_nvmlShutdown (data.hm_nv);
17240
17241 nvml_close (data.hm_nv);
17242
17243 #elif defined(WIN) && (HAVE_NVAPI)
17244
17245 hm_NvAPI_Unload (data.hm_nv);
17246
17247 nvapi_close (data.hm_nv);
17248
17249 #endif
17250
17251 data.hm_nv = NULL;
17252 }
17253 #endif
17254
17255 #ifdef HAVE_ADL
17256 if (data.hm_amd)
17257 {
17258 hm_ADL_Main_Control_Destroy (data.hm_amd);
17259
17260 adl_close (data.hm_amd);
17261 data.hm_amd = NULL;
17262 }
17263 #endif
17264 }
17265 #endif // HAVE_HWMON
17266
17267 // free memory
17268
17269 local_free (masks);
17270
17271 local_free (dictstat_base);
17272
17273 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17274 {
17275 pot_t *pot_ptr = &pot[pot_pos];
17276
17277 hash_t *hash = &pot_ptr->hash;
17278
17279 local_free (hash->digest);
17280
17281 if (isSalted)
17282 {
17283 local_free (hash->salt);
17284 }
17285 }
17286
17287 local_free (pot);
17288
17289 local_free (all_kernel_rules_cnt);
17290 local_free (all_kernel_rules_buf);
17291
17292 local_free (wl_data->buf);
17293 local_free (wl_data);
17294
17295 local_free (bitmap_s1_a);
17296 local_free (bitmap_s1_b);
17297 local_free (bitmap_s1_c);
17298 local_free (bitmap_s1_d);
17299 local_free (bitmap_s2_a);
17300 local_free (bitmap_s2_b);
17301 local_free (bitmap_s2_c);
17302 local_free (bitmap_s2_d);
17303
17304 #ifdef HAVE_HWMON
17305 local_free (temp_retain_fanspeed_value);
17306 #ifdef HAVE_ADL
17307 local_free (od_clock_mem_status);
17308 local_free (od_power_control_status);
17309 #endif // ADL
17310 #endif
17311
17312 global_free (devices_param);
17313
17314 global_free (kernel_rules_buf);
17315
17316 global_free (root_css_buf);
17317 global_free (markov_css_buf);
17318
17319 global_free (digests_buf);
17320 global_free (digests_shown);
17321 global_free (digests_shown_tmp);
17322
17323 global_free (salts_buf);
17324 global_free (salts_shown);
17325
17326 global_free (esalts_buf);
17327
17328 global_free (words_progress_done);
17329 global_free (words_progress_rejected);
17330 global_free (words_progress_restored);
17331
17332 if (pot_fp) fclose (pot_fp);
17333
17334 if (data.devices_status == STATUS_QUIT) break;
17335 }
17336
17337 // destroy others mutex
17338
17339 hc_thread_mutex_delete (mux_dispatcher);
17340 hc_thread_mutex_delete (mux_counter);
17341 hc_thread_mutex_delete (mux_display);
17342 hc_thread_mutex_delete (mux_adl);
17343
17344 // free memory
17345
17346 local_free (eff_restore_file);
17347 local_free (new_restore_file);
17348
17349 local_free (rd);
17350
17351 // tuning db
17352
17353 tuning_db_destroy (tuning_db);
17354
17355 // loopback
17356
17357 local_free (loopback_file);
17358
17359 if (loopback == 1) unlink (loopback_file);
17360
17361 // induction directory
17362
17363 if (induction_dir == NULL)
17364 {
17365 if (attack_mode != ATTACK_MODE_BF)
17366 {
17367 if (rmdir (induction_directory) == -1)
17368 {
17369 if (errno == ENOENT)
17370 {
17371 // good, we can ignore
17372 }
17373 else if (errno == ENOTEMPTY)
17374 {
17375 // good, we can ignore
17376 }
17377 else
17378 {
17379 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17380
17381 return (-1);
17382 }
17383 }
17384
17385 local_free (induction_directory);
17386 }
17387 }
17388
17389 // outfile-check directory
17390
17391 if (outfile_check_dir == NULL)
17392 {
17393 if (rmdir (outfile_check_directory) == -1)
17394 {
17395 if (errno == ENOENT)
17396 {
17397 // good, we can ignore
17398 }
17399 else if (errno == ENOTEMPTY)
17400 {
17401 // good, we can ignore
17402 }
17403 else
17404 {
17405 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17406
17407 return (-1);
17408 }
17409 }
17410
17411 local_free (outfile_check_directory);
17412 }
17413
17414 time_t proc_stop;
17415
17416 time (&proc_stop);
17417
17418 logfile_top_uint (proc_start);
17419 logfile_top_uint (proc_stop);
17420
17421 logfile_top_msg ("STOP");
17422
17423 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17424 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17425
17426 if (data.ocl) ocl_close (data.ocl);
17427
17428 if (data.devices_status == STATUS_ABORTED) return 2;
17429 if (data.devices_status == STATUS_QUIT) return 2;
17430 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17431 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17432 if (data.devices_status == STATUS_CRACKED) return 0;
17433
17434 return -1;
17435 }
Hashcat additions to support pwdhash