projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix broken -m 1500 and -m 3000 in -a 3 mode
[hashcat.git] / src / oclHashcat.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 = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
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 BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
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 HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 133
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 13200,
264 13300,
265 6211,
266 6221,
267 6231,
268 6241,
269 8800,
270 12900,
271 12200,
272 9700,
273 9710,
274 9800,
275 9810,
276 9400,
277 9500,
278 9600,
279 10400,
280 10410,
281 10500,
282 10600,
283 10700,
284 9000,
285 5200,
286 6800,
287 6600,
288 8200,
289 11300,
290 12700
291 };
292
293 /**
294 * types
295 */
296
297 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
298
299 /**
300 * globals
301 */
302
303 static unsigned int full01 = 0x01010101;
304 static unsigned int full80 = 0x80808080;
305
306 int SUPPRESS_OUTPUT = 0;
307
308 hc_thread_mutex_t mux_adl;
309 hc_thread_mutex_t mux_counter;
310 hc_thread_mutex_t mux_dispatcher;
311 hc_thread_mutex_t mux_display;
312
313 hc_global_data_t data;
314
315 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
316
317 const char *USAGE_MINI[] =
318 {
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "Try --help for more help.",
322 NULL
323 };
324
325 const char *USAGE_BIG[] =
326 {
327 "%s, advanced password recovery",
328 "",
329 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
330 "",
331 "=======",
332 "Options",
333 "=======",
334 "",
335 "* General:",
336 "",
337 " -m, --hash-type=NUM Hash-type, see references below",
338 " -a, --attack-mode=NUM Attack-mode, see references below",
339 " -V, --version Print version",
340 " -h, --help Print help",
341 " --quiet Suppress output",
342 "",
343 "* Misc:",
344 "",
345 " --hex-charset Assume charset is given in hex",
346 " --hex-salt Assume salt is given in hex",
347 " --hex-wordlist Assume words in wordlist is given in hex",
348 " --force Ignore warnings",
349 " --status Enable automatic update of the status-screen",
350 " --status-timer=NUM Seconds between status-screen update",
351 " --status-automat Display the status view in a machine readable format",
352 " --loopback Add new plains to induct directory",
353 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
354 "",
355 "* Markov:",
356 "",
357 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
358 " --markov-disable Disables markov-chains, emulates classic brute-force",
359 " --markov-classic Enables classic markov-chains, no per-position enhancement",
360 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
361 "",
362 "* Session:",
363 "",
364 " --runtime=NUM Abort session after NUM seconds of runtime",
365 " --session=STR Define specific session name",
366 " --restore Restore session from --session",
367 " --restore-disable Do not write restore file",
368 "",
369 "* Files:",
370 "",
371 " -o, --outfile=FILE Define outfile for recovered hash",
372 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
373 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
374 " --outfile-check-timer=NUM Seconds between outfile checks",
375 " -p, --separator=CHAR Separator char for hashlists and outfile",
376 " --show Show cracked passwords only",
377 " --left Show un-cracked passwords only",
378 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
379 " --remove Enable remove of hash once it is cracked",
380 " --remove-timer=NUM Update input hash file each NUM seconds",
381 " --potfile-disable Do not write potfile",
382 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
383 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
384 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
385 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
386 " --logfile-disable Disable the logfile",
387 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
388 "",
389 "* Resources:",
390 "",
391 " -b, --benchmark Run benchmark",
392 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
393 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
394 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
395 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
397 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
398 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
399 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
400 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
401 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
402 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
403 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
404 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
405 #ifdef HAVE_HWMON
406 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
407 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
408 #ifdef HAVE_ADL
409 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
410 #endif
411 #endif
412 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
413 "",
414 "* Distributed:",
415 "",
416 " -s, --skip=NUM Skip number of words",
417 " -l, --limit=NUM Limit number of words",
418 " --keyspace Show keyspace base:mod values and quit",
419 "",
420 "* Rules:",
421 "",
422 " -j, --rule-left=RULE Single rule applied to each word from left dict",
423 " -k, --rule-right=RULE Single rule applied to each word from right dict",
424 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
425 " -g, --generate-rules=NUM Generate NUM random rules",
426 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
427 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
428 " --generate-rules-seed=NUM Force RNG seed to NUM",
429 "",
430 "* Custom charsets:",
431 "",
432 " -1, --custom-charset1=CS User-defined charsets",
433 " -2, --custom-charset2=CS Example:",
434 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
435 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
436 "",
437 "* Increment:",
438 "",
439 " -i, --increment Enable increment mode",
440 " --increment-min=NUM Start incrementing at NUM",
441 " --increment-max=NUM Stop incrementing at NUM",
442 "",
443 "==========",
444 "References",
445 "==========",
446 "",
447 "* Workload Profile:",
448 "",
449 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
450 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
451 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
452 "",
453 "* OpenCL device-types:",
454 "",
455 " 1 = CPU devices",
456 " 2 = GPU devices",
457 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
458 "",
459 "* Outfile Formats:",
460 "",
461 " 1 = hash[:salt]",
462 " 2 = plain",
463 " 3 = hash[:salt]:plain",
464 " 4 = hex_plain",
465 " 5 = hash[:salt]:hex_plain",
466 " 6 = plain:hex_plain",
467 " 7 = hash[:salt]:plain:hex_plain",
468 " 8 = crackpos",
469 " 9 = hash[:salt]:crackpos",
470 " 10 = plain:crackpos",
471 " 11 = hash[:salt]:plain:crackpos",
472 " 12 = hex_plain:crackpos",
473 " 13 = hash[:salt]:hex_plain:crackpos",
474 " 14 = plain:hex_plain:crackpos",
475 " 15 = hash[:salt]:plain:hex_plain:crackpos",
476 "",
477 "* Debug mode output formats (for hybrid mode only, by using rules):",
478 "",
479 " 1 = save finding rule",
480 " 2 = save original word",
481 " 3 = save original word and finding rule",
482 " 4 = save original word, finding rule and modified plain",
483 "",
484 "* Built-in charsets:",
485 "",
486 " ?l = abcdefghijklmnopqrstuvwxyz",
487 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
488 " ?d = 0123456789",
489 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
490 " ?a = ?l?u?d?s",
491 " ?b = 0x00 - 0xff",
492 "",
493 "* Attack modes:",
494 "",
495 " 0 = Straight",
496 " 1 = Combination",
497 " 3 = Brute-force",
498 " 6 = Hybrid dict + mask",
499 " 7 = Hybrid mask + dict",
500 "",
501 "* Hash types:",
502 "",
503 "[[ Roll-your-own: Raw Hashes ]]",
504 "",
505 " 900 = MD4",
506 " 0 = MD5",
507 " 5100 = Half MD5",
508 " 100 = SHA1",
509 " 10800 = SHA-384",
510 " 1400 = SHA-256",
511 " 1700 = SHA-512",
512 " 5000 = SHA-3(Keccak)",
513 " 10100 = SipHash",
514 " 6000 = RipeMD160",
515 " 6100 = Whirlpool",
516 " 6900 = GOST R 34.11-94",
517 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
518 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
519 "",
520 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
521 "",
522 " 10 = md5($pass.$salt)",
523 " 20 = md5($salt.$pass)",
524 " 30 = md5(unicode($pass).$salt)",
525 " 40 = md5($salt.unicode($pass))",
526 " 3800 = md5($salt.$pass.$salt)",
527 " 3710 = md5($salt.md5($pass))",
528 " 2600 = md5(md5($pass)",
529 " 4300 = md5(strtoupper(md5($pass)))",
530 " 4400 = md5(sha1($pass))",
531 " 110 = sha1($pass.$salt)",
532 " 120 = sha1($salt.$pass)",
533 " 130 = sha1(unicode($pass).$salt)",
534 " 140 = sha1($salt.unicode($pass))",
535 " 4500 = sha1(sha1($pass)",
536 " 4700 = sha1(md5($pass))",
537 " 4900 = sha1($salt.$pass.$salt)",
538 " 1410 = sha256($pass.$salt)",
539 " 1420 = sha256($salt.$pass)",
540 " 1430 = sha256(unicode($pass).$salt)",
541 " 1440 = sha256($salt.unicode($pass))",
542 " 1710 = sha512($pass.$salt)",
543 " 1720 = sha512($salt.$pass)",
544 " 1730 = sha512(unicode($pass).$salt)",
545 " 1740 = sha512($salt.unicode($pass))",
546 "",
547 "[[ Roll-your-own: Authenticated Hashes ]]",
548 "",
549 " 50 = HMAC-MD5 (key = $pass)",
550 " 60 = HMAC-MD5 (key = $salt)",
551 " 150 = HMAC-SHA1 (key = $pass)",
552 " 160 = HMAC-SHA1 (key = $salt)",
553 " 1450 = HMAC-SHA256 (key = $pass)",
554 " 1460 = HMAC-SHA256 (key = $salt)",
555 " 1750 = HMAC-SHA512 (key = $pass)",
556 " 1760 = HMAC-SHA512 (key = $salt)",
557 "",
558 "[[ Generic KDF ]]",
559 "",
560 " 400 = phpass",
561 " 8900 = scrypt",
562 " 11900 = PBKDF2-HMAC-MD5",
563 " 12000 = PBKDF2-HMAC-SHA1",
564 " 10900 = PBKDF2-HMAC-SHA256",
565 " 12100 = PBKDF2-HMAC-SHA512",
566 "",
567 "[[ Network protocols, Challenge-Response ]]",
568 "",
569 " 23 = Skype",
570 " 2500 = WPA/WPA2",
571 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
572 " 5300 = IKE-PSK MD5",
573 " 5400 = IKE-PSK SHA1",
574 " 5500 = NetNTLMv1",
575 " 5500 = NetNTLMv1 + ESS",
576 " 5600 = NetNTLMv2",
577 " 7300 = IPMI2 RAKP HMAC-SHA1",
578 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
579 " 8300 = DNSSEC (NSEC3)",
580 " 10200 = Cram MD5",
581 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
582 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
583 " 11400 = SIP digest authentication (MD5)",
584 " 13100 = Kerberos 5 TGS-REP etype 23",
585 "",
586 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
587 "",
588 " 121 = SMF (Simple Machines Forum)",
589 " 400 = phpBB3",
590 " 2611 = vBulletin < v3.8.5",
591 " 2711 = vBulletin > v3.8.5",
592 " 2811 = MyBB",
593 " 2811 = IPB (Invison Power Board)",
594 " 8400 = WBB3 (Woltlab Burning Board)",
595 " 11 = Joomla < 2.5.18",
596 " 400 = Joomla > 2.5.18",
597 " 400 = Wordpress",
598 " 2612 = PHPS",
599 " 7900 = Drupal7",
600 " 21 = osCommerce",
601 " 21 = xt:Commerce",
602 " 11000 = PrestaShop",
603 " 124 = Django (SHA-1)",
604 " 10000 = Django (PBKDF2-SHA256)",
605 " 3711 = Mediawiki B type",
606 " 7600 = Redmine",
607 "",
608 "[[ Database Server ]]",
609 "",
610 " 12 = PostgreSQL",
611 " 131 = MSSQL(2000)",
612 " 132 = MSSQL(2005)",
613 " 1731 = MSSQL(2012)",
614 " 1731 = MSSQL(2014)",
615 " 200 = MySQL323",
616 " 300 = MySQL4.1/MySQL5",
617 " 3100 = Oracle H: Type (Oracle 7+)",
618 " 112 = Oracle S: Type (Oracle 11+)",
619 " 12300 = Oracle T: Type (Oracle 12+)",
620 " 8000 = Sybase ASE",
621 "",
622 "[[ HTTP, SMTP, LDAP Server ]]",
623 "",
624 " 141 = EPiServer 6.x < v4",
625 " 1441 = EPiServer 6.x > v4",
626 " 1600 = Apache $apr1$",
627 " 12600 = ColdFusion 10+",
628 " 1421 = hMailServer",
629 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
630 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
631 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
632 "",
633 "[[ Checksums ]]",
634 "",
635 " 11500 = CRC32",
636 "",
637 "[[ Operating-Systems ]]",
638 "",
639 " 3000 = LM",
640 " 1000 = NTLM",
641 " 1100 = Domain Cached Credentials (DCC), MS Cache",
642 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
643 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
644 " 1500 = descrypt, DES(Unix), Traditional DES",
645 " 12400 = BSDiCrypt, Extended DES",
646 " 500 = md5crypt $1$, MD5(Unix)",
647 " 3200 = bcrypt $2*$, Blowfish(Unix)",
648 " 7400 = sha256crypt $5$, SHA256(Unix)",
649 " 1800 = sha512crypt $6$, SHA512(Unix)",
650 " 122 = OSX v10.4",
651 " 122 = OSX v10.5",
652 " 122 = OSX v10.6",
653 " 1722 = OSX v10.7",
654 " 7100 = OSX v10.8",
655 " 7100 = OSX v10.9",
656 " 7100 = OSX v10.10",
657 " 6300 = AIX {smd5}",
658 " 6700 = AIX {ssha1}",
659 " 6400 = AIX {ssha256}",
660 " 6500 = AIX {ssha512}",
661 " 2400 = Cisco-PIX",
662 " 2410 = Cisco-ASA",
663 " 500 = Cisco-IOS $1$",
664 " 5700 = Cisco-IOS $4$",
665 " 9200 = Cisco-IOS $8$",
666 " 9300 = Cisco-IOS $9$",
667 " 22 = Juniper Netscreen/SSG (ScreenOS)",
668 " 501 = Juniper IVE",
669 " 5800 = Android PIN",
670 " 8100 = Citrix Netscaler",
671 " 8500 = RACF",
672 " 7200 = GRUB 2",
673 " 9900 = Radmin2",
674 "",
675 "[[ Enterprise Application Software (EAS) ]]",
676 "",
677 " 7700 = SAP CODVN B (BCODE)",
678 " 7800 = SAP CODVN F/G (PASSCODE)",
679 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
680 " 8600 = Lotus Notes/Domino 5",
681 " 8700 = Lotus Notes/Domino 6",
682 " 9100 = Lotus Notes/Domino 8",
683 " 133 = PeopleSoft",
684 "",
685 "[[ Archives ]]",
686 "",
687 " 11600 = 7-Zip",
688 " 12500 = RAR3-hp",
689 " 13000 = RAR5",
690 " 13200 = AxCrypt",
691 " 13300 = AxCrypt in memory SHA1",
692 "",
693 "[[ Full-Disk encryptions (FDE) ]]",
694 "",
695 " 62XY = TrueCrypt 5.0+",
696 " X = 1 = PBKDF2-HMAC-RipeMD160",
697 " X = 2 = PBKDF2-HMAC-SHA512",
698 " X = 3 = PBKDF2-HMAC-Whirlpool",
699 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
700 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
701 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
702 " Y = 3 = XTS 1536 bit (Ciphers: All)",
703 " 8800 = Android FDE < v4.3",
704 " 12900 = Android FDE (Samsung DEK)",
705 " 12200 = eCryptfs",
706 "",
707 "[[ Documents ]]",
708 "",
709 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
710 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
711 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
712 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
713 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
714 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
715 " 9400 = MS Office 2007",
716 " 9500 = MS Office 2010",
717 " 9600 = MS Office 2013",
718 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
719 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
720 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
721 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
722 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
723 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
724 "",
725 "[[ Password Managers ]]",
726 "",
727 " 9000 = Password Safe v2",
728 " 5200 = Password Safe v3",
729 " 6800 = Lastpass",
730 " 6600 = 1Password, agilekeychain",
731 " 8200 = 1Password, cloudkeychain",
732 " 11300 = Bitcoin/Litecoin wallet.dat",
733 " 12700 = Blockchain, My Wallet",
734 "",
735 NULL
736 };
737
738 /**
739 * oclHashcat specific functions
740 */
741
742 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
743 {
744 int exec_pos = (int) device_param->exec_pos - last_num_entries;
745
746 if (exec_pos < 0) exec_pos += EXEC_CACHE;
747
748 double exec_ms_sum = 0;
749
750 int exec_ms_cnt = 0;
751
752 for (int i = 0; i < last_num_entries; i++)
753 {
754 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
755
756 if (exec_ms)
757 {
758 exec_ms_sum += exec_ms;
759
760 exec_ms_cnt++;
761 }
762 }
763
764 if (exec_ms_cnt == 0) return 0;
765
766 return exec_ms_sum / exec_ms_cnt;
767 }
768
769 void status_display_automat ()
770 {
771 FILE *out = stdout;
772
773 fprintf (out, "STATUS\t%u\t", data.devices_status);
774
775 /**
776 * speed new
777 */
778
779 fprintf (out, "SPEED\t");
780
781 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
782 {
783 hc_device_param_t *device_param = &data.devices_param[device_id];
784
785 if (device_param->skipped) continue;
786
787 u64 speed_cnt = 0;
788 float speed_ms = 0;
789
790 for (int i = 0; i < SPEED_CACHE; i++)
791 {
792 float rec_ms;
793
794 hc_timer_get (device_param->speed_rec[i], rec_ms);
795
796 if (rec_ms > SPEED_MAXAGE) continue;
797
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 uint salts_left = data.salts_cnt - data.salts_done;
838
839 if (salts_left == 0) salts_left = 1;
840
841 u64 progress_total = data.words_cnt * salts_left;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 if (salts_left > 1)
850 {
851 // otherwise the final cracked status shows 0/XXX progress
852
853 if (data.salts_shown[salt_pos] == 1) continue;
854 }
855
856 all_done += data.words_progress_done[salt_pos];
857 all_rejected += data.words_progress_rejected[salt_pos];
858 all_restored += data.words_progress_restored[salt_pos];
859 }
860
861 u64 progress_cur = all_restored + all_done + all_rejected;
862 u64 progress_end = progress_total;
863
864 u64 progress_skip = 0;
865
866 if (data.skip)
867 {
868 progress_skip = MIN (data.skip, data.words_base) * salts_left;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
873 }
874
875 if (data.limit)
876 {
877 progress_end = MIN (data.limit, data.words_base) * salts_left;
878
879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
880 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
881 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
882 }
883
884 u64 progress_cur_relative_skip = progress_cur - progress_skip;
885 u64 progress_end_relative_skip = progress_end - progress_skip;
886
887 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
888
889 /**
890 * cracks
891 */
892
893 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
894 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
895
896 /**
897 * temperature
898 */
899
900 #ifdef HAVE_HWMON
901 if (data.gpu_temp_disable == 0)
902 {
903 fprintf (out, "TEMP\t");
904
905 hc_thread_mutex_lock (mux_adl);
906
907 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
908 {
909 hc_device_param_t *device_param = &data.devices_param[device_id];
910
911 if (device_param->skipped) continue;
912
913 int temp = hm_get_temperature_with_device_id (device_id);
914
915 fprintf (out, "%d\t", temp);
916 }
917
918 hc_thread_mutex_unlock (mux_adl);
919 }
920 #endif // HAVE_HWMON
921
922 /**
923 * flush
924 */
925
926 #ifdef _WIN
927 fputc ('\r', out);
928 fputc ('\n', out);
929 #endif
930
931 #ifdef _POSIX
932 fputc ('\n', out);
933 #endif
934
935 fflush (out);
936 }
937
938 void status_display ()
939 {
940 if (data.devices_status == STATUS_INIT) return;
941 if (data.devices_status == STATUS_STARTING) return;
942 if (data.devices_status == STATUS_BYPASS) return;
943
944 if (data.status_automat == 1)
945 {
946 status_display_automat ();
947
948 return;
949 }
950
951 char tmp_buf[1000] = { 0 };
952
953 uint tmp_len = 0;
954
955 log_info ("Session.Name...: %s", data.session);
956
957 char *status_type = strstatus (data.devices_status);
958
959 uint hash_mode = data.hash_mode;
960
961 char *hash_type = strhashtype (hash_mode); // not a bug
962
963 log_info ("Status.........: %s", status_type);
964
965 /**
966 * show rules
967 */
968
969 if (data.rp_files_cnt)
970 {
971 uint i;
972
973 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
974 {
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
976 }
977
978 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
979
980 log_info ("Rules.Type.....: %s", tmp_buf);
981
982 tmp_len = 0;
983 }
984
985 if (data.rp_gen)
986 {
987 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
988
989 if (data.rp_gen_seed)
990 {
991 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
992 }
993 }
994
995 /**
996 * show input
997 */
998
999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1000 {
1001 if (data.wordlist_mode == WL_MODE_FILE)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1004 }
1005 else if (data.wordlist_mode == WL_MODE_STDIN)
1006 {
1007 log_info ("Input.Mode.....: Pipe");
1008 }
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_COMBI)
1011 {
1012 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1013 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_BF)
1016 {
1017 char *mask = data.mask;
1018
1019 if (mask != NULL)
1020 {
1021 uint mask_len = data.css_cnt;
1022
1023 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1024
1025 if (mask_len > 0)
1026 {
1027 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1028 {
1029 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1030 {
1031 mask_len -= data.salts_buf[0].salt_len;
1032 }
1033 }
1034
1035 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1038 }
1039
1040 if (data.maskcnt > 1)
1041 {
1042 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1045 }
1046
1047 log_info ("Input.Mode.....: %s", tmp_buf);
1048 }
1049
1050 tmp_len = 0;
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1053 {
1054 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1055 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1058 {
1059 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1061 }
1062
1063 if (data.digests_cnt == 1)
1064 {
1065 if (data.hash_mode == 2500)
1066 {
1067 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1068
1069 uint pke[25] = { 0 };
1070
1071 char *pke_ptr = (char *) pke;
1072
1073 for (uint i = 0; i < 25; i++)
1074 {
1075 pke[i] = byte_swap_32 (wpa->pke[i]);
1076 }
1077
1078 char mac1[6] = { 0 };
1079 char mac2[6] = { 0 };
1080
1081 memcpy (mac1, pke_ptr + 23, 6);
1082 memcpy (mac2, pke_ptr + 29, 6);
1083
1084 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1085 (char *) data.salts_buf[0].salt_buf,
1086 mac1[0] & 0xff,
1087 mac1[1] & 0xff,
1088 mac1[2] & 0xff,
1089 mac1[3] & 0xff,
1090 mac1[4] & 0xff,
1091 mac1[5] & 0xff,
1092 mac2[0] & 0xff,
1093 mac2[1] & 0xff,
1094 mac2[2] & 0xff,
1095 mac2[3] & 0xff,
1096 mac2[4] & 0xff,
1097 mac2[5] & 0xff);
1098 }
1099 else if (data.hash_mode == 5200)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if (data.hash_mode == 9000)
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 else
1112 {
1113 char out_buf[4096] = { 0 };
1114
1115 ascii_digest (out_buf, 0, 0);
1116
1117 // limit length
1118 if (strlen (out_buf) > 40)
1119 {
1120 out_buf[41] = '.';
1121 out_buf[42] = '.';
1122 out_buf[43] = '.';
1123 out_buf[44] = 0;
1124 }
1125
1126 log_info ("Hash.Target....: %s", out_buf);
1127 }
1128 }
1129 else
1130 {
1131 if (data.hash_mode == 3000)
1132 {
1133 char out_buf1[4096] = { 0 };
1134 char out_buf2[4096] = { 0 };
1135
1136 ascii_digest (out_buf1, 0, 0);
1137 ascii_digest (out_buf2, 0, 1);
1138
1139 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1140 }
1141 else
1142 {
1143 log_info ("Hash.Target....: File (%s)", data.hashfile);
1144 }
1145 }
1146
1147 log_info ("Hash.Type......: %s", hash_type);
1148
1149 /**
1150 * speed new
1151 */
1152
1153 u64 speed_cnt[DEVICES_MAX] = { 0 };
1154 float speed_ms[DEVICES_MAX] = { 0 };
1155
1156 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1157 {
1158 hc_device_param_t *device_param = &data.devices_param[device_id];
1159
1160 if (device_param->skipped) continue;
1161
1162 // we need to clear values (set to 0) because in case the device does
1163 // not get new candidates it idles around but speed display would
1164 // show it as working.
1165 // if we instantly set it to 0 after reading it happens that the
1166 // speed can be shown as zero if the users refreshes too fast.
1167 // therefore, we add a timestamp when a stat was recorded and if its
1168 // too old we will not use it
1169
1170 speed_cnt[device_id] = 0;
1171 speed_ms[device_id] = 0;
1172
1173 for (int i = 0; i < SPEED_CACHE; i++)
1174 {
1175 float rec_ms;
1176
1177 hc_timer_get (device_param->speed_rec[i], rec_ms);
1178
1179 if (rec_ms > SPEED_MAXAGE) continue;
1180
1181 speed_cnt[device_id] += device_param->speed_cnt[i];
1182 speed_ms[device_id] += device_param->speed_ms[i];
1183 }
1184
1185 speed_cnt[device_id] /= SPEED_CACHE;
1186 speed_ms[device_id] /= SPEED_CACHE;
1187 }
1188
1189 float hashes_all_ms = 0;
1190
1191 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1192
1193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1194 {
1195 hc_device_param_t *device_param = &data.devices_param[device_id];
1196
1197 if (device_param->skipped) continue;
1198
1199 hashes_dev_ms[device_id] = 0;
1200
1201 if (speed_ms[device_id])
1202 {
1203 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1204
1205 hashes_all_ms += hashes_dev_ms[device_id];
1206 }
1207 }
1208
1209 /**
1210 * exec time
1211 */
1212
1213 double exec_all_ms[DEVICES_MAX] = { 0 };
1214
1215 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1216 {
1217 hc_device_param_t *device_param = &data.devices_param[device_id];
1218
1219 if (device_param->skipped) continue;
1220
1221 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1222
1223 exec_all_ms[device_id] = exec_ms_avg;
1224 }
1225
1226 /**
1227 * timers
1228 */
1229
1230 float ms_running = 0;
1231
1232 hc_timer_get (data.timer_running, ms_running);
1233
1234 float ms_paused = data.ms_paused;
1235
1236 if (data.devices_status == STATUS_PAUSED)
1237 {
1238 float ms_paused_tmp = 0;
1239
1240 hc_timer_get (data.timer_paused, ms_paused_tmp);
1241
1242 ms_paused += ms_paused_tmp;
1243 }
1244
1245 #ifdef WIN
1246
1247 __time64_t sec_run = ms_running / 1000;
1248
1249 #else
1250
1251 time_t sec_run = ms_running / 1000;
1252
1253 #endif
1254
1255 if (sec_run)
1256 {
1257 char display_run[32] = { 0 };
1258
1259 struct tm tm_run;
1260
1261 struct tm *tmp = NULL;
1262
1263 #ifdef WIN
1264
1265 tmp = _gmtime64 (&sec_run);
1266
1267 #else
1268
1269 tmp = gmtime (&sec_run);
1270
1271 #endif
1272
1273 if (tmp != NULL)
1274 {
1275 memset (&tm_run, 0, sizeof (tm_run));
1276
1277 memcpy (&tm_run, tmp, sizeof (tm_run));
1278
1279 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1280
1281 char *start = ctime (&data.proc_start);
1282
1283 size_t start_len = strlen (start);
1284
1285 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1286 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1287
1288 log_info ("Time.Started...: %s (%s)", start, display_run);
1289 }
1290 }
1291 else
1292 {
1293 log_info ("Time.Started...: 0 secs");
1294 }
1295
1296 /**
1297 * counters
1298 */
1299
1300 uint salts_left = data.salts_cnt - data.salts_done;
1301
1302 if (salts_left == 0) salts_left = 1;
1303
1304 u64 progress_total = data.words_cnt * salts_left;
1305
1306 u64 all_done = 0;
1307 u64 all_rejected = 0;
1308 u64 all_restored = 0;
1309
1310 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1311 {
1312 if (salts_left > 1)
1313 {
1314 // otherwise the final cracked status shows 0/XXX progress
1315
1316 if (data.salts_shown[salt_pos] == 1) continue;
1317 }
1318
1319 all_done += data.words_progress_done[salt_pos];
1320 all_rejected += data.words_progress_rejected[salt_pos];
1321 all_restored += data.words_progress_restored[salt_pos];
1322 }
1323
1324 u64 progress_cur = all_restored + all_done + all_rejected;
1325 u64 progress_end = progress_total;
1326
1327 u64 progress_skip = 0;
1328
1329 if (data.skip)
1330 {
1331 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1336 }
1337
1338 if (data.limit)
1339 {
1340 progress_end = MIN (data.limit, data.words_base) * salts_left;
1341
1342 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1344 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1345 }
1346
1347 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1348 u64 progress_end_relative_skip = progress_end - progress_skip;
1349
1350 float speed_ms_real = ms_running - ms_paused;
1351 u64 speed_plains_real = all_done;
1352
1353 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1354 {
1355 if (data.devices_status != STATUS_CRACKED)
1356 {
1357 u64 words_per_ms = 0;
1358
1359 if (speed_plains_real && speed_ms_real)
1360 {
1361 words_per_ms = speed_plains_real / speed_ms_real;
1362 }
1363
1364 #ifdef WIN
1365 __time64_t sec_etc = 0;
1366 #else
1367 time_t sec_etc = 0;
1368 #endif
1369
1370 if (words_per_ms)
1371 {
1372 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1373
1374 u64 ms_left = progress_left_relative_skip / words_per_ms;
1375
1376 sec_etc = ms_left / 1000;
1377 }
1378
1379 if (sec_etc == 0)
1380 {
1381 log_info ("Time.Estimated.: 0 secs");
1382 }
1383 else if ((u64) sec_etc > ETC_MAX)
1384 {
1385 log_info ("Time.Estimated.: > 10 Years");
1386 }
1387 else
1388 {
1389 char display_etc[32] = { 0 };
1390
1391 struct tm tm_etc;
1392
1393 struct tm *tmp = NULL;
1394
1395 #ifdef WIN
1396
1397 tmp = _gmtime64 (&sec_etc);
1398
1399 #else
1400
1401 tmp = gmtime (&sec_etc);
1402
1403 #endif
1404
1405 if (tmp != NULL)
1406 {
1407 memset (&tm_etc, 0, sizeof (tm_etc));
1408
1409 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1410
1411 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1412
1413 time_t now;
1414
1415 time (&now);
1416
1417 now += sec_etc;
1418
1419 char *etc = ctime (&now);
1420
1421 size_t etc_len = strlen (etc);
1422
1423 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1424 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1425
1426 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1427 }
1428 }
1429 }
1430 }
1431
1432 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1433 {
1434 hc_device_param_t *device_param = &data.devices_param[device_id];
1435
1436 if (device_param->skipped) continue;
1437
1438 char display_dev_cur[16] = { 0 };
1439
1440 strncpy (display_dev_cur, "0.00", 4);
1441
1442 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1443
1444 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1445 }
1446
1447 char display_all_cur[16] = { 0 };
1448
1449 strncpy (display_all_cur, "0.00", 4);
1450
1451 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1452
1453 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1454
1455 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1456 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1457
1458 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);
1459
1460 // crack-per-time
1461
1462 if (data.digests_cnt > 100)
1463 {
1464 time_t now = time (NULL);
1465
1466 int cpt_cur_min = 0;
1467 int cpt_cur_hour = 0;
1468 int cpt_cur_day = 0;
1469
1470 for (int i = 0; i < CPT_BUF; i++)
1471 {
1472 const uint cracked = data.cpt_buf[i].cracked;
1473 const time_t timestamp = data.cpt_buf[i].timestamp;
1474
1475 if ((timestamp + 60) > now)
1476 {
1477 cpt_cur_min += cracked;
1478 }
1479
1480 if ((timestamp + 3600) > now)
1481 {
1482 cpt_cur_hour += cracked;
1483 }
1484
1485 if ((timestamp + 86400) > now)
1486 {
1487 cpt_cur_day += cracked;
1488 }
1489 }
1490
1491 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1492 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1493 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1494
1495 if ((data.cpt_start + 86400) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_cur_day,
1501 cpt_avg_min,
1502 cpt_avg_hour,
1503 cpt_avg_day);
1504 }
1505 else if ((data.cpt_start + 3600) < now)
1506 {
1507 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1508 cpt_cur_min,
1509 cpt_cur_hour,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else if ((data.cpt_start + 60) < now)
1515 {
1516 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_cur_min,
1518 cpt_avg_min,
1519 cpt_avg_hour,
1520 cpt_avg_day);
1521 }
1522 else
1523 {
1524 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1525 cpt_avg_min,
1526 cpt_avg_hour,
1527 cpt_avg_day);
1528 }
1529 }
1530
1531 // Restore point
1532
1533 u64 restore_point = get_lowest_words_done ();
1534
1535 u64 restore_total = data.words_base;
1536
1537 float percent_restore = 0;
1538
1539 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1540
1541 if (progress_end_relative_skip)
1542 {
1543 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1544 {
1545 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1546 float percent_rejected = 0.0;
1547
1548 if (progress_cur)
1549 {
1550 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1551 }
1552
1553 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);
1554 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1555
1556 if (data.restore_disable == 0)
1557 {
1558 if (percent_finished != 1)
1559 {
1560 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1561 }
1562 }
1563 }
1564 }
1565 else
1566 {
1567 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1568 {
1569 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1570 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571
1572 if (data.restore_disable == 0)
1573 {
1574 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1575 }
1576 }
1577 else
1578 {
1579 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1580 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1581
1582 // --restore not allowed if stdin is used -- really? why?
1583
1584 //if (data.restore_disable == 0)
1585 //{
1586 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1587 //}
1588 }
1589 }
1590
1591 #ifdef HAVE_HWMON
1592 if (data.gpu_temp_disable == 0)
1593 {
1594 hc_thread_mutex_lock (mux_adl);
1595
1596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597 {
1598 hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600 if (device_param->skipped) continue;
1601
1602 #define HM_STR_BUF_SIZE 255
1603
1604 if (data.hm_device[device_id].fan_supported == 1)
1605 {
1606 char utilization[HM_STR_BUF_SIZE] = { 0 };
1607 char temperature[HM_STR_BUF_SIZE] = { 0 };
1608 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1609
1610 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1611 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1612
1613 if (device_param->vendor_id == VENDOR_ID_AMD)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617 else if (device_param->vendor_id == VENDOR_ID_NV)
1618 {
1619 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1620 }
1621
1622 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1623 }
1624 else
1625 {
1626 char utilization[HM_STR_BUF_SIZE] = { 0 };
1627 char temperature[HM_STR_BUF_SIZE] = { 0 };
1628
1629 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1630 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1631
1632 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1633 }
1634 }
1635
1636 hc_thread_mutex_unlock (mux_adl);
1637 }
1638 #endif // HAVE_HWMON
1639 }
1640
1641 static void status_benchmark ()
1642 {
1643 if (data.devices_status == STATUS_INIT) return;
1644 if (data.devices_status == STATUS_STARTING) return;
1645
1646 if (data.words_cnt == 0) return;
1647
1648 u64 speed_cnt[DEVICES_MAX] = { 0 };
1649 float speed_ms[DEVICES_MAX] = { 0 };
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 speed_cnt[device_id] = 0;
1658 speed_ms[device_id] = 0;
1659
1660 for (int i = 0; i < SPEED_CACHE; i++)
1661 {
1662 speed_cnt[device_id] += device_param->speed_cnt[i];
1663 speed_ms[device_id] += device_param->speed_ms[i];
1664 }
1665
1666 speed_cnt[device_id] /= SPEED_CACHE;
1667 speed_ms[device_id] /= SPEED_CACHE;
1668 }
1669
1670 float hashes_all_ms = 0;
1671
1672 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1673
1674 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1675 {
1676 hc_device_param_t *device_param = &data.devices_param[device_id];
1677
1678 if (device_param->skipped) continue;
1679
1680 hashes_dev_ms[device_id] = 0;
1681
1682 if (speed_ms[device_id])
1683 {
1684 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1685
1686 hashes_all_ms += hashes_dev_ms[device_id];
1687 }
1688 }
1689
1690 /**
1691 * exec time
1692 */
1693
1694 double exec_all_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1703
1704 exec_all_ms[device_id] = exec_ms_avg;
1705 }
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 char display_dev_cur[16] = { 0 };
1714
1715 strncpy (display_dev_cur, "0.00", 4);
1716
1717 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1718
1719 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1720 }
1721
1722 char display_all_cur[16] = { 0 };
1723
1724 strncpy (display_all_cur, "0.00", 4);
1725
1726 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1727
1728 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1729 }
1730
1731 /**
1732 * oclHashcat -only- functions
1733 */
1734
1735 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1736 {
1737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1738 {
1739 if (attack_kern == ATTACK_KERN_STRAIGHT)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_COMBI)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1743 else if (attack_kern == ATTACK_KERN_BF)
1744 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1745 }
1746 else
1747 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1748 }
1749
1750 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)
1751 {
1752 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1753 {
1754 if (attack_kern == ATTACK_KERN_STRAIGHT)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_COMBI)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 else if (attack_kern == ATTACK_KERN_BF)
1759 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 else
1762 {
1763 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 }
1765 }
1766
1767 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1768 {
1769 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1772 }
1773 else
1774 {
1775 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1776 }
1777 }
1778
1779 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)
1780 {
1781 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 else
1786 {
1787 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1788 }
1789 }
1790
1791 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1792 {
1793 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1794 }
1795
1796 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1799 }
1800
1801 static uint convert_from_hex (char *line_buf, const uint line_len)
1802 {
1803 if (line_len & 1) return (line_len); // not in hex
1804
1805 if (data.hex_wordlist == 1)
1806 {
1807 uint i;
1808 uint j;
1809
1810 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1811 {
1812 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1813 }
1814
1815 memset (line_buf + i, 0, line_len - i);
1816
1817 return (i);
1818 }
1819 else if (line_len >= 6) // $HEX[] = 6
1820 {
1821 if (line_buf[0] != '$') return (line_len);
1822 if (line_buf[1] != 'H') return (line_len);
1823 if (line_buf[2] != 'E') return (line_len);
1824 if (line_buf[3] != 'X') return (line_len);
1825 if (line_buf[4] != '[') return (line_len);
1826 if (line_buf[line_len - 1] != ']') return (line_len);
1827
1828 uint i;
1829 uint j;
1830
1831 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1832 {
1833 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1834 }
1835
1836 memset (line_buf + i, 0, line_len - i);
1837
1838 return (i);
1839 }
1840
1841 return (line_len);
1842 }
1843
1844 static void clear_prompt ()
1845 {
1846 fputc ('\r', stdout);
1847
1848 for (size_t i = 0; i < strlen (PROMPT); i++)
1849 {
1850 fputc (' ', stdout);
1851 }
1852
1853 fputc ('\r', stdout);
1854
1855 fflush (stdout);
1856 }
1857
1858 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1859 {
1860 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);
1861 }
1862
1863 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1864 {
1865 char *outfile = data.outfile;
1866 uint quiet = data.quiet;
1867 FILE *pot_fp = data.pot_fp;
1868 uint loopback = data.loopback;
1869 uint debug_mode = data.debug_mode;
1870 char *debug_file = data.debug_file;
1871
1872 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1873 int debug_rule_len = 0; // -1 error
1874 uint debug_plain_len = 0;
1875
1876 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1877
1878 // hash
1879
1880 char out_buf[4096] = { 0 };
1881
1882 ascii_digest (out_buf, salt_pos, digest_pos);
1883
1884 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1885
1886 // plain
1887
1888 plain_t plain;
1889
1890 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);
1891
1892 uint gidvid = plain.gidvid;
1893 uint il_pos = plain.il_pos;
1894
1895 u64 crackpos = device_param->words_off;
1896
1897 uint plain_buf[16] = { 0 };
1898
1899 u8 *plain_ptr = (u8 *) plain_buf;
1900 unsigned int plain_len = 0;
1901
1902 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1903 {
1904 u64 gidd = gidvid;
1905 u64 gidm = 0;
1906
1907 pw_t pw;
1908
1909 gidd_to_pw_t (device_param, gidd, &pw);
1910
1911 for (int i = 0, j = gidm; i < 16; i++, j++)
1912 {
1913 plain_buf[i] = pw.i[j];
1914 }
1915
1916 plain_len = pw.pw_len;
1917
1918 const uint off = device_param->innerloop_pos + il_pos;
1919
1920 if (debug_mode > 0)
1921 {
1922 debug_rule_len = 0;
1923
1924 // save rule
1925 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1928
1929 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1930 }
1931
1932 // save plain
1933 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1936
1937 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1938
1939 debug_plain_len = plain_len;
1940 }
1941 }
1942
1943 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1944
1945 crackpos += gidvid;
1946 crackpos *= data.kernel_rules_cnt;
1947 crackpos += device_param->innerloop_pos + il_pos;
1948
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_COMBI)
1952 {
1953 u64 gidd = gidvid;
1954 u64 gidm = 0;
1955
1956 pw_t pw;
1957
1958 gidd_to_pw_t (device_param, gidd, &pw);
1959
1960 for (int i = 0, j = gidm; i < 16; i++, j++)
1961 {
1962 plain_buf[i] = pw.i[j];
1963 }
1964
1965 plain_len = pw.pw_len;
1966
1967 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1968 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1969
1970 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1971 {
1972 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1973 }
1974 else
1975 {
1976 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1977
1978 memcpy (plain_ptr, comb_buf, comb_len);
1979 }
1980
1981 plain_len += comb_len;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992 else if (data.attack_mode == ATTACK_MODE_BF)
1993 {
1994 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1995 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1996
1997 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1998 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1999
2000 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2001 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2002
2003 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2004 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2005
2006 plain_len = data.css_cnt;
2007
2008 crackpos += gidvid;
2009 crackpos *= data.bfs_cnt;
2010 crackpos += device_param->innerloop_pos + il_pos;
2011 }
2012 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2013 {
2014 u64 gidd = gidvid;
2015 u64 gidm = 0;
2016
2017 pw_t pw;
2018
2019 gidd_to_pw_t (device_param, gidd, &pw);
2020
2021 for (int i = 0, j = gidm; i < 16; i++, j++)
2022 {
2023 plain_buf[i] = pw.i[j];
2024 }
2025
2026 plain_len = pw.pw_len;
2027
2028 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2029
2030 uint start = 0;
2031 uint stop = device_param->kernel_params_mp_buf32[4];
2032
2033 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2034
2035 plain_len += start + stop;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2047 {
2048 u64 gidd = gidvid;
2049 u64 gidm = 0;
2050
2051 pw_t pw;
2052
2053 gidd_to_pw_t (device_param, gidd, &pw);
2054
2055 for (int i = 0, j = gidm; i < 16; i++, j++)
2056 {
2057 plain_buf[i] = pw.i[j];
2058 }
2059
2060 plain_len = pw.pw_len;
2061
2062 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2063
2064 uint start = 0;
2065 uint stop = device_param->kernel_params_mp_buf32[4];
2066
2067 memmove (plain_ptr + stop, plain_ptr, plain_len);
2068
2069 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2070
2071 plain_len += start + stop;
2072
2073 crackpos += gidvid;
2074 crackpos *= data.combs_cnt;
2075 crackpos += device_param->innerloop_pos + il_pos;
2076
2077 if (data.pw_max != PW_DICTMAX1)
2078 {
2079 if (plain_len > data.pw_max) plain_len = data.pw_max;
2080 }
2081 }
2082
2083 if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2086 {
2087 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2088 {
2089 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2090 {
2091 plain_len = plain_len - data.salts_buf[0].salt_len;
2092 }
2093 }
2094
2095 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2096 {
2097 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2098 {
2099 plain_ptr[j] = plain_ptr[i];
2100 }
2101
2102 plain_len = plain_len / 2;
2103 }
2104 }
2105 }
2106
2107 // if enabled, update also the potfile
2108
2109 if (pot_fp)
2110 {
2111 lock_file (pot_fp);
2112
2113 fprintf (pot_fp, "%s:", out_buf);
2114
2115 format_plain (pot_fp, plain_ptr, plain_len, 1);
2116
2117 fputc ('\n', pot_fp);
2118
2119 fflush (pot_fp);
2120
2121 unlock_file (pot_fp);
2122 }
2123
2124 // outfile
2125
2126 FILE *out_fp = NULL;
2127
2128 if (outfile != NULL)
2129 {
2130 if ((out_fp = fopen (outfile, "ab")) == NULL)
2131 {
2132 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2133
2134 out_fp = stdout;
2135 }
2136 lock_file (out_fp);
2137 }
2138 else
2139 {
2140 out_fp = stdout;
2141
2142 if (quiet == 0) clear_prompt ();
2143 }
2144
2145 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2146
2147 if (outfile != NULL)
2148 {
2149 if (out_fp != stdout)
2150 {
2151 fclose (out_fp);
2152 }
2153 }
2154 else
2155 {
2156 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2157 {
2158 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2159 {
2160 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2161 if (quiet == 0) fflush (stdout);
2162 }
2163 }
2164 }
2165
2166 // loopback
2167
2168 if (loopback)
2169 {
2170 char *loopback_file = data.loopback_file;
2171
2172 FILE *fb_fp = NULL;
2173
2174 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2175 {
2176 lock_file (fb_fp);
2177
2178 format_plain (fb_fp, plain_ptr, plain_len, 1);
2179
2180 fputc ('\n', fb_fp);
2181
2182 fclose (fb_fp);
2183 }
2184 }
2185
2186 // (rule) debug mode
2187
2188 // the next check implies that:
2189 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2190 // - debug_mode > 0
2191
2192 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2193 {
2194 if (debug_rule_len < 0) debug_rule_len = 0;
2195
2196 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2197
2198 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2199
2200 if ((quiet == 0) && (debug_file == NULL))
2201 {
2202 fprintf (stdout, "%s", PROMPT);
2203 fflush (stdout);
2204 }
2205 }
2206 }
2207
2208 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2209 {
2210 salt_t *salt_buf = &data.salts_buf[salt_pos];
2211
2212 int found = 0;
2213
2214 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);
2215
2216 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2217
2218 if (found == 1)
2219 {
2220 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2221
2222 log_info_nn ("");
2223
2224 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);
2225
2226 uint cpt_cracked = 0;
2227
2228 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2229 {
2230 uint idx = salt_buf->digests_offset + digest_pos;
2231
2232 if (data.digests_shown_tmp[idx] == 0) continue;
2233
2234 if (data.digests_shown[idx] == 1) continue;
2235
2236 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2237 {
2238 data.digests_shown[idx] = 1;
2239
2240 data.digests_done++;
2241
2242 cpt_cracked++;
2243
2244 salt_buf->digests_done++;
2245
2246 if (salt_buf->digests_done == salt_buf->digests_cnt)
2247 {
2248 data.salts_shown[salt_pos] = 1;
2249
2250 data.salts_done++;
2251 }
2252 }
2253
2254 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2255
2256 check_hash (device_param, salt_pos, digest_pos);
2257 }
2258
2259 if (cpt_cracked > 0)
2260 {
2261 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2262 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2263
2264 data.cpt_pos++;
2265
2266 data.cpt_total += cpt_cracked;
2267
2268 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2269 }
2270
2271 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2272 {
2273 // we need to reset cracked state on the device
2274 // otherwise host thinks again and again the hash was cracked
2275 // and returns invalid password each time
2276
2277 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2278
2279 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);
2280 }
2281
2282 memset (device_param->result, 0, device_param->size_results);
2283
2284 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);
2285 }
2286 }
2287
2288 static void save_hash ()
2289 {
2290 char *hashfile = data.hashfile;
2291
2292 char new_hashfile[256] = { 0 };
2293 char old_hashfile[256] = { 0 };
2294
2295 snprintf (new_hashfile, 255, "%s.new", hashfile);
2296 snprintf (old_hashfile, 255, "%s.old", hashfile);
2297
2298 unlink (new_hashfile);
2299
2300 char separator = data.separator;
2301
2302 FILE *fp = fopen (new_hashfile, "wb");
2303
2304 if (fp == NULL)
2305 {
2306 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2307
2308 exit (-1);
2309 }
2310
2311 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2312 {
2313 if (data.salts_shown[salt_pos] == 1) continue;
2314
2315 salt_t *salt_buf = &data.salts_buf[salt_pos];
2316
2317 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2318 {
2319 uint idx = salt_buf->digests_offset + digest_pos;
2320
2321 if (data.digests_shown[idx] == 1) continue;
2322
2323 if (data.hash_mode != 2500)
2324 {
2325 char out_buf[4096] = { 0 };
2326
2327 if (data.username == 1)
2328 {
2329 user_t *user = data.hash_info[idx]->user;
2330
2331 uint i;
2332
2333 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2334
2335 fputc (separator, fp);
2336 }
2337
2338 ascii_digest (out_buf, salt_pos, digest_pos);
2339
2340 fputs (out_buf, fp);
2341
2342 log_out (fp, "");
2343 }
2344 else
2345 {
2346 hccap_t hccap;
2347
2348 to_hccap_t (&hccap, salt_pos, digest_pos);
2349
2350 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2351 }
2352 }
2353 }
2354
2355 fflush (fp);
2356
2357 fclose (fp);
2358
2359 unlink (old_hashfile);
2360
2361 if (rename (hashfile, old_hashfile) != 0)
2362 {
2363 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2364
2365 exit (-1);
2366 }
2367
2368 unlink (hashfile);
2369
2370 if (rename (new_hashfile, hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (old_hashfile);
2378 }
2379
2380 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2381 {
2382 // function called only in case kernel_power_all > words_left
2383
2384 float kernel_power_div = (float) (total_left) / kernel_power_all;
2385
2386 kernel_power_div += kernel_power_div / 100;
2387
2388 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2389
2390 while (kernel_power_new < total_left)
2391 {
2392 kernel_power_div += kernel_power_div / 100;
2393
2394 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2395 }
2396
2397 if (data.quiet == 0)
2398 {
2399 clear_prompt ();
2400
2401 log_info ("");
2402
2403 log_info ("INFO: approaching final keyspace, workload adjusted");
2404
2405 log_info ("");
2406
2407 fprintf (stdout, "%s", PROMPT);
2408
2409 fflush (stdout);
2410 }
2411
2412 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2413
2414 return kernel_power_div;
2415 }
2416
2417 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2418 {
2419 uint num_elements = num;
2420
2421 device_param->kernel_params_buf32[30] = data.combs_mode;
2422 device_param->kernel_params_buf32[31] = num;
2423
2424 uint kernel_threads = device_param->kernel_threads;
2425
2426 while (num_elements % kernel_threads) num_elements++;
2427
2428 cl_kernel kernel = NULL;
2429
2430 switch (kern_run)
2431 {
2432 case KERN_RUN_1: kernel = device_param->kernel1; break;
2433 case KERN_RUN_12: kernel = device_param->kernel12; break;
2434 case KERN_RUN_2: kernel = device_param->kernel2; break;
2435 case KERN_RUN_23: kernel = device_param->kernel23; break;
2436 case KERN_RUN_3: kernel = device_param->kernel3; break;
2437 }
2438
2439 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2440 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2441 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2442 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2443 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2444 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2445 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2446 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2447 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2448 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2449 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2450
2451 hc_timer_t timer;
2452
2453 hc_timer_set (&timer);
2454
2455 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2456 {
2457 const size_t global_work_size[3] = { num_elements, 32, 1 };
2458 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2459
2460 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2461 }
2462 else
2463 {
2464 size_t workgroup_size = 0;
2465
2466 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2467
2468 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2469
2470 const size_t global_work_size[3] = { num_elements, 1, 1 };
2471 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2472
2473 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2474 }
2475
2476 hc_clFlush (data.ocl, device_param->command_queue);
2477
2478 hc_clFinish (data.ocl, device_param->command_queue);
2479
2480 if (event_update)
2481 {
2482 float exec_time;
2483
2484 hc_timer_get (timer, exec_time);
2485
2486 uint exec_pos = device_param->exec_pos;
2487
2488 device_param->exec_ms[exec_pos] = exec_time;
2489
2490 exec_pos++;
2491
2492 if (exec_pos == EXEC_CACHE)
2493 {
2494 exec_pos = 0;
2495 }
2496
2497 device_param->exec_pos = exec_pos;
2498 }
2499 }
2500
2501 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2502 {
2503 uint num_elements = num;
2504
2505 switch (kern_run)
2506 {
2507 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2508 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2509 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2510 }
2511
2512 // causes problems with special threads like in bcrypt
2513 // const uint kernel_threads = device_param->kernel_threads;
2514
2515 uint kernel_threads = KERNEL_THREADS;
2516
2517 while (num_elements % kernel_threads) num_elements++;
2518
2519 cl_kernel kernel = NULL;
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2524 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2525 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2526 }
2527
2528 switch (kern_run)
2529 {
2530 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2536 break;
2537 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2543 break;
2544 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2545 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2546 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2547 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2548 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2549 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2550 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2551 break;
2552 }
2553
2554 size_t workgroup_size = 0;
2555 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2556 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2557
2558 const size_t global_work_size[3] = { num_elements, 1, 1 };
2559 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2562
2563 hc_clFlush (data.ocl, device_param->command_queue);
2564
2565 hc_clFinish (data.ocl, device_param->command_queue);
2566 }
2567
2568 static void run_kernel_tm (hc_device_param_t *device_param)
2569 {
2570 const uint num_elements = 1024; // fixed
2571
2572 uint kernel_threads = 32;
2573
2574 cl_kernel kernel = device_param->kernel_tm;
2575
2576 size_t workgroup_size = 0;
2577 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2578 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2579
2580 const size_t global_work_size[3] = { num_elements, 1, 1 };
2581 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2582
2583 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2584
2585 hc_clFlush (data.ocl, device_param->command_queue);
2586
2587 hc_clFinish (data.ocl, device_param->command_queue);
2588 }
2589
2590 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2591 {
2592 uint num_elements = num;
2593
2594 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2595 device_param->kernel_params_amp_buf32[6] = num_elements;
2596
2597 // causes problems with special threads like in bcrypt
2598 // const uint kernel_threads = device_param->kernel_threads;
2599
2600 uint kernel_threads = KERNEL_THREADS;
2601
2602 while (num_elements % kernel_threads) num_elements++;
2603
2604 cl_kernel kernel = device_param->kernel_amp;
2605
2606 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2607 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2608
2609 size_t workgroup_size = 0;
2610 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2611 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2612
2613 const size_t global_work_size[3] = { num_elements, 1, 1 };
2614 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2615
2616 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2617
2618 hc_clFlush (data.ocl, device_param->command_queue);
2619
2620 hc_clFinish (data.ocl, device_param->command_queue);
2621 }
2622
2623 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2624 {
2625 int rc = -1;
2626
2627 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2628 {
2629 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2630
2631 const cl_uchar zero = 0;
2632
2633 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2634 }
2635
2636 if (rc != 0)
2637 {
2638 // NOTE: clEnqueueFillBuffer () always fails with -59
2639 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2640 // How's that possible, OpenCL 1.2 support is advertised??
2641 // We need to workaround...
2642
2643 #define FILLSZ 0x100000
2644
2645 char *tmp = (char *) mymalloc (FILLSZ);
2646
2647 for (uint i = 0; i < size; i += FILLSZ)
2648 {
2649 const int left = size - i;
2650
2651 const int fillsz = MIN (FILLSZ, left);
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2654 }
2655
2656 myfree (tmp);
2657 }
2658 }
2659
2660 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)
2661 {
2662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2663 {
2664 if (attack_mode == ATTACK_MODE_BF)
2665 {
2666 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2667 {
2668 const uint size_tm = 32 * sizeof (bs_word_t);
2669
2670 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2671
2672 run_kernel_tm (device_param);
2673
2674 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);
2675 }
2676 }
2677
2678 if (highest_pw_len < 16)
2679 {
2680 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2681 }
2682 else if (highest_pw_len < 32)
2683 {
2684 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2685 }
2686 else
2687 {
2688 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2689 }
2690 }
2691 else
2692 {
2693 run_kernel_amp (device_param, pws_cnt);
2694
2695 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2696
2697 if (opts_type & OPTS_TYPE_HOOK12)
2698 {
2699 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2700 }
2701
2702 uint iter = salt_buf->salt_iter;
2703
2704 uint loop_step = device_param->kernel_loops;
2705
2706 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2707 {
2708 uint loop_left = iter - loop_pos;
2709
2710 loop_left = MIN (loop_left, loop_step);
2711
2712 device_param->kernel_params_buf32[25] = loop_pos;
2713 device_param->kernel_params_buf32[26] = loop_left;
2714
2715 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2716
2717 if (data.devices_status == STATUS_CRACKED) break;
2718 if (data.devices_status == STATUS_ABORTED) break;
2719 if (data.devices_status == STATUS_QUIT) break;
2720 }
2721
2722 if (opts_type & OPTS_TYPE_HOOK23)
2723 {
2724 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2725
2726 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);
2727
2728 // do something with data
2729
2730 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);
2731 }
2732
2733 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2734 }
2735 }
2736
2737 static int run_rule_engine (const int rule_len, const char *rule_buf)
2738 {
2739 if (rule_len == 0)
2740 {
2741 return 0;
2742 }
2743 else if (rule_len == 1)
2744 {
2745 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2746 }
2747
2748 return 1;
2749 }
2750
2751 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2752 {
2753 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2754 {
2755 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);
2756 }
2757 else if (data.attack_kern == ATTACK_KERN_COMBI)
2758 {
2759 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2760 {
2761 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2762 {
2763 for (u32 i = 0; i < pws_cnt; i++)
2764 {
2765 const u32 pw_len = device_param->pws_buf[i].pw_len;
2766
2767 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2768
2769 ptr[pw_len] = 0x01;
2770 }
2771 }
2772 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2773 {
2774 for (u32 i = 0; i < pws_cnt; i++)
2775 {
2776 const u32 pw_len = device_param->pws_buf[i].pw_len;
2777
2778 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2779
2780 ptr[pw_len] = 0x80;
2781 }
2782 }
2783 }
2784
2785 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);
2786 }
2787 else if (data.attack_kern == ATTACK_KERN_BF)
2788 {
2789 const u64 off = device_param->words_off;
2790
2791 device_param->kernel_params_mp_l_buf64[3] = off;
2792
2793 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2794 }
2795 }
2796
2797 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2798 {
2799 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2800
2801 device_param->kernel_params_buf32[26] = kernel_loops;
2802 device_param->kernel_params_buf32[27] = kernel_loops;
2803
2804 // init some fake words
2805
2806 for (u32 i = 0; i < kernel_power; i++)
2807 {
2808 device_param->pws_buf[i].i[0] = i;
2809 device_param->pws_buf[i].i[1] = 0x01234567;
2810 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2811 }
2812
2813 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2814
2815 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2816 {
2817 run_kernel_amp (device_param, kernel_power);
2818 }
2819
2820 // caching run
2821
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2829 }
2830
2831 // now user repeats
2832
2833 for (int i = 0; i < repeat; i++)
2834 {
2835 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2836 {
2837 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2838 }
2839 else
2840 {
2841 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2842 }
2843 }
2844
2845 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2846
2847 // reset fake words
2848
2849 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2850
2851 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2852 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2853
2854 return exec_ms_prev;
2855 }
2856
2857 static void autotune (hc_device_param_t *device_param)
2858 {
2859 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2860
2861 const u32 kernel_accel_min = device_param->kernel_accel_min;
2862 const u32 kernel_accel_max = device_param->kernel_accel_max;
2863
2864 const u32 kernel_loops_min = device_param->kernel_loops_min;
2865 const u32 kernel_loops_max = device_param->kernel_loops_max;
2866
2867 u32 kernel_accel = kernel_accel_min;
2868 u32 kernel_loops = kernel_loops_min;
2869
2870 // steps
2871
2872 #define STEPS_CNT 10
2873
2874 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2875 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2876
2877 u32 steps_accel[STEPS_ACCEL_CNT];
2878 u32 steps_loops[STEPS_LOOPS_CNT];
2879
2880 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2881 {
2882 steps_accel[i] = 1 << i;
2883 }
2884
2885 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2886 {
2887 steps_loops[i] = 1 << i;
2888 }
2889
2890 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2891 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2892
2893 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2894 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2895
2896 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2897 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2898
2899 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2900
2901 u32 kernel_loops_tmp;
2902
2903 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2904 {
2905 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2906
2907 if (exec_ms < target_ms) break;
2908 }
2909
2910 // kernel-accel
2911
2912 if (kernel_accel_min < kernel_accel_max)
2913 {
2914 double e_best = 0;
2915
2916 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2917 {
2918 const u32 kernel_accel_try = steps_accel[i];
2919
2920 if (kernel_accel_try < kernel_accel_min) continue;
2921 if (kernel_accel_try > kernel_accel_max) break;
2922
2923 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2924
2925 if (exec_ms > target_ms) break;
2926
2927 const double e = kernel_accel_try / exec_ms;
2928
2929 if (e > e_best)
2930 {
2931 kernel_accel = kernel_accel_try;
2932
2933 e_best = e;
2934 }
2935 }
2936 }
2937
2938 // kernel-loops final
2939
2940 if (kernel_loops_min < kernel_loops_max)
2941 {
2942 double e_best = 0;
2943
2944 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2945 {
2946 const u32 kernel_loops_try = steps_loops[i];
2947
2948 if (kernel_loops_try < kernel_loops_min) continue;
2949 if (kernel_loops_try > kernel_loops_max) break;
2950
2951 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2952
2953 if (exec_ms > target_ms) break;
2954
2955 const double e = kernel_loops_try / exec_ms;
2956
2957 if (e > e_best)
2958 {
2959 kernel_loops = kernel_loops_try;
2960
2961 e_best = e;
2962 }
2963 }
2964 }
2965
2966 // final balance
2967
2968 u32 kernel_accel_best = kernel_accel;
2969 u32 kernel_loops_best = kernel_loops;
2970
2971 u32 exec_best = -1;
2972
2973 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2974 {
2975 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2976
2977 exec_best = exec_ms;
2978 }
2979
2980 // reset
2981
2982 if (kernel_accel_min < kernel_accel_max)
2983 {
2984 u32 kernel_accel_try = kernel_accel;
2985 u32 kernel_loops_try = kernel_loops;
2986
2987 for (int i = 0; i < 2; i++)
2988 {
2989 kernel_accel_try >>= 1;
2990 kernel_loops_try <<= 1;
2991
2992 if (kernel_accel_try < kernel_accel_min) break;
2993 if (kernel_loops_try > kernel_loops_max) break;
2994
2995 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2996
2997 if (exec_ms < exec_best)
2998 {
2999 kernel_accel_best = kernel_accel_try;
3000 kernel_loops_best = kernel_loops_try;
3001
3002 exec_best = exec_ms;
3003 }
3004 }
3005 }
3006
3007 // reset
3008
3009 if (kernel_loops_min < kernel_loops_max)
3010 {
3011 u32 kernel_accel_try = kernel_accel;
3012 u32 kernel_loops_try = kernel_loops;
3013
3014 for (int i = 0; i < 2; i++)
3015 {
3016 kernel_accel_try <<= 1;
3017 kernel_loops_try >>= 1;
3018
3019 if (kernel_accel_try > kernel_accel_max) break;
3020 if (kernel_loops_try < kernel_loops_min) break;
3021
3022 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3023
3024 if (exec_ms < exec_best)
3025 {
3026 kernel_accel_best = kernel_accel_try;
3027 kernel_loops_best = kernel_loops_try;
3028
3029 exec_best = exec_ms;
3030 }
3031 }
3032 }
3033
3034 // reset timer
3035
3036 device_param->exec_pos = 0;
3037
3038 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3039
3040 // store
3041
3042 kernel_accel = kernel_accel_best;
3043 kernel_loops = kernel_loops_best;
3044
3045 device_param->kernel_accel = kernel_accel;
3046 device_param->kernel_loops = kernel_loops;
3047
3048 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3049
3050 device_param->kernel_power = kernel_power;
3051
3052 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3053 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3054 if (data.quiet == 0) log_info ("");
3055 }
3056
3057 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3058 {
3059 // init speed timer
3060
3061 uint speed_pos = device_param->speed_pos;
3062
3063 #ifdef _POSIX
3064 if (device_param->timer_speed.tv_sec == 0)
3065 {
3066 hc_timer_set (&device_param->timer_speed);
3067 }
3068 #endif
3069
3070 #ifdef _WIN
3071 if (device_param->timer_speed.QuadPart == 0)
3072 {
3073 hc_timer_set (&device_param->timer_speed);
3074 }
3075 #endif
3076
3077 // find higest password length, this is for optimization stuff
3078
3079 uint highest_pw_len = 0;
3080
3081 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3082 {
3083 }
3084 else if (data.attack_kern == ATTACK_KERN_COMBI)
3085 {
3086 }
3087 else if (data.attack_kern == ATTACK_KERN_BF)
3088 {
3089 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3090 + device_param->kernel_params_mp_l_buf32[5];
3091 }
3092
3093 // iteration type
3094
3095 uint innerloop_step = 0;
3096 uint innerloop_cnt = 0;
3097
3098 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3099 else innerloop_step = 1;
3100
3101 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3102 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3103 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3104
3105 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3106
3107 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3108 {
3109 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3110
3111 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3112
3113 if (data.devices_status == STATUS_CRACKED) break;
3114 if (data.devices_status == STATUS_ABORTED) break;
3115 if (data.devices_status == STATUS_QUIT) break;
3116 if (data.devices_status == STATUS_BYPASS) break;
3117
3118 if (data.salts_shown[salt_pos] == 1) continue;
3119
3120 salt_t *salt_buf = &data.salts_buf[salt_pos];
3121
3122 device_param->kernel_params_buf32[24] = salt_pos;
3123 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3124 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3125
3126 FILE *combs_fp = device_param->combs_fp;
3127
3128 if (data.attack_mode == ATTACK_MODE_COMBI)
3129 {
3130 rewind (combs_fp);
3131 }
3132
3133 // innerloops
3134
3135 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3136 {
3137 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3138
3139 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3140
3141 if (data.devices_status == STATUS_CRACKED) break;
3142 if (data.devices_status == STATUS_ABORTED) break;
3143 if (data.devices_status == STATUS_QUIT) break;
3144 if (data.devices_status == STATUS_BYPASS) break;
3145
3146 uint innerloop_left = innerloop_cnt - innerloop_pos;
3147
3148 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3149
3150 device_param->innerloop_pos = innerloop_pos;
3151 device_param->innerloop_left = innerloop_left;
3152
3153 device_param->kernel_params_buf32[27] = innerloop_left;
3154
3155 // i think we can get rid of this
3156 if (innerloop_left == 0)
3157 {
3158 puts ("bug, how should this happen????\n");
3159
3160 continue;
3161 }
3162
3163 // initialize amplifiers
3164
3165 if (data.attack_mode == ATTACK_MODE_COMBI)
3166 {
3167 char line_buf[BUFSIZ] = { 0 };
3168
3169 uint i = 0;
3170
3171 while (i < innerloop_left)
3172 {
3173 if (feof (combs_fp)) break;
3174
3175 int line_len = fgetl (combs_fp, line_buf);
3176
3177 if (line_len >= PW_MAX1) continue;
3178
3179 line_len = convert_from_hex (line_buf, line_len);
3180
3181 char *line_buf_new = line_buf;
3182
3183 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3184 {
3185 char rule_buf_out[BLOCK_SIZE] = { 0 };
3186
3187 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3188
3189 if (rule_len_out < 0)
3190 {
3191 data.words_progress_rejected[salt_pos] += pws_cnt;
3192
3193 continue;
3194 }
3195
3196 line_len = rule_len_out;
3197
3198 line_buf_new = rule_buf_out;
3199 }
3200
3201 line_len = MIN (line_len, PW_DICTMAX);
3202
3203 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3204
3205 memcpy (ptr, line_buf_new, line_len);
3206
3207 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3208
3209 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3210 {
3211 uppercase (ptr, line_len);
3212 }
3213
3214 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3215 {
3216 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3217 {
3218 ptr[line_len] = 0x80;
3219 }
3220
3221 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3222 {
3223 ptr[line_len] = 0x01;
3224 }
3225 }
3226
3227 device_param->combs_buf[i].pw_len = line_len;
3228
3229 i++;
3230 }
3231
3232 for (uint j = i; j < innerloop_left; j++)
3233 {
3234 device_param->combs_buf[j].i[0] = 0;
3235 device_param->combs_buf[j].i[1] = 0;
3236 device_param->combs_buf[j].i[2] = 0;
3237 device_param->combs_buf[j].i[3] = 0;
3238 device_param->combs_buf[j].i[4] = 0;
3239 device_param->combs_buf[j].i[5] = 0;
3240 device_param->combs_buf[j].i[6] = 0;
3241 device_param->combs_buf[j].i[7] = 0;
3242
3243 device_param->combs_buf[j].pw_len = 0;
3244 }
3245
3246 innerloop_left = i;
3247 }
3248 else if (data.attack_mode == ATTACK_MODE_BF)
3249 {
3250 u64 off = innerloop_pos;
3251
3252 device_param->kernel_params_mp_r_buf64[3] = off;
3253
3254 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3255 }
3256 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3257 {
3258 u64 off = innerloop_pos;
3259
3260 device_param->kernel_params_mp_buf64[3] = off;
3261
3262 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3265 {
3266 u64 off = innerloop_pos;
3267
3268 device_param->kernel_params_mp_buf64[3] = off;
3269
3270 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3271 }
3272
3273 // copy amplifiers
3274
3275 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3276 {
3277 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);
3278 }
3279 else if (data.attack_mode == ATTACK_MODE_COMBI)
3280 {
3281 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);
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_BF)
3284 {
3285 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);
3286 }
3287 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3288 {
3289 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);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3292 {
3293 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);
3294 }
3295
3296 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3297
3298 if (data.benchmark == 1)
3299 {
3300 for (u32 i = 0; i < data.benchmark_repeats; i++)
3301 {
3302 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3303 }
3304 }
3305
3306 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3307
3308 if (data.devices_status == STATUS_CRACKED) break;
3309 if (data.devices_status == STATUS_ABORTED) break;
3310 if (data.devices_status == STATUS_QUIT) break;
3311
3312 /**
3313 * result
3314 */
3315
3316 hc_thread_mutex_lock (mux_display);
3317
3318 check_cracked (device_param, salt_pos);
3319
3320 hc_thread_mutex_unlock (mux_display);
3321
3322 /**
3323 * progress
3324 */
3325
3326 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3327
3328 if (data.benchmark == 1)
3329 {
3330 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3331 }
3332
3333 hc_thread_mutex_lock (mux_counter);
3334
3335 data.words_progress_done[salt_pos] += perf_sum_all;
3336
3337 hc_thread_mutex_unlock (mux_counter);
3338
3339 /**
3340 * speed
3341 */
3342
3343 float speed_ms;
3344
3345 hc_timer_get (device_param->timer_speed, speed_ms);
3346
3347 hc_timer_set (&device_param->timer_speed);
3348
3349 hc_thread_mutex_lock (mux_display);
3350
3351 device_param->speed_cnt[speed_pos] = perf_sum_all;
3352
3353 device_param->speed_ms[speed_pos] = speed_ms;
3354
3355 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3356
3357 hc_thread_mutex_unlock (mux_display);
3358
3359 speed_pos++;
3360
3361 if (speed_pos == SPEED_CACHE)
3362 {
3363 speed_pos = 0;
3364 }
3365
3366 /**
3367 * benchmark
3368 */
3369
3370 if (data.benchmark == 1) break;
3371 }
3372 }
3373
3374 device_param->speed_pos = speed_pos;
3375 }
3376
3377 static void load_segment (wl_data_t *wl_data, FILE *fd)
3378 {
3379 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3380
3381 wl_data->pos = 0;
3382
3383 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3384
3385 wl_data->buf[wl_data->cnt] = 0;
3386
3387 if (wl_data->cnt == 0) return;
3388
3389 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3390
3391 while (!feof (fd))
3392 {
3393 if (wl_data->cnt == wl_data->avail)
3394 {
3395 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3396
3397 wl_data->avail += wl_data->incr;
3398 }
3399
3400 const int c = fgetc (fd);
3401
3402 if (c == EOF) break;
3403
3404 wl_data->buf[wl_data->cnt] = (char) c;
3405
3406 wl_data->cnt++;
3407
3408 if (c == '\n') break;
3409 }
3410
3411 // ensure stream ends with a newline
3412
3413 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3414 {
3415 wl_data->cnt++;
3416
3417 wl_data->buf[wl_data->cnt - 1] = '\n';
3418 }
3419
3420 return;
3421 }
3422
3423 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3424 {
3425 char *ptr = buf;
3426
3427 for (u32 i = 0; i < sz; i++, ptr++)
3428 {
3429 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3430
3431 if (i == 7)
3432 {
3433 *off = i;
3434 *len = i;
3435
3436 return;
3437 }
3438
3439 if (*ptr != '\n') continue;
3440
3441 *off = i + 1;
3442
3443 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3444
3445 *len = i;
3446
3447 return;
3448 }
3449
3450 *off = sz;
3451 *len = sz;
3452 }
3453
3454 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3455 {
3456 char *ptr = buf;
3457
3458 for (u32 i = 0; i < sz; i++, ptr++)
3459 {
3460 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3461
3462 if (*ptr != '\n') continue;
3463
3464 *off = i + 1;
3465
3466 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3467
3468 *len = i;
3469
3470 return;
3471 }
3472
3473 *off = sz;
3474 *len = sz;
3475 }
3476
3477 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3478 {
3479 char *ptr = buf;
3480
3481 for (u32 i = 0; i < sz; i++, ptr++)
3482 {
3483 if (*ptr != '\n') continue;
3484
3485 *off = i + 1;
3486
3487 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3488
3489 *len = i;
3490
3491 return;
3492 }
3493
3494 *off = sz;
3495 *len = sz;
3496 }
3497
3498 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3499 {
3500 while (wl_data->pos < wl_data->cnt)
3501 {
3502 uint off;
3503 uint len;
3504
3505 char *ptr = wl_data->buf + wl_data->pos;
3506
3507 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3508
3509 wl_data->pos += off;
3510
3511 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3512 {
3513 char rule_buf_out[BLOCK_SIZE] = { 0 };
3514
3515 int rule_len_out = -1;
3516
3517 if (len < BLOCK_SIZE)
3518 {
3519 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3520 }
3521
3522 if (rule_len_out < 0)
3523 {
3524 continue;
3525 }
3526
3527 if (rule_len_out > PW_MAX)
3528 {
3529 continue;
3530 }
3531 }
3532 else
3533 {
3534 if (len > PW_MAX)
3535 {
3536 continue;
3537 }
3538 }
3539
3540 *out_buf = ptr;
3541 *out_len = len;
3542
3543 return;
3544 }
3545
3546 if (feof (fd))
3547 {
3548 fprintf (stderr, "BUG feof()!!\n");
3549
3550 return;
3551 }
3552
3553 load_segment (wl_data, fd);
3554
3555 get_next_word (wl_data, fd, out_buf, out_len);
3556 }
3557
3558 #ifdef _POSIX
3559 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3560 #endif
3561
3562 #ifdef _WIN
3563 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3564 #endif
3565 {
3566 hc_signal (NULL);
3567
3568 dictstat_t d;
3569
3570 d.cnt = 0;
3571
3572 #ifdef _POSIX
3573 fstat (fileno (fd), &d.stat);
3574 #endif
3575
3576 #ifdef _WIN
3577 _fstat64 (fileno (fd), &d.stat);
3578 #endif
3579
3580 d.stat.st_mode = 0;
3581 d.stat.st_nlink = 0;
3582 d.stat.st_uid = 0;
3583 d.stat.st_gid = 0;
3584 d.stat.st_rdev = 0;
3585 d.stat.st_atime = 0;
3586
3587 #ifdef _POSIX
3588 d.stat.st_blksize = 0;
3589 d.stat.st_blocks = 0;
3590 #endif
3591
3592 if (d.stat.st_size == 0) return 0;
3593
3594 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3595
3596 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3597 {
3598 if (d_cache)
3599 {
3600 u64 cnt = d_cache->cnt;
3601
3602 u64 keyspace = cnt;
3603
3604 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3605 {
3606 keyspace *= data.kernel_rules_cnt;
3607 }
3608 else if (data.attack_kern == ATTACK_KERN_COMBI)
3609 {
3610 keyspace *= data.combs_cnt;
3611 }
3612
3613 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);
3614 if (data.quiet == 0) log_info ("");
3615
3616 hc_signal (sigHandler_default);
3617
3618 return (keyspace);
3619 }
3620 }
3621
3622 time_t now = 0;
3623 time_t prev = 0;
3624
3625 u64 comp = 0;
3626 u64 cnt = 0;
3627 u64 cnt2 = 0;
3628
3629 while (!feof (fd))
3630 {
3631 load_segment (wl_data, fd);
3632
3633 comp += wl_data->cnt;
3634
3635 u32 i = 0;
3636
3637 while (i < wl_data->cnt)
3638 {
3639 u32 len;
3640 u32 off;
3641
3642 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3643
3644 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3645 {
3646 char rule_buf_out[BLOCK_SIZE] = { 0 };
3647
3648 int rule_len_out = -1;
3649
3650 if (len < BLOCK_SIZE)
3651 {
3652 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3653 }
3654
3655 if (rule_len_out < 0)
3656 {
3657 len = PW_MAX1;
3658 }
3659 else
3660 {
3661 len = rule_len_out;
3662 }
3663 }
3664
3665 if (len < PW_MAX1)
3666 {
3667 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3668 {
3669 cnt += data.kernel_rules_cnt;
3670 }
3671 else if (data.attack_kern == ATTACK_KERN_COMBI)
3672 {
3673 cnt += data.combs_cnt;
3674 }
3675
3676 d.cnt++;
3677 }
3678
3679 i += off;
3680
3681 cnt2++;
3682 }
3683
3684 time (&now);
3685
3686 if ((now - prev) == 0) continue;
3687
3688 float percent = (float) comp / (float) d.stat.st_size;
3689
3690 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);
3691
3692 time (&prev);
3693 }
3694
3695 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);
3696 if (data.quiet == 0) log_info ("");
3697
3698 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3699
3700 hc_signal (sigHandler_default);
3701
3702 return (cnt);
3703 }
3704
3705 static void *thread_monitor (void *p)
3706 {
3707 uint runtime_check = 0;
3708 uint remove_check = 0;
3709 uint status_check = 0;
3710 uint restore_check = 0;
3711
3712 uint restore_left = data.restore_timer;
3713 uint remove_left = data.remove_timer;
3714 uint status_left = data.status_timer;
3715
3716 #ifdef HAVE_HWMON
3717 uint hwmon_check = 0;
3718
3719 // these variables are mainly used for fan control (AMD only)
3720
3721 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3722
3723 // temperature controller "loopback" values
3724
3725 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3726 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3727
3728 #ifdef HAVE_ADL
3729 int temp_threshold = 1; // degrees celcius
3730
3731 int fan_speed_min = 15; // in percentage
3732 int fan_speed_max = 100;
3733 #endif // HAVE_ADL
3734
3735 time_t last_temp_check_time;
3736 #endif // HAVE_HWMON
3737
3738 uint sleep_time = 1;
3739
3740 if (data.runtime)
3741 {
3742 runtime_check = 1;
3743 }
3744
3745 if (data.restore_timer)
3746 {
3747 restore_check = 1;
3748 }
3749
3750 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3751 {
3752 remove_check = 1;
3753 }
3754
3755 if (data.status == 1)
3756 {
3757 status_check = 1;
3758 }
3759
3760 #ifdef HAVE_HWMON
3761 if (data.gpu_temp_disable == 0)
3762 {
3763 time (&last_temp_check_time);
3764
3765 hwmon_check = 1;
3766 }
3767 #endif
3768
3769 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3770 {
3771 #ifdef HAVE_HWMON
3772 if (hwmon_check == 0)
3773 #endif
3774 return (p);
3775 }
3776
3777 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3778 {
3779 hc_sleep (sleep_time);
3780
3781 if (data.devices_status != STATUS_RUNNING) continue;
3782
3783 #ifdef HAVE_HWMON
3784 if (hwmon_check == 1)
3785 {
3786 hc_thread_mutex_lock (mux_adl);
3787
3788 time_t temp_check_time;
3789
3790 time (&temp_check_time);
3791
3792 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3793
3794 if (Ta == 0) Ta = 1;
3795
3796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3797 {
3798 hc_device_param_t *device_param = &data.devices_param[device_id];
3799
3800 if (device_param->skipped) continue;
3801
3802 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3803
3804 const int temperature = hm_get_temperature_with_device_id (device_id);
3805
3806 if (temperature > (int) data.gpu_temp_abort)
3807 {
3808 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3809
3810 if (data.devices_status != STATUS_QUIT) myabort ();
3811
3812 break;
3813 }
3814
3815 #ifdef HAVE_ADL
3816 const int gpu_temp_retain = data.gpu_temp_retain;
3817
3818 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3819 {
3820 if (data.hm_device[device_id].fan_supported == 1)
3821 {
3822 int temp_cur = temperature;
3823
3824 int temp_diff_new = gpu_temp_retain - temp_cur;
3825
3826 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3827
3828 // calculate Ta value (time difference in seconds between the last check and this check)
3829
3830 last_temp_check_time = temp_check_time;
3831
3832 float Kp = 1.8;
3833 float Ki = 0.005;
3834 float Kd = 6;
3835
3836 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3837
3838 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);
3839
3840 if (abs (fan_diff_required) >= temp_threshold)
3841 {
3842 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3843
3844 int fan_speed_level = fan_speed_cur;
3845
3846 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3847
3848 int fan_speed_new = fan_speed_level - fan_diff_required;
3849
3850 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3851 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3852
3853 if (fan_speed_new != fan_speed_cur)
3854 {
3855 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3856 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3857
3858 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3859 {
3860 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3861
3862 fan_speed_chgd[device_id] = 1;
3863 }
3864
3865 temp_diff_old[device_id] = temp_diff_new;
3866 }
3867 }
3868 }
3869 }
3870 #endif // HAVE_ADL
3871 }
3872
3873 hc_thread_mutex_unlock (mux_adl);
3874 }
3875 #endif // HAVE_HWMON
3876
3877 if (restore_check == 1)
3878 {
3879 restore_left--;
3880
3881 if (restore_left == 0)
3882 {
3883 if (data.restore_disable == 0) cycle_restore ();
3884
3885 restore_left = data.restore_timer;
3886 }
3887 }
3888
3889 if ((runtime_check == 1) && (data.runtime_start > 0))
3890 {
3891 time_t runtime_cur;
3892
3893 time (&runtime_cur);
3894
3895 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3896
3897 if (runtime_left <= 0)
3898 {
3899 if (data.benchmark == 0)
3900 {
3901 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3902 }
3903
3904 if (data.devices_status != STATUS_QUIT) myabort ();
3905 }
3906 }
3907
3908 if (remove_check == 1)
3909 {
3910 remove_left--;
3911
3912 if (remove_left == 0)
3913 {
3914 if (data.digests_saved != data.digests_done)
3915 {
3916 data.digests_saved = data.digests_done;
3917
3918 save_hash ();
3919 }
3920
3921 remove_left = data.remove_timer;
3922 }
3923 }
3924
3925 if (status_check == 1)
3926 {
3927 status_left--;
3928
3929 if (status_left == 0)
3930 {
3931 hc_thread_mutex_lock (mux_display);
3932
3933 if (data.quiet == 0) clear_prompt ();
3934
3935 if (data.quiet == 0) log_info ("");
3936
3937 status_display ();
3938
3939 if (data.quiet == 0) log_info ("");
3940
3941 hc_thread_mutex_unlock (mux_display);
3942
3943 status_left = data.status_timer;
3944 }
3945 }
3946 }
3947
3948 #ifdef HAVE_HWMON
3949 myfree (fan_speed_chgd);
3950
3951 myfree (temp_diff_old);
3952 myfree (temp_diff_sum);
3953 #endif
3954
3955 p = NULL;
3956
3957 return (p);
3958 }
3959
3960 static void *thread_outfile_remove (void *p)
3961 {
3962 // some hash-dependent constants
3963 char *outfile_dir = data.outfile_check_directory;
3964 uint dgst_size = data.dgst_size;
3965 uint isSalted = data.isSalted;
3966 uint esalt_size = data.esalt_size;
3967 uint hash_mode = data.hash_mode;
3968
3969 uint outfile_check_timer = data.outfile_check_timer;
3970
3971 char separator = data.separator;
3972
3973 // some hash-dependent functions
3974 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3975 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3976
3977 // buffers
3978 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3979
3980 hash_buf.digest = mymalloc (dgst_size);
3981
3982 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3983
3984 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3985
3986 uint digest_buf[64] = { 0 };
3987
3988 outfile_data_t *out_info = NULL;
3989
3990 char **out_files = NULL;
3991
3992 time_t folder_mtime = 0;
3993
3994 int out_cnt = 0;
3995
3996 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3997
3998 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3999 {
4000 hc_sleep (1);
4001
4002 if (data.devices_status != STATUS_RUNNING) continue;
4003
4004 check_left--;
4005
4006 if (check_left == 0)
4007 {
4008 struct stat outfile_check_stat;
4009
4010 if (stat (outfile_dir, &outfile_check_stat) == 0)
4011 {
4012 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4013
4014 if (is_dir == 1)
4015 {
4016 if (outfile_check_stat.st_mtime > folder_mtime)
4017 {
4018 char **out_files_new = scan_directory (outfile_dir);
4019
4020 int out_cnt_new = count_dictionaries (out_files_new);
4021
4022 outfile_data_t *out_info_new = NULL;
4023
4024 if (out_cnt_new > 0)
4025 {
4026 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4027
4028 for (int i = 0; i < out_cnt_new; i++)
4029 {
4030 out_info_new[i].file_name = out_files_new[i];
4031
4032 // check if there are files that we have seen/checked before (and not changed)
4033
4034 for (int j = 0; j < out_cnt; j++)
4035 {
4036 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4037 {
4038 struct stat outfile_stat;
4039
4040 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4041 {
4042 if (outfile_stat.st_ctime == out_info[j].ctime)
4043 {
4044 out_info_new[i].ctime = out_info[j].ctime;
4045 out_info_new[i].seek = out_info[j].seek;
4046 }
4047 }
4048 }
4049 }
4050 }
4051 }
4052
4053 local_free (out_info);
4054 local_free (out_files);
4055
4056 out_files = out_files_new;
4057 out_cnt = out_cnt_new;
4058 out_info = out_info_new;
4059
4060 folder_mtime = outfile_check_stat.st_mtime;
4061 }
4062
4063 for (int j = 0; j < out_cnt; j++)
4064 {
4065 FILE *fp = fopen (out_info[j].file_name, "rb");
4066
4067 if (fp != NULL)
4068 {
4069 //hc_thread_mutex_lock (mux_display);
4070
4071 #ifdef _POSIX
4072 struct stat outfile_stat;
4073
4074 fstat (fileno (fp), &outfile_stat);
4075 #endif
4076
4077 #ifdef _WIN
4078 struct stat64 outfile_stat;
4079
4080 _fstat64 (fileno (fp), &outfile_stat);
4081 #endif
4082
4083 if (outfile_stat.st_ctime > out_info[j].ctime)
4084 {
4085 out_info[j].ctime = outfile_stat.st_ctime;
4086 out_info[j].seek = 0;
4087 }
4088
4089 fseek (fp, out_info[j].seek, SEEK_SET);
4090
4091 while (!feof (fp))
4092 {
4093 char line_buf[BUFSIZ] = { 0 };
4094
4095 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4096
4097 if (ptr == NULL) break;
4098
4099 int line_len = strlen (line_buf);
4100
4101 if (line_len <= 0) continue;
4102
4103 int iter = MAX_CUT_TRIES;
4104
4105 for (uint i = line_len - 1; i && iter; i--, line_len--)
4106 {
4107 if (line_buf[i] != separator) continue;
4108
4109 int parser_status = PARSER_OK;
4110
4111 if ((hash_mode != 2500) && (hash_mode != 6800))
4112 {
4113 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4114 }
4115
4116 uint found = 0;
4117
4118 if (parser_status == PARSER_OK)
4119 {
4120 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4121 {
4122 if (data.salts_shown[salt_pos] == 1) continue;
4123
4124 salt_t *salt_buf = &data.salts_buf[salt_pos];
4125
4126 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4127 {
4128 uint idx = salt_buf->digests_offset + digest_pos;
4129
4130 if (data.digests_shown[idx] == 1) continue;
4131
4132 uint cracked = 0;
4133
4134 if (hash_mode == 6800)
4135 {
4136 if (i == salt_buf->salt_len)
4137 {
4138 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4139 }
4140 }
4141 else if (hash_mode == 2500)
4142 {
4143 // BSSID : MAC1 : MAC2 (:plain)
4144 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4145 {
4146 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4147
4148 if (!cracked) continue;
4149
4150 // now compare MAC1 and MAC2 too, since we have this additional info
4151 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4152 char *mac2_pos = mac1_pos + 12 + 1;
4153
4154 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4155 wpa_t *wpa = &wpas[salt_pos];
4156
4157 uint pke[25] = { 0 };
4158
4159 char *pke_ptr = (char *) pke;
4160
4161 for (uint i = 0; i < 25; i++)
4162 {
4163 pke[i] = byte_swap_32 (wpa->pke[i]);
4164 }
4165
4166 u8 mac1[6] = { 0 };
4167 u8 mac2[6] = { 0 };
4168
4169 memcpy (mac1, pke_ptr + 23, 6);
4170 memcpy (mac2, pke_ptr + 29, 6);
4171
4172 // compare hex string(s) vs binary MAC address(es)
4173
4174 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4175 {
4176 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4177 {
4178 cracked = 0;
4179 break;
4180 }
4181 }
4182
4183 // early skip ;)
4184 if (!cracked) continue;
4185
4186 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4187 {
4188 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4189 {
4190 cracked = 0;
4191 break;
4192 }
4193 }
4194 }
4195 }
4196 else
4197 {
4198 char *digests_buf_ptr = (char *) data.digests_buf;
4199
4200 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4201
4202 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4203 }
4204
4205 if (cracked == 1)
4206 {
4207 found = 1;
4208
4209 data.digests_shown[idx] = 1;
4210
4211 data.digests_done++;
4212
4213 salt_buf->digests_done++;
4214
4215 if (salt_buf->digests_done == salt_buf->digests_cnt)
4216 {
4217 data.salts_shown[salt_pos] = 1;
4218
4219 data.salts_done++;
4220
4221 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4222 }
4223 }
4224 }
4225
4226 if (data.devices_status == STATUS_CRACKED) break;
4227 }
4228 }
4229
4230 if (found) break;
4231
4232 if (data.devices_status == STATUS_CRACKED) break;
4233
4234 iter--;
4235 }
4236
4237 if (data.devices_status == STATUS_CRACKED) break;
4238 }
4239
4240 out_info[j].seek = ftell (fp);
4241
4242 //hc_thread_mutex_unlock (mux_display);
4243
4244 fclose (fp);
4245 }
4246 }
4247 }
4248 }
4249
4250 check_left = outfile_check_timer;
4251 }
4252 }
4253
4254 if (esalt_size) local_free (hash_buf.esalt);
4255
4256 if (isSalted) local_free (hash_buf.salt);
4257
4258 local_free (hash_buf.digest);
4259
4260 local_free (out_info);
4261
4262 local_free (out_files);
4263
4264 p = NULL;
4265
4266 return (p);
4267 }
4268
4269 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4270 {
4271 if (device_param->pws_cnt < device_param->kernel_power)
4272 {
4273 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4274
4275 u8 *ptr = (u8 *) pw->i;
4276
4277 memcpy (ptr, pw_buf, pw_len);
4278
4279 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4280
4281 pw->pw_len = pw_len;
4282
4283 device_param->pws_cnt++;
4284 }
4285 else
4286 {
4287 fprintf (stderr, "BUG pw_add()!!\n");
4288
4289 return;
4290 }
4291 }
4292
4293 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4294 {
4295 hc_thread_mutex_lock (mux_dispatcher);
4296
4297 const u64 words_cur = data.words_cur;
4298 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4299
4300 device_param->words_off = words_cur;
4301
4302 const u64 words_left = words_base - words_cur;
4303
4304 if (allow_div)
4305 {
4306 if (data.kernel_power_all > words_left)
4307 {
4308 if (data.kernel_power_div == 0)
4309 {
4310 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4311 }
4312 }
4313
4314 if (data.kernel_power_div)
4315 {
4316 if (device_param->kernel_power == device_param->kernel_power_user)
4317 {
4318 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4319
4320 if (kernel_power_new < device_param->kernel_power)
4321 {
4322 device_param->kernel_power = kernel_power_new;
4323 }
4324 }
4325 }
4326 }
4327
4328 const uint kernel_power = device_param->kernel_power;
4329
4330 uint work = MIN (words_left, kernel_power);
4331
4332 work = MIN (work, max);
4333
4334 data.words_cur += work;
4335
4336 hc_thread_mutex_unlock (mux_dispatcher);
4337
4338 return work;
4339 }
4340
4341 static void *thread_calc_stdin (void *p)
4342 {
4343 hc_device_param_t *device_param = (hc_device_param_t *) p;
4344
4345 if (device_param->skipped) return NULL;
4346
4347 autotune (device_param);
4348
4349 const uint attack_kern = data.attack_kern;
4350
4351 const uint kernel_power = device_param->kernel_power;
4352
4353 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4354 {
4355 hc_thread_mutex_lock (mux_dispatcher);
4356
4357 if (feof (stdin) != 0)
4358 {
4359 hc_thread_mutex_unlock (mux_dispatcher);
4360
4361 break;
4362 }
4363
4364 uint words_cur = 0;
4365
4366 while (words_cur < kernel_power)
4367 {
4368 char buf[BUFSIZ] = { 0 };
4369
4370 char *line_buf = fgets (buf, sizeof (buf), stdin);
4371
4372 if (line_buf == NULL) break;
4373
4374 uint line_len = in_superchop (line_buf);
4375
4376 line_len = convert_from_hex (line_buf, line_len);
4377
4378 // post-process rule engine
4379
4380 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4381 {
4382 char rule_buf_out[BLOCK_SIZE] = { 0 };
4383
4384 int rule_len_out = -1;
4385
4386 if (line_len < BLOCK_SIZE)
4387 {
4388 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4389 }
4390
4391 if (rule_len_out < 0) continue;
4392
4393 line_buf = rule_buf_out;
4394 line_len = rule_len_out;
4395 }
4396
4397 if (line_len > PW_MAX)
4398 {
4399 continue;
4400 }
4401
4402 if (attack_kern == ATTACK_KERN_STRAIGHT)
4403 {
4404 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4405 {
4406 hc_thread_mutex_lock (mux_counter);
4407
4408 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4409 {
4410 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4411 }
4412
4413 hc_thread_mutex_unlock (mux_counter);
4414
4415 continue;
4416 }
4417 }
4418 else if (attack_kern == ATTACK_KERN_COMBI)
4419 {
4420 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4421 // since we still need to combine the plains
4422
4423 if (line_len > data.pw_max)
4424 {
4425 hc_thread_mutex_lock (mux_counter);
4426
4427 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4428 {
4429 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4430 }
4431
4432 hc_thread_mutex_unlock (mux_counter);
4433
4434 continue;
4435 }
4436 }
4437
4438 pw_add (device_param, (u8 *) line_buf, line_len);
4439
4440 words_cur++;
4441
4442 if (data.devices_status == STATUS_CRACKED) break;
4443 if (data.devices_status == STATUS_ABORTED) break;
4444 if (data.devices_status == STATUS_QUIT) break;
4445 if (data.devices_status == STATUS_BYPASS) break;
4446 }
4447
4448 hc_thread_mutex_unlock (mux_dispatcher);
4449
4450 if (data.devices_status == STATUS_CRACKED) break;
4451 if (data.devices_status == STATUS_ABORTED) break;
4452 if (data.devices_status == STATUS_QUIT) break;
4453 if (data.devices_status == STATUS_BYPASS) break;
4454
4455 // flush
4456
4457 const uint pws_cnt = device_param->pws_cnt;
4458
4459 if (pws_cnt)
4460 {
4461 run_copy (device_param, pws_cnt);
4462
4463 run_cracker (device_param, pws_cnt);
4464
4465 device_param->pws_cnt = 0;
4466
4467 if (attack_kern == ATTACK_KERN_STRAIGHT)
4468 {
4469 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4470 }
4471 else if (attack_kern == ATTACK_KERN_COMBI)
4472 {
4473 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4474 }
4475 }
4476 }
4477
4478 device_param->kernel_accel = 0;
4479 device_param->kernel_loops = 0;
4480
4481 return NULL;
4482 }
4483
4484 static void *thread_calc (void *p)
4485 {
4486 hc_device_param_t *device_param = (hc_device_param_t *) p;
4487
4488 if (device_param->skipped) return NULL;
4489
4490 autotune (device_param);
4491
4492 const uint attack_mode = data.attack_mode;
4493 const uint attack_kern = data.attack_kern;
4494
4495 if (attack_mode == ATTACK_MODE_BF)
4496 {
4497 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4498 {
4499 const uint work = get_work (device_param, -1, true);
4500
4501 if (work == 0) break;
4502
4503 const u64 words_off = device_param->words_off;
4504 const u64 words_fin = words_off + work;
4505
4506 const uint pws_cnt = work;
4507
4508 device_param->pws_cnt = pws_cnt;
4509
4510 if (pws_cnt)
4511 {
4512 run_copy (device_param, pws_cnt);
4513
4514 run_cracker (device_param, pws_cnt);
4515
4516 device_param->pws_cnt = 0;
4517
4518 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4519 }
4520
4521 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4522
4523 if (data.devices_status == STATUS_CRACKED) break;
4524 if (data.devices_status == STATUS_ABORTED) break;
4525 if (data.devices_status == STATUS_QUIT) break;
4526 if (data.devices_status == STATUS_BYPASS) break;
4527
4528 if (data.benchmark == 1) break;
4529
4530 device_param->words_done = words_fin;
4531 }
4532 }
4533 else
4534 {
4535 const uint segment_size = data.segment_size;
4536
4537 char *dictfile = data.dictfile;
4538
4539 if (attack_mode == ATTACK_MODE_COMBI)
4540 {
4541 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4542 {
4543 dictfile = data.dictfile2;
4544 }
4545 }
4546
4547 FILE *fd = fopen (dictfile, "rb");
4548
4549 if (fd == NULL)
4550 {
4551 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4552
4553 return NULL;
4554 }
4555
4556 if (attack_mode == ATTACK_MODE_COMBI)
4557 {
4558 const uint combs_mode = data.combs_mode;
4559
4560 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4561 {
4562 const char *dictfilec = data.dictfile2;
4563
4564 FILE *combs_fp = fopen (dictfilec, "rb");
4565
4566 if (combs_fp == NULL)
4567 {
4568 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4569
4570 fclose (fd);
4571
4572 return NULL;
4573 }
4574
4575 device_param->combs_fp = combs_fp;
4576 }
4577 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4578 {
4579 const char *dictfilec = data.dictfile;
4580
4581 FILE *combs_fp = fopen (dictfilec, "rb");
4582
4583 if (combs_fp == NULL)
4584 {
4585 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4586
4587 fclose (fd);
4588
4589 return NULL;
4590 }
4591
4592 device_param->combs_fp = combs_fp;
4593 }
4594 }
4595
4596 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4597
4598 wl_data->buf = (char *) mymalloc (segment_size);
4599 wl_data->avail = segment_size;
4600 wl_data->incr = segment_size;
4601 wl_data->cnt = 0;
4602 wl_data->pos = 0;
4603
4604 u64 words_cur = 0;
4605
4606 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4607 {
4608 u64 words_off = 0;
4609 u64 words_fin = 0;
4610
4611 bool allow_div = true;
4612
4613 u64 max = -1;
4614
4615 while (max)
4616 {
4617 const uint work = get_work (device_param, max, allow_div);
4618
4619 allow_div = false;
4620
4621 if (work == 0) break;
4622
4623 words_off = device_param->words_off;
4624 words_fin = words_off + work;
4625
4626 char *line_buf;
4627 uint line_len;
4628
4629 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4630
4631 max = 0;
4632
4633 for ( ; words_cur < words_fin; words_cur++)
4634 {
4635 get_next_word (wl_data, fd, &line_buf, &line_len);
4636
4637 line_len = convert_from_hex (line_buf, line_len);
4638
4639 // post-process rule engine
4640
4641 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4642 {
4643 char rule_buf_out[BLOCK_SIZE] = { 0 };
4644
4645 int rule_len_out = -1;
4646
4647 if (line_len < BLOCK_SIZE)
4648 {
4649 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4650 }
4651
4652 if (rule_len_out < 0) continue;
4653
4654 line_buf = rule_buf_out;
4655 line_len = rule_len_out;
4656 }
4657
4658 if (attack_kern == ATTACK_KERN_STRAIGHT)
4659 {
4660 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4661 {
4662 max++;
4663
4664 hc_thread_mutex_lock (mux_counter);
4665
4666 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4667 {
4668 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4669 }
4670
4671 hc_thread_mutex_unlock (mux_counter);
4672
4673 continue;
4674 }
4675 }
4676 else if (attack_kern == ATTACK_KERN_COMBI)
4677 {
4678 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4679 // since we still need to combine the plains
4680
4681 if (line_len > data.pw_max)
4682 {
4683 max++;
4684
4685 hc_thread_mutex_lock (mux_counter);
4686
4687 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4688 {
4689 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4690 }
4691
4692 hc_thread_mutex_unlock (mux_counter);
4693
4694 continue;
4695 }
4696 }
4697
4698 pw_add (device_param, (u8 *) line_buf, line_len);
4699
4700 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4701
4702 if (data.devices_status == STATUS_CRACKED) break;
4703 if (data.devices_status == STATUS_ABORTED) break;
4704 if (data.devices_status == STATUS_QUIT) break;
4705 if (data.devices_status == STATUS_BYPASS) break;
4706 }
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714 }
4715
4716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4717
4718 if (data.devices_status == STATUS_CRACKED) break;
4719 if (data.devices_status == STATUS_ABORTED) break;
4720 if (data.devices_status == STATUS_QUIT) break;
4721 if (data.devices_status == STATUS_BYPASS) break;
4722
4723 //
4724 // flush
4725 //
4726
4727 const uint pws_cnt = device_param->pws_cnt;
4728
4729 if (pws_cnt)
4730 {
4731 run_copy (device_param, pws_cnt);
4732
4733 run_cracker (device_param, pws_cnt);
4734
4735 device_param->pws_cnt = 0;
4736
4737 if (attack_kern == ATTACK_KERN_STRAIGHT)
4738 {
4739 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4740 }
4741 else if (attack_kern == ATTACK_KERN_COMBI)
4742 {
4743 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4744 }
4745 }
4746
4747 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4748
4749 if (data.devices_status == STATUS_CRACKED) break;
4750 if (data.devices_status == STATUS_ABORTED) break;
4751 if (data.devices_status == STATUS_QUIT) break;
4752 if (data.devices_status == STATUS_BYPASS) break;
4753
4754 if (words_fin == 0) break;
4755
4756 device_param->words_done = words_fin;
4757 }
4758
4759 if (attack_mode == ATTACK_MODE_COMBI)
4760 {
4761 fclose (device_param->combs_fp);
4762 }
4763
4764 free (wl_data->buf);
4765 free (wl_data);
4766
4767 fclose (fd);
4768 }
4769
4770 device_param->kernel_accel = 0;
4771 device_param->kernel_loops = 0;
4772
4773 return NULL;
4774 }
4775
4776 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4777 {
4778 if (!device_param)
4779 {
4780 log_error ("ERROR: %s : Invalid argument", __func__);
4781
4782 exit (-1);
4783 }
4784
4785 salt_t *salt_buf = &data.salts_buf[salt_pos];
4786
4787 device_param->kernel_params_buf32[24] = salt_pos;
4788 device_param->kernel_params_buf32[27] = 1;
4789 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4790 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4791 device_param->kernel_params_buf32[30] = 0;
4792 device_param->kernel_params_buf32[31] = 1;
4793
4794 char *dictfile_old = data.dictfile;
4795
4796 const char *weak_hash_check = "weak-hash-check";
4797
4798 data.dictfile = (char *) weak_hash_check;
4799
4800 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4801
4802 data.kernel_rules_buf[0].cmds[0] = 0;
4803
4804 /**
4805 * run the kernel
4806 */
4807
4808 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4809 {
4810 run_kernel (KERN_RUN_1, device_param, 1, false);
4811 }
4812 else
4813 {
4814 run_kernel (KERN_RUN_1, device_param, 1, false);
4815
4816 uint loop_step = 16;
4817
4818 const uint iter = salt_buf->salt_iter;
4819
4820 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4821 {
4822 uint loop_left = iter - loop_pos;
4823
4824 loop_left = MIN (loop_left, loop_step);
4825
4826 device_param->kernel_params_buf32[25] = loop_pos;
4827 device_param->kernel_params_buf32[26] = loop_left;
4828
4829 run_kernel (KERN_RUN_2, device_param, 1, false);
4830 }
4831
4832 run_kernel (KERN_RUN_3, device_param, 1, false);
4833 }
4834
4835 /**
4836 * result
4837 */
4838
4839 check_cracked (device_param, salt_pos);
4840
4841 /**
4842 * cleanup
4843 */
4844
4845 device_param->kernel_params_buf32[24] = 0;
4846 device_param->kernel_params_buf32[25] = 0;
4847 device_param->kernel_params_buf32[26] = 0;
4848 device_param->kernel_params_buf32[27] = 0;
4849 device_param->kernel_params_buf32[28] = 0;
4850 device_param->kernel_params_buf32[29] = 0;
4851 device_param->kernel_params_buf32[30] = 0;
4852 device_param->kernel_params_buf32[31] = 0;
4853
4854 data.dictfile = dictfile_old;
4855
4856 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4857 }
4858
4859 // hlfmt hashcat
4860
4861 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4862 {
4863 if (data.username == 0)
4864 {
4865 *hashbuf_pos = line_buf;
4866 *hashbuf_len = line_len;
4867 }
4868 else
4869 {
4870 char *pos = line_buf;
4871 int len = line_len;
4872
4873 for (int i = 0; i < line_len; i++, pos++, len--)
4874 {
4875 if (line_buf[i] == data.separator)
4876 {
4877 pos++;
4878
4879 len--;
4880
4881 break;
4882 }
4883 }
4884
4885 *hashbuf_pos = pos;
4886 *hashbuf_len = len;
4887 }
4888 }
4889
4890 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_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] == data.separator)
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (sep_cnt == 0)
4907 {
4908 if (pos == NULL) pos = line_buf + i;
4909
4910 len++;
4911 }
4912 }
4913
4914 *userbuf_pos = pos;
4915 *userbuf_len = len;
4916 }
4917
4918 // hlfmt pwdump
4919
4920 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4921 {
4922 int sep_cnt = 0;
4923
4924 int sep2_len = 0;
4925 int sep3_len = 0;
4926
4927 for (int i = 0; i < line_len; i++)
4928 {
4929 if (line_buf[i] == ':')
4930 {
4931 sep_cnt++;
4932
4933 continue;
4934 }
4935
4936 if (sep_cnt == 2) sep2_len++;
4937 if (sep_cnt == 3) sep3_len++;
4938 }
4939
4940 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4941
4942 return 0;
4943 }
4944
4945 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4946 {
4947 char *pos = NULL;
4948 int len = 0;
4949
4950 int sep_cnt = 0;
4951
4952 for (int i = 0; i < line_len; i++)
4953 {
4954 if (line_buf[i] == ':')
4955 {
4956 sep_cnt++;
4957
4958 continue;
4959 }
4960
4961 if (data.hash_mode == 1000)
4962 {
4963 if (sep_cnt == 3)
4964 {
4965 if (pos == NULL) pos = line_buf + i;
4966
4967 len++;
4968 }
4969 }
4970 else if (data.hash_mode == 3000)
4971 {
4972 if (sep_cnt == 2)
4973 {
4974 if (pos == NULL) pos = line_buf + i;
4975
4976 len++;
4977 }
4978 }
4979 }
4980
4981 *hashbuf_pos = pos;
4982 *hashbuf_len = len;
4983 }
4984
4985 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_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 == 0)
5002 {
5003 if (pos == NULL) pos = line_buf + i;
5004
5005 len++;
5006 }
5007 }
5008
5009 *userbuf_pos = pos;
5010 *userbuf_len = len;
5011 }
5012
5013 // hlfmt passwd
5014
5015 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5016 {
5017 int sep_cnt = 0;
5018
5019 char sep5_first = 0;
5020 char sep6_first = 0;
5021
5022 for (int i = 0; i < line_len; i++)
5023 {
5024 if (line_buf[i] == ':')
5025 {
5026 sep_cnt++;
5027
5028 continue;
5029 }
5030
5031 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5032 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5033 }
5034
5035 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5036
5037 return 0;
5038 }
5039
5040 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5041 {
5042 char *pos = NULL;
5043 int len = 0;
5044
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == ':')
5050 {
5051 sep_cnt++;
5052
5053 continue;
5054 }
5055
5056 if (sep_cnt == 1)
5057 {
5058 if (pos == NULL) pos = line_buf + i;
5059
5060 len++;
5061 }
5062 }
5063
5064 *hashbuf_pos = pos;
5065 *hashbuf_len = len;
5066 }
5067
5068 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5069 {
5070 char *pos = NULL;
5071 int len = 0;
5072
5073 int sep_cnt = 0;
5074
5075 for (int i = 0; i < line_len; i++)
5076 {
5077 if (line_buf[i] == ':')
5078 {
5079 sep_cnt++;
5080
5081 continue;
5082 }
5083
5084 if (sep_cnt == 0)
5085 {
5086 if (pos == NULL) pos = line_buf + i;
5087
5088 len++;
5089 }
5090 }
5091
5092 *userbuf_pos = pos;
5093 *userbuf_len = len;
5094 }
5095
5096 // hlfmt shadow
5097
5098 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5099 {
5100 int sep_cnt = 0;
5101
5102 for (int i = 0; i < line_len; i++)
5103 {
5104 if (line_buf[i] == ':') sep_cnt++;
5105 }
5106
5107 if (sep_cnt == 8) return 1;
5108
5109 return 0;
5110 }
5111
5112 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5113 {
5114 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5115 }
5116
5117 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5118 {
5119 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5120 }
5121
5122 // hlfmt main
5123
5124 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5125 {
5126 switch (hashfile_format)
5127 {
5128 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5129 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5132 }
5133 }
5134
5135 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5136 {
5137 switch (hashfile_format)
5138 {
5139 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5140 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5143 }
5144 }
5145
5146 static uint hlfmt_detect (FILE *fp, uint max_check)
5147 {
5148 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5149
5150 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5151 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5152
5153 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5154
5155 uint num_check = 0;
5156
5157 while (!feof (fp))
5158 {
5159 char line_buf[BUFSIZ] = { 0 };
5160
5161 int line_len = fgetl (fp, line_buf);
5162
5163 if (line_len == 0) continue;
5164
5165 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5166 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5167 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5168
5169 if (num_check == max_check) break;
5170
5171 num_check++;
5172 }
5173
5174 uint hashlist_format = HLFMT_HASHCAT;
5175
5176 for (int i = 1; i < HLFMTS_CNT; i++)
5177 {
5178 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5179
5180 hashlist_format = i;
5181 }
5182
5183 free (formats_cnt);
5184
5185 return hashlist_format;
5186 }
5187
5188 /**
5189 * some further helper function
5190 */
5191
5192 // wrapper around mymalloc for ADL
5193
5194 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5195 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5196 {
5197 return mymalloc (iSize);
5198 }
5199 #endif
5200
5201 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)
5202 {
5203 u64 collisions = 0;
5204
5205 const uint dgst_pos0 = data.dgst_pos0;
5206 const uint dgst_pos1 = data.dgst_pos1;
5207 const uint dgst_pos2 = data.dgst_pos2;
5208 const uint dgst_pos3 = data.dgst_pos3;
5209
5210 memset (bitmap_a, 0, bitmap_size);
5211 memset (bitmap_b, 0, bitmap_size);
5212 memset (bitmap_c, 0, bitmap_size);
5213 memset (bitmap_d, 0, bitmap_size);
5214
5215 for (uint i = 0; i < digests_cnt; i++)
5216 {
5217 uint *digest_ptr = (uint *) digests_buf_ptr;
5218
5219 digests_buf_ptr += dgst_size;
5220
5221 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5222 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5223 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5224 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5225
5226 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5227 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5228 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5229 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5230
5231 if (bitmap_a[idx0] & val0) collisions++;
5232 if (bitmap_b[idx1] & val1) collisions++;
5233 if (bitmap_c[idx2] & val2) collisions++;
5234 if (bitmap_d[idx3] & val3) collisions++;
5235
5236 bitmap_a[idx0] |= val0;
5237 bitmap_b[idx1] |= val1;
5238 bitmap_c[idx2] |= val2;
5239 bitmap_d[idx3] |= val3;
5240
5241 if (collisions >= collisions_max) return 0x7fffffff;
5242 }
5243
5244 return collisions;
5245 }
5246
5247 /**
5248 * main
5249 */
5250
5251 int main (int argc, char **argv)
5252 {
5253 /**
5254 * To help users a bit
5255 */
5256
5257 char *compute = getenv ("COMPUTE");
5258
5259 if (compute)
5260 {
5261 static char display[100];
5262
5263 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5264
5265 putenv (display);
5266 }
5267 else
5268 {
5269 if (getenv ("DISPLAY") == NULL)
5270 putenv ((char *) "DISPLAY=:0");
5271 }
5272
5273 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5274 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5275
5276 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5277 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5278
5279 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5280 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5281
5282 /**
5283 * Real init
5284 */
5285
5286 memset (&data, 0, sizeof (hc_global_data_t));
5287
5288 time_t proc_start;
5289
5290 time (&proc_start);
5291
5292 data.proc_start = proc_start;
5293
5294 int myargc = argc;
5295 char **myargv = argv;
5296
5297 hc_thread_mutex_init (mux_dispatcher);
5298 hc_thread_mutex_init (mux_counter);
5299 hc_thread_mutex_init (mux_display);
5300 hc_thread_mutex_init (mux_adl);
5301
5302 /**
5303 * commandline parameters
5304 */
5305
5306 uint usage = USAGE;
5307 uint version = VERSION;
5308 uint quiet = QUIET;
5309 uint benchmark = BENCHMARK;
5310 uint benchmark_repeats = BENCHMARK_REPEATS;
5311 uint show = SHOW;
5312 uint left = LEFT;
5313 uint username = USERNAME;
5314 uint remove = REMOVE;
5315 uint remove_timer = REMOVE_TIMER;
5316 u64 skip = SKIP;
5317 u64 limit = LIMIT;
5318 uint keyspace = KEYSPACE;
5319 uint potfile_disable = POTFILE_DISABLE;
5320 uint debug_mode = DEBUG_MODE;
5321 char *debug_file = NULL;
5322 char *induction_dir = NULL;
5323 char *outfile_check_dir = NULL;
5324 uint force = FORCE;
5325 uint runtime = RUNTIME;
5326 uint hash_mode = HASH_MODE;
5327 uint attack_mode = ATTACK_MODE;
5328 uint markov_disable = MARKOV_DISABLE;
5329 uint markov_classic = MARKOV_CLASSIC;
5330 uint markov_threshold = MARKOV_THRESHOLD;
5331 char *markov_hcstat = NULL;
5332 char *outfile = NULL;
5333 uint outfile_format = OUTFILE_FORMAT;
5334 uint outfile_autohex = OUTFILE_AUTOHEX;
5335 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5336 uint restore = RESTORE;
5337 uint restore_timer = RESTORE_TIMER;
5338 uint restore_disable = RESTORE_DISABLE;
5339 uint status = STATUS;
5340 uint status_timer = STATUS_TIMER;
5341 uint status_automat = STATUS_AUTOMAT;
5342 uint loopback = LOOPBACK;
5343 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5344 char *session = NULL;
5345 uint hex_charset = HEX_CHARSET;
5346 uint hex_salt = HEX_SALT;
5347 uint hex_wordlist = HEX_WORDLIST;
5348 uint rp_gen = RP_GEN;
5349 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5350 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5351 uint rp_gen_seed = RP_GEN_SEED;
5352 char *rule_buf_l = (char *) RULE_BUF_L;
5353 char *rule_buf_r = (char *) RULE_BUF_R;
5354 uint increment = INCREMENT;
5355 uint increment_min = INCREMENT_MIN;
5356 uint increment_max = INCREMENT_MAX;
5357 char *cpu_affinity = NULL;
5358 OCL_PTR *ocl = NULL;
5359 char *opencl_devices = NULL;
5360 char *opencl_platforms = NULL;
5361 char *opencl_device_types = NULL;
5362 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5363 char *truecrypt_keyfiles = NULL;
5364 uint workload_profile = WORKLOAD_PROFILE;
5365 uint kernel_accel = KERNEL_ACCEL;
5366 uint kernel_loops = KERNEL_LOOPS;
5367 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5368 #ifdef HAVE_HWMON
5369 uint gpu_temp_abort = GPU_TEMP_ABORT;
5370 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5371 #ifdef HAVE_ADL
5372 uint powertune_enable = POWERTUNE_ENABLE;
5373 #endif
5374 #endif
5375 uint logfile_disable = LOGFILE_DISABLE;
5376 uint segment_size = SEGMENT_SIZE;
5377 uint scrypt_tmto = SCRYPT_TMTO;
5378 char separator = SEPARATOR;
5379 uint bitmap_min = BITMAP_MIN;
5380 uint bitmap_max = BITMAP_MAX;
5381 char *custom_charset_1 = NULL;
5382 char *custom_charset_2 = NULL;
5383 char *custom_charset_3 = NULL;
5384 char *custom_charset_4 = NULL;
5385
5386 #define IDX_HELP 'h'
5387 #define IDX_VERSION 'V'
5388 #define IDX_VERSION_LOWER 'v'
5389 #define IDX_QUIET 0xff02
5390 #define IDX_SHOW 0xff03
5391 #define IDX_LEFT 0xff04
5392 #define IDX_REMOVE 0xff05
5393 #define IDX_REMOVE_TIMER 0xff37
5394 #define IDX_SKIP 's'
5395 #define IDX_LIMIT 'l'
5396 #define IDX_KEYSPACE 0xff35
5397 #define IDX_POTFILE_DISABLE 0xff06
5398 #define IDX_DEBUG_MODE 0xff43
5399 #define IDX_DEBUG_FILE 0xff44
5400 #define IDX_INDUCTION_DIR 0xff46
5401 #define IDX_OUTFILE_CHECK_DIR 0xff47
5402 #define IDX_USERNAME 0xff07
5403 #define IDX_FORCE 0xff08
5404 #define IDX_RUNTIME 0xff09
5405 #define IDX_BENCHMARK 'b'
5406 #define IDX_BENCHMARK_REPEATS 0xff78
5407 #define IDX_HASH_MODE 'm'
5408 #define IDX_ATTACK_MODE 'a'
5409 #define IDX_RP_FILE 'r'
5410 #define IDX_RP_GEN 'g'
5411 #define IDX_RP_GEN_FUNC_MIN 0xff10
5412 #define IDX_RP_GEN_FUNC_MAX 0xff11
5413 #define IDX_RP_GEN_SEED 0xff34
5414 #define IDX_RULE_BUF_L 'j'
5415 #define IDX_RULE_BUF_R 'k'
5416 #define IDX_INCREMENT 'i'
5417 #define IDX_INCREMENT_MIN 0xff12
5418 #define IDX_INCREMENT_MAX 0xff13
5419 #define IDX_OUTFILE 'o'
5420 #define IDX_OUTFILE_FORMAT 0xff14
5421 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5422 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5423 #define IDX_RESTORE 0xff15
5424 #define IDX_RESTORE_DISABLE 0xff27
5425 #define IDX_STATUS 0xff17
5426 #define IDX_STATUS_TIMER 0xff18
5427 #define IDX_STATUS_AUTOMAT 0xff50
5428 #define IDX_LOOPBACK 0xff38
5429 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5430 #define IDX_SESSION 0xff19
5431 #define IDX_HEX_CHARSET 0xff20
5432 #define IDX_HEX_SALT 0xff21
5433 #define IDX_HEX_WORDLIST 0xff40
5434 #define IDX_MARKOV_DISABLE 0xff22
5435 #define IDX_MARKOV_CLASSIC 0xff23
5436 #define IDX_MARKOV_THRESHOLD 't'
5437 #define IDX_MARKOV_HCSTAT 0xff24
5438 #define IDX_CPU_AFFINITY 0xff25
5439 #define IDX_OPENCL_DEVICES 'd'
5440 #define IDX_OPENCL_PLATFORMS 0xff72
5441 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5442 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5443 #define IDX_WORKLOAD_PROFILE 'w'
5444 #define IDX_KERNEL_ACCEL 'n'
5445 #define IDX_KERNEL_LOOPS 'u'
5446 #define IDX_GPU_TEMP_DISABLE 0xff29
5447 #define IDX_GPU_TEMP_ABORT 0xff30
5448 #define IDX_GPU_TEMP_RETAIN 0xff31
5449 #define IDX_POWERTUNE_ENABLE 0xff41
5450 #define IDX_LOGFILE_DISABLE 0xff51
5451 #define IDX_TRUECRYPT_KEYFILES 0xff52
5452 #define IDX_SCRYPT_TMTO 0xff61
5453 #define IDX_SEGMENT_SIZE 'c'
5454 #define IDX_SEPARATOR 'p'
5455 #define IDX_BITMAP_MIN 0xff70
5456 #define IDX_BITMAP_MAX 0xff71
5457 #define IDX_CUSTOM_CHARSET_1 '1'
5458 #define IDX_CUSTOM_CHARSET_2 '2'
5459 #define IDX_CUSTOM_CHARSET_3 '3'
5460 #define IDX_CUSTOM_CHARSET_4 '4'
5461
5462 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5463
5464 struct option long_options[] =
5465 {
5466 {"help", no_argument, 0, IDX_HELP},
5467 {"version", no_argument, 0, IDX_VERSION},
5468 {"quiet", no_argument, 0, IDX_QUIET},
5469 {"show", no_argument, 0, IDX_SHOW},
5470 {"left", no_argument, 0, IDX_LEFT},
5471 {"username", no_argument, 0, IDX_USERNAME},
5472 {"remove", no_argument, 0, IDX_REMOVE},
5473 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5474 {"skip", required_argument, 0, IDX_SKIP},
5475 {"limit", required_argument, 0, IDX_LIMIT},
5476 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5477 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5478 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5479 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5480 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5481 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5482 {"force", no_argument, 0, IDX_FORCE},
5483 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5484 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5485 {"restore", no_argument, 0, IDX_RESTORE},
5486 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5487 {"status", no_argument, 0, IDX_STATUS},
5488 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5489 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5490 {"loopback", no_argument, 0, IDX_LOOPBACK},
5491 {"weak-hash-threshold",
5492 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5493 {"session", required_argument, 0, IDX_SESSION},
5494 {"runtime", required_argument, 0, IDX_RUNTIME},
5495 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5496 {"generate-rules-func-min",
5497 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5498 {"generate-rules-func-max",
5499 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5500 {"generate-rules-seed",
5501 required_argument, 0, IDX_RP_GEN_SEED},
5502 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5503 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5504 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5505 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5506 {"rules-file", required_argument, 0, IDX_RP_FILE},
5507 {"outfile", required_argument, 0, IDX_OUTFILE},
5508 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5509 {"outfile-autohex-disable",
5510 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5511 {"outfile-check-timer",
5512 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5513 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5514 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5515 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5516 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5517 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5518 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5519 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5520 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5521 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5522 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5523 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5524 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5525 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5526 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5527 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5528 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5529 #ifdef HAVE_HWMON
5530 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5531 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5532 #ifdef HAVE_ADL
5533 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5534 #endif
5535 #endif // HAVE_HWMON
5536 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5537 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5538 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5539 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5540 // deprecated
5541 {"seperator", required_argument, 0, IDX_SEPARATOR},
5542 {"separator", required_argument, 0, IDX_SEPARATOR},
5543 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5544 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5545 {"increment", no_argument, 0, IDX_INCREMENT},
5546 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5547 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5548 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5549 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5550 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5551 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5552
5553 {0, 0, 0, 0}
5554 };
5555
5556 uint rp_files_cnt = 0;
5557
5558 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5559
5560 int option_index = 0;
5561 int c = -1;
5562
5563 optind = 1;
5564 optopt = 0;
5565
5566 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5567 {
5568 switch (c)
5569 {
5570 case IDX_HELP: usage = 1; break;
5571 case IDX_VERSION:
5572 case IDX_VERSION_LOWER: version = 1; break;
5573 case IDX_RESTORE: restore = 1; break;
5574 case IDX_SESSION: session = optarg; break;
5575 case IDX_SHOW: show = 1; break;
5576 case IDX_LEFT: left = 1; break;
5577 case '?': return (-1);
5578 }
5579 }
5580
5581 if (optopt != 0)
5582 {
5583 log_error ("ERROR: Invalid argument specified");
5584
5585 return (-1);
5586 }
5587
5588 /**
5589 * exit functions
5590 */
5591
5592 if (version)
5593 {
5594 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5595
5596 return (0);
5597 }
5598
5599 if (usage)
5600 {
5601 usage_big_print (PROGNAME);
5602
5603 return (0);
5604 }
5605
5606 /**
5607 * session needs to be set, always!
5608 */
5609
5610 if (session == NULL) session = (char *) PROGNAME;
5611
5612 /**
5613 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5614 */
5615
5616 char *exec_path = get_exec_path ();
5617
5618 #ifdef LINUX
5619
5620 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5621 char *resolved_exec_path = realpath (exec_path, NULL);
5622
5623 char *install_dir = get_install_dir (resolved_exec_path);
5624 char *profile_dir = NULL;
5625 char *session_dir = NULL;
5626 char *shared_dir = NULL;
5627
5628 if (strcmp (install_dir, resolved_install_folder) == 0)
5629 {
5630 struct passwd *pw = getpwuid (getuid ());
5631
5632 const char *homedir = pw->pw_dir;
5633
5634 profile_dir = get_profile_dir (homedir);
5635 session_dir = get_session_dir (profile_dir);
5636 shared_dir = strdup (SHARED_FOLDER);
5637
5638 mkdir (profile_dir, 0700);
5639 mkdir (session_dir, 0700);
5640 }
5641 else
5642 {
5643 profile_dir = install_dir;
5644 session_dir = install_dir;
5645 shared_dir = install_dir;
5646 }
5647
5648 myfree (resolved_install_folder);
5649 myfree (resolved_exec_path);
5650
5651 #else
5652
5653 char *install_dir = get_install_dir (exec_path);
5654 char *profile_dir = install_dir;
5655 char *session_dir = install_dir;
5656 char *shared_dir = install_dir;
5657
5658 #endif
5659
5660 data.install_dir = install_dir;
5661 data.profile_dir = profile_dir;
5662 data.session_dir = session_dir;
5663 data.shared_dir = shared_dir;
5664
5665 myfree (exec_path);
5666
5667 /**
5668 * kernel cache, we need to make sure folder exist
5669 */
5670
5671 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5672
5673 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5674
5675 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5676
5677 mkdir (kernels_folder, 0700);
5678
5679 myfree (kernels_folder);
5680
5681 /**
5682 * session
5683 */
5684
5685 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5686
5687 data.session = session;
5688
5689 char *eff_restore_file = (char *) mymalloc (session_size);
5690 char *new_restore_file = (char *) mymalloc (session_size);
5691
5692 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5693 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5694
5695 data.eff_restore_file = eff_restore_file;
5696 data.new_restore_file = new_restore_file;
5697
5698 if (((show == 1) || (left == 1)) && (restore == 1))
5699 {
5700 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5701 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5702
5703 return (-1);
5704 }
5705
5706 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5707 if ((show == 1) || (left == 1))
5708 {
5709 restore_disable = 1;
5710
5711 restore = 0;
5712 }
5713
5714 data.restore_disable = restore_disable;
5715
5716 restore_data_t *rd = init_restore (argc, argv);
5717
5718 data.rd = rd;
5719
5720 /**
5721 * restore file
5722 */
5723
5724 if (restore == 1)
5725 {
5726 read_restore (eff_restore_file, rd);
5727
5728 if (rd->version_bin < RESTORE_MIN)
5729 {
5730 log_error ("ERROR: Incompatible restore-file version");
5731
5732 return (-1);
5733 }
5734
5735 myargc = rd->argc;
5736 myargv = rd->argv;
5737
5738 #ifdef _POSIX
5739 rd->pid = getpid ();
5740 #elif _WIN
5741 rd->pid = GetCurrentProcessId ();
5742 #endif
5743 }
5744
5745 uint hash_mode_chgd = 0;
5746 uint runtime_chgd = 0;
5747 uint kernel_loops_chgd = 0;
5748 uint kernel_accel_chgd = 0;
5749 uint attack_mode_chgd = 0;
5750 uint outfile_format_chgd = 0;
5751 uint rp_gen_seed_chgd = 0;
5752 uint remove_timer_chgd = 0;
5753 uint increment_min_chgd = 0;
5754 uint increment_max_chgd = 0;
5755 uint workload_profile_chgd = 0;
5756 uint opencl_vector_width_chgd = 0;
5757
5758 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5759 uint gpu_temp_retain_chgd = 0;
5760 uint gpu_temp_abort_chgd = 0;
5761 #endif
5762
5763 optind = 1;
5764 optopt = 0;
5765 option_index = 0;
5766
5767 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5768 {
5769 switch (c)
5770 {
5771 //case IDX_HELP: usage = 1; break;
5772 //case IDX_VERSION: version = 1; break;
5773 //case IDX_RESTORE: restore = 1; break;
5774 case IDX_QUIET: quiet = 1; break;
5775 //case IDX_SHOW: show = 1; break;
5776 case IDX_SHOW: break;
5777 //case IDX_LEFT: left = 1; break;
5778 case IDX_LEFT: break;
5779 case IDX_USERNAME: username = 1; break;
5780 case IDX_REMOVE: remove = 1; break;
5781 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5782 remove_timer_chgd = 1; break;
5783 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5784 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5785 case IDX_DEBUG_FILE: debug_file = optarg; break;
5786 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5787 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5788 case IDX_FORCE: force = 1; break;
5789 case IDX_SKIP: skip = atoll (optarg); break;
5790 case IDX_LIMIT: limit = atoll (optarg); break;
5791 case IDX_KEYSPACE: keyspace = 1; break;
5792 case IDX_BENCHMARK: benchmark = 1; break;
5793 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5794 case IDX_RESTORE: break;
5795 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5796 case IDX_STATUS: status = 1; break;
5797 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5798 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5799 case IDX_LOOPBACK: loopback = 1; break;
5800 case IDX_WEAK_HASH_THRESHOLD:
5801 weak_hash_threshold = atoi (optarg); break;
5802 //case IDX_SESSION: session = optarg; break;
5803 case IDX_SESSION: break;
5804 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5805 hash_mode_chgd = 1; break;
5806 case IDX_RUNTIME: runtime = atoi (optarg);
5807 runtime_chgd = 1; break;
5808 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5809 attack_mode_chgd = 1; break;
5810 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5811 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5812 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5813 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5814 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5815 rp_gen_seed_chgd = 1; break;
5816 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5817 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5818 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5819 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5820 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5821 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5822 case IDX_OUTFILE: outfile = optarg; break;
5823 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5824 outfile_format_chgd = 1; break;
5825 case IDX_OUTFILE_AUTOHEX_DISABLE:
5826 outfile_autohex = 0; break;
5827 case IDX_OUTFILE_CHECK_TIMER:
5828 outfile_check_timer = atoi (optarg); break;
5829 case IDX_HEX_CHARSET: hex_charset = 1; break;
5830 case IDX_HEX_SALT: hex_salt = 1; break;
5831 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5832 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5833 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5834 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5835 case IDX_OPENCL_DEVICE_TYPES:
5836 opencl_device_types = optarg; break;
5837 case IDX_OPENCL_VECTOR_WIDTH:
5838 opencl_vector_width = atoi (optarg);
5839 opencl_vector_width_chgd = 1; break;
5840 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5841 workload_profile_chgd = 1; break;
5842 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5843 kernel_accel_chgd = 1; break;
5844 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5845 kernel_loops_chgd = 1; break;
5846 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5847 #ifdef HAVE_HWMON
5848 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5849 #ifdef HAVE_ADL
5850 gpu_temp_abort_chgd = 1;
5851 #endif
5852 break;
5853 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5854 #ifdef HAVE_ADL
5855 gpu_temp_retain_chgd = 1;
5856 #endif
5857 break;
5858 #ifdef HAVE_ADL
5859 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5860 #endif
5861 #endif // HAVE_HWMON
5862 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5863 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5864 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5865 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5866 case IDX_SEPARATOR: separator = optarg[0]; break;
5867 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5868 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5869 case IDX_INCREMENT: increment = 1; break;
5870 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5871 increment_min_chgd = 1; break;
5872 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5873 increment_max_chgd = 1; break;
5874 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5875 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5876 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5877 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5878
5879 default:
5880 log_error ("ERROR: Invalid argument specified");
5881 return (-1);
5882 }
5883 }
5884
5885 if (optopt != 0)
5886 {
5887 log_error ("ERROR: Invalid argument specified");
5888
5889 return (-1);
5890 }
5891
5892 /**
5893 * Inform user things getting started,
5894 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5895 * - we do not need to check algorithm_pos
5896 */
5897
5898 if (quiet == 0)
5899 {
5900 if (benchmark == 1)
5901 {
5902 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5903
5904 log_info ("");
5905 }
5906 else if (restore == 1)
5907 {
5908 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5909
5910 log_info ("");
5911 }
5912 else
5913 {
5914 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5915
5916 log_info ("");
5917 }
5918 }
5919
5920 /**
5921 * sanity check
5922 */
5923
5924 if (attack_mode > 7)
5925 {
5926 log_error ("ERROR: Invalid attack-mode specified");
5927
5928 return (-1);
5929 }
5930
5931 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5932 {
5933 log_error ("ERROR: Invalid runtime specified");
5934
5935 return (-1);
5936 }
5937
5938 if (hash_mode_chgd && hash_mode > 13300) // just added to remove compiler warnings for hash_mode_chgd
5939 {
5940 log_error ("ERROR: Invalid hash-type specified");
5941
5942 return (-1);
5943 }
5944
5945 // renamed hash modes
5946
5947 if (hash_mode_chgd)
5948 {
5949 int n = -1;
5950
5951 switch (hash_mode)
5952 {
5953 case 123: n = 124;
5954 break;
5955 }
5956
5957 if (n >= 0)
5958 {
5959 log_error ("Old -m specified, use -m %d instead", n);
5960
5961 return (-1);
5962 }
5963 }
5964
5965 if (username == 1)
5966 {
5967 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5968 {
5969 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5970
5971 return (-1);
5972 }
5973 }
5974
5975 if (outfile_format > 16)
5976 {
5977 log_error ("ERROR: Invalid outfile-format specified");
5978
5979 return (-1);
5980 }
5981
5982 if (left == 1)
5983 {
5984 if (outfile_format_chgd == 1)
5985 {
5986 if (outfile_format > 1)
5987 {
5988 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5989
5990 return (-1);
5991 }
5992 }
5993 else
5994 {
5995 outfile_format = OUTFILE_FMT_HASH;
5996 }
5997 }
5998
5999 if (show == 1)
6000 {
6001 if (outfile_format_chgd == 1)
6002 {
6003 if ((outfile_format > 7) && (outfile_format < 16))
6004 {
6005 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6006
6007 return (-1);
6008 }
6009 }
6010 }
6011
6012 if (increment_min < INCREMENT_MIN)
6013 {
6014 log_error ("ERROR: Invalid increment-min specified");
6015
6016 return (-1);
6017 }
6018
6019 if (increment_max > INCREMENT_MAX)
6020 {
6021 log_error ("ERROR: Invalid increment-max specified");
6022
6023 return (-1);
6024 }
6025
6026 if (increment_min > increment_max)
6027 {
6028 log_error ("ERROR: Invalid increment-min specified");
6029
6030 return (-1);
6031 }
6032
6033 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6034 {
6035 log_error ("ERROR: increment is not allowed in attack-mode 0");
6036
6037 return (-1);
6038 }
6039
6040 if ((increment == 0) && (increment_min_chgd == 1))
6041 {
6042 log_error ("ERROR: increment-min is only supported together with increment switch");
6043
6044 return (-1);
6045 }
6046
6047 if ((increment == 0) && (increment_max_chgd == 1))
6048 {
6049 log_error ("ERROR: increment-max is only supported together with increment switch");
6050
6051 return (-1);
6052 }
6053
6054 if (rp_files_cnt && rp_gen)
6055 {
6056 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6057
6058 return (-1);
6059 }
6060
6061 if (rp_files_cnt || rp_gen)
6062 {
6063 if (attack_mode != ATTACK_MODE_STRAIGHT)
6064 {
6065 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6066
6067 return (-1);
6068 }
6069 }
6070
6071 if (rp_gen_func_min > rp_gen_func_max)
6072 {
6073 log_error ("ERROR: Invalid rp-gen-func-min specified");
6074
6075 return (-1);
6076 }
6077
6078 if (kernel_accel_chgd == 1)
6079 {
6080 if (kernel_accel < 1)
6081 {
6082 log_error ("ERROR: Invalid kernel-accel specified");
6083
6084 return (-1);
6085 }
6086
6087 if (kernel_accel > 1024)
6088 {
6089 log_error ("ERROR: Invalid kernel-accel specified");
6090
6091 return (-1);
6092 }
6093 }
6094
6095 if (kernel_loops_chgd == 1)
6096 {
6097 if (kernel_loops < 1)
6098 {
6099 log_error ("ERROR: Invalid kernel-loops specified");
6100
6101 return (-1);
6102 }
6103
6104 if (kernel_loops > 1024)
6105 {
6106 log_error ("ERROR: Invalid kernel-loops specified");
6107
6108 return (-1);
6109 }
6110 }
6111
6112 if ((workload_profile < 1) || (workload_profile > 3))
6113 {
6114 log_error ("ERROR: workload-profile %i not available", workload_profile);
6115
6116 return (-1);
6117 }
6118
6119 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6120 {
6121 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6122
6123 return (-1);
6124 }
6125
6126 if (show == 1 || left == 1)
6127 {
6128 attack_mode = ATTACK_MODE_NONE;
6129
6130 if (remove == 1)
6131 {
6132 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6133
6134 return (-1);
6135 }
6136
6137 if (potfile_disable == 1)
6138 {
6139 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 uint attack_kern = ATTACK_KERN_NONE;
6146
6147 switch (attack_mode)
6148 {
6149 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6150 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6151 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6152 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6153 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6154 }
6155
6156 if (benchmark == 0)
6157 {
6158 if (keyspace == 1)
6159 {
6160 int num_additional_params = 1;
6161
6162 if (attack_kern == ATTACK_KERN_COMBI)
6163 {
6164 num_additional_params = 2;
6165 }
6166
6167 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6168
6169 if (keyspace_wordlist_specified == 0) optind--;
6170 }
6171
6172 if (attack_kern == ATTACK_KERN_NONE)
6173 {
6174 if ((optind + 1) != myargc)
6175 {
6176 usage_mini_print (myargv[0]);
6177
6178 return (-1);
6179 }
6180 }
6181 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6182 {
6183 if ((optind + 1) > myargc)
6184 {
6185 usage_mini_print (myargv[0]);
6186
6187 return (-1);
6188 }
6189 }
6190 else if (attack_kern == ATTACK_KERN_COMBI)
6191 {
6192 if ((optind + 3) != myargc)
6193 {
6194 usage_mini_print (myargv[0]);
6195
6196 return (-1);
6197 }
6198 }
6199 else if (attack_kern == ATTACK_KERN_BF)
6200 {
6201 if ((optind + 1) > myargc)
6202 {
6203 usage_mini_print (myargv[0]);
6204
6205 return (-1);
6206 }
6207 }
6208 else
6209 {
6210 usage_mini_print (myargv[0]);
6211
6212 return (-1);
6213 }
6214 }
6215 else
6216 {
6217 if (myargv[optind] != 0)
6218 {
6219 log_error ("ERROR: Invalid argument for benchmark mode specified");
6220
6221 return (-1);
6222 }
6223
6224 if (attack_mode_chgd == 1)
6225 {
6226 if (attack_mode != ATTACK_MODE_BF)
6227 {
6228 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6229
6230 return (-1);
6231 }
6232 }
6233 }
6234
6235 if (skip != 0 && limit != 0)
6236 {
6237 limit += skip;
6238 }
6239
6240 if (keyspace == 1)
6241 {
6242 if (show == 1)
6243 {
6244 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6245
6246 return (-1);
6247 }
6248 else if (left == 1)
6249 {
6250 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6251
6252 return (-1);
6253 }
6254
6255 potfile_disable = 1;
6256
6257 restore_disable = 1;
6258
6259 restore = 0;
6260
6261 weak_hash_threshold = 0;
6262
6263 quiet = 1;
6264 }
6265
6266 if (remove_timer_chgd == 1)
6267 {
6268 if (remove == 0)
6269 {
6270 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6271
6272 return (-1);
6273 }
6274
6275 if (remove_timer < 1)
6276 {
6277 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6278
6279 return (-1);
6280 }
6281 }
6282
6283 if (loopback == 1)
6284 {
6285 if (attack_mode == ATTACK_MODE_BF)
6286 {
6287 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6288
6289 return (-1);
6290 }
6291 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6292 {
6293 if ((rp_files_cnt == 0) && (rp_gen == 0))
6294 {
6295 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6296
6297 return (-1);
6298 }
6299 }
6300 }
6301
6302 if (debug_mode > 0)
6303 {
6304 if (attack_mode != ATTACK_MODE_STRAIGHT)
6305 {
6306 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6307
6308 return (-1);
6309 }
6310
6311 if ((rp_files_cnt == 0) && (rp_gen == 0))
6312 {
6313 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (debug_mode > 4)
6320 {
6321 log_error ("ERROR: Invalid debug-mode specified");
6322
6323 return (-1);
6324 }
6325
6326 if (debug_file != NULL)
6327 {
6328 if (debug_mode < 1)
6329 {
6330 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6331
6332 return (-1);
6333 }
6334 }
6335
6336 if (induction_dir != NULL)
6337 {
6338 if (attack_mode == ATTACK_MODE_BF)
6339 {
6340 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6341
6342 return (-1);
6343 }
6344 }
6345
6346 if (attack_mode != ATTACK_MODE_STRAIGHT)
6347 {
6348 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6349 {
6350 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6351
6352 return (-1);
6353 }
6354
6355 weak_hash_threshold = 0;
6356 }
6357
6358 /**
6359 * induction directory
6360 */
6361
6362 char *induction_directory = NULL;
6363
6364 if (attack_mode != ATTACK_MODE_BF)
6365 {
6366 if (induction_dir == NULL)
6367 {
6368 induction_directory = (char *) mymalloc (session_size);
6369
6370 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6371
6372 // create induction folder if it does not already exist
6373
6374 if (keyspace == 0)
6375 {
6376 if (rmdir (induction_directory) == -1)
6377 {
6378 if (errno == ENOENT)
6379 {
6380 // good, we can ignore
6381 }
6382 else if (errno == ENOTEMPTY)
6383 {
6384 char *induction_directory_mv = (char *) mymalloc (session_size);
6385
6386 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6387
6388 if (rename (induction_directory, induction_directory_mv) != 0)
6389 {
6390 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6391
6392 return (-1);
6393 }
6394 }
6395 else
6396 {
6397 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6398
6399 return (-1);
6400 }
6401 }
6402
6403 if (mkdir (induction_directory, 0700) == -1)
6404 {
6405 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6406
6407 return (-1);
6408 }
6409 }
6410 }
6411 else
6412 {
6413 induction_directory = induction_dir;
6414 }
6415 }
6416
6417 data.induction_directory = induction_directory;
6418
6419 /**
6420 * loopback
6421 */
6422
6423 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6424
6425 char *loopback_file = (char *) mymalloc (loopback_size);
6426
6427 /**
6428 * tuning db
6429 */
6430
6431 char tuning_db_file[256] = { 0 };
6432
6433 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6434
6435 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6436
6437 /**
6438 * outfile-check directory
6439 */
6440
6441 char *outfile_check_directory = NULL;
6442
6443 if (outfile_check_dir == NULL)
6444 {
6445 outfile_check_directory = (char *) mymalloc (session_size);
6446
6447 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6448 }
6449 else
6450 {
6451 outfile_check_directory = outfile_check_dir;
6452 }
6453
6454 data.outfile_check_directory = outfile_check_directory;
6455
6456 if (keyspace == 0)
6457 {
6458 struct stat outfile_check_stat;
6459
6460 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6461 {
6462 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6463
6464 if (is_dir == 0)
6465 {
6466 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6467
6468 return (-1);
6469 }
6470 }
6471 else if (outfile_check_dir == NULL)
6472 {
6473 if (mkdir (outfile_check_directory, 0700) == -1)
6474 {
6475 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6476
6477 return (-1);
6478 }
6479 }
6480 }
6481
6482 /**
6483 * special other stuff
6484 */
6485
6486 if (hash_mode == 9710)
6487 {
6488 outfile_format = 5;
6489 outfile_format_chgd = 1;
6490 }
6491
6492 if (hash_mode == 9810)
6493 {
6494 outfile_format = 5;
6495 outfile_format_chgd = 1;
6496 }
6497
6498 if (hash_mode == 10410)
6499 {
6500 outfile_format = 5;
6501 outfile_format_chgd = 1;
6502 }
6503
6504 /**
6505 * store stuff
6506 */
6507
6508 data.hash_mode = hash_mode;
6509 data.restore = restore;
6510 data.restore_timer = restore_timer;
6511 data.restore_disable = restore_disable;
6512 data.status = status;
6513 data.status_timer = status_timer;
6514 data.status_automat = status_automat;
6515 data.loopback = loopback;
6516 data.runtime = runtime;
6517 data.remove = remove;
6518 data.remove_timer = remove_timer;
6519 data.debug_mode = debug_mode;
6520 data.debug_file = debug_file;
6521 data.username = username;
6522 data.quiet = quiet;
6523 data.outfile = outfile;
6524 data.outfile_format = outfile_format;
6525 data.outfile_autohex = outfile_autohex;
6526 data.hex_charset = hex_charset;
6527 data.hex_salt = hex_salt;
6528 data.hex_wordlist = hex_wordlist;
6529 data.separator = separator;
6530 data.rp_files = rp_files;
6531 data.rp_files_cnt = rp_files_cnt;
6532 data.rp_gen = rp_gen;
6533 data.rp_gen_seed = rp_gen_seed;
6534 data.force = force;
6535 data.benchmark = benchmark;
6536 data.benchmark_repeats = benchmark_repeats;
6537 data.skip = skip;
6538 data.limit = limit;
6539 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6540 data.powertune_enable = powertune_enable;
6541 #endif
6542 data.logfile_disable = logfile_disable;
6543 data.truecrypt_keyfiles = truecrypt_keyfiles;
6544 data.scrypt_tmto = scrypt_tmto;
6545 data.workload_profile = workload_profile;
6546
6547 /**
6548 * cpu affinity
6549 */
6550
6551 if (cpu_affinity)
6552 {
6553 set_cpu_affinity (cpu_affinity);
6554 }
6555
6556 if (rp_gen_seed_chgd == 0)
6557 {
6558 srand (proc_start);
6559 }
6560 else
6561 {
6562 srand (rp_gen_seed);
6563 }
6564
6565 /**
6566 * logfile init
6567 */
6568
6569 if (logfile_disable == 0)
6570 {
6571 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6572
6573 char *logfile = (char *) mymalloc (logfile_size);
6574
6575 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6576
6577 data.logfile = logfile;
6578
6579 char *topid = logfile_generate_topid ();
6580
6581 data.topid = topid;
6582 }
6583
6584 // logfile_append() checks for logfile_disable internally to make it easier from here
6585
6586 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6587 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6588 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6589 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6590 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6591 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6592 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6593 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6594 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6595 #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));
6596
6597 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6598 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6599 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6600 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6601 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6602 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6603 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6604 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6605
6606 logfile_top_msg ("START");
6607
6608 logfile_top_uint (attack_mode);
6609 logfile_top_uint (attack_kern);
6610 logfile_top_uint (benchmark);
6611 logfile_top_uint (benchmark_repeats);
6612 logfile_top_uint (bitmap_min);
6613 logfile_top_uint (bitmap_max);
6614 logfile_top_uint (debug_mode);
6615 logfile_top_uint (force);
6616 logfile_top_uint (kernel_accel);
6617 logfile_top_uint (kernel_loops);
6618 logfile_top_uint (gpu_temp_disable);
6619 #ifdef HAVE_HWMON
6620 logfile_top_uint (gpu_temp_abort);
6621 logfile_top_uint (gpu_temp_retain);
6622 #endif
6623 logfile_top_uint (hash_mode);
6624 logfile_top_uint (hex_charset);
6625 logfile_top_uint (hex_salt);
6626 logfile_top_uint (hex_wordlist);
6627 logfile_top_uint (increment);
6628 logfile_top_uint (increment_max);
6629 logfile_top_uint (increment_min);
6630 logfile_top_uint (keyspace);
6631 logfile_top_uint (left);
6632 logfile_top_uint (logfile_disable);
6633 logfile_top_uint (loopback);
6634 logfile_top_uint (markov_classic);
6635 logfile_top_uint (markov_disable);
6636 logfile_top_uint (markov_threshold);
6637 logfile_top_uint (outfile_autohex);
6638 logfile_top_uint (outfile_check_timer);
6639 logfile_top_uint (outfile_format);
6640 logfile_top_uint (potfile_disable);
6641 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6642 logfile_top_uint (powertune_enable);
6643 #endif
6644 logfile_top_uint (scrypt_tmto);
6645 logfile_top_uint (quiet);
6646 logfile_top_uint (remove);
6647 logfile_top_uint (remove_timer);
6648 logfile_top_uint (restore);
6649 logfile_top_uint (restore_disable);
6650 logfile_top_uint (restore_timer);
6651 logfile_top_uint (rp_gen);
6652 logfile_top_uint (rp_gen_func_max);
6653 logfile_top_uint (rp_gen_func_min);
6654 logfile_top_uint (rp_gen_seed);
6655 logfile_top_uint (runtime);
6656 logfile_top_uint (segment_size);
6657 logfile_top_uint (show);
6658 logfile_top_uint (status);
6659 logfile_top_uint (status_automat);
6660 logfile_top_uint (status_timer);
6661 logfile_top_uint (usage);
6662 logfile_top_uint (username);
6663 logfile_top_uint (version);
6664 logfile_top_uint (weak_hash_threshold);
6665 logfile_top_uint (workload_profile);
6666 logfile_top_uint64 (limit);
6667 logfile_top_uint64 (skip);
6668 logfile_top_char (separator);
6669 logfile_top_string (cpu_affinity);
6670 logfile_top_string (custom_charset_1);
6671 logfile_top_string (custom_charset_2);
6672 logfile_top_string (custom_charset_3);
6673 logfile_top_string (custom_charset_4);
6674 logfile_top_string (debug_file);
6675 logfile_top_string (opencl_devices);
6676 logfile_top_string (opencl_platforms);
6677 logfile_top_string (opencl_device_types);
6678 logfile_top_uint (opencl_vector_width);
6679 logfile_top_string (induction_dir);
6680 logfile_top_string (markov_hcstat);
6681 logfile_top_string (outfile);
6682 logfile_top_string (outfile_check_dir);
6683 logfile_top_string (rule_buf_l);
6684 logfile_top_string (rule_buf_r);
6685 logfile_top_string (session);
6686 logfile_top_string (truecrypt_keyfiles);
6687
6688 /**
6689 * Init OpenCL library loader
6690 */
6691
6692 if (keyspace == 0)
6693 {
6694 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6695
6696 ocl_init (ocl);
6697
6698 data.ocl = ocl;
6699 }
6700
6701 /**
6702 * OpenCL platform selection
6703 */
6704
6705 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6706
6707 /**
6708 * OpenCL device selection
6709 */
6710
6711 u32 devices_filter = setup_devices_filter (opencl_devices);
6712
6713 /**
6714 * OpenCL device type selection
6715 */
6716
6717 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6718
6719 /**
6720 * benchmark
6721 */
6722
6723 if (benchmark == 1)
6724 {
6725 /**
6726 * disable useless stuff for benchmark
6727 */
6728
6729 status_timer = 0;
6730 restore_timer = 0;
6731 restore_disable = 1;
6732 potfile_disable = 1;
6733 weak_hash_threshold = 0;
6734 gpu_temp_disable = 1;
6735
6736 data.status_timer = status_timer;
6737 data.restore_timer = restore_timer;
6738 data.restore_disable = restore_disable;
6739
6740 /**
6741 * force attack mode to be bruteforce
6742 */
6743
6744 attack_mode = ATTACK_MODE_BF;
6745 attack_kern = ATTACK_KERN_BF;
6746
6747 if (workload_profile_chgd == 0)
6748 {
6749 workload_profile = 3;
6750
6751 data.workload_profile = workload_profile;
6752 }
6753 }
6754
6755 /**
6756 * config
6757 */
6758
6759 uint hash_type = 0;
6760 uint salt_type = 0;
6761 uint attack_exec = 0;
6762 uint opts_type = 0;
6763 uint kern_type = 0;
6764 uint dgst_size = 0;
6765 uint esalt_size = 0;
6766 uint opti_type = 0;
6767 uint dgst_pos0 = -1;
6768 uint dgst_pos1 = -1;
6769 uint dgst_pos2 = -1;
6770 uint dgst_pos3 = -1;
6771
6772 int (*parse_func) (char *, uint, hash_t *);
6773 int (*sort_by_digest) (const void *, const void *);
6774
6775 uint algorithm_pos = 0;
6776 uint algorithm_max = 1;
6777
6778 uint *algorithms = default_benchmark_algorithms;
6779
6780 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6781
6782 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6783 {
6784 /*
6785 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6786 * the following algos are skipped entirely
6787 */
6788
6789 if (algorithm_pos > 0)
6790 {
6791 local_free (rd);
6792
6793 rd = init_restore (argc, argv);
6794
6795 data.rd = rd;
6796 }
6797
6798 /**
6799 * update hash_mode in case of multihash benchmark
6800 */
6801
6802 if (benchmark == 1)
6803 {
6804 if (hash_mode_chgd == 0)
6805 {
6806 hash_mode = algorithms[algorithm_pos];
6807
6808 data.hash_mode = hash_mode;
6809 }
6810
6811 quiet = 1;
6812
6813 data.quiet = quiet;
6814 }
6815
6816 switch (hash_mode)
6817 {
6818 case 0: hash_type = HASH_TYPE_MD5;
6819 salt_type = SALT_TYPE_NONE;
6820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6821 opts_type = OPTS_TYPE_PT_GENERATE_LE
6822 | OPTS_TYPE_PT_ADD80
6823 | OPTS_TYPE_PT_ADDBITS14;
6824 kern_type = KERN_TYPE_MD5;
6825 dgst_size = DGST_SIZE_4_4;
6826 parse_func = md5_parse_hash;
6827 sort_by_digest = sort_by_digest_4_4;
6828 opti_type = OPTI_TYPE_ZERO_BYTE
6829 | OPTI_TYPE_PRECOMPUTE_INIT
6830 | OPTI_TYPE_PRECOMPUTE_MERKLE
6831 | OPTI_TYPE_MEET_IN_MIDDLE
6832 | OPTI_TYPE_EARLY_SKIP
6833 | OPTI_TYPE_NOT_ITERATED
6834 | OPTI_TYPE_NOT_SALTED
6835 | OPTI_TYPE_RAW_HASH;
6836 dgst_pos0 = 0;
6837 dgst_pos1 = 3;
6838 dgst_pos2 = 2;
6839 dgst_pos3 = 1;
6840 break;
6841
6842 case 10: hash_type = HASH_TYPE_MD5;
6843 salt_type = SALT_TYPE_INTERN;
6844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6845 opts_type = OPTS_TYPE_PT_GENERATE_LE
6846 | OPTS_TYPE_ST_ADD80
6847 | OPTS_TYPE_ST_ADDBITS14;
6848 kern_type = KERN_TYPE_MD5_PWSLT;
6849 dgst_size = DGST_SIZE_4_4;
6850 parse_func = md5s_parse_hash;
6851 sort_by_digest = sort_by_digest_4_4;
6852 opti_type = OPTI_TYPE_ZERO_BYTE
6853 | OPTI_TYPE_PRECOMPUTE_INIT
6854 | OPTI_TYPE_PRECOMPUTE_MERKLE
6855 | OPTI_TYPE_MEET_IN_MIDDLE
6856 | OPTI_TYPE_EARLY_SKIP
6857 | OPTI_TYPE_NOT_ITERATED
6858 | OPTI_TYPE_APPENDED_SALT
6859 | OPTI_TYPE_RAW_HASH;
6860 dgst_pos0 = 0;
6861 dgst_pos1 = 3;
6862 dgst_pos2 = 2;
6863 dgst_pos3 = 1;
6864 break;
6865
6866 case 11: hash_type = HASH_TYPE_MD5;
6867 salt_type = SALT_TYPE_INTERN;
6868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6869 opts_type = OPTS_TYPE_PT_GENERATE_LE
6870 | OPTS_TYPE_ST_ADD80
6871 | OPTS_TYPE_ST_ADDBITS14;
6872 kern_type = KERN_TYPE_MD5_PWSLT;
6873 dgst_size = DGST_SIZE_4_4;
6874 parse_func = joomla_parse_hash;
6875 sort_by_digest = sort_by_digest_4_4;
6876 opti_type = OPTI_TYPE_ZERO_BYTE
6877 | OPTI_TYPE_PRECOMPUTE_INIT
6878 | OPTI_TYPE_PRECOMPUTE_MERKLE
6879 | OPTI_TYPE_MEET_IN_MIDDLE
6880 | OPTI_TYPE_EARLY_SKIP
6881 | OPTI_TYPE_NOT_ITERATED
6882 | OPTI_TYPE_APPENDED_SALT
6883 | OPTI_TYPE_RAW_HASH;
6884 dgst_pos0 = 0;
6885 dgst_pos1 = 3;
6886 dgst_pos2 = 2;
6887 dgst_pos3 = 1;
6888 break;
6889
6890 case 12: hash_type = HASH_TYPE_MD5;
6891 salt_type = SALT_TYPE_INTERN;
6892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6893 opts_type = OPTS_TYPE_PT_GENERATE_LE
6894 | OPTS_TYPE_ST_ADD80
6895 | OPTS_TYPE_ST_ADDBITS14;
6896 kern_type = KERN_TYPE_MD5_PWSLT;
6897 dgst_size = DGST_SIZE_4_4;
6898 parse_func = postgresql_parse_hash;
6899 sort_by_digest = sort_by_digest_4_4;
6900 opti_type = OPTI_TYPE_ZERO_BYTE
6901 | OPTI_TYPE_PRECOMPUTE_INIT
6902 | OPTI_TYPE_PRECOMPUTE_MERKLE
6903 | OPTI_TYPE_MEET_IN_MIDDLE
6904 | OPTI_TYPE_EARLY_SKIP
6905 | OPTI_TYPE_NOT_ITERATED
6906 | OPTI_TYPE_APPENDED_SALT
6907 | OPTI_TYPE_RAW_HASH;
6908 dgst_pos0 = 0;
6909 dgst_pos1 = 3;
6910 dgst_pos2 = 2;
6911 dgst_pos3 = 1;
6912 break;
6913
6914 case 20: hash_type = HASH_TYPE_MD5;
6915 salt_type = SALT_TYPE_INTERN;
6916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6917 opts_type = OPTS_TYPE_PT_GENERATE_LE
6918 | OPTS_TYPE_PT_ADD80
6919 | OPTS_TYPE_PT_ADDBITS14;
6920 kern_type = KERN_TYPE_MD5_SLTPW;
6921 dgst_size = DGST_SIZE_4_4;
6922 parse_func = md5s_parse_hash;
6923 sort_by_digest = sort_by_digest_4_4;
6924 opti_type = OPTI_TYPE_ZERO_BYTE
6925 | OPTI_TYPE_PRECOMPUTE_INIT
6926 | OPTI_TYPE_PRECOMPUTE_MERKLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_PREPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 0;
6932 dgst_pos1 = 3;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 21: hash_type = HASH_TYPE_MD5;
6938 salt_type = SALT_TYPE_INTERN;
6939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6940 opts_type = OPTS_TYPE_PT_GENERATE_LE
6941 | OPTS_TYPE_PT_ADD80
6942 | OPTS_TYPE_PT_ADDBITS14;
6943 kern_type = KERN_TYPE_MD5_SLTPW;
6944 dgst_size = DGST_SIZE_4_4;
6945 parse_func = osc_parse_hash;
6946 sort_by_digest = sort_by_digest_4_4;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_EARLY_SKIP
6951 | OPTI_TYPE_NOT_ITERATED
6952 | OPTI_TYPE_PREPENDED_SALT
6953 | OPTI_TYPE_RAW_HASH;
6954 dgst_pos0 = 0;
6955 dgst_pos1 = 3;
6956 dgst_pos2 = 2;
6957 dgst_pos3 = 1;
6958 break;
6959
6960 case 22: hash_type = HASH_TYPE_MD5;
6961 salt_type = SALT_TYPE_EMBEDDED;
6962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6963 opts_type = OPTS_TYPE_PT_GENERATE_LE
6964 | OPTS_TYPE_PT_ADD80
6965 | OPTS_TYPE_PT_ADDBITS14;
6966 kern_type = KERN_TYPE_MD5_SLTPW;
6967 dgst_size = DGST_SIZE_4_4;
6968 parse_func = netscreen_parse_hash;
6969 sort_by_digest = sort_by_digest_4_4;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 0;
6978 dgst_pos1 = 3;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 23: hash_type = HASH_TYPE_MD5;
6984 salt_type = SALT_TYPE_EMBEDDED;
6985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6986 opts_type = OPTS_TYPE_PT_GENERATE_LE
6987 | OPTS_TYPE_PT_ADD80
6988 | OPTS_TYPE_PT_ADDBITS14;
6989 kern_type = KERN_TYPE_MD5_SLTPW;
6990 dgst_size = DGST_SIZE_4_4;
6991 parse_func = skype_parse_hash;
6992 sort_by_digest = sort_by_digest_4_4;
6993 opti_type = OPTI_TYPE_ZERO_BYTE
6994 | OPTI_TYPE_PRECOMPUTE_INIT
6995 | OPTI_TYPE_PRECOMPUTE_MERKLE
6996 | OPTI_TYPE_EARLY_SKIP
6997 | OPTI_TYPE_NOT_ITERATED
6998 | OPTI_TYPE_PREPENDED_SALT
6999 | OPTI_TYPE_RAW_HASH;
7000 dgst_pos0 = 0;
7001 dgst_pos1 = 3;
7002 dgst_pos2 = 2;
7003 dgst_pos3 = 1;
7004 break;
7005
7006 case 30: hash_type = HASH_TYPE_MD5;
7007 salt_type = SALT_TYPE_INTERN;
7008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7009 opts_type = OPTS_TYPE_PT_GENERATE_LE
7010 | OPTS_TYPE_PT_UNICODE
7011 | OPTS_TYPE_ST_ADD80
7012 | OPTS_TYPE_ST_ADDBITS14;
7013 kern_type = KERN_TYPE_MD5_PWUSLT;
7014 dgst_size = DGST_SIZE_4_4;
7015 parse_func = md5s_parse_hash;
7016 sort_by_digest = sort_by_digest_4_4;
7017 opti_type = OPTI_TYPE_ZERO_BYTE
7018 | OPTI_TYPE_PRECOMPUTE_INIT
7019 | OPTI_TYPE_PRECOMPUTE_MERKLE
7020 | OPTI_TYPE_MEET_IN_MIDDLE
7021 | OPTI_TYPE_EARLY_SKIP
7022 | OPTI_TYPE_NOT_ITERATED
7023 | OPTI_TYPE_APPENDED_SALT
7024 | OPTI_TYPE_RAW_HASH;
7025 dgst_pos0 = 0;
7026 dgst_pos1 = 3;
7027 dgst_pos2 = 2;
7028 dgst_pos3 = 1;
7029 break;
7030
7031 case 40: hash_type = HASH_TYPE_MD5;
7032 salt_type = SALT_TYPE_INTERN;
7033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7034 opts_type = OPTS_TYPE_PT_GENERATE_LE
7035 | OPTS_TYPE_PT_ADD80
7036 | OPTS_TYPE_PT_ADDBITS14
7037 | OPTS_TYPE_PT_UNICODE;
7038 kern_type = KERN_TYPE_MD5_SLTPWU;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = md5s_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_EARLY_SKIP
7046 | OPTI_TYPE_NOT_ITERATED
7047 | OPTI_TYPE_PREPENDED_SALT
7048 | OPTI_TYPE_RAW_HASH;
7049 dgst_pos0 = 0;
7050 dgst_pos1 = 3;
7051 dgst_pos2 = 2;
7052 dgst_pos3 = 1;
7053 break;
7054
7055 case 50: hash_type = HASH_TYPE_MD5;
7056 salt_type = SALT_TYPE_INTERN;
7057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7058 opts_type = OPTS_TYPE_PT_GENERATE_LE
7059 | OPTS_TYPE_ST_ADD80
7060 | OPTS_TYPE_ST_ADDBITS14;
7061 kern_type = KERN_TYPE_HMACMD5_PW;
7062 dgst_size = DGST_SIZE_4_4;
7063 parse_func = hmacmd5_parse_hash;
7064 sort_by_digest = sort_by_digest_4_4;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_NOT_ITERATED;
7067 dgst_pos0 = 0;
7068 dgst_pos1 = 3;
7069 dgst_pos2 = 2;
7070 dgst_pos3 = 1;
7071 break;
7072
7073 case 60: hash_type = HASH_TYPE_MD5;
7074 salt_type = SALT_TYPE_INTERN;
7075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7076 opts_type = OPTS_TYPE_PT_GENERATE_LE
7077 | OPTS_TYPE_PT_ADD80
7078 | OPTS_TYPE_PT_ADDBITS14;
7079 kern_type = KERN_TYPE_HMACMD5_SLT;
7080 dgst_size = DGST_SIZE_4_4;
7081 parse_func = hmacmd5_parse_hash;
7082 sort_by_digest = sort_by_digest_4_4;
7083 opti_type = OPTI_TYPE_ZERO_BYTE
7084 | OPTI_TYPE_NOT_ITERATED;
7085 dgst_pos0 = 0;
7086 dgst_pos1 = 3;
7087 dgst_pos2 = 2;
7088 dgst_pos3 = 1;
7089 break;
7090
7091 case 100: hash_type = HASH_TYPE_SHA1;
7092 salt_type = SALT_TYPE_NONE;
7093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7094 opts_type = OPTS_TYPE_PT_GENERATE_BE
7095 | OPTS_TYPE_PT_ADD80
7096 | OPTS_TYPE_PT_ADDBITS15;
7097 kern_type = KERN_TYPE_SHA1;
7098 dgst_size = DGST_SIZE_4_5;
7099 parse_func = sha1_parse_hash;
7100 sort_by_digest = sort_by_digest_4_5;
7101 opti_type = OPTI_TYPE_ZERO_BYTE
7102 | OPTI_TYPE_PRECOMPUTE_INIT
7103 | OPTI_TYPE_PRECOMPUTE_MERKLE
7104 | OPTI_TYPE_EARLY_SKIP
7105 | OPTI_TYPE_NOT_ITERATED
7106 | OPTI_TYPE_NOT_SALTED
7107 | OPTI_TYPE_RAW_HASH;
7108 dgst_pos0 = 3;
7109 dgst_pos1 = 4;
7110 dgst_pos2 = 2;
7111 dgst_pos3 = 1;
7112 break;
7113
7114 case 101: hash_type = HASH_TYPE_SHA1;
7115 salt_type = SALT_TYPE_NONE;
7116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7117 opts_type = OPTS_TYPE_PT_GENERATE_BE
7118 | OPTS_TYPE_PT_ADD80
7119 | OPTS_TYPE_PT_ADDBITS15;
7120 kern_type = KERN_TYPE_SHA1;
7121 dgst_size = DGST_SIZE_4_5;
7122 parse_func = sha1b64_parse_hash;
7123 sort_by_digest = sort_by_digest_4_5;
7124 opti_type = OPTI_TYPE_ZERO_BYTE
7125 | OPTI_TYPE_PRECOMPUTE_INIT
7126 | OPTI_TYPE_PRECOMPUTE_MERKLE
7127 | OPTI_TYPE_EARLY_SKIP
7128 | OPTI_TYPE_NOT_ITERATED
7129 | OPTI_TYPE_NOT_SALTED
7130 | OPTI_TYPE_RAW_HASH;
7131 dgst_pos0 = 3;
7132 dgst_pos1 = 4;
7133 dgst_pos2 = 2;
7134 dgst_pos3 = 1;
7135 break;
7136
7137 case 110: hash_type = HASH_TYPE_SHA1;
7138 salt_type = SALT_TYPE_INTERN;
7139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7140 opts_type = OPTS_TYPE_PT_GENERATE_BE
7141 | OPTS_TYPE_ST_ADD80
7142 | OPTS_TYPE_ST_ADDBITS15;
7143 kern_type = KERN_TYPE_SHA1_PWSLT;
7144 dgst_size = DGST_SIZE_4_5;
7145 parse_func = sha1s_parse_hash;
7146 sort_by_digest = sort_by_digest_4_5;
7147 opti_type = OPTI_TYPE_ZERO_BYTE
7148 | OPTI_TYPE_PRECOMPUTE_INIT
7149 | OPTI_TYPE_PRECOMPUTE_MERKLE
7150 | OPTI_TYPE_EARLY_SKIP
7151 | OPTI_TYPE_NOT_ITERATED
7152 | OPTI_TYPE_APPENDED_SALT
7153 | OPTI_TYPE_RAW_HASH;
7154 dgst_pos0 = 3;
7155 dgst_pos1 = 4;
7156 dgst_pos2 = 2;
7157 dgst_pos3 = 1;
7158 break;
7159
7160 case 111: hash_type = HASH_TYPE_SHA1;
7161 salt_type = SALT_TYPE_EMBEDDED;
7162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7163 opts_type = OPTS_TYPE_PT_GENERATE_BE
7164 | OPTS_TYPE_ST_ADD80
7165 | OPTS_TYPE_ST_ADDBITS15;
7166 kern_type = KERN_TYPE_SHA1_PWSLT;
7167 dgst_size = DGST_SIZE_4_5;
7168 parse_func = sha1b64s_parse_hash;
7169 sort_by_digest = sort_by_digest_4_5;
7170 opti_type = OPTI_TYPE_ZERO_BYTE
7171 | OPTI_TYPE_PRECOMPUTE_INIT
7172 | OPTI_TYPE_PRECOMPUTE_MERKLE
7173 | OPTI_TYPE_EARLY_SKIP
7174 | OPTI_TYPE_NOT_ITERATED
7175 | OPTI_TYPE_APPENDED_SALT
7176 | OPTI_TYPE_RAW_HASH;
7177 dgst_pos0 = 3;
7178 dgst_pos1 = 4;
7179 dgst_pos2 = 2;
7180 dgst_pos3 = 1;
7181 break;
7182
7183 case 112: hash_type = HASH_TYPE_SHA1;
7184 salt_type = SALT_TYPE_INTERN;
7185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7186 opts_type = OPTS_TYPE_PT_GENERATE_BE
7187 | OPTS_TYPE_ST_ADD80
7188 | OPTS_TYPE_ST_ADDBITS15
7189 | OPTS_TYPE_ST_HEX;
7190 kern_type = KERN_TYPE_SHA1_PWSLT;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = oracles_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_APPENDED_SALT
7200 | OPTI_TYPE_RAW_HASH;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 1;
7205 break;
7206
7207 case 120: hash_type = HASH_TYPE_SHA1;
7208 salt_type = SALT_TYPE_INTERN;
7209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7210 opts_type = OPTS_TYPE_PT_GENERATE_BE
7211 | OPTS_TYPE_PT_ADD80
7212 | OPTS_TYPE_PT_ADDBITS15;
7213 kern_type = KERN_TYPE_SHA1_SLTPW;
7214 dgst_size = DGST_SIZE_4_5;
7215 parse_func = sha1s_parse_hash;
7216 sort_by_digest = sort_by_digest_4_5;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_PREPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 4;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 121: hash_type = HASH_TYPE_SHA1;
7231 salt_type = SALT_TYPE_INTERN;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_PT_ADD80
7235 | OPTS_TYPE_PT_ADDBITS15
7236 | OPTS_TYPE_ST_LOWER;
7237 kern_type = KERN_TYPE_SHA1_SLTPW;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = smf_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_PREPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 122: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_EMBEDDED;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15
7260 | OPTS_TYPE_ST_HEX;
7261 kern_type = KERN_TYPE_SHA1_SLTPW;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = osx1_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 124: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_EMBEDDED;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15;
7284 kern_type = KERN_TYPE_SHA1_SLTPW;
7285 dgst_size = DGST_SIZE_4_5;
7286 parse_func = djangosha1_parse_hash;
7287 sort_by_digest = sort_by_digest_4_5;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_PREPENDED_SALT
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 4;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 130: hash_type = HASH_TYPE_SHA1;
7302 salt_type = SALT_TYPE_INTERN;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_UNICODE
7306 | OPTS_TYPE_ST_ADD80
7307 | OPTS_TYPE_ST_ADDBITS15;
7308 kern_type = KERN_TYPE_SHA1_PWUSLT;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = sha1s_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_PRECOMPUTE_MERKLE
7315 | OPTI_TYPE_EARLY_SKIP
7316 | OPTI_TYPE_NOT_ITERATED
7317 | OPTI_TYPE_APPENDED_SALT
7318 | OPTI_TYPE_RAW_HASH;
7319 dgst_pos0 = 3;
7320 dgst_pos1 = 4;
7321 dgst_pos2 = 2;
7322 dgst_pos3 = 1;
7323 break;
7324
7325 case 131: hash_type = HASH_TYPE_SHA1;
7326 salt_type = SALT_TYPE_EMBEDDED;
7327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7328 opts_type = OPTS_TYPE_PT_GENERATE_BE
7329 | OPTS_TYPE_PT_UNICODE
7330 | OPTS_TYPE_PT_UPPER
7331 | OPTS_TYPE_ST_ADD80
7332 | OPTS_TYPE_ST_ADDBITS15
7333 | OPTS_TYPE_ST_HEX;
7334 kern_type = KERN_TYPE_SHA1_PWUSLT;
7335 dgst_size = DGST_SIZE_4_5;
7336 parse_func = mssql2000_parse_hash;
7337 sort_by_digest = sort_by_digest_4_5;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_APPENDED_SALT
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 3;
7346 dgst_pos1 = 4;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 1;
7349 break;
7350
7351 case 132: hash_type = HASH_TYPE_SHA1;
7352 salt_type = SALT_TYPE_EMBEDDED;
7353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7354 opts_type = OPTS_TYPE_PT_GENERATE_BE
7355 | OPTS_TYPE_PT_UNICODE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS15
7358 | OPTS_TYPE_ST_HEX;
7359 kern_type = KERN_TYPE_SHA1_PWUSLT;
7360 dgst_size = DGST_SIZE_4_5;
7361 parse_func = mssql2005_parse_hash;
7362 sort_by_digest = sort_by_digest_4_5;
7363 opti_type = OPTI_TYPE_ZERO_BYTE
7364 | OPTI_TYPE_PRECOMPUTE_INIT
7365 | OPTI_TYPE_PRECOMPUTE_MERKLE
7366 | OPTI_TYPE_EARLY_SKIP
7367 | OPTI_TYPE_NOT_ITERATED
7368 | OPTI_TYPE_APPENDED_SALT
7369 | OPTI_TYPE_RAW_HASH;
7370 dgst_pos0 = 3;
7371 dgst_pos1 = 4;
7372 dgst_pos2 = 2;
7373 dgst_pos3 = 1;
7374 break;
7375
7376 case 133: hash_type = HASH_TYPE_SHA1;
7377 salt_type = SALT_TYPE_EMBEDDED;
7378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7379 opts_type = OPTS_TYPE_PT_GENERATE_BE
7380 | OPTS_TYPE_PT_UNICODE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS15;
7383 kern_type = KERN_TYPE_SHA1_PWUSLT;
7384 dgst_size = DGST_SIZE_4_5;
7385 parse_func = peoplesoft_parse_hash;
7386 sort_by_digest = sort_by_digest_4_5;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 3;
7395 dgst_pos1 = 4;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 140: hash_type = HASH_TYPE_SHA1;
7401 salt_type = SALT_TYPE_INTERN;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_BE
7404 | OPTS_TYPE_PT_ADD80
7405 | OPTS_TYPE_PT_ADDBITS15
7406 | OPTS_TYPE_PT_UNICODE;
7407 kern_type = KERN_TYPE_SHA1_SLTPWU;
7408 dgst_size = DGST_SIZE_4_5;
7409 parse_func = sha1s_parse_hash;
7410 sort_by_digest = sort_by_digest_4_5;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_EARLY_SKIP
7415 | OPTI_TYPE_NOT_ITERATED
7416 | OPTI_TYPE_PREPENDED_SALT
7417 | OPTI_TYPE_RAW_HASH;
7418 dgst_pos0 = 3;
7419 dgst_pos1 = 4;
7420 dgst_pos2 = 2;
7421 dgst_pos3 = 1;
7422 break;
7423
7424 case 141: hash_type = HASH_TYPE_SHA1;
7425 salt_type = SALT_TYPE_EMBEDDED;
7426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7427 opts_type = OPTS_TYPE_PT_GENERATE_BE
7428 | OPTS_TYPE_PT_ADD80
7429 | OPTS_TYPE_PT_ADDBITS15
7430 | OPTS_TYPE_PT_UNICODE
7431 | OPTS_TYPE_ST_BASE64;
7432 kern_type = KERN_TYPE_SHA1_SLTPWU;
7433 dgst_size = DGST_SIZE_4_5;
7434 parse_func = episerver_parse_hash;
7435 sort_by_digest = sort_by_digest_4_5;
7436 opti_type = OPTI_TYPE_ZERO_BYTE
7437 | OPTI_TYPE_PRECOMPUTE_INIT
7438 | OPTI_TYPE_PRECOMPUTE_MERKLE
7439 | OPTI_TYPE_EARLY_SKIP
7440 | OPTI_TYPE_NOT_ITERATED
7441 | OPTI_TYPE_PREPENDED_SALT
7442 | OPTI_TYPE_RAW_HASH;
7443 dgst_pos0 = 3;
7444 dgst_pos1 = 4;
7445 dgst_pos2 = 2;
7446 dgst_pos3 = 1;
7447 break;
7448
7449 case 150: hash_type = HASH_TYPE_SHA1;
7450 salt_type = SALT_TYPE_INTERN;
7451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7452 opts_type = OPTS_TYPE_PT_GENERATE_BE
7453 | OPTS_TYPE_ST_ADD80
7454 | OPTS_TYPE_ST_ADDBITS15;
7455 kern_type = KERN_TYPE_HMACSHA1_PW;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = hmacsha1_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_NOT_ITERATED;
7461 dgst_pos0 = 3;
7462 dgst_pos1 = 4;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 160: hash_type = HASH_TYPE_SHA1;
7468 salt_type = SALT_TYPE_INTERN;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_BE
7471 | OPTS_TYPE_PT_ADD80
7472 | OPTS_TYPE_PT_ADDBITS15;
7473 kern_type = KERN_TYPE_HMACSHA1_SLT;
7474 dgst_size = DGST_SIZE_4_5;
7475 parse_func = hmacsha1_parse_hash;
7476 sort_by_digest = sort_by_digest_4_5;
7477 opti_type = OPTI_TYPE_ZERO_BYTE
7478 | OPTI_TYPE_NOT_ITERATED;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 190: hash_type = HASH_TYPE_SHA1;
7486 salt_type = SALT_TYPE_NONE;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15;
7491 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7492 dgst_size = DGST_SIZE_4_5;
7493 parse_func = sha1linkedin_parse_hash;
7494 sort_by_digest = sort_by_digest_4_5;
7495 opti_type = OPTI_TYPE_ZERO_BYTE
7496 | OPTI_TYPE_PRECOMPUTE_INIT
7497 | OPTI_TYPE_EARLY_SKIP
7498 | OPTI_TYPE_NOT_ITERATED
7499 | OPTI_TYPE_NOT_SALTED;
7500 dgst_pos0 = 0;
7501 dgst_pos1 = 4;
7502 dgst_pos2 = 3;
7503 dgst_pos3 = 2;
7504 break;
7505
7506 case 200: hash_type = HASH_TYPE_MYSQL;
7507 salt_type = SALT_TYPE_NONE;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = 0;
7510 kern_type = KERN_TYPE_MYSQL;
7511 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7512 parse_func = mysql323_parse_hash;
7513 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7514 opti_type = OPTI_TYPE_ZERO_BYTE;
7515 dgst_pos0 = 0;
7516 dgst_pos1 = 1;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 3;
7519 break;
7520
7521 case 300: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_NONE;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15;
7527 kern_type = KERN_TYPE_MYSQL41;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = sha1_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_PRECOMPUTE_INIT
7533 | OPTI_TYPE_PRECOMPUTE_MERKLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_NOT_SALTED;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 400: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7547 kern_type = KERN_TYPE_PHPASS;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = phpass_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 1;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 3;
7556 break;
7557
7558 case 500: hash_type = HASH_TYPE_MD5;
7559 salt_type = SALT_TYPE_EMBEDDED;
7560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7562 kern_type = KERN_TYPE_MD5CRYPT;
7563 dgst_size = DGST_SIZE_4_4;
7564 parse_func = md5crypt_parse_hash;
7565 sort_by_digest = sort_by_digest_4_4;
7566 opti_type = OPTI_TYPE_ZERO_BYTE;
7567 dgst_pos0 = 0;
7568 dgst_pos1 = 1;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 3;
7571 break;
7572
7573 case 501: hash_type = HASH_TYPE_MD5;
7574 salt_type = SALT_TYPE_EMBEDDED;
7575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7576 opts_type = OPTS_TYPE_PT_GENERATE_LE
7577 | OPTS_TYPE_HASH_COPY;
7578 kern_type = KERN_TYPE_MD5CRYPT;
7579 dgst_size = DGST_SIZE_4_4;
7580 parse_func = juniper_parse_hash;
7581 sort_by_digest = sort_by_digest_4_4;
7582 opti_type = OPTI_TYPE_ZERO_BYTE;
7583 dgst_pos0 = 0;
7584 dgst_pos1 = 1;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 3;
7587 break;
7588
7589 case 900: hash_type = HASH_TYPE_MD4;
7590 salt_type = SALT_TYPE_NONE;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE
7593 | OPTS_TYPE_PT_ADD80
7594 | OPTS_TYPE_PT_ADDBITS14;
7595 kern_type = KERN_TYPE_MD4;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = md4_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE
7600 | OPTI_TYPE_PRECOMPUTE_INIT
7601 | OPTI_TYPE_PRECOMPUTE_MERKLE
7602 | OPTI_TYPE_MEET_IN_MIDDLE
7603 | OPTI_TYPE_EARLY_SKIP
7604 | OPTI_TYPE_NOT_ITERATED
7605 | OPTI_TYPE_NOT_SALTED
7606 | OPTI_TYPE_RAW_HASH;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 3;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 1;
7611 break;
7612
7613 case 1000: hash_type = HASH_TYPE_MD4;
7614 salt_type = SALT_TYPE_NONE;
7615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE
7617 | OPTS_TYPE_PT_ADD80
7618 | OPTS_TYPE_PT_ADDBITS14
7619 | OPTS_TYPE_PT_UNICODE;
7620 kern_type = KERN_TYPE_MD4_PWU;
7621 dgst_size = DGST_SIZE_4_4;
7622 parse_func = md4_parse_hash;
7623 sort_by_digest = sort_by_digest_4_4;
7624 opti_type = OPTI_TYPE_ZERO_BYTE
7625 | OPTI_TYPE_PRECOMPUTE_INIT
7626 | OPTI_TYPE_PRECOMPUTE_MERKLE
7627 | OPTI_TYPE_MEET_IN_MIDDLE
7628 | OPTI_TYPE_EARLY_SKIP
7629 | OPTI_TYPE_NOT_ITERATED
7630 | OPTI_TYPE_NOT_SALTED
7631 | OPTI_TYPE_RAW_HASH;
7632 dgst_pos0 = 0;
7633 dgst_pos1 = 3;
7634 dgst_pos2 = 2;
7635 dgst_pos3 = 1;
7636 break;
7637
7638 case 1100: hash_type = HASH_TYPE_MD4;
7639 salt_type = SALT_TYPE_INTERN;
7640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7641 opts_type = OPTS_TYPE_PT_GENERATE_LE
7642 | OPTS_TYPE_PT_ADD80
7643 | OPTS_TYPE_PT_ADDBITS14
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_UNICODE
7647 | OPTS_TYPE_ST_LOWER;
7648 kern_type = KERN_TYPE_MD44_PWUSLT;
7649 dgst_size = DGST_SIZE_4_4;
7650 parse_func = dcc_parse_hash;
7651 sort_by_digest = sort_by_digest_4_4;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 3;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 1;
7661 break;
7662
7663 case 1400: hash_type = HASH_TYPE_SHA256;
7664 salt_type = SALT_TYPE_NONE;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15;
7669 kern_type = KERN_TYPE_SHA256;
7670 dgst_size = DGST_SIZE_4_8;
7671 parse_func = sha256_parse_hash;
7672 sort_by_digest = sort_by_digest_4_8;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_EARLY_SKIP
7677 | OPTI_TYPE_NOT_ITERATED
7678 | OPTI_TYPE_NOT_SALTED
7679 | OPTI_TYPE_RAW_HASH;
7680 dgst_pos0 = 3;
7681 dgst_pos1 = 7;
7682 dgst_pos2 = 2;
7683 dgst_pos3 = 6;
7684 break;
7685
7686 case 1410: hash_type = HASH_TYPE_SHA256;
7687 salt_type = SALT_TYPE_INTERN;
7688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7689 opts_type = OPTS_TYPE_PT_GENERATE_BE
7690 | OPTS_TYPE_ST_ADD80
7691 | OPTS_TYPE_ST_ADDBITS15;
7692 kern_type = KERN_TYPE_SHA256_PWSLT;
7693 dgst_size = DGST_SIZE_4_8;
7694 parse_func = sha256s_parse_hash;
7695 sort_by_digest = sort_by_digest_4_8;
7696 opti_type = OPTI_TYPE_ZERO_BYTE
7697 | OPTI_TYPE_PRECOMPUTE_INIT
7698 | OPTI_TYPE_PRECOMPUTE_MERKLE
7699 | OPTI_TYPE_EARLY_SKIP
7700 | OPTI_TYPE_NOT_ITERATED
7701 | OPTI_TYPE_APPENDED_SALT
7702 | OPTI_TYPE_RAW_HASH;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 7;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 6;
7707 break;
7708
7709 case 1420: hash_type = HASH_TYPE_SHA256;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS15;
7715 kern_type = KERN_TYPE_SHA256_SLTPW;
7716 dgst_size = DGST_SIZE_4_8;
7717 parse_func = sha256s_parse_hash;
7718 sort_by_digest = sort_by_digest_4_8;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_PRECOMPUTE_INIT
7721 | OPTI_TYPE_PRECOMPUTE_MERKLE
7722 | OPTI_TYPE_EARLY_SKIP
7723 | OPTI_TYPE_NOT_ITERATED
7724 | OPTI_TYPE_PREPENDED_SALT
7725 | OPTI_TYPE_RAW_HASH;
7726 dgst_pos0 = 3;
7727 dgst_pos1 = 7;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 6;
7730 break;
7731
7732 case 1421: hash_type = HASH_TYPE_SHA256;
7733 salt_type = SALT_TYPE_EMBEDDED;
7734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7735 opts_type = OPTS_TYPE_PT_GENERATE_BE
7736 | OPTS_TYPE_PT_ADD80
7737 | OPTS_TYPE_PT_ADDBITS15;
7738 kern_type = KERN_TYPE_SHA256_SLTPW;
7739 dgst_size = DGST_SIZE_4_8;
7740 parse_func = hmailserver_parse_hash;
7741 sort_by_digest = sort_by_digest_4_8;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED
7747 | OPTI_TYPE_PREPENDED_SALT
7748 | OPTI_TYPE_RAW_HASH;
7749 dgst_pos0 = 3;
7750 dgst_pos1 = 7;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 6;
7753 break;
7754
7755 case 1430: hash_type = HASH_TYPE_SHA256;
7756 salt_type = SALT_TYPE_INTERN;
7757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_BE
7759 | OPTS_TYPE_PT_UNICODE
7760 | OPTS_TYPE_ST_ADD80
7761 | OPTS_TYPE_ST_ADDBITS15;
7762 kern_type = KERN_TYPE_SHA256_PWUSLT;
7763 dgst_size = DGST_SIZE_4_8;
7764 parse_func = sha256s_parse_hash;
7765 sort_by_digest = sort_by_digest_4_8;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_PRECOMPUTE_INIT
7768 | OPTI_TYPE_PRECOMPUTE_MERKLE
7769 | OPTI_TYPE_EARLY_SKIP
7770 | OPTI_TYPE_NOT_ITERATED
7771 | OPTI_TYPE_APPENDED_SALT
7772 | OPTI_TYPE_RAW_HASH;
7773 dgst_pos0 = 3;
7774 dgst_pos1 = 7;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 6;
7777 break;
7778
7779 case 1440: hash_type = HASH_TYPE_SHA256;
7780 salt_type = SALT_TYPE_INTERN;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_BE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS15
7785 | OPTS_TYPE_PT_UNICODE;
7786 kern_type = KERN_TYPE_SHA256_SLTPWU;
7787 dgst_size = DGST_SIZE_4_8;
7788 parse_func = sha256s_parse_hash;
7789 sort_by_digest = sort_by_digest_4_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_PREPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 7;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 6;
7801 break;
7802
7803 case 1441: hash_type = HASH_TYPE_SHA256;
7804 salt_type = SALT_TYPE_EMBEDDED;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_PT_ADD80
7808 | OPTS_TYPE_PT_ADDBITS15
7809 | OPTS_TYPE_PT_UNICODE
7810 | OPTS_TYPE_ST_BASE64;
7811 kern_type = KERN_TYPE_SHA256_SLTPWU;
7812 dgst_size = DGST_SIZE_4_8;
7813 parse_func = episerver4_parse_hash;
7814 sort_by_digest = sort_by_digest_4_8;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_PREPENDED_SALT
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 3;
7823 dgst_pos1 = 7;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 6;
7826 break;
7827
7828 case 1450: hash_type = HASH_TYPE_SHA256;
7829 salt_type = SALT_TYPE_INTERN;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_ST_ADD80;
7833 kern_type = KERN_TYPE_HMACSHA256_PW;
7834 dgst_size = DGST_SIZE_4_8;
7835 parse_func = hmacsha256_parse_hash;
7836 sort_by_digest = sort_by_digest_4_8;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_NOT_ITERATED;
7839 dgst_pos0 = 3;
7840 dgst_pos1 = 7;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 6;
7843 break;
7844
7845 case 1460: hash_type = HASH_TYPE_SHA256;
7846 salt_type = SALT_TYPE_INTERN;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_ADD80
7850 | OPTS_TYPE_PT_ADDBITS15;
7851 kern_type = KERN_TYPE_HMACSHA256_SLT;
7852 dgst_size = DGST_SIZE_4_8;
7853 parse_func = hmacsha256_parse_hash;
7854 sort_by_digest = sort_by_digest_4_8;
7855 opti_type = OPTI_TYPE_ZERO_BYTE
7856 | OPTI_TYPE_NOT_ITERATED;
7857 dgst_pos0 = 3;
7858 dgst_pos1 = 7;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 6;
7861 break;
7862
7863 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_LE
7867 | OPTS_TYPE_PT_BITSLICE;
7868 kern_type = KERN_TYPE_DESCRYPT;
7869 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7870 parse_func = descrypt_parse_hash;
7871 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7874 dgst_pos0 = 0;
7875 dgst_pos1 = 1;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 3;
7878 break;
7879
7880 case 1600: hash_type = HASH_TYPE_MD5;
7881 salt_type = SALT_TYPE_EMBEDDED;
7882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7884 kern_type = KERN_TYPE_APR1CRYPT;
7885 dgst_size = DGST_SIZE_4_4;
7886 parse_func = md5apr1_parse_hash;
7887 sort_by_digest = sort_by_digest_4_4;
7888 opti_type = OPTI_TYPE_ZERO_BYTE;
7889 dgst_pos0 = 0;
7890 dgst_pos1 = 1;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 3;
7893 break;
7894
7895 case 1700: hash_type = HASH_TYPE_SHA512;
7896 salt_type = SALT_TYPE_NONE;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_BE
7899 | OPTS_TYPE_PT_ADD80
7900 | OPTS_TYPE_PT_ADDBITS15;
7901 kern_type = KERN_TYPE_SHA512;
7902 dgst_size = DGST_SIZE_8_8;
7903 parse_func = sha512_parse_hash;
7904 sort_by_digest = sort_by_digest_8_8;
7905 opti_type = OPTI_TYPE_ZERO_BYTE
7906 | OPTI_TYPE_PRECOMPUTE_INIT
7907 | OPTI_TYPE_PRECOMPUTE_MERKLE
7908 | OPTI_TYPE_EARLY_SKIP
7909 | OPTI_TYPE_NOT_ITERATED
7910 | OPTI_TYPE_NOT_SALTED
7911 | OPTI_TYPE_USES_BITS_64
7912 | OPTI_TYPE_RAW_HASH;
7913 dgst_pos0 = 14;
7914 dgst_pos1 = 15;
7915 dgst_pos2 = 6;
7916 dgst_pos3 = 7;
7917 break;
7918
7919 case 1710: hash_type = HASH_TYPE_SHA512;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_ST_ADD80
7924 | OPTS_TYPE_ST_ADDBITS15;
7925 kern_type = KERN_TYPE_SHA512_PWSLT;
7926 dgst_size = DGST_SIZE_8_8;
7927 parse_func = sha512s_parse_hash;
7928 sort_by_digest = sort_by_digest_8_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_PRECOMPUTE_INIT
7931 | OPTI_TYPE_PRECOMPUTE_MERKLE
7932 | OPTI_TYPE_EARLY_SKIP
7933 | OPTI_TYPE_NOT_ITERATED
7934 | OPTI_TYPE_APPENDED_SALT
7935 | OPTI_TYPE_USES_BITS_64
7936 | OPTI_TYPE_RAW_HASH;
7937 dgst_pos0 = 14;
7938 dgst_pos1 = 15;
7939 dgst_pos2 = 6;
7940 dgst_pos3 = 7;
7941 break;
7942
7943 case 1711: hash_type = HASH_TYPE_SHA512;
7944 salt_type = SALT_TYPE_EMBEDDED;
7945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7946 opts_type = OPTS_TYPE_PT_GENERATE_BE
7947 | OPTS_TYPE_ST_ADD80
7948 | OPTS_TYPE_ST_ADDBITS15;
7949 kern_type = KERN_TYPE_SHA512_PWSLT;
7950 dgst_size = DGST_SIZE_8_8;
7951 parse_func = sha512b64s_parse_hash;
7952 sort_by_digest = sort_by_digest_8_8;
7953 opti_type = OPTI_TYPE_ZERO_BYTE
7954 | OPTI_TYPE_PRECOMPUTE_INIT
7955 | OPTI_TYPE_PRECOMPUTE_MERKLE
7956 | OPTI_TYPE_EARLY_SKIP
7957 | OPTI_TYPE_NOT_ITERATED
7958 | OPTI_TYPE_APPENDED_SALT
7959 | OPTI_TYPE_USES_BITS_64
7960 | OPTI_TYPE_RAW_HASH;
7961 dgst_pos0 = 14;
7962 dgst_pos1 = 15;
7963 dgst_pos2 = 6;
7964 dgst_pos3 = 7;
7965 break;
7966
7967 case 1720: hash_type = HASH_TYPE_SHA512;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_PT_ADD80
7972 | OPTS_TYPE_PT_ADDBITS15;
7973 kern_type = KERN_TYPE_SHA512_SLTPW;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = sha512s_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_PREPENDED_SALT
7983 | OPTI_TYPE_USES_BITS_64
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 14;
7986 dgst_pos1 = 15;
7987 dgst_pos2 = 6;
7988 dgst_pos3 = 7;
7989 break;
7990
7991 case 1722: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_EMBEDDED;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_ADD80
7996 | OPTS_TYPE_PT_ADDBITS15
7997 | OPTS_TYPE_ST_HEX;
7998 kern_type = KERN_TYPE_SHA512_SLTPW;
7999 dgst_size = DGST_SIZE_8_8;
8000 parse_func = osx512_parse_hash;
8001 sort_by_digest = sort_by_digest_8_8;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_PREPENDED_SALT
8008 | OPTI_TYPE_USES_BITS_64
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 14;
8011 dgst_pos1 = 15;
8012 dgst_pos2 = 6;
8013 dgst_pos3 = 7;
8014 break;
8015
8016 case 1730: hash_type = HASH_TYPE_SHA512;
8017 salt_type = SALT_TYPE_INTERN;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA512_PWSLTU;
8024 dgst_size = DGST_SIZE_8_8;
8025 parse_func = sha512s_parse_hash;
8026 sort_by_digest = sort_by_digest_8_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_USES_BITS_64
8034 | OPTI_TYPE_RAW_HASH;
8035 dgst_pos0 = 14;
8036 dgst_pos1 = 15;
8037 dgst_pos2 = 6;
8038 dgst_pos3 = 7;
8039 break;
8040
8041 case 1731: hash_type = HASH_TYPE_SHA512;
8042 salt_type = SALT_TYPE_EMBEDDED;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_BE
8045 | OPTS_TYPE_PT_UNICODE
8046 | OPTS_TYPE_ST_ADD80
8047 | OPTS_TYPE_ST_ADDBITS15
8048 | OPTS_TYPE_ST_HEX;
8049 kern_type = KERN_TYPE_SHA512_PWSLTU;
8050 dgst_size = DGST_SIZE_8_8;
8051 parse_func = mssql2012_parse_hash;
8052 sort_by_digest = sort_by_digest_8_8;
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_INIT
8055 | OPTI_TYPE_PRECOMPUTE_MERKLE
8056 | OPTI_TYPE_EARLY_SKIP
8057 | OPTI_TYPE_NOT_ITERATED
8058 | OPTI_TYPE_APPENDED_SALT
8059 | OPTI_TYPE_USES_BITS_64
8060 | OPTI_TYPE_RAW_HASH;
8061 dgst_pos0 = 14;
8062 dgst_pos1 = 15;
8063 dgst_pos2 = 6;
8064 dgst_pos3 = 7;
8065 break;
8066
8067 case 1740: hash_type = HASH_TYPE_SHA512;
8068 salt_type = SALT_TYPE_INTERN;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_BE
8071 | OPTS_TYPE_PT_ADD80
8072 | OPTS_TYPE_PT_ADDBITS15
8073 | OPTS_TYPE_PT_UNICODE;
8074 kern_type = KERN_TYPE_SHA512_SLTPWU;
8075 dgst_size = DGST_SIZE_8_8;
8076 parse_func = sha512s_parse_hash;
8077 sort_by_digest = sort_by_digest_8_8;
8078 opti_type = OPTI_TYPE_ZERO_BYTE
8079 | OPTI_TYPE_PRECOMPUTE_INIT
8080 | OPTI_TYPE_PRECOMPUTE_MERKLE
8081 | OPTI_TYPE_EARLY_SKIP
8082 | OPTI_TYPE_NOT_ITERATED
8083 | OPTI_TYPE_PREPENDED_SALT
8084 | OPTI_TYPE_USES_BITS_64
8085 | OPTI_TYPE_RAW_HASH;
8086 dgst_pos0 = 14;
8087 dgst_pos1 = 15;
8088 dgst_pos2 = 6;
8089 dgst_pos3 = 7;
8090 break;
8091
8092 case 1750: hash_type = HASH_TYPE_SHA512;
8093 salt_type = SALT_TYPE_INTERN;
8094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_BE
8096 | OPTS_TYPE_ST_ADD80;
8097 kern_type = KERN_TYPE_HMACSHA512_PW;
8098 dgst_size = DGST_SIZE_8_8;
8099 parse_func = hmacsha512_parse_hash;
8100 sort_by_digest = sort_by_digest_8_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_USES_BITS_64
8103 | OPTI_TYPE_NOT_ITERATED;
8104 dgst_pos0 = 14;
8105 dgst_pos1 = 15;
8106 dgst_pos2 = 6;
8107 dgst_pos3 = 7;
8108 break;
8109
8110 case 1760: hash_type = HASH_TYPE_SHA512;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_HMACSHA512_SLT;
8117 dgst_size = DGST_SIZE_8_8;
8118 parse_func = hmacsha512_parse_hash;
8119 sort_by_digest = sort_by_digest_8_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_USES_BITS_64
8122 | OPTI_TYPE_NOT_ITERATED;
8123 dgst_pos0 = 14;
8124 dgst_pos1 = 15;
8125 dgst_pos2 = 6;
8126 dgst_pos3 = 7;
8127 break;
8128
8129 case 1800: hash_type = HASH_TYPE_SHA512;
8130 salt_type = SALT_TYPE_EMBEDDED;
8131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8133 kern_type = KERN_TYPE_SHA512CRYPT;
8134 dgst_size = DGST_SIZE_8_8;
8135 parse_func = sha512crypt_parse_hash;
8136 sort_by_digest = sort_by_digest_8_8;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_USES_BITS_64;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 1;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 3;
8143 break;
8144
8145 case 2100: hash_type = HASH_TYPE_DCC2;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8149 | OPTS_TYPE_ST_LOWER
8150 | OPTS_TYPE_ST_UNICODE;
8151 kern_type = KERN_TYPE_DCC2;
8152 dgst_size = DGST_SIZE_4_4;
8153 parse_func = dcc2_parse_hash;
8154 sort_by_digest = sort_by_digest_4_4;
8155 opti_type = OPTI_TYPE_ZERO_BYTE;
8156 dgst_pos0 = 0;
8157 dgst_pos1 = 1;
8158 dgst_pos2 = 2;
8159 dgst_pos3 = 3;
8160 break;
8161
8162 case 2400: hash_type = HASH_TYPE_MD5;
8163 salt_type = SALT_TYPE_NONE;
8164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8166 kern_type = KERN_TYPE_MD5PIX;
8167 dgst_size = DGST_SIZE_4_4;
8168 parse_func = md5pix_parse_hash;
8169 sort_by_digest = sort_by_digest_4_4;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_PRECOMPUTE_INIT
8172 | OPTI_TYPE_PRECOMPUTE_MERKLE
8173 | OPTI_TYPE_EARLY_SKIP
8174 | OPTI_TYPE_NOT_ITERATED
8175 | OPTI_TYPE_NOT_SALTED;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 3;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 1;
8180 break;
8181
8182 case 2410: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8186 kern_type = KERN_TYPE_MD5ASA;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = md5asa_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP
8194 | OPTI_TYPE_NOT_ITERATED;
8195 dgst_pos0 = 0;
8196 dgst_pos1 = 3;
8197 dgst_pos2 = 2;
8198 dgst_pos3 = 1;
8199 break;
8200
8201 case 2500: hash_type = HASH_TYPE_WPA;
8202 salt_type = SALT_TYPE_EMBEDDED;
8203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8205 kern_type = KERN_TYPE_WPA;
8206 dgst_size = DGST_SIZE_4_4;
8207 parse_func = wpa_parse_hash;
8208 sort_by_digest = sort_by_digest_4_4;
8209 opti_type = OPTI_TYPE_ZERO_BYTE;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 1;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 3;
8214 break;
8215
8216 case 2600: hash_type = HASH_TYPE_MD5;
8217 salt_type = SALT_TYPE_VIRTUAL;
8218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE
8220 | OPTS_TYPE_PT_ADD80
8221 | OPTS_TYPE_PT_ADDBITS14
8222 | OPTS_TYPE_ST_ADD80;
8223 kern_type = KERN_TYPE_MD55_PWSLT1;
8224 dgst_size = DGST_SIZE_4_4;
8225 parse_func = md5md5_parse_hash;
8226 sort_by_digest = sort_by_digest_4_4;
8227 opti_type = OPTI_TYPE_ZERO_BYTE
8228 | OPTI_TYPE_PRECOMPUTE_INIT
8229 | OPTI_TYPE_PRECOMPUTE_MERKLE
8230 | OPTI_TYPE_EARLY_SKIP;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 3;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 1;
8235 break;
8236
8237 case 2611: hash_type = HASH_TYPE_MD5;
8238 salt_type = SALT_TYPE_INTERN;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS14
8243 | OPTS_TYPE_ST_ADD80;
8244 kern_type = KERN_TYPE_MD55_PWSLT1;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = vb3_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_EARLY_SKIP;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 2612: hash_type = HASH_TYPE_MD5;
8259 salt_type = SALT_TYPE_EMBEDDED;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE
8262 | OPTS_TYPE_PT_ADD80
8263 | OPTS_TYPE_PT_ADDBITS14
8264 | OPTS_TYPE_ST_ADD80
8265 | OPTS_TYPE_ST_HEX;
8266 kern_type = KERN_TYPE_MD55_PWSLT1;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = phps_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP;
8274 dgst_pos0 = 0;
8275 dgst_pos1 = 3;
8276 dgst_pos2 = 2;
8277 dgst_pos3 = 1;
8278 break;
8279
8280 case 2711: hash_type = HASH_TYPE_MD5;
8281 salt_type = SALT_TYPE_INTERN;
8282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8283 opts_type = OPTS_TYPE_PT_GENERATE_LE
8284 | OPTS_TYPE_PT_ADD80
8285 | OPTS_TYPE_PT_ADDBITS14
8286 | OPTS_TYPE_ST_ADD80;
8287 kern_type = KERN_TYPE_MD55_PWSLT2;
8288 dgst_size = DGST_SIZE_4_4;
8289 parse_func = vb30_parse_hash;
8290 sort_by_digest = sort_by_digest_4_4;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_PRECOMPUTE_INIT
8293 | OPTI_TYPE_EARLY_SKIP;
8294 dgst_pos0 = 0;
8295 dgst_pos1 = 3;
8296 dgst_pos2 = 2;
8297 dgst_pos3 = 1;
8298 break;
8299
8300 case 2811: hash_type = HASH_TYPE_MD5;
8301 salt_type = SALT_TYPE_INTERN;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_LE
8304 | OPTS_TYPE_PT_ADD80
8305 | OPTS_TYPE_PT_ADDBITS14;
8306 kern_type = KERN_TYPE_MD55_SLTPW;
8307 dgst_size = DGST_SIZE_4_4;
8308 parse_func = ipb2_parse_hash;
8309 sort_by_digest = sort_by_digest_4_4;
8310 opti_type = OPTI_TYPE_ZERO_BYTE
8311 | OPTI_TYPE_PRECOMPUTE_INIT
8312 | OPTI_TYPE_EARLY_SKIP;
8313 dgst_pos0 = 0;
8314 dgst_pos1 = 3;
8315 dgst_pos2 = 2;
8316 dgst_pos3 = 1;
8317 break;
8318
8319 case 3000: hash_type = HASH_TYPE_LM;
8320 salt_type = SALT_TYPE_NONE;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_LE
8323 | OPTS_TYPE_PT_UPPER
8324 | OPTS_TYPE_PT_BITSLICE;
8325 kern_type = KERN_TYPE_LM;
8326 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8327 parse_func = lm_parse_hash;
8328 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8329 opti_type = OPTI_TYPE_ZERO_BYTE
8330 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8331 dgst_pos0 = 0;
8332 dgst_pos1 = 1;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 3;
8335 break;
8336
8337 case 3100: hash_type = HASH_TYPE_ORACLEH;
8338 salt_type = SALT_TYPE_INTERN;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_LE
8341 | OPTS_TYPE_PT_UPPER
8342 | OPTS_TYPE_ST_UPPER;
8343 kern_type = KERN_TYPE_ORACLEH;
8344 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8345 parse_func = oracleh_parse_hash;
8346 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8347 opti_type = OPTI_TYPE_ZERO_BYTE;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 1;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 3;
8352 break;
8353
8354 case 3200: hash_type = HASH_TYPE_BCRYPT;
8355 salt_type = SALT_TYPE_EMBEDDED;
8356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_ST_GENERATE_LE;
8359 kern_type = KERN_TYPE_BCRYPT;
8360 dgst_size = DGST_SIZE_4_6;
8361 parse_func = bcrypt_parse_hash;
8362 sort_by_digest = sort_by_digest_4_6;
8363 opti_type = OPTI_TYPE_ZERO_BYTE;
8364 dgst_pos0 = 0;
8365 dgst_pos1 = 1;
8366 dgst_pos2 = 2;
8367 dgst_pos3 = 3;
8368 break;
8369
8370 case 3710: hash_type = HASH_TYPE_MD5;
8371 salt_type = SALT_TYPE_INTERN;
8372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8373 opts_type = OPTS_TYPE_PT_GENERATE_LE
8374 | OPTS_TYPE_PT_ADD80
8375 | OPTS_TYPE_PT_ADDBITS14;
8376 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8377 dgst_size = DGST_SIZE_4_4;
8378 parse_func = md5s_parse_hash;
8379 sort_by_digest = sort_by_digest_4_4;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_PRECOMPUTE_INIT
8382 | OPTI_TYPE_PRECOMPUTE_MERKLE
8383 | OPTI_TYPE_EARLY_SKIP;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 3;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 1;
8388 break;
8389
8390 case 3711: hash_type = HASH_TYPE_MD5;
8391 salt_type = SALT_TYPE_EMBEDDED;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80
8395 | OPTS_TYPE_PT_ADDBITS14;
8396 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = mediawiki_b_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_INIT
8402 | OPTI_TYPE_PRECOMPUTE_MERKLE
8403 | OPTI_TYPE_EARLY_SKIP;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 3;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 1;
8408 break;
8409
8410 case 3800: hash_type = HASH_TYPE_MD5;
8411 salt_type = SALT_TYPE_INTERN;
8412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE
8414 | OPTS_TYPE_ST_ADDBITS14;
8415 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8416 dgst_size = DGST_SIZE_4_4;
8417 parse_func = md5s_parse_hash;
8418 sort_by_digest = sort_by_digest_4_4;
8419 opti_type = OPTI_TYPE_ZERO_BYTE
8420 | OPTI_TYPE_PRECOMPUTE_INIT
8421 | OPTI_TYPE_PRECOMPUTE_MERKLE
8422 | OPTI_TYPE_EARLY_SKIP
8423 | OPTI_TYPE_NOT_ITERATED
8424 | OPTI_TYPE_RAW_HASH;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 3;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 1;
8429 break;
8430
8431 case 4300: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_VIRTUAL;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS14
8437 | OPTS_TYPE_ST_ADD80;
8438 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8439 dgst_size = DGST_SIZE_4_4;
8440 parse_func = md5md5_parse_hash;
8441 sort_by_digest = sort_by_digest_4_4;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_PRECOMPUTE_INIT
8444 | OPTI_TYPE_PRECOMPUTE_MERKLE
8445 | OPTI_TYPE_EARLY_SKIP;
8446 dgst_pos0 = 0;
8447 dgst_pos1 = 3;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 1;
8450 break;
8451
8452
8453 case 4400: hash_type = HASH_TYPE_MD5;
8454 salt_type = SALT_TYPE_NONE;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_BE
8457 | OPTS_TYPE_PT_ADD80
8458 | OPTS_TYPE_PT_ADDBITS15;
8459 kern_type = KERN_TYPE_MD5_SHA1;
8460 dgst_size = DGST_SIZE_4_4;
8461 parse_func = md5_parse_hash;
8462 sort_by_digest = sort_by_digest_4_4;
8463 opti_type = OPTI_TYPE_ZERO_BYTE
8464 | OPTI_TYPE_PRECOMPUTE_INIT
8465 | OPTI_TYPE_PRECOMPUTE_MERKLE
8466 | OPTI_TYPE_EARLY_SKIP
8467 | OPTI_TYPE_NOT_ITERATED
8468 | OPTI_TYPE_NOT_SALTED
8469 | OPTI_TYPE_RAW_HASH;
8470 dgst_pos0 = 0;
8471 dgst_pos1 = 3;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 1;
8474 break;
8475
8476 case 4500: hash_type = HASH_TYPE_SHA1;
8477 salt_type = SALT_TYPE_NONE;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_BE
8480 | OPTS_TYPE_PT_ADD80
8481 | OPTS_TYPE_PT_ADDBITS15;
8482 kern_type = KERN_TYPE_SHA11;
8483 dgst_size = DGST_SIZE_4_5;
8484 parse_func = sha1_parse_hash;
8485 sort_by_digest = sort_by_digest_4_5;
8486 opti_type = OPTI_TYPE_ZERO_BYTE
8487 | OPTI_TYPE_PRECOMPUTE_INIT
8488 | OPTI_TYPE_PRECOMPUTE_MERKLE
8489 | OPTI_TYPE_EARLY_SKIP
8490 | OPTI_TYPE_NOT_SALTED;
8491 dgst_pos0 = 3;
8492 dgst_pos1 = 4;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 4700: hash_type = HASH_TYPE_SHA1;
8498 salt_type = SALT_TYPE_NONE;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_PT_ADD80
8502 | OPTS_TYPE_PT_ADDBITS14;
8503 kern_type = KERN_TYPE_SHA1_MD5;
8504 dgst_size = DGST_SIZE_4_5;
8505 parse_func = sha1_parse_hash;
8506 sort_by_digest = sort_by_digest_4_5;
8507 opti_type = OPTI_TYPE_ZERO_BYTE
8508 | OPTI_TYPE_PRECOMPUTE_INIT
8509 | OPTI_TYPE_PRECOMPUTE_MERKLE
8510 | OPTI_TYPE_EARLY_SKIP
8511 | OPTI_TYPE_NOT_ITERATED
8512 | OPTI_TYPE_NOT_SALTED
8513 | OPTI_TYPE_RAW_HASH;
8514 dgst_pos0 = 3;
8515 dgst_pos1 = 4;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 1;
8518 break;
8519
8520 case 4800: hash_type = HASH_TYPE_MD5;
8521 salt_type = SALT_TYPE_EMBEDDED;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_LE
8524 | OPTS_TYPE_PT_ADDBITS14;
8525 kern_type = KERN_TYPE_MD5_CHAP;
8526 dgst_size = DGST_SIZE_4_4;
8527 parse_func = chap_parse_hash;
8528 sort_by_digest = sort_by_digest_4_4;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_MEET_IN_MIDDLE
8533 | OPTI_TYPE_EARLY_SKIP
8534 | OPTI_TYPE_NOT_ITERATED
8535 | OPTI_TYPE_RAW_HASH;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 3;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 1;
8540 break;
8541
8542 case 4900: hash_type = HASH_TYPE_SHA1;
8543 salt_type = SALT_TYPE_INTERN;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8546 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8547 dgst_size = DGST_SIZE_4_5;
8548 parse_func = sha1s_parse_hash;
8549 sort_by_digest = sort_by_digest_4_5;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_PRECOMPUTE_INIT
8552 | OPTI_TYPE_PRECOMPUTE_MERKLE
8553 | OPTI_TYPE_EARLY_SKIP;
8554 dgst_pos0 = 3;
8555 dgst_pos1 = 4;
8556 dgst_pos2 = 2;
8557 dgst_pos3 = 1;
8558 break;
8559
8560 case 5000: hash_type = HASH_TYPE_KECCAK;
8561 salt_type = SALT_TYPE_EMBEDDED;
8562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8563 opts_type = OPTS_TYPE_PT_GENERATE_LE
8564 | OPTS_TYPE_PT_ADD01;
8565 kern_type = KERN_TYPE_KECCAK;
8566 dgst_size = DGST_SIZE_8_25;
8567 parse_func = keccak_parse_hash;
8568 sort_by_digest = sort_by_digest_8_25;
8569 opti_type = OPTI_TYPE_ZERO_BYTE
8570 | OPTI_TYPE_USES_BITS_64
8571 | OPTI_TYPE_RAW_HASH;
8572 dgst_pos0 = 2;
8573 dgst_pos1 = 3;
8574 dgst_pos2 = 4;
8575 dgst_pos3 = 5;
8576 break;
8577
8578 case 5100: hash_type = HASH_TYPE_MD5H;
8579 salt_type = SALT_TYPE_NONE;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE
8582 | OPTS_TYPE_PT_ADD80
8583 | OPTS_TYPE_PT_ADDBITS14;
8584 kern_type = KERN_TYPE_MD5H;
8585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8586 parse_func = md5half_parse_hash;
8587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8588 opti_type = OPTI_TYPE_ZERO_BYTE
8589 | OPTI_TYPE_RAW_HASH;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 1;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 3;
8594 break;
8595
8596 case 5200: hash_type = HASH_TYPE_SHA256;
8597 salt_type = SALT_TYPE_EMBEDDED;
8598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8600 kern_type = KERN_TYPE_PSAFE3;
8601 dgst_size = DGST_SIZE_4_8;
8602 parse_func = psafe3_parse_hash;
8603 sort_by_digest = sort_by_digest_4_8;
8604 opti_type = OPTI_TYPE_ZERO_BYTE;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 1;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 3;
8609 break;
8610
8611 case 5300: hash_type = HASH_TYPE_MD5;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_ST_ADD80;
8616 kern_type = KERN_TYPE_IKEPSK_MD5;
8617 dgst_size = DGST_SIZE_4_4;
8618 parse_func = ikepsk_md5_parse_hash;
8619 sort_by_digest = sort_by_digest_4_4;
8620 opti_type = OPTI_TYPE_ZERO_BYTE;
8621 dgst_pos0 = 0;
8622 dgst_pos1 = 3;
8623 dgst_pos2 = 2;
8624 dgst_pos3 = 1;
8625 break;
8626
8627 case 5400: hash_type = HASH_TYPE_SHA1;
8628 salt_type = SALT_TYPE_EMBEDDED;
8629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8630 opts_type = OPTS_TYPE_PT_GENERATE_BE
8631 | OPTS_TYPE_ST_ADD80;
8632 kern_type = KERN_TYPE_IKEPSK_SHA1;
8633 dgst_size = DGST_SIZE_4_5;
8634 parse_func = ikepsk_sha1_parse_hash;
8635 sort_by_digest = sort_by_digest_4_5;
8636 opti_type = OPTI_TYPE_ZERO_BYTE;
8637 dgst_pos0 = 3;
8638 dgst_pos1 = 4;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 1;
8641 break;
8642
8643 case 5500: hash_type = HASH_TYPE_NETNTLM;
8644 salt_type = SALT_TYPE_EMBEDDED;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS14
8649 | OPTS_TYPE_PT_UNICODE
8650 | OPTS_TYPE_ST_HEX;
8651 kern_type = KERN_TYPE_NETNTLMv1;
8652 dgst_size = DGST_SIZE_4_4;
8653 parse_func = netntlmv1_parse_hash;
8654 sort_by_digest = sort_by_digest_4_4;
8655 opti_type = OPTI_TYPE_ZERO_BYTE
8656 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8657 dgst_pos0 = 0;
8658 dgst_pos1 = 1;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 3;
8661 break;
8662
8663 case 5600: hash_type = HASH_TYPE_MD5;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS14
8669 | OPTS_TYPE_PT_UNICODE;
8670 kern_type = KERN_TYPE_NETNTLMv2;
8671 dgst_size = DGST_SIZE_4_4;
8672 parse_func = netntlmv2_parse_hash;
8673 sort_by_digest = sort_by_digest_4_4;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 3;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 1;
8679 break;
8680
8681 case 5700: hash_type = HASH_TYPE_SHA256;
8682 salt_type = SALT_TYPE_NONE;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_BE
8685 | OPTS_TYPE_PT_ADD80
8686 | OPTS_TYPE_PT_ADDBITS15;
8687 kern_type = KERN_TYPE_SHA256;
8688 dgst_size = DGST_SIZE_4_8;
8689 parse_func = cisco4_parse_hash;
8690 sort_by_digest = sort_by_digest_4_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_PRECOMPUTE_INIT
8693 | OPTI_TYPE_PRECOMPUTE_MERKLE
8694 | OPTI_TYPE_EARLY_SKIP
8695 | OPTI_TYPE_NOT_ITERATED
8696 | OPTI_TYPE_NOT_SALTED
8697 | OPTI_TYPE_RAW_HASH;
8698 dgst_pos0 = 3;
8699 dgst_pos1 = 7;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 6;
8702 break;
8703
8704 case 5800: hash_type = HASH_TYPE_SHA1;
8705 salt_type = SALT_TYPE_INTERN;
8706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8708 | OPTS_TYPE_ST_ADD80;
8709 kern_type = KERN_TYPE_ANDROIDPIN;
8710 dgst_size = DGST_SIZE_4_5;
8711 parse_func = androidpin_parse_hash;
8712 sort_by_digest = sort_by_digest_4_5;
8713 opti_type = OPTI_TYPE_ZERO_BYTE;
8714 dgst_pos0 = 0;
8715 dgst_pos1 = 1;
8716 dgst_pos2 = 2;
8717 dgst_pos3 = 3;
8718 break;
8719
8720 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8721 salt_type = SALT_TYPE_NONE;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_LE
8724 | OPTS_TYPE_PT_ADD80;
8725 kern_type = KERN_TYPE_RIPEMD160;
8726 dgst_size = DGST_SIZE_4_5;
8727 parse_func = ripemd160_parse_hash;
8728 sort_by_digest = sort_by_digest_4_5;
8729 opti_type = OPTI_TYPE_ZERO_BYTE;
8730 dgst_pos0 = 0;
8731 dgst_pos1 = 1;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 3;
8734 break;
8735
8736 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8737 salt_type = SALT_TYPE_NONE;
8738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_BE
8740 | OPTS_TYPE_PT_ADD80;
8741 kern_type = KERN_TYPE_WHIRLPOOL;
8742 dgst_size = DGST_SIZE_4_16;
8743 parse_func = whirlpool_parse_hash;
8744 sort_by_digest = sort_by_digest_4_16;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8756 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8757 dgst_size = DGST_SIZE_4_5;
8758 parse_func = truecrypt_parse_hash_2k;
8759 sort_by_digest = sort_by_digest_4_5;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8771 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8772 dgst_size = DGST_SIZE_4_5;
8773 parse_func = truecrypt_parse_hash_2k;
8774 sort_by_digest = sort_by_digest_4_5;
8775 opti_type = OPTI_TYPE_ZERO_BYTE;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8786 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = truecrypt_parse_hash_2k;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6221: hash_type = HASH_TYPE_SHA512;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8801 kern_type = KERN_TYPE_TCSHA512_XTS512;
8802 dgst_size = DGST_SIZE_8_8;
8803 parse_func = truecrypt_parse_hash_1k;
8804 sort_by_digest = sort_by_digest_8_8;
8805 opti_type = OPTI_TYPE_ZERO_BYTE
8806 | OPTI_TYPE_USES_BITS_64;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6222: hash_type = HASH_TYPE_SHA512;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8817 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8818 dgst_size = DGST_SIZE_8_8;
8819 parse_func = truecrypt_parse_hash_1k;
8820 sort_by_digest = sort_by_digest_8_8;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_USES_BITS_64;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 6223: hash_type = HASH_TYPE_SHA512;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8833 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8834 dgst_size = DGST_SIZE_8_8;
8835 parse_func = truecrypt_parse_hash_1k;
8836 sort_by_digest = sort_by_digest_8_8;
8837 opti_type = OPTI_TYPE_ZERO_BYTE
8838 | OPTI_TYPE_USES_BITS_64;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8849 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8850 dgst_size = DGST_SIZE_4_8;
8851 parse_func = truecrypt_parse_hash_1k;
8852 sort_by_digest = sort_by_digest_4_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8864 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8865 dgst_size = DGST_SIZE_4_8;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_4_8;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8879 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8880 dgst_size = DGST_SIZE_4_8;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_4_8;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8894 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8895 dgst_size = DGST_SIZE_4_5;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_4_5;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8909 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8910 dgst_size = DGST_SIZE_4_5;
8911 parse_func = truecrypt_parse_hash_1k;
8912 sort_by_digest = sort_by_digest_4_5;
8913 opti_type = OPTI_TYPE_ZERO_BYTE;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8924 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = truecrypt_parse_hash_1k;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 0;
8930 dgst_pos1 = 1;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 3;
8933 break;
8934
8935 case 6300: hash_type = HASH_TYPE_MD5;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8939 kern_type = KERN_TYPE_MD5AIX;
8940 dgst_size = DGST_SIZE_4_4;
8941 parse_func = md5aix_parse_hash;
8942 sort_by_digest = sort_by_digest_4_4;
8943 opti_type = OPTI_TYPE_ZERO_BYTE;
8944 dgst_pos0 = 0;
8945 dgst_pos1 = 1;
8946 dgst_pos2 = 2;
8947 dgst_pos3 = 3;
8948 break;
8949
8950 case 6400: hash_type = HASH_TYPE_SHA256;
8951 salt_type = SALT_TYPE_EMBEDDED;
8952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8954 kern_type = KERN_TYPE_SHA256AIX;
8955 dgst_size = DGST_SIZE_4_8;
8956 parse_func = sha256aix_parse_hash;
8957 sort_by_digest = sort_by_digest_4_8;
8958 opti_type = OPTI_TYPE_ZERO_BYTE;
8959 dgst_pos0 = 0;
8960 dgst_pos1 = 1;
8961 dgst_pos2 = 2;
8962 dgst_pos3 = 3;
8963 break;
8964
8965 case 6500: hash_type = HASH_TYPE_SHA512;
8966 salt_type = SALT_TYPE_EMBEDDED;
8967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8968 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8969 kern_type = KERN_TYPE_SHA512AIX;
8970 dgst_size = DGST_SIZE_8_8;
8971 parse_func = sha512aix_parse_hash;
8972 sort_by_digest = sort_by_digest_8_8;
8973 opti_type = OPTI_TYPE_ZERO_BYTE
8974 | OPTI_TYPE_USES_BITS_64;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6600: hash_type = HASH_TYPE_AES;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_AGILEKEY;
8986 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8987 parse_func = agilekey_parse_hash;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6700: hash_type = HASH_TYPE_SHA1;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9000 kern_type = KERN_TYPE_SHA1AIX;
9001 dgst_size = DGST_SIZE_4_5;
9002 parse_func = sha1aix_parse_hash;
9003 sort_by_digest = sort_by_digest_4_5;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6800: hash_type = HASH_TYPE_AES;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9015 kern_type = KERN_TYPE_LASTPASS;
9016 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9017 parse_func = lastpass_parse_hash;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6900: hash_type = HASH_TYPE_GOST;
9027 salt_type = SALT_TYPE_NONE;
9028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_GOST;
9031 dgst_size = DGST_SIZE_4_8;
9032 parse_func = gost_parse_hash;
9033 sort_by_digest = sort_by_digest_4_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 7100: hash_type = HASH_TYPE_SHA512;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9045 kern_type = KERN_TYPE_PBKDF2_SHA512;
9046 dgst_size = DGST_SIZE_8_16;
9047 parse_func = sha512osx_parse_hash;
9048 sort_by_digest = sort_by_digest_8_16;
9049 opti_type = OPTI_TYPE_ZERO_BYTE
9050 | OPTI_TYPE_USES_BITS_64;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 7200: hash_type = HASH_TYPE_SHA512;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_PBKDF2_SHA512;
9062 dgst_size = DGST_SIZE_8_16;
9063 parse_func = sha512grub_parse_hash;
9064 sort_by_digest = sort_by_digest_8_16;
9065 opti_type = OPTI_TYPE_ZERO_BYTE
9066 | OPTI_TYPE_USES_BITS_64;
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_LE
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 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 9300: hash_type = HASH_TYPE_SCRYPT;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_SCRYPT;
9424 dgst_size = DGST_SIZE_4_8;
9425 parse_func = cisco9_parse_hash;
9426 sort_by_digest = sort_by_digest_4_8;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_OFFICE2007;
9439 dgst_size = DGST_SIZE_4_4;
9440 parse_func = office2007_parse_hash;
9441 sort_by_digest = sort_by_digest_4_4;
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9453 kern_type = KERN_TYPE_OFFICE2010;
9454 dgst_size = DGST_SIZE_4_4;
9455 parse_func = office2010_parse_hash;
9456 sort_by_digest = sort_by_digest_4_4;
9457 opti_type = OPTI_TYPE_ZERO_BYTE;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9468 kern_type = KERN_TYPE_OFFICE2013;
9469 dgst_size = DGST_SIZE_4_4;
9470 parse_func = office2013_parse_hash;
9471 sort_by_digest = sort_by_digest_4_4;
9472 opti_type = OPTI_TYPE_ZERO_BYTE;
9473 dgst_pos0 = 0;
9474 dgst_pos1 = 1;
9475 dgst_pos2 = 2;
9476 dgst_pos3 = 3;
9477 break;
9478
9479 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9480 salt_type = SALT_TYPE_EMBEDDED;
9481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9482 opts_type = OPTS_TYPE_PT_GENERATE_LE
9483 | OPTS_TYPE_PT_ADD80
9484 | OPTS_TYPE_PT_UNICODE;
9485 kern_type = KERN_TYPE_OLDOFFICE01;
9486 dgst_size = DGST_SIZE_4_4;
9487 parse_func = oldoffice01_parse_hash;
9488 sort_by_digest = sort_by_digest_4_4;
9489 opti_type = OPTI_TYPE_ZERO_BYTE
9490 | OPTI_TYPE_PRECOMPUTE_INIT
9491 | OPTI_TYPE_NOT_ITERATED;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE
9502 | OPTS_TYPE_PT_ADD80;
9503 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9504 dgst_size = DGST_SIZE_4_4;
9505 parse_func = oldoffice01cm1_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4;
9507 opti_type = OPTI_TYPE_ZERO_BYTE
9508 | OPTI_TYPE_PRECOMPUTE_INIT
9509 | OPTI_TYPE_NOT_ITERATED;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE
9520 | OPTS_TYPE_PT_ADD80
9521 | OPTS_TYPE_PT_UNICODE
9522 | OPTS_TYPE_PT_NEVERCRACK;
9523 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9524 dgst_size = DGST_SIZE_4_4;
9525 parse_func = oldoffice01cm2_parse_hash;
9526 sort_by_digest = sort_by_digest_4_4;
9527 opti_type = OPTI_TYPE_ZERO_BYTE
9528 | OPTI_TYPE_PRECOMPUTE_INIT
9529 | OPTI_TYPE_NOT_ITERATED;
9530 dgst_pos0 = 0;
9531 dgst_pos1 = 1;
9532 dgst_pos2 = 2;
9533 dgst_pos3 = 3;
9534 break;
9535
9536 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9537 salt_type = SALT_TYPE_EMBEDDED;
9538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9539 opts_type = OPTS_TYPE_PT_GENERATE_BE
9540 | OPTS_TYPE_PT_ADD80
9541 | OPTS_TYPE_PT_UNICODE;
9542 kern_type = KERN_TYPE_OLDOFFICE34;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = oldoffice34_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_INIT
9548 | OPTI_TYPE_NOT_ITERATED;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9556 salt_type = SALT_TYPE_EMBEDDED;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = oldoffice34cm1_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_NOT_ITERATED;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_BE
9576 | OPTS_TYPE_PT_ADD80
9577 | OPTS_TYPE_PT_UNICODE
9578 | OPTS_TYPE_PT_NEVERCRACK;
9579 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9580 dgst_size = DGST_SIZE_4_4;
9581 parse_func = oldoffice34cm2_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_PRECOMPUTE_INIT
9585 | OPTI_TYPE_NOT_ITERATED;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 9900: hash_type = HASH_TYPE_MD5;
9593 salt_type = SALT_TYPE_NONE;
9594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9596 kern_type = KERN_TYPE_RADMIN2;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = radmin2_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_PRECOMPUTE_INIT
9602 | OPTI_TYPE_EARLY_SKIP
9603 | OPTI_TYPE_NOT_ITERATED
9604 | OPTI_TYPE_NOT_SALTED;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 3;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 1;
9609 break;
9610
9611 case 10000: hash_type = HASH_TYPE_SHA256;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9615 kern_type = KERN_TYPE_PBKDF2_SHA256;
9616 dgst_size = DGST_SIZE_4_32;
9617 parse_func = djangopbkdf2_parse_hash;
9618 sort_by_digest = sort_by_digest_4_32;
9619 opti_type = OPTI_TYPE_ZERO_BYTE;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 10100: hash_type = HASH_TYPE_SIPHASH;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_SIPHASH;
9631 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9632 parse_func = siphash_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9634 opti_type = OPTI_TYPE_ZERO_BYTE
9635 | OPTI_TYPE_NOT_ITERATED
9636 | OPTI_TYPE_RAW_HASH;
9637 dgst_pos0 = 0;
9638 dgst_pos1 = 1;
9639 dgst_pos2 = 2;
9640 dgst_pos3 = 3;
9641 break;
9642
9643 case 10200: hash_type = HASH_TYPE_MD5;
9644 salt_type = SALT_TYPE_EMBEDDED;
9645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9646 opts_type = OPTS_TYPE_PT_GENERATE_LE
9647 | OPTS_TYPE_ST_ADD80
9648 | OPTS_TYPE_ST_ADDBITS14;
9649 kern_type = KERN_TYPE_HMACMD5_PW;
9650 dgst_size = DGST_SIZE_4_4;
9651 parse_func = crammd5_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4;
9653 opti_type = OPTI_TYPE_ZERO_BYTE
9654 | OPTI_TYPE_NOT_ITERATED;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 3;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 1;
9659 break;
9660
9661 case 10300: hash_type = HASH_TYPE_SHA1;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9665 kern_type = KERN_TYPE_SAPH_SHA1;
9666 dgst_size = DGST_SIZE_4_5;
9667 parse_func = saph_sha1_parse_hash;
9668 sort_by_digest = sort_by_digest_4_5;
9669 opti_type = OPTI_TYPE_ZERO_BYTE;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 10400: hash_type = HASH_TYPE_PDFU16;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_PDF11;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = pdf11_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_NOT_ITERATED;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 10410: hash_type = HASH_TYPE_PDFU16;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9696 kern_type = KERN_TYPE_PDF11CM1;
9697 dgst_size = DGST_SIZE_4_4;
9698 parse_func = pdf11cm1_parse_hash;
9699 sort_by_digest = sort_by_digest_4_4;
9700 opti_type = OPTI_TYPE_ZERO_BYTE
9701 | OPTI_TYPE_NOT_ITERATED;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 10420: hash_type = HASH_TYPE_PDFU16;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9712 kern_type = KERN_TYPE_PDF11CM2;
9713 dgst_size = DGST_SIZE_4_4;
9714 parse_func = pdf11cm2_parse_hash;
9715 sort_by_digest = sort_by_digest_4_4;
9716 opti_type = OPTI_TYPE_ZERO_BYTE
9717 | OPTI_TYPE_NOT_ITERATED;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 10500: hash_type = HASH_TYPE_PDFU16;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_PDF14;
9729 dgst_size = DGST_SIZE_4_4;
9730 parse_func = pdf14_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4;
9732 opti_type = OPTI_TYPE_ZERO_BYTE
9733 | OPTI_TYPE_NOT_ITERATED;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 10600: hash_type = HASH_TYPE_SHA256;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_BE
9744 | OPTS_TYPE_ST_ADD80
9745 | OPTS_TYPE_ST_ADDBITS15
9746 | OPTS_TYPE_HASH_COPY;
9747 kern_type = KERN_TYPE_SHA256_PWSLT;
9748 dgst_size = DGST_SIZE_4_8;
9749 parse_func = pdf17l3_parse_hash;
9750 sort_by_digest = sort_by_digest_4_8;
9751 opti_type = OPTI_TYPE_ZERO_BYTE
9752 | OPTI_TYPE_PRECOMPUTE_INIT
9753 | OPTI_TYPE_PRECOMPUTE_MERKLE
9754 | OPTI_TYPE_EARLY_SKIP
9755 | OPTI_TYPE_NOT_ITERATED
9756 | OPTI_TYPE_APPENDED_SALT
9757 | OPTI_TYPE_RAW_HASH;
9758 dgst_pos0 = 3;
9759 dgst_pos1 = 7;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 6;
9762 break;
9763
9764 case 10700: hash_type = HASH_TYPE_PDFU32;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_LE
9768 | OPTS_TYPE_HASH_COPY;
9769 kern_type = KERN_TYPE_PDF17L8;
9770 dgst_size = DGST_SIZE_4_8;
9771 parse_func = pdf17l8_parse_hash;
9772 sort_by_digest = sort_by_digest_4_8;
9773 opti_type = OPTI_TYPE_ZERO_BYTE
9774 | OPTI_TYPE_NOT_ITERATED;
9775 dgst_pos0 = 0;
9776 dgst_pos1 = 1;
9777 dgst_pos2 = 2;
9778 dgst_pos3 = 3;
9779 break;
9780
9781 case 10800: hash_type = HASH_TYPE_SHA384;
9782 salt_type = SALT_TYPE_NONE;
9783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9784 opts_type = OPTS_TYPE_PT_GENERATE_BE
9785 | OPTS_TYPE_PT_ADD80
9786 | OPTS_TYPE_PT_ADDBITS15;
9787 kern_type = KERN_TYPE_SHA384;
9788 dgst_size = DGST_SIZE_8_8;
9789 parse_func = sha384_parse_hash;
9790 sort_by_digest = sort_by_digest_8_8;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_PRECOMPUTE_INIT
9793 | OPTI_TYPE_PRECOMPUTE_MERKLE
9794 | OPTI_TYPE_EARLY_SKIP
9795 | OPTI_TYPE_NOT_ITERATED
9796 | OPTI_TYPE_NOT_SALTED
9797 | OPTI_TYPE_USES_BITS_64
9798 | OPTI_TYPE_RAW_HASH;
9799 dgst_pos0 = 6;
9800 dgst_pos1 = 7;
9801 dgst_pos2 = 4;
9802 dgst_pos3 = 5;
9803 break;
9804
9805 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE
9809 | OPTS_TYPE_ST_BASE64
9810 | OPTS_TYPE_HASH_COPY;
9811 kern_type = KERN_TYPE_PBKDF2_SHA256;
9812 dgst_size = DGST_SIZE_4_32;
9813 parse_func = pbkdf2_sha256_parse_hash;
9814 sort_by_digest = sort_by_digest_4_32;
9815 opti_type = OPTI_TYPE_ZERO_BYTE;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 1;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 3;
9820 break;
9821
9822 case 11000: hash_type = HASH_TYPE_MD5;
9823 salt_type = SALT_TYPE_INTERN;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_LE
9826 | OPTS_TYPE_PT_ADD80;
9827 kern_type = KERN_TYPE_PRESTASHOP;
9828 dgst_size = DGST_SIZE_4_4;
9829 parse_func = prestashop_parse_hash;
9830 sort_by_digest = sort_by_digest_4_4;
9831 opti_type = OPTI_TYPE_ZERO_BYTE
9832 | OPTI_TYPE_PRECOMPUTE_INIT
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_PREPENDED_SALT;
9835 dgst_pos0 = 0;
9836 dgst_pos1 = 3;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 1;
9839 break;
9840
9841 case 11100: hash_type = HASH_TYPE_MD5;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE
9845 | OPTS_TYPE_ST_ADD80;
9846 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = postgresql_auth_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_PRECOMPUTE_INIT
9852 | OPTI_TYPE_PRECOMPUTE_MERKLE
9853 | OPTI_TYPE_EARLY_SKIP;
9854 dgst_pos0 = 0;
9855 dgst_pos1 = 3;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 1;
9858 break;
9859
9860 case 11200: hash_type = HASH_TYPE_SHA1;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_BE
9864 | OPTS_TYPE_PT_ADD80
9865 | OPTS_TYPE_ST_HEX;
9866 kern_type = KERN_TYPE_MYSQL_AUTH;
9867 dgst_size = DGST_SIZE_4_5;
9868 parse_func = mysql_auth_parse_hash;
9869 sort_by_digest = sort_by_digest_4_5;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_EARLY_SKIP;
9872 dgst_pos0 = 3;
9873 dgst_pos1 = 4;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 1;
9876 break;
9877
9878 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9879 salt_type = SALT_TYPE_EMBEDDED;
9880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE
9882 | OPTS_TYPE_ST_HEX
9883 | OPTS_TYPE_ST_ADD80;
9884 kern_type = KERN_TYPE_BITCOIN_WALLET;
9885 dgst_size = DGST_SIZE_4_4;
9886 parse_func = bitcoin_wallet_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4;
9888 opti_type = OPTI_TYPE_ZERO_BYTE;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 1;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 3;
9893 break;
9894
9895 case 11400: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_PT_ADD80
9900 | OPTS_TYPE_HASH_COPY;
9901 kern_type = KERN_TYPE_SIP_AUTH;
9902 dgst_size = DGST_SIZE_4_4;
9903 parse_func = sip_auth_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4;
9905 opti_type = OPTI_TYPE_ZERO_BYTE;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11500: hash_type = HASH_TYPE_CRC32;
9913 salt_type = SALT_TYPE_INTERN;
9914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE
9916 | OPTS_TYPE_ST_GENERATE_LE
9917 | OPTS_TYPE_ST_HEX;
9918 kern_type = KERN_TYPE_CRC32;
9919 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9920 parse_func = crc32_parse_hash;
9921 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9922 opti_type = OPTI_TYPE_ZERO_BYTE;
9923 dgst_pos0 = 0;
9924 dgst_pos1 = 1;
9925 dgst_pos2 = 2;
9926 dgst_pos3 = 3;
9927 break;
9928
9929 case 11600: hash_type = HASH_TYPE_AES;
9930 salt_type = SALT_TYPE_EMBEDDED;
9931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9932 opts_type = OPTS_TYPE_PT_GENERATE_LE
9933 | OPTS_TYPE_PT_NEVERCRACK;
9934 kern_type = KERN_TYPE_SEVEN_ZIP;
9935 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9936 parse_func = seven_zip_parse_hash;
9937 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9938 opti_type = OPTI_TYPE_ZERO_BYTE;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 1;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 3;
9943 break;
9944
9945 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9946 salt_type = SALT_TYPE_NONE;
9947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_PT_ADD01;
9950 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9951 dgst_size = DGST_SIZE_4_8;
9952 parse_func = gost2012sbog_256_parse_hash;
9953 sort_by_digest = sort_by_digest_4_8;
9954 opti_type = OPTI_TYPE_ZERO_BYTE;
9955 dgst_pos0 = 0;
9956 dgst_pos1 = 1;
9957 dgst_pos2 = 2;
9958 dgst_pos3 = 3;
9959 break;
9960
9961 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9962 salt_type = SALT_TYPE_NONE;
9963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9964 opts_type = OPTS_TYPE_PT_GENERATE_LE
9965 | OPTS_TYPE_PT_ADD01;
9966 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9967 dgst_size = DGST_SIZE_4_16;
9968 parse_func = gost2012sbog_512_parse_hash;
9969 sort_by_digest = sort_by_digest_4_16;
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_ST_BASE64
9982 | OPTS_TYPE_HASH_COPY;
9983 kern_type = KERN_TYPE_PBKDF2_MD5;
9984 dgst_size = DGST_SIZE_4_32;
9985 parse_func = pbkdf2_md5_parse_hash;
9986 sort_by_digest = sort_by_digest_4_32;
9987 opti_type = OPTI_TYPE_ZERO_BYTE;
9988 dgst_pos0 = 0;
9989 dgst_pos1 = 1;
9990 dgst_pos2 = 2;
9991 dgst_pos3 = 3;
9992 break;
9993
9994 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9995 salt_type = SALT_TYPE_EMBEDDED;
9996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9997 opts_type = OPTS_TYPE_PT_GENERATE_LE
9998 | OPTS_TYPE_ST_BASE64
9999 | OPTS_TYPE_HASH_COPY;
10000 kern_type = KERN_TYPE_PBKDF2_SHA1;
10001 dgst_size = DGST_SIZE_4_32;
10002 parse_func = pbkdf2_sha1_parse_hash;
10003 sort_by_digest = sort_by_digest_4_32;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE
10015 | OPTS_TYPE_ST_BASE64
10016 | OPTS_TYPE_HASH_COPY;
10017 kern_type = KERN_TYPE_PBKDF2_SHA512;
10018 dgst_size = DGST_SIZE_8_16;
10019 parse_func = pbkdf2_sha512_parse_hash;
10020 sort_by_digest = sort_by_digest_8_16;
10021 opti_type = OPTI_TYPE_ZERO_BYTE
10022 | OPTI_TYPE_USES_BITS_64;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10033 kern_type = KERN_TYPE_ECRYPTFS;
10034 dgst_size = DGST_SIZE_8_8;
10035 parse_func = ecryptfs_parse_hash;
10036 sort_by_digest = sort_by_digest_8_8;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_USES_BITS_64;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 12300: hash_type = HASH_TYPE_ORACLET;
10046 salt_type = SALT_TYPE_EMBEDDED;
10047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10049 kern_type = KERN_TYPE_ORACLET;
10050 dgst_size = DGST_SIZE_8_16;
10051 parse_func = oraclet_parse_hash;
10052 sort_by_digest = sort_by_digest_8_16;
10053 opti_type = OPTI_TYPE_ZERO_BYTE
10054 | OPTI_TYPE_USES_BITS_64;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 1;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 3;
10059 break;
10060
10061 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10065 kern_type = KERN_TYPE_BSDICRYPT;
10066 dgst_size = DGST_SIZE_4_4;
10067 parse_func = bsdicrypt_parse_hash;
10068 sort_by_digest = sort_by_digest_4_4;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 12500: hash_type = HASH_TYPE_RAR3HP;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10081 kern_type = KERN_TYPE_RAR3;
10082 dgst_size = DGST_SIZE_4_4;
10083 parse_func = rar3hp_parse_hash;
10084 sort_by_digest = sort_by_digest_4_4;
10085 opti_type = OPTI_TYPE_ZERO_BYTE;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12600: hash_type = HASH_TYPE_SHA256;
10093 salt_type = SALT_TYPE_INTERN;
10094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_BE
10096 | OPTS_TYPE_PT_ADD80;
10097 kern_type = KERN_TYPE_CF10;
10098 dgst_size = DGST_SIZE_4_8;
10099 parse_func = cf10_parse_hash;
10100 sort_by_digest = sort_by_digest_4_8;
10101 opti_type = OPTI_TYPE_ZERO_BYTE
10102 | OPTI_TYPE_PRECOMPUTE_INIT
10103 | OPTI_TYPE_EARLY_SKIP
10104 | OPTI_TYPE_NOT_ITERATED;
10105 dgst_pos0 = 3;
10106 dgst_pos1 = 7;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 6;
10109 break;
10110
10111 case 12700: hash_type = HASH_TYPE_AES;
10112 salt_type = SALT_TYPE_EMBEDDED;
10113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE
10115 | OPTS_TYPE_HASH_COPY;
10116 kern_type = KERN_TYPE_MYWALLET;
10117 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10118 parse_func = mywallet_parse_hash;
10119 sort_by_digest = sort_by_digest_4_5;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10131 kern_type = KERN_TYPE_MS_DRSR;
10132 dgst_size = DGST_SIZE_4_8;
10133 parse_func = ms_drsr_parse_hash;
10134 sort_by_digest = sort_by_digest_4_8;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10146 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10147 dgst_size = DGST_SIZE_4_8;
10148 parse_func = androidfde_samsung_parse_hash;
10149 sort_by_digest = sort_by_digest_4_8;
10150 opti_type = OPTI_TYPE_ZERO_BYTE;
10151 dgst_pos0 = 0;
10152 dgst_pos1 = 1;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 3;
10155 break;
10156
10157 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10161 kern_type = KERN_TYPE_RAR5;
10162 dgst_size = DGST_SIZE_4_4;
10163 parse_func = rar5_parse_hash;
10164 sort_by_digest = sort_by_digest_4_4;
10165 opti_type = OPTI_TYPE_ZERO_BYTE;
10166 dgst_pos0 = 0;
10167 dgst_pos1 = 1;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 3;
10170 break;
10171
10172 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10176 kern_type = KERN_TYPE_KRB5TGS;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = krb5tgs_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE
10181 | OPTI_TYPE_NOT_ITERATED;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 13200: hash_type = HASH_TYPE_AES;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_AXCRYPT;
10193 dgst_size = DGST_SIZE_4_4;
10194 parse_func = axcrypt_parse_hash;
10195 sort_by_digest = sort_by_digest_4_4;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 13300: hash_type = HASH_TYPE_SHA1;
10204 salt_type = SALT_TYPE_NONE;
10205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_BE
10207 | OPTS_TYPE_PT_ADD80
10208 | OPTS_TYPE_PT_ADDBITS15;
10209 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10210 dgst_size = DGST_SIZE_4_5;
10211 parse_func = sha1axcrypt_parse_hash;
10212 sort_by_digest = sort_by_digest_4_5;
10213 opti_type = OPTI_TYPE_ZERO_BYTE
10214 | OPTI_TYPE_PRECOMPUTE_INIT
10215 | OPTI_TYPE_EARLY_SKIP
10216 | OPTI_TYPE_NOT_ITERATED
10217 | OPTI_TYPE_NOT_SALTED;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 4;
10220 dgst_pos2 = 3;
10221 dgst_pos3 = 2;
10222 break;
10223
10224 default: usage_mini_print (PROGNAME); return (-1);
10225 }
10226
10227 /**
10228 * parser
10229 */
10230
10231 data.parse_func = parse_func;
10232
10233 /**
10234 * misc stuff
10235 */
10236
10237 if (hex_salt)
10238 {
10239 if (salt_type == SALT_TYPE_INTERN)
10240 {
10241 opts_type |= OPTS_TYPE_ST_HEX;
10242 }
10243 else
10244 {
10245 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10246
10247 return (-1);
10248 }
10249 }
10250
10251 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10252 | (salt_type == SALT_TYPE_EXTERN)
10253 | (salt_type == SALT_TYPE_EMBEDDED)
10254 | (salt_type == SALT_TYPE_VIRTUAL));
10255
10256 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10257
10258 data.hash_type = hash_type;
10259 data.attack_mode = attack_mode;
10260 data.attack_kern = attack_kern;
10261 data.attack_exec = attack_exec;
10262 data.kern_type = kern_type;
10263 data.opts_type = opts_type;
10264 data.dgst_size = dgst_size;
10265 data.salt_type = salt_type;
10266 data.isSalted = isSalted;
10267 data.sort_by_digest = sort_by_digest;
10268 data.dgst_pos0 = dgst_pos0;
10269 data.dgst_pos1 = dgst_pos1;
10270 data.dgst_pos2 = dgst_pos2;
10271 data.dgst_pos3 = dgst_pos3;
10272
10273 esalt_size = 0;
10274
10275 switch (hash_mode)
10276 {
10277 case 2500: esalt_size = sizeof (wpa_t); break;
10278 case 5300: esalt_size = sizeof (ikepsk_t); break;
10279 case 5400: esalt_size = sizeof (ikepsk_t); break;
10280 case 5500: esalt_size = sizeof (netntlm_t); break;
10281 case 5600: esalt_size = sizeof (netntlm_t); break;
10282 case 6211: esalt_size = sizeof (tc_t); break;
10283 case 6212: esalt_size = sizeof (tc_t); break;
10284 case 6213: esalt_size = sizeof (tc_t); break;
10285 case 6221: esalt_size = sizeof (tc_t); break;
10286 case 6222: esalt_size = sizeof (tc_t); break;
10287 case 6223: esalt_size = sizeof (tc_t); break;
10288 case 6231: esalt_size = sizeof (tc_t); break;
10289 case 6232: esalt_size = sizeof (tc_t); break;
10290 case 6233: esalt_size = sizeof (tc_t); break;
10291 case 6241: esalt_size = sizeof (tc_t); break;
10292 case 6242: esalt_size = sizeof (tc_t); break;
10293 case 6243: esalt_size = sizeof (tc_t); break;
10294 case 6600: esalt_size = sizeof (agilekey_t); break;
10295 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10296 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10297 case 7300: esalt_size = sizeof (rakp_t); break;
10298 case 7500: esalt_size = sizeof (krb5pa_t); break;
10299 case 8200: esalt_size = sizeof (cloudkey_t); break;
10300 case 8800: esalt_size = sizeof (androidfde_t); break;
10301 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10302 case 9400: esalt_size = sizeof (office2007_t); break;
10303 case 9500: esalt_size = sizeof (office2010_t); break;
10304 case 9600: esalt_size = sizeof (office2013_t); break;
10305 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10306 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10307 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10308 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10309 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10310 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10311 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10312 case 10200: esalt_size = sizeof (cram_md5_t); break;
10313 case 10400: esalt_size = sizeof (pdf_t); break;
10314 case 10410: esalt_size = sizeof (pdf_t); break;
10315 case 10420: esalt_size = sizeof (pdf_t); break;
10316 case 10500: esalt_size = sizeof (pdf_t); break;
10317 case 10600: esalt_size = sizeof (pdf_t); break;
10318 case 10700: esalt_size = sizeof (pdf_t); break;
10319 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10320 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10321 case 11400: esalt_size = sizeof (sip_t); break;
10322 case 11600: esalt_size = sizeof (seven_zip_t); break;
10323 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10324 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10325 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10326 case 13000: esalt_size = sizeof (rar5_t); break;
10327 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10328 }
10329
10330 data.esalt_size = esalt_size;
10331
10332 /**
10333 * choose dictionary parser
10334 */
10335
10336 if (hash_type == HASH_TYPE_LM)
10337 {
10338 get_next_word_func = get_next_word_lm;
10339 }
10340 else if (opts_type & OPTS_TYPE_PT_UPPER)
10341 {
10342 get_next_word_func = get_next_word_uc;
10343 }
10344 else
10345 {
10346 get_next_word_func = get_next_word_std;
10347 }
10348
10349 /**
10350 * dictstat
10351 */
10352
10353 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10354
10355 #ifdef _POSIX
10356 size_t dictstat_nmemb = 0;
10357 #endif
10358
10359 #ifdef _WIN
10360 uint dictstat_nmemb = 0;
10361 #endif
10362
10363 char dictstat[256] = { 0 };
10364
10365 FILE *dictstat_fp = NULL;
10366
10367 if (keyspace == 0)
10368 {
10369 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10370
10371 dictstat_fp = fopen (dictstat, "rb");
10372
10373 if (dictstat_fp)
10374 {
10375 #ifdef _POSIX
10376 struct stat tmpstat;
10377
10378 fstat (fileno (dictstat_fp), &tmpstat);
10379 #endif
10380
10381 #ifdef _WIN
10382 struct stat64 tmpstat;
10383
10384 _fstat64 (fileno (dictstat_fp), &tmpstat);
10385 #endif
10386
10387 if (tmpstat.st_mtime < COMPTIME)
10388 {
10389 /* with v0.15 the format changed so we have to ensure user is using a good version
10390 since there is no version-header in the dictstat file */
10391
10392 fclose (dictstat_fp);
10393
10394 unlink (dictstat);
10395 }
10396 else
10397 {
10398 while (!feof (dictstat_fp))
10399 {
10400 dictstat_t d;
10401
10402 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10403
10404 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10405
10406 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10407 {
10408 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10409
10410 return -1;
10411 }
10412 }
10413
10414 fclose (dictstat_fp);
10415 }
10416 }
10417 }
10418
10419 /**
10420 * potfile
10421 */
10422
10423 char potfile[256] = { 0 };
10424
10425 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10426
10427 data.pot_fp = NULL;
10428
10429 FILE *out_fp = NULL;
10430 FILE *pot_fp = NULL;
10431
10432 if (show == 1 || left == 1)
10433 {
10434 pot_fp = fopen (potfile, "rb");
10435
10436 if (pot_fp == NULL)
10437 {
10438 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10439
10440 return (-1);
10441 }
10442
10443 if (outfile != NULL)
10444 {
10445 if ((out_fp = fopen (outfile, "ab")) == NULL)
10446 {
10447 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10448
10449 fclose (pot_fp);
10450
10451 return (-1);
10452 }
10453 }
10454 else
10455 {
10456 out_fp = stdout;
10457 }
10458 }
10459 else
10460 {
10461 if (potfile_disable == 0)
10462 {
10463 pot_fp = fopen (potfile, "ab");
10464
10465 if (pot_fp == NULL)
10466 {
10467 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10468
10469 return (-1);
10470 }
10471
10472 data.pot_fp = pot_fp;
10473 }
10474 }
10475
10476 pot_t *pot = NULL;
10477
10478 uint pot_cnt = 0;
10479 uint pot_avail = 0;
10480
10481 if (show == 1 || left == 1)
10482 {
10483 SUPPRESS_OUTPUT = 1;
10484
10485 pot_avail = count_lines (pot_fp);
10486
10487 rewind (pot_fp);
10488
10489 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10490
10491 uint pot_hashes_avail = 0;
10492
10493 uint line_num = 0;
10494
10495 while (!feof (pot_fp))
10496 {
10497 line_num++;
10498
10499 char line_buf[BUFSIZ] = { 0 };
10500
10501 int line_len = fgetl (pot_fp, line_buf);
10502
10503 if (line_len == 0) continue;
10504
10505 char *plain_buf = line_buf + line_len;
10506
10507 pot_t *pot_ptr = &pot[pot_cnt];
10508
10509 hash_t *hashes_buf = &pot_ptr->hash;
10510
10511 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10512 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10513
10514 if (pot_cnt == pot_hashes_avail)
10515 {
10516 uint pos = 0;
10517
10518 for (pos = 0; pos < INCR_POT; pos++)
10519 {
10520 if ((pot_cnt + pos) >= pot_avail) break;
10521
10522 pot_t *tmp_pot = &pot[pot_cnt + pos];
10523
10524 hash_t *tmp_hash = &tmp_pot->hash;
10525
10526 tmp_hash->digest = mymalloc (dgst_size);
10527
10528 if (isSalted)
10529 {
10530 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10531 }
10532
10533 if (esalt_size)
10534 {
10535 tmp_hash->esalt = mymalloc (esalt_size);
10536 }
10537
10538 pot_hashes_avail++;
10539 }
10540 }
10541
10542 int plain_len = 0;
10543
10544 int parser_status;
10545
10546 int iter = MAX_CUT_TRIES;
10547
10548 do
10549 {
10550 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10551 {
10552 if (line_buf[i] == ':')
10553 {
10554 line_len--;
10555
10556 break;
10557 }
10558 }
10559
10560 if (data.hash_mode != 2500)
10561 {
10562 parser_status = parse_func (line_buf, line_len, hashes_buf);
10563 }
10564 else
10565 {
10566 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10567
10568 if (line_len > max_salt_size)
10569 {
10570 parser_status = PARSER_GLOBAL_LENGTH;
10571 }
10572 else
10573 {
10574 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10575
10576 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10577
10578 hashes_buf->salt->salt_len = line_len;
10579
10580 parser_status = PARSER_OK;
10581 }
10582 }
10583
10584 // if NOT parsed without error, we add the ":" to the plain
10585
10586 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10587 {
10588 plain_len++;
10589 plain_buf--;
10590 }
10591
10592 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10593
10594 if (parser_status < PARSER_GLOBAL_ZERO)
10595 {
10596 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10597
10598 continue;
10599 }
10600
10601 if (plain_len >= 255) continue;
10602
10603 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10604
10605 pot_ptr->plain_len = plain_len;
10606
10607 pot_cnt++;
10608 }
10609
10610 fclose (pot_fp);
10611
10612 SUPPRESS_OUTPUT = 0;
10613
10614 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10615 }
10616
10617 /**
10618 * word len
10619 */
10620
10621 uint pw_min = PW_MIN;
10622 uint pw_max = PW_MAX;
10623
10624 switch (hash_mode)
10625 {
10626 case 400: if (pw_max > 40) pw_max = 40;
10627 break;
10628 case 500: if (pw_max > 16) pw_max = 16;
10629 break;
10630 case 1500: if (pw_max > 8) pw_max = 8;
10631 break;
10632 case 1600: if (pw_max > 16) pw_max = 16;
10633 break;
10634 case 1800: if (pw_max > 16) pw_max = 16;
10635 break;
10636 case 2100: if (pw_max > 16) pw_max = 16;
10637 break;
10638 case 2500: if (pw_min < 8) pw_min = 8;
10639 break;
10640 case 3000: if (pw_max > 7) pw_max = 7;
10641 break;
10642 case 5200: if (pw_max > 24) pw_max = 24;
10643 break;
10644 case 5800: if (pw_max > 16) pw_max = 16;
10645 break;
10646 case 6300: if (pw_max > 16) pw_max = 16;
10647 break;
10648 case 7400: if (pw_max > 16) pw_max = 16;
10649 break;
10650 case 7900: if (pw_max > 48) pw_max = 48;
10651 break;
10652 case 8500: if (pw_max > 8) pw_max = 8;
10653 break;
10654 case 8600: if (pw_max > 16) pw_max = 16;
10655 break;
10656 case 9710: pw_min = 5;
10657 pw_max = 5;
10658 break;
10659 case 9810: pw_min = 5;
10660 pw_max = 5;
10661 break;
10662 case 10410: pw_min = 5;
10663 pw_max = 5;
10664 break;
10665 case 10300: if (pw_max < 3) pw_min = 3;
10666 if (pw_max > 40) pw_max = 40;
10667 break;
10668 case 10500: if (pw_max < 3) pw_min = 3;
10669 if (pw_max > 40) pw_max = 40;
10670 break;
10671 case 10700: if (pw_max > 16) pw_max = 16;
10672 break;
10673 case 11300: if (pw_max > 40) pw_max = 40;
10674 break;
10675 case 12500: if (pw_max > 20) pw_max = 20;
10676 break;
10677 case 12800: if (pw_max > 24) pw_max = 24;
10678 break;
10679 }
10680
10681 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10682 {
10683 switch (attack_kern)
10684 {
10685 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10686 break;
10687 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10688 break;
10689 }
10690 }
10691
10692 /**
10693 * charsets : keep them together for more easy maintainnce
10694 */
10695
10696 cs_t mp_sys[6] = { { { 0 }, 0 } };
10697 cs_t mp_usr[4] = { { { 0 }, 0 } };
10698
10699 mp_setup_sys (mp_sys);
10700
10701 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10702 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10703 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10704 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10705
10706 /**
10707 * load hashes, part I: find input mode, count hashes
10708 */
10709
10710 uint hashlist_mode = 0;
10711 uint hashlist_format = HLFMT_HASHCAT;
10712
10713 uint hashes_avail = 0;
10714
10715 if (benchmark == 0)
10716 {
10717 struct stat f;
10718
10719 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10720
10721 if ((hash_mode == 2500) ||
10722 (hash_mode == 5200) ||
10723 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10724 (hash_mode == 9000))
10725 {
10726 hashlist_mode = HL_MODE_ARG;
10727
10728 char *hashfile = myargv[optind];
10729
10730 data.hashfile = hashfile;
10731
10732 logfile_top_var_string ("target", hashfile);
10733 }
10734
10735 if (hashlist_mode == HL_MODE_ARG)
10736 {
10737 if (hash_mode == 2500)
10738 {
10739 struct stat st;
10740
10741 if (stat (data.hashfile, &st) == -1)
10742 {
10743 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10744
10745 return (-1);
10746 }
10747
10748 hashes_avail = st.st_size / sizeof (hccap_t);
10749 }
10750 else
10751 {
10752 hashes_avail = 1;
10753 }
10754 }
10755 else if (hashlist_mode == HL_MODE_FILE)
10756 {
10757 char *hashfile = myargv[optind];
10758
10759 data.hashfile = hashfile;
10760
10761 logfile_top_var_string ("target", hashfile);
10762
10763 FILE *fp = NULL;
10764
10765 if ((fp = fopen (hashfile, "rb")) == NULL)
10766 {
10767 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10768
10769 return (-1);
10770 }
10771
10772 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10773
10774 hashes_avail = count_lines (fp);
10775
10776 rewind (fp);
10777
10778 if (hashes_avail == 0)
10779 {
10780 log_error ("ERROR: hashfile is empty or corrupt");
10781
10782 fclose (fp);
10783
10784 return (-1);
10785 }
10786
10787 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10788
10789 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10790 {
10791 log_error ("ERROR: remove not supported in native hashfile-format mode");
10792
10793 fclose (fp);
10794
10795 return (-1);
10796 }
10797
10798 fclose (fp);
10799 }
10800 }
10801 else
10802 {
10803 hashlist_mode = HL_MODE_ARG;
10804
10805 hashes_avail = 1;
10806 }
10807
10808 if (hash_mode == 3000) hashes_avail *= 2;
10809
10810 data.hashlist_mode = hashlist_mode;
10811 data.hashlist_format = hashlist_format;
10812
10813 logfile_top_uint (hashlist_mode);
10814 logfile_top_uint (hashlist_format);
10815
10816 /**
10817 * load hashes, part II: allocate required memory, set pointers
10818 */
10819
10820 hash_t *hashes_buf = NULL;
10821 void *digests_buf = NULL;
10822 salt_t *salts_buf = NULL;
10823 void *esalts_buf = NULL;
10824
10825 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10826
10827 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10828
10829 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10830 {
10831 u32 hash_pos;
10832
10833 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10834 {
10835 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10836
10837 hashes_buf[hash_pos].hash_info = hash_info;
10838
10839 if (username && (remove || show || left))
10840 {
10841 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10842 }
10843
10844 if (benchmark)
10845 {
10846 hash_info->orighash = (char *) mymalloc (256);
10847 }
10848 }
10849 }
10850
10851 if (isSalted)
10852 {
10853 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10854
10855 if (esalt_size)
10856 {
10857 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10858 }
10859 }
10860 else
10861 {
10862 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10863 }
10864
10865 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10866 {
10867 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10868
10869 if (isSalted)
10870 {
10871 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10872
10873 if (esalt_size)
10874 {
10875 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10876 }
10877 }
10878 else
10879 {
10880 hashes_buf[hash_pos].salt = &salts_buf[0];
10881 }
10882 }
10883
10884 /**
10885 * load hashes, part III: parse hashes or generate them if benchmark
10886 */
10887
10888 uint hashes_cnt = 0;
10889
10890 if (benchmark == 0)
10891 {
10892 if (keyspace == 1)
10893 {
10894 // useless to read hash file for keyspace, cheat a little bit w/ optind
10895 }
10896 else if (hashes_avail == 0)
10897 {
10898 }
10899 else if (hashlist_mode == HL_MODE_ARG)
10900 {
10901 char *input_buf = myargv[optind];
10902
10903 uint input_len = strlen (input_buf);
10904
10905 logfile_top_var_string ("target", input_buf);
10906
10907 char *hash_buf = NULL;
10908 int hash_len = 0;
10909
10910 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10911
10912 if (hash_len)
10913 {
10914 if (opts_type & OPTS_TYPE_HASH_COPY)
10915 {
10916 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10917
10918 hash_info_tmp->orighash = mystrdup (hash_buf);
10919 }
10920
10921 if (isSalted)
10922 {
10923 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10924 }
10925
10926 int parser_status = PARSER_OK;
10927
10928 if (hash_mode == 2500)
10929 {
10930 if (hash_len == 0)
10931 {
10932 log_error ("ERROR: hccap file not specified");
10933
10934 return (-1);
10935 }
10936
10937 hashlist_mode = HL_MODE_FILE;
10938
10939 data.hashlist_mode = hashlist_mode;
10940
10941 FILE *fp = fopen (hash_buf, "rb");
10942
10943 if (fp == NULL)
10944 {
10945 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10946
10947 return (-1);
10948 }
10949
10950 if (hashes_avail < 1)
10951 {
10952 log_error ("ERROR: hccap file is empty or corrupt");
10953
10954 fclose (fp);
10955
10956 return (-1);
10957 }
10958
10959 uint hccap_size = sizeof (hccap_t);
10960
10961 char *in = (char *) mymalloc (hccap_size);
10962
10963 while (!feof (fp))
10964 {
10965 int n = fread (in, hccap_size, 1, fp);
10966
10967 if (n != 1)
10968 {
10969 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10970
10971 break;
10972 }
10973
10974 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10975
10976 if (parser_status != PARSER_OK)
10977 {
10978 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10979
10980 continue;
10981 }
10982
10983 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10984
10985 if ((show == 1) || (left == 1))
10986 {
10987 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10988
10989 char *salt_ptr = (char *) tmp_salt->salt_buf;
10990
10991 int cur_pos = tmp_salt->salt_len;
10992 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10993
10994 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10995
10996 u8 *pke_ptr = (u8 *) wpa->pke;
10997
10998 // do the appending task
10999
11000 snprintf (salt_ptr + cur_pos,
11001 rem_len,
11002 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11003 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11004 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11005
11006
11007 // memset () the remaining part of the salt
11008
11009 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11010 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11011
11012 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11013
11014 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11015 }
11016
11017 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);
11018 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);
11019
11020 hashes_cnt++;
11021 }
11022
11023 fclose (fp);
11024
11025 myfree (in);
11026 }
11027 else if (hash_mode == 3000)
11028 {
11029 if (hash_len == 32)
11030 {
11031 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11032
11033 hash_t *lm_hash_left = NULL;
11034
11035 if (parser_status == PARSER_OK)
11036 {
11037 lm_hash_left = &hashes_buf[hashes_cnt];
11038
11039 hashes_cnt++;
11040 }
11041 else
11042 {
11043 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11044 }
11045
11046 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11047
11048 hash_t *lm_hash_right = NULL;
11049
11050 if (parser_status == PARSER_OK)
11051 {
11052 lm_hash_right = &hashes_buf[hashes_cnt];
11053
11054 hashes_cnt++;
11055 }
11056 else
11057 {
11058 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11059 }
11060
11061 // show / left
11062
11063 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11064 {
11065 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);
11066 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);
11067 }
11068 }
11069 else
11070 {
11071 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11072
11073 if (parser_status == PARSER_OK)
11074 {
11075 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11076 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11077 }
11078
11079 if (parser_status == PARSER_OK)
11080 {
11081 hashes_cnt++;
11082 }
11083 else
11084 {
11085 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11086 }
11087 }
11088 }
11089 else
11090 {
11091 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11092
11093 if (parser_status == PARSER_OK)
11094 {
11095 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11096 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11097 }
11098
11099 if (parser_status == PARSER_OK)
11100 {
11101 hashes_cnt++;
11102 }
11103 else
11104 {
11105 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11106 }
11107 }
11108 }
11109 }
11110 else if (hashlist_mode == HL_MODE_FILE)
11111 {
11112 char *hashfile = data.hashfile;
11113
11114 FILE *fp;
11115
11116 if ((fp = fopen (hashfile, "rb")) == NULL)
11117 {
11118 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11119
11120 return (-1);
11121 }
11122
11123 uint line_num = 0;
11124
11125 while (!feof (fp))
11126 {
11127 line_num++;
11128
11129 char line_buf[BUFSIZ] = { 0 };
11130
11131 int line_len = fgetl (fp, line_buf);
11132
11133 if (line_len == 0) continue;
11134
11135 char *hash_buf = NULL;
11136 int hash_len = 0;
11137
11138 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11139
11140 if (username)
11141 {
11142 char *user_buf = NULL;
11143 int user_len = 0;
11144
11145 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11146
11147 if (remove || show)
11148 {
11149 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11150
11151 *user = (user_t *) mymalloc (sizeof (user_t));
11152
11153 user_t *user_ptr = *user;
11154
11155 if (user_buf != NULL)
11156 {
11157 user_ptr->user_name = mystrdup (user_buf);
11158 }
11159 else
11160 {
11161 user_ptr->user_name = mystrdup ("");
11162 }
11163
11164 user_ptr->user_len = user_len;
11165 }
11166 }
11167
11168 if (opts_type & OPTS_TYPE_HASH_COPY)
11169 {
11170 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11171
11172 hash_info_tmp->orighash = mystrdup (hash_buf);
11173 }
11174
11175 if (isSalted)
11176 {
11177 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11178 }
11179
11180 if (hash_mode == 3000)
11181 {
11182 if (hash_len == 32)
11183 {
11184 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11185
11186 if (parser_status < PARSER_GLOBAL_ZERO)
11187 {
11188 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11189
11190 continue;
11191 }
11192
11193 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11194
11195 hashes_cnt++;
11196
11197 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11198
11199 if (parser_status < PARSER_GLOBAL_ZERO)
11200 {
11201 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11202
11203 continue;
11204 }
11205
11206 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11207
11208 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);
11209
11210 hashes_cnt++;
11211
11212 // show / left
11213
11214 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);
11215 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);
11216 }
11217 else
11218 {
11219 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11220
11221 if (parser_status < PARSER_GLOBAL_ZERO)
11222 {
11223 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11224
11225 continue;
11226 }
11227
11228 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);
11229
11230 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11231 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11232
11233 hashes_cnt++;
11234 }
11235 }
11236 else
11237 {
11238 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11239
11240 if (parser_status < PARSER_GLOBAL_ZERO)
11241 {
11242 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11243
11244 continue;
11245 }
11246
11247 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);
11248
11249 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11250 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11251
11252 hashes_cnt++;
11253 }
11254 }
11255
11256 fclose (fp);
11257
11258 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11259
11260 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11261 }
11262 }
11263 else
11264 {
11265 if (isSalted)
11266 {
11267 hashes_buf[0].salt->salt_len = 8;
11268
11269 // special salt handling
11270
11271 switch (hash_mode)
11272 {
11273 case 1500: hashes_buf[0].salt->salt_len = 2;
11274 break;
11275 case 1731: hashes_buf[0].salt->salt_len = 4;
11276 break;
11277 case 2410: hashes_buf[0].salt->salt_len = 4;
11278 break;
11279 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11280 break;
11281 case 3100: hashes_buf[0].salt->salt_len = 1;
11282 break;
11283 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11284 break;
11285 case 5800: hashes_buf[0].salt->salt_len = 16;
11286 break;
11287 case 6800: hashes_buf[0].salt->salt_len = 32;
11288 break;
11289 case 8400: hashes_buf[0].salt->salt_len = 40;
11290 break;
11291 case 8800: hashes_buf[0].salt->salt_len = 16;
11292 break;
11293 case 8900: hashes_buf[0].salt->salt_len = 16;
11294 hashes_buf[0].salt->scrypt_N = 1024;
11295 hashes_buf[0].salt->scrypt_r = 1;
11296 hashes_buf[0].salt->scrypt_p = 1;
11297 break;
11298 case 9100: hashes_buf[0].salt->salt_len = 16;
11299 break;
11300 case 9300: hashes_buf[0].salt->salt_len = 14;
11301 hashes_buf[0].salt->scrypt_N = 16384;
11302 hashes_buf[0].salt->scrypt_r = 1;
11303 hashes_buf[0].salt->scrypt_p = 1;
11304 break;
11305 case 9400: hashes_buf[0].salt->salt_len = 16;
11306 break;
11307 case 9500: hashes_buf[0].salt->salt_len = 16;
11308 break;
11309 case 9600: hashes_buf[0].salt->salt_len = 16;
11310 break;
11311 case 9700: hashes_buf[0].salt->salt_len = 16;
11312 break;
11313 case 9710: hashes_buf[0].salt->salt_len = 16;
11314 break;
11315 case 9720: hashes_buf[0].salt->salt_len = 16;
11316 break;
11317 case 9800: hashes_buf[0].salt->salt_len = 16;
11318 break;
11319 case 9810: hashes_buf[0].salt->salt_len = 16;
11320 break;
11321 case 9820: hashes_buf[0].salt->salt_len = 16;
11322 break;
11323 case 10300: hashes_buf[0].salt->salt_len = 12;
11324 break;
11325 case 11500: hashes_buf[0].salt->salt_len = 4;
11326 break;
11327 case 11600: hashes_buf[0].salt->salt_len = 4;
11328 break;
11329 case 12400: hashes_buf[0].salt->salt_len = 4;
11330 break;
11331 case 12500: hashes_buf[0].salt->salt_len = 8;
11332 break;
11333 case 12600: hashes_buf[0].salt->salt_len = 64;
11334 break;
11335 }
11336
11337 // special esalt handling
11338
11339 switch (hash_mode)
11340 {
11341 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11342 break;
11343 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11344 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11345 break;
11346 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11347 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11348 break;
11349 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11350 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11351 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11352 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11353 break;
11354 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11355 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11356 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11357 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11358 break;
11359 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11360 break;
11361 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11362 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11363 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11364 break;
11365 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11366 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11367 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11368 break;
11369 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11370 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11371 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11372 break;
11373 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11374 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11375 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11376 break;
11377 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11378 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11379 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11380 break;
11381 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11382 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11383 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11384 break;
11385 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11386 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11387 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11388 break;
11389 }
11390 }
11391
11392 // set hashfile
11393
11394 switch (hash_mode)
11395 {
11396 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11397 break;
11398 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11399 break;
11400 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11401 break;
11402 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11403 break;
11404 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11405 break;
11406 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11407 break;
11408 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11409 break;
11410 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11411 break;
11412 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11413 break;
11414 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11415 break;
11416 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11417 break;
11418 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11419 break;
11420 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11421 break;
11422 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11423 break;
11424 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11425 break;
11426 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11427 break;
11428 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11429 break;
11430 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11431 break;
11432 }
11433
11434 // set default iterations
11435
11436 switch (hash_mode)
11437 {
11438 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11439 break;
11440 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11441 break;
11442 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11443 break;
11444 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11445 break;
11446 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11447 break;
11448 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11449 break;
11450 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11451 break;
11452 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11453 break;
11454 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11455 break;
11456 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11457 break;
11458 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11459 break;
11460 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11461 break;
11462 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11463 break;
11464 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11465 break;
11466 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11467 break;
11468 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11469 break;
11470 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11471 break;
11472 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11473 break;
11474 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11475 break;
11476 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11477 break;
11478 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11479 break;
11480 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11481 break;
11482 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11483 break;
11484 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11485 break;
11486 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11487 break;
11488 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11489 break;
11490 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11491 break;
11492 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11493 break;
11494 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11495 break;
11496 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11497 break;
11498 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11499 break;
11500 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11501 break;
11502 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11503 break;
11504 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11505 break;
11506 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11507 break;
11508 case 8900: hashes_buf[0].salt->salt_iter = 1;
11509 break;
11510 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11511 break;
11512 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11513 break;
11514 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11515 break;
11516 case 9300: hashes_buf[0].salt->salt_iter = 1;
11517 break;
11518 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11519 break;
11520 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11521 break;
11522 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11523 break;
11524 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11525 break;
11526 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11527 break;
11528 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11529 break;
11530 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11531 break;
11532 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11533 break;
11534 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11535 break;
11536 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11537 break;
11538 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11539 break;
11540 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11541 break;
11542 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11543 break;
11544 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11545 break;
11546 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11547 break;
11548 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11549 break;
11550 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11551 break;
11552 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11553 break;
11554 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11555 break;
11556 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11557 break;
11558 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11559 break;
11560 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11561 break;
11562 }
11563
11564 hashes_cnt = 1;
11565 }
11566
11567 if (show == 1 || left == 1)
11568 {
11569 for (uint i = 0; i < pot_cnt; i++)
11570 {
11571 pot_t *pot_ptr = &pot[i];
11572
11573 hash_t *hashes_buf = &pot_ptr->hash;
11574
11575 local_free (hashes_buf->digest);
11576
11577 if (isSalted)
11578 {
11579 local_free (hashes_buf->salt);
11580 }
11581 }
11582
11583 local_free (pot);
11584
11585 if (data.quiet == 0) log_info_nn ("");
11586
11587 return (0);
11588 }
11589
11590 if (keyspace == 0)
11591 {
11592 if (hashes_cnt == 0)
11593 {
11594 log_error ("ERROR: No hashes loaded");
11595
11596 return (-1);
11597 }
11598 }
11599
11600 /**
11601 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11602 */
11603
11604 if (data.outfile != NULL)
11605 {
11606 if (data.hashfile != NULL)
11607 {
11608 #ifdef _POSIX
11609 struct stat tmpstat_outfile;
11610 struct stat tmpstat_hashfile;
11611 #endif
11612
11613 #ifdef _WIN
11614 struct stat64 tmpstat_outfile;
11615 struct stat64 tmpstat_hashfile;
11616 #endif
11617
11618 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11619
11620 if (tmp_outfile_fp)
11621 {
11622 #ifdef _POSIX
11623 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11624 #endif
11625
11626 #ifdef _WIN
11627 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11628 #endif
11629
11630 fclose (tmp_outfile_fp);
11631 }
11632
11633 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11634
11635 if (tmp_hashfile_fp)
11636 {
11637 #ifdef _POSIX
11638 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11639 #endif
11640
11641 #ifdef _WIN
11642 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11643 #endif
11644
11645 fclose (tmp_hashfile_fp);
11646 }
11647
11648 if (tmp_outfile_fp && tmp_outfile_fp)
11649 {
11650 tmpstat_outfile.st_mode = 0;
11651 tmpstat_outfile.st_nlink = 0;
11652 tmpstat_outfile.st_uid = 0;
11653 tmpstat_outfile.st_gid = 0;
11654 tmpstat_outfile.st_rdev = 0;
11655 tmpstat_outfile.st_atime = 0;
11656
11657 tmpstat_hashfile.st_mode = 0;
11658 tmpstat_hashfile.st_nlink = 0;
11659 tmpstat_hashfile.st_uid = 0;
11660 tmpstat_hashfile.st_gid = 0;
11661 tmpstat_hashfile.st_rdev = 0;
11662 tmpstat_hashfile.st_atime = 0;
11663
11664 #ifdef _POSIX
11665 tmpstat_outfile.st_blksize = 0;
11666 tmpstat_outfile.st_blocks = 0;
11667
11668 tmpstat_hashfile.st_blksize = 0;
11669 tmpstat_hashfile.st_blocks = 0;
11670 #endif
11671
11672 #ifdef _POSIX
11673 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11674 {
11675 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11676
11677 return (-1);
11678 }
11679 #endif
11680
11681 #ifdef _WIN
11682 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11683 {
11684 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11685
11686 return (-1);
11687 }
11688 #endif
11689 }
11690 }
11691 }
11692
11693 /**
11694 * Remove duplicates
11695 */
11696
11697 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11698
11699 if (isSalted)
11700 {
11701 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11702 }
11703 else
11704 {
11705 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11706 }
11707
11708 uint hashes_cnt_orig = hashes_cnt;
11709
11710 hashes_cnt = 1;
11711
11712 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11713 {
11714 if (isSalted)
11715 {
11716 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11717 {
11718 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11719 }
11720 }
11721 else
11722 {
11723 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11724 }
11725
11726 if (hashes_pos > hashes_cnt)
11727 {
11728 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11729 }
11730
11731 hashes_cnt++;
11732 }
11733
11734 /**
11735 * Potfile removes
11736 */
11737
11738 uint potfile_remove_cracks = 0;
11739
11740 if (potfile_disable == 0)
11741 {
11742 hash_t hash_buf;
11743
11744 hash_buf.digest = mymalloc (dgst_size);
11745 hash_buf.salt = NULL;
11746 hash_buf.esalt = NULL;
11747 hash_buf.hash_info = NULL;
11748 hash_buf.cracked = 0;
11749
11750 if (isSalted)
11751 {
11752 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11753 }
11754
11755 if (esalt_size)
11756 {
11757 hash_buf.esalt = mymalloc (esalt_size);
11758 }
11759
11760 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11761
11762 // no solution for these special hash types (for instane because they use hashfile in output etc)
11763 if ((hash_mode != 5200) &&
11764 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11765 (hash_mode != 9000))
11766 {
11767 FILE *fp = fopen (potfile, "rb");
11768
11769 if (fp != NULL)
11770 {
11771 while (!feof (fp))
11772 {
11773 char line_buf[BUFSIZ] = { 0 };
11774
11775 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11776
11777 if (ptr == NULL) break;
11778
11779 int line_len = strlen (line_buf);
11780
11781 if (line_len == 0) continue;
11782
11783 int iter = MAX_CUT_TRIES;
11784
11785 for (int i = line_len - 1; i && iter; i--, line_len--)
11786 {
11787 if (line_buf[i] != ':') continue;
11788
11789 if (isSalted)
11790 {
11791 memset (hash_buf.salt, 0, sizeof (salt_t));
11792 }
11793
11794 hash_t *found = NULL;
11795
11796 if (hash_mode == 6800)
11797 {
11798 if (i < 64) // 64 = 16 * uint in salt_buf[]
11799 {
11800 // manipulate salt_buf
11801 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11802
11803 hash_buf.salt->salt_len = i;
11804
11805 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11806 }
11807 }
11808 else if (hash_mode == 2500)
11809 {
11810 if (i < 64) // 64 = 16 * uint in salt_buf[]
11811 {
11812 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11813 // manipulate salt_buf
11814
11815 // to be safe work with a copy (because of line_len loop, i etc)
11816
11817 char line_buf_cpy[BUFSIZ] = { 0 };
11818
11819 memcpy (line_buf_cpy, line_buf, i);
11820
11821 char *mac2_pos = strrchr (line_buf_cpy, ':');
11822
11823 if (mac2_pos == NULL) continue;
11824
11825 mac2_pos[0] = 0;
11826 mac2_pos++;
11827
11828 if (strlen (mac2_pos) != 12) continue;
11829
11830 char *mac1_pos = strrchr (line_buf_cpy, ':');
11831
11832 if (mac1_pos == NULL) continue;
11833
11834 mac1_pos[0] = 0;
11835 mac1_pos++;
11836
11837 if (strlen (mac1_pos) != 12) continue;
11838
11839 uint essid_length = mac1_pos - line_buf_cpy - 1;
11840
11841 // here we need the ESSID
11842 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11843
11844 hash_buf.salt->salt_len = essid_length;
11845
11846 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11847
11848 if (found)
11849 {
11850 wpa_t *wpa = (wpa_t *) found->esalt;
11851
11852 uint pke[25] = { 0 };
11853
11854 char *pke_ptr = (char *) pke;
11855
11856 for (uint i = 0; i < 25; i++)
11857 {
11858 pke[i] = byte_swap_32 (wpa->pke[i]);
11859 }
11860
11861 u8 mac1[6] = { 0 };
11862 u8 mac2[6] = { 0 };
11863
11864 memcpy (mac1, pke_ptr + 23, 6);
11865 memcpy (mac2, pke_ptr + 29, 6);
11866
11867 // compare hex string(s) vs binary MAC address(es)
11868
11869 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11870 {
11871 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11872 {
11873 found = NULL;
11874 break;
11875 }
11876 }
11877
11878 // early skip ;)
11879 if (!found) continue;
11880
11881 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11882 {
11883 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11884 {
11885 found = NULL;
11886 break;
11887 }
11888 }
11889 }
11890 }
11891 }
11892 else
11893 {
11894 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11895
11896 if (parser_status == PARSER_OK)
11897 {
11898 if (isSalted)
11899 {
11900 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11901 }
11902 else
11903 {
11904 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11905 }
11906 }
11907 }
11908
11909 if (found == NULL) continue;
11910
11911 if (!found->cracked) potfile_remove_cracks++;
11912
11913 found->cracked = 1;
11914
11915 if (found) break;
11916
11917 iter--;
11918 }
11919 }
11920
11921 fclose (fp);
11922 }
11923 }
11924
11925 if (esalt_size)
11926 {
11927 local_free (hash_buf.esalt);
11928 }
11929
11930 if (isSalted)
11931 {
11932 local_free (hash_buf.salt);
11933 }
11934
11935 local_free (hash_buf.digest);
11936 }
11937
11938 /**
11939 * Now generate all the buffers required for later
11940 */
11941
11942 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11943
11944 salt_t *salts_buf_new = NULL;
11945 void *esalts_buf_new = NULL;
11946
11947 if (isSalted)
11948 {
11949 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11950
11951 if (esalt_size)
11952 {
11953 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11954 }
11955 }
11956 else
11957 {
11958 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11959 }
11960
11961 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11962
11963 uint digests_cnt = hashes_cnt;
11964 uint digests_done = 0;
11965
11966 uint size_digests = digests_cnt * dgst_size;
11967 uint size_shown = digests_cnt * sizeof (uint);
11968
11969 uint *digests_shown = (uint *) mymalloc (size_shown);
11970 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11971
11972 uint salts_cnt = 0;
11973 uint salts_done = 0;
11974
11975 hashinfo_t **hash_info = NULL;
11976
11977 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11978 {
11979 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11980
11981 if (username && (remove || show))
11982 {
11983 uint user_pos;
11984
11985 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11986 {
11987 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11988
11989 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11990 }
11991 }
11992 }
11993
11994 uint *salts_shown = (uint *) mymalloc (size_shown);
11995
11996 salt_t *salt_buf;
11997
11998 {
11999 // copied from inner loop
12000
12001 salt_buf = &salts_buf_new[salts_cnt];
12002
12003 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12004
12005 if (esalt_size)
12006 {
12007 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12008 }
12009
12010 salt_buf->digests_cnt = 0;
12011 salt_buf->digests_done = 0;
12012 salt_buf->digests_offset = 0;
12013
12014 salts_cnt++;
12015 }
12016
12017 if (hashes_buf[0].cracked == 1)
12018 {
12019 digests_shown[0] = 1;
12020
12021 digests_done++;
12022
12023 salt_buf->digests_done++;
12024 }
12025
12026 salt_buf->digests_cnt++;
12027
12028 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12029
12030 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12031 {
12032 hash_info[0] = hashes_buf[0].hash_info;
12033 }
12034
12035 // copy from inner loop
12036
12037 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12038 {
12039 if (isSalted)
12040 {
12041 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12042 {
12043 salt_buf = &salts_buf_new[salts_cnt];
12044
12045 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12046
12047 if (esalt_size)
12048 {
12049 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12050 }
12051
12052 salt_buf->digests_cnt = 0;
12053 salt_buf->digests_done = 0;
12054 salt_buf->digests_offset = hashes_pos;
12055
12056 salts_cnt++;
12057 }
12058 }
12059
12060 if (hashes_buf[hashes_pos].cracked == 1)
12061 {
12062 digests_shown[hashes_pos] = 1;
12063
12064 digests_done++;
12065
12066 salt_buf->digests_done++;
12067 }
12068
12069 salt_buf->digests_cnt++;
12070
12071 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12072
12073 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12074 {
12075 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12076 }
12077 }
12078
12079 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12080 {
12081 salt_t *salt_buf = &salts_buf_new[salt_pos];
12082
12083 if (salt_buf->digests_done == salt_buf->digests_cnt)
12084 {
12085 salts_shown[salt_pos] = 1;
12086
12087 salts_done++;
12088 }
12089
12090 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12091 }
12092
12093 local_free (digests_buf);
12094 local_free (salts_buf);
12095 local_free (esalts_buf);
12096
12097 digests_buf = digests_buf_new;
12098 salts_buf = salts_buf_new;
12099 esalts_buf = esalts_buf_new;
12100
12101 local_free (hashes_buf);
12102
12103 /**
12104 * special modification not set from parser
12105 */
12106
12107 switch (hash_mode)
12108 {
12109 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12110 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12111 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12112 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12113 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12114 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12115 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12116 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12117 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12118 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12119 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12120 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12121 }
12122
12123 if (truecrypt_keyfiles)
12124 {
12125 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12126
12127 char *keyfiles = strdup (truecrypt_keyfiles);
12128
12129 char *keyfile = strtok (keyfiles, ",");
12130
12131 do
12132 {
12133 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12134
12135 } while ((keyfile = strtok (NULL, ",")) != NULL);
12136
12137 free (keyfiles);
12138 }
12139
12140 data.digests_cnt = digests_cnt;
12141 data.digests_done = digests_done;
12142 data.digests_buf = digests_buf;
12143 data.digests_shown = digests_shown;
12144 data.digests_shown_tmp = digests_shown_tmp;
12145
12146 data.salts_cnt = salts_cnt;
12147 data.salts_done = salts_done;
12148 data.salts_buf = salts_buf;
12149 data.salts_shown = salts_shown;
12150
12151 data.esalts_buf = esalts_buf;
12152 data.hash_info = hash_info;
12153
12154 /**
12155 * Automatic Optimizers
12156 */
12157
12158 if (salts_cnt == 1)
12159 opti_type |= OPTI_TYPE_SINGLE_SALT;
12160
12161 if (digests_cnt == 1)
12162 opti_type |= OPTI_TYPE_SINGLE_HASH;
12163
12164 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12165 opti_type |= OPTI_TYPE_NOT_ITERATED;
12166
12167 if (attack_mode == ATTACK_MODE_BF)
12168 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12169
12170 data.opti_type = opti_type;
12171
12172 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12173 {
12174 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12175 {
12176 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12177 {
12178 if (opts_type & OPTS_TYPE_ST_ADD80)
12179 {
12180 opts_type &= ~OPTS_TYPE_ST_ADD80;
12181 opts_type |= OPTS_TYPE_PT_ADD80;
12182 }
12183
12184 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12185 {
12186 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12187 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12188 }
12189
12190 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12191 {
12192 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12193 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12194 }
12195 }
12196 }
12197 }
12198
12199 /**
12200 * Some algorithm, like descrypt, can benefit from JIT compilation
12201 */
12202
12203 int force_jit_compilation = -1;
12204
12205 if (hash_mode == 8900)
12206 {
12207 force_jit_compilation = 8900;
12208 }
12209 else if (hash_mode == 9300)
12210 {
12211 force_jit_compilation = 8900;
12212 }
12213 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12214 {
12215 force_jit_compilation = 1500;
12216 }
12217
12218 /**
12219 * generate bitmap tables
12220 */
12221
12222 const uint bitmap_shift1 = 5;
12223 const uint bitmap_shift2 = 13;
12224
12225 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12226
12227 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12228 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12229 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12230 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12231 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12232 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12233 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12234 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12235
12236 uint bitmap_bits;
12237 uint bitmap_nums;
12238 uint bitmap_mask;
12239 uint bitmap_size;
12240
12241 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12242 {
12243 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12244
12245 bitmap_nums = 1 << bitmap_bits;
12246
12247 bitmap_mask = bitmap_nums - 1;
12248
12249 bitmap_size = bitmap_nums * sizeof (uint);
12250
12251 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12252
12253 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;
12254 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;
12255
12256 break;
12257 }
12258
12259 bitmap_nums = 1 << bitmap_bits;
12260
12261 bitmap_mask = bitmap_nums - 1;
12262
12263 bitmap_size = bitmap_nums * sizeof (uint);
12264
12265 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);
12266 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);
12267
12268 /**
12269 * prepare quick rule
12270 */
12271
12272 data.rule_buf_l = rule_buf_l;
12273 data.rule_buf_r = rule_buf_r;
12274
12275 int rule_len_l = (int) strlen (rule_buf_l);
12276 int rule_len_r = (int) strlen (rule_buf_r);
12277
12278 data.rule_len_l = rule_len_l;
12279 data.rule_len_r = rule_len_r;
12280
12281 /**
12282 * load rules
12283 */
12284
12285 uint *all_kernel_rules_cnt = NULL;
12286
12287 kernel_rule_t **all_kernel_rules_buf = NULL;
12288
12289 if (rp_files_cnt)
12290 {
12291 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12292
12293 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12294 }
12295
12296 char rule_buf[BUFSIZ] = { 0 };
12297
12298 int rule_len = 0;
12299
12300 for (uint i = 0; i < rp_files_cnt; i++)
12301 {
12302 uint kernel_rules_avail = 0;
12303
12304 uint kernel_rules_cnt = 0;
12305
12306 kernel_rule_t *kernel_rules_buf = NULL;
12307
12308 char *rp_file = rp_files[i];
12309
12310 char in[BLOCK_SIZE] = { 0 };
12311 char out[BLOCK_SIZE] = { 0 };
12312
12313 FILE *fp = NULL;
12314
12315 uint rule_line = 0;
12316
12317 if ((fp = fopen (rp_file, "rb")) == NULL)
12318 {
12319 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12320
12321 return (-1);
12322 }
12323
12324 while (!feof (fp))
12325 {
12326 memset (rule_buf, 0, BUFSIZ);
12327
12328 rule_len = fgetl (fp, rule_buf);
12329
12330 rule_line++;
12331
12332 if (rule_len == 0) continue;
12333
12334 if (rule_buf[0] == '#') continue;
12335
12336 if (kernel_rules_avail == kernel_rules_cnt)
12337 {
12338 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12339
12340 kernel_rules_avail += INCR_RULES;
12341 }
12342
12343 memset (in, 0, BLOCK_SIZE);
12344 memset (out, 0, BLOCK_SIZE);
12345
12346 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12347
12348 if (result == -1)
12349 {
12350 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12351
12352 continue;
12353 }
12354
12355 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12356 {
12357 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12358
12359 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12360
12361 continue;
12362 }
12363
12364 /* its so slow
12365 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12366 {
12367 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12368
12369 continue;
12370 }
12371 */
12372
12373 kernel_rules_cnt++;
12374 }
12375
12376 fclose (fp);
12377
12378 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12379
12380 all_kernel_rules_buf[i] = kernel_rules_buf;
12381 }
12382
12383 /**
12384 * merge rules or automatic rule generator
12385 */
12386
12387 uint kernel_rules_cnt = 0;
12388
12389 kernel_rule_t *kernel_rules_buf = NULL;
12390
12391 if (attack_mode == ATTACK_MODE_STRAIGHT)
12392 {
12393 if (rp_files_cnt)
12394 {
12395 kernel_rules_cnt = 1;
12396
12397 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12398
12399 repeats[0] = kernel_rules_cnt;
12400
12401 for (uint i = 0; i < rp_files_cnt; i++)
12402 {
12403 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12404
12405 repeats[i + 1] = kernel_rules_cnt;
12406 }
12407
12408 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12409
12410 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12411
12412 for (uint i = 0; i < kernel_rules_cnt; i++)
12413 {
12414 uint out_pos = 0;
12415
12416 kernel_rule_t *out = &kernel_rules_buf[i];
12417
12418 for (uint j = 0; j < rp_files_cnt; j++)
12419 {
12420 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12421 uint in_pos;
12422
12423 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12424
12425 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12426 {
12427 if (out_pos == RULES_MAX - 1)
12428 {
12429 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12430
12431 break;
12432 }
12433
12434 out->cmds[out_pos] = in->cmds[in_pos];
12435 }
12436 }
12437 }
12438
12439 local_free (repeats);
12440 }
12441 else if (rp_gen)
12442 {
12443 uint kernel_rules_avail = 0;
12444
12445 while (kernel_rules_cnt < rp_gen)
12446 {
12447 if (kernel_rules_avail == kernel_rules_cnt)
12448 {
12449 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12450
12451 kernel_rules_avail += INCR_RULES;
12452 }
12453
12454 memset (rule_buf, 0, BLOCK_SIZE);
12455
12456 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12457
12458 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12459
12460 kernel_rules_cnt++;
12461 }
12462 }
12463 }
12464
12465 /**
12466 * generate NOP rules
12467 */
12468
12469 if (kernel_rules_cnt == 0)
12470 {
12471 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12472
12473 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12474
12475 kernel_rules_cnt++;
12476 }
12477
12478 data.kernel_rules_cnt = kernel_rules_cnt;
12479 data.kernel_rules_buf = kernel_rules_buf;
12480
12481 /**
12482 * OpenCL platforms: detect
12483 */
12484
12485 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12486 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12487
12488 cl_uint platforms_cnt = 0;
12489 cl_uint platform_devices_cnt = 0;
12490
12491 if (keyspace == 0)
12492 {
12493 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12494
12495 if (platforms_cnt == 0)
12496 {
12497 log_error ("ERROR: No OpenCL compatible platform found");
12498
12499 return (-1);
12500 }
12501
12502 if (opencl_platforms_filter != (uint) -1)
12503 {
12504 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12505
12506 if (opencl_platforms_filter > platform_cnt_mask)
12507 {
12508 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12509
12510 return (-1);
12511 }
12512 }
12513 }
12514
12515 /**
12516 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12517 */
12518
12519 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12520 {
12521 cl_platform_id platform = platforms[platform_id];
12522
12523 char platform_vendor[INFOSZ] = { 0 };
12524
12525 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12526
12527 #ifdef HAVE_HWMON
12528 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12529 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12530 {
12531 // make sure that we do not directly control the fan for NVidia
12532
12533 gpu_temp_retain = 0;
12534
12535 data.gpu_temp_retain = gpu_temp_retain;
12536 }
12537 #endif // HAVE_NVML || HAVE_NVAPI
12538 #endif
12539 }
12540
12541 /**
12542 * OpenCL devices: simply push all devices from all platforms into the same device array
12543 */
12544
12545 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12546
12547 data.devices_param = devices_param;
12548
12549 uint devices_cnt = 0;
12550
12551 uint devices_active = 0;
12552
12553 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12554 {
12555 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12556
12557 cl_platform_id platform = platforms[platform_id];
12558
12559 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12560
12561 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12562 {
12563 size_t param_value_size = 0;
12564
12565 const uint device_id = devices_cnt;
12566
12567 hc_device_param_t *device_param = &data.devices_param[device_id];
12568
12569 device_param->device = platform_devices[platform_devices_id];
12570
12571 device_param->device_id = device_id;
12572
12573 device_param->platform_devices_id = platform_devices_id;
12574
12575 // device_type
12576
12577 cl_device_type device_type;
12578
12579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12580
12581 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12582
12583 device_param->device_type = device_type;
12584
12585 // vendor_id
12586
12587 cl_uint vendor_id = 0;
12588
12589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12590
12591 device_param->vendor_id = vendor_id;
12592
12593 // device_name
12594
12595 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12596
12597 char *device_name = (char *) mymalloc (param_value_size);
12598
12599 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12600
12601 device_param->device_name = device_name;
12602
12603 // tuning db
12604
12605 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12606
12607 // device_version
12608
12609 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12610
12611 char *device_version = (char *) mymalloc (param_value_size);
12612
12613 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12614
12615 device_param->device_version = device_version;
12616
12617 // device_opencl_version
12618
12619 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12620
12621 char *device_opencl_version = (char *) mymalloc (param_value_size);
12622
12623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12624
12625 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12626
12627 myfree (device_opencl_version);
12628
12629 if (strstr (device_version, "pocl"))
12630 {
12631 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12632 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12633
12634 cl_uint vendor_id = VENDOR_ID_GENERIC;
12635
12636 device_param->vendor_id = vendor_id;
12637 }
12638
12639 // vector_width
12640
12641 cl_uint vector_width;
12642
12643 if (opencl_vector_width_chgd == 0)
12644 {
12645 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12646 {
12647 if (opti_type & OPTI_TYPE_USES_BITS_64)
12648 {
12649 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12650 }
12651 else
12652 {
12653 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12654 }
12655 }
12656 else
12657 {
12658 vector_width = (cl_uint) tuningdb_entry->vector_width;
12659 }
12660 }
12661 else
12662 {
12663 vector_width = opencl_vector_width;
12664 }
12665
12666 if (vector_width > 16) vector_width = 16;
12667
12668 device_param->vector_width = vector_width;
12669
12670 // max_compute_units
12671
12672 cl_uint device_processors;
12673
12674 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12675
12676 device_param->device_processors = device_processors;
12677
12678 // max_mem_alloc_size
12679
12680 cl_ulong device_maxmem_alloc;
12681
12682 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12683
12684 device_param->device_maxmem_alloc = device_maxmem_alloc;
12685
12686 // max_mem_alloc_size
12687
12688 cl_ulong device_global_mem;
12689
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12691
12692 device_param->device_global_mem = device_global_mem;
12693
12694 // max_clock_frequency
12695
12696 cl_uint device_maxclock_frequency;
12697
12698 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12699
12700 device_param->device_maxclock_frequency = device_maxclock_frequency;
12701
12702 // skipped
12703
12704 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12705 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12706
12707 device_param->skipped = (skipped1 || skipped2);
12708
12709 // driver_version
12710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12711
12712 char *driver_version = (char *) mymalloc (param_value_size);
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12715
12716 device_param->driver_version = driver_version;
12717
12718 // device_name_chksum
12719
12720 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12721
12722 #if __x86_64__
12723 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);
12724 #else
12725 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);
12726 #endif
12727
12728 uint device_name_digest[4] = { 0 };
12729
12730 md5_64 ((uint *) device_name_chksum, device_name_digest);
12731
12732 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12733
12734 device_param->device_name_chksum = device_name_chksum;
12735
12736 // device_processor_cores
12737
12738 if (device_type & CL_DEVICE_TYPE_CPU)
12739 {
12740 cl_uint device_processor_cores = 1;
12741
12742 device_param->device_processor_cores = device_processor_cores;
12743 }
12744
12745 if (device_type & CL_DEVICE_TYPE_GPU)
12746 {
12747 if (vendor_id == VENDOR_ID_AMD)
12748 {
12749 cl_uint device_processor_cores = 0;
12750
12751 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12752
12753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12754
12755 device_param->device_processor_cores = device_processor_cores;
12756 }
12757 else if (vendor_id == VENDOR_ID_NV)
12758 {
12759 cl_uint kernel_exec_timeout = 0;
12760
12761 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12762
12763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12764
12765 device_param->kernel_exec_timeout = kernel_exec_timeout;
12766
12767 cl_uint device_processor_cores = 0;
12768
12769 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12770
12771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12772
12773 device_param->device_processor_cores = device_processor_cores;
12774
12775 cl_uint sm_minor = 0;
12776 cl_uint sm_major = 0;
12777
12778 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12779 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12780
12781 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12783
12784 device_param->sm_minor = sm_minor;
12785 device_param->sm_major = sm_major;
12786 }
12787 else
12788 {
12789 cl_uint device_processor_cores = 1;
12790
12791 device_param->device_processor_cores = device_processor_cores;
12792 }
12793 }
12794
12795 // display results
12796
12797 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12798 {
12799 if (device_param->skipped == 0)
12800 {
12801 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12802 device_id + 1,
12803 device_name,
12804 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12805 (unsigned int) (device_global_mem / 1024 / 1024),
12806 (unsigned int) (device_maxclock_frequency),
12807 (unsigned int) device_processors);
12808 }
12809 else
12810 {
12811 log_info ("Device #%u: %s, skipped",
12812 device_id + 1,
12813 device_name);
12814 }
12815 }
12816
12817 // common driver check
12818
12819 if (device_param->skipped == 0)
12820 {
12821 if (strstr (device_version, "pocl"))
12822 {
12823 if (force == 0)
12824 {
12825 log_info ("");
12826 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12827 log_info ("You are STRONGLY encouraged not to use it");
12828 log_info ("You can use --force to override this but do not post error reports if you do so");
12829 log_info ("");
12830
12831 return (-1);
12832 }
12833 }
12834
12835 if (device_type & CL_DEVICE_TYPE_GPU)
12836 {
12837 if (vendor_id == VENDOR_ID_NV)
12838 {
12839 if (device_param->kernel_exec_timeout != 0)
12840 {
12841 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);
12842 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12843 }
12844 }
12845 else if (vendor_id == VENDOR_ID_AMD)
12846 {
12847 int catalyst_check = (force == 1) ? 0 : 1;
12848
12849 int catalyst_warn = 0;
12850
12851 int catalyst_broken = 0;
12852
12853 if (catalyst_check == 1)
12854 {
12855 catalyst_warn = 1;
12856
12857 // v14.9 and higher
12858 if (atoi (device_param->driver_version) >= 1573)
12859 {
12860 catalyst_warn = 0;
12861 }
12862
12863 catalyst_check = 0;
12864 }
12865
12866 if (catalyst_broken == 1)
12867 {
12868 log_info ("");
12869 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12870 log_info ("It will pass over cracked hashes and does not report them as cracked");
12871 log_info ("You are STRONGLY encouraged not to use it");
12872 log_info ("You can use --force to override this but do not post error reports if you do so");
12873 log_info ("");
12874
12875 return (-1);
12876 }
12877
12878 if (catalyst_warn == 1)
12879 {
12880 log_info ("");
12881 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12882 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12883 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12884 #ifdef _WIN
12885 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12886 #endif
12887 log_info ("You can use --force to override this but do not post error reports if you do so");
12888 log_info ("");
12889
12890 return (-1);
12891 }
12892 }
12893 }
12894
12895 /**
12896 * kernel accel and loops tuning db adjustment
12897 */
12898
12899 device_param->kernel_accel_min = 1;
12900 device_param->kernel_accel_max = 1024;
12901
12902 device_param->kernel_loops_min = 1;
12903 device_param->kernel_loops_max = 1024;
12904
12905 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12906
12907 if (tuningdb_entry)
12908 {
12909 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12910 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12911
12912 if (_kernel_accel)
12913 {
12914 device_param->kernel_accel_min = _kernel_accel;
12915 device_param->kernel_accel_max = _kernel_accel;
12916 }
12917
12918 if (_kernel_loops)
12919 {
12920 if (workload_profile == 1)
12921 {
12922 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12923 }
12924 else if (workload_profile == 2)
12925 {
12926 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12927 }
12928
12929 device_param->kernel_loops_min = _kernel_loops;
12930 device_param->kernel_loops_max = _kernel_loops;
12931 }
12932 }
12933
12934 // commandline parameters overwrite tuningdb entries
12935
12936 if (kernel_accel)
12937 {
12938 device_param->kernel_accel_min = kernel_accel;
12939 device_param->kernel_accel_max = kernel_accel;
12940 }
12941
12942 if (kernel_loops)
12943 {
12944 device_param->kernel_loops_min = kernel_loops;
12945 device_param->kernel_loops_max = kernel_loops;
12946 }
12947
12948 /**
12949 * activate device
12950 */
12951
12952 devices_active++;
12953 }
12954
12955 // next please
12956
12957 devices_cnt++;
12958 }
12959 }
12960
12961 if (keyspace == 0 && devices_active == 0)
12962 {
12963 log_error ("ERROR: No devices found/left");
12964
12965 return (-1);
12966 }
12967
12968 // 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)
12969
12970 if (devices_filter != (uint) -1)
12971 {
12972 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
12973
12974 if (devices_filter > devices_cnt_mask)
12975 {
12976 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
12977
12978 return (-1);
12979 }
12980 }
12981
12982 data.devices_cnt = devices_cnt;
12983
12984 data.devices_active = devices_active;
12985
12986 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12987 {
12988 log_info ("");
12989 }
12990
12991 /**
12992 * HM devices: init
12993 */
12994
12995 #ifdef HAVE_HWMON
12996 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12997 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12998 #endif
12999
13000 #ifdef HAVE_ADL
13001 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13002 #endif
13003
13004 if (gpu_temp_disable == 0)
13005 {
13006 #if defined(WIN) && defined(HAVE_NVAPI)
13007 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13008
13009 if (nvapi_init (nvapi) == 0)
13010 data.hm_nv = nvapi;
13011
13012 if (data.hm_nv)
13013 {
13014 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13015 {
13016 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13017
13018 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13019
13020 int tmp_out = 0;
13021
13022 for (int i = 0; i < tmp_in; i++)
13023 {
13024 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13025 }
13026
13027 for (int i = 0; i < tmp_out; i++)
13028 {
13029 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13030
13031 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13032
13033 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;
13034 }
13035 }
13036 }
13037 #endif // WIN && HAVE_NVAPI
13038
13039 #if defined(LINUX) && defined(HAVE_NVML)
13040 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13041
13042 if (nvml_init (nvml) == 0)
13043 data.hm_nv = nvml;
13044
13045 if (data.hm_nv)
13046 {
13047 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13048 {
13049 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13050
13051 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13052
13053 int tmp_out = 0;
13054
13055 for (int i = 0; i < tmp_in; i++)
13056 {
13057 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13058 }
13059
13060 for (int i = 0; i < tmp_out; i++)
13061 {
13062 unsigned int speed;
13063
13064 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;
13065 }
13066 }
13067 }
13068 #endif // LINUX && HAVE_NVML
13069
13070 data.hm_amd = NULL;
13071
13072 #ifdef HAVE_ADL
13073 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13074
13075 if (adl_init (adl) == 0)
13076 data.hm_amd = adl;
13077
13078 if (data.hm_amd)
13079 {
13080 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13081 {
13082 // total number of adapters
13083
13084 int hm_adapters_num;
13085
13086 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13087
13088 // adapter info
13089
13090 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13091
13092 if (lpAdapterInfo == NULL) return (-1);
13093
13094 // get a list (of ids of) valid/usable adapters
13095
13096 int num_adl_adapters = 0;
13097
13098 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13099
13100 if (num_adl_adapters > 0)
13101 {
13102 hc_thread_mutex_lock (mux_adl);
13103
13104 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13105
13106 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13107
13108 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13109 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13110
13111 hc_thread_mutex_unlock (mux_adl);
13112 }
13113
13114 myfree (valid_adl_device_list);
13115 myfree (lpAdapterInfo);
13116 }
13117 }
13118 #endif // HAVE_ADL
13119
13120 if (data.hm_amd == NULL && data.hm_nv == NULL)
13121 {
13122 gpu_temp_disable = 1;
13123 }
13124 }
13125
13126 /**
13127 * OpenCL devices: allocate buffer for device specific information
13128 */
13129
13130 #ifdef HAVE_HWMON
13131 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13132
13133 #ifdef HAVE_ADL
13134 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13135
13136 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13137 #endif // ADL
13138 #endif
13139
13140 /**
13141 * enable custom signal handler(s)
13142 */
13143
13144 if (benchmark == 0)
13145 {
13146 hc_signal (sigHandler_default);
13147 }
13148 else
13149 {
13150 hc_signal (sigHandler_benchmark);
13151 }
13152
13153 /**
13154 * User-defined GPU temp handling
13155 */
13156
13157 #ifdef HAVE_HWMON
13158 if (gpu_temp_disable == 1)
13159 {
13160 gpu_temp_abort = 0;
13161 gpu_temp_retain = 0;
13162 }
13163
13164 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13165 {
13166 if (gpu_temp_abort < gpu_temp_retain)
13167 {
13168 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13169
13170 return (-1);
13171 }
13172 }
13173
13174 data.gpu_temp_disable = gpu_temp_disable;
13175 data.gpu_temp_abort = gpu_temp_abort;
13176 data.gpu_temp_retain = gpu_temp_retain;
13177 #endif
13178
13179 /**
13180 * inform the user
13181 */
13182
13183 if (data.quiet == 0)
13184 {
13185 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13186
13187 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);
13188
13189 if (attack_mode == ATTACK_MODE_STRAIGHT)
13190 {
13191 log_info ("Rules: %u", kernel_rules_cnt);
13192 }
13193
13194 if (opti_type)
13195 {
13196 log_info ("Applicable Optimizers:");
13197
13198 for (uint i = 0; i < 32; i++)
13199 {
13200 const uint opti_bit = 1u << i;
13201
13202 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13203 }
13204 }
13205
13206 /**
13207 * Watchdog and Temperature balance
13208 */
13209
13210 #ifdef HAVE_HWMON
13211 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13212 {
13213 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13214 }
13215
13216 if (gpu_temp_abort == 0)
13217 {
13218 log_info ("Watchdog: Temperature abort trigger disabled");
13219 }
13220 else
13221 {
13222 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13223 }
13224
13225 if (gpu_temp_retain == 0)
13226 {
13227 log_info ("Watchdog: Temperature retain trigger disabled");
13228 }
13229 else
13230 {
13231 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13232 }
13233 #endif
13234 }
13235
13236 if (data.quiet == 0) log_info ("");
13237
13238 /**
13239 * HM devices: copy
13240 */
13241
13242 if (gpu_temp_disable == 0)
13243 {
13244 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13245 {
13246 hc_device_param_t *device_param = &data.devices_param[device_id];
13247
13248 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13249
13250 if (device_param->skipped) continue;
13251
13252 const uint platform_devices_id = device_param->platform_devices_id;
13253
13254 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13255 if (device_param->vendor_id == VENDOR_ID_NV)
13256 {
13257 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13258 }
13259 #endif
13260
13261 #ifdef HAVE_ADL
13262 if (device_param->vendor_id == VENDOR_ID_AMD)
13263 {
13264 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13265 }
13266 #endif
13267 }
13268 }
13269
13270 /*
13271 * Temporary fix:
13272 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13273 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13274 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13275 * Driver / ADL bug?
13276 */
13277
13278 #ifdef HAVE_ADL
13279 if (powertune_enable == 1)
13280 {
13281 hc_thread_mutex_lock (mux_adl);
13282
13283 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13284 {
13285 hc_device_param_t *device_param = &data.devices_param[device_id];
13286
13287 if (device_param->skipped) continue;
13288
13289 if (data.hm_device[device_id].od_version == 6)
13290 {
13291 // set powertune value only
13292
13293 int powertune_supported = 0;
13294
13295 int ADL_rc = 0;
13296
13297 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13298 {
13299 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13300
13301 return (-1);
13302 }
13303
13304 if (powertune_supported != 0)
13305 {
13306 // powertune set
13307 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13308
13309 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13310 {
13311 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13312
13313 return (-1);
13314 }
13315
13316 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13317 {
13318 log_error ("ERROR: Failed to set new ADL PowerControl values");
13319
13320 return (-1);
13321 }
13322 }
13323 }
13324 }
13325
13326 hc_thread_mutex_unlock (mux_adl);
13327 }
13328 #endif // HAVE_ADK
13329 #endif // HAVE_HWMON
13330
13331 #ifdef DEBUG
13332 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13333 #endif
13334
13335 uint kernel_power_all = 0;
13336
13337 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13338 {
13339 /**
13340 * host buffer
13341 */
13342
13343 hc_device_param_t *device_param = &data.devices_param[device_id];
13344
13345 if (device_param->skipped) continue;
13346
13347 /**
13348 * device properties
13349 */
13350
13351 const char *device_name_chksum = device_param->device_name_chksum;
13352 const u32 device_processors = device_param->device_processors;
13353 const u32 device_processor_cores = device_param->device_processor_cores;
13354
13355 /**
13356 * create context for each device
13357 */
13358
13359 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13360
13361 /**
13362 * create command-queue
13363 */
13364
13365 // not supported with NV
13366 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13367
13368 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13369
13370 /**
13371 * create input buffers on device : calculate size of fixed memory buffers
13372 */
13373
13374 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13375 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13376
13377 device_param->size_root_css = size_root_css;
13378 device_param->size_markov_css = size_markov_css;
13379
13380 uint size_results = KERNEL_THREADS * sizeof (uint);
13381
13382 device_param->size_results = size_results;
13383
13384 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13385 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13386
13387 uint size_plains = digests_cnt * sizeof (plain_t);
13388 uint size_salts = salts_cnt * sizeof (salt_t);
13389 uint size_esalts = salts_cnt * esalt_size;
13390
13391 device_param->size_plains = size_plains;
13392 device_param->size_digests = size_digests;
13393 device_param->size_shown = size_shown;
13394 device_param->size_salts = size_salts;
13395
13396 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13397 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13398 uint size_tm = 32 * sizeof (bs_word_t);
13399
13400 // scryptV stuff
13401
13402 u64 size_scryptV = 1;
13403
13404 if ((hash_mode == 8900) || (hash_mode == 9300))
13405 {
13406 uint tmto_start = 0;
13407 uint tmto_stop = 10;
13408
13409 if (scrypt_tmto)
13410 {
13411 tmto_start = scrypt_tmto;
13412 }
13413 else
13414 {
13415 // in case the user did not specify the tmto manually
13416 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13417 // but set the lower end only in case the user has a device with too less memory
13418
13419 if (hash_mode == 8900)
13420 {
13421 if (device_param->vendor_id == VENDOR_ID_AMD)
13422 {
13423 tmto_start = 1;
13424 }
13425 else if (device_param->vendor_id == VENDOR_ID_NV)
13426 {
13427 tmto_start = 3;
13428 }
13429 }
13430 else if (hash_mode == 9300)
13431 {
13432 if (device_param->vendor_id == VENDOR_ID_AMD)
13433 {
13434 tmto_start = 3;
13435 }
13436 else if (device_param->vendor_id == VENDOR_ID_NV)
13437 {
13438 tmto_start = 5;
13439 }
13440 }
13441 }
13442
13443 if (quiet == 0) log_info ("");
13444
13445 uint shader_per_mp = 1;
13446
13447 if (device_param->vendor_id == VENDOR_ID_AMD)
13448 {
13449 shader_per_mp = 8;
13450 }
13451 else if (device_param->vendor_id == VENDOR_ID_NV)
13452 {
13453 shader_per_mp = 32;
13454 }
13455
13456 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13457 {
13458 // TODO: in theory the following calculation needs to be done per salt, not global
13459 // we assume all hashes have the same scrypt settings
13460
13461 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13462
13463 size_scryptV /= 1 << tmto;
13464
13465 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13466
13467 if (size_scryptV > device_param->device_maxmem_alloc)
13468 {
13469 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13470
13471 continue;
13472 }
13473
13474 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13475 {
13476 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13477 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13478 }
13479
13480 break;
13481 }
13482
13483 if (data.salts_buf[0].scrypt_phy == 0)
13484 {
13485 log_error ("ERROR: can't allocate enough device memory");
13486
13487 return -1;
13488 }
13489
13490 if (quiet == 0) log_info ("");
13491 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13492 }
13493
13494 /**
13495 * create input buffers on device : calculate size of dynamic size memory buffers
13496 */
13497
13498 uint kernel_threads = KERNEL_THREADS;
13499
13500 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13501
13502 if (hash_mode == 3200) kernel_threads = 8;
13503 if (hash_mode == 9000) kernel_threads = 8;
13504
13505 /**
13506 * some algorithms need a fixed kernel-loops count
13507 */
13508
13509 if (hash_mode == 1500)
13510 {
13511 const u32 kernel_loops_fixed = 1024;
13512
13513 device_param->kernel_loops_min = kernel_loops_fixed;
13514 device_param->kernel_loops_max = kernel_loops_fixed;
13515 }
13516
13517 if (hash_mode == 3000)
13518 {
13519 const u32 kernel_loops_fixed = 1024;
13520
13521 device_param->kernel_loops_min = kernel_loops_fixed;
13522 device_param->kernel_loops_max = kernel_loops_fixed;
13523 }
13524
13525 if (hash_mode == 8900)
13526 {
13527 const u32 kernel_loops_fixed = 1;
13528
13529 device_param->kernel_loops_min = kernel_loops_fixed;
13530 device_param->kernel_loops_max = kernel_loops_fixed;
13531 }
13532
13533 if (hash_mode == 9300)
13534 {
13535 const u32 kernel_loops_fixed = 1;
13536
13537 device_param->kernel_loops_min = kernel_loops_fixed;
13538 device_param->kernel_loops_max = kernel_loops_fixed;
13539 }
13540
13541 if (hash_mode == 12500)
13542 {
13543 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13544
13545 device_param->kernel_loops_min = kernel_loops_fixed;
13546 device_param->kernel_loops_max = kernel_loops_fixed;
13547 }
13548
13549 /**
13550 * some algorithms have a maximum kernel-loops count
13551 */
13552
13553 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13554 {
13555 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13556 {
13557 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13558 }
13559 }
13560
13561 /**
13562 * some algorithms need a special kernel-accel
13563 */
13564
13565 if (hash_mode == 8900)
13566 {
13567 device_param->kernel_accel_min = 1;
13568 device_param->kernel_accel_max = 64;
13569 }
13570
13571 if (hash_mode == 9300)
13572 {
13573 device_param->kernel_accel_min = 1;
13574 device_param->kernel_accel_max = 64;
13575 }
13576
13577 u32 kernel_accel_min = device_param->kernel_accel_min;
13578 u32 kernel_accel_max = device_param->kernel_accel_max;
13579
13580 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13581
13582 uint size_pws = 4;
13583 uint size_tmps = 4;
13584 uint size_hooks = 4;
13585
13586 while (kernel_accel_max >= kernel_accel_min)
13587 {
13588 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13589
13590 // size_pws
13591
13592 size_pws = kernel_power_max * sizeof (pw_t);
13593
13594 // size_tmps
13595
13596 switch (hash_mode)
13597 {
13598 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13599 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13600 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13601 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13602 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13603 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13604 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13605 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13606 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13607 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13608 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13609 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13610 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13611 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13612 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13613 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13614 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13615 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13616 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13617 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13618 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13619 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13620 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13621 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13622 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13623 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13624 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13625 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13626 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13627 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13628 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13629 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13630 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13631 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13632 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13633 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13634 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13635 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13636 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13637 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13638 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13639 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13640 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13641 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13642 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13643 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13644 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13645 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13646 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13647 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13648 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13649 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13650 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13651 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13652 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13653 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13654 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13655 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13656 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13657 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13658 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13659 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13660 };
13661
13662 // size_hooks
13663
13664 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13665 {
13666 // none yet
13667 }
13668
13669 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13670 // if not, decrease amplifier and try again
13671
13672 int skip = 0;
13673
13674 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13675 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13676 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13677
13678 if (( bitmap_size
13679 + bitmap_size
13680 + bitmap_size
13681 + bitmap_size
13682 + bitmap_size
13683 + bitmap_size
13684 + bitmap_size
13685 + bitmap_size
13686 + size_bfs
13687 + size_combs
13688 + size_digests
13689 + size_esalts
13690 + size_hooks
13691 + size_markov_css
13692 + size_plains
13693 + size_pws
13694 + size_results
13695 + size_root_css
13696 + size_rules
13697 + size_rules_c
13698 + size_salts
13699 + size_scryptV
13700 + size_shown
13701 + size_tm
13702 + size_tmps) > device_param->device_global_mem) skip = 1;
13703
13704 if (skip == 1)
13705 {
13706 kernel_accel_max--;
13707
13708 continue;
13709 }
13710
13711 break;
13712 }
13713
13714 /*
13715 if (kernel_accel_max == 0)
13716 {
13717 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13718
13719 return -1;
13720 }
13721 */
13722
13723 device_param->kernel_accel_min = kernel_accel_min;
13724 device_param->kernel_accel_max = kernel_accel_max;
13725
13726 /*
13727 if (kernel_accel_max < kernel_accel)
13728 {
13729 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13730
13731 device_param->kernel_accel = kernel_accel_max;
13732 }
13733 */
13734
13735 device_param->size_bfs = size_bfs;
13736 device_param->size_combs = size_combs;
13737 device_param->size_rules = size_rules;
13738 device_param->size_rules_c = size_rules_c;
13739 device_param->size_pws = size_pws;
13740 device_param->size_tmps = size_tmps;
13741 device_param->size_hooks = size_hooks;
13742
13743 // do not confuse kernel_accel_max with kernel_accel here
13744
13745 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13746
13747 device_param->kernel_threads = kernel_threads;
13748 device_param->kernel_power_user = kernel_power;
13749
13750 kernel_power_all += kernel_power;
13751
13752 /**
13753 * default building options
13754 */
13755
13756 char build_opts[1024] = { 0 };
13757
13758 // we don't have sm_* on vendors not NV but it doesn't matter
13759
13760 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13761
13762 /**
13763 * main kernel
13764 */
13765
13766 {
13767 /**
13768 * kernel source filename
13769 */
13770
13771 char source_file[256] = { 0 };
13772
13773 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13774
13775 struct stat sst;
13776
13777 if (stat (source_file, &sst) == -1)
13778 {
13779 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13780
13781 return -1;
13782 }
13783
13784 /**
13785 * kernel cached filename
13786 */
13787
13788 char cached_file[256] = { 0 };
13789
13790 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13791
13792 int cached = 1;
13793
13794 struct stat cst;
13795
13796 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13797 {
13798 cached = 0;
13799 }
13800
13801 /**
13802 * kernel compile or load
13803 */
13804
13805 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13806
13807 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13808
13809 if (force_jit_compilation == -1)
13810 {
13811 if (cached == 0)
13812 {
13813 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13814
13815 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13816
13817 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13818
13819 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13820
13821 if (rc != 0)
13822 {
13823 device_param->skipped = true;
13824 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13825 continue;
13826 }
13827
13828 size_t binary_size;
13829
13830 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13831
13832 u8 *binary = (u8 *) mymalloc (binary_size);
13833
13834 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13835
13836 writeProgramBin (cached_file, binary, binary_size);
13837
13838 local_free (binary);
13839 }
13840 else
13841 {
13842 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13843
13844 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13845
13846 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13847
13848 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13849 }
13850 }
13851 else
13852 {
13853 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13854
13855 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13856
13857 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13858
13859 char build_opts_update[1024] = { 0 };
13860
13861 if (force_jit_compilation == 1500)
13862 {
13863 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13864 }
13865 else if (force_jit_compilation == 8900)
13866 {
13867 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);
13868 }
13869 else
13870 {
13871 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13872 }
13873
13874 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13875
13876 if (rc != 0)
13877 {
13878 device_param->skipped = true;
13879
13880 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13881 }
13882 }
13883
13884 local_free (kernel_lengths);
13885 local_free (kernel_sources[0]);
13886 local_free (kernel_sources);
13887 }
13888
13889 /**
13890 * word generator kernel
13891 */
13892
13893 if (attack_mode != ATTACK_MODE_STRAIGHT)
13894 {
13895 /**
13896 * kernel mp source filename
13897 */
13898
13899 char source_file[256] = { 0 };
13900
13901 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13902
13903 struct stat sst;
13904
13905 if (stat (source_file, &sst) == -1)
13906 {
13907 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13908
13909 return -1;
13910 }
13911
13912 /**
13913 * kernel mp cached filename
13914 */
13915
13916 char cached_file[256] = { 0 };
13917
13918 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13919
13920 int cached = 1;
13921
13922 struct stat cst;
13923
13924 if (stat (cached_file, &cst) == -1)
13925 {
13926 cached = 0;
13927 }
13928
13929 /**
13930 * kernel compile or load
13931 */
13932
13933 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13934
13935 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13936
13937 if (cached == 0)
13938 {
13939 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13940
13941 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13942
13943 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13944
13945 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13946
13947 if (rc != 0)
13948 {
13949 device_param->skipped = true;
13950 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13951 continue;
13952 }
13953
13954 size_t binary_size;
13955
13956 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13957
13958 u8 *binary = (u8 *) mymalloc (binary_size);
13959
13960 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13961
13962 writeProgramBin (cached_file, binary, binary_size);
13963
13964 local_free (binary);
13965 }
13966 else
13967 {
13968 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13969
13970 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13971
13972 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13973
13974 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13975 }
13976
13977 local_free (kernel_lengths);
13978 local_free (kernel_sources[0]);
13979 local_free (kernel_sources);
13980 }
13981
13982 /**
13983 * amplifier kernel
13984 */
13985
13986 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13987 {
13988
13989 }
13990 else
13991 {
13992 /**
13993 * kernel amp source filename
13994 */
13995
13996 char source_file[256] = { 0 };
13997
13998 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13999
14000 struct stat sst;
14001
14002 if (stat (source_file, &sst) == -1)
14003 {
14004 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14005
14006 return -1;
14007 }
14008
14009 /**
14010 * kernel amp cached filename
14011 */
14012
14013 char cached_file[256] = { 0 };
14014
14015 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14016
14017 int cached = 1;
14018
14019 struct stat cst;
14020
14021 if (stat (cached_file, &cst) == -1)
14022 {
14023 cached = 0;
14024 }
14025
14026 /**
14027 * kernel compile or load
14028 */
14029
14030 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14031
14032 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14033
14034 if (cached == 0)
14035 {
14036 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14037
14038 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14039
14040 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14041
14042 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14043
14044 if (rc != 0)
14045 {
14046 device_param->skipped = true;
14047 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14048 continue;
14049 }
14050
14051 size_t binary_size;
14052
14053 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14054
14055 u8 *binary = (u8 *) mymalloc (binary_size);
14056
14057 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14058
14059 writeProgramBin (cached_file, binary, binary_size);
14060
14061 local_free (binary);
14062 }
14063 else
14064 {
14065 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14066
14067 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14068
14069 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14070
14071 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14072 }
14073
14074 local_free (kernel_lengths);
14075 local_free (kernel_sources[0]);
14076 local_free (kernel_sources);
14077 }
14078
14079 // some algorithm collide too fast, make that impossible
14080
14081 if (benchmark == 1)
14082 {
14083 ((uint *) digests_buf)[0] = -1;
14084 ((uint *) digests_buf)[1] = -1;
14085 ((uint *) digests_buf)[2] = -1;
14086 ((uint *) digests_buf)[3] = -1;
14087 }
14088
14089 /**
14090 * global buffers
14091 */
14092
14093 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14094 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14095 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14096 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14097 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14098 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14099 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14100 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14101 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14102 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14103 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14104 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14105 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14106 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14107 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14108 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14109 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14110 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14111
14112 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);
14113 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);
14114 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);
14115 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);
14116 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);
14117 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);
14118 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);
14119 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);
14120 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14121 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14122 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14123
14124 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14125 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14126 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14127 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14128 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14129 run_kernel_bzero (device_param, device_param->d_result, size_results);
14130
14131 /**
14132 * special buffers
14133 */
14134
14135 if (attack_kern == ATTACK_KERN_STRAIGHT)
14136 {
14137 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14138 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14139
14140 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14141
14142 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14143 }
14144 else if (attack_kern == ATTACK_KERN_COMBI)
14145 {
14146 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14147 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14148 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14149 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14150
14151 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14152 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14153 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14154 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14155 }
14156 else if (attack_kern == ATTACK_KERN_BF)
14157 {
14158 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14159 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14160 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14161 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14162 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14163
14164 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14165 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14166 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14167 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14168 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14169 }
14170
14171 if (size_esalts)
14172 {
14173 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14174
14175 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14176 }
14177
14178 /**
14179 * main host data
14180 */
14181
14182 uint *result = (uint *) mymalloc (size_results);
14183
14184 device_param->result = result;
14185
14186 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14187
14188 device_param->pws_buf = pws_buf;
14189
14190 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14191
14192 device_param->combs_buf = combs_buf;
14193
14194 void *hooks_buf = mymalloc (size_hooks);
14195
14196 device_param->hooks_buf = hooks_buf;
14197
14198 /**
14199 * kernel args
14200 */
14201
14202 device_param->kernel_params_buf32[21] = bitmap_mask;
14203 device_param->kernel_params_buf32[22] = bitmap_shift1;
14204 device_param->kernel_params_buf32[23] = bitmap_shift2;
14205 device_param->kernel_params_buf32[24] = 0; // salt_pos
14206 device_param->kernel_params_buf32[25] = 0; // loop_pos
14207 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14208 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14209 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14210 device_param->kernel_params_buf32[29] = 0; // digests_offset
14211 device_param->kernel_params_buf32[30] = 0; // combs_mode
14212 device_param->kernel_params_buf32[31] = 0; // gid_max
14213
14214 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14215 ? &device_param->d_pws_buf
14216 : &device_param->d_pws_amp_buf;
14217 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14218 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14219 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14220 device_param->kernel_params[ 4] = &device_param->d_tmps;
14221 device_param->kernel_params[ 5] = &device_param->d_hooks;
14222 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14223 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14224 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14225 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14226 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14227 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14228 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14229 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14230 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14231 device_param->kernel_params[15] = &device_param->d_digests_buf;
14232 device_param->kernel_params[16] = &device_param->d_digests_shown;
14233 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14234 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14235 device_param->kernel_params[19] = &device_param->d_result;
14236 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14237 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14238 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14239 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14240 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14241 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14242 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14243 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14244 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14245 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14246 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14247 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14248
14249 device_param->kernel_params_mp_buf64[3] = 0;
14250 device_param->kernel_params_mp_buf32[4] = 0;
14251 device_param->kernel_params_mp_buf32[5] = 0;
14252 device_param->kernel_params_mp_buf32[6] = 0;
14253 device_param->kernel_params_mp_buf32[7] = 0;
14254 device_param->kernel_params_mp_buf32[8] = 0;
14255
14256 device_param->kernel_params_mp[0] = NULL;
14257 device_param->kernel_params_mp[1] = NULL;
14258 device_param->kernel_params_mp[2] = NULL;
14259 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14260 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14261 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14262 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14263 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14264 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14265
14266 device_param->kernel_params_mp_l_buf64[3] = 0;
14267 device_param->kernel_params_mp_l_buf32[4] = 0;
14268 device_param->kernel_params_mp_l_buf32[5] = 0;
14269 device_param->kernel_params_mp_l_buf32[6] = 0;
14270 device_param->kernel_params_mp_l_buf32[7] = 0;
14271 device_param->kernel_params_mp_l_buf32[8] = 0;
14272 device_param->kernel_params_mp_l_buf32[9] = 0;
14273
14274 device_param->kernel_params_mp_l[0] = NULL;
14275 device_param->kernel_params_mp_l[1] = NULL;
14276 device_param->kernel_params_mp_l[2] = NULL;
14277 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14278 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14279 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14280 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14281 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14282 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14283 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14284
14285 device_param->kernel_params_mp_r_buf64[3] = 0;
14286 device_param->kernel_params_mp_r_buf32[4] = 0;
14287 device_param->kernel_params_mp_r_buf32[5] = 0;
14288 device_param->kernel_params_mp_r_buf32[6] = 0;
14289 device_param->kernel_params_mp_r_buf32[7] = 0;
14290 device_param->kernel_params_mp_r_buf32[8] = 0;
14291
14292 device_param->kernel_params_mp_r[0] = NULL;
14293 device_param->kernel_params_mp_r[1] = NULL;
14294 device_param->kernel_params_mp_r[2] = NULL;
14295 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14296 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14297 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14298 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14299 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14300 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14301
14302 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14303 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14304
14305 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14306 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14307 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14308 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14309 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14310 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14311 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14312
14313 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14314 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14315
14316 /**
14317 * kernel name
14318 */
14319
14320 char kernel_name[64] = { 0 };
14321
14322 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14323 {
14324 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14325 {
14326 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14327
14328 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14329
14330 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14331
14332 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14333
14334 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14335
14336 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14337 }
14338 else
14339 {
14340 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14341
14342 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14343
14344 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14345
14346 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14347
14348 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14349
14350 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14351 }
14352
14353 if (data.attack_mode == ATTACK_MODE_BF)
14354 {
14355 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14356 {
14357 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14358
14359 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14360 }
14361 }
14362 }
14363 else
14364 {
14365 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14366
14367 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14368
14369 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14370
14371 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14372
14373 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14374
14375 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14376
14377 if (opts_type & OPTS_TYPE_HOOK12)
14378 {
14379 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14380
14381 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14382 }
14383
14384 if (opts_type & OPTS_TYPE_HOOK23)
14385 {
14386 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14387
14388 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14389 }
14390 }
14391
14392 for (uint i = 0; i <= 20; i++)
14393 {
14394 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14395 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14396 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14397
14398 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14399 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14400 }
14401
14402 for (uint i = 21; i <= 31; i++)
14403 {
14404 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14405 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14406 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14407
14408 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14409 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14410 }
14411
14412 if (attack_mode == ATTACK_MODE_BF)
14413 {
14414 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14415 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14416
14417 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14418 {
14419 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14420 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14421 }
14422 }
14423 else if (attack_mode == ATTACK_MODE_HYBRID1)
14424 {
14425 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14426 }
14427 else if (attack_mode == ATTACK_MODE_HYBRID2)
14428 {
14429 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14430 }
14431
14432 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14433 {
14434 // nothing to do
14435 }
14436 else
14437 {
14438 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14439 }
14440
14441 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14442 {
14443 // nothing to do
14444 }
14445 else
14446 {
14447 for (uint i = 0; i < 5; i++)
14448 {
14449 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14450 }
14451
14452 for (uint i = 5; i < 7; i++)
14453 {
14454 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14455 }
14456 }
14457
14458 /**
14459 * Store initial fanspeed if gpu_temp_retain is enabled
14460 */
14461
14462 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14463 int gpu_temp_retain_set = 0;
14464
14465 if (gpu_temp_disable == 0)
14466 {
14467 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14468 {
14469 hc_thread_mutex_lock (mux_adl);
14470
14471 if (data.hm_device[device_id].fan_supported == 1)
14472 {
14473 if (gpu_temp_retain_chgd == 0)
14474 {
14475 uint cur_temp = 0;
14476 uint default_temp = 0;
14477
14478 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);
14479
14480 if (ADL_rc == ADL_OK)
14481 {
14482 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14483
14484 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14485
14486 // special case with multi gpu setups: always use minimum retain
14487
14488 if (gpu_temp_retain_set == 0)
14489 {
14490 gpu_temp_retain = gpu_temp_retain_target;
14491 gpu_temp_retain_set = 1;
14492 }
14493 else
14494 {
14495 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14496 }
14497
14498 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14499 }
14500 }
14501
14502 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14503
14504 temp_retain_fanspeed_value[device_id] = fan_speed;
14505
14506 if (fan_speed == -1)
14507 {
14508 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14509
14510 temp_retain_fanspeed_value[device_id] = 0;
14511 }
14512 }
14513
14514 hc_thread_mutex_unlock (mux_adl);
14515 }
14516 }
14517
14518 /**
14519 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14520 */
14521
14522 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14523 {
14524 hc_thread_mutex_lock (mux_adl);
14525
14526 if (data.hm_device[device_id].od_version == 6)
14527 {
14528 int ADL_rc;
14529
14530 // check powertune capabilities first, if not available then skip device
14531
14532 int powertune_supported = 0;
14533
14534 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14535 {
14536 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14537
14538 return (-1);
14539 }
14540
14541 if (powertune_supported != 0)
14542 {
14543 // powercontrol settings
14544
14545 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14546
14547 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14548 {
14549 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14550 }
14551
14552 if (ADL_rc != ADL_OK)
14553 {
14554 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14555
14556 return (-1);
14557 }
14558
14559 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14560 {
14561 log_error ("ERROR: Failed to set new ADL PowerControl values");
14562
14563 return (-1);
14564 }
14565
14566 // clocks
14567
14568 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14569
14570 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14571
14572 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)
14573 {
14574 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14575
14576 return (-1);
14577 }
14578
14579 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14580
14581 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14582
14583 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14584 {
14585 log_error ("ERROR: Failed to get ADL device capabilities");
14586
14587 return (-1);
14588 }
14589
14590 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14591 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14592
14593 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14594 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14595
14596 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14597 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14598
14599 // warning if profile has too low max values
14600
14601 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14602 {
14603 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14604 }
14605
14606 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14607 {
14608 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14609 }
14610
14611 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14612
14613 performance_state->iNumberOfPerformanceLevels = 2;
14614
14615 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14616 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14617 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14618 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14619
14620 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)
14621 {
14622 log_info ("ERROR: Failed to set ADL performance state");
14623
14624 return (-1);
14625 }
14626
14627 local_free (performance_state);
14628 }
14629 }
14630
14631 hc_thread_mutex_unlock (mux_adl);
14632 }
14633 #endif // HAVE_HWMON && HAVE_ADL
14634 }
14635
14636 data.kernel_power_all = kernel_power_all;
14637
14638 if (data.quiet == 0) log_info ("");
14639
14640 /**
14641 * Inform user which algorithm is checked and at which workload setting
14642 */
14643
14644 if (benchmark == 1)
14645 {
14646 quiet = 0;
14647
14648 data.quiet = quiet;
14649
14650 char *hash_type = strhashtype (data.hash_mode); // not a bug
14651
14652 log_info ("Hashtype: %s", hash_type);
14653 log_info ("");
14654 }
14655
14656 /**
14657 * keep track of the progress
14658 */
14659
14660 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14661 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14662 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14663
14664 /**
14665 * open filehandles
14666 */
14667
14668 #if _WIN
14669 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14670 {
14671 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14672
14673 return (-1);
14674 }
14675
14676 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14677 {
14678 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14679
14680 return (-1);
14681 }
14682
14683 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14684 {
14685 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14686
14687 return (-1);
14688 }
14689 #endif
14690
14691 /**
14692 * dictionary pad
14693 */
14694
14695 segment_size *= (1024 * 1024);
14696
14697 data.segment_size = segment_size;
14698
14699 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14700
14701 wl_data->buf = (char *) mymalloc (segment_size);
14702 wl_data->avail = segment_size;
14703 wl_data->incr = segment_size;
14704 wl_data->cnt = 0;
14705 wl_data->pos = 0;
14706
14707 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14708
14709 data.wordlist_mode = wordlist_mode;
14710
14711 cs_t *css_buf = NULL;
14712 uint css_cnt = 0;
14713 uint dictcnt = 0;
14714 uint maskcnt = 1;
14715 char **masks = NULL;
14716 char **dictfiles = NULL;
14717
14718 uint mask_from_file = 0;
14719
14720 if (attack_mode == ATTACK_MODE_STRAIGHT)
14721 {
14722 if (wordlist_mode == WL_MODE_FILE)
14723 {
14724 int wls_left = myargc - (optind + 1);
14725
14726 for (int i = 0; i < wls_left; i++)
14727 {
14728 char *l0_filename = myargv[optind + 1 + i];
14729
14730 struct stat l0_stat;
14731
14732 if (stat (l0_filename, &l0_stat) == -1)
14733 {
14734 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14735
14736 return (-1);
14737 }
14738
14739 uint is_dir = S_ISDIR (l0_stat.st_mode);
14740
14741 if (is_dir == 0)
14742 {
14743 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14744
14745 dictcnt++;
14746
14747 dictfiles[dictcnt - 1] = l0_filename;
14748 }
14749 else
14750 {
14751 // do not allow --keyspace w/ a directory
14752
14753 if (keyspace == 1)
14754 {
14755 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14756
14757 return (-1);
14758 }
14759
14760 char **dictionary_files = NULL;
14761
14762 dictionary_files = scan_directory (l0_filename);
14763
14764 if (dictionary_files != NULL)
14765 {
14766 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14767
14768 for (int d = 0; dictionary_files[d] != NULL; d++)
14769 {
14770 char *l1_filename = dictionary_files[d];
14771
14772 struct stat l1_stat;
14773
14774 if (stat (l1_filename, &l1_stat) == -1)
14775 {
14776 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14777
14778 return (-1);
14779 }
14780
14781 if (S_ISREG (l1_stat.st_mode))
14782 {
14783 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14784
14785 dictcnt++;
14786
14787 dictfiles[dictcnt - 1] = strdup (l1_filename);
14788 }
14789 }
14790 }
14791
14792 local_free (dictionary_files);
14793 }
14794 }
14795
14796 if (dictcnt < 1)
14797 {
14798 log_error ("ERROR: No usable dictionary file found.");
14799
14800 return (-1);
14801 }
14802 }
14803 else if (wordlist_mode == WL_MODE_STDIN)
14804 {
14805 dictcnt = 1;
14806 }
14807 }
14808 else if (attack_mode == ATTACK_MODE_COMBI)
14809 {
14810 // display
14811
14812 char *dictfile1 = myargv[optind + 1 + 0];
14813 char *dictfile2 = myargv[optind + 1 + 1];
14814
14815 // find the bigger dictionary and use as base
14816
14817 FILE *fp1 = NULL;
14818 FILE *fp2 = NULL;
14819
14820 struct stat tmp_stat;
14821
14822 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14823 {
14824 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14825
14826 return (-1);
14827 }
14828
14829 if (stat (dictfile1, &tmp_stat) == -1)
14830 {
14831 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14832
14833 fclose (fp1);
14834
14835 return (-1);
14836 }
14837
14838 if (S_ISDIR (tmp_stat.st_mode))
14839 {
14840 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14841
14842 fclose (fp1);
14843
14844 return (-1);
14845 }
14846
14847 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14848 {
14849 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14850
14851 fclose (fp1);
14852
14853 return (-1);
14854 }
14855
14856 if (stat (dictfile2, &tmp_stat) == -1)
14857 {
14858 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14859
14860 fclose (fp1);
14861 fclose (fp2);
14862
14863 return (-1);
14864 }
14865
14866 if (S_ISDIR (tmp_stat.st_mode))
14867 {
14868 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14869
14870 fclose (fp1);
14871 fclose (fp2);
14872
14873 return (-1);
14874 }
14875
14876 data.combs_cnt = 1;
14877
14878 data.quiet = 1;
14879
14880 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14881
14882 data.quiet = quiet;
14883
14884 if (words1_cnt == 0)
14885 {
14886 log_error ("ERROR: %s: empty file", dictfile1);
14887
14888 fclose (fp1);
14889 fclose (fp2);
14890
14891 return (-1);
14892 }
14893
14894 data.combs_cnt = 1;
14895
14896 data.quiet = 1;
14897
14898 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14899
14900 data.quiet = quiet;
14901
14902 if (words2_cnt == 0)
14903 {
14904 log_error ("ERROR: %s: empty file", dictfile2);
14905
14906 fclose (fp1);
14907 fclose (fp2);
14908
14909 return (-1);
14910 }
14911
14912 fclose (fp1);
14913 fclose (fp2);
14914
14915 data.dictfile = dictfile1;
14916 data.dictfile2 = dictfile2;
14917
14918 if (words1_cnt >= words2_cnt)
14919 {
14920 data.combs_cnt = words2_cnt;
14921 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14922
14923 dictfiles = &data.dictfile;
14924
14925 dictcnt = 1;
14926 }
14927 else
14928 {
14929 data.combs_cnt = words1_cnt;
14930 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14931
14932 dictfiles = &data.dictfile2;
14933
14934 dictcnt = 1;
14935
14936 // we also have to switch wordlist related rules!
14937
14938 char *tmpc = data.rule_buf_l;
14939
14940 data.rule_buf_l = data.rule_buf_r;
14941 data.rule_buf_r = tmpc;
14942
14943 int tmpi = data.rule_len_l;
14944
14945 data.rule_len_l = data.rule_len_r;
14946 data.rule_len_r = tmpi;
14947 }
14948 }
14949 else if (attack_mode == ATTACK_MODE_BF)
14950 {
14951 char *mask = NULL;
14952
14953 maskcnt = 0;
14954
14955 if (benchmark == 0)
14956 {
14957 mask = myargv[optind + 1];
14958
14959 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14960
14961 if ((optind + 2) <= myargc)
14962 {
14963 struct stat file_stat;
14964
14965 if (stat (mask, &file_stat) == -1)
14966 {
14967 maskcnt = 1;
14968
14969 masks[maskcnt - 1] = mystrdup (mask);
14970 }
14971 else
14972 {
14973 int wls_left = myargc - (optind + 1);
14974
14975 uint masks_avail = INCR_MASKS;
14976
14977 for (int i = 0; i < wls_left; i++)
14978 {
14979 if (i != 0)
14980 {
14981 mask = myargv[optind + 1 + i];
14982
14983 if (stat (mask, &file_stat) == -1)
14984 {
14985 log_error ("ERROR: %s: %s", mask, strerror (errno));
14986
14987 return (-1);
14988 }
14989 }
14990
14991 uint is_file = S_ISREG (file_stat.st_mode);
14992
14993 if (is_file == 1)
14994 {
14995 FILE *mask_fp;
14996
14997 if ((mask_fp = fopen (mask, "r")) == NULL)
14998 {
14999 log_error ("ERROR: %s: %s", mask, strerror (errno));
15000
15001 return (-1);
15002 }
15003
15004 char line_buf[BUFSIZ] = { 0 };
15005
15006 while (!feof (mask_fp))
15007 {
15008 memset (line_buf, 0, BUFSIZ);
15009
15010 int line_len = fgetl (mask_fp, line_buf);
15011
15012 if (line_len == 0) continue;
15013
15014 if (line_buf[0] == '#') continue;
15015
15016 if (masks_avail == maskcnt)
15017 {
15018 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15019
15020 masks_avail += INCR_MASKS;
15021 }
15022
15023 masks[maskcnt] = mystrdup (line_buf);
15024
15025 maskcnt++;
15026 }
15027
15028 fclose (mask_fp);
15029 }
15030 else
15031 {
15032 log_error ("ERROR: %s: unsupported file-type", mask);
15033
15034 return (-1);
15035 }
15036 }
15037
15038 mask_from_file = 1;
15039 }
15040 }
15041 else
15042 {
15043 custom_charset_1 = (char *) "?l?d?u";
15044 custom_charset_2 = (char *) "?l?d";
15045 custom_charset_3 = (char *) "?l?d*!$@_";
15046
15047 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15048 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15049 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15050
15051 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15052
15053 wordlist_mode = WL_MODE_MASK;
15054
15055 data.wordlist_mode = wordlist_mode;
15056
15057 increment = 1;
15058
15059 maskcnt = 1;
15060 }
15061 }
15062 else
15063 {
15064 /**
15065 * generate full masks and charsets
15066 */
15067
15068 masks = (char **) mymalloc (sizeof (char *));
15069
15070 switch (hash_mode)
15071 {
15072 case 1731: pw_min = 5;
15073 pw_max = 5;
15074 mask = mystrdup ("?b?b?b?b?b");
15075 break;
15076 case 12500: pw_min = 5;
15077 pw_max = 5;
15078 mask = mystrdup ("?b?b?b?b?b");
15079 break;
15080 default: pw_min = 7;
15081 pw_max = 7;
15082 mask = mystrdup ("?b?b?b?b?b?b?b");
15083 break;
15084 }
15085
15086 maskcnt = 1;
15087
15088 masks[maskcnt - 1] = mystrdup (mask);
15089
15090 wordlist_mode = WL_MODE_MASK;
15091
15092 data.wordlist_mode = wordlist_mode;
15093
15094 increment = 1;
15095 }
15096
15097 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15098
15099 if (increment)
15100 {
15101 if (increment_min > pw_min) pw_min = increment_min;
15102
15103 if (increment_max < pw_max) pw_max = increment_max;
15104 }
15105 }
15106 else if (attack_mode == ATTACK_MODE_HYBRID1)
15107 {
15108 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15109
15110 // display
15111
15112 char *mask = myargv[myargc - 1];
15113
15114 maskcnt = 0;
15115
15116 masks = (char **) mymalloc (1 * sizeof (char *));
15117
15118 // mod
15119
15120 struct stat file_stat;
15121
15122 if (stat (mask, &file_stat) == -1)
15123 {
15124 maskcnt = 1;
15125
15126 masks[maskcnt - 1] = mystrdup (mask);
15127 }
15128 else
15129 {
15130 uint is_file = S_ISREG (file_stat.st_mode);
15131
15132 if (is_file == 1)
15133 {
15134 FILE *mask_fp;
15135
15136 if ((mask_fp = fopen (mask, "r")) == NULL)
15137 {
15138 log_error ("ERROR: %s: %s", mask, strerror (errno));
15139
15140 return (-1);
15141 }
15142
15143 char line_buf[BUFSIZ] = { 0 };
15144
15145 uint masks_avail = 1;
15146
15147 while (!feof (mask_fp))
15148 {
15149 memset (line_buf, 0, BUFSIZ);
15150
15151 int line_len = fgetl (mask_fp, line_buf);
15152
15153 if (line_len == 0) continue;
15154
15155 if (line_buf[0] == '#') continue;
15156
15157 if (masks_avail == maskcnt)
15158 {
15159 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15160
15161 masks_avail += INCR_MASKS;
15162 }
15163
15164 masks[maskcnt] = mystrdup (line_buf);
15165
15166 maskcnt++;
15167 }
15168
15169 fclose (mask_fp);
15170
15171 mask_from_file = 1;
15172 }
15173 else
15174 {
15175 maskcnt = 1;
15176
15177 masks[maskcnt - 1] = mystrdup (mask);
15178 }
15179 }
15180
15181 // base
15182
15183 int wls_left = myargc - (optind + 2);
15184
15185 for (int i = 0; i < wls_left; i++)
15186 {
15187 char *filename = myargv[optind + 1 + i];
15188
15189 struct stat file_stat;
15190
15191 if (stat (filename, &file_stat) == -1)
15192 {
15193 log_error ("ERROR: %s: %s", filename, strerror (errno));
15194
15195 return (-1);
15196 }
15197
15198 uint is_dir = S_ISDIR (file_stat.st_mode);
15199
15200 if (is_dir == 0)
15201 {
15202 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15203
15204 dictcnt++;
15205
15206 dictfiles[dictcnt - 1] = filename;
15207 }
15208 else
15209 {
15210 // do not allow --keyspace w/ a directory
15211
15212 if (keyspace == 1)
15213 {
15214 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15215
15216 return (-1);
15217 }
15218
15219 char **dictionary_files = NULL;
15220
15221 dictionary_files = scan_directory (filename);
15222
15223 if (dictionary_files != NULL)
15224 {
15225 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15226
15227 for (int d = 0; dictionary_files[d] != NULL; d++)
15228 {
15229 char *l1_filename = dictionary_files[d];
15230
15231 struct stat l1_stat;
15232
15233 if (stat (l1_filename, &l1_stat) == -1)
15234 {
15235 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15236
15237 return (-1);
15238 }
15239
15240 if (S_ISREG (l1_stat.st_mode))
15241 {
15242 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15243
15244 dictcnt++;
15245
15246 dictfiles[dictcnt - 1] = strdup (l1_filename);
15247 }
15248 }
15249 }
15250
15251 local_free (dictionary_files);
15252 }
15253 }
15254
15255 if (dictcnt < 1)
15256 {
15257 log_error ("ERROR: No usable dictionary file found.");
15258
15259 return (-1);
15260 }
15261
15262 if (increment)
15263 {
15264 maskcnt = 0;
15265
15266 uint mask_min = increment_min; // we can't reject smaller masks here
15267 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15268
15269 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15270 {
15271 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15272
15273 if (cur_mask == NULL) break;
15274
15275 masks[maskcnt] = cur_mask;
15276
15277 maskcnt++;
15278
15279 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15280 }
15281 }
15282 }
15283 else if (attack_mode == ATTACK_MODE_HYBRID2)
15284 {
15285 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15286
15287 // display
15288
15289 char *mask = myargv[optind + 1 + 0];
15290
15291 maskcnt = 0;
15292
15293 masks = (char **) mymalloc (1 * sizeof (char *));
15294
15295 // mod
15296
15297 struct stat file_stat;
15298
15299 if (stat (mask, &file_stat) == -1)
15300 {
15301 maskcnt = 1;
15302
15303 masks[maskcnt - 1] = mystrdup (mask);
15304 }
15305 else
15306 {
15307 uint is_file = S_ISREG (file_stat.st_mode);
15308
15309 if (is_file == 1)
15310 {
15311 FILE *mask_fp;
15312
15313 if ((mask_fp = fopen (mask, "r")) == NULL)
15314 {
15315 log_error ("ERROR: %s: %s", mask, strerror (errno));
15316
15317 return (-1);
15318 }
15319
15320 char line_buf[BUFSIZ] = { 0 };
15321
15322 uint masks_avail = 1;
15323
15324 while (!feof (mask_fp))
15325 {
15326 memset (line_buf, 0, BUFSIZ);
15327
15328 int line_len = fgetl (mask_fp, line_buf);
15329
15330 if (line_len == 0) continue;
15331
15332 if (line_buf[0] == '#') continue;
15333
15334 if (masks_avail == maskcnt)
15335 {
15336 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15337
15338 masks_avail += INCR_MASKS;
15339 }
15340
15341 masks[maskcnt] = mystrdup (line_buf);
15342
15343 maskcnt++;
15344 }
15345
15346 fclose (mask_fp);
15347
15348 mask_from_file = 1;
15349 }
15350 else
15351 {
15352 maskcnt = 1;
15353
15354 masks[maskcnt - 1] = mystrdup (mask);
15355 }
15356 }
15357
15358 // base
15359
15360 int wls_left = myargc - (optind + 2);
15361
15362 for (int i = 0; i < wls_left; i++)
15363 {
15364 char *filename = myargv[optind + 2 + i];
15365
15366 struct stat file_stat;
15367
15368 if (stat (filename, &file_stat) == -1)
15369 {
15370 log_error ("ERROR: %s: %s", filename, strerror (errno));
15371
15372 return (-1);
15373 }
15374
15375 uint is_dir = S_ISDIR (file_stat.st_mode);
15376
15377 if (is_dir == 0)
15378 {
15379 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15380
15381 dictcnt++;
15382
15383 dictfiles[dictcnt - 1] = filename;
15384 }
15385 else
15386 {
15387 // do not allow --keyspace w/ a directory
15388
15389 if (keyspace == 1)
15390 {
15391 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15392
15393 return (-1);
15394 }
15395
15396 char **dictionary_files = NULL;
15397
15398 dictionary_files = scan_directory (filename);
15399
15400 if (dictionary_files != NULL)
15401 {
15402 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15403
15404 for (int d = 0; dictionary_files[d] != NULL; d++)
15405 {
15406 char *l1_filename = dictionary_files[d];
15407
15408 struct stat l1_stat;
15409
15410 if (stat (l1_filename, &l1_stat) == -1)
15411 {
15412 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15413
15414 return (-1);
15415 }
15416
15417 if (S_ISREG (l1_stat.st_mode))
15418 {
15419 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15420
15421 dictcnt++;
15422
15423 dictfiles[dictcnt - 1] = strdup (l1_filename);
15424 }
15425 }
15426 }
15427
15428 local_free (dictionary_files);
15429 }
15430 }
15431
15432 if (dictcnt < 1)
15433 {
15434 log_error ("ERROR: No usable dictionary file found.");
15435
15436 return (-1);
15437 }
15438
15439 if (increment)
15440 {
15441 maskcnt = 0;
15442
15443 uint mask_min = increment_min; // we can't reject smaller masks here
15444 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15445
15446 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15447 {
15448 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15449
15450 if (cur_mask == NULL) break;
15451
15452 masks[maskcnt] = cur_mask;
15453
15454 maskcnt++;
15455
15456 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15457 }
15458 }
15459 }
15460
15461 data.pw_min = pw_min;
15462 data.pw_max = pw_max;
15463
15464 /**
15465 * weak hash check
15466 */
15467
15468 if (weak_hash_threshold >= salts_cnt)
15469 {
15470 hc_device_param_t *device_param = NULL;
15471
15472 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15473 {
15474 device_param = &data.devices_param[device_id];
15475
15476 if (device_param->skipped) continue;
15477
15478 break;
15479 }
15480
15481 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15482
15483 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15484 {
15485 weak_hash_check (device_param, salt_pos);
15486 }
15487 }
15488
15489 // Display hack, guarantee that there is at least one \r before real start
15490
15491 if (data.quiet == 0) log_info_nn ("");
15492
15493 /**
15494 * status and monitor threads
15495 */
15496
15497 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15498
15499 hc_thread_t i_thread = 0;
15500
15501 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15502 {
15503 hc_thread_create (i_thread, thread_keypress, &benchmark);
15504 }
15505
15506 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15507
15508 uint ni_threads_cnt = 0;
15509
15510 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15511
15512 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15513
15514 ni_threads_cnt++;
15515
15516 /**
15517 * Outfile remove
15518 */
15519
15520 if (keyspace == 0)
15521 {
15522 if (outfile_check_timer != 0)
15523 {
15524 if (data.outfile_check_directory != NULL)
15525 {
15526 if ((hash_mode != 5200) &&
15527 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15528 (hash_mode != 9000))
15529 {
15530 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15531
15532 ni_threads_cnt++;
15533 }
15534 else
15535 {
15536 outfile_check_timer = 0;
15537 }
15538 }
15539 else
15540 {
15541 outfile_check_timer = 0;
15542 }
15543 }
15544 }
15545
15546 /**
15547 * Inform the user if we got some hashes remove because of the pot file remove feature
15548 */
15549
15550 if (data.quiet == 0)
15551 {
15552 if (potfile_remove_cracks > 0)
15553 {
15554 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15555 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15556 }
15557 }
15558
15559 data.outfile_check_timer = outfile_check_timer;
15560
15561 /**
15562 * main loop
15563 */
15564
15565 char **induction_dictionaries = NULL;
15566
15567 int induction_dictionaries_cnt = 0;
15568
15569 hcstat_table_t *root_table_buf = NULL;
15570 hcstat_table_t *markov_table_buf = NULL;
15571
15572 uint initial_restore_done = 0;
15573
15574 data.maskcnt = maskcnt;
15575
15576 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15577 {
15578 if (data.devices_status == STATUS_CRACKED) break;
15579
15580 data.devices_status = STATUS_INIT;
15581
15582 if (maskpos > rd->maskpos)
15583 {
15584 rd->dictpos = 0;
15585 }
15586
15587 rd->maskpos = maskpos;
15588 data.maskpos = maskpos;
15589
15590 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15591 {
15592 char *mask = masks[maskpos];
15593
15594 if (mask_from_file == 1)
15595 {
15596 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15597
15598 char *str_ptr;
15599 uint str_pos;
15600
15601 uint mask_offset = 0;
15602
15603 uint separator_cnt;
15604
15605 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15606 {
15607 str_ptr = strstr (mask + mask_offset, ",");
15608
15609 if (str_ptr == NULL) break;
15610
15611 str_pos = str_ptr - mask;
15612
15613 // escaped separator, i.e. "\,"
15614
15615 if (str_pos > 0)
15616 {
15617 if (mask[str_pos - 1] == '\\')
15618 {
15619 separator_cnt --;
15620
15621 mask_offset = str_pos + 1;
15622
15623 continue;
15624 }
15625 }
15626
15627 // reset the offset
15628
15629 mask_offset = 0;
15630
15631 mask[str_pos] = '\0';
15632
15633 switch (separator_cnt)
15634 {
15635 case 0:
15636 mp_reset_usr (mp_usr, 0);
15637
15638 custom_charset_1 = mask;
15639 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15640 break;
15641
15642 case 1:
15643 mp_reset_usr (mp_usr, 1);
15644
15645 custom_charset_2 = mask;
15646 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15647 break;
15648
15649 case 2:
15650 mp_reset_usr (mp_usr, 2);
15651
15652 custom_charset_3 = mask;
15653 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15654 break;
15655
15656 case 3:
15657 mp_reset_usr (mp_usr, 3);
15658
15659 custom_charset_4 = mask;
15660 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15661 break;
15662 }
15663
15664 mask = mask + str_pos + 1;
15665 }
15666 }
15667
15668 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15669 {
15670 if (maskpos > 0)
15671 {
15672 local_free (css_buf);
15673 local_free (data.root_css_buf);
15674 local_free (data.markov_css_buf);
15675
15676 local_free (masks[maskpos - 1]);
15677 }
15678
15679 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15680
15681 data.mask = mask;
15682 data.css_cnt = css_cnt;
15683 data.css_buf = css_buf;
15684
15685 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15686
15687 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15688
15689 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15690 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15691
15692 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15693
15694 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15695
15696 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15697 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15698
15699 data.root_css_buf = root_css_buf;
15700 data.markov_css_buf = markov_css_buf;
15701
15702 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15703
15704 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15705
15706 local_free (root_table_buf);
15707 local_free (markov_table_buf);
15708
15709 // args
15710
15711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15712 {
15713 hc_device_param_t *device_param = &data.devices_param[device_id];
15714
15715 if (device_param->skipped) continue;
15716
15717 device_param->kernel_params_mp[0] = &device_param->d_combs;
15718 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15719 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15720
15721 device_param->kernel_params_mp_buf64[3] = 0;
15722 device_param->kernel_params_mp_buf32[4] = css_cnt;
15723 device_param->kernel_params_mp_buf32[5] = 0;
15724 device_param->kernel_params_mp_buf32[6] = 0;
15725 device_param->kernel_params_mp_buf32[7] = 0;
15726
15727 if (attack_mode == ATTACK_MODE_HYBRID1)
15728 {
15729 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15730 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15731 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15732 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15733 }
15734 else if (attack_mode == ATTACK_MODE_HYBRID2)
15735 {
15736 device_param->kernel_params_mp_buf32[5] = 0;
15737 device_param->kernel_params_mp_buf32[6] = 0;
15738 device_param->kernel_params_mp_buf32[7] = 0;
15739 }
15740
15741 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]);
15742 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]);
15743 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]);
15744
15745 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);
15746 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);
15747 }
15748 }
15749 else if (attack_mode == ATTACK_MODE_BF)
15750 {
15751 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15752
15753 if (increment)
15754 {
15755 for (uint i = 0; i < dictcnt; i++)
15756 {
15757 local_free (dictfiles[i]);
15758 }
15759
15760 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15761 {
15762 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15763
15764 if (l1_filename == NULL) break;
15765
15766 dictcnt++;
15767
15768 dictfiles[dictcnt - 1] = l1_filename;
15769 }
15770 }
15771 else
15772 {
15773 dictcnt++;
15774
15775 dictfiles[dictcnt - 1] = mask;
15776 }
15777
15778 if (dictcnt == 0)
15779 {
15780 log_error ("ERROR: Mask is too small");
15781
15782 return (-1);
15783 }
15784 }
15785 }
15786
15787 free (induction_dictionaries);
15788
15789 // induction_dictionaries_cnt = 0; // implied
15790
15791 if (attack_mode != ATTACK_MODE_BF)
15792 {
15793 if (keyspace == 0)
15794 {
15795 induction_dictionaries = scan_directory (induction_directory);
15796
15797 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15798 }
15799 }
15800
15801 if (induction_dictionaries_cnt)
15802 {
15803 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15804 }
15805
15806 /**
15807 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15808 */
15809 if (keyspace == 1)
15810 {
15811 if ((maskcnt > 1) || (dictcnt > 1))
15812 {
15813 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15814
15815 return (-1);
15816 }
15817 }
15818
15819 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15820 {
15821 char *subid = logfile_generate_subid ();
15822
15823 data.subid = subid;
15824
15825 logfile_sub_msg ("START");
15826
15827 data.devices_status = STATUS_INIT;
15828
15829 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15830 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15831 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15832
15833 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15834
15835 data.cpt_pos = 0;
15836
15837 data.cpt_start = time (NULL);
15838
15839 data.cpt_total = 0;
15840
15841 if (data.restore == 0)
15842 {
15843 rd->words_cur = skip;
15844
15845 skip = 0;
15846
15847 data.skip = 0;
15848 }
15849
15850 data.ms_paused = 0;
15851
15852 data.words_cur = rd->words_cur;
15853
15854 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15855 {
15856 hc_device_param_t *device_param = &data.devices_param[device_id];
15857
15858 if (device_param->skipped) continue;
15859
15860 device_param->speed_pos = 0;
15861
15862 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15863 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15864 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15865
15866 device_param->exec_pos = 0;
15867
15868 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15869
15870 device_param->kernel_power = device_param->kernel_power_user;
15871
15872 device_param->outerloop_pos = 0;
15873 device_param->outerloop_left = 0;
15874 device_param->innerloop_pos = 0;
15875 device_param->innerloop_left = 0;
15876
15877 // some more resets:
15878
15879 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15880
15881 device_param->pws_cnt = 0;
15882
15883 device_param->words_off = 0;
15884 device_param->words_done = 0;
15885 }
15886
15887 data.kernel_power_div = 0;
15888
15889 // figure out some workload
15890
15891 if (attack_mode == ATTACK_MODE_STRAIGHT)
15892 {
15893 if (data.wordlist_mode == WL_MODE_FILE)
15894 {
15895 char *dictfile = NULL;
15896
15897 if (induction_dictionaries_cnt)
15898 {
15899 dictfile = induction_dictionaries[0];
15900 }
15901 else
15902 {
15903 dictfile = dictfiles[dictpos];
15904 }
15905
15906 data.dictfile = dictfile;
15907
15908 logfile_sub_string (dictfile);
15909
15910 for (uint i = 0; i < rp_files_cnt; i++)
15911 {
15912 logfile_sub_var_string ("rulefile", rp_files[i]);
15913 }
15914
15915 FILE *fd2 = fopen (dictfile, "rb");
15916
15917 if (fd2 == NULL)
15918 {
15919 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15920
15921 return (-1);
15922 }
15923
15924 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15925
15926 fclose (fd2);
15927
15928 if (data.words_cnt == 0)
15929 {
15930 if (data.devices_status == STATUS_CRACKED) break;
15931 if (data.devices_status == STATUS_ABORTED) break;
15932
15933 dictpos++;
15934
15935 continue;
15936 }
15937 }
15938 }
15939 else if (attack_mode == ATTACK_MODE_COMBI)
15940 {
15941 char *dictfile = data.dictfile;
15942 char *dictfile2 = data.dictfile2;
15943
15944 logfile_sub_string (dictfile);
15945 logfile_sub_string (dictfile2);
15946
15947 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15948 {
15949 FILE *fd2 = fopen (dictfile, "rb");
15950
15951 if (fd2 == NULL)
15952 {
15953 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15954
15955 return (-1);
15956 }
15957
15958 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15959
15960 fclose (fd2);
15961 }
15962 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15963 {
15964 FILE *fd2 = fopen (dictfile2, "rb");
15965
15966 if (fd2 == NULL)
15967 {
15968 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15969
15970 return (-1);
15971 }
15972
15973 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15974
15975 fclose (fd2);
15976 }
15977
15978 if (data.words_cnt == 0)
15979 {
15980 if (data.devices_status == STATUS_CRACKED) break;
15981 if (data.devices_status == STATUS_ABORTED) break;
15982
15983 dictpos++;
15984
15985 continue;
15986 }
15987 }
15988 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15989 {
15990 char *dictfile = NULL;
15991
15992 if (induction_dictionaries_cnt)
15993 {
15994 dictfile = induction_dictionaries[0];
15995 }
15996 else
15997 {
15998 dictfile = dictfiles[dictpos];
15999 }
16000
16001 data.dictfile = dictfile;
16002
16003 char *mask = data.mask;
16004
16005 logfile_sub_string (dictfile);
16006 logfile_sub_string (mask);
16007
16008 FILE *fd2 = fopen (dictfile, "rb");
16009
16010 if (fd2 == NULL)
16011 {
16012 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16013
16014 return (-1);
16015 }
16016
16017 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16018
16019 fclose (fd2);
16020
16021 if (data.words_cnt == 0)
16022 {
16023 if (data.devices_status == STATUS_CRACKED) break;
16024 if (data.devices_status == STATUS_ABORTED) break;
16025
16026 dictpos++;
16027
16028 continue;
16029 }
16030 }
16031 else if (attack_mode == ATTACK_MODE_BF)
16032 {
16033 local_free (css_buf);
16034 local_free (data.root_css_buf);
16035 local_free (data.markov_css_buf);
16036
16037 char *mask = dictfiles[dictpos];
16038
16039 logfile_sub_string (mask);
16040
16041 // base
16042
16043 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16044
16045 if (opts_type & OPTS_TYPE_PT_UNICODE)
16046 {
16047 uint css_cnt_unicode = css_cnt * 2;
16048
16049 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16050
16051 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16052 {
16053 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16054
16055 css_buf_unicode[j + 1].cs_buf[0] = 0;
16056 css_buf_unicode[j + 1].cs_len = 1;
16057 }
16058
16059 free (css_buf);
16060
16061 css_buf = css_buf_unicode;
16062 css_cnt = css_cnt_unicode;
16063 }
16064
16065 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16066
16067 uint mask_min = pw_min;
16068 uint mask_max = pw_max;
16069
16070 if (opts_type & OPTS_TYPE_PT_UNICODE)
16071 {
16072 mask_min *= 2;
16073 mask_max *= 2;
16074 }
16075
16076 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16077 {
16078 if (css_cnt < mask_min)
16079 {
16080 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16081 }
16082
16083 if (css_cnt > mask_max)
16084 {
16085 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16086 }
16087
16088 // skip to next mask
16089
16090 dictpos++;
16091
16092 rd->dictpos = dictpos;
16093
16094 logfile_sub_msg ("STOP");
16095
16096 continue;
16097 }
16098
16099 uint save_css_cnt = css_cnt;
16100
16101 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16102 {
16103 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16104 {
16105 uint salt_len = (uint) data.salts_buf[0].salt_len;
16106 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16107
16108 uint css_cnt_salt = css_cnt + salt_len;
16109
16110 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16111
16112 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16113
16114 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16115 {
16116 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16117 css_buf_salt[j].cs_len = 1;
16118 }
16119
16120 free (css_buf);
16121
16122 css_buf = css_buf_salt;
16123 css_cnt = css_cnt_salt;
16124 }
16125 }
16126
16127 data.mask = mask;
16128 data.css_cnt = css_cnt;
16129 data.css_buf = css_buf;
16130
16131 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16132
16133 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16134
16135 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16136
16137 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16138 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16139
16140 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16141
16142 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16143
16144 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16145 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16146
16147 data.root_css_buf = root_css_buf;
16148 data.markov_css_buf = markov_css_buf;
16149
16150 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16151
16152 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16153
16154 local_free (root_table_buf);
16155 local_free (markov_table_buf);
16156
16157 // copy + args
16158
16159 uint css_cnt_l = css_cnt;
16160 uint css_cnt_r;
16161
16162 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16163 {
16164 if (save_css_cnt < 6)
16165 {
16166 css_cnt_r = 1;
16167 }
16168 else if (save_css_cnt == 6)
16169 {
16170 css_cnt_r = 2;
16171 }
16172 else
16173 {
16174 if (opts_type & OPTS_TYPE_PT_UNICODE)
16175 {
16176 if (save_css_cnt == 8 || save_css_cnt == 10)
16177 {
16178 css_cnt_r = 2;
16179 }
16180 else
16181 {
16182 css_cnt_r = 4;
16183 }
16184 }
16185 else
16186 {
16187 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16188 {
16189 css_cnt_r = 3;
16190 }
16191 else
16192 {
16193 css_cnt_r = 4;
16194 }
16195 }
16196 }
16197 }
16198 else
16199 {
16200 css_cnt_r = 1;
16201
16202 /* unfinished code?
16203 int sum = css_buf[css_cnt_r - 1].cs_len;
16204
16205 for (uint i = 1; i < 4 && i < css_cnt; i++)
16206 {
16207 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16208
16209 css_cnt_r++;
16210
16211 sum *= css_buf[css_cnt_r - 1].cs_len;
16212 }
16213 */
16214 }
16215
16216 css_cnt_l -= css_cnt_r;
16217
16218 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16219
16220 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16221 {
16222 hc_device_param_t *device_param = &data.devices_param[device_id];
16223
16224 if (device_param->skipped) continue;
16225
16226 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16227 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16228 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16229
16230 device_param->kernel_params_mp_l_buf64[3] = 0;
16231 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16232 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16233 device_param->kernel_params_mp_l_buf32[6] = 0;
16234 device_param->kernel_params_mp_l_buf32[7] = 0;
16235 device_param->kernel_params_mp_l_buf32[8] = 0;
16236
16237 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16238 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16239 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16240 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16241
16242 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16243 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16244 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16245
16246 device_param->kernel_params_mp_r_buf64[3] = 0;
16247 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16248 device_param->kernel_params_mp_r_buf32[5] = 0;
16249 device_param->kernel_params_mp_r_buf32[6] = 0;
16250 device_param->kernel_params_mp_r_buf32[7] = 0;
16251
16252 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]);
16253 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]);
16254 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]);
16255
16256 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]);
16257 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]);
16258 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]);
16259
16260 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);
16261 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);
16262 }
16263 }
16264
16265 u64 words_base = data.words_cnt;
16266
16267 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16268 {
16269 if (data.kernel_rules_cnt)
16270 {
16271 words_base /= data.kernel_rules_cnt;
16272 }
16273 }
16274 else if (data.attack_kern == ATTACK_KERN_COMBI)
16275 {
16276 if (data.combs_cnt)
16277 {
16278 words_base /= data.combs_cnt;
16279 }
16280 }
16281 else if (data.attack_kern == ATTACK_KERN_BF)
16282 {
16283 if (data.bfs_cnt)
16284 {
16285 words_base /= data.bfs_cnt;
16286 }
16287 }
16288
16289 data.words_base = words_base;
16290
16291 if (keyspace == 1)
16292 {
16293 log_info ("%llu", (unsigned long long int) words_base);
16294
16295 return (0);
16296 }
16297
16298 if (data.words_cur > data.words_base)
16299 {
16300 log_error ("ERROR: restore value greater keyspace");
16301
16302 return (-1);
16303 }
16304
16305 if (data.words_cur)
16306 {
16307 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16308 {
16309 for (uint i = 0; i < data.salts_cnt; i++)
16310 {
16311 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16312 }
16313 }
16314 else if (data.attack_kern == ATTACK_KERN_COMBI)
16315 {
16316 for (uint i = 0; i < data.salts_cnt; i++)
16317 {
16318 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16319 }
16320 }
16321 else if (data.attack_kern == ATTACK_KERN_BF)
16322 {
16323 for (uint i = 0; i < data.salts_cnt; i++)
16324 {
16325 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16326 }
16327 }
16328 }
16329
16330 /*
16331 * Inform user about possible slow speeds
16332 */
16333
16334 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16335 {
16336 if (data.words_base < kernel_power_all)
16337 {
16338 if (quiet == 0)
16339 {
16340 log_info ("");
16341 log_info ("ATTENTION!");
16342 log_info (" The wordlist or mask you are using is too small.");
16343 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16344 log_info (" The cracking speed will drop.");
16345 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16346 log_info ("");
16347 }
16348 }
16349 }
16350
16351 /*
16352 * Update loopback file
16353 */
16354
16355 if (loopback == 1)
16356 {
16357 time_t now;
16358
16359 time (&now);
16360
16361 uint random_num = get_random_num (0, 9999);
16362
16363 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16364
16365 data.loopback_file = loopback_file;
16366 }
16367
16368 /*
16369 * Update dictionary statistic
16370 */
16371
16372 if (keyspace == 0)
16373 {
16374 dictstat_fp = fopen (dictstat, "wb");
16375
16376 if (dictstat_fp)
16377 {
16378 lock_file (dictstat_fp);
16379
16380 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16381
16382 fclose (dictstat_fp);
16383 }
16384 }
16385
16386 data.devices_status = STATUS_RUNNING;
16387
16388 if (initial_restore_done == 0)
16389 {
16390 if (data.restore_disable == 0) cycle_restore ();
16391
16392 initial_restore_done = 1;
16393 }
16394
16395 hc_timer_set (&data.timer_running);
16396
16397 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16398 {
16399 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16400 {
16401 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16402 if (quiet == 0) fflush (stdout);
16403 }
16404 }
16405 else if (wordlist_mode == WL_MODE_STDIN)
16406 {
16407 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16408 if (data.quiet == 0) log_info ("");
16409 }
16410
16411 time_t runtime_start;
16412
16413 time (&runtime_start);
16414
16415 data.runtime_start = runtime_start;
16416
16417 /**
16418 * create cracker threads
16419 */
16420
16421 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16422
16423 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16424 {
16425 hc_device_param_t *device_param = &devices_param[device_id];
16426
16427 if (wordlist_mode == WL_MODE_STDIN)
16428 {
16429 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16430 }
16431 else
16432 {
16433 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16434 }
16435 }
16436
16437 // wait for crack threads to exit
16438
16439 hc_thread_wait (data.devices_cnt, c_threads);
16440
16441 local_free (c_threads);
16442
16443 data.restore = 0;
16444
16445 // finalize task
16446
16447 logfile_sub_var_uint ("status-after-work", data.devices_status);
16448
16449 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16450
16451 if (data.devices_status == STATUS_CRACKED) break;
16452 if (data.devices_status == STATUS_ABORTED) break;
16453
16454 if (data.devices_status == STATUS_BYPASS)
16455 {
16456 data.devices_status = STATUS_RUNNING;
16457 }
16458
16459 if (induction_dictionaries_cnt)
16460 {
16461 unlink (induction_dictionaries[0]);
16462 }
16463
16464 free (induction_dictionaries);
16465
16466 if (attack_mode != ATTACK_MODE_BF)
16467 {
16468 induction_dictionaries = scan_directory (induction_directory);
16469
16470 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16471 }
16472
16473 if (benchmark == 0)
16474 {
16475 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16476 {
16477 if (quiet == 0) clear_prompt ();
16478
16479 if (quiet == 0) log_info ("");
16480
16481 if (status == 1)
16482 {
16483 status_display ();
16484 }
16485 else
16486 {
16487 if (quiet == 0) status_display ();
16488 }
16489
16490 if (quiet == 0) log_info ("");
16491 }
16492 }
16493
16494 if (attack_mode == ATTACK_MODE_BF)
16495 {
16496 dictpos++;
16497
16498 rd->dictpos = dictpos;
16499 }
16500 else
16501 {
16502 if (induction_dictionaries_cnt)
16503 {
16504 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16505 }
16506 else
16507 {
16508 dictpos++;
16509
16510 rd->dictpos = dictpos;
16511 }
16512 }
16513
16514 time_t runtime_stop;
16515
16516 time (&runtime_stop);
16517
16518 data.runtime_stop = runtime_stop;
16519
16520 logfile_sub_uint (runtime_start);
16521 logfile_sub_uint (runtime_stop);
16522
16523 logfile_sub_msg ("STOP");
16524
16525 global_free (subid);
16526 }
16527
16528 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16529
16530 if (data.devices_status == STATUS_CRACKED) break;
16531 if (data.devices_status == STATUS_ABORTED) break;
16532 if (data.devices_status == STATUS_QUIT) break;
16533
16534 if (data.devices_status == STATUS_BYPASS)
16535 {
16536 data.devices_status = STATUS_RUNNING;
16537 }
16538 }
16539
16540 // 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
16541
16542 if (attack_mode == ATTACK_MODE_STRAIGHT)
16543 {
16544 if (data.wordlist_mode == WL_MODE_FILE)
16545 {
16546 if (data.dictfile == NULL)
16547 {
16548 if (dictfiles != NULL)
16549 {
16550 data.dictfile = dictfiles[0];
16551
16552 hc_timer_set (&data.timer_running);
16553 }
16554 }
16555 }
16556 }
16557 // NOTE: combi is okay because it is already set beforehand
16558 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16559 {
16560 if (data.dictfile == NULL)
16561 {
16562 if (dictfiles != NULL)
16563 {
16564 hc_timer_set (&data.timer_running);
16565
16566 data.dictfile = dictfiles[0];
16567 }
16568 }
16569 }
16570 else if (attack_mode == ATTACK_MODE_BF)
16571 {
16572 if (data.mask == NULL)
16573 {
16574 hc_timer_set (&data.timer_running);
16575
16576 data.mask = masks[0];
16577 }
16578 }
16579
16580 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16581 {
16582 data.devices_status = STATUS_EXHAUSTED;
16583 }
16584
16585 // if cracked / aborted remove last induction dictionary
16586
16587 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16588 {
16589 struct stat induct_stat;
16590
16591 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16592 {
16593 unlink (induction_dictionaries[file_pos]);
16594 }
16595 }
16596
16597 // wait for non-interactive threads
16598
16599 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16600 {
16601 hc_thread_wait (1, &ni_threads[thread_idx]);
16602 }
16603
16604 local_free (ni_threads);
16605
16606 // wait for interactive threads
16607
16608 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16609 {
16610 hc_thread_wait (1, &i_thread);
16611 }
16612
16613 // we dont need restore file anymore
16614 if (data.restore_disable == 0)
16615 {
16616 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16617 {
16618 unlink (eff_restore_file);
16619 unlink (new_restore_file);
16620 }
16621 else
16622 {
16623 cycle_restore ();
16624 }
16625 }
16626
16627 // finally save left hashes
16628
16629 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16630 {
16631 save_hash ();
16632 }
16633
16634 /**
16635 * Clean up
16636 */
16637
16638 if (benchmark == 1)
16639 {
16640 status_benchmark ();
16641
16642 log_info ("");
16643 }
16644 else
16645 {
16646 if (quiet == 0) clear_prompt ();
16647
16648 if (quiet == 0) log_info ("");
16649
16650 if (status == 1)
16651 {
16652 status_display ();
16653 }
16654 else
16655 {
16656 if (quiet == 0) status_display ();
16657 }
16658
16659 if (quiet == 0) log_info ("");
16660 }
16661
16662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16663 {
16664 hc_device_param_t *device_param = &data.devices_param[device_id];
16665
16666 if (device_param->skipped) continue;
16667
16668 local_free (device_param->result);
16669
16670 local_free (device_param->combs_buf);
16671
16672 local_free (device_param->hooks_buf);
16673
16674 local_free (device_param->device_name);
16675
16676 local_free (device_param->device_name_chksum);
16677
16678 local_free (device_param->device_version);
16679
16680 local_free (device_param->driver_version);
16681
16682 if (device_param->pws_buf) myfree (device_param->pws_buf);
16683 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16684 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16685 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16686 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16687 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16688 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16689 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16690 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16691 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16692 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16693 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16694 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16695 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16696 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16697 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16698 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16699 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16700 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16701 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16702 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16703 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16704 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16705 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16706 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16707 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16708 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16709 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16710 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16711
16712 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16713 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16714 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16715 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16716 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16717 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16718 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16719 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16720 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16721 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16722
16723 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16724 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16725 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16726
16727 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16728 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16729 }
16730
16731 // reset default fan speed
16732
16733 #ifdef HAVE_HWMON
16734 if (gpu_temp_disable == 0)
16735 {
16736 #ifdef HAVE_ADL
16737 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16738 {
16739 hc_thread_mutex_lock (mux_adl);
16740
16741 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16742 {
16743 hc_device_param_t *device_param = &data.devices_param[device_id];
16744
16745 if (device_param->skipped) continue;
16746
16747 if (data.hm_device[device_id].fan_supported == 1)
16748 {
16749 int fanspeed = temp_retain_fanspeed_value[device_id];
16750
16751 if (fanspeed == -1) continue;
16752
16753 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16754
16755 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16756 }
16757 }
16758
16759 hc_thread_mutex_unlock (mux_adl);
16760 }
16761 #endif // HAVE_ADL
16762 }
16763
16764 #ifdef HAVE_ADL
16765 // reset power tuning
16766
16767 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16768 {
16769 hc_thread_mutex_lock (mux_adl);
16770
16771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16772 {
16773 hc_device_param_t *device_param = &data.devices_param[device_id];
16774
16775 if (device_param->skipped) continue;
16776
16777 if (data.hm_device[device_id].od_version == 6)
16778 {
16779 // check powertune capabilities first, if not available then skip device
16780
16781 int powertune_supported = 0;
16782
16783 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16784 {
16785 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16786
16787 return (-1);
16788 }
16789
16790 if (powertune_supported != 0)
16791 {
16792 // powercontrol settings
16793
16794 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)
16795 {
16796 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16797
16798 return (-1);
16799 }
16800
16801 // clocks
16802
16803 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16804
16805 performance_state->iNumberOfPerformanceLevels = 2;
16806
16807 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16808 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16809 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16810 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16811
16812 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)
16813 {
16814 log_info ("ERROR: Failed to restore ADL performance state");
16815
16816 return (-1);
16817 }
16818
16819 local_free (performance_state);
16820 }
16821 }
16822 }
16823
16824 hc_thread_mutex_unlock (mux_adl);
16825 }
16826 #endif // HAVE_ADL
16827
16828 if (gpu_temp_disable == 0)
16829 {
16830 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16831 if (data.hm_nv)
16832 {
16833 #if defined(LINUX) && defined(HAVE_NVML)
16834
16835 hm_NVML_nvmlShutdown (data.hm_nv);
16836
16837 nvml_close (data.hm_nv);
16838
16839 #elif defined(WIN) && (HAVE_NVAPI)
16840
16841 hm_NvAPI_Unload (data.hm_nv);
16842
16843 nvapi_close (data.hm_nv);
16844
16845 #endif
16846
16847 data.hm_nv = NULL;
16848 }
16849 #endif
16850
16851 #ifdef HAVE_ADL
16852 if (data.hm_amd)
16853 {
16854 hm_ADL_Main_Control_Destroy (data.hm_amd);
16855
16856 adl_close (data.hm_amd);
16857 data.hm_amd = NULL;
16858 }
16859 #endif
16860 }
16861 #endif // HAVE_HWMON
16862
16863 // free memory
16864
16865 local_free (masks);
16866
16867 local_free (dictstat_base);
16868
16869 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16870 {
16871 pot_t *pot_ptr = &pot[pot_pos];
16872
16873 hash_t *hash = &pot_ptr->hash;
16874
16875 local_free (hash->digest);
16876
16877 if (isSalted)
16878 {
16879 local_free (hash->salt);
16880 }
16881 }
16882
16883 local_free (pot);
16884
16885 local_free (all_kernel_rules_cnt);
16886 local_free (all_kernel_rules_buf);
16887
16888 local_free (wl_data->buf);
16889 local_free (wl_data);
16890
16891 local_free (bitmap_s1_a);
16892 local_free (bitmap_s1_b);
16893 local_free (bitmap_s1_c);
16894 local_free (bitmap_s1_d);
16895 local_free (bitmap_s2_a);
16896 local_free (bitmap_s2_b);
16897 local_free (bitmap_s2_c);
16898 local_free (bitmap_s2_d);
16899
16900 #ifdef HAVE_HWMON
16901 local_free (temp_retain_fanspeed_value);
16902 #ifdef HAVE_ADL
16903 local_free (od_clock_mem_status);
16904 local_free (od_power_control_status);
16905 #endif // ADL
16906 #endif
16907
16908 global_free (devices_param);
16909
16910 global_free (kernel_rules_buf);
16911
16912 global_free (root_css_buf);
16913 global_free (markov_css_buf);
16914
16915 global_free (digests_buf);
16916 global_free (digests_shown);
16917 global_free (digests_shown_tmp);
16918
16919 global_free (salts_buf);
16920 global_free (salts_shown);
16921
16922 global_free (esalts_buf);
16923
16924 global_free (words_progress_done);
16925 global_free (words_progress_rejected);
16926 global_free (words_progress_restored);
16927
16928 if (pot_fp) fclose (pot_fp);
16929
16930 if (data.devices_status == STATUS_QUIT) break;
16931 }
16932
16933 // destroy others mutex
16934
16935 hc_thread_mutex_delete (mux_dispatcher);
16936 hc_thread_mutex_delete (mux_counter);
16937 hc_thread_mutex_delete (mux_display);
16938 hc_thread_mutex_delete (mux_adl);
16939
16940 // free memory
16941
16942 local_free (eff_restore_file);
16943 local_free (new_restore_file);
16944
16945 local_free (rd);
16946
16947 // tuning db
16948
16949 tuning_db_destroy (tuning_db);
16950
16951 // loopback
16952
16953 local_free (loopback_file);
16954
16955 if (loopback == 1) unlink (loopback_file);
16956
16957 // induction directory
16958
16959 if (induction_dir == NULL)
16960 {
16961 if (attack_mode != ATTACK_MODE_BF)
16962 {
16963 if (rmdir (induction_directory) == -1)
16964 {
16965 if (errno == ENOENT)
16966 {
16967 // good, we can ignore
16968 }
16969 else if (errno == ENOTEMPTY)
16970 {
16971 // good, we can ignore
16972 }
16973 else
16974 {
16975 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16976
16977 return (-1);
16978 }
16979 }
16980
16981 local_free (induction_directory);
16982 }
16983 }
16984
16985 // outfile-check directory
16986
16987 if (outfile_check_dir == NULL)
16988 {
16989 if (rmdir (outfile_check_directory) == -1)
16990 {
16991 if (errno == ENOENT)
16992 {
16993 // good, we can ignore
16994 }
16995 else if (errno == ENOTEMPTY)
16996 {
16997 // good, we can ignore
16998 }
16999 else
17000 {
17001 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17002
17003 return (-1);
17004 }
17005 }
17006
17007 local_free (outfile_check_directory);
17008 }
17009
17010 time_t proc_stop;
17011
17012 time (&proc_stop);
17013
17014 logfile_top_uint (proc_start);
17015 logfile_top_uint (proc_stop);
17016
17017 logfile_top_msg ("STOP");
17018
17019 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17020 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17021
17022 if (data.ocl) ocl_close (data.ocl);
17023
17024 if (data.devices_status == STATUS_ABORTED) return 2;
17025 if (data.devices_status == STATUS_QUIT) return 2;
17026 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17027 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17028 if (data.devices_status == STATUS_CRACKED) return 0;
17029
17030 return -1;
17031 }
Hashcat additions to support pwdhash